On 2017-05-30 11:32, Ian Oliver wrote:

Ah, but I can use Super Ellipses and use splines to get dimensions,
locations and roundness/squareness parameters.

https://en.wikipedia.org/wiki/Superellipse

That should work.

On 2017-05-30 20:55, Eric Buijs wrote:

Many thanks. I'll play with that and see where it takes me.

Thanks, I'm very pleased with how the 3D model came out. I'm hoping
someone prints it and does a better finishing job than I did!

BTW I played with some linear sweeps of size and superellipse
roundness/squareness last night and got the attached out of some pretty
simple code. I should be able to use this to generate a vector
containing all of my body "slices", use a modified sweep function to
skin this as a polyhedron, but also then access the points data from
other code to generate spline control points for attaching tail/wings etc.

This one is going to be a long slog and I don't expect to have anything
close to printable for months!

On 2017-05-31 09:59, caterpillar wrote:

I've looked at that (in awe!) in the past but haven't yet had an excuse
to play with it. Now might be the time!

Great, thanks. I'm currently just after a "reading list" so I can work
through a few approaches and see what shows promise.

On 2017-05-31 09:59, caterpillar wrote:

I mentioned splines because my understanding (vague/wrong/whatever) is
that these pass through the control points as they have multiple
polynomial components, which is what I think I want for my smooth
interpolation. My plan is to take coordinates from blueprints with
calipers and then use splines (or whatever) to let me generate nice
curves to feed into my supersellipse sweeper thingy.

Gadgetmind wrote

Good plan. It will work. The general method is:

1. define a parametrized shape function like superellipse to generate an
   interpolable cross section
2. find the exact parameters and locations for a couple of "slices" and
   stuff them properly sequenced into a matrix - one row per slice. It is
   obviously important to choose "good" slices.
3. use nSpline() to interpolate the rows.
4. define a generator function that interpretes the cross section
   (superellipse) and the trajectory (e.g. Z axis) from the interpolated data
   and generates a sequence of polygons in 3D from it.
5. use sweep() from Naca_sweep.scad or skin() to extrude the full shape.
   skin() also lets you extrude along a series of shapes with an unequal number
   of points. This might be important for the caps.

reads more complicated than it is.

Here the sceleton as pseudo code:

--
View this message in context: http://forum.openscad.org/Advice-regards-curve-fitting-splines-tp21597p21611.html
Sent from the OpenSCAD mailing list archive at Nabble.com.

On 2017-05-31 12:23, Parkinbot wrote:

Here is what I have now as a proof of concept.

Rot45 = sin(45);
// Generate one slice of the body
function SESlice (SE=1, xs=1, ys=1) = [
for (t=[0: $fa : 359])
let (
x = pow(abs(cos(t)), 2/SE) * sign(cos(t)) ,
y = pow(abs(sin(t)), 2/SE) * sign(sin(t))
)
// Rotate 45 degrees so scaling works properly and then scale
[ xs * (x * Rot45 - y * Rot45), ys * (y * Rot45 + x * Rot45)]
];

BodySE=1.4;    // 1.4 is in the right ball park for centre
Steps = 100;

 skin([
     for (s=[0 : Steps-1])
         let (
             sf = s/(Steps-1),
             // Linear for now, needs a spline/lookup.
             SE = BodySE + sf*(2-BodySE),
             xs = 15 + sf*(1-15),
             ys = 19 + sf*(1-19)
         )
         transform(translation([0,0,s]) * rotation([0,0,s*2]), 

SESlice (SE=SE, xs=xs, ys=ys))
]);

Output attached and shows scaling working well and superellipse going
from slightly rounded rectangle to circle. That's a lot of flexibility
from some pretty simple code, but I'm glad I didn't have to write skin()
or the transform library!

I'm not sure I need the unequal number of points logic and currently
have it ripped out of my "cut and paste" version of skin (). Let's see.

On 2017-05-31 12:58, Ian Oliver wrote:

Note that I think you were describing using superellipse to generate
some slices and then splines to interpolate (I think). I'm instead
looking to use splines to interpolate the various parameters that are
then used to generate a whole load of slices. I'll probably only need a
handful of spline control points for the whole body.

And then comes fun with wings etc., which I don't have much idea about
currently, but one problem at a time.