I'm deeply frustrated and intimitated by applying rotations

sasho648 · October 7, 2019, 6:51pm

How can I apply vector rotations around the three axis and how can I extract them later on.

Looking at the API and the matrix structure I feel hopeless - one wants a vector and degree (SUTransformationRotation) and the other a 3x3 matrix.

DanRathbun · October 7, 2019, 7:29pm

Do you have a desktop edition? If not install 2017 Make and get ThomThom’s transformation inspector tool from the Extension Warehouse. This will enable you to inspect your C API generated model’s within SketchUp. (Just backsave them as 2017 version.)

And if you’ll be using attribute dictionaries, I’d also recommend Aerilius’ Attribute Inspector extension.

sasho648 · October 7, 2019, 8:57pm

Confused. I’m asking how to apply axis based rotations to an instance.

DaveR · October 7, 2019, 9:02pm

In the free web-based version that your profile indicates you are using?

sasho648 · October 7, 2019, 9:40pm

You do realize this is the SDK section right?

It doesn’t matter what version of sketchup I have.

DaveR · October 7, 2019, 9:42pm

Yes I do realize this is the SDK section.

sasho648 · October 7, 2019, 9:44pm

Ok ignore everything else currently it is important extracting the rotation as floating point values per axis programmatically.

I think I’ve got the exportion part.

DanRathbun · October 7, 2019, 11:30pm

Don’t be. I am basically giving you advice on how to inspect the models you create with the C API.
The desktop editions can have extensions. The extension I told you about, will allow you to inspect the transformation matrices of the instances that you transform. Ie, it’s a self help avenue.

Firstly, again I remind you that SketchUp’s modeling axes are different from game engines.
Z is up, X is to the right (points toward east,) Y runs away from the viewer (and is north 0 degrees.)

A simple single rotation would be done by creating a rotational transform.
SUTransformationRotation

The point argument places the rotational axis vector somewhere in 3D space.
This does not have to be (but can be) within or even near the instance itself.
The vector argument is the axis of rotation.
The angle argument will be the angle to rotate about the axis defined by the vector argument.
- You can use the SUDegreesToRadians() function to specify values in degrees.

If you wish a compound rotation, then you’ll need to create 2 rotational transforms, and multiply them together, using the SUTransformationMultiply() function, and then apply the resultant transform to the instance.
You can also “mix in” translational and scaling transforms by multiplying them also.

But they are traditionally applied in a particular order. Translational first. Rotational second in (X, Y then Z order.) Then Scaling (X, Y then Z order.) Decomposing a transformation matrix must be done in reverse order. (See Aerilius’ code … link posted below.)

You could try this …

You get the transform of the instance.
from this you get the transform’s 3 axial vectors (X, Y and Z.) SUTransformationGetXAxis, etc.
You get the model’s global Axes object … SUModelGetAxes
from this you get the model’s 3 axial vectors (X, Y and Z.) SUAxesGetXAxis, etc.
You compare each of the 3 corresponding instance transformation axis with the model’s corresponding axis.
… ie X for X, Y for Y, etc. using SUVector3DAngleBetween
- You can use the SURadiansToDegrees() function to convert the values to degrees.

Note that the both (Ruby and C) API’s may have a limitation with the angle between method/function. I think it works using dot product for vectors which always returns a value between 0 and 180. (May not be a problem if the return value is signed.)

There are some ways to use trigonometry on the matrix values to get the axial rotations.
Aerilius posted code in Ruby here …

Get Component Rotation (x, y, z) - #4 by Aerilius

sasho648 · October 8, 2019, 5:30pm

I still don’t understand where the 3x3 rotation matrix is located inside the transformation matrix - can you specify which indices define it.

Is it 0 - 2, 4 - 6, 8 - 10

DanRathbun · October 8, 2019, 7:52pm

If you (again) install a desktop SketchUp and install ThomThom’s Transfromation Inspector (also requires his TT_Lib2 library,) … you’ll be able to visualize transformations, and play around with editing them parametrically.

https://extensions.sketchup.com/en/content/tt_lib²
https://extensions.sketchup.com/en/content/transformation-inspector

