@inweb/viewer-visualize 26.12.6 → 26.12.7

package/dist/viewer-visualize.module.js

@@ -3866,7 +3866,7 @@ class VisualizeMarkup {
         const visLib = this._viewer.visLib();
         const visViewer = this._viewer.visViewer();
         if (!viewpoint)
-            viewpoint = {};
+            viewpoint = { custom_fields: {} };
         viewpoint.lines = [];
         viewpoint.texts = [];
         const model = visViewer.getMarkupModel();
@@ -3908,12 +3908,8 @@ class VisualizeMarkup {
             entityPtr.delete();
         }
         itr.delete();
-        viewpoint.snapshot = {
-            data: visLib.canvas.toDataURL("image/jpeg", 0.25),
-        };
-        viewpoint.custom_fields = {
-            markup_color: this.getMarkupColor(),
-        };
+        viewpoint.snapshot = { data: visLib.canvas.toDataURL("image/jpeg", 0.25) };
+        viewpoint.custom_fields.markup_color = this.getMarkupColor();
         return viewpoint;
     }
     enableEditMode(mode) {
@@ -4513,11 +4509,27 @@ class Viewer extends EventEmitter2 {
         const setOrthogonalCamera = (orthogonal_camera) => {
             if (orthogonal_camera) {
                 activeView.setView(getPoint3dAsArray(orthogonal_camera.view_point), getPoint3dAsArray(orthogonal_camera.direction), getPoint3dAsArray(orthogonal_camera.up_vector), orthogonal_camera.field_width, orthogonal_camera.field_height, true);
-                this.syncOverlay();
+                this.options.cameraMode = "orthographic";
                 this.emitEvent({ type: "changecameramode", mode: "orthographic" });
             }
         };
-        const setPerspectiveCamera = (perspective_camera) => { };
+        const setPerspectiveCamera = (perspective_camera) => {
+            if (perspective_camera) {
+                const aspectRatio = this.canvas.width / this.canvas.height;
+                const position = perspective_camera.view_point;
+                const target = perspective_camera.direction;
+                const fov = (perspective_camera.field_of_view * Math.PI) / 180;
+                const dx = target.x - position.x;
+                const dy = target.y - position.y;
+                const dz = target.z - position.z;
+                const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+                const fieldHeight = 2 * distance * Math.tan(fov / 2);
+                const fieldWidth = fieldHeight * aspectRatio;
+                activeView.setView(getPoint3dAsArray(perspective_camera.view_point), getPoint3dAsArray(perspective_camera.direction), getPoint3dAsArray(perspective_camera.up_vector), fieldWidth, fieldHeight, false);
+                this.options.cameraMode = "perspective";
+                this.emitEvent({ type: "changecameramode", mode: "perspective" });
+            }
+        };
         const setClippingPlanes = (clipping_planes) => {
             if (clipping_planes) {
                 for (const clipping_plane of clipping_planes) {
@@ -4544,6 +4556,7 @@ class Viewer extends EventEmitter2 {
         setClippingPlanes(viewpoint.clipping_planes);
         setSelection(((_b = viewpoint.custom_fields) === null || _b === void 0 ? void 0 : _b.selection2) || viewpoint.selection);
         this._markup.setViewpoint(viewpoint);
+        this.syncOverlay();
         this.setActiveDragger(draggerName);
         this.emitEvent({ type: "drawviewpoint", data: viewpoint });
         this.update();
@@ -4557,17 +4570,37 @@ class Viewer extends EventEmitter2 {
             return { x: array[0], y: array[1], z: array[2] };
         };
         const getOrthogonalCamera = () => {
-            return {
-                view_point: getPoint3dFromArray(activeView.viewPosition),
-                direction: getPoint3dFromArray(activeView.viewTarget),
-                up_vector: getPoint3dFromArray(activeView.upVector),
-                field_width: activeView.viewFieldWidth,
-                field_height: activeView.viewFieldHeight,
-                view_to_world_scale: 1,
-            };
+            if (!activeView.perspective)
+                return {
+                    view_point: getPoint3dFromArray(activeView.viewPosition),
+                    direction: getPoint3dFromArray(activeView.viewTarget),
+                    up_vector: getPoint3dFromArray(activeView.upVector),
+                    field_width: activeView.viewFieldWidth,
+                    field_height: activeView.viewFieldHeight,
+                    view_to_world_scale: 1,
+                };
+            else
+                return undefined;
         };
         const getPerspectiveCamera = () => {
-            return undefined;
+            if (activeView.perspective) {
+                const position = activeView.viewPosition;
+                const target = activeView.viewTarget;
+                const fieldHeight = activeView.viewFieldHeight;
+                const dx = target[0] - position[0];
+                const dy = target[1] - position[1];
+                const dz = target[2] - position[2];
+                const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+                const fov = 2 * Math.atan(fieldHeight / (2 * distance));
+                return {
+                    view_point: getPoint3dFromArray(activeView.viewPosition),
+                    direction: getPoint3dFromArray(activeView.viewTarget),
+                    up_vector: getPoint3dFromArray(activeView.upVector),
+                    field_of_view: (fov * 180) / Math.PI,
+                };
+            }
+            else
+                return undefined;
         };
         const getClippingPlanes = () => {
             const clipping_planes = [];