*This is the second in an occasional series about 3D models and prints that
I design. The code for this post, and some 3D models, are available in
the associated github repo. The
code for this post was largely inspired by the bending procedures
posted to Thingiverse by the user flavius*

In the previous post, I described how to use the `children`

module in OpenSCAD
to repeat models in regular patterns–specifically, to make cylindrical tiled
vase sculptures. This post will explore what I call *distortion fields*–modules
that apply non-homogenous transformations to their children. A word of
warning: these techniques are extremely computationally expensive if you want
good results in many common cases. They also tend to require some massaging
to fit each specific case, so it’s worth understanding how they work. The good
news is that with a few helper functions, distortion fields are fairly simple
to implement, so it’s mostly a matter of coding for 10 minutes, pressing
“render,” and going to get a beer.

A good example of where a distortion field can be useful is in a model of an airplane wing (warning: I know nothing about actual aerodynamics). Wikipedia gives me a nice cross-section of an airfoil.

I’d like to take that cross-section and use `linear_extrude`

to stretch it out
into a wing.

```
linear_extrude(height = 203) import("../dxf/airfoil.dxf");
```

But that’s not right. Wings are wider at their base, where they connect to the fuselage, and narrower at their tip. They’re also usually more triangular, in top-down view, than rectangular. What I need to make this extruded airfoil into a wing is to apply a kind of “scale-gradient,” so that it gets smaller from one end to the other, and also a “translation-gradient” so that it sweeps back from the big end to the small end.

The `linear_extrude`

function *does* have a `scale`

parameter, which will
help a little bit in this case.

```
module scaled_extruded_airfoil() {
linear_extrude(height = 203, scale=[0.3, 0.3]) {
import("../dxf/airfoil.dxf");
}
}
scaled_extruded_airfoil();
```

This is good, but it doesn’t give you a way to control where the end of the extruded
shape “lands.” The leading edge of the wing is a straight line, based on some internal
representation of the origin of the 2D shape being extruded. I’d like the leading
edge of the wing to be swept back. Also, in many cases the model to be scaled will
be 3D, so this nice `linear_extrude`

scaling trick won’t be available. Or I might
want to scale an object in a way that is *not* linear along its length, and this
trick won’t be suitable.

One way to try to achieve a “scaled and swept-back” effect is with a clever use
of `hull`

to unite a big, thin airfoil cross-section with a smaller cross-section
translated one wing-length away. This is a good approach when it works, because
it is far cheaper, and the result far smoother, than using a distortion field, as we’ll
see. But `hull`

has its own price: it eliminates any concave details in the
model. Holes and indentations, like the scooped bottom of the airfoil, do not
survive.

```
module hull_wing() {
hull() {
linear_extrude(height = 0.5) {
scale([0.2, 0.2, 1]) import("../dxf/airfoil.dxf");
}
translate([-100, 0, 203]) {
linear_extrude(height = 0.5) import("../dxf/airfoil.dxf");
}
}
}
hull_wing();
```

As an introduction to how distortion fields work, let’s look at how OpenSCAD models cylinders. If I make a simple cylinder, the result will be a prism with very obvious facets, not a smoothly-curved one.

```
cylinder(10, d-5);
```

If I want a cylinder with a smooth surface, I can manually specify the
number of facets using the `$fn`

parameter.

```
cylinder(10, d-5, $fn=30);
```

The best number of facets is the lowest number that still looks like a curve in the eventual object. I’m usually making models for 3D printing, and I know that when each facet is small enough, the printer is just going to print a smooth curve. The central idea is that small-enough details blend together.

To apply that idea to the wing model, I can imagine applying successive
transformations to arbitrarily-small slices of the wing, so that the
final result would be a relatively-smooth approximation of the shape I wanted.
I *could* make thin wing slices with successive calls to `linear_extrude,`

but
for the sake of demonstration I’m going to pretend that I only have a 3D
model to work with, which is often the case in practice. I can take a short,
wide cylinder (really any shape that can surround the 2D wing shape) and
superimpose it on the wing.

```
module extruded_airfoil_cylinder_superimposed() {
linear_extrude(height = 203) import("../dxf/airfoil.dxf");
color("red") translate([100, 0, 0]) cylinder(1, d=300);
}
extruded_airfoil_cylinder_superimposed();
```

Now, if I take the intersection of these shapes, I should be left with a slice of the wing that has the same (thin) height as the red cylinder.

```
module intersection_airfoil_cylinder() {
intersection() {
linear_extrude(height = 203) import("../dxf/airfoil.dxf");
color("red") translate([100, 0, 0]) cylinder(1, d=300);
}
}
intersection_airfoil_cylinder();
```

There’s a special kind of tipping point I always look for in any technical
project. It’s the point where I’ve figured out, not *exactly* how to do
the thing I want, but enough to know that it *can* be done. Sometimes
the process of getting to that tipping point is called “driving out risk,”
with the idea that once you hit it, there are no more risks that have the
potential to fundamentally prevent what you want to do. After I know that
I have all the building blocks to realize my idea, my next step is to get
a working version, no matter mow ugly. Once I have a working version I can
refine it as necessary (but it’s surprising how often an initial version
works for all the cases that matter!).