In the image below, the 3x3 matrix has a green background.

Well the Ruby API returns a nested array where each row is a subarray.
So it would be ary[0][0..2], ary[1][0..2] and ary[2][0..2]

But I think the C API just returns a flattened 16-element array (the equivalent of the Ruby API’s transformation.to_a method.)

So yes you’d use: ary[0..2], ary[4..6] and ary[8..10]

eneroth3 · October 8, 2019, 8:04pm

I’ve made a Ruby library that can help extracting Euler angles. Maybe it can be helpful for implementing something similar using the C API.

github.com

Eneroth3/sketchup-community-lib/blob/b290884947a066b2723d6542f6b049e539849350/modules/geom/transformation.rb#L112


      
          #   angles = SkippyLib::LGeom::LTransformation.euler_angles(transformation)
          #   angles.map(&:radians)
          #
          #   # Determine Angles of Selected Group/Component
          #   # Select a group or component and run:
          #   e = Sketchup.active_model.selection.first
          #   SkippyLib::LGeom::LTransformation.euler_angles(e.transformation).map(&:radians)
          #
          # @return [Array(Float, Float, Float)] X rotation, Y rotation and Z Rotation
          #   in radians.
          def self.euler_angles(transformation)
            a = remove_scaling(remove_shearing(transformation, false)).to_a
          
          
  x = Math.atan2(a[6], a[10])
            c2 = Math.sqrt(a[0]**2 + a[1]**2)
            y = Math.atan2(-a[2], c2)
            s = Math.sin(x)
            c1 = Math.cos(x)
            z = Math.atan2(s * a[8] - c1 * a[4], c1 * a[5] - s * a[9])
          
          
  [x, y, z]

I don’t know how experienced you are with transformation matrices but the angles aren’t directly written anywhere in there. Instead you can think of the matrix as the 3 axis vectors for a local coordinate system, as well as a translation (to get really technical the translation mathematically equals to a shearing in a 4th dimension). To extract angles you have to do some trigonometry.

sasho648 · October 8, 2019, 9:48pm

OK I used the formula from the wiki page to set translations but now objects are doubled in a weird way:

doubledoor

The above is supposed to be a single door. Here is my code:

	static struct SUTransformation matrixtransform, matrixrotationX, matrixrotationY, matrixrotationZ;

	SUTransformationTranslation(&matrixrotationX, (struct SUVector3D[]) { 0, 0, 0 });
	SUTransformationTranslation(&matrixrotationY, (struct SUVector3D[]) { 0, 0, 0 });
	SUTransformationTranslation(&matrixrotationZ, (struct SUVector3D[]) { 0, 0, 0 });

	0[matrixrotationZ.values] = cos(rotation.z),
	1[matrixrotationZ.values] = -sin(rotation.z),
	2[matrixrotationZ.values] = 0,

	4[matrixrotationZ.values] = sin(rotation.z),
	5[matrixrotationZ.values] = cos(rotation.z),
	6[matrixrotationZ.values] = 0,

	8[matrixrotationZ.values] = 0,
	9[matrixrotationZ.values] = 0,
	10[matrixrotationZ.values] = 1,

	0[matrixrotationY.values] = cos(rotation.y),
	1[matrixrotationY.values] = 0,
	2[matrixrotationY.values] = sin(rotation.y),

	4[matrixrotationY.values] = 0,
	5[matrixrotationY.values] = 1,
	6[matrixrotationY.values] = 0,

	8[matrixrotationY.values] = -sin(rotation.y),
	9[matrixrotationY.values] = 0,
	10[matrixrotationY.values] = cos(rotation.y),

	0[matrixrotationX.values] = 1,
	1[matrixrotationX.values] = 0,
	2[matrixrotationX.values] = 0,

	4[matrixrotationX.values] = 0,
	5[matrixrotationX.values] = cos(rotation.x),
	6[matrixrotationX.values] = -sin(rotation.x),

	8[matrixrotationX.values] = 0,
	9[matrixrotationX.values] = sin(rotation.x),
	10[matrixrotationX.values] = cos(rotation.x);

	SUTransformationTranslation(&matrixtransform, &translation);
	
	SUTransformationMultiply(&matrixtransform, &matrixrotationX, &matrixtransform);
	SUTransformationMultiply(&matrixtransform, &matrixrotationY, &matrixtransform);
	SUTransformationMultiply(&matrixtransform, &matrixrotationZ, &matrixtransform);

	SUComponentInstanceSetTransform(instance, &matrixtransform);

