[Feature Request][Rail Revolve] Add a "No Scaling" option to Rail Revolve

I’d like Rhino to add a “small” feature to the Rail Revolve command. Below, I explain why, what it is, and why (in theory) it should be rather easy to implement.

Why (Problem to Solve):

Currently, Rhino does not have an easy way to make tapered-threads in mechanical engineering. For example, in the oil-drilling industry, there are a series of tapered threads that join drill pipes.

Similarly, there might be architectural applications, where a spiral-ramp (of constant width) would be desirable.

Wait, can’t you make these shapes with Sweep1 or Sweep2 ?

Actually, no, with a caveat. Mathematically, it is impossible for Sweep1 and Sweep2 to generate a geometrically ideal tapered thread. To many, including myself, this was not immediately obvious, and requires either some vector calculus (TNB frames of curves in 3d), or unusually good geometric intuition.

As someone with degrees in physics, computer-science, and experience as a software-developer at Parametric Technology (PTC), I can demonstrate this at multiple levels, from a mathematical proof (undergraduate vector calculus), to some demonstration .3dm files in Rhino, to some informal intuition about why this is so.

An informal discussion with example files, can be found in this thread from earlier. I’m open to a mathematical discussion, if that would be useful. The link below is to a post in a much longer thread. The post contains a demonstration file (.3dm) in Rhino. Some of the other discussion in the same thread, may also be of interest, but is not well-organized into a coherent explanation.

I should clearly state that for slight to mild tapers, Sweep1 and Sweep2 can almost generate a correct surface. In tapered NPT pipe threads, the taper is only a few degrees, and the geometric deviation is so small as to be insignificant for any reasonable tolerance (ie: below 1 micron).

However, as the taper becomes severe, and as the helix narrows to a radius close to the thread-pitch, the error increases non-linearly. These severely tapered threads might occur in the oil-drilling industry, or might be overall-shapes desired in architecture.

This was problematic for me, because I wanted to create a Grasshopper script to generate tapered threads. At first, I used Sweep1 and Sweep2 to generate surfaces, but they would not Join together. And I didn’t understand why. After doing some math, I understood what was going on.

I did create a working Grasshopper script, but because I couldn’t use Sweep1 and Sweep2, it turned out to be way more complicated than I expected. (I ended up using Loft. About half of the Grasshopper script is setting up for a Loft. The other half is converting that surface into a solid.)

This is why I’m submitting this feature request.

How to modify RailRevolve to create tapered threads?

It was pointed out by David Cockey (Profile - davidcockey - McNeel Forum) that Rail Revolve almost does what we want for tapered threads.

However, Rail Revolve re-scales (stretches) the rail-shape. From the documentation:
“The profile curve, in addition to being revolved, stretches along the revolve axis using the revolve axis origin as the scale base point.”
Discussion and example file here:

All we need, for tapered threads, is for Rail Revolve to do no scaling at all (no stretching). A tapered helix can be created with Spiral, a thread cross-section (aligned to the helix axis) could then be used with Rail Revolve to create a tapered thread that is geometrically correct.

So I am proposing we add a feature to Rail Revolve. Perhaps it is a checkbox that says,“No scaling” or “No stretching” and would turn off (grey out) all of the scaling features, like ScaleHeight.

Hopefully this could easily be implemented by setting the scaling transformation to the identity matrix (along with some stuff to make the surface accurate within the file tolerances for lengths and angles).


I think tapered-threads are a very natural geometry in mechanical engineering, as well as architecture. So I would like Rhino to have a single command (or feature) that can create them easily and accurately. Unfortunately, Sweep1 and Sweep2 cannot generate mechanical tapered-threads that are mathematically correct. But I’m guessing this could easily be fixed by adding a feature to Rail Revolve.

Feel free to contact me, for any further discussion, if that would be helpful.

–Anthony K. Yan

This other post of mine (in the same very long thread) is a more extreme demonstration of the problem with using Sweep1-roadlike to make a (severely) tapered thread.

In this example file, the deviations are clearly too large to be issues with numerical stability/accuracy.