@inweb/viewer-visualize 25.8.7 → 25.8.9

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;
@@ -766,7 +827,7 @@ class KonvaLine {
             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({
@@ -868,7 +929,7 @@ class KonvaText {
             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,
@@ -970,7 +1031,7 @@ class KonvaRectangle {
             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,
@@ -1080,7 +1141,7 @@ class KonvaEllipse {
             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,
@@ -1202,7 +1263,7 @@ class KonvaArrow {
             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",
@@ -1296,6 +1357,7 @@ class KonvaArrow {
 
 class KonvaImage {
     constructor(params, ref = null) {
+        var _a, _b;
         this._ratio = 1;
         if (ref) {
             if (ref.height() === 0 || ref.width() === 0) return;
@@ -1304,14 +1366,14 @@ class KonvaImage {
             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 = () => {
@@ -1419,7 +1481,7 @@ class KonvaCloud {
             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,
@@ -1623,7 +1685,7 @@ const MarkupMode2Konva = {
     },
     Cloud: {
         name: "Cloud",
-        initializer: ref => new KonvaCloud(null, ref),
+        initializer: (ref, params = null) => new KonvaCloud(params, ref),
         zIndex: 1
     }
 };
@@ -3091,6 +3153,14 @@ class MeasureLineDragger extends OdBaseDragger {
         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);
@@ -5471,10 +5541,24 @@ class Viewer extends EventEmitter2 {
         return extHeight !== 0;
     }
     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;
+        if (!this.visualizeJs) 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 ]);
@@ -5497,12 +5581,12 @@ class Viewer extends EventEmitter2 {
         };
         const projMatrix = this.visViewer().activeView.projectionMatrix;
         const tolerance = 1e-6;
-        const x = projMatrix.get(1, 1);
-        if (x > tolerance || x < -tolerance) result.x = 1 / result.x;
+        const x = projMatrix.get(0, 0);
+        if (x > tolerance || x < -tolerance) result.x = 1 / x;
         const y = projMatrix.get(1, 1);
-        if (y > tolerance || y < -tolerance) result.y = 1 / result.y;
+        if (y > tolerance || y < -tolerance) result.y = 1 / y;
         const z = projMatrix.get(2, 2);
-        if (z > tolerance || z < -tolerance) result.z = 1 / result.z;
+        if (z > tolerance || z < -tolerance) result.z = 1 / z;
         return result;
     }
     getSelected() {