Rotate plane by degrees about an axis

mark_stouffer

I am trying to create a series of similar bodies in different different orientations. They are like fingers on a hand.

I am able to create each finger currently, but am having some difficulty orienting them. I pass in a plane to the function that creates each finger, but then I have to rotate several features on each finger.

The passed-in plane parameter needs to be slightly rotated on the x axis. Then when I construct the finger I have to rotate several planes to construct the additional fingers. Right now I am rotating the additional fingers with respect to the original base plane. For the additional features I should be rotating the feature planes with respect to the x-rotated passed-in plane parameter.

I can use opTransform to rotate each finger after it's construction, but is seems to me like it would be more appropriate to construct the bodies on the appropriate plane first, to simplify further construction process.

Is there a method or function that accepts a plane, a degree * number, and a rotationAxis to move the plane or return a new rotated plane?

Thanks for any help or suggestions of a better way to perform such a construction.

mahir

You can create a rotated plane using existing plane vectors (x-axis & normal) as a base and then create rotated vectors by multiplying with a transform created with rotationAround().

mark_stouffer

I have the rotationAround transform already. What is the function that performs the transform? Is it one of the transform(), or opTransform()? I thought opTransform() only operated on bodies. 

mark_stouffer

I use: 

var pipRotation = rotationAround(axisLine, rotateDegrees * degree);

... and then it looks like I can parse some values out of pipRotation["linear"] but I thought there might already be a function for rotating a plane along an axis without having to parse the contents of a transform.

mahir

You don't have to parse anything. The output of rotationAround is a transformation matrix. This is just a 3x3 matrix that you multiply with a base point or vector to transform it (translate, rotate, or scale). In your case, 

newNormal = pipRotation*oldPlane.normal
newOrigin = pipRotation*oldPlane.origin
newX = pipRotation*oldPlane.x

https://cad.onshape.com/FsDoc/library.html#Transform

mark_stouffer

Wow, that is just about 100 times simpler than what I was trying to do. Thanks!

mark_stouffer

It looks like I have to use:

var dipNormal = pipRotation.linear * oldPlane.normal;

mahir

I would use the whole transform, not just the linear component. When you use rotationAround, it generates the required transform to rotate around a specific axis. This transform is really just a combination of a rotation about the origin and a translation. If you separate out the linear portion of the transform, the result will no longer be a rotation about the desired axis. It will probably be around a parallel axis that goes through the origin. 

ilya_baran

Mark is correct in that when transforming the plane normal, you want just the linear component.  However, there's an easier way: you can just multiply transforms and planes directly (operator * is overloaded for these in surfaceGeometry.fs).  So you can do:

var newPlane = pipRotation * oldPlane;

mahir

@ilya_baran, that's handy. I understand why the .linear component can be used for the normal and x, since they're just direction vectors centered on the origin, but would it yield an incorrect result to use the whole transform? Does applying a translation to a direction vector end up changing its direction?

Also, in the overloaded operator, the normal is transformed by inverse(tranpose(transform.linear)). What does using the inverse of the transpose do?

ilya_baran

Not using linear would not work because of a units mismatch I believe (this is why units are great IMO).  Without units, it would give the wrong result because the normal is a direction vector rather than a point (e.g., the easiest case to see is that if you translate a plane, you leave the normal be).

The inverse transpose is the correct way to transform a normal if your transform does not preserve right angles: when you apply a transform to a plane, you're actually transforming the basis vectors.  If you transform the normal the same way, the result may not be orthogonal to the transformed basis. A more mathematical explanation is here: https://computergraphics.stackexchange.com/questions/1502/why-is-the-transposed-inverse-of-the-model-view-matrix-used-to-transform-the-nor

mahir

Thanks for the math lesson:)

mark_stouffer

One of the things that threw me off for a while was that you must do Rotation * Plane. Whereas Plane * Rotation fails. This does not conform to the commutative property of the multiplication operator, which I think coders could reasonably expect. I don't think I've ever seen it disregarded before.

mahir

The issue is you're not really performing a multiplication. As a coder, you can appreciate overloading functions. The multiplication operator has been overloaded to perform what amounts to a matrix multiplication, which is not a commutative operation. 

mark_stouffer

I see. I guess adding a Plane * Rotation overload would be misleading.

Jake_Rosenfeld

Hi Mark,

To give a little more detail: Matrix multiplication is not commutative, and the origin and normal of the plane being transformed are column vectors.

If you were to want to apply a more complicated transformation to the plane than one rotation, you could do something like:
(transform1) * (transform2) * (plane)
Which is not the same transformation as:
(transform2) * (transform1) * (plane)

(^ as a note here in case you are interested, these multiplications are associative, just not commutative)

because of the way matrix multiplication operates
(plane) * (transform)
or more specifically
(origin) * (transform) and
(normal) * (transform)
are not valid matrix multiplications (the dimensions of the matrices don't line up)

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