@inweb/viewer-visualize 25.8.7 → 25.8.9

package/dist/viewer-visualize.js

@@ -379,11 +379,15 @@
     }
 
     ///////////////////////////////////////////////////////////////////////////////
-    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, scale, 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) {
         var _a;
@@ -399,7 +403,8 @@
             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);
             }
         }
@@ -692,6 +697,65 @@
     }
     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; // Model.getModelTransformMatrix() since 24.3.14
+        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()); // ext in wcs
+                const unitsMatrixInvert = modelPtr.getUnitsMatrix().invert();
+                const center = ext.center();
+                const scale = 1.0;
+                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.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);
+
     var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
     function getDefaultExportFromCjs (x) {
@@ -12204,7 +12268,7 @@
                 this._ref = ref;
                 return;
             }
-            if (!params.points) return;
+            if (!params || !params.points) return;
             const konvaPoints = [];
             params.points.forEach((point => konvaPoints.push(point.x, point.y)));
             this._ref = new Konva.Line({
@@ -12306,7 +12370,7 @@
                 this._ref = ref;
                 return;
             }
-            if (!params || !params.text) return;
+            if (!params || !params.position || !params.text) return;
             this._ref = new Konva.Text({
                 x: params.position.x,
                 y: params.position.y,
@@ -12408,7 +12472,7 @@
                 this._ref = ref;
                 return;
             }
-            if (!params.position) return;
+            if (!params || !params.position) return;
             this._ref = new Konva.Rect({
                 stroke: (_a = params.color) !== null && _a !== void 0 ? _a : "#ff0000",
                 strokeWidth: (_b = params.lineWidth) !== null && _b !== void 0 ? _b : 4,
@@ -12518,7 +12582,7 @@
                 this._ref = ref;
                 return;
             }
-            if (!params.position) return;
+            if (!params || !params.position || !params.radius) return;
             this._ref = new Konva.Ellipse({
                 stroke: (_a = params.color) !== null && _a !== void 0 ? _a : "#ff0000",
                 strokeWidth: (_b = params.lineWidth) !== null && _b !== void 0 ? _b : 4,
@@ -12640,7 +12704,7 @@
                 this._ref = ref;
                 return;
             }
-            if (!params.start || !params.end) return;
+            if (!params || !params.start || !params.end) return;
             this._ref = new Konva.Arrow({
                 stroke: (_a = params.color) !== null && _a !== void 0 ? _a : "#ff0000",
                 fill: (_b = params.color) !== null && _b !== void 0 ? _b : "#ff0000",
@@ -12734,6 +12798,7 @@
 
     class KonvaImage {
         constructor(params, ref = null) {
+            var _a, _b;
             this._ratio = 1;
             if (ref) {
                 if (ref.height() === 0 || ref.width() === 0) return;
@@ -12742,14 +12807,14 @@
                 this._ratio = this._ref.height() / this._ref.width();
                 return;
             }
-            if (!params.position || !params.src) return;
+            if (!params || !params.position || !params.src) return;
             this._canvasImage = new Image;
             this._ref = new Konva.Image({
                 x: params.position.x,
                 y: params.position.y,
                 image: this._canvasImage,
-                width: params.width,
-                height: params.height,
+                width: (_a = params.width) !== null && _a !== void 0 ? _a : 0,
+                height: (_b = params.height) !== null && _b !== void 0 ? _b : 0,
                 draggable: true
             });
             this._canvasImage.onload = () => {
@@ -12857,7 +12922,7 @@
                 this._ref = ref;
                 return;
             }
-            if (!params.position || !params.width || !params.height) return;
+            if (!params || !params.position) return;
             const arcRadius = 16;
             this._ref = new Konva.Shape({
                 x: params.position.x,
@@ -13061,7 +13126,7 @@
         },
         Cloud: {
             name: "Cloud",
-            initializer: ref => new KonvaCloud(null, ref),
+            initializer: (ref, params = null) => new KonvaCloud(params, ref),
             zIndex: 1
         }
     };
@@ -14496,6 +14561,14 @@
             pt2[1] -= pt1[1];
             return Math.min(pt2[0], pt2[1]) / 120;
         }
+        start(x, y) {
+            this.createNewMeasureIfNeed();
+            const point = this.getViewer().getSnapPoint(x, y, this.gripingRadius);
+            if (point) {
+                this.firstPoint = point;
+                this.previewMeasureLine.setStartPoint(this.firstPoint);
+            }
+        }
         drag(x, y) {
             this.createNewMeasureIfNeed();
             const point = this.getViewer().getSnapPoint(x, y, this.gripingRadius);
@@ -17097,11 +17170,15 @@
             //return visViewer.activeView.upVector[1] >= 0.95;
         }
         screenToWorld(position) {
-            return this.visViewer().screenToWorld(position.x * window.devicePixelRatio, position.y * window.devicePixelRatio);
+            if (!this.visualizeJs)
+                return { x: position.x, y: position.y, z: 0 };
+            const worldPoint = this.visViewer().screenToWorld(position.x * window.devicePixelRatio, position.y * window.devicePixelRatio);
+            const result = { x: worldPoint[0], y: worldPoint[1], z: worldPoint[2] };
+            return result;
         }
         worldToScreen(position) {
             if (!this.visualizeJs)
-                return position;
+                return { x: position.x, y: position.y };
             const activeView = this.visViewer().activeView;
             const worldMatrix = activeView.worldToDeviceMatrix;
             const worldPoint = this.visLib().Point3d.createFromArray([position.x, position.y, position.z]);
@@ -17117,15 +17194,15 @@
             const result = { x: 1.0, y: 1.0, z: 1.0 };
             const projMatrix = this.visViewer().activeView.projectionMatrix;
             const tolerance = 1.0e-6;
-            const x = projMatrix.get(1, 1);
+            const x = projMatrix.get(0, 0);
             if (x > tolerance || x < -tolerance)
-                result.x = 1 / result.x;
+                result.x = 1 / x;
             const y = projMatrix.get(1, 1);
             if (y > tolerance || y < -tolerance)
-                result.y = 1 / result.y;
+                result.y = 1 / y;
             const z = projMatrix.get(2, 2);
             if (z > tolerance || z < -tolerance)
-                result.z = 1 / result.z;
+                result.z = 1 / z;
             return result;
         }
         /**