@itwin/core-geometry 4.10.0-dev.26 → 4.10.0-dev.28

package/lib/esm/geometry3d/Matrix3d.js

@@ -2497,8 +2497,8 @@ export class Matrix3d {
         return Math.sqrt(sumLow) <= Geometry.smallAngleRadians * (1.0 + Math.sqrt(sumAll));
     }
     /**
-     * If the matrix is diagonal and all diagonals are almost equal, return the first diagonal (entry 0
-     * which is same as entry 4 and 8). Otherwise return `undefined`.
+     * If the matrix is diagonal with almost equal diagonal entries, return the first diagonal entry.
+     * Otherwise return `undefined`.
      */
     sameDiagonalScale() {
         const sumAll = this.sumSquares();
@@ -2511,32 +2511,31 @@ export class Matrix3d {
         return undefined;
     }
     /**
-     * Test if all rows and columns are unit length and are perpendicular to each other, i.e., the matrix is either
-     * a `pure rotation` (determinant is +1) or is a `mirror` (determinant is -1).
-     * * **Note:** such a matrix is called `orthogonal` and its inverse is its transpose.
+     * Test if all rows and columns are unit length and perpendicular to each other.
+     * * If so, the matrix is either a rotation (determinant is +1) or a mirror (determinant is -1).
+     * * Such a matrix is called "orthogonal" and its inverse is its transpose.
      */
     testPerpendicularUnitRowsAndColumns() {
         const product = this.multiplyMatrixMatrixTranspose(this);
         return product.isIdentity;
     }
     /**
-     * Test if the matrix is a `rigid` matrix (or `pure rotation`, i.e., columns and rows are unit length and
-     * pairwise perpendicular and determinant is +1).
-     * @param allowMirror whether to widen the test to return true if the matrix is a `mirror` (determinant is -1).
+     * Test if the matrix is a rigid matrix.
+     * * A rigid matrix is a rotation: its columns and rows are unit length and pairwise perpendicular, and its
+     * determinant is +1.
+     * @param allowMirror whether to widen the test to also return true if the matrix is a mirror (determinant is -1).
     */
     isRigid(allowMirror = false) {
         return this.testPerpendicularUnitRowsAndColumns() && (allowMirror || this.determinant() > 0);
     }
     /**
-     * Test if all rows and columns are perpendicular to each other and have equal length.
-     * If so, the length (or its negative) is the `scale` factor from a set of `orthonormal axes` to
-     * the set of axes created by columns of `this` matrix. Otherwise, returns `undefined`.
+     * Test if the instance is the product of a rigid matrix and a signed scale, and return both.
+     * * Specifically, this is a test of whether the instance rows and columns are pairwise perpendicular and have equal
+     * length. If so, the scale factor is this length, or its negative if the instance is a mirror, and dividing the
+     * columns by this scale factor produces a rigid matrix (a rotation).
      * @param result optional pre-allocated object to populate and return
-     * @returns returns `{ rigidAxes, scale }` where `rigidAxes` is a Matrix3d with its columns as the rigid axes
-     * (with the scale factor removed) and `scale` is the scale factor.
-     * * Note that determinant of a rigid matrix is +1.
-     * * The context for this method is to determine if the matrix is the product a `rotation` matrix and a uniform
-     * `scale` matrix (diagonal matrix with all diagonal entries the same nonzero number).
+     * @returns the factorization `{ rigidAxes, scale }` where `rigidAxes` is the instance matrix with `scale` factor
+     * removed, or undefined if the factorization failed.
      */
     factorRigidWithSignedScale(result) {
         const product = this.multiplyMatrixMatrixTranspose(this);
@@ -2547,6 +2546,25 @@ export class Matrix3d {
         const scaleInverse = 1.0 / scale;
         return { rigidAxes: this.scaleColumns(scaleInverse, scaleInverse, scaleInverse, result), scale };
     }
+    /**
+     * Compute the factorization M = R*G, where R is rigid (a rotation) and G is whatever is left over (skew, scale,
+     * mirror, etc).
+     * * The rotation is computed from the instance by passing `axisOrder` into [[createRigidFromMatrix3d]].
+     * @param rotation the rigid factor R
+     * @param skew the non-rotation factor G = R^t * M (since R transposed is its inverse)
+     * @param axisOrder optional cross product ordering for computing R
+     * @return whether [[createRigidFromMatrix3d]] succeeded; if not, `rotation` is set to the identity, and `skew` is
+     * set to this instance.
+     */
+    factorRigidSkew(rotation, skew, axisOrder = AxisOrder.XYZ) {
+        if (Matrix3d.createRigidFromMatrix3d(this, axisOrder, rotation)) {
+            rotation.multiplyMatrixTransposeMatrix(this, skew);
+            return true;
+        }
+        rotation.setIdentity();
+        skew.setFrom(this);
+        return false;
+    }
     /** Test if `this` matrix reorders and/or negates the columns of the `identity` matrix. */
     get isSignedPermutation() {
         let count = 0;