@smarterplan/ngx-smarterplan-core 1.4.6 → 1.4.7

package/fesm2022/smarterplan-ngx-smarterplan-core.mjs

@@ -2,7 +2,7 @@ import * as i0 from '@angular/core';
 import { Injectable, Input, Component, Inject, EventEmitter, isDevMode, Output, Pipe, ViewChild, NgModule } from '@angular/core';
 import * as i1 from '@ngx-translate/core';
 import { TranslateModule } from '@ngx-translate/core';
-import { Subject, takeUntil, Observable } from 'rxjs';
+import { Subject, BehaviorSubject, takeUntil, Observable } from 'rxjs';
 import * as i1$2 from '@ng-bootstrap/ng-bootstrap';
 import { NgbDate, NgbModule } from '@ng-bootstrap/ng-bootstrap';
 import * as i1$1 from '@angular/router';
@@ -1964,62 +1964,43 @@ class MattertagData {
     mediaSrc;
     sweepID;
     customIconIndex = 0;
-    rotation;
+    rotation = null;
     poi;
+    matterportSid = null;
     constructor(type) {
         this.setType(type);
     }
-    /*-----------------------------------------------------------------------------
-        Setters
-    ------------------------------------------------------------------------------*/
-    setType(type) {
-        this.type = type;
-    }
+    /*---------------------------------------------------------------------------
+      Setters
+    ---------------------------------------------------------------------------*/
+    setType(type) { this.type = type; }
     setObject(object, tagType) {
         this.object = object;
         this.setElementID(object.id);
         this.setType(tagType);
     }
-    setElementID(ticketID) {
-        this.elementID = ticketID;
-    }
+    setElementID(id) { this.elementID = id; }
     setPosition(position) {
         this.position = position;
     }
     setNormal(normal) {
         this.normal = normal;
     }
-    setMediaSource(source) {
-        this.mediaSrc = source;
-    }
-    setSweepID(sweepID) {
-        this.sweepID = sweepID;
-    }
-    setRotation(rotation) {
-        this.rotation = rotation;
-    }
-    setPoi(poi) {
-        this.poi = poi;
-    }
-    /*-----------------------------------------------------------------------------
-        Getters
-    ------------------------------------------------------------------------------*/
-    // MattertagData
+    setMediaSource(source) { this.mediaSrc = source; }
+    setSweepID(sweepID) { this.sweepID = sweepID; }
+    setRotation(rotation) { this.rotation = rotation; }
+    setPoi(poi) { this.poi = poi; }
+    setMatterportSid(sid) { this.matterportSid = sid; }
+    /*---------------------------------------------------------------------------
+      Getters
+    ---------------------------------------------------------------------------*/
     getData() {
         let label = "New Tag";
         switch (this.type) {
             case PoiType.TICKET:
-                label = this.object ? "" : "New Tag"; // if the object exists we inject title in html
-                break;
             case PoiType.EQUIPMENT:
-                label = this.object ? "" : "New Tag";
-                break;
             case PoiType.MEASURE:
-                label = this.object ? "" : "New Tag";
-                break;
             case PoiType.DATA:
-                label = this.object ? "" : "New Tag";
-                break;
             case PoiType.DESK:
                 label = this.object ? "" : "New Tag";
                 break;
@@ -2031,47 +2012,73 @@ class MattertagData {
                 break;
             default:
                 label = "New Tag";
-                break;
         }
-        const data = {
+        return {
             label,
             description: "",
-            anchorPosition: {
-                x: this.position.x * 1,
-                y: this.position.y * 1,
-                z: this.position.z * 1,
-            },
-            stemVector: {
-                x: this.normal.x * 0.3,
-                y: this.normal.y * 0.3,
-                z: this.normal.z * 0.3,
-            },
-            color: {
-                // blue disc
-                r: 0,
-                g: 0,
-                b: 1,
-            },
-            media: {
-                type: "mattertag.media.none",
-                src: ""
-            },
+            anchorPosition: { ...this.position },
+            stemVector: this.getStemVector(),
+            color: { r: 1, g: 1, b: 1 },
+        };
+    }
+    /**
+     * Get the descriptor for sdk.Tag.add(...descriptor)
+     * Format : [{ label, description, anchorPosition, stemVector, color, id? }]
+     * If matterportSid is defined (already known tag) we send it so the SDK
+     * reuse it instead of trying to create a new one and generate an error : "already in use".
+     */
+    getMattertagDescriptor() {
+        const base = this.getData();
+        const descriptor = { ...base };
+        if (this.matterportSid) {
+            descriptor['id'] = this.matterportSid;
+        }
+        return [descriptor];
+    }
+    /**
+     * Get data for sdk.Tag.editPosition() or sdk.Tag.editBillboard().
+     */
+    getTagSdkData() {
+        return {
+            anchorPosition: { ...this.position },
+            stemVector: this.getStemVector(),
         };
-        return data;
     }
-    getType() {
-        return this.type;
+    /** Load the matterportSid from the poi metadata */
+    loadSidFromPoi(poi) {
+        if (!poi?.metadata)
+            return;
+        try {
+            const meta = JSON.parse(poi.metadata);
+            if (meta?.sid && typeof meta.sid === 'string') {
+                this.matterportSid = meta.sid;
+            }
+        }
+        catch { }
     }
-    getNormal() {
-        return this.normal;
+    /** Get the stem vector for the tag */
+    getStemVector() {
+        return {
+            x: this.normal.x * 0.3,
+            y: this.normal.y * 0.3,
+            z: this.normal.z * 0.3,
+        };
     }
+    getType() { return this.type; }
+    getNormal() { return this.normal; }
+    getPosition() { return this.position; }
+    getSweepID() { return this.sweepID; }
+    getObject() { return this.object; }
+    getRotation() { return this.rotation; }
+    getPoi() { return this.poi; }
+    getMatterportSid() { return this.matterportSid; }
+    /** Get the action mode for the tag */
     getCallbackActionMode() {
         switch (this.type) {
             case PoiType.TICKET:
                 return this.object ? MattertagActionMode.POSITION_TICKET : MattertagActionMode.ADD_TICKET;
             case PoiType.OBJECT3D:
                 return MattertagActionMode.POSITION_OBJECT3D;
-            // return this.object ? MattertagActionMode.POSITION_OBJECT3D : MattertagActionMode.ADD_OBJECT3D;
             case PoiType.EQUIPMENT:
                 return this.object ? MattertagActionMode.POSITION_EQUIPMENT : MattertagActionMode.ADD_EQUIPMENT;
             case PoiType.DATA:
@@ -2084,448 +2091,1471 @@ class MattertagData {
                 return MattertagActionMode.ADD_TICKET;
         }
     }
+    /** Get the icon for the tag */
     getIcon() {
         switch (this.type) {
-            case PoiType.TICKET:
-                return "icon_ticket.png";
-            case PoiType.EQUIPMENT:
-                return "icon_equipment.png";
-            case PoiType.OBJECT3D:
-                return "icon_object3d.png";
+            case PoiType.TICKET: return "icon_ticket.png";
+            case PoiType.EQUIPMENT: return "icon_equipment.png";
+            case PoiType.OBJECT3D: return "icon_object3d.png";
+            case PoiType.MEASURE: return "icon_measure.png";
+            case PoiType.DATA: return "icon_data.png";
+            case PoiType.DESK: return "icon_data.png";
+            case PoiType.ROOM: return "";
+            default: return "";
         }
-        return "";
     }
+    /** Get the coordinate string for the tag */
     getCoordinateString() {
         return JSON.stringify({
             x: this.position.x,
             y: this.position.y,
             z: this.position.z,
-            xRotation: this.rotation ? this.rotation.x : null,
-            yRotation: this.rotation ? this.rotation.y : null,
+            xRotation: this.rotation?.x ?? null,
+            yRotation: this.rotation?.y ?? null,
         });
     }
+    /** Get the metadata string for the tag */
     getMetadataString() {
         return JSON.stringify({
             icon: this.getIcon(),
             normal: this.getNormal(),
+            sid: this.matterportSid,
         });
     }
-    getSweepID() {
-        return this.sweepID;
-    }
-    getObject() {
-        return this.object;
-    }
-    getRotation() {
-        return this.rotation;
-    }
-    getPoi() {
-        return this.poi;
-    }
 }
 
-const HoverEvent$1 = 'hover';
-const UnhoverEvent$1 = 'unhover';
-const RepaintEvent = 'repaint';
-class NestThermostat extends SceneComponent {
-    cv = null;
-    planeRenderer = null;
-    rootScene = null;
-    mixer = null;
-    onEnterClip = null;
-    mesh = null;
-    currentTime = 0;
-    nextUpdate = 0;
-    temperature = 0;
-    tempChangeRange = 5;
-    component;
-    inputs = {
-        loadingState: 'Idle',
-        texture: null,
-        updateInterval: 1000,
-    };
-    outputs = {
-        painter: null,
-        visible: false,
+class BaseVisibilityService {
+    detailShowing = new Subject();
+    isChangePositionVisible = new Subject();
+    constructor() { }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseVisibilityService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseVisibilityService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseVisibilityService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+class MatterportMeasurementService {
+    router;
+    lastMeasure = [];
+    distancesLastMeasure = [];
+    lastScreenshotUri;
+    resolution = {
+        width: 500,
+        height: 600,
     };
-    events = {
-        [HoverEvent$1]: true,
-        [UnhoverEvent$1]: true,
+    visibility = {
+        mattertags: false,
+        sweeps: true,
     };
-    onInit(modelNode, plane, inputTexture) {
-        if (!this.context) {
-            this.context = {
-                root: modelNode
-            };
-        }
-        this.inputs.texture = inputTexture;
-        const root = this.context.root;
-        const THREE = this.context.three;
-        this.planeRenderer = plane;
-        this.planeRenderer.outputs.objectRoot.translateZ(0.05);
-        this.planeRenderer.outputs.objectRoot.translateY(0.4);
-        this.planeRenderer.outputs.objectRoot.scale.set(0.5, 0.5, 0.5);
-        // planeRenderer.inputs.localPosition.z = 0.05;
-        // planeRenderer.inputs.localPosition.y = 0.4;
-        // planeRenderer.inputs.localScale = {x: 0.5, y: 0.5, z: 0.5};
-        this.outputs.painter = this;
-        this.mixer = new AnimationMixer(this.planeRenderer.outputs.objectRoot);
-        const tm = 0.2;
-        const positionTrack = new VectorKeyframeTrack('.scale', [0, tm], [
-            0, 0, 0,
-            0.5, 0.5, 0.5
-        ], InterpolateSmooth);
-        this.onEnterClip = new AnimationClip(null, tm, [positionTrack]);
+    constructor(router) {
+        this.router = router;
     }
-    onInputsUpdated() {
-        if (this.inputs.loadingState === 'Loaded') {
-            const lines = [];
-            //@ts-ignore
-            this.context.root.obj3D.traverse((obj) => {
-                // we dont want line segments, track them and remove them.
-                if (obj.type === 'LineSegments') {
-                    lines.push(obj);
-                }
-                else if (obj.type === 'Mesh') {
-                    this.mesh = obj;
-                    const materials = this.mesh.material;
-                    materials.forEach((m, idx) => {
-                        if (m && m.map.source.data.outerHTML.indexOf('_5b76dbe388862300126c1e14') !== -1) {
-                            const newMaterial = new MeshBasicMaterial({ map: this.inputs.texture });
-                            this.mesh.material[idx] = newMaterial;
-                        }
-                    });
-                }
-            });
-            // remove the line segments.
-            lines.forEach((line) => {
-                line.parent.remove(line);
+    /**
+     * 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`]);
             });
         }
     }
-    onEvent(eventType, eventData) {
-        if (eventType === HoverEvent$1) {
-            const data = eventData;
-            if (data.hover) {
-                this.outputs.visible = true;
-                const onEnterAction = this.mixer.clipAction(this.onEnterClip);
-                onEnterAction.stop();
-                onEnterAction.loop = LoopOnce;
-                onEnterAction.clampWhenFinished = true;
-                onEnterAction.play();
-            }
-            else {
-                this.outputs.visible = false;
-            }
-        }
+    getLastDistances() {
+        return this.distancesLastMeasure;
     }
-    paint(context2d, size) {
-        const x = 490;
-        const y = 490;
-        context2d.fillStyle = 'black';
-        context2d.beginPath();
-        context2d.arc(x, y, 400, 0, Math.PI * 2);
-        context2d.fill();
-        context2d.fillStyle = '#CF5300';
-        context2d.beginPath();
-        context2d.arc(x, y, 300, 0, Math.PI * 2);
-        context2d.fill();
-        context2d.beginPath();
-        context2d.strokeStyle = 'orange';
-        context2d.arc(x, y, 240, 0.75 * Math.PI, 0.25 * Math.PI);
-        context2d.lineCap = 'butt';
-        context2d.lineWidth = 80;
-        context2d.stroke();
-        context2d.fillStyle = 'white';
-        context2d.font = '220px Arial';
-        context2d.fillText(`${this.temperature}`, x - 115, y + 75);
-        this.outputs.visible = true;
+    /**
+     * 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();
+        });
     }
-    onTick(delta) {
-        this.currentTime += delta;
-        if (this.mixer) {
-            this.mixer.update(delta / 1000);
-        }
-        if (this.currentTime > this.nextUpdate) {
-            this.nextUpdate += this.inputs.updateInterval;
-            this.temperature += (Math.random() * this.tempChangeRange);
-            this.temperature = Math.trunc(this.temperature);
-            if (this.temperature > 99) {
-                this.temperature = 99;
-                this.tempChangeRange = -this.tempChangeRange;
-            }
-            if (this.temperature < 10) {
-                this.temperature = 10;
-                this.tempChangeRange = -this.tempChangeRange;
-            }
-            this.component.notify(RepaintEvent);
-            this.cv.repaint();
-        }
+    getScreenShotUri() {
+        return this.lastScreenshotUri;
     }
-    setComponent(component, plane, cv) {
-        component.onTick = this.onTick.bind(this);
-        // plane.onTick = this.onTick.bind(this);
-        this.cv = cv;
-        this.component = component;
-        this.context = component.context;
+    getLastMeasurement(poseCamera) {
+        return {
+            measure: this.lastMeasure,
+            sweep: poseCamera.sweep,
+        };
     }
-    setRootScene(rootScene) {
-        this.rootScene = rootScene;
+    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$1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportMeasurementService, providedIn: 'root' });
 }
-const nestThermostatType = 'mp.nestThermostat';
-const makeNestThermostat = function () {
-    return new NestThermostat();
-};
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportMeasurementService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1$1.Router }] });
 
-class PlaneRenderer extends SceneComponent {
-    rootScene = null;
-    mesh;
-    pivotNode;
-    inputs = {
-        texture: null,
-        aspect: 1,
-        transparent: true,
-        visible: true,
-        opacity: 1,
-        polygonOffset: false,
-        polygonOffsetFactor: 0,
-        polygonOffsetUnits: 0,
-        localScale: { x: 1, y: 1, z: 1 },
-        localPosition: { x: 0, y: 0, z: 0 },
+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: () => [] });
+
+class MatterportPointerService {
+    pointerButton = null;
+    getCursorPositionButton = null;
+    textDisplayCursorPositionPanel = null;
+    cursorPositionButtonDisplayed = false;
+    intervalCursorPointerPosition;
+    timerPointer;
+    oldPoseMatterportPosition;
+    constructor() { }
+    init(container, pointerButton, getCursorPositionButton, textDisplayCursorPositionPanel, callbacks) {
+        this.pointerButton = pointerButton;
+        this.getCursorPositionButton = getCursorPositionButton;
+        this.textDisplayCursorPositionPanel = textDisplayCursorPositionPanel;
+        if (this.pointerButton) {
+            this.pointerButton.addEventListener('click', callbacks.onLeftClick);
+            this.pointerButton.addEventListener('contextmenu', callbacks.onRightClick);
+        }
+        if (this.getCursorPositionButton) {
+            this.getCursorPositionButton.addEventListener('click', callbacks.onMiddleClick);
+        }
+    }
+    startPointerTrick(sdk, container, getPose, getPoseCamera, getInteractionMode, getMattertagToFollow) {
+        this.timerPointer = setInterval(() => {
+            this.updatePointerTrick(sdk, container, getPose(), getPoseCamera(), getInteractionMode(), getMattertagToFollow());
+        }, 50);
+    }
+    stopPointerTrick() {
+        clearInterval(this.timerPointer);
+    }
+    startAdminCursorTracker(sdk, container, getPose, getPoseCamera) {
+        if (!!this.getCursorPositionButton &&
+            (document.location.href.indexOf('dev') !== -1 || document.location.href.indexOf('localhost') !== -1)) {
+            this.intervalCursorPointerPosition = setInterval(() => {
+                const poseMatterport = getPose();
+                if (!poseMatterport)
+                    return;
+                const nextShow = poseMatterport.time + 1000;
+                if (new Date().getTime() > nextShow) {
+                    if (this.cursorPositionButtonDisplayed)
+                        return;
+                    const size = {
+                        w: container.clientWidth,
+                        h: container.clientHeight,
+                    };
+                    const coord = sdk.Conversion.worldToScreen(poseMatterport.position, getPoseCamera(), size);
+                    this.getCursorPositionButton.style.left = `${coord.x - 25}px`;
+                    this.getCursorPositionButton.style.top = `${coord.y - 22}px`;
+                    this.getCursorPositionButton.style.display = 'block';
+                    this.cursorPositionButtonDisplayed = true;
+                }
+            }, 500);
+        }
+    }
+    stopAdminCursorTracker() {
+        clearInterval(this.intervalCursorPointerPosition);
+    }
+    updatePointerTrick(sdk, container, poseMatterport, poseCamera, interactionMode, mattertagToFollow) {
+        if (!this.pointerButton)
+            return;
+        if (interactionMode !== 0 && // ViewerInteractions.DEFAULT
+            mattertagToFollow &&
+            poseMatterport &&
+            this.getDistPosition(sdk, container, poseCamera, poseMatterport.position, this.oldPoseMatterportPosition) > 25) {
+            this.pointerButton.style.display = 'none';
+            const size = {
+                w: container.clientWidth,
+                h: container.clientHeight,
+            };
+            const coords = sdk.Conversion.worldToScreen(poseMatterport.position, poseCamera, size);
+            this.pointerButton.style.left = `${coords.x * Math.sign(coords.x) - 25}px`;
+            this.pointerButton.style.top = `${coords.y * Math.sign(coords.x) - 25}px`;
+            this.oldPoseMatterportPosition = {
+                ...poseMatterport.position,
+            };
+        }
+        else {
+            this.pointerButton.style.display = 'block';
+        }
+    }
+    getDistPosition(sdk, container, poseCamera, pos1, pos2) {
+        if (!pos1 || !pos2)
+            return 100; // Force update if one is missing
+        const size = {
+            w: container.clientWidth,
+            h: container.clientHeight,
+        };
+        const coords1 = sdk.Conversion.worldToScreen(pos1, poseCamera, size);
+        const coords2 = sdk.Conversion.worldToScreen(pos2, poseCamera, size);
+        return Math.sqrt((coords1.x - coords2.x) ** 2 + (coords1.y - coords2.y) ** 2);
+    }
+    updateCursorDisplay(poseMatterport) {
+        if (this.textDisplayCursorPositionPanel && poseMatterport) {
+            this.textDisplayCursorPositionPanel.innerHTML = `position:
+           ${pointToString(poseMatterport.position)}\n
+           normal:
+           ${pointToString(poseMatterport.normal)}\n
+           floorId:
+           ${poseMatterport.floorId}`;
+            if (this.getCursorPositionButton) {
+                this.getCursorPositionButton.style.display = 'none';
+            }
+        }
+    }
+    clear(callbacks) {
+        if (this.pointerButton) {
+            this.pointerButton.removeEventListener('click', callbacks.onLeftClick);
+            this.pointerButton.removeEventListener('contextmenu', callbacks.onRightClick);
+        }
+        if (this.getCursorPositionButton) {
+            this.getCursorPositionButton.removeEventListener('click', callbacks.onMiddleClick);
+        }
+        this.stopPointerTrick();
+        this.stopAdminCursorTracker();
+    }
+    setCursorPositionButtonDisplayed(value) {
+        this.cursorPositionButtonDisplayed = value;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportPointerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportPointerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportPointerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+const HoverEvent$1 = 'hover';
+const UnhoverEvent$1 = 'unhover';
+const RepaintEvent = 'repaint';
+class NestThermostat extends SceneComponent {
+    cv = null;
+    planeRenderer = null;
+    rootScene = null;
+    mixer = null;
+    onEnterClip = null;
+    mesh = null;
+    currentTime = 0;
+    nextUpdate = 0;
+    temperature = 0;
+    tempChangeRange = 5;
+    component;
+    inputs = {
+        loadingState: 'Idle',
+        texture: null,
+        updateInterval: 1000,
+    };
+    outputs = {
+        painter: null,
+        visible: false,
     };
     events = {
-        [ComponentInteractionType.CLICK]: true,
+        [HoverEvent$1]: true,
+        [UnhoverEvent$1]: true,
     };
-    onInit(modelNode, inputTexture) {
-        this.inputs.texture = inputTexture;
+    onInit(modelNode, plane, inputTexture) {
         if (!this.context) {
             this.context = {
                 root: modelNode
             };
         }
-        this.pivotNode = new Group();
-        this.mesh = new Mesh(new PlaneBufferGeometry(1.0, 1.0), new MeshBasicMaterial({
-            transparent: this.inputs.transparent,
-            map: this.inputs.texture,
-            opacity: this.inputs.opacity,
-            polygonOffset: this.inputs.polygonOffset,
-            polygonOffsetFactor: this.inputs.polygonOffsetFactor,
-            polygonOffsetUnits: this.inputs.polygonOffsetUnits,
-        }));
-        this.mesh.scale.set(this.inputs.localScale.x, this.inputs.localScale.y / this.inputs.aspect, this.inputs.localScale.z);
-        this.mesh.position.set(this.inputs.localPosition.x, this.inputs.localPosition.y, this.inputs.localPosition.z);
-        this.mesh.updateMatrixWorld();
-        this.pivotNode.add(this.mesh);
-        this.outputs.objectRoot = this.pivotNode;
-        this.outputs.collider = this.pivotNode;
-        this.mesh.visible = this.inputs.visible;
-    }
-    onEvent(eventType, eventData) {
-        this.notify(eventType, eventData);
+        this.inputs.texture = inputTexture;
+        const root = this.context.root;
+        const THREE = this.context.three;
+        this.planeRenderer = plane;
+        this.planeRenderer.outputs.objectRoot.translateZ(0.05);
+        this.planeRenderer.outputs.objectRoot.translateY(0.4);
+        this.planeRenderer.outputs.objectRoot.scale.set(0.5, 0.5, 0.5);
+        // planeRenderer.inputs.localPosition.z = 0.05;
+        // planeRenderer.inputs.localPosition.y = 0.4;
+        // planeRenderer.inputs.localScale = {x: 0.5, y: 0.5, z: 0.5};
+        this.outputs.painter = this;
+        this.mixer = new AnimationMixer(this.planeRenderer.outputs.objectRoot);
+        const tm = 0.2;
+        const positionTrack = new VectorKeyframeTrack('.scale', [0, tm], [
+            0, 0, 0,
+            0.5, 0.5, 0.5
+        ], InterpolateSmooth);
+        this.onEnterClip = new AnimationClip(null, tm, [positionTrack]);
     }
-    onInputsUpdated(oldInputs) {
-        if (oldInputs.transparent !== this.inputs.transparent) {
-            this.mesh.material.transparent = this.inputs.transparent;
-        }
-        if (oldInputs.texture !== this.inputs.texture) {
-            const material = this.mesh.material;
-            material.map = this.inputs.texture;
-            material.needsUpdate = true;
-        }
-        if (oldInputs.visible !== this.inputs.visible) {
-            this.mesh.visible = this.inputs.visible;
-        }
-        if (oldInputs.polygonOffset !== this.inputs.polygonOffset) {
-            const material = this.mesh.material;
-            material.polygonOffset = this.inputs.polygonOffset;
-            material.polygonOffsetFactor = this.inputs.polygonOffsetFactor;
-            material.polygonOffsetUnits = this.inputs.polygonOffsetUnits;
+    onInputsUpdated() {
+        if (this.inputs.loadingState === 'Loaded') {
+            const lines = [];
+            //@ts-ignore
+            this.context.root.obj3D.traverse((obj) => {
+                // we dont want line segments, track them and remove them.
+                if (obj.type === 'LineSegments') {
+                    lines.push(obj);
+                }
+                else if (obj.type === 'Mesh') {
+                    this.mesh = obj;
+                    const materials = this.mesh.material;
+                    materials.forEach((m, idx) => {
+                        if (m && m.map.source.data.outerHTML.indexOf('_5b76dbe388862300126c1e14') !== -1) {
+                            const newMaterial = new MeshBasicMaterial({ map: this.inputs.texture });
+                            this.mesh.material[idx] = newMaterial;
+                        }
+                    });
+                }
+            });
+            // remove the line segments.
+            lines.forEach((line) => {
+                line.parent.remove(line);
+            });
+        }
+    }
+    onEvent(eventType, eventData) {
+        if (eventType === HoverEvent$1) {
+            const data = eventData;
+            if (data.hover) {
+                this.outputs.visible = true;
+                const onEnterAction = this.mixer.clipAction(this.onEnterClip);
+                onEnterAction.stop();
+                onEnterAction.loop = LoopOnce;
+                onEnterAction.clampWhenFinished = true;
+                onEnterAction.play();
+            }
+            else {
+                this.outputs.visible = false;
+            }
+        }
+    }
+    paint(context2d, size) {
+        const x = 490;
+        const y = 490;
+        context2d.fillStyle = 'black';
+        context2d.beginPath();
+        context2d.arc(x, y, 400, 0, Math.PI * 2);
+        context2d.fill();
+        context2d.fillStyle = '#CF5300';
+        context2d.beginPath();
+        context2d.arc(x, y, 300, 0, Math.PI * 2);
+        context2d.fill();
+        context2d.beginPath();
+        context2d.strokeStyle = 'orange';
+        context2d.arc(x, y, 240, 0.75 * Math.PI, 0.25 * Math.PI);
+        context2d.lineCap = 'butt';
+        context2d.lineWidth = 80;
+        context2d.stroke();
+        context2d.fillStyle = 'white';
+        context2d.font = '220px Arial';
+        context2d.fillText(`${this.temperature}`, x - 115, y + 75);
+        this.outputs.visible = true;
+    }
+    onTick(delta) {
+        this.currentTime += delta;
+        if (this.mixer) {
+            this.mixer.update(delta / 1000);
+        }
+        if (this.currentTime > this.nextUpdate) {
+            this.nextUpdate += this.inputs.updateInterval;
+            this.temperature += (Math.random() * this.tempChangeRange);
+            this.temperature = Math.trunc(this.temperature);
+            if (this.temperature > 99) {
+                this.temperature = 99;
+                this.tempChangeRange = -this.tempChangeRange;
+            }
+            if (this.temperature < 10) {
+                this.temperature = 10;
+                this.tempChangeRange = -this.tempChangeRange;
+            }
+            this.component.notify(RepaintEvent);
+            this.cv.repaint();
+        }
+    }
+    setComponent(component, plane, cv) {
+        component.onTick = this.onTick.bind(this);
+        // plane.onTick = this.onTick.bind(this);
+        this.cv = cv;
+        this.component = component;
+        this.context = component.context;
+    }
+    setRootScene(rootScene) {
+        this.rootScene = rootScene;
+    }
+}
+const nestThermostatType = 'mp.nestThermostat';
+const makeNestThermostat = function () {
+    return new NestThermostat();
+};
+
+class PlaneRenderer extends SceneComponent {
+    rootScene = null;
+    mesh;
+    pivotNode;
+    inputs = {
+        texture: null,
+        aspect: 1,
+        transparent: true,
+        visible: true,
+        opacity: 1,
+        polygonOffset: false,
+        polygonOffsetFactor: 0,
+        polygonOffsetUnits: 0,
+        localScale: { x: 1, y: 1, z: 1 },
+        localPosition: { x: 0, y: 0, z: 0 },
+    };
+    events = {
+        [ComponentInteractionType.CLICK]: true,
+    };
+    onInit(modelNode, inputTexture) {
+        this.inputs.texture = inputTexture;
+        if (!this.context) {
+            this.context = {
+                root: modelNode
+            };
+        }
+        this.pivotNode = new Group();
+        this.mesh = new Mesh(new PlaneBufferGeometry(1.0, 1.0), new MeshBasicMaterial({
+            transparent: this.inputs.transparent,
+            map: this.inputs.texture,
+            opacity: this.inputs.opacity,
+            polygonOffset: this.inputs.polygonOffset,
+            polygonOffsetFactor: this.inputs.polygonOffsetFactor,
+            polygonOffsetUnits: this.inputs.polygonOffsetUnits,
+        }));
+        this.mesh.scale.set(this.inputs.localScale.x, this.inputs.localScale.y / this.inputs.aspect, this.inputs.localScale.z);
+        this.mesh.position.set(this.inputs.localPosition.x, this.inputs.localPosition.y, this.inputs.localPosition.z);
+        this.mesh.updateMatrixWorld();
+        this.pivotNode.add(this.mesh);
+        this.outputs.objectRoot = this.pivotNode;
+        this.outputs.collider = this.pivotNode;
+        this.mesh.visible = this.inputs.visible;
+    }
+    onEvent(eventType, eventData) {
+        this.notify(eventType, eventData);
+    }
+    onInputsUpdated(oldInputs) {
+        if (oldInputs.transparent !== this.inputs.transparent) {
+            this.mesh.material.transparent = this.inputs.transparent;
+        }
+        if (oldInputs.texture !== this.inputs.texture) {
+            const material = this.mesh.material;
+            material.map = this.inputs.texture;
+            material.needsUpdate = true;
+        }
+        if (oldInputs.visible !== this.inputs.visible) {
+            this.mesh.visible = this.inputs.visible;
+        }
+        if (oldInputs.polygonOffset !== this.inputs.polygonOffset) {
+            const material = this.mesh.material;
+            material.polygonOffset = this.inputs.polygonOffset;
+            material.polygonOffsetFactor = this.inputs.polygonOffsetFactor;
+            material.polygonOffsetUnits = this.inputs.polygonOffsetUnits;
+        }
+        this.mesh.scale.set(this.inputs.localScale.x, this.inputs.localScale.y / this.inputs.aspect, this.inputs.localScale.z);
+        this.mesh.position.set(this.inputs.localPosition.x, this.inputs.localPosition.y, this.inputs.localPosition.z);
+    }
+    onDestroy() {
+        this.outputs.collider = null;
+        this.outputs.objectRoot = null;
+        this.mesh.material.dispose();
+        this.mesh.geometry.dispose();
+    }
+    setRootScene(rootScene) {
+        this.rootScene = rootScene;
+    }
+}
+const planeRendererType = 'mp.planeRenderer';
+function makePlaneRenderer() {
+    return new PlaneRenderer();
+}
+
+class CanvasRenderer extends SceneComponent {
+    canvas;
+    renderContext2D;
+    inputs = {
+        painter: null,
+        textureRes: { w: 1024, h: 1024 }, // dim for thermostat
+    };
+    outputs = {
+        texture: null,
+    };
+    events = {
+        repaint: true,
+    };
+    onInit() {
+        // set up canvas 2d context
+        this.canvas = document.createElement('canvas');
+        this.renderContext2D = this.canvas.getContext('2d');
+        this.outputs.texture = new CanvasTexture(this.canvas);
+        this.resize(this.inputs.textureRes);
+        this.repaint();
+    }
+    setCanvasNestThermostatPainter(sc) {
+        this.inputs.painter = sc;
+    }
+    onInputsUpdated(oldInputs) {
+        if (oldInputs.textureRes.w !== this.inputs.textureRes.w ||
+            oldInputs.textureRes.h !== this.inputs.textureRes.h) {
+            this.resize(this.inputs.textureRes);
+        }
+        if (oldInputs.painter !== this.inputs.painter) {
+            this.repaint();
+        }
+    }
+    onEvent(eventType, _eventData) {
+        if (eventType === 'repaint') {
+            this.repaint();
+        }
+    }
+    onDestroy() {
+        this.outputs.texture.dispose();
+        this.outputs.texture = null;
+    }
+    resize(size) {
+        this.canvas.width = size.w;
+        this.canvas.height = size.h;
+    }
+    repaint() {
+        if (this.inputs.painter) {
+            this.inputs.painter.paint(this.renderContext2D, this.inputs.textureRes);
+            this.outputs.texture.needsUpdate = true;
+        }
+    }
+}
+const canvasRendererType = 'mp.canvasRenderer';
+function makeCanvasRenderer() {
+    return new CanvasRenderer();
+}
+
+const HoverEvent = 'hover';
+const UnhoverEvent = 'unhover';
+class TvPlayer extends SceneComponent {
+    rootScene = null;
+    mesh = null;
+    component;
+    inputs = {
+        loadingState: 'Idle',
+        texture: null,
+        updateInterval: 1000,
+    };
+    events = {
+        [HoverEvent]: true,
+        [UnhoverEvent]: true,
+    };
+    intervalVideoTexture;
+    onInit(modelNode) {
+        if (!this.context) {
+            this.context = {
+                root: modelNode
+            };
+        }
+        const root = this.context.root;
+        const THREE = this.context.three;
+    }
+    onDestroy() {
+        super.onDestroy();
+        clearInterval(this.intervalVideoTexture);
+    }
+    onInputsUpdated() {
+        if (this.inputs.loadingState === 'Loaded') {
+            const lines = [];
+            //@ts-ignore
+            this.context.root.obj3D.traverse((obj) => {
+                // we dont want line segments, track them and remove them.
+                if (obj.type === 'LineSegments') {
+                    lines.push(obj);
+                }
+                else if (obj.type === 'Mesh') {
+                    this.mesh = obj;
+                    let video, videoImage, videoImageContext, videoTexture;
+                    // create the video element
+                    video = document.createElement('video');
+                    // video.src = "./../assets/video/video_samsic.mp4";
+                    video.src = "./../assets/video/121222-04.mp4";
+                    video.load(); // must call after setting/changing source
+                    video.loop = true;
+                    video.play();
+                    videoImage = document.createElement('canvas');
+                    // videoImage.width = 640;
+                    videoImage.width = 1280;
+                    // videoImage.height = 360;
+                    videoImage.height = 720;
+                    videoImageContext = videoImage.getContext('2d');
+                    // background color if no video present
+                    videoImageContext.fillStyle = '#000000';
+                    videoImageContext.fillRect(0, 0, videoImage.width, videoImage.height);
+                    videoTexture = new Texture(videoImage);
+                    videoTexture.minFilter = LinearFilter;
+                    videoTexture.magFilter = LinearFilter;
+                    const movieMaterial = new MeshBasicMaterial({ map: videoTexture });
+                    this.mesh.material = movieMaterial;
+                    const render = () => {
+                        if (video.readyState === video.HAVE_ENOUGH_DATA) {
+                            videoImageContext.drawImage(video, 0, 0);
+                            if (videoTexture)
+                                videoTexture.needsUpdate = true;
+                        }
+                        const camera = (this.context.scene.children.find(u => u.constructor.name === 'CameraRig')).camera;
+                        this.context.renderer.render(this.context.scene, camera);
+                    };
+                    this.intervalVideoTexture = setInterval(() => {
+                        render();
+                    }, 180);
+                }
+            });
+            // remove the line segments.
+            lines.forEach((line) => {
+                line.parent.remove(line);
+            });
+        }
+    }
+    setComponent(component) {
+        this.component = component;
+        this.context = component.context;
+    }
+    setRootScene(rootScene) {
+        this.rootScene = rootScene;
+    }
+}
+const TvPlayerType = 'mp.TvPlayer';
+const makeTvPlayer = function () {
+    return new TvPlayer();
+};
+
+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: () => [] });
+
+class MatterportTagService {
+    navigationService;
+    dictionnaryTags = new Map();
+    tagAddQueue = Promise.resolve();
+    mattertagToFollow = null;
+    onGoToTag = new Subject();
+    mattertagIDs = [];
+    tagsAttachments = {};
+    tagMessengerOn = false;
+    tagService = null;
+    tagsCurrentOpacity = new Map();
+    tagsCurrentEnabled = new Map();
+    constructor(navigationService) {
+        this.navigationService = navigationService;
+    }
+    setTagService(service) {
+        this.tagService = service;
+    }
+    /** Opens a specific tag in the Matterport viewer by its ID. */
+    async goToTag(sdk, sid) {
+        if (!sdk)
+            return;
+        try {
+            this.onGoToTag.next(sid);
+            await sdk.Tag.open(sid);
+        }
+        catch (e) {
+            if (isDevMode())
+                console.warn('Cannot open tag', sid, e);
+        }
+    }
+    /** Opens the most recently created tag in the viewer. */
+    async goToLastTag(sdk) {
+        if (!sdk || this.mattertagIDs.length === 0)
+            return;
+        const lastSid = this.mattertagIDs[this.mattertagIDs.length - 1];
+        return this.goToTag(sdk, lastSid);
+    }
+    /**
+     * Adds a Mattertag to the viewer, serializing calls to prevent SDK race conditions.
+     * Reuses existing IDs if the tag is already present in the session.
+     */
+    async addMattertagToViewer(sdk, mattertagData) {
+        if (!sdk)
+            return null;
+        this.tagAddQueue = this.tagAddQueue.then(async () => {
+            const data = mattertagData.getData();
+            const existingId = data?.id || null;
+            try {
+                const sidList = await sdk.Tag.add(data);
+                if (sidList && sidList.length > 0) {
+                    const mattertagID = sidList[0];
+                    this.mattertagIDs.push(mattertagID);
+                    this.dictionnaryTags.set(mattertagID, mattertagData);
+                    return mattertagID;
+                }
+            }
+            catch (error) {
+                if (error?.message?.includes('already in use') && existingId) {
+                    if (!this.dictionnaryTags.has(existingId)) {
+                        this.mattertagIDs.push(existingId);
+                        this.dictionnaryTags.set(existingId, mattertagData);
+                    }
+                    return existingId;
+                }
+                if (isDevMode())
+                    console.warn('Failed to add tag to viewer', error);
+            }
+            return null;
+        });
+        return this.tagAddQueue;
+    }
+    /**
+     * Internal method to add and configure a Mattertag with icon, opacity, and HTML content.
+     * Handles existing tags gracefully and queues operations to avoid SDK conflicts.
+     */
+    async _doAddMattertag(sdk, mattertagData, setTagIconAndOpacity, injectHtmlInTag) {
+        const descriptor = mattertagData.getMattertagDescriptor();
+        //console.log('descriptor', descriptor);
+        const sid = descriptor[0]['id'];
+        if (sid && this.dictionnaryTags.has(sid)) {
+            await setTagIconAndOpacity(sid, mattertagData);
+            await injectHtmlInTag(mattertagData.getType(), mattertagData.getObject(), sid);
+            return sid;
+        }
+        this.tagAddQueue = this.tagAddQueue.then(async () => {
+            try {
+                const [createdSid] = await sdk.Tag.add(...descriptor);
+                this.mattertagIDs.push(createdSid);
+                this.dictionnaryTags.set(createdSid, mattertagData);
+                await wait(100);
+                await setTagIconAndOpacity(createdSid, mattertagData);
+                injectHtmlInTag(mattertagData.getType(), mattertagData.getObject(), createdSid).catch(err => {
+                    if (isDevMode())
+                        console.warn('HTML injection failed for', createdSid, err);
+                });
+                return createdSid;
+            }
+            catch (e) {
+                if (e?.message?.includes('already in use') && sid) {
+                    if (!this.dictionnaryTags.has(sid)) {
+                        this.mattertagIDs.push(sid);
+                        this.dictionnaryTags.set(sid, mattertagData);
+                    }
+                    await setTagIconAndOpacity(sid, mattertagData);
+                    await injectHtmlInTag(mattertagData.getType(), mattertagData.getObject(), sid);
+                    return sid;
+                }
+                throw e;
+            }
+        });
+        return this.tagAddQueue;
+    }
+    getDistance(p1, p2) {
+        return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2) + Math.pow(p2.z - p1.z, 2));
+    }
+    /**
+     * Checks if a tag is within the bounding box of any active room (adding a slight margin to account for wall-mounted tags).
+     * If there are no active rooms (e.g., hallway), falls back to returning true.
+     */
+    isTagInRooms(mattertagData, rooms) {
+        if (!rooms || rooms.length === 0)
+            return false;
+        const tagPos = mattertagData.getPosition();
+        const margin = 1.5;
+        return rooms.some((room) => {
+            if (!room.bounds)
+                return false;
+            const { min, max } = room.bounds;
+            return (tagPos.x >= min.x - margin && tagPos.x <= max.x + margin &&
+                tagPos.y >= min.y - margin && tagPos.y <= max.y + margin &&
+                tagPos.z >= min.z - margin && tagPos.z <= max.z + margin);
+        });
+    }
+    /**
+     * Computes the final context-aware opacity for a single tag.
+     * @param currentFloorSequence  Authoritative current floor sequence from sdk.Floor.current
+     *                              (null = single-floor model or unknown).
+     * @param currentRooms          Array of active rooms the camera is in.
+     */
+    /*computeSingleTagContextOpacity(
+      mattertagData: MattertagData,
+      poseCamera: any,
+      sweepCollection: any,
+      currentFloorSequence: number | null,
+      currentRooms: any[]
+    ): number {
+      const mode = this.navigationService.currentCameraMode;
+  
+      // 1. Check Floor
+      const tagFloorId = this.getFloorIdForTag(mattertagData, sweepCollection);
+      const currentFloorId = currentFloorSequence?.toString();
+      if (tagFloorId && currentFloorId && tagFloorId !== currentFloorId) {
+        return 0;
+      }
+  
+      // 2. Si Dollhouse -> Pleine opacité
+      //if (mode !== CameraMode.INSIDE) return 1;
+  
+      // 3. Si Inside -> Check pièce + Distance progressive
+      //if (!this.isTagInRooms(mattertagData, currentRooms)) return 0;
+  
+      return 1;
+    }*/
+    /** Returns the ID of the most recently added tag. */
+    getLastTag() {
+        if (this.mattertagIDs.length === 0)
+            return null;
+        return this.mattertagIDs[this.mattertagIDs.length - 1];
+    }
+    /**
+     * Updates the visibility (opacity) of all tags based on the current camera mode,
+     * floor and room context. Must be called after each sweep, floor or mode change.
+     *
+     * Rules:
+     *  - DOLLHOUSE / FLOORPLAN → all tags hidden (opacity 0).
+     *  - INSIDE → only tags whose sweep belongs to the current floor are shown;
+     *    proximity-based opacity is applied via computeTagOpacity().
+     *    Tags on other floors are hidden (opacity 0).
+     *  - TRANSITIONING → no change (skip update to avoid flickering).
+     *
+     * @param sdk          Matterport SDK instance.
+     * @param poseCamera   Current camera pose.
+     * @param sweepCollection  Full collection of sweeps.
+     * @param currentCameraMode  Current camera mode.
+     * @param mattertagToFollow  ID of the cursor tag (never touched).
+     */
+    async updateTagsVisibilityForContext(sdk, sweepCollection, currentCameraMode, mattertagToFollow, currentFloorSequence = null, currentRooms = []) {
+        if (!sdk || this.dictionnaryTags.size === 0)
+            return;
+        const isInteriorMode = currentCameraMode === CameraMode.INSIDE;
+        const currentFloorId = currentFloorSequence !== null ? currentFloorSequence.toString() : null;
+        const promises = [];
+        for (const [tagId, mattertagData] of this.dictionnaryTags) {
+            if (tagId === mattertagToFollow)
+                continue;
+            const tagFloorId = this.getFloorIdForTag(mattertagData, sweepCollection);
+            const isOnCurrentFloor = !tagFloorId || !currentFloorId || tagFloorId === currentFloorId;
+            let targetOpacity = 0;
+            let shouldBeEnabled = false;
+            // Calculation of opacity and enable status
+            if (isOnCurrentFloor) {
+                if (!isInteriorMode) {
+                    targetOpacity = 1;
+                    shouldBeEnabled = true;
+                }
+                else {
+                    targetOpacity = 0.9;
+                    shouldBeEnabled = true;
+                }
+            }
+            // Apply changes
+            // Tooltip and click management
+            const lastEnabled = this.tagsCurrentEnabled.get(tagId);
+            if (lastEnabled !== shouldBeEnabled) {
+                this.tagsCurrentEnabled.set(tagId, shouldBeEnabled);
+                promises.push(sdk.Tag.allowAction(tagId, {
+                    opening: shouldBeEnabled,
+                    navigating: shouldBeEnabled,
+                    docking: false
+                }).catch(() => { }));
+            }
+            // Opacity management
+            const lastOpacity = this.tagsCurrentOpacity.get(tagId) ?? -1;
+            if (Math.abs(lastOpacity - targetOpacity) > 0.05) {
+                this.tagsCurrentOpacity.set(tagId, targetOpacity);
+                promises.push(sdk.Tag.editOpacity(tagId, targetOpacity).catch(() => { }));
+            }
         }
-        this.mesh.scale.set(this.inputs.localScale.x, this.inputs.localScale.y / this.inputs.aspect, this.inputs.localScale.z);
-        this.mesh.position.set(this.inputs.localPosition.x, this.inputs.localPosition.y, this.inputs.localPosition.z);
-    }
-    onDestroy() {
-        this.outputs.collider = null;
-        this.outputs.objectRoot = null;
-        this.mesh.material.dispose();
-        this.mesh.geometry.dispose();
+        await Promise.all(promises);
     }
-    setRootScene(rootScene) {
-        this.rootScene = rootScene;
+    /** Removes a specific tag from the viewer and local dictionaries. */
+    async deleteMattertagFromId(sdk, mattertagID) {
+        try {
+            if (sdk)
+                await sdk.Tag.remove(mattertagID);
+            this.dictionnaryTags.delete(mattertagID);
+            const index = this.mattertagIDs.indexOf(mattertagID);
+            if (index > -1)
+                this.mattertagIDs.splice(index, 1);
+        }
+        catch (e) {
+            if (isDevMode())
+                console.warn('Cannot delete tag', mattertagID, e);
+        }
     }
-}
-const planeRendererType = 'mp.planeRenderer';
-function makePlaneRenderer() {
-    return new PlaneRenderer();
-}
-
-class CanvasRenderer extends SceneComponent {
-    canvas;
-    renderContext2D;
-    inputs = {
-        painter: null,
-        textureRes: { w: 1024, h: 1024 }, // dim for thermostat
-    };
-    outputs = {
-        texture: null,
-    };
-    events = {
-        repaint: true,
-    };
-    onInit() {
-        // set up canvas 2d context
-        this.canvas = document.createElement('canvas');
-        this.renderContext2D = this.canvas.getContext('2d');
-        this.outputs.texture = new CanvasTexture(this.canvas);
-        this.resize(this.inputs.textureRes);
-        this.repaint();
+    /** Removes the last added tag from the viewer. */
+    async deleteLastMattertag(sdk) {
+        const lastSid = this.getLastTag();
+        if (lastSid)
+            await this.deleteMattertagFromId(sdk, lastSid);
     }
-    setCanvasNestThermostatPainter(sc) {
-        this.inputs.painter = sc;
+    /** Clears all tags from the viewer and resets local state. */
+    async action_delete_all_mattertags(sdk) {
+        if (sdk) {
+            const sidsToRemove = [...this.mattertagIDs];
+            for (const sid of sidsToRemove) {
+                try {
+                    await sdk.Tag.remove(sid);
+                }
+                catch (e) { }
+            }
+        }
+        this.clear();
     }
-    onInputsUpdated(oldInputs) {
-        if (oldInputs.textureRes.w !== this.inputs.textureRes.w ||
-            oldInputs.textureRes.h !== this.inputs.textureRes.h) {
-            this.resize(this.inputs.textureRes);
+    /**
+     * Creates and configures a Mattertag from a POI, handling coordinates, normals, and sweep ID.
+     * Skips creation if a tag for the object already exists.
+     */
+    async createMattertagFromPOI(sdk, tagType, object, poi, poseCamera, getTagFromElementId, setTagIconAndOpacity, injectHtmlInTag) {
+        const { tag } = getTagFromElementId(object.id);
+        if (tag)
+            return;
+        const mattertagData = new MattertagData(tagType);
+        mattertagData.setObject(object, tagType);
+        if (poi.coordinate) {
+            try {
+                mattertagData.setPosition(JSON.parse(poi.coordinate));
+            }
+            catch (e) {
+                if (isDevMode())
+                    console.warn('Error parsing POI coordinates', poi.coordinate);
+            }
         }
-        if (oldInputs.painter !== this.inputs.painter) {
-            this.repaint();
+        if (poi.metadata) {
+            try {
+                const tagMetadata = JSON.parse(poi.metadata);
+                mattertagData.setNormal(tagMetadata.normal || { x: 0, y: -0.15, z: 0 });
+            }
+            catch (e) {
+                mattertagData.setNormal({ x: 0, y: -0.15, z: 0 });
+            }
         }
-    }
-    onEvent(eventType, _eventData) {
-        if (eventType === 'repaint') {
-            this.repaint();
+        if (poi.matterportSweepID) {
+            mattertagData.setSweepID(poi.matterportSweepID);
         }
+        mattertagData.setPoi(poi);
+        const createdTagID = await this.addMattertagToViewer(sdk, mattertagData);
+        if (createdTagID && sdk) {
+            await wait(100);
+            await setTagIconAndOpacity(createdTagID, mattertagData);
+            injectHtmlInTag(tagType, object, createdTagID).catch(err => {
+                if (isDevMode())
+                    console.warn('HTML injection failed for', createdTagID, err);
+            });
+        }
+        return createdTagID;
     }
-    onDestroy() {
-        this.outputs.texture.dispose();
-        this.outputs.texture = null;
-    }
-    resize(size) {
-        this.canvas.width = size.w;
-        this.canvas.height = size.h;
+    /** Updates the icon, opacity, and HTML content of an existing tag. */
+    async updateMatterTagContentForTagID(sdk, mattertagID, object, poiType, setTagIconAndOpacity, injectHtmlInTag) {
+        const mattertagData = this.dictionnaryTags.get(mattertagID);
+        if (!mattertagData)
+            return;
+        if (object) {
+            mattertagData.setObject(object, poiType);
+        }
+        await setTagIconAndOpacity(mattertagID, mattertagData);
+        await injectHtmlInTag(poiType, object, mattertagID);
     }
-    repaint() {
-        if (this.inputs.painter) {
-            this.inputs.painter.paint(this.renderContext2D, this.inputs.textureRes);
-            this.outputs.texture.needsUpdate = true;
+    /** Registers a custom texture and applies it to a tag, optionally adjusting opacity. */
+    async addNewIconAndSetForTag(sdk, mattertagID, iconPath, applyOpacity, opacity) {
+        if (!sdk)
+            return;
+        try {
+            const iconName = `custom-icon-${mattertagID}`;
+            await sdk.Asset.registerTexture(iconName, iconPath);
+            await sdk.Tag.editIcon(mattertagID, iconName);
+            if (applyOpacity) {
+                await sdk.Tag.editOpacity(mattertagID, opacity);
+            }
+        }
+        catch (error) {
+            if (isDevMode())
+                console.warn('Error setting custom icon or opacity', error);
         }
     }
-}
-const canvasRendererType = 'mp.canvasRenderer';
-function makeCanvasRenderer() {
-    return new CanvasRenderer();
-}
-
-const HoverEvent = 'hover';
-const UnhoverEvent = 'unhover';
-class TvPlayer extends SceneComponent {
-    rootScene = null;
-    mesh = null;
-    component;
-    inputs = {
-        loadingState: 'Idle',
-        texture: null,
-        updateInterval: 1000,
-    };
-    events = {
-        [HoverEvent]: true,
-        [UnhoverEvent]: true,
-    };
-    intervalVideoTexture;
-    onInit(modelNode) {
-        if (!this.context) {
-            this.context = {
-                root: modelNode
-            };
+    /** Finds the tag ID and sweep ID associated with a specific element ID. */
+    getTagFromElementId(elementID, sweeps) {
+        let tagID = null;
+        let sweepID = null;
+        for (let [mattertagID, mattertagData] of this.dictionnaryTags) {
+            if (mattertagData.elementID === elementID) {
+                tagID = mattertagID;
+                const sweep = mattertagData.getSweepID();
+                if (sweep && sweeps && sweeps.includes(sweep)) {
+                    sweepID = sweep;
+                }
+            }
         }
-        const root = this.context.root;
-        const THREE = this.context.three;
+        return { tag: tagID, sweep: sweepID };
     }
-    onDestroy() {
-        super.onDestroy();
-        clearInterval(this.intervalVideoTexture);
+    /** Retrieves the floor identifier associated with a tag based on its sweep data.
+     *  Handles both the object form ({ floorInfo: { id, sequence }, floor: { id } })
+     *  and the primitive form (floor: number) used by Matterport SDK v3.
+     */
+    getFloorIdForTag(mattertagData, sweepCollection) {
+        const sweepId = mattertagData.getSweepID();
+        if (!sweepId || !sweepCollection)
+            return null;
+        const sweepData = sweepCollection[sweepId];
+        if (!sweepData)
+            return null;
+        // SDK v3: sweep.floor is a primitive number (the sequence index)
+        if (typeof sweepData.floor === 'number') {
+            return sweepData.floor.toString();
+        }
+        // Older / extended formats
+        return sweepData?.floorInfo?.id
+            ?? sweepData?.floorInfo?.sequence?.toString()
+            ?? sweepData?.floorId
+            ?? sweepData?.floor?.id
+            ?? sweepData?.floor?.sequence?.toString()
+            ?? null;
     }
-    onInputsUpdated() {
-        if (this.inputs.loadingState === 'Loaded') {
-            const lines = [];
-            //@ts-ignore
-            this.context.root.obj3D.traverse((obj) => {
-                // we dont want line segments, track them and remove them.
-                if (obj.type === 'LineSegments') {
-                    lines.push(obj);
+    /**
+     * Injects custom HTML or fallback billboard media into a Mattertag sandbox.
+     * Attaches event listeners for interactive elements within the tag.
+     */
+    async injectHtmlInTag(sdk, tagType, object, tagID) {
+        if (!this.tagService) {
+            console.error('[MatterportTagService] tagService is not initialized.');
+            return;
+        }
+        try {
+            let html = await this.tagService.getHtmlToInject(tagType, object);
+            if (html && html.trim().length > 0 && sdk) {
+                const scriptTag = this.tagService.getScriptForTag(object, tagType);
+                html += `${scriptTag}`;
+                const [sandboxId, messenger] = await sdk.Tag.registerSandbox(html);
+                const attachmentID = this.tagsAttachments[tagID];
+                if (attachmentID) {
+                    try {
+                        await sdk.Tag.detach(tagID, attachmentID);
+                    }
+                    catch (e) { }
                 }
-                else if (obj.type === 'Mesh') {
-                    this.mesh = obj;
-                    let video, videoImage, videoImageContext, videoTexture;
-                    // create the video element
-                    video = document.createElement('video');
-                    // video.src = "./../assets/video/video_samsic.mp4";
-                    video.src = "./../assets/video/121222-04.mp4";
-                    video.load(); // must call after setting/changing source
-                    video.loop = true;
-                    video.play();
-                    videoImage = document.createElement('canvas');
-                    // videoImage.width = 640;
-                    videoImage.width = 1280;
-                    // videoImage.height = 360;
-                    videoImage.height = 720;
-                    videoImageContext = videoImage.getContext('2d');
-                    // background color if no video present
-                    videoImageContext.fillStyle = '#000000';
-                    videoImageContext.fillRect(0, 0, videoImage.width, videoImage.height);
-                    videoTexture = new Texture(videoImage);
-                    videoTexture.minFilter = LinearFilter;
-                    videoTexture.magFilter = LinearFilter;
-                    const movieMaterial = new MeshBasicMaterial({ map: videoTexture });
-                    this.mesh.material = movieMaterial;
-                    const render = () => {
-                        if (video.readyState === video.HAVE_ENOUGH_DATA) {
-                            videoImageContext.drawImage(video, 0, 0);
-                            if (videoTexture)
-                                videoTexture.needsUpdate = true;
-                        }
-                        const camera = (this.context.scene.children.find(u => u.constructor.name === 'CameraRig')).camera;
-                        this.context.renderer.render(this.context.scene, camera);
-                    };
-                    this.intervalVideoTexture = setInterval(() => {
-                        render();
-                    }, 180);
+                this.tagsAttachments[tagID] = sandboxId;
+                await sdk.Tag.attach(tagID, sandboxId);
+                // Attach the "View informations" handler in tooltip
+                messenger.on(TagAction.DETAIL_CLICK, this.tagService.onActionDetailClick.bind(this.tagService));
+                messenger.on(TagAction.TICKET_CLICK, this.tagService.onActionDetailClick.bind(this.tagService));
+                messenger.on(TagAction.AUDIO_CLICK, (audioCommentID) => this.tagService.onActionAudioClick(audioCommentID));
+                messenger.on(TagAction.VIDEO_CLICK, (videoUrl) => this.tagService.onActionVideoClick(videoUrl));
+                messenger.on(TagAction.IMAGE_CLICK, (imageCommentID) => this.tagService.onActionImageClick(imageCommentID));
+                messenger.on(TagAction.DOC_CLICK, (docUrl) => this.tagService.onActionDocClick(docUrl));
+                messenger.on(TagAction.YOUTUBE_CLICK, (youtubeUrl) => this.tagService.onActionYoutubeClick(youtubeUrl));
+            }
+            else if (sdk) {
+                const { comment, tagDescription } = this.tagService.getBillboardMediaToEmbed(object);
+                if (comment) {
+                    const attachmentID = await sdk.Tag.registerAttachment({
+                        type: 'media',
+                        data: {
+                            url: comment.externalLink,
+                            label: object.title || 'Media',
+                        },
+                    });
+                    await sdk.Tag.attach(tagID, attachmentID);
+                    const billboardAttachmentID = await sdk.Tag.registerAttachment({
+                        type: 'billboard',
+                        data: {
+                            title: object.title,
+                            description: tagDescription,
+                        },
+                    });
+                    await sdk.Tag.attach(tagID, billboardAttachmentID);
+                    this.tagsAttachments[tagID] = billboardAttachmentID;
                 }
-            });
-            // remove the line segments.
-            lines.forEach((line) => {
-                line.parent.remove(line);
-            });
+            }
+        }
+        catch (error) {
+            console.error('[MatterportTagService] Error in injectHtmlInTag:', error);
         }
     }
-    setComponent(component) {
-        this.component = component;
-        this.context = component.context;
-    }
-    setRootScene(rootScene) {
-        this.rootScene = rootScene;
+    /** Clears all local tag data and resets the addition queue. */
+    clear() {
+        this.dictionnaryTags.clear();
+        this.tagAddQueue = Promise.resolve();
+        this.mattertagToFollow = null;
+        this.mattertagIDs = [];
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportTagService, deps: [{ token: MatterportNavigationService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportTagService, providedIn: 'root' });
 }
-const TvPlayerType = 'mp.TvPlayer';
-const makeTvPlayer = function () {
-    return new TvPlayer();
-};
-
-class BaseVisibilityService {
-    detailShowing = new Subject();
-    isChangePositionVisible = new Subject();
-    constructor() { }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseVisibilityService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseVisibilityService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseVisibilityService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportTagService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: () => [] });
+        }], ctorParameters: () => [{ type: MatterportNavigationService }] });
 
 class Config {
     my_config;
@@ -2537,85 +3567,154 @@ class MatterportService {
     activeRoute;
     visibilityService;
     ngZone;
-    slots = []; //SlotNode[] = [];
-    nodes = [];
+    measurementService;
+    navigationService;
+    pointerService;
+    object3DService;
+    matterportTagService;
     sdk;
     container;
     // Position camera
     poseMatterport;
     poseCamera;
     lastCameraPosition = { x: 0.0, y: 0.0, z: 0.0 };
-    azimuthalCrown;
-    // Pointer trick
-    pointerButton;
-    // Display and get current position of cursor (for Admins only)
-    getCursorPositionButton;
-    cursorPositionButtonDisplayed = false;
-    intervalCursorPointerPosition;
-    textDisplayCursorPositionPanel;
-    oldPoseMatterportPosition;
-    // Measure mode
     isMeasureModeOn = false;
     interactionMode = ViewerInteractions.DEFAULT;
-    // List of created Mattertag IDs in the current viewer session
-    mattertagIDs = [];
-    // Dictionnary of MattertagID and its data (mattertagData)
-    dictionnaryTags = new Map();
-    dictionnaryObjects3D = new Map();
-    dictionnarySceneObjects3D = new Map();
-    threeJSScene; // global root scene (not used now!)
-    lastMeasure = [];
-    distancesLastMeasure = [];
-    resolution = {
-        width: 500,
-        height: 600,
-    };
-    visibility = {
-        mattertags: false,
-        sweeps: true,
-    };
-    tagsAttachments = {};
-    lastScreenshotUri;
-    sweeps;
-    currentSweep = new Subject();
+    cameraMode = 'INSIDE';
+    get mattertagIDs() {
+        return this.matterportTagService.mattertagIDs;
+    }
+    set mattertagIDs(value) {
+        this.matterportTagService.mattertagIDs = value;
+    }
+    get dictionnaryTags() {
+        return this.matterportTagService.dictionnaryTags;
+    }
+    get dictionnaryObjects3D() {
+        return this.object3DService.dictionnaryObjects3D;
+    }
+    get dictionnarySceneObjects3D() {
+        return this.object3DService.dictionnarySceneObjects3D;
+    }
+    get threeJSScene() {
+        return this.object3DService.threeJSScene;
+    }
+    set threeJSScene(value) {
+        this.object3DService.threeJSScene = value;
+    }
+    get azimuthalCrown() {
+        return this.object3DService.azimuthalCrown;
+    }
+    set azimuthalCrown(value) {
+        this.object3DService.azimuthalCrown = value;
+    }
+    get tagsAttachments() {
+        return this.matterportTagService.tagsAttachments;
+    }
+    get sweeps() {
+        return this.navigationService.sweeps;
+    }
+    set sweeps(value) {
+        this.navigationService.sweeps = value;
+    }
+    get sweepCollection() {
+        return this.navigationService.sweepCollection;
+    }
+    set sweepCollection(value) {
+        this.navigationService.sweepCollection = value;
+    }
+    get currentSweep() {
+        return this.navigationService.currentSweep;
+    }
     //camera position with rotation
     currentCameraPose = new Subject();
-    floors;
+    get floors() {
+        return this.navigationService.floors;
+    }
+    set floors(value) {
+        this.navigationService.floors = value;
+    }
     _currentSpaceID;
-    lastObject3D; // Three JS object
-    currentFloor;
+    get lastObject3D() {
+        return this.object3DService.lastObject3D;
+    }
+    set lastObject3D(value) {
+        this.object3DService.lastObject3D = value;
+    }
+    get currentRooms() {
+        return this.navigationService.currentRooms;
+    }
+    set currentRooms(value) {
+        this.navigationService.currentRooms = value;
+    }
     get currentSpaceID() {
         return this._currentSpaceID;
     }
     set currentSpaceID(value) {
         this._currentSpaceID = value;
     }
-    timerPointer;
-    forbiddenSweeps = [];
+    get forbiddenSweeps() {
+        return this.navigationService.forbiddenSweeps;
+    }
+    set forbiddenSweeps(value) {
+        this.navigationService.forbiddenSweeps = value;
+    }
     tagAction = new Subject();
-    mattertagToFollow;
+    get mattertagToFollow() {
+        return this.matterportTagService.mattertagToFollow;
+    }
+    set mattertagToFollow(value) {
+        this.matterportTagService.mattertagToFollow = value;
+    }
+    get inTransitionMode() {
+        return this.navigationService.inTransitionMode;
+    }
+    set inTransitionMode(value) {
+        this.navigationService.inTransitionMode = value;
+    }
+    get inTransitionSweep() {
+        return this.navigationService.inTransitionSweep;
+    }
+    set inTransitionSweep(value) {
+        this.navigationService.inTransitionSweep = value;
+    }
+    noLightForObjects = true;
+    get currentCameraMode() {
+        return this.navigationService.currentCameraMode;
+    }
+    set currentCameraMode(value) {
+        this.navigationService.currentCameraMode = value;
+    }
+    get onCameraModeChanged() {
+        return this.navigationService.onCameraModeChanged;
+    }
+    get onRoomChanged() {
+        return this.navigationService.onRoomChanged;
+    }
+    get onGoToTag() {
+        return this.matterportTagService.onGoToTag;
+    }
     tagService;
     config;
-    inTransitionMode = false;
-    inTransitionSweep = false;
-    noLightForObjects = true;
-    currentCameraMode = CameraMode.OUTSIDE;
-    onCameraModeChanged = new Subject();
-    onGoToTag = new Subject();
-    tagMessengerOn = false;
     SPModule;
-    objectControl;
-    securityCameraAnimator;
+    get objectControl() {
+        return this.object3DService.objectControl;
+    }
+    get securityCameraAnimator() {
+        return this.object3DService.securityCameraAnimator;
+    }
     /**
      * Actions on left click when positioning mattertag in visit
      */
-    pointerLeftClickHandler = () => {
+    pointerLeftClickHandler = (evt) => {
         if (this.mattertagToFollow) {
             const mattertagData = this.dictionnaryTags.get(this.mattertagToFollow);
-            mattertagData.setPosition({ ...this.poseMatterport.position }); // copy!! not the reference
-            mattertagData.setNormal({ ...this.poseMatterport.normal }); // copy!! not the reference
-            this.dictionnaryTags.set(this.mattertagToFollow, mattertagData);
-            this.updateMatterTagContentForTagID(this.mattertagToFollow);
+            if (mattertagData) {
+                mattertagData.setPosition({ ...this.poseMatterport.position });
+                mattertagData.setNormal({ ...this.poseMatterport.normal });
+                this.dictionnaryTags.set(this.mattertagToFollow, mattertagData);
+                this.updateMatterTagContentForTagID(this.mattertagToFollow);
+            }
         }
         this.onValidatedMattertag();
     };
@@ -2625,52 +3724,25 @@ class MatterportService {
         alert('action cancelled');
     };
     pointerMiddleClickHandler = (e) => {
-        this.textDisplayCursorPositionPanel.innerHTML = `position:
-       ${this.pointToString(this.poseMatterport.position)}\n
-       normal:
-       ${this.pointToString(this.poseMatterport.normal)}\n
-       floorId:
-       ${this.poseMatterport.floorId}`;
-        // this.textDisplayCursorPositionPanel.style.display = 'visible';
-        this.getCursorPositionButton.style.display = 'none';
+        this.pointerService.updateCursorDisplay(this.poseMatterport);
     };
-    constructor(config, router, activeRoute, visibilityService, ngZone) {
+    constructor(config, router, activeRoute, visibilityService, ngZone, measurementService, navigationService, pointerService, object3DService, matterportTagService) {
         this.router = router;
         this.activeRoute = activeRoute;
         this.visibilityService = visibilityService;
         this.ngZone = ngZone;
+        this.measurementService = measurementService;
+        this.navigationService = navigationService;
+        this.pointerService = pointerService;
+        this.object3DService = object3DService;
+        this.matterportTagService = matterportTagService;
         this.config = config;
-        // TODO: only for dev!
-        if (!!this.getCursorPositionButton &&
-            (document.location.href.indexOf('dev') !== -1 || document.location.href.indexOf('localhost') !== -1)) {
-            this.intervalCursorPointerPosition = setInterval(() => {
-                if (!this.poseMatterport) {
-                    return;
-                }
-                const nextShow = this.poseMatterport.time + 1000;
-                if (new Date().getTime() > nextShow) {
-                    if (this.cursorPositionButtonDisplayed) {
-                        return;
-                    }
-                    const size = {
-                        w: this.container.clientWidth,
-                        h: this.container.clientHeight,
-                    };
-                    const coord = this.sdk.Conversion.worldToScreen(this.poseMatterport.position, this.poseCamera, size);
-                    this.getCursorPositionButton.style.left = `${coord.x - 25}px`;
-                    this.getCursorPositionButton.style.top = `${coord.y - 22}px`;
-                    this.getCursorPositionButton.style.display = 'block';
-                    // this.textDisplayCursorPositionPanel.style.display = 'none';
-                    this.cursorPositionButtonDisplayed = true;
-                }
-            }, 500);
-        }
     }
     /**
-     * Initializes Matterport and all listeners/data
-     * @param tagService BaseTagService (to inject html)
-     * @param module SpModule (Museum, Immo) to subscribe only to needed functionnnalities
-     * @returns boolean
+     * Initializes the Matterport SDK, sets up event listeners, and configures assets.
+     * @param tagService Service used to generate and inject HTML into tags.
+     * @param module Application module (e.g., IMMO, MUSEUM) to enable specific features.
+     * @returns Promise resolving to true when initialization is complete.
      */
     async initSdk(tagService, module = SpModule.IMMO) {
         if (this.sdk) {
@@ -2678,39 +3750,35 @@ class MatterportService {
             await this.action_delete_all_mattertags();
         }
         this.tagService = tagService;
+        this.matterportTagService.setTagService(tagService);
         this.SPModule = module;
         return new Promise((resolve, reject) => {
             // Retrieve DOM elements
-            this.pointerButton = document.querySelector('#viewer-pointer-trick');
+            const pointerBtn = document.querySelector('#viewer-pointer-trick');
             this.container = document.querySelector('#viewer-module');
             const iframe = document.querySelector('#viewer-module');
             if (!iframe) {
                 return;
             }
-            // Add listeners
-            if (this.pointerButton) {
-                this.pointerButton.addEventListener('click', this.pointerLeftClickHandler);
-                // cancel on right click
-                this.pointerButton.addEventListener('contextmenu', this.pointerRightClickHandler);
-            }
-            // Retrieve DOM elements
-            this.getCursorPositionButton = document.querySelector('#button');
-            this.textDisplayCursorPositionPanel = document.querySelector('#text');
-            if (this.getCursorPositionButton) {
-                // get position on Matterport "model" on middle click
-                this.getCursorPositionButton.addEventListener('click', this.pointerMiddleClickHandler);
-            }
+            const cursorBtn = document.querySelector('#button');
+            const textPanel = document.querySelector('#text');
+            this.pointerService.init(this.container, pointerBtn, cursorBtn, textPanel, {
+                onLeftClick: this.pointerLeftClickHandler.bind(this),
+                onRightClick: this.pointerRightClickHandler.bind(this),
+                onMiddleClick: this.pointerMiddleClickHandler.bind(this),
+            });
             // Load SDK
-            console.log('Loading Matterport SDK');
             const showcaseWindow = iframe.contentWindow;
-            iframe.addEventListener('load', async function () {
+            iframe.addEventListener('load', async () => {
                 try {
-                    this.sdk = await showcaseWindow.MP_SDK.connect(showcaseWindow, 'qn9wsasuy5h2fzrbrn1nzr0id', '3.5');
+                    this.sdk = await showcaseWindow.MP_SDK.connect(showcaseWindow, 'qn9wsasuy5h2fzrbrn1nzr0id', '');
                 }
                 catch (e) {
                     console.error(e);
                     return;
                 }
+                this.addCustomCss();
+                this.pointerService.startAdminCursorTracker(this.sdk, this.container, () => this.poseMatterport, () => this.poseCamera);
                 // Load Mattertag icons and custom subscriptions
                 switch (module) {
                     case SpModule.IMMO:
@@ -2721,17 +3789,11 @@ class MatterportService {
                         this.sdk.Asset.registerTexture('icon-object3d', this.config.my_config.icon_object3d);
                         this.sdk.Measurements.data.subscribe({
                             onAdded: function (index, item, collection) {
-                                // console.log(
-                                //     "item added to the collection",
-                                //     index,
-                                //     item,
-                                // );
-                                // this.measurements[index] = item;
-                                this.lastMeasure = item.points;
+                                this.measurementService.setLastMeasure(item.points);
                             }.bind(this),
                             onCollectionUpdated: function (collection) {
                                 // console.log('the entire up-to-date collection', collection);
-                                this.getDistanceForLastMeasurement();
+                                this.measurementService.getDistanceForLastMeasurement(this.sdk, this.currentSpaceID);
                             }.bind(this),
                         });
                         this.sdk.Measurements.mode.subscribe(function (measurementModeState) {
@@ -2755,7 +3817,11 @@ class MatterportService {
                 this.sdk.Asset.registerTexture('icon-position', this.config.my_config.icon_position);
                 // Current Room (used for getting bounding box and eventually lazy load mattertag or object3D inside current Room)
                 this.sdk.Room.current.subscribe((currentRoom) => {
-                    console.log(`hello current Room ${JSON.stringify(currentRoom)}`);
+                    const rooms = Array.isArray(currentRoom) ? currentRoom : (currentRoom ? [currentRoom] : []);
+                    this.currentRooms = rooms;
+                    this.navigationService.onRoomChanged.next(rooms);
+                    // Refresh tag visibility whenever the room context changes
+                    this.refreshTagsVisibility();
                 });
                 // 3D position's pointer
                 this.sdk.Pointer.intersection.subscribe(function (intersection) {
@@ -2768,64 +3834,41 @@ class MatterportService {
                             z: 0,
                         };
                     }
-                    if (this.interactionMode !== ViewerInteractions.DEFAULT &&
-                        this.mattertagToFollow) {
+                    if (this.interactionMode !== ViewerInteractions.DEFAULT && this.mattertagToFollow) {
                         // follow the pointer and changes the position of the last tag
                         // (we are about to validate, but it exists in sdk already)
                         this.enable_following_tag(this.mattertagToFollow);
                     }
-                    if (!!this.getCursorPositionButton && !!this.getCursorPositionButton.style &&
-                        (document.URL.indexOf('https://dev.smarterplan.io') !== -1 || document.location.href.indexOf('localhost') !== -1)) {
-                        this.getCursorPositionButton.style.display = 'none';
-                        this.cursorPositionButtonDisplayed = false;
+                    if (this.pointerService) {
+                        this.pointerService.setCursorPositionButtonDisplayed(false);
                     }
                 }.bind(this));
                 //Camera mode
                 this.sdk.Mode.current.subscribe((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;
+                    if (this.cameraMode !== mode) {
+                        this.navigationService.setCameraMode(mode);
+                        // Refresh tag visibility on every mode change (INSIDE vs DOLLHOUSE vs FLOORPLAN)
+                        this.refreshTagsVisibility();
+                        this.cameraMode = mode;
                     }
-                    this.onCameraModeChanged.next(this.currentCameraMode);
                 });
-                // Camera's viewpoint
-                this.sdk.Camera.pose.subscribe(function subscr(pose) {
-                    this.poseCamera = pose;
-                    this.currentCameraPose.next(pose);
-                    // console.log('Current position is ', pose.position);
-                    // console.log('Rotation angle is ', pose.rotation);
-                    // console.log("Sweep UUID is", pose.sweep);
-                }.bind(this));
+                setTimeout(() => {
+                    if (this.sdk && this.poseCamera) {
+                        this.matterportTagService.updateTagsVisibilityForContext(this.sdk, this.sweepCollection, this.navigationService.currentCameraMode, this.mattertagToFollow, this.navigationService.currentFloorSequence, this.navigationService.currentRooms);
+                    }
+                }, 1000);
                 // subscribe to sweeps
                 this.sdk.Sweep.data.subscribe({
                     onCollectionUpdated: function subscr(collection) {
-                        // console.log("Sweep collection updated");
                         this.sweeps = Object.keys(collection);
+                        this.sweepCollection = collection;
                     }.bind(this),
                 });
                 // subscribe to current sweep
                 this.sdk.Sweep.current.subscribe(function subscr(currentSweep) {
-                    // Change to the current sweep has occurred.
-                    if (currentSweep.sid === '') {
-                        // console.log('Not currently stationed at a sweep position');
-                    }
-                    else {
-                        // console.log("emmiting sweep", currentSweep.sid);
-                        this.currentSweep.next(currentSweep.sid);
-                    }
+                    if (currentSweep.sid === '')
+                        return;
+                    this.currentSweep.next(currentSweep.sid);
                 }.bind(this));
                 // Subscribe to Floor data
                 this.sdk.Floor.data.subscribe({
@@ -2833,25 +3876,23 @@ class MatterportService {
                         this.floors = Object.values(collection);
                     }.bind(this),
                 });
-                // Handler générique pour les sélections de tags
-                const handleTagSelection = async (sid, source, evt) => {
+                // Subscribe to current floor – authoritative source for multi-floor filtering
+                this.sdk.Floor.current.subscribe((currentFloor) => {
+                    const seq = currentFloor?.sequence ?? null;
+                    this.navigationService.currentFloorSequence = seq;
                     if (isDevMode()) {
-                        console.log(`[MatterportService] handleTagSelection from ${source} for sid: ${sid}`, { evt });
+                        console.log('[Floor.current] sequence =', seq, '| full =', currentFloor);
                     }
-                    // Exécution de l'action personnalisée (ouverture du panneau de détail via navigation)
+                    this.refreshTagsVisibility();
+                });
+                // Generic handler for tag selection events
+                const handleTagSelection = async (sid, source, evt) => {
                     try {
                         const mattertagData = this.dictionnaryTags.get(sid);
-                        if (!mattertagData) {
-                            if (isDevMode()) {
-                                console.log('no mattertagData to display', sid);
-                            }
+                        if (!mattertagData)
                             return;
-                        }
                         const url = tagService.getUrlForSeeDetails(mattertagData.getObject(), mattertagData.getType());
                         if (url !== '') {
-                            if (isDevMode()) {
-                                console.log(`[MatterportService] Navigating to detail URL: ${url}`);
-                            }
                             this.visibilityService.detailShowing.next(true);
                             this.ngZone.run(() => {
                                 this.router.navigate([url]);
@@ -2859,48 +3900,39 @@ class MatterportService {
                         }
                     }
                     catch (error) {
-                        if (isDevMode()) {
-                            console.log('Cannot show details for tag', error);
-                        }
+                        if (isDevMode())
+                            console.warn('Cannot show details for tag', error);
                     }
                 };
-                // Fonction pour désactiver les actions natives sur un tag (SDK v3)
+                // Disable native Matterport actions
                 const disableNativeActions = (sid) => {
-                    if (!this.sdk)
-                        return;
+                    if (!this.sdk || sid === this.mattertagToFollow)
+                        return; // ignore when we are in positioning mode
                     try {
-                        if (this.sdk.Tag && this.sdk.Tag.allowAction) {
-                            // opening: false désactive le billboard natif
-                            // navigating: false désactive le déplacement de la caméra vers le tag
-                            this.sdk.Tag.allowAction(sid, { opening: false, navigating: true, docking: false });
-                            /*if (isDevMode()) {
-                              console.log(`[MatterportService] Disabled native actions for tag ${sid}`);
-                            }*/
-                        }
-                        else if (this.sdk.Mattertag && this.sdk.Mattertag.preventAction) {
-                            // Fallback ancienne API
-                            this.sdk.Mattertag.preventAction(sid, { opening: true, navigating: true });
-                            if (isDevMode()) {
-                                console.log(`[MatterportService] Prevented native actions (legacy) for tag ${sid}`);
-                            }
+                        if (this.sdk.Tag?.allowAction) {
+                            this.sdk.Tag.allowAction(sid, { opening: true, navigating: true, docking: false });
                         }
                     }
                     catch (e) {
-                        if (isDevMode()) {
-                            console.warn(`[MatterportService] Error disabling actions for ${sid}`, e);
+                        // silently ignore already removed tags
+                        if (isDevMode() && !e?.message?.includes('not found')) {
+                            console.warn('MatterportService: Error disabling actions for', sid, e);
                         }
                     }
                 };
-                // Attendre que l'application soit en phase PLAYING
+                // Wait for the application to reach PLAYING phase
                 if (this.sdk.App && this.sdk.App.state) {
-                    if (isDevMode()) {
-                        console.log('[MatterportService] Waiting for App.Phase.PLAYING...');
-                    }
                     this.sdk.App.state.waitUntil((s) => s.phase === this.sdk.App.Phase.PLAYING).then(() => {
-                        if (isDevMode()) {
-                            console.log('[MatterportService] App is PLAYING.');
+                        this.sdk.Camera.pose.subscribe((pose) => {
+                            this.poseCamera = pose;
+                            this.matterportTagService.updateTagsVisibilityForContext(this.sdk, this.sweepCollection, this.navigationService.currentCameraMode, this.mattertagToFollow, this.navigationService.currentFloorSequence, this.navigationService.currentRooms);
+                        });
+                        setTimeout(() => {
+                            this.matterportTagService.updateTagsVisibilityForContext(this.sdk, this.sweepCollection, this.navigationService.currentCameraMode, this.mattertagToFollow, this.navigationService.currentFloorSequence, this.navigationService.currentRooms);
+                        }, 1500);
+                        if (this.interactionMode === ViewerInteractions.DEFAULT) {
+                            this.navigationService.action_toolbox_inside_view(this.sdk);
                         }
-                        // 1. Désactiver les actions natives pour tous les tags existants et futurs
                         if (this.sdk.Tag && this.sdk.Tag.data) {
                             this.sdk.Tag.data.subscribe({
                                 onAdded: (sid) => {
@@ -2910,21 +3942,14 @@ class MatterportService {
                                     disableNativeActions(sid);
                                 },
                                 onCollectionUpdated: (collection) => {
-                                    Object.keys(collection).forEach(sid => disableNativeActions(sid));
-                                }
-                            });
-                        }
-                        // 2. Écouter les sélections via l'observable openTags (Méthode moderne)
-                        if (this.sdk.Tag && this.sdk.Tag.openTags) {
-                            this.sdk.Tag.openTags.subscribe({
-                                onChanged: (newState) => {
-                                    if (newState.selected && newState.selected.size > 0) {
-                                        const sid = Array.from(newState.selected)[0];
-                                        handleTagSelection(sid, 'Tag.openTags.selected');
-                                    }
+                                    Object.keys(collection).forEach((sid) => disableNativeActions(sid));
                                 }
                             });
                         }
+                        resolve(true);
+                    })
+                        .catch((error) => {
+                        reject(error);
                     });
                 }
                 // Fallback pour l'événement global tag.click
@@ -2933,224 +3958,118 @@ class MatterportService {
                         console.log(`[MatterportService] sdk.on('tag.click') received for sid: ${sid}`);
                     }
                     handleTagSelection(sid, 'global.tag.click');
-                    // On s'assure qu'il est bien désactivé même si on a raté l'évènement d'ajout
                     disableNativeActions(sid);
                 });
                 // Pointer trick
                 // Create a div that will appear when the cursor is still
                 // It will intercept the click of the mouse before it trigerring the Matterport's tour navigation
-                this.timerPointer = setInterval(this.updatePointerTrick.bind(this), 50);
+                this.pointerService.startPointerTrick(this.sdk, this.container, () => this.poseMatterport, () => this.poseCamera, () => this.interactionMode, () => this.mattertagToFollow);
                 /**
-                 * Transitions
-                 */
+                * Transitions
+                */
                 this.sdk.on('viewmode.changestart', function (to, from) {
-                    // console.log('Starting to move to ' + to + ' from ' + from);
-                    this.inTransitionMode = true;
+                    console.debug('Starting to move to ' + to + ' from ' + from);
+                    this.navigationService.inTransitionMode = true;
                 }.bind(this));
                 this.sdk.on('viewmode.changeend', function (oldMode, newMode) {
-                    // console.log('Ended to move to ' + newMode + ' from ' + oldMode);
+                    console.debug('Ended to move to ' + newMode + ' from ' + oldMode);
                     if (newMode !== 'mode.transitioning') {
-                        this.inTransitionMode = false;
+                        this.navigationService.inTransitionMode = false;
                     }
                 }.bind(this));
                 this.sdk.on(this.sdk.Sweep.Event.ENTER, function (oldSweep, newSweep) {
-                    // console.log('Leaving sweep ' + oldSweep);
-                    // console.log('Entering sweep ' + newSweep);
-                    this.inTransitionSweep = false;
+                    console.debug('Leaving sweep ' + oldSweep);
+                    console.debug('Entering sweep ' + newSweep);
+                    this.navigationService.inTransitionSweep = false;
                     this.displayAzimutalCrown();
+                    // Refresh on sweep is removed because we only update on room or floor changes now.
                 }.bind(this));
                 this.sdk.on(this.sdk.Sweep.Event.EXIT, function (fromSweep, toSweep) {
-                    //   console.log('Leaving sweep ' + fromSweep);
-                    //   console.log('Transitioning to sweep ' + toSweep);
-                    this.inTransitionSweep = true;
+                    console.debug('Leaving sweep ' + fromSweep);
+                    console.debug('Transitioning to sweep ' + toSweep);
+                    this.navigationService.inTransitionSweep = true;
                 }.bind(this));
-                // TODO: get scene with getter instead!
-                const [sceneObject] = await this.sdk.Scene.createObjects(1);
-                const node = sceneObject.addNode();
-                node.start();
-                this.threeJSScene = node.obj3D.parent;
-                // await this.sdk.Scene.configure((renderer: any, three: any) => {
-                //   renderer.physicallyCorrectLights = true;
-                //   renderer.outputEncoding = three.sRGBEncoding;
-                //   renderer.shadowMap.enabled = true;
-                //   renderer.shadowMap.bias = 0.0001;
-                //   renderer.shadowMap.type = three.PCFSoftShadowMap;
-                // });
-                // TODO: wait for MP ticket resolution before decomment these!
-                // Wait until Showcase is actually playing....
-                // this.sdk.Tag.data.subscribe({
-                //   onAdded: async function (index, item, collection) {
-                //
-                //     let thisOpacity = 0.2;
-                //     this.sdk.Tag.editOpacity(index, thisOpacity);
-                //
-                //     let source = null;
-                //     try {
-                //       source = await Promise.all([
-                //         this.sdk.Sensor.createSource(this.sdk.Sensor.SourceType.SPHERE, {
-                //           origin: item.anchorPosition,
-                //           radius: Number(3),
-                //           userData: {
-                //             id: index + '-sphere-source',
-                //           },
-                //         })
-                //       ]);
-                //     } catch (e) {
-                //       console.log('could not create Sphere sensor')
-                //       console.error(e);
-                //     }
-                //     if (!source) {
-                //       return;
-                //     }
-                //
-                //     let sensor = null;
-                //     try {
-                //       sensor = await this.sdk.Sensor.createSensor(this.sdk.Sensor.SensorType.CAMERA);
-                //     } catch (e) {
-                //       console.log('could not create Camera sensor')
-                //       console.error(e);
-                //     }
-                //     if (!sensor) {
-                //       return;
-                //     }
-                //
-                //     sensor.addSource(...source);
-                //     sensor.readings.subscribe({
-                //       onUpdated(source, reading) {
-                //         console.log(thisOpacity);
-                //         let oldOpacity = thisOpacity;
-                //         if (reading.inRange) {
-                //           thisOpacity = 1;
-                //           console.log(index + ' is inRange');
-                //         } else if (reading.inView) {
-                //           console.log(index + ' is inView but not inRange');
-                //           thisOpacity = 0.5;
-                //         } else {
-                //           thisOpacity = 0.2;
-                //           console.log(index + ' is not inView or inRange');
-                //         }
-                //
-                //         this.sdk.Tag.editOpacity(index, thisOpacity);
-                //         /*
-                //                   let inc = 0.01;
-                //                   if (oldOpacity > thisOpacity) {
-                //                     inc = -0.01;
-                //                   }
-                //
-                //                   for(var i = oldOpacity; i != thisOpacity; i=i+inc) {
-                //                       setTimeout(function() {
-                //                          mpSdk.Tag.editOpacity(index, i);
-                //                       console.log('Delay', i);
-                //                       },10);
-                //                   }
-                //         */
-                //       }
-                //     });
-                //     //sensor.showDebug(true);
-                //   }.bind(this),
-                //   onCollectionUpdated: function (collection) {
-                //     console.log('Collection received. There are ', Object.keys(collection).length, ' Tags in the collection', collection);
-                //   }
-                // });
+                await this.init3DObjectViewer();
                 resolve(true);
-            }.bind(this));
+            });
         });
     }
+    getSweepUUIDForSid(sid) {
+        const collection = this.sweepCollection;
+        if (!collection || !collection[sid])
+            return null;
+        return collection[sid].uuid ?? null;
+    }
     setLightingOff() {
         this.noLightForObjects = true;
     }
-    pointToString(point) {
-        var x = point.x.toFixed(3);
-        var y = point.y.toFixed(3);
-        var z = point.z.toFixed(3);
-        return `{ x: ${x}, y: ${y}, z: ${z} }`;
-    }
-    //
-    // ---------- Measurements related ----------
-    //
-    /**
-     * Callback after measurement is performed
-     */
     getDistanceForLastMeasurement() {
-        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().then((res) => {
-                this.router.navigate([`visit/${this.currentSpaceID}/add_measurement`]);
-            });
-        }
+        this.measurementService.getDistanceForLastMeasurement(this.sdk, this.currentSpaceID);
     }
     getLastDistances() {
-        return this.distancesLastMeasure;
+        return this.measurementService.getLastDistances();
     }
     /**
      * Takes screenshot and saves base64 in lastScreenshotUri
      * @returns Promise
      */
     takeScreenShot() {
-        return this.sdk.Renderer.takeScreenShot(this.resolution, this.visibility).then(function (screenShotUri) {
-            // base64 string
-            this.lastScreenshotUri = screenShotUri;
-            return Promise.resolve();
-        }.bind(this));
+        return this.measurementService.takeScreenShot(this.sdk);
     }
     getScreenShotUri() {
-        return this.lastScreenshotUri;
+        return this.measurementService.getScreenShotUri();
     }
     getLastMeasurement() {
-        const data = {
-            measure: this.lastMeasure,
-            sweep: this.poseCamera.sweep,
-        };
-        return data;
+        return this.measurementService.getLastMeasurement(this.poseCamera);
     }
     //
     // ---------- Utils ----------
     //
+    getFloorIdForTag(mattertagData) {
+        return this.matterportTagService.getFloorIdForTag(mattertagData, this.sweepCollection);
+    }
     /**
      * Styling of pointer
      */
     updatePointerTrick() {
-        if (this.interactionMode !== ViewerInteractions.DEFAULT &&
-            this.mattertagToFollow &&
-            this.poseMatterport &&
-            this.getDistPosition(this.poseMatterport.position, this.oldPoseMatterportPosition) > 25) {
-            this.pointerButton.style.display = 'none';
-            const size = {
-                w: this.container.clientWidth,
-                h: this.container.clientHeight,
-            };
-            const coords = this.sdk.Conversion.worldToScreen(this.poseMatterport.position, this.poseCamera, size);
-            this.pointerButton.style.left = `${coords.x * Math.sign(coords.x) - 25}px`;
-            this.pointerButton.style.top = `${coords.y * Math.sign(coords.x) - 25}px`;
-            this.oldPoseMatterportPosition = {
-                ...this.poseMatterport.position,
-            };
-        }
-        else {
-            this.pointerButton.style.display = 'block';
-        }
+        this.pointerService.updatePointerTrick(this.sdk, this.container, this.poseMatterport, this.poseCamera, this.interactionMode, this.mattertagToFollow);
+    }
+    /**
+     * Triggers a tag visibility refresh based on current camera mode, floor and sweep.
+     * Delegates all logic to MatterportTagService.updateTagsVisibilityForContext().
+     * Called automatically on Mode, Sweep, Floor and Room changes.
+     */
+    refreshTagsVisibility() {
+        Promise.resolve().then(() => {
+            if (isDevMode() && this.sweepCollection && this.poseCamera?.sweep) {
+                const sweepData = this.sweepCollection[this.poseCamera.sweep];
+                console.debug('[refreshTagsVisibility] sweepData for current sweep:', JSON.stringify(sweepData));
+                console.debug('[refreshTagsVisibility] currentFloorSequence:', this.navigationService.currentFloorSequence);
+                console.debug('[refreshTagsVisibility] currentCameraMode:', this.currentCameraMode);
+            }
+            this.matterportTagService.updateTagsVisibilityForContext(this.sdk, this.sweepCollection, this.currentCameraMode, this.mattertagToFollow, this.navigationService.currentFloorSequence, this.navigationService.currentRooms).catch(err => {
+                if (isDevMode())
+                    console.warn('[MatterportService] refreshTagsVisibility error', err);
+            });
+        });
     }
     /**
      * Realtime mattertag following the cursor
      * @param mattertag string
      */
     enable_following_tag(mattertag) {
+        const OFFSET = 0.0001; // quasi-invisible mais suffit à éviter l'interception
         this.sdk.Tag.editPosition(mattertag, {
             anchorPosition: {
-                x: this.poseMatterport.position.x * 1,
-                y: this.poseMatterport.position.y * 1,
-                z: this.poseMatterport.position.z * 1,
+                x: this.poseMatterport.position.x + OFFSET,
+                y: this.poseMatterport.position.y,
+                z: this.poseMatterport.position.z + OFFSET,
             },
             stemVector: {
                 x: this.poseMatterport.normal.x * 0.3,
                 y: this.poseMatterport.normal.y * 0.3,
                 z: this.poseMatterport.normal.z * 0.3,
-            },
+            }
         });
     }
     /**
@@ -3160,58 +4079,46 @@ class MatterportService {
      * @param pos2
      */
     getDistPosition(pos1, pos2) {
-        const size = {
-            w: this.container.clientWidth,
-            h: this.container.clientHeight,
-        };
-        const coords1 = this.sdk.Conversion.worldToScreen(pos1, this.poseCamera, size);
-        const coords2 = this.sdk.Conversion.worldToScreen(pos2, this.poseCamera, size);
-        return Math.sqrt((coords1.x - coords2.x) ** 2 + (coords1.y - coords2.y) ** 2);
+        return this.pointerService.getDistPosition(this.sdk, this.container, this.poseCamera, pos1, pos2);
     }
     //
     // ---------- Mattertag related ----------
     //
-    /**
-     * Creates the Mattertag that will follow the cursor
-     * @param mattertagData MattertagData
-     */
+    /** Creates a temporary Mattertag that follows the user's cursor for positioning. */
     async addCursorMattertag(mattertagData) {
         if (!this.poseMatterport)
             return;
         this.mattertagToFollow = await this.addMattertagToViewer(mattertagData);
-        console.log('following the tag', this.mattertagToFollow);
+        await wait(50);
         this.sdk.Tag.editIcon(this.mattertagToFollow, 'icon-position');
         this.sdk.Tag.editOpacity(this.mattertagToFollow, 1);
-    }
-    /**
-     * Adds Mattertag to viewer for an existing object with coordinates (in mattertagData.poi)
-     * (position, injected html, set icon)
-     * @param mattertagData
-     * returns mattertagID
-     */
-    async addMattertagToViewer(mattertagData) {
-        let sidList;
-        if (!this.sdk) {
-            return null;
-        }
+        this.sdk.Tag.editPosition(this.mattertagToFollow, {
+            anchorPosition: { ...this.poseMatterport.position },
+            stemVector: {
+                x: this.poseMatterport.normal.x * 0.3,
+                y: this.poseMatterport.normal.y * 0.3,
+                z: this.poseMatterport.normal.z * 0.3,
+            }
+        });
         try {
-            sidList = await this.sdk.Tag.add(mattertagData.getData());
-        }
-        catch (error) {
-            console.log('Tag does not belong to the visit', error, mattertagData.getData());
-        }
-        if (sidList) {
-            const mattertagID = sidList[0];
-            // console.log("added tag", mattertagData.getType(), mattertagID);
-            this.mattertagIDs.push(mattertagID);
-            this.dictionnaryTags.set(mattertagID, mattertagData);
-            return mattertagID;
+            await this.sdk.Tag.allowAction(this.mattertagToFollow, {
+                opening: true,
+                navigating: false,
+                docking: false
+            });
         }
-        return null;
+        catch (e) { }
     }
-    /**
-     * Actions when position of mattertag is validated by left click
-     */
+    get tagAddQueue() {
+        return this.matterportTagService.tagAddQueue;
+    }
+    set tagAddQueue(value) {
+        this.matterportTagService.tagAddQueue = value;
+    }
+    async addMattertagToViewer(mattertagData) {
+        return this.matterportTagService.addMattertagToViewer(this.sdk, mattertagData);
+    }
+    /** Triggers callback actions after a tag's position is validated by a left click. */
     onValidatedMattertag() {
         this.setInteractionMode(ViewerInteractions.DEFAULT);
         const lastTag = this.getLastTag();
@@ -3222,34 +4129,21 @@ class MatterportService {
             this.callbackAfterMattertagValidation(callbackMode);
         }
     }
-    /**
-     * Registers new icon (path to image) and set its for Mattertag
-     * @param mattertagID string
-     * @param iconPath string
-     */
+    /** Registers a new icon texture and applies it to a specific Mattertag. */
     async addNewIconAndSetForTag(mattertagID, iconPath) {
-        await this.sdk.Asset.registerTexture(`icon_${mattertagID}`, iconPath);
-        this.sdk.Tag.editIcon(mattertagID, `icon_${mattertagID}`);
+        await this.matterportTagService.addNewIconAndSetForTag(this.sdk, mattertagID, iconPath, false, 1);
     }
-    /**
-     * Changes icon of Mattertag (the iconName should be registered = one of default ones)
-     * @param mattertagID string
-     * @param iconName string
-     */
+    /** Applies a pre-registered icon to a Mattertag. */
     async setRegistredIconForTag(mattertagID, iconName) {
         try {
             this.sdk.Tag.editIcon(mattertagID, iconName);
         }
         catch (e) {
-            console.log('could not edit Icon with name ', iconName, '. Is it registered?');
+            if (isDevMode())
+                console.warn('Could not edit icon', iconName, e);
         }
     }
-    /**
-     * Sets default icon for a tag (registered in initSdk) OR uses tagIcon from POI (available from MattertagData)
-     * @param mattertagID string
-     * @param mattertagData MattertagData
-     * @returns
-     */
+    /** Sets the appropriate icon and opacity for a tag based on its type and POI metadata. */
     async setTagIconAndOpacity(mattertagID, mattertagData) {
         if (this.SPModule === SpModule.HOTEL) {
             const room = mattertagData.getObject();
@@ -3294,36 +4188,89 @@ class MatterportService {
         }
         try {
             this.sdk.Tag.editIcon(mattertagID, iconName);
-            this.sdk.Tag.editOpacity(mattertagID, opacity);
         }
         catch (error) {
             console.log('Error editIcon or opacity', error);
         }
     }
-    /**
-     * Moves viewer to last tag created
-     */
-    goToLastTag() {
-        setTimeout(() => {
-            const lastTag = this.getLastTag();
-            this.goToTag(lastTag);
-        }, 2000);
+    /** Navigates the camera to the most recently created tag. */
+    async goToLastTag() {
+        await this.matterportTagService.goToLastTag(this.sdk);
     }
-    /**
-     * Moves viewer to Mattertag with ID provided
-     * @param mattertagID string
-     * @returns
-     */
+    /** Navigates the camera to a specific Mattertag by its ID. */
     async goToTag(mattertagID) {
-        if (mattertagID === '')
+        if (!mattertagID /* || this.inTransitionSweep*/) {
             return;
+        }
         try {
             this.onGoToTag.next(mattertagID);
             await this.sdk.Sweep.current.waitUntil((currentSweep) => currentSweep !== '');
-            await this.sdk.Mattertag.navigateToTag(mattertagID, this.sdk.Mattertag.Transition.FLY);
+            const mtData = this.dictionnaryTags.get(mattertagID);
+            if (mtData) {
+                const position = mtData.getPosition();
+                await this.sdk.Camera.lookAt(position, {
+                    transition: this.sdk.Camera.TransitionType.FLY
+                });
+                await this.sdk.Tag.open(mattertagID);
+            }
+            else {
+                // Fallback for cases where we don't have local data yet
+                await this.sdk.Tag.open(mattertagID);
+            }
         }
         catch (error) {
-            console.log('cannot navigate to tag', error);
+            if (isDevMode())
+                console.warn('Cannot navigate to tag', error);
+        }
+    }
+    /**
+      * Computes the context-aware opacity for a single tag at the moment it is rendered.
+      * - Cursor tag: always use provided defaultOpacity.
+      * - DOLLHOUSE / FLOORPLAN: 0 (hidden).
+      * - INSIDE: floor-filtered proximity opacity via MatterportTagService.
+      * - Other / unknown: defaultOpacity.
+      */
+    /*private _computeContextOpacityForTag(
+      mattertagID: string,
+      mattertagData: MattertagData,
+      defaultOpacity: number
+    ): number {
+      if (mattertagID === this.mattertagToFollow) {
+        return defaultOpacity;
+      }
+      return this.matterportTagService.computeSingleTagContextOpacity(
+        mattertagData,
+        this.poseCamera,
+        this.sweepCollection,
+        this.navigationService.currentFloorSequence,
+        this.navigationService.currentRooms
+      );
+    }*/
+    addCustomCss() {
+        const css = `
+      .footer-ui,
+      .showcase-footer,
+      .mp-nova-btn-group,
+      .footer-divider,
+      .logo-link,
+      .footer-logo,
+      .bottom-ui,
+      [data-testid="showcase-footer"] {
+        opacity: 0 !important;
+        visibility: hidden !important;
+        pointer-events: none !important;
+      }
+    `;
+        // 1st method: Via Scene SDK
+        if (this.sdk?.Scene?.addStyle) {
+            this.sdk.Scene.addStyle(css);
+        }
+        // 2nd method: Direct injection in iFrame DOM (Fallback)
+        const iframe = document.querySelector('#viewer-module');
+        if (iframe?.contentWindow?.document) {
+            const style = iframe.contentWindow.document.createElement('style');
+            style.textContent = css;
+            iframe.contentWindow.document.head.appendChild(style);
         }
     }
     /**
@@ -3333,11 +4280,18 @@ class MatterportService {
      * @param tagType PoiType
      */
     async updateMatterTagContentForTagID(mattertagID, object = null, tagType = null) {
-        this.sdk.Tag.editBillboard(mattertagID, this.dictionnaryTags.get(mattertagID).getData());
-        if (object && tagType) {
-            await this.injectHtmlInTag(tagType, object, mattertagID);
-        }
-        await this.setTagIconAndOpacity(mattertagID, this.dictionnaryTags.get(mattertagID));
+        if (this.sdk) {
+            await this.sdk.Tag.editBillboard(mattertagID, this.dictionnaryTags.get(mattertagID).getData());
+        }
+        // Mise à jour de l'icône immédiate
+        await this.matterportTagService.updateMatterTagContentForTagID(this.sdk, mattertagID, object, tagType, this.setTagIconAndOpacity.bind(this), 
+        // On passe une fonction wrapper qui exécute l'injection HTML sans bloquer
+        async (type, obj, sid) => {
+            this.injectHtmlInTag(type, obj, sid).catch(err => {
+                if (isDevMode())
+                    console.warn('Async HTML update failed for', sid, err);
+            });
+        });
     }
     /**
      * Updates injected html for Mattertag
@@ -3353,17 +4307,13 @@ class MatterportService {
      * @param mattertagID string
      */
     deleteMattertagFromId(mattertagID) {
-        this.sdk.Tag.remove(mattertagID);
-        this.dictionnaryTags.delete(mattertagID);
+        this.matterportTagService.deleteMattertagFromId(this.sdk, mattertagID);
     }
     /**
      * Deletes latest created mattertag
      */
-    deleteLastMattertag() {
-        const mattertagID = this.mattertagIDs.pop();
-        if (mattertagID) {
-            this.deleteMattertagFromId(mattertagID);
-        }
+    async deleteLastMattertag() {
+        await this.matterportTagService.deleteLastMattertag(this.sdk);
     }
     /**
      * Legacy: used to be called action_add_mattertag_from_POI
@@ -3374,35 +4324,7 @@ class MatterportService {
      * @returns
      */
     async createMattertagFromPOI(tagType, object, poi) {
-        // check if tag exists already
-        const { tag, sweep } = this.getTagFromElementId(object.id);
-        if (tag) {
-            // console.log("tag exists", object)
-            return;
-        }
-        const mattertagData = new MattertagData(tagType);
-        mattertagData.setObject(object, tagType);
-        if (poi.coordinate) {
-            mattertagData.setPosition(JSON.parse(poi.coordinate));
-        }
-        if (poi.metadata) {
-            const tagMetadata = JSON.parse(poi.metadata);
-            if (tagMetadata.normal) {
-                mattertagData.setNormal(tagMetadata.normal);
-            }
-            else {
-                mattertagData.setNormal({ x: 0, y: -0.15, z: 0 });
-            }
-        }
-        if (poi.matterportSweepID) {
-            mattertagData.setSweepID(poi.matterportSweepID);
-        }
-        mattertagData.setPoi(poi);
-        const createdTagID = await this.addMattertagToViewer(mattertagData);
-        if (createdTagID && this.sdk) {
-            await this.setTagIconAndOpacity(createdTagID, mattertagData);
-            await this.injectHtmlInTag(tagType, object, createdTagID);
-        }
+        return this.matterportTagService.createMattertagFromPOI(this.sdk, tagType, object, poi, this.poseCamera, this.getTagFromElementId.bind(this), this.setTagIconAndOpacity.bind(this), this.injectHtmlInTag.bind(this));
     }
     /**
      * Inject custom HTML as Mattertag content
@@ -3411,63 +4333,10 @@ class MatterportService {
      * @param tagID string
      */
     async injectHtmlInTag(tagType, object, tagID) {
-        let html = await this.tagService.getHtmlToInject(tagType, object);
-        if (html !== '' && this.sdk) {
-            const scriptTag = this.tagService.getScriptForTag(object, tagType);
-            html += `${scriptTag}`;
-            // create and register the sandbox
-            const [sandboxId, messenger] = await this.sdk.Tag.registerSandbox(html);
-            // detach previous sandbox from a tag
-            let attachmentID = this.tagsAttachments[tagID];
-            if (attachmentID) {
-                this.sdk.Tag.detach(tagID, attachmentID);
-            }
-            this.tagsAttachments[tagID] = sandboxId;
-            // attach the sandbox to a tag
-            this.sdk.Tag.attach(tagID, sandboxId);
-            // receive data from the sandbox
-            // tagMessengerOn allows to go here only once
-            if (!this.tagMessengerOn) {
-                this.tagMessengerOn = true;
-                const imageClick = (featureID) => {
-                    // console.log("image click handler", featureID);
-                    this.tagService.onActionImageClick(featureID);
-                };
-                const audioClick = (audioCommentID) => {
-                    // console.log("audio click handler", audioCommentID);
-                    this.tagService.onActionAudioClick(audioCommentID);
-                };
-                const videoClick = (url) => {
-                    this.tagService.onActionVideoClick(url);
-                };
-                messenger.on(TagAction.DETAIL_CLICK, this.tagService.onActionDetailClick.bind(this.tagService));
-                messenger.on(TagAction.TICKET_CLICK, this.tagService.onActionDetailClick.bind(this.tagService));
-                messenger.on(TagAction.AUDIO_CLICK, audioClick);
-                messenger.on(TagAction.IMAGE_CLICK, imageClick);
-                messenger.on(TagAction.VIDEO_CLICK, videoClick);
-                messenger.on(TagAction.DOC_CLICK, this.tagService.onActionDocClick.bind(this.tagService));
-                messenger.on(TagAction.YOUTUBE_CLICK, this.tagService.onActionYoutubeClick.bind(this.tagService));
-            }
-        }
-        else {
-            // if html is empty (case of EMBED content), we edit billboard for Feature and attach new content
-            const { comment, tagDescription } = this.tagService.getBillboardMediaToEmbed(object);
-            if (comment) {
-                // register the media
-                const [attachmentID] = await this.sdk.Tag.registerAttachment(comment.externalLink);
-                // attach
-                this.sdk.Tag.attach(tagID, attachmentID);
-                this.sdk.Tag.editBillboard(tagID, {
-                    label: object.title,
-                    description: tagDescription,
-                });
-            }
-        }
+        return this.matterportTagService.injectHtmlInTag(this.sdk, tagType, object, tagID);
     }
     async action_delete_all_mattertags() {
-        await this.sdk.Tag.remove(...this.mattertagIDs);
-        this.mattertagIDs = [];
-        this.dictionnaryTags.clear();
+        await this.matterportTagService.action_delete_all_mattertags(this.sdk);
     }
     /**
      * Deletes Mattertag from visit associated with object ID (ticketID, etc)
@@ -3476,36 +4345,21 @@ class MatterportService {
     async deleteMattertagForObject(elementID) {
         const matterTagID = this.getTagFromElementId(elementID).tag;
         if (matterTagID) {
-            try {
-                await this.sdk.Tag.remove(matterTagID);
-                this.dictionnaryTags.delete(matterTagID);
-                const index = this.mattertagIDs.indexOf(matterTagID);
-                this.mattertagIDs.splice(index, 1);
-            }
-            catch (error) {
-                console.log('Cannot delete tag', matterTagID, error);
-            }
+            this.tagAddQueue = this.tagAddQueue.then(async () => {
+                await this.matterportTagService.deleteMattertagFromId(this.sdk, matterTagID);
+            });
         }
+        return this.tagAddQueue;
     }
     /**
      * uuid from threejs
      * @param uuid
      */
     async deleteObject3D(uuid) {
-        this.dictionnaryObjects3D.get(uuid).obj3D.visible = false;
+        return this.object3DService.deleteObject3D(uuid);
     }
     getObject3DModelNodeFromDictionnary(uuid) {
-        let obj = this.dictionnaryObjects3D.get(uuid);
-        if (!obj) {
-            console.log("weird thing again");
-            return null;
-        }
-        //might break things or fix everything ..?
-        if (obj.obj3D.uuid != uuid) {
-            console.log("we have THE problem");
-            obj.obj3D.uuid = uuid; //not enugh to fix the pb
-        }
-        return obj;
+        return this.object3DService.getObject3DModelNodeFromDictionnary(uuid);
     }
     /**
      * Creates  MattertagData and start repositioning (creates temporary mattertag that follows the cursor)
@@ -3546,10 +4400,10 @@ class MatterportService {
         this.setInteractionMode(ViewerInteractions.DEFAULT);
     }
     setLastObject3D(lastObject3D) {
-        this.lastObject3D = lastObject3D;
+        this.object3DService.lastObject3D = lastObject3D;
     }
     getLastObject3D() {
-        return this.lastObject3D;
+        return this.object3DService.lastObject3D;
     }
     /**
      * Performs callback after mattertag position was validated (creation of object or repositioning)
@@ -3645,7 +4499,6 @@ class MatterportService {
         this.dictionnaryTags.get(mattertagID).elementID = object.id;
         try {
             await this.updateMatterTagContentForTagID(mattertagID, object, poiType);
-            // TODO: fix this
             await this.updateMatterTagPosInSdkViewer(mattertagID, object, poiType, poi);
         }
         catch (e) {
@@ -3669,7 +4522,7 @@ class MatterportService {
                 z: 0,
             },
         };
-        this.sdk.Mattertag.editPosition(mattertagID, newPosition);
+        //this.sdk.Mattertag.editPosition(mattertagID, newPosition);
         this.sdk.Tag.editPosition(mattertagID, newPosition);
         this.dictionnaryTags
             .get(mattertagID)
@@ -3682,7 +4535,6 @@ class MatterportService {
             if (currentTag.elementID === object.id && tagId !== mattertagID) {
                 this.dictionnaryTags.delete(tagId);
                 this.sdk.Tag.remove(tagId);
-                this.sdk.Mattertag.remove(tagId);
                 break;
             }
         }
@@ -3692,19 +4544,8 @@ class MatterportService {
      * @param elementID string
      * @returns {tag: string | null, sweep: string | null}
      */
-    getTagFromElementId(elementID) {
-        let tagID = null;
-        let sweepID = null;
-        for (let [mattertagID, mattertagData] of this.dictionnaryTags) {
-            if (mattertagData.elementID === elementID) {
-                tagID = mattertagID;
-                const sweep = mattertagData.getSweepID();
-                if (sweep && this.sweeps && this.sweeps.includes(sweep)) {
-                    sweepID = sweep;
-                }
-            }
-        }
-        return { tag: tagID, sweep: sweepID };
+    getTagFromElementId(elementID) {
+        return this.matterportTagService.getTagFromElementId(elementID, this.sweeps);
     }
     /**
      * Gets latest tag created in the visit (when following the cursor to position)
@@ -3738,42 +4579,16 @@ class MatterportService {
     // ---------- Viewer related (switch views, go to) ----------
     //
     async action_toolbox_floorplan() {
-        if (this.inTransitionMode || this.inTransitionSweep) {
-            console.log('viewer is in transition, cannot go floorplan');
-            return;
-        }
-        try {
-            await this.sdk.Mode.moveTo('mode.floorplan');
-        }
-        catch (e) {
-            console.log('cannot go to floorplan', e);
-        }
+        return this.navigationService.action_toolbox_floorplan(this.sdk);
     }
     action_toolbox_inside_view() {
-        this.sdk.Mode.moveTo('mode.inside');
+        this.navigationService.action_toolbox_inside_view(this.sdk);
     }
     actionShowAllFloors() {
-        try {
-            this.sdk.Floor.showAll();
-        }
-        catch (e) {
-            console.log('cannot show all floors', e);
-        }
+        this.navigationService.actionShowAllFloors(this.sdk);
     }
     async action_toolbox_dollhouse() {
-        setTimeout(async () => {
-            // console.log("mode: ", this.inTransitionMode, " sweep: ", this.inTransitionSweep);
-            if (this.inTransitionMode || this.inTransitionSweep) {
-                console.log('viewer is in transition, cannot go dollhouse');
-                return;
-            }
-            try {
-                await this.sdk.Mode.moveTo('mode.dollhouse');
-            }
-            catch (e) {
-                console.log('cannot go to dollhouse', e);
-            }
-        }, 1200);
+        return this.navigationService.action_toolbox_dollhouse(this.sdk);
     }
     action_toolbox_mesure() {
         const newState = !this.isMeasureModeOn;
@@ -3787,70 +4602,13 @@ class MatterportService {
         }
     }
     async action_go_to_floor(floorName, matterportFloorSequence = null) {
-        if (!this.floors) {
-            console.log('Floor are not loaded yet');
-            return;
-        }
-        // console.log(this.floors);
-        // look up for sequence number (the safest method)
-        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));
-        }
-        // console.log(floorMatterport)
-        if (floorMatterport) {
-            let retry = true;
-            while (retry) {
-                try {
-                    const floorIndex = await this.sdk.Floor.moveTo(floorMatterport.sequence);
-                    // console.log("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');
-        }
+        return this.navigationService.action_go_to_floor(this.sdk, floorName, matterportFloorSequence);
     }
-    async action_go_to_sweep(sweep, rotation = null) {
-        if (this.forbiddenSweeps.includes(sweep)) {
-            console.log('user is not allowed to go to this sweep');
-            return;
-        }
-        // console.log("going to sweep", sweep, "with rotation:", rotation);
-        setTimeout(async () => {
-            if (this.inTransitionMode || this.inTransitionSweep) {
-                console.log('Cannot go to sweep, in transition');
-                return;
-            }
-            try {
-                this.inTransitionSweep = true;
-                await this.sdk.Sweep.moveTo(sweep, {
-                    transition: 'transition.instant',
-                    transitionTime: 1500,
-                });
-            }
-            catch (error) {
-                this.inTransitionSweep = false;
-                console.log('Cannot move to sweep', error);
-            }
-            if (rotation) {
-                await this.sdk.Camera.setRotation(rotation, { speed: 100 }); // speed is degrees per second
-            }
-        }, 1000);
+    async action_go_to_sweep(sweep, rotation) {
+        return this.navigationService.action_go_to_sweep(this.sdk, sweep, rotation);
     }
     getCurrentSweep() {
-        if (this.poseCamera) {
-            return this.poseCamera.sweep;
-        }
-        return null;
+        return this.navigationService.getCurrentSweep(this.poseCamera);
     }
     getCurrentCameraPosition() {
         if (this.poseCamera) {
@@ -3869,341 +4627,54 @@ class MatterportService {
      */
     async clearAll() {
         console.log('removing viewer');
-        this.action_delete_all_mattertags();
+        await this.action_delete_all_mattertags();
         this.floors = null;
         this.sweeps = null;
         this.sdk = null;
-        clearInterval(this.timerPointer);
+        this.pointerService.clear({
+            onLeftClick: this.pointerLeftClickHandler.bind(this),
+            onRightClick: this.pointerRightClickHandler.bind(this),
+            onMiddleClick: this.pointerMiddleClickHandler.bind(this),
+        });
         this.forbiddenSweeps = [];
-        this.tagMessengerOn = false;
-        // cancel subscriptions
-        this.pointerButton.removeEventListener('click', this.pointerLeftClickHandler);
-        this.pointerButton.removeEventListener('contextmenu', this.pointerRightClickHandler);
-        // TODO: only For Admins
-        if (this.getCursorPositionButton) {
-            this.getCursorPositionButton.removeEventListener('auxclick', this.pointerMiddleClickHandler);
-        }
-        // TODO: only for dev!
-        if (!!this.getCursorPositionButton &&
-            (document.location.href.indexOf('dev') !== -1 || document.location.href.indexOf('localhost') !== -1)) {
-            clearInterval(this.intervalCursorPointerPosition);
-        }
     }
     async removeForbiddenSweeps(forbiddenSweeps) {
-        this.forbiddenSweeps = [...forbiddenSweeps];
-        let removed = 0;
-        await Promise.all(forbiddenSweeps.map(async (sweep) => {
-            try {
-                await this.sdk.Sweep.disable(sweep);
-                removed += 1;
-            }
-            catch (error) {
-                console.log(error);
-            }
-        }));
-        console.log('removed sweeps:', removed);
+        return this.navigationService.removeForbiddenSweeps(this.sdk, forbiddenSweeps);
     }
     //
     // ---------- 3D objects (SDK Bundle only) ----------
     //
     async init3DObjectViewer() {
-        return new Promise(async (resolve) => {
-            var [sceneObject] = await this.sdk.Scene.createObjects(1);
-            var node = sceneObject.addNode();
-            // TODO change this 🤮
-            node.addComponent('mp.lights');
-            //node.addComponent('mp.lights');
-            /*node.addComponent('mp.lights');
-            node.addComponent('mp.lights');*/
-            node.start();
-            const nodeControl = sceneObject.addNode();
-            this.objectControl = nodeControl.addComponent('mp.transformControls');
-            nodeControl.start();
-            //this.add3DObject({},null);
-            resolve();
-        });
+        return this.object3DService.init3DObjectViewer(this.sdk);
     }
     async add3DObject(obj, mode) {
-        return new Promise(async (resolve) => {
-            const [sceneObject] = await this.sdk.Scene.createObjects(1);
-            // TODO: improvment, regroup all of these in Dynamical Objects Lib
-            // SecurityCamera
-            // NestThermostat
-            // Video
-            let isAnimatedSecurityCamera = false;
-            let isNestThermostat = false;
-            let isSmarterplanPromotionalVideo = false;
-            let isAzimuthalCrown = false;
-            /**
-             * TODO: refacto with an enum or switch/case
-             */
-            if (obj.object === "security_camera") {
-                isAnimatedSecurityCamera = true;
-            }
-            if (obj.object === "nest_thermostat") {
-                isNestThermostat = true;
-            }
-            if (obj.object === 'video') {
-                isSmarterplanPromotionalVideo = true;
-            }
-            if (obj.object === 'azimuth') {
-                isAzimuthalCrown = true;
-            }
-            const modelNode = sceneObject.addNode();
-            let component = null;
-            const initial = {
-                url: `/assets/3Dobjects/objects/${obj.object}${obj.format.indexOf('.') === -1 ? '.' + obj.format : obj.format}`,
-                // TODO/ store localPosition && localRotation in BDD too (in order to have pertfect initial placement)
-                localRotation: { "x": 0, "y": 0, "z": 0 },
-                // TODO/ store localPosition && localRotation in BDD too (in order to have pertfect initial placement)
-                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':
-                    component = modelNode.addComponent('mp.gltfLoader', initial);
-                    break;
-                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;
-            }
-            //cache system (i'll try to make it work later ...)
-            /*let objContentsJSON = JSON.stringify(modelNode);
-            console.log(modelNode);
-            console.log(objContentsJSON);
-            console.log(JSON.stringify(modelNode));
-            localStorage.setItem(`testObj_${obj.object}`, objContentsJSON);
-            console.log("stored ?!");
-            console.log(typeof modelNode);*/
-            //let dataS = serialijse.serialize(modelNode);
-            //console.log(dataS);
-            // Use 3 ?! Ambient lightings
-            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) {
-                /*if(modelNode.obj3D.scale.x >= 1.0){
-                  modelNode.obj3D.scale.set(obj.scale.x/5000, obj.scale.y/5000, obj.scale.z/5000);
-                }*/
-                this.azimuthalCrown = modelNode;
-                this.displayAzimutalCrown();
-            }
-            // By defaut, during creation, object has translation gizmo
-            // => User has to click on lateral panel, and save its position after playing with it!
-            if (mode && !isNestThermostat) {
-                this.attachGizmoControlTo3DObject(modelNode, sceneObject, mode, true, true).catch((e) => console.log(e));
-            }
-            if (this.lastObject3D && typeof this.lastObject3D.id === 'string') {
-                // prompt ThreeJS UUID to match our last generated object if new (not from Db)
-                modelNode.obj3D.uuid = this.lastObject3D.id;
-            }
-            else if (obj.id) {
-                modelNode.obj3D.uuid = obj.id;
-            }
-            this.lastObject3D = modelNode.obj3D;
-            // Store this in memory Map dictionnary
-            //console.log("Adding object: ");
-            //console.log(modelNode);
-            this.dictionnaryObjects3D.set(modelNode.obj3D.uuid, modelNode);
-            this.dictionnarySceneObjects3D.set(modelNode.obj3D.uuid, sceneObject);
-            /*this.sdk.Camera.pose.subscribe(
-              function (pose: any) {
-                //console.log("in callback")
-                //console.log(this.lastCameraPosition)
-                //console.log(pose.position)
-                if((pose.position.x == this.lastCameraPosition.x && pose.position.y == this.lastCameraPosition.y && pose.position.z == this.lastCameraPosition.z) || this.inTransitionMode || this.inTransitionSweep){
-                  //console.log("returning")
-                  return;
-                }
-                console.log("camera pos:",pose.position);
-                this.lastCameraPosition = {...pose.position};
-                if(this.lastObject3D){
-                  this.lastObject3D.position.set(pose.position.x+.5,pose.position.y+.5,pose.position.z+.5);
-                }
-              }.bind(this));*/
-            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
-                });
-                const modelOutput = sceneObject.addPath({
-                    id: 'animated-model',
-                    type: this.sdk.Scene.PathType.OUTPUT,
-                    node: modelNode,
-                    component: animator,
-                    property: 'objectRoot'
-                });
-                this.securityCameraAnimator = animator;
-                if (!obj.viewFrustum) {
-                    setTimeout(() => {
-                        animator.toggleViewFrustum();
-                    }, 1000);
-                }
-            }
-            if (isNestThermostat) {
-                // TODO: use bindPath instead using MP sdk classes (see Security Camera example)
-                // for TV uses CanvasImage below!
-                // const ci = new CanvasImage();
-                // ci.onInit();
-                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) {
-                // TODO: use bindPath instead using MP sdk classes (see Security Camera example)
-                const sc = new TvPlayer();
-                sc.setComponent(component);
-                sc.onInit(modelNode);
-                setTimeout(() => {
-                    sc.inputs.loadingState = "Loaded";
-                    sc.onInputsUpdated();
-                }, 5000);
-            }
-            sceneObject.start();
-            resolve(this.lastObject3D);
-        });
+        return this.object3DService.add3DObject(this.sdk, obj, mode);
     }
     toggleObjectVisibility(objectId) {
-        let obj = this.dictionnaryObjects3D.get(objectId);
-        obj.obj3D.visible = !obj.obj3D.visible;
+        this.object3DService.toggleObjectVisibility(objectId);
     }
     isObjectVisible(objectId) {
-        let obj = this.dictionnaryObjects3D.get(objectId);
-        return obj.obj3D.visible;
+        return this.object3DService.isObjectVisible(objectId);
     }
     async pointCameraTo3DObject(objectId) {
-        let obj = this.dictionnaryObjects3D.get(objectId);
-        //We create a temporary Tag
-        const poiObject = {
-            coordinate: JSON.stringify(obj.obj3D.position),
-            type: PoiType.OBJECT3D,
-            elementID: objectId, //todo: be careful with this
-        };
-        const objectDb = { id: objectId };
-        try {
-            await this.createMattertagFromPOI(PoiType.OBJECT3D, objectDb, poiObject);
-        }
-        catch (err) { }
-        //Not really necessary anymore since the tag will disappear quick
-        //this.sdk.Tag.editOpacity(mattertagID, 0.0);//opacity);
-        //this.sdk.Tag.allowAction(mattertagID, {}); //disables every action
-        let result = this.getTagFromElementId(objectId);
-        await this.goToTag(result.tag);
-        this.deleteLastMattertag();
+        return this.object3DService.pointCameraTo3DObject(this.sdk, objectId, this.createMattertagFromPOI.bind(this), this.goToTag.bind(this), this.deleteLastMattertag.bind(this), this.getTagFromElementId.bind(this));
     }
     getSceneNodeFromObject3DId(uuid) {
-        return this.dictionnarySceneObjects3D.get(uuid);
+        return this.object3DService.getSceneNodeFromObject3DId(uuid);
     }
     async displayAzimutalCrown() {
-        if (this.azimuthalCrown) {
-            this.azimuthalCrown.obj3D.position.set(this.poseCamera.position.x, this.poseCamera.position.y, this.poseCamera.position.z);
-        }
+        return this.object3DService.displayAzimutalCrown(this.poseCamera);
     }
     async attachGizmoControlTo3DObject(modelNode, sceneObject, mode, visible, isNewObject) {
-        // Create a scene node with a transform control component.
-        let node = null;
-        node = sceneObject.addNode();
-        if (!node) {
-            const [sceneObject] = await this.sdk.Scene.createObjects(1);
-            node = sceneObject.addNode();
-        }
-        const myControl = node.addComponent('mp.transformControls');
-        node.start();
-        //
-        // // Make the transform control visible so that the user can manipulate the control selection.
-        myControl.transformControls.visible = visible;
-        //
-        // // Attach the model to the transform control
-        myControl.inputs.selection = modelNode;
-        //
-        // // set 'translate' mode to position the selection.
-        myControl.inputs.mode = mode;
-        modelNode.obj3D.controls = myControl; // store gizmoCtrl inside object
-        if (isNewObject) { //i keep the current solution for new objects
-            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 since`);
-                }
-                this.lastObject3D = modelNode.obj3D;
-            }
-        }
-        else { //objects already in place have to become the "lastObject" (i think?)
-            console.log("in my solution !");
-            console.log(modelNode);
-            console.log(modelNode.obj3D.uuid);
-            this.lastObject3D = modelNode.obj3D;
-        }
-        return modelNode;
+        return this.object3DService.attachGizmoControlTo3DObject(this.sdk, modelNode, sceneObject, mode, visible, isNewObject);
     }
     removeGizmoFromLastObject() {
-        this.lastObject3D.controls.transformControls.visible = false;
-        this.lastObject3D.controls.transformControls.dispose();
-        this.lastObject3D.controls = null;
+        this.object3DService.removeGizmoFromLastObject();
     }
     toggleViewFrustum() {
-        this.securityCameraAnimator.toggleViewFrustum();
+        this.object3DService.toggleViewFrustum();
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportService, deps: [{ token: 'config' }, { token: i1$1.Router }, { token: i1$1.ActivatedRoute }, { token: BaseVisibilityService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportService, deps: [{ token: 'config' }, { token: i1$1.Router }, { token: i1$1.ActivatedRoute }, { token: BaseVisibilityService }, { token: i0.NgZone }, { token: MatterportMeasurementService }, { token: MatterportNavigationService }, { token: MatterportPointerService }, { token: MatterportObject3DService }, { token: MatterportTagService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportService, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportService, decorators: [{
@@ -4214,7 +4685,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
         }], ctorParameters: () => [{ type: Config, decorators: [{
                     type: Inject,
                     args: ['config']
-                }] }, { type: i1$1.Router }, { type: i1$1.ActivatedRoute }, { type: BaseVisibilityService }, { type: i0.NgZone }] });
+                }] }, { type: i1$1.Router }, { type: i1$1.ActivatedRoute }, { type: BaseVisibilityService }, { type: i0.NgZone }, { type: MatterportMeasurementService }, { type: MatterportNavigationService }, { type: MatterportPointerService }, { type: MatterportObject3DService }, { type: MatterportTagService }] });
 
 /* eslint-disable no-await-in-loop */
 /* eslint-disable camelcase */
@@ -4275,21 +4746,50 @@ class ViewerService {
     setMode(indexMode) {
         this.viewerMode = indexMode;
     }
-    setTourUrl(model3d, showIconPlan = true, showIconDollhouse = true, showIconFloors = true, enableQuickStart = true) {
-        // this.tourUrl = `https://my.matterport.com/show/?m=${model3d}&play=1&hr=0&gt=0&title=0&log=0&brand=0&search=0&applicationKey=qn9wsasuy5h2fzrbrn1nzr0id&mds=0&newtags=1`;
-        this.tourUrl = `/assets/bundle/showcase.html?m=${model3d}&play=1&hr=0&gt=0&title=0&log=0&brand=0&search=0&applicationKey=qn9wsasuy5h2fzrbrn1nzr0id&mds=0&newtags=1`;
+    setTourUrl(model3d, showIconPlan = true, showIconDollhouse = true, showIconFloors = true, showQuickStart = true, showFullscreen = true, showGuidedTour = true, showHighlightReel = true) {
+        const baseUrl = `/assets/bundle/showcase.html`;
+        const params = [];
+        // Modèle
+        params.push(`m=${model3d}`);
+        // Comportement général
+        params.push(`play=1`);
+        params.push(`ui=1`);
+        params.push(`title=0`);
+        params.push(`log=0`);
+        params.push(`brand=0`);
+        params.push(`search=0`);
+        params.push(`applicationKey=qn9wsasuy5h2fzrbrn1nzr0id`);
+        params.push(`mds=0`);
+        // Quick start
+        if (showQuickStart) {
+            params.push(`qs=1`);
+        }
+        // Floorplan (plan)
         if (!showIconPlan) {
-            this.tourUrl += '&fp=0';
+            params.push(`fp=0`);
         }
+        // Dollhouse (maison/poupée)
         if (!showIconDollhouse) {
-            this.tourUrl += '&dh=0';
+            params.push(`dh=0`);
         }
+        // Sélecteur d’étages
         if (!showIconFloors) {
-            this.tourUrl += '&f=0';
+            params.push(`sf=0`);
+        }
+        // Guided tour
+        if (!showGuidedTour) {
+            params.push(`gt=0`);
         }
-        if (enableQuickStart) {
-            this.tourUrl += '&qs=1';
+        // Highlight reel (bande du bas)
+        if (!showHighlightReel) {
+            // Selon ton bundle : hr=1 ou hr=0 masque
+            params.push(`hr=1`);
         }
+        // Plein écran
+        if (!showFullscreen) {
+            params.push(`fs=0`);
+        }
+        this.tourUrl = `${baseUrl}?${params.join("&")}`;
     }
     async clearAll() {
         // this.sweepToMove = null;
@@ -4552,19 +5052,15 @@ class ViewerService {
             .then(async (result) => {
             if (result) {
                 const { sdk } = this.matterportService;
-                // TODO: add condition whether we want to enable it or not
-                // Additionnal extensions for Matterport
-                // 1. Security Camera with Frustum (FOV)
-                // 2. TODO register all new Matterport extensions here (nestSensor, lods, slots, ...)
                 await Promise.all([
                     sdk.Scene.register(securityCameraType, makeSecurityCamera.bind(sdk.Scene)),
                     sdk.Scene.register(ViewFrustumMeshType, makeViewFrustumMesh.bind(sdk.Scene))
                 ]);
+                this.showingViewer = true;
                 sdk.App.state.subscribe(function (appState) {
-                    // app state has changed
-                    // console.log('The current phase: ', appState.phase);
+                    console.debug('The current phase: ', appState.phase);
                     if (appState.phase === sdk.App.Phase.PLAYING) {
-                        // console.log('The app is playing');
+                        console.log('The app is playing');
                         this.showingViewer = true;
                         this.viewerIsOn.next({
                             spaceID,
@@ -4578,6 +5074,16 @@ class ViewerService {
                         this.rotationToMove = null;
                     }
                 }.bind(this));
+                this.viewerIsOn.next({
+                    spaceID,
+                    model3D,
+                    sweep: this.sweepToMove,
+                    rotation: this.rotationToMove,
+                });
+                this.dataIsLoaded.next(true);
+                this.isLoaded = true;
+                this.sweepToMove = null;
+                this.rotationToMove = null;
                 return Promise.resolve();
             }
             return Promise.reject();
@@ -5012,6 +5518,23 @@ function openModalForVisitSwitch(modalService, model3D, spaceID, dataToMove = nu
         modalReference.componentInstance.dataToMove = dataToMove;
     }
 }
+function getCurrentLang(translate) {
+    let lang = translate.getCurrentLang() || translate.getFallbackLang() || "fr";
+    // Clean up leading mess
+    lang = lang.replace(/^[_-]+/, '');
+    // Handle fr_FR or fr-FR (take primary language)
+    if (lang.includes("_")) {
+        lang = lang.split("_")[0];
+    }
+    if (lang.includes("-")) {
+        lang = lang.split("-")[0];
+    }
+    // Ensure 2-letter code (ISO 639-1)
+    if (lang.length > 2) {
+        lang = lang.substring(0, 2);
+    }
+    return lang;
+}
 /**
  * Return a string of a given date time in local format.
  * The format is determined by the current language.
@@ -5019,14 +5542,7 @@ function openModalForVisitSwitch(modalService, model3D, spaceID, dataToMove = nu
 function dateTimeToLocalString(date, translate, mode) {
     let lang = "en-EN";
     if (translate) {
-        /** Get current language */
-        lang = translate.currentLang
-            ? translate.currentLang
-            : translate.defaultLang;
-        /** Transforme '_fr' to 'fr' */
-        if (lang) {
-            lang = lang.slice(1);
-        }
+        lang = getCurrentLang(translate);
     }
     let options;
     switch (mode) {
@@ -5155,11 +5671,7 @@ function translateDatePeriod(translateService, dateStartPeriod, dateEndPeriod) {
 * Return local in the canonical form: "en-GB", "fr-FR"
 */
 function getLocaleLong(translate) {
-    let lang = translate.currentLang
-        ? translate.currentLang
-        : translate.defaultLang;
-    /** Transform '_fr' to 'fr' */
-    lang = lang.slice(1);
+    let lang = getCurrentLang(translate);
     if (lang === "en") {
         return "en-GB";
     }
@@ -5169,12 +5681,7 @@ function getLocaleLong(translate) {
  * Return local in the short form: "en", "fr"
  */
 function getLocaleShort(translate) {
-    let lang = translate.currentLang
-        ? translate.currentLang
-        : translate.defaultLang;
-    /** Transform '_fr' to 'fr' */
-    lang = lang.slice(1);
-    return lang;
+    return getCurrentLang(translate);
 }
 /**
  * Format string to lowercase, no spaces
@@ -5243,6 +5750,12 @@ function durationToString(duration, translate) {
     }
     return `${seconds} ${secondsString}`;
 }
+function pointToString(point) {
+    const x = point.x.toFixed(3);
+    const y = point.y.toFixed(3);
+    const z = point.z.toFixed(3);
+    return `{ x: ${x}, y: ${y}, z: ${z} }`;
+}
 
 /* eslint-disable class-methods-use-this */
 class ZoneService {
@@ -6635,6 +7148,11 @@ class NavigatorService {
         // if first load and zones are not set
         this.zonesForUserForSpace = await this.zoneService.getZonesBySpaceForUser(this.currentSpaceID);
         this.audioZonesForUserForSpace = this.zonesForUserForSpace.filter((zone) => zone.audioID);
+        this.zonesForUserForSpace = await this.zoneService.getZonesBySpaceForUser(this.currentSpaceID);
+        this.audioZonesForUserForSpace = this.zonesForUserForSpace.filter((zone) => zone.audioID);
+        if (!this.currentSweep) {
+            this.currentSweep = this.matterportService.getCurrentSweep();
+        }
         this.setZonesForCurrentSweep();
     }
     checkRotationForSweep(sweep) {
@@ -6648,7 +7166,10 @@ class NavigatorService {
         if (!this.currentSweep) {
             return;
         }
-        let zonesForSweep = this.zonesForUserForSpace?.filter((zone) => zone.sweepIDs && zone.sweepIDs.includes(this.currentSweep));
+        const uuid = this.matterportService.getSweepUUIDForSid(this.currentSweep);
+        console.log('uuid', uuid);
+        const sweepToMatch = uuid ?? this.currentSweep;
+        let zonesForSweep = this.zonesForUserForSpace?.filter((zone) => zone.sweepIDs && zone.sweepIDs.includes(sweepToMatch));
         const audioZones = this.audioZonesForUserForSpace?.filter((zone) => zone.sweepIDs && zone.sweepIDs.includes(this.currentSweep));
         this.audioZonesChange.next(audioZones);
         this.currentAudioZones = audioZones;
@@ -6939,7 +7460,7 @@ class TicketsService extends BaseObjectService {
         zone: [],
         space: [],
     };
-    ticketTags = new Subject();
+    ticketTags = new BehaviorSubject(null);
     ticketsFiltered = [];
     ticketsUpdated = new Subject();
     currentSpaceID;
@@ -7391,7 +7912,6 @@ class TicketsService extends BaseObjectService {
             }
         }
         else {
-            /** Si on force le switch de la visit */
             window.open(`${url}?model3D=${result.model3D}&sweep=true`, '_blank');
         }
     }
@@ -7465,7 +7985,7 @@ class EquipmentService extends BaseObjectService {
         space: [],
         zonesMap: new Map(),
     };
-    equipmentsTags = new Subject();
+    equipmentsTags = new BehaviorSubject(null);
     zoneIDFilter;
     currentZone;
     currentSpaceID;
@@ -7942,7 +8462,6 @@ class EquipmentService extends BaseObjectService {
             }
         }
         else {
-            /** Si on force le switch de la visit */
             window.open(`${url}?model3D=${result.model3D}&sweep=true`, '_blank');
         }
     }
@@ -8461,13 +8980,8 @@ class TimeDateToLocalStringPipe {
         let lang = "en-EN";
         if (this.translate) {
             /** Get current language */
-            lang = this.translate.getCurrentLang()
-                ? this.translate.getCurrentLang()
-                : this.translate.getFallbackLang();
-            /** Transforme '_fr' to 'fr' */
-            if (lang) {
-                lang = lang.slice(1);
-            }
+            const currentLang = this.translate.getCurrentLang() || this.translate.getFallbackLang() || "fr";
+            lang = currentLang.replace(/^[_-]+/, '').substring(0, 2);
         }
         let options;
         switch (mode) {
@@ -8802,10 +9316,8 @@ class LocaleService {
         this.translate.use(`_${lang}`); // because files are "_en.json"
     }
     getLocale() {
-        const lang = this.translate.getCurrentLang()
-            ? this.translate.getCurrentLang()
-            : this.translate.getFallbackLang();
-        return lang.slice(1);
+        const currentLang = this.translate.getCurrentLang() || this.translate.getFallbackLang() || "fr";
+        return currentLang.replace(/^[_-]+/, '').substring(0, 2);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocaleService, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocaleService, providedIn: "root" });
@@ -10278,7 +10790,7 @@ class FeatureService extends BaseObjectService {
         space: [],
         zone: [],
     };
-    featureTags = new Subject();
+    featureTags = new BehaviorSubject(null);
     featureFiltered = [];
     updateDone = new Subject();
     zoneIDFilter;
@@ -10649,7 +11161,7 @@ class MeasurementService {
     navigationService;
     path = 'measurements/';
     currentMeasurements = { space: [], zone: [] };
-    measurementsTags = new Subject();
+    measurementsTags = new BehaviorSubject(null);
     measurementsUpdated = new Subject();
     currentSpaceID;
     zoneIDFilter;
@@ -11804,10 +12316,32 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
 /* eslint-disable class-methods-use-this */
 class BaseTagService {
     constructor() { }
+    /** Base implementation for generating tag HTML. Override in derived classes. */
     async getHtmlToInject(tagType, object) {
-        throw new Error(`getHtmlToInject is not implemented in the base class. 
-        Please override this method in your extended class.`);
+        return "";
+    }
+    /** Base implementation for injecting HTML into a tag container. */
+    async injectHtml(container, tagType, object) {
+        if (!container) {
+            console.warn('injectHtml: container is null');
+            return;
+        }
+        try {
+            const html = await this.getHtmlToInject(tagType, object);
+            if (!html || html.trim().length === 0) {
+                console.warn(`Empty HTML returned for ${tagType}`);
+                container.innerHTML = `<div class="tag-div" style="color: white; padding: 10px;">Base implementation: No content for ${tagType}</div>`;
+            }
+            else {
+                container.innerHTML = html;
+            }
+        }
+        catch (error) {
+            console.error('Error in injectHtml:', error);
+            container.innerHTML = `<div class="tag-div" style="color: white; padding: 10px;">Error: ${error.message}</div>`;
+        }
     }
+    /** Returns the navigation URL for viewing details of a specific object type. */
     getUrlForSeeDetails(object, tagType) {
         switch (tagType) {
             case PoiType.TICKET: {
@@ -11829,28 +12363,31 @@ class BaseTagService {
                 return '';
         }
     }
+    /*async updatePoiMetadata(poiId: string, metadata: string): Promise<void> {
+      throw new Error('updatePoiMetadata is not implemented in the base class.');
+    }*/
     async prepareEquipmentHtml(equip) {
-        throw new Error(`prepareEquipmentHtml is not implemented in the base class. 
+        throw new Error(`prepareEquipmentHtml is not implemented in the base class.
         Please override this method in your extended class.`);
     }
     async prepareTicketHtml(ticket) {
-        throw new Error(`prepareTicketHtml is not implemented in the base class. 
+        throw new Error(`prepareTicketHtml is not implemented in the base class.
                          Please override this method in your extended class.`);
     }
     async prepareFeatureHtml(feature) {
-        throw new Error(`prepareFeatureHtml is not implemented in the base class. 
+        throw new Error(`prepareFeatureHtml is not implemented in the base class.
                          Please override this method in your extended class.`);
     }
     async prepareMeasurementHtml(measure) {
-        throw new Error(`prepareMeasurementHtml is not implemented in the base class. 
+        throw new Error(`prepareMeasurementHtml is not implemented in the base class.
                          Please override this method in your extended class.`);
     }
     async prepareDeskHtml(feature) {
-        throw new Error(`prepareDeskHtml is not implemented in the base class. 
+        throw new Error(`prepareDeskHtml is not implemented in the base class.
                          Please override this method in your extended class.`);
     }
     async prepareIndicatorHtml(feature) {
-        throw new Error(`prepareDeskHtml is not implemented in the base class. 
+        throw new Error(`prepareDeskHtml is not implemented in the base class.
                          Please override this method in your extended class.`);
     }
     async getSignedTagIconSource(tagIconSrc) {
@@ -11859,31 +12396,32 @@ class BaseTagService {
     getIconTagImageForFeature(feature, poi) {
         // const tagIcon = JSON.parse(poi.tagIcon);
         // return tagIcon.src;
-        throw new Error(`getIconTagImageForFeature is not implemented in the base class. 
+        throw new Error(`getIconTagImageForFeature is not implemented in the base class.
                          Please override this method in your extended class.`);
     }
     getScriptForTag(object, tagType) {
-        throw new Error(`getScriptForTag is not implemented in the base class. 
+        throw new Error(`getScriptForTag is not implemented in the base class.
         Please override this method in your extended class.`);
     }
     getAnnexeForCommentTypeInFeature(feature, commentType) {
-        throw new Error(`getAnnexeForCommentTypeInFeature is not implemented in the base class. 
+        throw new Error(`getAnnexeForCommentTypeInFeature is not implemented in the base class.
         Please override this method in your extended class.`);
     }
     getBillboardMediaToEmbed(object) {
-        throw new Error(`getBillboardMediaToEmbed is not implemented in the base class. 
-        Please override this method in your extended class.`);
+        // Default implementation to prevent crash if base class is instantiated directly.
+        // Extended classes should override this method.
+        return { comment: null, tagDescription: '' };
     }
     onActionDetailClick(url) {
-        throw new Error(`onActionDetailClick is not implemented in the base class. 
+        throw new Error(`onActionDetailClick is not implemented in the base class.
         Please override this method in your extended class.`);
     }
     onActionAudioClick(audioCommentID) {
-        throw new Error(`onActionDetailClick is not implemented in the base class. 
+        throw new Error(`onActionDetailClick is not implemented in the base class.
         Please override this method in your extended class.`);
     }
     onActionVideoClick(url) {
-        throw new Error(`onActionVideoClick is not implemented in the base class. 
+        throw new Error(`onActionVideoClick is not implemented in the base class.
         Please override this method in your extended class.`);
     }
     onActionImageClick(imageCommentID) {
@@ -11891,11 +12429,11 @@ class BaseTagService {
         Please override this method in your extended class.`);
     }
     onActionDocClick(url) {
-        throw new Error(`onActionDocClick is not implemented in the base class. 
+        throw new Error(`onActionDocClick is not implemented in the base class.
         Please override this method in your extended class.`);
     }
     onActionYoutubeClick(url) {
-        throw new Error(`onActionYoutubeClick is not implemented in the base class. 
+        throw new Error(`onActionYoutubeClick is not implemented in the base class.
         Please override this method in your extended class.`);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseTagService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
@@ -12022,7 +12560,7 @@ class MatterportImportService {
         return new Promise((res, rej) => {
             iframe.addEventListener('load', async () => {
                 try {
-                    this.sdk = await showcaseWindow.MP_SDK.connect(iframe, 'qn9wsasuy5h2fzrbrn1nzr0id', '3.11');
+                    this.sdk = await showcaseWindow.MP_SDK.connect(iframe, 'qn9wsasuy5h2fzrbrn1nzr0id', '');
                     // Subscribe to Floor data
                     this.sdk.Floor.data.subscribe({
                         onCollectionUpdated: function upd(collection) {
@@ -12152,7 +12690,7 @@ class MatterportImportService {
             const start = overrideExisting ? 0 : await this.getUploadedImageCount(this.modelID);
             for (let index = start; index < nmbScans; index += 1) {
                 if (!this.stop) {
-                    await this.sdk.Sweep.moveTo(scans[index].uuid, { rotation: { x: 0, y: 0 }, transition: this.sdk.Sweep.Transition.INSTANT, transitionTime: 0 });
+                    await this.sdk.Sweep.moveTo(scans[index].uuid, { rotation: { x: 0, y: 0 }, transition: this.sdk.Camera.TransitionType.INSTANT, transitionTime: 0 });
                     const img = await this.sdk.Renderer.takeEquirectangular({ width: 2048, height: 1024 }, { mattertags: false, sweeps: true });
                     /**Upload on S3 are asynchronous, in order to no slow down the process*/
                     uploadBase64ImageWithRetry(img, scans[index].uuid, `visits/${this.modelID}/sweeps/`, 'sweep', 5).then((r) => {
@@ -12875,5 +13413,5 @@ function floatValidator() {
  * Generated bundle index. Do not edit.
  */
 
-export { AffectationService, AvatarComponent, BaseLateralTabService, BaseTagService, BaseUserService, BaseVisibilityService, CameraMode, CaptureService, CaptureViewer, CommentService, CommentType, Config, ContentService, CsvExportComponent, DomainService, DomainType, DurationToStringPipe, EmailStatus, EquipmentService, EventService, EventStatus, EventType, FeatureService, FeatureType, FilterService, HashtagFromIdPipe, HashtagService, InterventionService, InventoryStatus, LayerService, LevelStatus, LoaderComponent, Locale, LocaleService, MatterportImportService, MatterportService, MattertagActionMode, MattertagData, MeasurementService, MenuBarComponent, MissionService, NavigationService, NavigatorService, NgxSmarterplanCoreModule, NgxSmarterplanCoreService, NodeService, Object3DService, OperationService, OrganisationService, PaymentStatus, PlanService, PoiService, PoiType, ProfileEntity, ProfileService, ProfileStatus, PropertyService, PropertyType, RoleStatus, SafeUrlPipe, SearchBarComponent, SearchObjectType, SearchService, SpModule, SpaceService, SpaceStatus, StatusEquipment, SupportModalComponent, SupportService, TagAction, TemplateService, TicketPriority, TicketStatus, TicketType, TicketsService, TimeDateToLocalStringPipe, TypeNote, UsernameFromIdPipe, ValidatorsService, ViewerInteractions, ViewerService, VisitService, ZoneChangeService, ZoneService, arraysContainSameElements, checkElementById, convertTimestampToLocalZone, dateHasExpired, dateTimeToLocalString, deleteFromS3, downloadBlob, downloadEquipmentDocument, downloadFile, downloadFileAsObject, durationToString, emailValidator, enumToArray, filterUniqueArrayByID, floatValidator, getBufferForFileFromS3, getCoefficientsForImage, getDistanceBetweenTwoPoints, getHighestLevelForMissions, getHighestRoleForMissions, getLevelsBelow, getLocaleLong, getLocaleShort, getMetaForImage, getRolesBelowForManager, getSignedFile, getSignedImageUrlForEquipment, getSignedImageUrlForProfile, getSignedImageUrlForSpace, getSpaceIDFromUrl, getVisitUrl, isEmptyObject, listFilesInFolder, mean, noEmptyValidator, numberToDateString, openDocument, openModalForVisitSwitch, poiTypeToString, removeAllFilesFromFolderS3, removeNullKeysFromObject, showScanPointsOnPlanInDiv, shuffleArray, sortAlphabeticallyOnName, stringLocaleToEnum, stringToLowercaseNoSpaces, styleButton, textValidator, translateDatePeriod, uploadBase64Image, uploadBase64ImageWithRetry, uploadFileToS3, uploadJsonToS3, validEmail, wait, waitUntil };
+export { AffectationService, AvatarComponent, BaseLateralTabService, BaseTagService, BaseUserService, BaseVisibilityService, CameraMode, CaptureService, CaptureViewer, CommentService, CommentType, Config, ContentService, CsvExportComponent, DomainService, DomainType, DurationToStringPipe, EmailStatus, EquipmentService, EventService, EventStatus, EventType, FeatureService, FeatureType, FilterService, HashtagFromIdPipe, HashtagService, InterventionService, InventoryStatus, LayerService, LevelStatus, LoaderComponent, Locale, LocaleService, MatterportImportService, MatterportService, MattertagActionMode, MattertagData, MeasurementService, MenuBarComponent, MissionService, NavigationService, NavigatorService, NgxSmarterplanCoreModule, NgxSmarterplanCoreService, NodeService, Object3DService, OperationService, OrganisationService, PaymentStatus, PlanService, PoiService, PoiType, ProfileEntity, ProfileService, ProfileStatus, PropertyService, PropertyType, RoleStatus, SafeUrlPipe, SearchBarComponent, SearchObjectType, SearchService, SpModule, SpaceService, SpaceStatus, StatusEquipment, SupportModalComponent, SupportService, TagAction, TemplateService, TicketPriority, TicketStatus, TicketType, TicketsService, TimeDateToLocalStringPipe, TypeNote, UsernameFromIdPipe, ValidatorsService, ViewerInteractions, ViewerService, VisitService, ZoneChangeService, ZoneService, arraysContainSameElements, checkElementById, convertTimestampToLocalZone, dateHasExpired, dateTimeToLocalString, deleteFromS3, downloadBlob, downloadEquipmentDocument, downloadFile, downloadFileAsObject, durationToString, emailValidator, enumToArray, filterUniqueArrayByID, floatValidator, getBufferForFileFromS3, getCoefficientsForImage, getCurrentLang, getDistanceBetweenTwoPoints, getHighestLevelForMissions, getHighestRoleForMissions, getLevelsBelow, getLocaleLong, getLocaleShort, getMetaForImage, getRolesBelowForManager, getSignedFile, getSignedImageUrlForEquipment, getSignedImageUrlForProfile, getSignedImageUrlForSpace, getSpaceIDFromUrl, getVisitUrl, isEmptyObject, listFilesInFolder, mean, noEmptyValidator, numberToDateString, openDocument, openModalForVisitSwitch, poiTypeToString, pointToString, removeAllFilesFromFolderS3, removeNullKeysFromObject, showScanPointsOnPlanInDiv, shuffleArray, sortAlphabeticallyOnName, stringLocaleToEnum, stringToLowercaseNoSpaces, styleButton, textValidator, translateDatePeriod, uploadBase64Image, uploadBase64ImageWithRetry, uploadFileToS3, uploadJsonToS3, validEmail, wait, waitUntil };
 //# sourceMappingURL=smarterplan-ngx-smarterplan-core.mjs.map