@inweb/viewer-visualize 25.8.7 → 25.8.8

package/dist/viewer-visualize.module.js

@@ -374,11 +374,15 @@ class Dragger {
     updatePreview() {}
 }
 
-const composeMatrixFromTransform = (translate, rotate, scale, modelCenter, matrix) => {
-    const translateMatrix = matrix.setTranslation([ translate.x, translate.y, translate.z ]);
-    const rotateMatrix = matrix.setToRotation(rotate.angle, [ rotate.x, rotate.y, rotate.z ], modelCenter);
-    const scaleMatrix = matrix.setToScaling(scale, modelCenter);
-    return translateMatrix.postMultBy(rotateMatrix).postMultBy(scaleMatrix);
+const composeMatrixFromTransform = (transform, modelCenter, visLib) => {
+    const {translate: translate, scale: scale, rotation: rotation} = transform;
+    const translateMatrix = new visLib.Matrix3d;
+    translateMatrix.setTranslation([ translate.x, translate.y, translate.z ]);
+    const rotateMatrix = new visLib.Matrix3d;
+    rotateMatrix.setToRotation(rotation.angle, [ rotation.x, rotation.y, rotation.z ], modelCenter);
+    const scaleMatrix = new visLib.Matrix3d;
+    scaleMatrix.setToScaling(scale, modelCenter);
+    return rotateMatrix.postMultBy(translateMatrix).postMultBy(scaleMatrix);
 };
 
 function applyModelTransform(viewer, model) {
@@ -393,7 +397,8 @@ function applyModelTransform(viewer, model) {
         const transform = model.getModelTransformMatrix(modelPtr.getDatabaseHandle());
         if (transform) {
             const extents = modelPtr.getExtents();
-            const matrix = composeMatrixFromTransform(transform.translate, transform.rotation, transform.scale, extents.center(), new visLib.Matrix3d);
+            extents.transformBy(modelPtr.getUnitsMatrix());
+            const matrix = composeMatrixFromTransform(transform, extents.center(), visLib);
             modelPtr.setModelingMatrix(matrix, true);
         }
     }
@@ -705,6 +710,62 @@ function zoomToSelected(viewer) {
 
 commands("VisualizeJS").registerCommand("zoomToSelected", zoomToSelected);
 
+function isTemplateModel(modelPtr) {
+    return modelPtr.getName()[0] === "$";
+}
+
+async function autoTransformAllModelsToCentralPoint(viewer, model) {
+    var _a;
+    if (!viewer.visualizeJs) return;
+    if (!model.getModelTransformMatrix) return;
+    const visLib = viewer.visLib();
+    const visViewer = visLib.getViewer();
+    const viewExt = visViewer.getActiveExtents();
+    const centralPoint = viewExt.center();
+    const modelItr = visViewer.getModelIterator();
+    for (;!modelItr.done(); modelItr.step()) {
+        const modelPtr = modelItr.getModel();
+        if (!isTemplateModel(modelPtr)) {
+            let ext = modelPtr.getExtents();
+            const unitsMatrix = modelPtr.getUnitsMatrix();
+            ext.transformBy(modelPtr.getUnitsMatrix());
+            const unitsMatrixInvert = modelPtr.getUnitsMatrix().invert();
+            const center = ext.center();
+            const scale = 1;
+            const scaleMatrix = new visLib.Matrix3d;
+            const translateMatrix = new visLib.Matrix3d;
+            translateMatrix.setTranslation([ centralPoint[0] - center[0], centralPoint[1] - center[1], centralPoint[2] - center[2] ]);
+            scaleMatrix.setToScaling(scale, centralPoint);
+            const resMatrixWithUnits = unitsMatrixInvert.postMultBy(scaleMatrix).postMultBy(translateMatrix).postMultBy(unitsMatrix);
+            const resScale = resMatrixWithUnits.scale();
+            const transform = {
+                translate: {
+                    x: resMatrixWithUnits.get(0, 3) - (1 - resScale) * center[0],
+                    y: resMatrixWithUnits.get(1, 3) - (1 - resScale) * center[1],
+                    z: resMatrixWithUnits.get(2, 3) - (1 - resScale) * center[2]
+                },
+                rotation: {
+                    x: 0,
+                    y: 0,
+                    z: 1,
+                    angle: 0
+                },
+                scale: resScale
+            };
+            const matrix = composeMatrixFromTransform(transform, center, visLib);
+            modelPtr.setModelingMatrix(matrix, true);
+            centralPoint[0] += Math.abs(ext.max()[0] - ext.min()[0]) * resScale;
+            await model.setModelTransformMatrix(modelPtr.getDatabaseHandle(), transform);
+        }
+        modelPtr.delete();
+    }
+    modelItr.delete();
+    (_a = visViewer.clearViewExtentsCache) === null || _a === void 0 ? void 0 : _a.call(visViewer);
+    viewer.update();
+}
+
+commands("VisualizeJS").registerCommand("autoTransformAllModelsToCentralPoint", autoTransformAllModelsToCentralPoint);
+
 class MarkupColor {
     get HexColor() {
         return "#" + this._hex;