DanRathbun · October 8, 2019, 10:33pm

Is this your door component?

If not, take extra care with door and window components. Actually any “snap_to” component. If they are snap_to components then they are drawn lying flat on the XY ground plane (which is the cutting plane if their “cuts_opening” flag is set,) facing up (the door’s outside face’s normal vector is perpendicular to the blue Z axis.)
In the GUI when the user is placing one of these type of components, the core automatically reorients the instance attached to the cursor when it nears a snapable face (which depends upon what the definition’s “snap_to”/“glue to” setting is, ie, vertical, horizontal, sloped, or any.)

sasho648 · October 8, 2019, 11:07pm

I haven’t assigned any special properties to this specific component instance. In fact I draw everything equally dumb - by using 3d faces.

My original idea was doing something like:

	SUTransformationRotation(&matrixrotationX, &translation, (struct SUVector3D[]) { 1, 0, 0 }, rotation.x * M_PI / 180.0),
	SUTransformationRotation(&matrixrotationY, &translation, (struct SUVector3D[]) { 0, 1, 0 }, rotation.y * M_PI / 180.0),
	SUTransformationRotation(&matrixrotationZ, &translation, (struct SUVector3D[]) { 0, 0, 1 }, rotation.z * M_PI / 180.0);

	SUTransformationTranslation(&matrixtransform, &translation);

	SUTransformationMultiply(&matrixtransform, &matrixrotationX, &matrixtransform);

	SUTransformationMultiply(&matrixtransform, &matrixrotationY, &matrixtransform);

	SUTransformationMultiply(&matrixtransform, &matrixrotationZ, &matrixtransform);

	SUComponentInstanceSetTransform(instance, &matrixtransform);

But obviously this doesn’t work since the resulting transformations are way off the original models in the game engine.

Never mind I got it to work - excluding duplicates that is and I haven’t even started exportion yet.

tt_su · October 11, 2019, 4:20pm

I’m actually working on an update to better visualize the matrix. My current released version indicate row-major order. But SketchUp uses column-major order.

New version is currently looking like this:

Color coding for the rotation axes, along with their angles described in degrees.
Note that the translation values are now located to the right, not the bottom. Hovering over a matrix will display what index it relates to.

WIP is is the dev/column-major branch:
https://github.com/thomthom/transformation-inspector/tree/dev/column-major

eneroth3 · October 11, 2019, 7:51pm

FR: When hovering a field there could be a tooltip saying “X component of Y axis” and the like. I never really got transformation matrices until I noticed how the rows (or is it teh columns) of the 3x3 rotation matrix are the vectors of the axes.

kengey · October 12, 2019, 7:22am

Wow. Never noticed this either, until now. Thanks.

slbaumgartner · October 12, 2019, 1:30pm

That was a key aha moment for me too, and I’ve gone to using this idea in my extensions when placing complicated groups such as angular dimensions, slope markers, etc. I draw the group at the origin in the model (which makes it easier to place all the parts) and then use unit vectors at the desired destination to create the Transformation from an Array without ever knowing or caring about the angles involved.

Topic		Replies	Views
SetCoordinateAxes SketchUp SDK	4	1710	May 4, 2015
Newbie struggling with rotate tool SketchUp for Web rotation , sketchup , rotate , help	3	231	September 4, 2024
Help Sketchup Axes SketchUp sketchup , import , bug , export , modeling	10	740	June 28, 2021
Angles are off SketchUp for Web	3	596	March 22, 2020
Exporting 3D model from SketchUp to Unity - Orientation problem SketchUp for Web sketchup , export , axes , unity , 3d-model	14	3853	January 1, 2021

I'm deeply frustrated and intimitated by applying rotations

Related topics