Creating a spring between two points

[GenieTim]

I guess this is one of the questions I will regret asking some day, based on how easy it feels, and how this may not be the ideal place to post, but I spent so much time trying to get this working and still do not see an end in sight.

So please, I am trying to solve the following simple problem: I have two coordinates (vec3) where I want to span a spring (coilspring_tension) in between.

As the coilspring_tension does not have any placement arguments, it is clear that I should use the .transform() method on the Solid.
Placing the spring where I want it with the wrong rotation is straight-forward:

from madcad import *

s_from = vec3(1.2, 3.4, 1.9)
s_to = vec3(0.9, 7.6, 1.0)

s_len = distance(s_from, s_to)
spring = coilspring_tension(s_len, d=0.1)

t = transform(s_from + 0.5*(s_to - s_from))
spring = spring.transform(t)

However, I do not manage to get the rotation to be correct.
I tried the (probably) madcad way:

a = normalize(s_to - s_from)  # target orientation
base_orientation = spring.orientation
b = vec3(base_orientation[0], base_orientation[1], base_orientation[2])
R = rotatearound(anglebt(a, b), b, a)
spring = spring.transform(R)

I tried the naïve way:

spring.orientation[0] = a[0]
spring.orientation[1] = a[1]
spring.orientation[2] = a[2]

I tried the Unity way:

spring = spring.transform(spring.orientation * a)

I tried following various StackOverflow questions to compute the rotation matrix from one vector to another, but (admittedly also due to a lack of understanding, potentially) all of them fail.

May I ask for the actual, ideal way of how to span a spring between two points given their coordinates as vec3 here in pymadcad?
Thanks!

[jimy-byerley]

Hello these was few mistakes in your previous code samples, but of course such thing is easily doable in madcad ;)

best approach

The best way (most readable and efficient) in madcad is using a special constructor of quat:

quat(dir1, dir2)  # compute the quaternion rotating from direction 1 to direction 2

As the spring generated by for instance coilspring_tension is oriented toward Z, we need to rotate it toward b-a

orient = quat(Z, b-a)

As the spring is generated centered around zero, we need to translate it to the midpoint between a and b

pos = (b + a) / 2

Now, orient and pos cannot be combined together (quat and vec3), so we need to cast them to transformation matrices so we can use the matrix product to compute the transformation composition.

sprint.transform(
     translate((b + a) / 2)    # translate to midpoint with an homogeneous translation matrix
    * mat4(quat(Z, b - a))  )  # reorient from Z to b-a with a quaternion casted to an homogeneous matrix

what was wrong

• The first idea can work that way:

# this will compute an orientation matrix
orient = (  rotatearound(
                      anglebt(Z, b - a),  # angle between Z (current spring direction) and b-a (desired spring direction)
                      Axis(O,Y))  # this will rotate around axis (O,Y) because the spring center is currently in O
# now we have final spring orientation
# resposition the spring on the midpoint between a and b
pos = translate((b + a) / 2)

final = spring.transform(pos * orient)   # matrix product to compose transformations

• Your second attempt could not work: Solid.orientation is a quat (quaternion) and thus assigning 3 of its 4 components to a position vector will not give you the meant orientation.

• Your third coould not work either: spring.orientation is a quat and a a vec3 I guess, so your sample is transforming a spring by the their product which is a vector, transforming by a vector only get you a translation.