At this point I have all the building blocks I need to make the wing.

- I can make a thin slice of an object if I know its approximate dimensions in X and Y.
- I can scale and translate a thin slice of an object.
- I can use the
`children`

module to refer to an object to be distorted.

In pseudocode, the algorithm I want to implement looks like:

```
// This isn't real code!
// start and end are [x, y, z] vectors for the translation.
module translate_field(diameter, height, steps, start, end) {
for (i=[0:steps - 1]) {
// take the intersection of the transformed object and
// a cylinder to cut out a thin slice
intersection() {
// apply the appropriate transformation to the object.
// note that the interpolate function doesn't
//exist in OpenSCAD, I need to write it myself
translate(interpolate(start, end, steps, step)) {
children(0);
}
// translate a thin cylinder to the correct height for this
// step on the original object
translate([0, 0, i * (height / steps)]) {
cylinder((height / steps), d=diameter);
}
}
}
}
```

Functions in OpenSCAD have a kind of odd syntax. I haven’t looked
into it in depth, but when I need to write one I often refer to
the documentation.
Suffice it to say that the `interpolate`

function can be implemented
this way:

```
function interp(start, end, steps, step) =
let (pct = step / steps)
[
start[0] + (pct * (end[0] - start[0])),
start[1] + (pct * (end[1] - start[1])),
start[2] + (pct * (end[2] - start[2])),
];
```

This is a good linear interpolation function, but I actually don’t want to permit translation in the Z-axis, so I can write a helper function that prevents it.

```
function xy_interp(start, end, steps, step) =
interp([start[0], start[1], 0], [end[0], end[1], 0], steps, step);
```

Now I should be able to use this function to complete the `translate_field`

function and use it to modify the scaled extruded airfoil.

```
// start and end are [x, y, z] vectors for the translation.
module translate_field(diameter, height, steps, start, end) {
for (i=[0:steps - 1]) {
// take the intersection of the transformed object and
// a cylinder to cut out a thin slice
intersection() {
// apply the appropriate transformation to the object.
// note that the interpolate function doesn't
//exist in OpenSCAD, I need to write it myself
translate(xy_interp(start, end, steps, i)) {
children(0);
}
// translate a thin cylinder to the correct height for this
// step on the original object
translate([0, 0, i * (height / steps)]) {
cylinder((height / steps), d=diameter);
}
}
}
}
module scaled_translated_wing(steps) {
translate_field(600, 203, steps, [0, 0, 0], [100, 0, 0]) {
scaled_extruded_airfoil();
}
}
translate([-200, 0, 0]) scaled_translated_wing(20);
scaled_translated_wing(50);
translate([200, 0, 0]) scaled_translated_wing(500);
```

As the figure shows, it’s possible to approximate a smooth distortion if I’m willing to pay a significant price in rendering time. As I said before, this can be an expensive technique, but its flexibility, and the fact that it can be applied to arbitary 3D shapes sometimes make it the best tool for the job.

Note that a big factor that affects rendering time is the number of parts that a model has. Each step consists of about three parts for rendering purposes:

- the whole wing, translated;
- the cylinder that intersects it
- the intersection of the wing and the cylinder

That means that for 500 steps, OpenSCAD is rendering 1500 objects. This is
why it’s often better to construct a custom distortion field procedure
rather than “stacking” a set of generic ones. For instance, if I wrote a
`scale_field`

module that did a linear scaling of an object the same
way the `translate_field`

does a translation, and I had an object that I
wanted to both scale and translate, I *could* use the following code

```
module scaled_translated_wing(steps) {
translate_field(600, 203, steps, [0, 0, 0], [100, 0, 0]) {
scale_field(600, 203, steps, [1, 1, 1], [0.4, 0.4, 1]) {
extruded_airfoil();
}
}
}
scaled_translated_wing(500);
```

But this would be a Bad Idea, because first the `scale_field`

would
take the wing and generate 1500 parts from it, and then the `translate_field`

would do the same, for a total of 3000 parts. In a moderately complicated
model, where an object like this wing might be repeated a few times, the
rendering time would quickly become infeasible. Instead, it would be better
to write a custom `scale_and_translate`

field that would apply both
transformations in a single pass.

Obviously, this technique is only a tool for situations where OpenSCAD doesn’t
have a better option built in. But in those situations it provides
unparallelled flexibility. It’s especially useful when you want to define
a custom interpolation function. With a quadratic interpolation you can achieve
a curved scaling or translation effect, which is often useful when you
want a seamless transition between individual pieces that are meant
to be screwed or glued together. It’s also nice to have the ability to
apply these kinds of effects *after* you have designed the individual
parts, so that the design of the part itself isn’t burdened with the
detail of how it attaches to the rest of the system.

All the code for this post is available in the associated github repo. If you liked it, I encourage you to download a copy of OpenSCAD and try it out for yourself.