@smarterplan/ngx-smarterplan-core 1.4.6 → 1.4.8

package/esm2022/lib/services/matterport-measurement.service.mjs

@@ -0,0 +1,78 @@
+import { Injectable } from '@angular/core';
+import { getDistanceBetweenTwoPoints } from '../helpers.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class MatterportMeasurementService {
+    router;
+    lastMeasure = [];
+    distancesLastMeasure = [];
+    lastScreenshotUri;
+    resolution = {
+        width: 500,
+        height: 600,
+    };
+    visibility = {
+        mattertags: false,
+        sweeps: true,
+    };
+    constructor(router) {
+        this.router = router;
+    }
+    /**
+     * Callback after measurement is performed
+     */
+    getDistanceForLastMeasurement(sdk, currentSpaceID) {
+        if (this.lastMeasure.length > 0) {
+            const numberPoints = this.lastMeasure.length;
+            this.distancesLastMeasure = [];
+            for (let index = 1; index < numberPoints; index += 1) {
+                const distance = getDistanceBetweenTwoPoints(this.lastMeasure[index - 1], this.lastMeasure[index]);
+                this.distancesLastMeasure.push(distance);
+            }
+            this.takeScreenShot(sdk).then(() => {
+                this.router.navigate([`visit/${currentSpaceID}/add_measurement`]);
+            });
+        }
+    }
+    getLastDistances() {
+        return this.distancesLastMeasure;
+    }
+    /**
+     * Takes screenshot and saves base64 in lastScreenshotUri
+     * @param sdk Matterport SDK
+     * @returns Promise
+     */
+    takeScreenShot(sdk) {
+        return sdk.Renderer.takeScreenShot(this.resolution, this.visibility).then((screenShotUri) => {
+            this.lastScreenshotUri = screenShotUri;
+            return Promise.resolve();
+        });
+    }
+    getScreenShotUri() {
+        return this.lastScreenshotUri;
+    }
+    getLastMeasurement(poseCamera) {
+        return {
+            measure: this.lastMeasure,
+            sweep: poseCamera.sweep,
+        };
+    }
+    setLastMeasure(points) {
+        this.lastMeasure = points;
+    }
+    getResolution() {
+        return this.resolution;
+    }
+    getVisibility() {
+        return this.visibility;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportMeasurementService, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportMeasurementService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportMeasurementService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/matterport-navigation.service.mjs

@@ -0,0 +1,157 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { CameraMode } from '../types.service';
+import { wait } from '../helpers.service';
+import * as i0 from "@angular/core";
+export class MatterportNavigationService {
+    sweepCollection = null;
+    sweeps = null;
+    floors = null;
+    forbiddenSweeps = [];
+    currentSweep = new Subject();
+    onCameraModeChanged = new Subject();
+    /** Emits whenever the set of current rooms changes (sdk.Room.current). */
+    onRoomChanged = new Subject();
+    inTransitionMode = false;
+    inTransitionSweep = false;
+    currentCameraMode = CameraMode.OUTSIDE;
+    currentRooms = [];
+    /** Sequence number of the floor currently visible in sdk.Floor.current (null = single-floor or unknown). */
+    currentFloorSequence = null;
+    constructor() { }
+    async action_toolbox_floorplan(sdk) {
+        if (this.inTransitionMode || this.inTransitionSweep) {
+            console.log('viewer is in transition, cannot go floorplan');
+            return;
+        }
+        try {
+            await sdk.Mode.moveTo('mode.floorplan');
+        }
+        catch (e) {
+            console.log('cannot go to floorplan', e);
+        }
+    }
+    action_toolbox_inside_view(sdk) {
+        sdk.Mode.moveTo('mode.inside');
+    }
+    actionShowAllFloors(sdk) {
+        try {
+            sdk.Floor.showAll();
+        }
+        catch (e) {
+            console.log('cannot show all floors', e);
+        }
+    }
+    async action_toolbox_dollhouse(sdk) {
+        setTimeout(async () => {
+            if (this.inTransitionMode || this.inTransitionSweep) {
+                console.log('viewer is in transition, cannot go dollhouse');
+                return;
+            }
+            try {
+                await sdk.Mode.moveTo('mode.dollhouse');
+            }
+            catch (e) {
+                console.log('cannot go to dollhouse', e);
+            }
+        }, 1200);
+    }
+    async action_go_to_floor(sdk, floorName, matterportFloorSequence = null) {
+        if (!this.floors) {
+            console.log('Floor are not loaded yet');
+            return;
+        }
+        let floorMatterport = this.floors.find((floor) => floor.sequence === matterportFloorSequence);
+        if (!floorMatterport) {
+            floorMatterport = this.floors.find((floor) => floorName.includes(floor.name) && floor.name != '');
+        }
+        if (!floorMatterport) {
+            floorMatterport = this.floors.find((floor) => floorName.includes(floor.id));
+        }
+        if (floorMatterport) {
+            let retry = true;
+            while (retry) {
+                try {
+                    const floorIndex = await sdk.Floor.moveTo(floorMatterport.sequence);
+                    console.debug("moved to floorIndex", floorIndex);
+                    retry = false;
+                }
+                catch (error) {
+                    console.log('Cannot move to Floor', error);
+                    await wait(100);
+                }
+            }
+        }
+        else {
+            console.warn('No matterport floor found to move to');
+        }
+    }
+    async action_go_to_sweep(sdk, sweep, rotation) {
+        if (this.forbiddenSweeps.includes(sweep)) {
+            console.log('user is not allowed to go to this sweep');
+            return;
+        }
+        setTimeout(async () => {
+            try {
+                this.inTransitionSweep = true;
+                await sdk.Sweep.moveTo(sweep, {
+                    transition: sdk.Camera.TransitionType.INSTANT,
+                    transitionTime: 1500
+                });
+            }
+            catch (error) {
+                this.inTransitionSweep = false;
+                console.log('Cannot move to sweep', error);
+            }
+            if (rotation) {
+                await sdk.Camera.setRotation(rotation, { speed: 100 });
+            }
+        }, 1000);
+    }
+    async removeForbiddenSweeps(sdk, forbiddenSweeps) {
+        this.forbiddenSweeps = [...forbiddenSweeps];
+        let removed = 0;
+        await Promise.all(forbiddenSweeps.map(async (sweep) => {
+            try {
+                await sdk.Sweep.disable(sweep);
+                removed += 1;
+            }
+            catch (error) {
+                console.log(error);
+            }
+        }));
+        console.log('removed sweeps:', removed);
+    }
+    getCurrentSweep(poseCamera) {
+        return poseCamera?.sweep || null;
+    }
+    setCameraMode(mode) {
+        this.inTransitionSweep = false;
+        switch (mode) {
+            case 'mode.dollhouse':
+                this.currentCameraMode = CameraMode.DOLLHOUSE;
+                break;
+            case 'mode.floorplan':
+                this.currentCameraMode = CameraMode.FLOORPLAN;
+                break;
+            case 'mode.inside':
+                this.currentCameraMode = CameraMode.INSIDE;
+                break;
+            case 'mode.transitioning':
+                this.currentCameraMode = CameraMode.TRANSITIONING;
+                break;
+            default:
+                this.currentCameraMode = CameraMode.OUTSIDE;
+        }
+        this.onCameraModeChanged.next(this.currentCameraMode);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportNavigationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportNavigationService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportNavigationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"matterport-navigation.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-smarterplan-core/src/lib/services/matterport-navigation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { Subject } from 'rxjs';\r\nimport { CameraMode } from '../types.service';\r\nimport { wait } from '../helpers.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class MatterportNavigationService {\r\n  public sweepCollection: any = null;\r\n  public sweeps: Array<string> | null = null;\r\n  public floors: Array<{ id: string; name: string; sequence: number }> | null = null;\r\n  public forbiddenSweeps: string[] = [];\r\n\r\n  public currentSweep: Subject<string> = new Subject();\r\n  public onCameraModeChanged = new Subject<CameraMode>();\r\n  /** Emits whenever the set of current rooms changes (sdk.Room.current). */\r\n  public onRoomChanged = new Subject<any[]>();\r\n\r\n  public inTransitionMode = false;\r\n  public inTransitionSweep = false;\r\n  public currentCameraMode: CameraMode = CameraMode.OUTSIDE;\r\n  public currentRooms: any[] = [];\r\n  /** Sequence number of the floor currently visible in sdk.Floor.current (null = single-floor or unknown). */\r\n  public currentFloorSequence: number | null = null;\r\n\r\n  constructor() { }\r\n\r\n  async action_toolbox_floorplan(sdk: any) {\r\n    if (this.inTransitionMode || this.inTransitionSweep) {\r\n      console.log('viewer is in transition, cannot go floorplan');\r\n      return;\r\n    }\r\n    try {\r\n      await sdk.Mode.moveTo('mode.floorplan');\r\n    } catch (e) {\r\n      console.log('cannot go to floorplan', e);\r\n    }\r\n  }\r\n\r\n  action_toolbox_inside_view(sdk: any) {\r\n    sdk.Mode.moveTo('mode.inside');\r\n  }\r\n\r\n  actionShowAllFloors(sdk: any) {\r\n    try {\r\n      sdk.Floor.showAll();\r\n    } catch (e) {\r\n      console.log('cannot show all floors', e);\r\n    }\r\n  }\r\n\r\n  async action_toolbox_dollhouse(sdk: any) {\r\n    setTimeout(async () => {\r\n      if (this.inTransitionMode || this.inTransitionSweep) {\r\n        console.log('viewer is in transition, cannot go dollhouse');\r\n        return;\r\n      }\r\n      try {\r\n        await sdk.Mode.moveTo('mode.dollhouse');\r\n      } catch (e) {\r\n        console.log('cannot go to dollhouse', e);\r\n      }\r\n    }, 1200);\r\n  }\r\n\r\n  async action_go_to_floor(sdk: any, floorName: string, matterportFloorSequence: number = null) {\r\n    if (!this.floors) {\r\n      console.log('Floor are not loaded yet');\r\n      return;\r\n    }\r\n    let floorMatterport = this.floors.find(\r\n      (floor) => floor.sequence === matterportFloorSequence\r\n    );\r\n    if (!floorMatterport) {\r\n      floorMatterport = this.floors.find(\r\n        (floor) => floorName.includes(floor.name) && floor.name != ''\r\n      );\r\n    }\r\n    if (!floorMatterport) {\r\n      floorMatterport = this.floors.find((floor) =>\r\n        floorName.includes(floor.id)\r\n      );\r\n    }\r\n    if (floorMatterport) {\r\n      let retry = true;\r\n      while (retry) {\r\n        try {\r\n          const floorIndex = await sdk.Floor.moveTo(floorMatterport.sequence);\r\n          console.debug(\"moved to floorIndex\", floorIndex);\r\n          retry = false;\r\n        } catch (error) {\r\n          console.log('Cannot move to Floor', error);\r\n          await wait(100);\r\n        }\r\n      }\r\n    } else {\r\n      console.warn('No matterport floor found to move to');\r\n    }\r\n  }\r\n\r\n  async action_go_to_sweep(sdk: any, sweep: string, rotation?: { x: number, y: number } | null) {\r\n    if (this.forbiddenSweeps.includes(sweep)) {\r\n      console.log('user is not allowed to go to this sweep');\r\n      return;\r\n    }\r\n    setTimeout(async () => {\r\n      try {\r\n        this.inTransitionSweep = true;\r\n        await sdk.Sweep.moveTo(sweep, {\r\n          transition: sdk.Camera.TransitionType.INSTANT,\r\n          transitionTime: 1500\r\n        });\r\n      } catch (error) {\r\n        this.inTransitionSweep = false;\r\n        console.log('Cannot move to sweep', error);\r\n      }\r\n      if (rotation) {\r\n        await sdk.Camera.setRotation(rotation, { speed: 100 });\r\n      }\r\n    }, 1000);\r\n  }\r\n\r\n  async removeForbiddenSweeps(sdk: any, forbiddenSweeps: string[]) {\r\n    this.forbiddenSweeps = [...forbiddenSweeps];\r\n    let removed = 0;\r\n    await Promise.all(\r\n      forbiddenSweeps.map(async (sweep) => {\r\n        try {\r\n          await sdk.Sweep.disable(sweep);\r\n          removed += 1;\r\n        } catch (error) {\r\n          console.log(error);\r\n        }\r\n      })\r\n    );\r\n    console.log('removed sweeps:', removed);\r\n  }\r\n\r\n  getCurrentSweep(poseCamera: any): string | null {\r\n    return poseCamera?.sweep || null;\r\n  }\r\n\r\n  setCameraMode(mode: string) {\r\n    this.inTransitionSweep = false;\r\n    switch (mode) {\r\n      case 'mode.dollhouse':\r\n        this.currentCameraMode = CameraMode.DOLLHOUSE;\r\n        break;\r\n      case 'mode.floorplan':\r\n        this.currentCameraMode = CameraMode.FLOORPLAN;\r\n        break;\r\n      case 'mode.inside':\r\n        this.currentCameraMode = CameraMode.INSIDE;\r\n        break;\r\n      case 'mode.transitioning':\r\n        this.currentCameraMode = CameraMode.TRANSITIONING;\r\n        break;\r\n      default:\r\n        this.currentCameraMode = CameraMode.OUTSIDE;\r\n    }\r\n    this.onCameraModeChanged.next(this.currentCameraMode);\r\n  }\r\n}\r\n"]}

package/esm2022/lib/services/matterport-object3d.service.mjs

@@ -0,0 +1,234 @@
+import { Injectable } from '@angular/core';
+import { PoiType } from '../types.service';
+import { Object3D } from 'three';
+import { NestThermostat } from '../matterport-extensions/nest-thermostat/NestThermostat';
+import { PlaneRenderer } from '../matterport-extensions/nest-thermostat/PlaneRenderer';
+import { CanvasRenderer } from "../matterport-extensions/nest-thermostat/CanvasRenderer";
+import { TvPlayer } from "../matterport-extensions/tv-player/TvPlayer";
+import * as i0 from "@angular/core";
+export class MatterportObject3DService {
+    dictionnaryObjects3D = new Map();
+    dictionnarySceneObjects3D = new Map();
+    lastObject3D; // Three JS object
+    objectControl;
+    securityCameraAnimator;
+    azimuthalCrown;
+    threeJSScene;
+    noLightForObjects = true;
+    constructor() { }
+    async init3DObjectViewer(sdk) {
+        const [sceneObject] = await sdk.Scene.createObjects(1);
+        const node = sceneObject.addNode();
+        node.start();
+        this.threeJSScene = node.obj3D.parent;
+        const nodeControl = sceneObject.addNode();
+        this.objectControl = nodeControl.addComponent('mp.transformControls');
+        nodeControl.start();
+    }
+    async add3DObject(sdk, obj, mode) {
+        return new Promise(async (resolve) => {
+            const [sceneObject] = await sdk.Scene.createObjects(1);
+            let isAnimatedSecurityCamera = (obj.object === "security_camera");
+            let isNestThermostat = (obj.object === "nest_thermostat");
+            let isSmarterplanPromotionalVideo = (obj.object === 'video');
+            let isAzimuthalCrown = (obj.object === 'azimuth');
+            const modelNode = sceneObject.addNode();
+            let component = null;
+            const initial = {
+                url: `/assets/3Dobjects/objects/${obj.object}${obj.format.indexOf('.') === -1 ? '.' + obj.format : obj.format}`,
+                localRotation: { "x": 0, "y": 0, "z": 0 },
+                localPosition: { "x": 0, "y": 0, "z": 0 },
+                visible: true,
+                colliderEnabled: true
+            };
+            switch (obj.format) {
+                case '.obj':
+                case 'obj':
+                    component = modelNode.addComponent('mp.objLoader', initial);
+                    break;
+                case '.fbx':
+                case 'fbx':
+                    component = modelNode.addComponent('mp.fbxLoader', initial);
+                    break;
+                case '.gltf':
+                case 'gltf':
+                case '.glb':
+                case 'glb':
+                    component = modelNode.addComponent('mp.gltfLoader', initial);
+                    break;
+                case '.dae':
+                case 'dae':
+                    component = modelNode.addComponent('mp.daeLoader', initial);
+                    break;
+                default:
+                    console.log('Format not supported');
+                    break;
+            }
+            if (this.noLightForObjects) {
+                const lightsNode = sceneObject.addNode();
+                lightsNode.addComponent('mp.ambientLight', {
+                    intensity: 1,
+                    color: { r: 1.0, g: 1.0, b: 1.0 },
+                });
+                this.noLightForObjects = false;
+            }
+            modelNode.obj3D.position.set(obj.position.x, obj.position.y, obj.position.z);
+            modelNode.obj3D.rotation.set(obj.rotation.x, obj.rotation.y, obj.rotation.z);
+            modelNode.obj3D.scale.set(obj.scale.x, obj.scale.y, obj.scale.z);
+            if (isAzimuthalCrown) {
+                this.azimuthalCrown = modelNode;
+            }
+            if (mode && !isNestThermostat) {
+                this.attachGizmoControlTo3DObject(sdk, modelNode, sceneObject, mode, true, true).catch((e) => console.log(e));
+            }
+            if (this.lastObject3D && typeof this.lastObject3D.id === 'string') {
+                modelNode.obj3D.uuid = this.lastObject3D.id;
+            }
+            else if (obj.id) {
+                modelNode.obj3D.uuid = obj.id;
+            }
+            this.lastObject3D = modelNode.obj3D;
+            this.dictionnaryObjects3D.set(modelNode.obj3D.uuid, modelNode);
+            this.dictionnarySceneObjects3D.set(modelNode.obj3D.uuid, sceneObject);
+            if (isAnimatedSecurityCamera) {
+                const animator = modelNode.addComponent('mp.securityCamera', {
+                    "nearPlane": 0.1, "farPlane": 10, "horizontalFOV": 52, "aspect": 1.7777777777777777,
+                    "localPosition": { "x": 0.3, "y": 0.18, "z": 0 },
+                    "localRotation": { "x": -15, "y": -90, "z": 0 },
+                    "color": 65280, "panPeriod": 5, "panAngle": -45
+                });
+                this.securityCameraAnimator = animator;
+                if (!obj.viewFrustum) {
+                    setTimeout(() => { animator.toggleViewFrustum(); }, 1000);
+                }
+            }
+            if (isNestThermostat) {
+                const cv = new CanvasRenderer();
+                cv.onInit();
+                const plane = new PlaneRenderer();
+                plane.outputs = { objectRoot: new Object3D(), collider: new Object3D() };
+                const inputTexture = cv.outputs.texture;
+                plane.setRootScene(this.threeJSScene);
+                plane.onInit(modelNode, inputTexture);
+                const sc = new NestThermostat();
+                sc.setComponent(component, plane, cv);
+                sc.setRootScene(this.threeJSScene);
+                sc.onInit(modelNode, plane, inputTexture);
+                cv.setCanvasNestThermostatPainter(sc);
+                setTimeout(() => { sc.inputs.loadingState = "Loaded"; sc.onInputsUpdated(); }, 5000);
+            }
+            if (isSmarterplanPromotionalVideo) {
+                const sc = new TvPlayer();
+                sc.setComponent(component);
+                sc.onInit(modelNode);
+                setTimeout(() => { sc.inputs.loadingState = "Loaded"; sc.onInputsUpdated(); }, 5000);
+            }
+            sceneObject.start();
+            resolve(this.lastObject3D);
+        });
+    }
+    async deleteObject3D(uuid) {
+        const obj = this.dictionnaryObjects3D.get(uuid);
+        if (obj)
+            obj.obj3D.visible = false;
+    }
+    getObject3DModelNodeFromDictionnary(uuid) {
+        let obj = this.dictionnaryObjects3D.get(uuid);
+        if (!obj)
+            return null;
+        if (obj.obj3D.uuid != uuid) {
+            obj.obj3D.uuid = uuid;
+        }
+        return obj;
+    }
+    toggleObjectVisibility(objectId) {
+        let obj = this.dictionnaryObjects3D.get(objectId);
+        if (obj)
+            obj.obj3D.visible = !obj.obj3D.visible;
+    }
+    isObjectVisible(objectId) {
+        let obj = this.dictionnaryObjects3D.get(objectId);
+        return obj ? obj.obj3D.visible : false;
+    }
+    async pointCameraTo3DObject(sdk, objectId, createTagCallback, goToTagCallback, deleteLastTagCallback, getTagFromElementId) {
+        let obj = this.dictionnaryObjects3D.get(objectId);
+        const poiObject = {
+            coordinate: JSON.stringify(obj.obj3D.position),
+            type: PoiType.OBJECT3D,
+            elementID: objectId,
+        };
+        const objectDb = { id: objectId };
+        try {
+            await createTagCallback(PoiType.OBJECT3D, objectDb, poiObject);
+        }
+        catch (err) { }
+        let result = getTagFromElementId(objectId);
+        await goToTagCallback(result.tag);
+        deleteLastTagCallback();
+    }
+    getSceneNodeFromObject3DId(uuid) {
+        return this.dictionnarySceneObjects3D.get(uuid);
+    }
+    async displayAzimutalCrown(poseCamera) {
+        if (this.azimuthalCrown && poseCamera) {
+            this.azimuthalCrown.obj3D.position.set(poseCamera.position.x, poseCamera.position.y, poseCamera.position.z);
+        }
+    }
+    async attachGizmoControlTo3DObject(sdk, modelNode, sceneObject, mode, visible, isNewObject) {
+        let node = sceneObject.addNode();
+        if (!node) {
+            const [newSceneObject] = await sdk.Scene.createObjects(1);
+            node = newSceneObject.addNode();
+        }
+        const myControl = node.addComponent('mp.transformControls');
+        node.start();
+        myControl.transformControls.visible = visible;
+        myControl.inputs.selection = modelNode;
+        myControl.inputs.mode = mode;
+        modelNode.obj3D.controls = myControl;
+        if (isNewObject) {
+            if (!this.lastObject3D || !this.lastObject3D.controls) {
+                try {
+                    modelNode.obj3D.uuid = this.lastObject3D.uuid || this.lastObject3D.id;
+                }
+                catch (e) {
+                    console.log(`id obj in Scene was not assigned to id from DB`);
+                }
+                this.lastObject3D = modelNode.obj3D;
+            }
+        }
+        else {
+            this.lastObject3D = modelNode.obj3D;
+        }
+        return modelNode;
+    }
+    removeGizmoFromLastObject() {
+        if (this.lastObject3D && this.lastObject3D.controls) {
+            this.lastObject3D.controls.transformControls.visible = false;
+            this.lastObject3D.controls.transformControls.dispose();
+            this.lastObject3D.controls = null;
+        }
+    }
+    toggleViewFrustum() {
+        if (this.securityCameraAnimator) {
+            this.securityCameraAnimator.toggleViewFrustum();
+        }
+    }
+    clear() {
+        this.dictionnaryObjects3D.clear();
+        this.dictionnarySceneObjects3D.clear();
+        this.lastObject3D = null;
+        this.azimuthalCrown = null;
+        this.securityCameraAnimator = null;
+        this.noLightForObjects = true;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportObject3DService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportObject3DService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportObject3DService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"matterport-object3d.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-smarterplan-core/src/lib/services/matterport-object3d.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { IObject3D, PoiType, POI, DbObjectType } from '../types.service';\r\nimport { Object3D } from 'three';\r\nimport { NestThermostat } from '../matterport-extensions/nest-thermostat/NestThermostat';\r\nimport { PlaneRenderer } from '../matterport-extensions/nest-thermostat/PlaneRenderer';\r\nimport { CanvasRenderer } from \"../matterport-extensions/nest-thermostat/CanvasRenderer\";\r\nimport { TvPlayer } from \"../matterport-extensions/tv-player/TvPlayer\";\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class MatterportObject3DService {\r\n  public dictionnaryObjects3D: Map<string, any> = new Map();\r\n  public dictionnarySceneObjects3D: Map<string, any> = new Map();\r\n  public lastObject3D: any; // Three JS object\r\n  public objectControl: any;\r\n  public securityCameraAnimator: any;\r\n  public azimuthalCrown: any;\r\n  public threeJSScene: any;\r\n  public noLightForObjects = true;\r\n\r\n  constructor() { }\r\n\r\n  async init3DObjectViewer(sdk: any): Promise<void> {\r\n    const [sceneObject] = await sdk.Scene.createObjects(1);\r\n    const node = sceneObject.addNode();\r\n    node.start();\r\n    this.threeJSScene = node.obj3D.parent;\r\n\r\n    const nodeControl = sceneObject.addNode();\r\n    this.objectControl = nodeControl.addComponent('mp.transformControls');\r\n    nodeControl.start();\r\n  }\r\n\r\n  async add3DObject(\r\n    sdk: any,\r\n    obj: IObject3D,\r\n    mode?: 'translate' | 'rotate'\r\n  ): Promise<any> {\r\n    return new Promise(async (resolve) => {\r\n      const [sceneObject] = await sdk.Scene.createObjects(1);\r\n\r\n      let isAnimatedSecurityCamera = (obj.object === \"security_camera\");\r\n      let isNestThermostat = (obj.object === \"nest_thermostat\");\r\n      let isSmarterplanPromotionalVideo = (obj.object === 'video');\r\n      let isAzimuthalCrown = (obj.object === 'azimuth');\r\n\r\n      const modelNode = sceneObject.addNode();\r\n      let component = null;\r\n      const initial = {\r\n        url: `/assets/3Dobjects/objects/${obj.object}${obj.format.indexOf('.') === -1 ? '.' + obj.format : obj.format}`,\r\n        localRotation: { \"x\": 0, \"y\": 0, \"z\": 0 },\r\n        localPosition: { \"x\": 0, \"y\": 0, \"z\": 0 },\r\n        visible: true,\r\n        colliderEnabled: true\r\n      };\r\n\r\n      switch (obj.format) {\r\n        case '.obj': case 'obj': component = modelNode.addComponent('mp.objLoader', initial); break;\r\n        case '.fbx': case 'fbx': component = modelNode.addComponent('mp.fbxLoader', initial); break;\r\n        case '.gltf': case 'gltf': case '.glb': case 'glb': component = modelNode.addComponent('mp.gltfLoader', initial); break;\r\n        case '.dae': case 'dae': component = modelNode.addComponent('mp.daeLoader', initial); break;\r\n        default: console.log('Format not supported'); break;\r\n      }\r\n\r\n      if (this.noLightForObjects) {\r\n        const lightsNode = sceneObject.addNode();\r\n        lightsNode.addComponent('mp.ambientLight', {\r\n          intensity: 1,\r\n          color: { r: 1.0, g: 1.0, b: 1.0 },\r\n        });\r\n        this.noLightForObjects = false;\r\n      }\r\n\r\n      modelNode.obj3D.position.set(obj.position.x, obj.position.y, obj.position.z);\r\n      modelNode.obj3D.rotation.set(obj.rotation.x, obj.rotation.y, obj.rotation.z);\r\n      modelNode.obj3D.scale.set(obj.scale.x, obj.scale.y, obj.scale.z);\r\n\r\n      if (isAzimuthalCrown) {\r\n        this.azimuthalCrown = modelNode;\r\n      }\r\n\r\n      if (mode && !isNestThermostat) {\r\n        this.attachGizmoControlTo3DObject(sdk, modelNode, sceneObject, mode, true, true).catch((e) => console.log(e));\r\n      }\r\n\r\n      if (this.lastObject3D && typeof this.lastObject3D.id === 'string') {\r\n        modelNode.obj3D.uuid = this.lastObject3D.id;\r\n      } else if (obj.id) {\r\n        modelNode.obj3D.uuid = obj.id;\r\n      }\r\n      this.lastObject3D = modelNode.obj3D;\r\n\r\n      this.dictionnaryObjects3D.set(modelNode.obj3D.uuid, modelNode);\r\n      this.dictionnarySceneObjects3D.set(modelNode.obj3D.uuid, sceneObject);\r\n\r\n      if (isAnimatedSecurityCamera) {\r\n        const animator = modelNode.addComponent('mp.securityCamera', {\r\n          \"nearPlane\": 0.1, \"farPlane\": 10, \"horizontalFOV\": 52, \"aspect\": 1.7777777777777777,\r\n          \"localPosition\": { \"x\": 0.3, \"y\": 0.18, \"z\": 0 },\r\n          \"localRotation\": { \"x\": -15, \"y\": -90, \"z\": 0 },\r\n          \"color\": 65280, \"panPeriod\": 5, \"panAngle\": -45\r\n        });\r\n        this.securityCameraAnimator = animator;\r\n        if (!obj.viewFrustum) {\r\n          setTimeout(() => { animator.toggleViewFrustum(); }, 1000);\r\n        }\r\n      }\r\n\r\n      if (isNestThermostat) {\r\n        const cv = new CanvasRenderer(); cv.onInit();\r\n        const plane = new PlaneRenderer();\r\n        plane.outputs = { objectRoot: new Object3D(), collider: new Object3D() };\r\n        const inputTexture = cv.outputs.texture;\r\n        plane.setRootScene(this.threeJSScene);\r\n        plane.onInit(modelNode, inputTexture);\r\n        const sc = new NestThermostat();\r\n        sc.setComponent(component, plane, cv);\r\n        sc.setRootScene(this.threeJSScene);\r\n        sc.onInit(modelNode, plane, inputTexture);\r\n        cv.setCanvasNestThermostatPainter(sc);\r\n        setTimeout(() => { sc.inputs.loadingState = \"Loaded\"; sc.onInputsUpdated(); }, 5000);\r\n      }\r\n\r\n      if (isSmarterplanPromotionalVideo) {\r\n        const sc = new TvPlayer(); sc.setComponent(component); sc.onInit(modelNode);\r\n        setTimeout(() => { sc.inputs.loadingState = \"Loaded\"; sc.onInputsUpdated(); }, 5000);\r\n      }\r\n\r\n      sceneObject.start();\r\n      resolve(this.lastObject3D);\r\n    });\r\n  }\r\n\r\n  async deleteObject3D(uuid: string): Promise<void> {\r\n    const obj = this.dictionnaryObjects3D.get(uuid);\r\n    if (obj) obj.obj3D.visible = false;\r\n  }\r\n\r\n  getObject3DModelNodeFromDictionnary(uuid: string): any {\r\n    let obj = this.dictionnaryObjects3D.get(uuid);\r\n    if (!obj) return null;\r\n    if (obj.obj3D.uuid != uuid) {\r\n      obj.obj3D.uuid = uuid;\r\n    }\r\n    return obj;\r\n  }\r\n\r\n  toggleObjectVisibility(objectId: any) {\r\n    let obj = this.dictionnaryObjects3D.get(objectId);\r\n    if (obj) obj.obj3D.visible = !obj.obj3D.visible;\r\n  }\r\n\r\n  isObjectVisible(objectId: any): boolean {\r\n    let obj = this.dictionnaryObjects3D.get(objectId);\r\n    return obj ? obj.obj3D.visible : false;\r\n  }\r\n\r\n  async pointCameraTo3DObject(sdk: any, objectId: any, createTagCallback: (tagType: PoiType, object: DbObjectType, poi: POI) => Promise<any>, goToTagCallback: (sid: string) => Promise<any>, deleteLastTagCallback: () => void, getTagFromElementId: (id: string) => { tag: string, sweep: string }) {\r\n    let obj = this.dictionnaryObjects3D.get(objectId);\r\n    const poiObject = {\r\n      coordinate: JSON.stringify(obj.obj3D.position),\r\n      type: PoiType.OBJECT3D,\r\n      elementID: objectId,\r\n    } as POI;\r\n    const objectDb = { id: objectId } as DbObjectType;\r\n    try {\r\n      await createTagCallback(PoiType.OBJECT3D, objectDb, poiObject);\r\n    } catch (err: any) { }\r\n\r\n    let result = getTagFromElementId(objectId);\r\n    await goToTagCallback(result.tag);\r\n    deleteLastTagCallback();\r\n  }\r\n\r\n  getSceneNodeFromObject3DId(uuid: string): any {\r\n    return this.dictionnarySceneObjects3D.get(uuid);\r\n  }\r\n\r\n  async displayAzimutalCrown(poseCamera: any) {\r\n    if (this.azimuthalCrown && poseCamera) {\r\n      this.azimuthalCrown.obj3D.position.set(poseCamera.position.x, poseCamera.position.y, poseCamera.position.z)\r\n    }\r\n  }\r\n\r\n  async attachGizmoControlTo3DObject(\r\n    sdk: any,\r\n    modelNode: any,\r\n    sceneObject: any,\r\n    mode: 'translate' | 'rotate' | 'scale',\r\n    visible: boolean,\r\n    isNewObject: boolean\r\n  ): Promise<any> {\r\n    let node = sceneObject.addNode();\r\n    if (!node) {\r\n      const [newSceneObject] = await sdk.Scene.createObjects(1);\r\n      node = newSceneObject.addNode();\r\n    }\r\n    const myControl = node.addComponent('mp.transformControls');\r\n    node.start();\r\n    myControl.transformControls.visible = visible;\r\n    myControl.inputs.selection = modelNode;\r\n    myControl.inputs.mode = mode;\r\n    modelNode.obj3D.controls = myControl;\r\n    if (isNewObject) {\r\n      if (!this.lastObject3D || !this.lastObject3D.controls) {\r\n        try {\r\n          modelNode.obj3D.uuid = this.lastObject3D.uuid || this.lastObject3D.id;\r\n        } catch (e) {\r\n          console.log(`id obj in Scene was not assigned to id from DB`);\r\n        }\r\n        this.lastObject3D = modelNode.obj3D;\r\n      }\r\n    } else {\r\n      this.lastObject3D = modelNode.obj3D;\r\n    }\r\n    return modelNode;\r\n  }\r\n\r\n  removeGizmoFromLastObject(): void {\r\n    if (this.lastObject3D && this.lastObject3D.controls) {\r\n      this.lastObject3D.controls.transformControls.visible = false;\r\n      this.lastObject3D.controls.transformControls.dispose();\r\n      this.lastObject3D.controls = null;\r\n    }\r\n  }\r\n\r\n  toggleViewFrustum(): void {\r\n    if (this.securityCameraAnimator) {\r\n      this.securityCameraAnimator.toggleViewFrustum();\r\n    }\r\n  }\r\n\r\n  clear() {\r\n    this.dictionnaryObjects3D.clear();\r\n    this.dictionnarySceneObjects3D.clear();\r\n    this.lastObject3D = null;\r\n    this.azimuthalCrown = null;\r\n    this.securityCameraAnimator = null;\r\n    this.noLightForObjects = true;\r\n  }\r\n}\r\n"]}