nop head nop.head@gmail.com wrote:

Yes, you are right, the global method can't work .

To avoid the singularity shouldn't you look at the next tangent and orient

The trouble with the local method may arise just at the beginning of the
path because there it is computed a minimum rotation from vector [0,0,1] to
the first path tangent. When the first unitary tangent is [0,0,-1], we have
a singularity and by taking the identity matrix as the rotation matrix
produces a wrong winding of the very first section. From there on, all
winding will be reverted. When we do a perturbation in one of the vectors
in rotate_from_to(), the cross product of a and the perturbed b is no
longer 0 and the singularity and all its consequences are avoided.

For the intermediate points of the path, the occurrence of two subsequent
tangents opposed to each other will surely generate a bad condition but
then the polyhedron will have a self-intersections which is even worst. So,
just the start point of the path demands concern. Instead of a perturbation
in the minimum rotation function we could just check if the first tangent
is [0,0,-1] and set an ad hoc solution: take the rotation
[[1,0,0],[0,-1,0],[0,0,-1]] instead of calling rotate_from_to(). That
alternative seems better.

Ronaldo wrote

How do you determine that the continued path will not demand
[[1,0,0],[0,1,0],[0,0,-1]]?

--
Sent from: http://forum.openscad.org/

Ha, I have been using [[-1, 0, 0], [0, 1, 0], [0, 0, -1]]. I have also
experimented with reversing the winding order of the profile and doing the
first rotation from [0, 0, -1]. That extrudes the profile downwards in the
same orientation as it does upwards, whereas the other methods flip it.

There are an infinite number of ways of spinning a cat it seems!

On Fri, 1 Feb 2019 at 14:04, Ronaldo Persiano rcmpersiano@gmail.com wrote:

Parkinbot rudolf@digitaldocument.de wrote:

Well, that is not a rotation but a reflection. But it is unimportant which
first rotation you use provided that it rotates [0,0,1] to [0,0,-1]. The
following rotations will be consistent with that first one.

In relative mode you never get the singularity after the start as that
would mean the path has doubled back on itself at a cusp.

On Fri, 1 Feb 2019 at 14:37, Parkinbot rudolf@digitaldocument.de wrote:

Since one can flip around x or around y I think it makes sense to look at
the second tangent to decide. I.e. perturb b by adding a little of c. Then
it flips the same way it would of the first normal was leaning slightly in
the direction of the second.

However all these methods cause a discontinuity of behaviour with changing
directions. For example the flips change around the 45 degree mark.

One way around that is to always orient the first frame like Frenet-Serret.
I.e. profile gets rotated around Z so the Y axis points towards the centre
of curvature of the start of the path. Then there are no discontinuities of
behaviour.

On Fri, 1 Feb 2019 at 14:47, Ronaldo Persiano rcmpersiano@gmail.com wrote:

this is correct. But the path can go up or down the z-axis ...

Ronaldo wrote

--
Sent from: http://forum.openscad.org/

For up direction, the standard rotation of rotate_from_to() is the identity
what gives the right behavior.

nop head nop.head@gmail.com wrote:

Yes, I just changed accumulate_rotations() in my code to:

function accumulate_rotations(rots) =
[for( i = 0, R = rots[0];
i <= len(rots);
i=i+1, R = rots[i]*R)
R ];

and minimizing_rotations() to:

function minimizing_rotations(tangents) =
// avoid singularity at the first rotation of the sequence
[ let( axis = unit(cross([0,0,1],tangents[1])) )
axis*axis >= 0.99 || tangents[1][2]>=0 ?
rotate_from_to([0,0,1],tangents[1]) :
[[1,0,0],[0,-1,0],[0,0,-1]],
for (i = [1:len(tangents)-2])
rotate_from_to(tangents[i],tangents[i+1])
];

I think I am in position now to update my code in github with the
conclusions of this discussion.