@smarterplan/ngx-smarterplan-core 1.4.19 → 1.4.21

package/esm2022/lib/services/threejs.service.mjs

@@ -6,6 +6,9 @@ import { MTLLoader } from 'three/examples/jsm/loaders/MTLLoader';
 import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader';
 import { KTX2Loader } from 'three/examples/jsm/loaders/KTX2Loader';
 import { MeshoptDecoder } from 'three/examples/jsm/libs/meshopt_decoder.module.js';
+import { Line2 } from 'three/examples/jsm/lines/Line2';
+import { LineGeometry } from 'three/examples/jsm/lines/LineGeometry';
+import { LineMaterial } from 'three/examples/jsm/lines/LineMaterial';
 import { Subject } from 'rxjs';
 import * as i0 from "@angular/core";
 /**
@@ -30,20 +33,29 @@ function frameFromPoints(a, b, c) {
     return new THREE.Matrix4().makeBasis(e1, e2, e1.clone().cross(e2));
 }
 /**
- * Solves the transform that maps stored tag coordinates onto the loaded model.
+ * Solves the transform that maps stored tag coordinates onto the loaded model, from as many matched
+ * tags as there are - up to three.
  *
- * Takes exactly the correspondences a person can produce by hand: three tags, each pointed at twice
- * - once where it currently sits, once where it belongs. That is the minimum that pins down all
- * three parts of the answer. One pair fixes only translation; two leave the rotation about the line
- * between them free; three resolve it.
+ * Three pairs pin down everything: position, orientation and scale. A model that shares only a
+ * corner with the tags' space may not have three tags to offer, so fewer are accepted, each
+ * settling what it can and assuming the rest:
  *
- * Returns null when the points are collinear or degenerate, because a wrong alignment applied
- * silently is worse than none.
+ *  - Two pairs: position, heading and scale. The one thing two points cannot say is how the model
+ *    is tilted, so both spaces are taken to agree on which way is up.
+ *  - One pair: position only. Heading and scale are taken to match already.
+ *
+ * `targetUp` is the model's vertical axis, which the tags' own vertical (+Y) is matched to in those
+ * two cases. Returns null when the points cannot answer the question asked of them - collinear for
+ * three, one above the other for two - because a wrong calibration applied silently is worse than
+ * none.
  */
-export function solveThreeJsAlignment(pairs) {
-    if (!pairs || pairs.length < 3) {
+export function solveThreeJsAlignment(pairs, targetUp = { x: 0, y: 1, z: 0 }) {
+    if (!pairs || pairs.length === 0) {
         return null;
     }
+    if (pairs.length < 3) {
+        return solveReducedAlignment(pairs, new THREE.Vector3(targetUp.x, targetUp.y, targetUp.z).normalize());
+    }
     const sources = pairs.slice(0, 3).map((pair) => new THREE.Vector3(pair.source.x, pair.source.y, pair.source.z));
     const targets = pairs.slice(0, 3).map((pair) => new THREE.Vector3(pair.target.x, pair.target.y, pair.target.z));
     const sourceFrame = frameFromPoints(sources[0], sources[1], sources[2]);
@@ -84,6 +96,41 @@ export function solveThreeJsAlignment(pairs) {
         scale,
     };
 }
+/** The one- and two-pair cases of solveThreeJsAlignment, which share the "same vertical" assumption. */
+function solveReducedAlignment(pairs, up) {
+    const sources = pairs.map((pair) => new THREE.Vector3(pair.source.x, pair.source.y, pair.source.z));
+    const targets = pairs.map((pair) => new THREE.Vector3(pair.target.x, pair.target.y, pair.target.z));
+    // Starts from the rotation that only stands the tags' vertical on the model's.
+    const rotation = new THREE.Quaternion().setFromUnitVectors(new THREE.Vector3(0, 1, 0), up);
+    let scale = 1;
+    if (pairs.length === 2) {
+        const sourceSpan = sources[1].clone().sub(sources[0]);
+        const targetSpan = targets[1].clone().sub(targets[0]);
+        if (sourceSpan.length() < 1e-9 || targetSpan.length() < 1e-9) {
+            return null;
+        }
+        scale = targetSpan.length() / sourceSpan.length();
+        // Heading is the turn about the vertical that lines the two spans up, so only their horizontal
+        // parts count. Two points one above the other have none, and say nothing about heading.
+        const flatten = (v) => v.clone().sub(up.clone().multiplyScalar(v.dot(up)));
+        const from = flatten(sourceSpan.clone().applyQuaternion(rotation));
+        const to = flatten(targetSpan);
+        if (from.length() < 1e-6 * sourceSpan.length() || to.length() < 1e-6 * targetSpan.length()) {
+            return null;
+        }
+        const heading = Math.atan2(new THREE.Vector3().crossVectors(from, to).dot(up), from.dot(to));
+        rotation.premultiply(new THREE.Quaternion().setFromAxisAngle(up, heading));
+    }
+    // A point lands at t + s*R*p; solved for t at the centroids, as in the three-pair case.
+    const centroid = (points) => points.reduce((sum, v) => sum.add(v), new THREE.Vector3()).multiplyScalar(1 / points.length);
+    const translation = centroid(targets).sub(centroid(sources).applyQuaternion(rotation).multiplyScalar(scale));
+    const euler = new THREE.Euler().setFromQuaternion(rotation);
+    return {
+        translation: { x: translation.x, y: translation.y, z: translation.z },
+        rotation: { x: euler.x, y: euler.y, z: euler.z },
+        scale,
+    };
+}
 export class ThreeJsService {
     ngZone;
     scene;
@@ -121,6 +168,61 @@ export class ThreeJsService {
     pendingTagPlacement = null;
     /** Pointer position waiting for a preview pick, coalesced to one per frame. */
     pendingPreviewEvent = null;
+    /**
+     * Tags whose position is in this model's own coordinates. A sibling of the tag group that does not
+     * carry the calibration: calibrating a model for the tags it imports must not move the ones that
+     * were placed straight onto it.
+     */
+    modelTagGroup = new THREE.Group();
+    /**
+     * The capture on screen. A tag placed in a 3D model is recorded with it, which is how the tags
+     * placed in this one are told from those that came from elsewhere.
+     */
+    currentCaptureID = null;
+    /**
+     * The model's surface as a grid: every cell some part of the surface passes through.
+     *
+     * It answers "is this point near the model?" without visiting the triangles, of which a captured
+     * model has millions - the question is asked for every tag, every time the calibration changes.
+     */
+    surfaceCells = null;
+    surfaceOrigin = new THREE.Vector3();
+    surfaceCellSize = 1;
+    /**
+     * How far from the model's surface a tag may be and still count as on it, in metres.
+     *
+     * Every tag of the space is offered to every model; this is what decides which ones a model
+     * shows. A tag marks something on a surface, so one that belongs here sits on the surface or
+     * close to it. One that lands deep inside the model, or well away from it, marks something that
+     * is not part of this model. The allowance covers a calibration done by hand and the model not
+     * matching the scan exactly, which together run to a few tens of centimetres.
+     */
+    static ON_MODEL_METRES = 0.75;
+    /** Cells per axis the grid's keys can address, with room either side for points off the model. */
+    static SURFACE_GRID_SPAN = 1024;
+    static SURFACE_GRID_PAD = 128;
+    /** Own tags moved to keep their place under the last calibration, waiting to be stored. */
+    rebasedTags = [];
+    /** The type filter in force. Null shows every type. */
+    visibleTagTypes = null;
+    measuring = false;
+    /** Points clicked so far, in tag space. */
+    measurePoints = [];
+    /**
+     * Everything drawn for the measurement. A child of the tag group, so its points share the frame
+     * tag coordinates are stored in - which is metres, and what the saved POI has to be in.
+     */
+    measureGroup = new THREE.Group();
+    /** The segment that follows the pointer from the last point clicked. */
+    measureRubberBand;
+    lastMeasurement = null;
+    /** Half the model's diagonal as placed in the scene, where it is centred on the origin. */
+    modelWorldRadius = 0;
+    /** The outermost group the model and its tags hang from: where "which way is up" is applied. */
+    modelGroup;
+    modelUp = 'y';
+    /** While measuring: how many points and each segment's length. Null when it is abandoned. */
+    measurementProgress$ = new Subject();
     /**
      * Layer carrying the model alone, so the depth pick can render it without the tags.
      *
@@ -128,6 +230,8 @@ export class ThreeJsService {
      * their parent passed, so marking the model's own meshes is enough - no re-parenting.
      */
     static PICK_LAYER = 1;
+    /** The app's highlight colour, so a measurement reads as the active thing on screen. */
+    static MEASURE_COLOR = '#FFB103';
     /** Cache Storage bucket holding downloaded models, and how many to keep. */
     static MODEL_CACHE = 'smarterplan-3d-models';
     static MODEL_CACHE_SIZE = 3;
@@ -144,6 +248,8 @@ export class ThreeJsService {
     aligning = false;
     alignmentPairs = [];
     alignmentSource = null;
+    /** The tag `alignmentSource` was read from, kept so the same tag is not matched twice. */
+    alignmentSourceTagId;
     /** Drives the alignment walkthrough's UI: how many pairs are done and what it wants next. */
     alignmentProgress$ = new Subject();
     /** In-flight camera move started by goToTag, advanced by the render loop. */
@@ -259,6 +365,8 @@ export class ThreeJsService {
         //    new model and show the previous visit's tags on it.
         this.discardCurrentLoad();
         this.clearTags();
+        this.measuring = false;
+        this.clearMeasurement();
         this.cameraTween = null;
         this.modelRoot = undefined;
         // 1. Setup Scene
@@ -366,7 +474,7 @@ export class ThreeJsService {
      * and stays indexed, so far less data reaches the GPU. KTX2 textures are supported too: they
      * stay compressed in VRAM instead of being decoded to raw pixels like JPEG/PNG.
      */
-    loadGLTFModel(url, cameraPosition, rotation, cacheKey) {
+    loadGLTFModel(url, cameraPosition, rotation, cacheKey, up) {
         const loader = new GLTFLoader();
         // KTX2 needs the renderer to report which compressed formats this GPU accepts, so this has to
         // happen after init(). Guarded so a model without KTX2 textures still loads if it's missing.
@@ -392,7 +500,7 @@ export class ThreeJsService {
             this.forceDoubleSidedMaterials(gltf.scene);
             this.ensureVertexNormals(gltf.scene);
             this.tuneTextureSampling(gltf.scene);
-            this.placeLoadedObjectInScene(gltf.scene, cameraPosition, rotation);
+            this.placeLoadedObjectInScene(gltf.scene, cameraPosition, rotation, up);
             this.modelLoading$.next(false);
         };
         const onError = (error) => {
@@ -865,7 +973,7 @@ export class ThreeJsService {
         });
     }
     /** Centers, scales and adds a loaded object to the scene, then frames the camera on it. */
-    placeLoadedObjectInScene(object, cameraPosition, rotation) {
+    placeLoadedObjectInScene(object, cameraPosition, rotation, up) {
         const box = new THREE.Box3().setFromObject(object);
         const center = box.getCenter(new THREE.Vector3());
         const size = box.getSize(new THREE.Vector3());
@@ -880,12 +988,25 @@ export class ThreeJsService {
         if (rotation) {
             object.rotation.set(rotation.x, rotation.y, rotation.z);
         }
+        // Which way is up. A choice someone made by hand always wins; otherwise, unless the model came
+        // with an orientation of its own, it is worked out from the geometry. Applied to the outer
+        // group, above both the model and the tags: they turn together, and every coordinate already
+        // stored - tag positions, the calibration - keeps meaning what it meant.
+        this.modelGroup = group;
+        this.modelUp = up ?? (rotation ? 'y' : this.detectModelUp(object, size));
+        group.quaternion.copy(this.uprightRotation(this.modelUp));
         this.modelRoot = object;
+        this.modelWorldRadius = (size.length() / 2) * scale;
+        // The box above was measured before any rotation from the metadata was applied; with one, it
+        // has to be measured again to be the model as it actually sits.
+        this.buildSurfaceGrid(object, rotation ? new THREE.Box3().setFromObject(object) : box);
+        this.refreshTagVisibility();
         // Marks the model for the depth pick, which renders this layer alone - so tags and the ghost
         // itself cannot end up being what the cursor reports as the surface under it.
         object.traverse((child) => child.layers.enable(ThreeJsService.PICK_LAYER));
         centered.add(object);
         centered.add(this.tagGroup);
+        centered.add(this.modelTagGroup);
         group.add(centered);
         group.scale.setScalar(scale);
         this.scene.add(group);
@@ -901,6 +1022,98 @@ export class ThreeJsService {
         this.controls.target.set(0, 0, 0);
         this.controls.update();
     }
+    /**
+     * Which of the model's axes is its vertical: 'y' when it already stands upright, or when it is
+     * not clear enough to act on.
+     *
+     * Models arrive in two conventions: Y up (glTF, and what this viewer assumes) and Z up (most CAD
+     * and scanning exports). A Z-up model loads lying on its side. Two independent cues say which
+     * axis is the vertical one, and both have to agree before anything is turned:
+     *
+     *  - Surface area. Floors and ceilings all face along the vertical, while walls are shared out
+     *    between the two horizontal axes, so the vertical usually collects the most area.
+     *  - Extent. A building is normally wider than it is tall, so the vertical is its shortest side.
+     *
+     * Either alone is wrong often enough to matter - a long corridor has more wall than floor, a
+     * tower is taller than it is wide - and turning a model that was fine is worse than leaving one
+     * that was not. A model that already has Y as its vertical is never touched.
+     */
+    detectModelUp(object, size) {
+        const axes = ['x', 'y', 'z'];
+        // Projected area facing each way along each axis: [positive, negative].
+        const area = { x: [0, 0], y: [0, 0], z: [0, 0] };
+        let triangleCount = 0;
+        object.updateMatrixWorld(true);
+        object.traverse((child) => {
+            const position = child.isMesh && child.geometry?.attributes?.position;
+            if (position) {
+                triangleCount += (child.geometry.index ? child.geometry.index.count : position.count) / 3;
+            }
+        });
+        if (triangleCount === 0) {
+            return 'y';
+        }
+        // A sample is plenty to see where the area lies, and keeps this cheap on models with millions
+        // of triangles.
+        const stride = Math.max(1, Math.ceil(triangleCount / 200000));
+        const a = new THREE.Vector3();
+        const b = new THREE.Vector3();
+        const c = new THREE.Vector3();
+        const normal = new THREE.Vector3();
+        object.traverse((child) => {
+            const position = child.isMesh && child.geometry?.attributes?.position;
+            if (!position) {
+                return;
+            }
+            const index = child.geometry.index;
+            const count = (index ? index.count : position.count) / 3;
+            for (let triangle = 0; triangle < count; triangle += stride) {
+                const offset = triangle * 3;
+                a.fromBufferAttribute(position, index ? index.getX(offset) : offset).applyMatrix4(child.matrixWorld);
+                b.fromBufferAttribute(position, index ? index.getX(offset + 1) : offset + 1).applyMatrix4(child.matrixWorld);
+                c.fromBufferAttribute(position, index ? index.getX(offset + 2) : offset + 2).applyMatrix4(child.matrixWorld);
+                // The cross product's length is twice the triangle's area, so its components are the
+                // area the triangle shows along each axis.
+                normal.crossVectors(b.sub(a), c.sub(a));
+                axes.forEach((axis) => {
+                    area[axis][normal[axis] >= 0 ? 0 : 1] += Math.abs(normal[axis]);
+                });
+            }
+        });
+        const total = { x: area.x[0] + area.x[1], y: area.y[0] + area.y[1], z: area.z[0] + area.z[1] };
+        const byArea = axes.reduce((best, axis) => (total[axis] > total[best] ? axis : best), 'y');
+        const byExtent = axes.reduce((best, axis) => (size[axis] < size[best] ? axis : best), 'y');
+        if (byArea === 'y' || byArea !== byExtent || total[byArea] < 1.25 * total.y) {
+            return 'y';
+        }
+        // Which way along that axis is up. Roofs and ground make an outdoor model face mostly upward,
+        // which settles it; indoors floors and ceilings balance out, and the convention - positive is
+        // up - is the better guess.
+        const [positive, negative] = area[byArea];
+        const up = `${negative > 0.65 * (positive + negative) ? '-' : ''}${byArea}`;
+        console.info(`ThreeJsService: this model's vertical axis looks like ${up}, not y - standing it upright.`);
+        return up;
+    }
+    /** The rotation that brings the given model axis to point up. */
+    uprightRotation(up) {
+        const axis = new THREE.Vector3();
+        axis[up.replace('-', '')] = up.startsWith('-') ? -1 : 1;
+        return new THREE.Quaternion().setFromUnitVectors(axis, new THREE.Vector3(0, 1, 0));
+    }
+    /** Which of the model's axes is currently treated as up, whether chosen or worked out. */
+    getModelUp() {
+        return this.modelUp;
+    }
+    /**
+     * Turns the model so the given axis points up, at once.
+     *
+     * The model and its tags turn as one, so nothing stored has to be recomputed. The caller is
+     * expected to store the choice, or the next load goes back to working it out.
+     */
+    setModelUp(up) {
+        this.modelUp = up;
+        this.modelGroup?.quaternion.copy(this.uprightRotation(up));
+    }
     /**
      * Keeps the drawing buffer and camera matched to the canvas as it is resized.
      *
@@ -926,6 +1139,7 @@ export class ThreeJsService {
             this.camera.aspect = width / height;
             this.camera.updateProjectionMatrix();
             this.renderer.setSize(width, height);
+            this.updateMeasureLineResolution();
         });
         this.canvasResizeObserver.observe(container);
     }
@@ -937,9 +1151,16 @@ export class ThreeJsService {
      * applied until solveAlignmentFromPairs() succeeds.
      */
     startTagAlignment() {
+        // One pointer mode at a time, the same rule startMeasuring() applies the other way round.
+        if (this.measuring) {
+            this.cancelMeasuring();
+        }
         this.aligning = true;
         this.alignmentPairs = [];
         this.alignmentSource = null;
+        // While calibrating, the tags from elsewhere are all shown - including the ones off the model,
+        // which are exactly the ones a calibration is for.
+        this.refreshTagVisibility();
         if (this.renderer) {
             this.renderer.domElement.style.cursor = 'crosshair';
         }
@@ -952,6 +1173,7 @@ export class ThreeJsService {
         this.alignmentSource = null;
         this.pendingPreviewEvent = null;
         this.removePlacementPreview();
+        this.refreshTagVisibility();
         if (this.renderer) {
             this.renderer.domElement.style.cursor = 'default';
         }
@@ -971,12 +1193,22 @@ export class ThreeJsService {
      * first half of a pair, which is a click on a tag, not on the model.
      */
     isPreviewingPlacement() {
-        return this.placingTag || (this.aligning && !!this.alignmentSource);
+        return this.placingTag || this.measuring || (this.aligning && !!this.alignmentSource);
     }
     /** Whether a tag is currently registered for this element. */
     hasTag(elementId) {
         return this.tagSprites.has(elementId);
     }
+    /** How many tags are on show - the ones a person could actually click. */
+    getTagCount() {
+        let visible = 0;
+        this.tagSprites.forEach((sprite) => {
+            if (sprite.visible) {
+                visible += 1;
+            }
+        });
+        return visible;
+    }
     /**
      * Solves and applies the alignment collected so far, returning it so the caller can persist it.
      *
@@ -984,35 +1216,105 @@ export class ThreeJsService {
      * the walkthrough stays open for the person to pick a better third point.
      */
     solveAlignmentFromPairs() {
-        const alignment = solveThreeJsAlignment(this.alignmentPairs);
+        const up = new THREE.Vector3();
+        up[this.modelUp.replace('-', '')] = this.modelUp.startsWith('-') ? -1 : 1;
+        const alignment = solveThreeJsAlignment(this.alignmentPairs, up);
         if (!alignment) {
             return null;
         }
-        this.setTagAlignment(alignment);
+        // Out of calibrating mode first: applying the result re-decides which tags show, and from here
+        // on that is the ones on the model again, not all of them.
         this.aligning = false;
+        this.applyAlignmentKeepingOwnTags(alignment);
         this.pendingPreviewEvent = null;
         this.removePlacementPreview();
         this.renderer.domElement.style.cursor = 'default';
         this.alignmentProgress$.next({ pairs: this.alignmentPairs.length, awaiting: null });
         return alignment;
     }
+    /**
+     * Applies a new calibration while keeping every tag placed in this model exactly where it is.
+     *
+     * A calibration is worked out for the tags that came from elsewhere. The model's own tags were put
+     * where they are by someone clicking the model, so they must not follow it. Their stored
+     * coordinates are rewritten instead: into the shared space as the new calibration defines it.
+     * That is also what makes them comparable with other visits from here on - a tag placed before
+     * the model was calibrated was in the model's own coordinates, visible nowhere else.
+     *
+     * The rewritten tags are kept for the caller to store; see takeRebasedTags().
+     */
+    applyAlignmentKeepingOwnTags(alignment) {
+        const own = [...this.tagSprites.values()].filter((sprite) => this.isOwnedByVisit(sprite));
+        // Where each one is now, in the space the model sits in, and how its parent was turned.
+        const placed = own.map((sprite) => {
+            sprite.parent?.updateMatrix();
+            return {
+                sprite,
+                position: sprite.position.clone().applyMatrix4(sprite.parent?.matrix ?? new THREE.Matrix4()),
+                turn: sprite.parent?.quaternion.clone() ?? new THREE.Quaternion(),
+            };
+        });
+        this.setTagAlignment(alignment);
+        const inverse = this.tagGroup.matrix.clone().invert();
+        const unturn = this.tagGroup.quaternion.clone().invert();
+        this.rebasedTags = placed.map(({ sprite, position, turn }) => {
+            sprite.position.copy(position.applyMatrix4(inverse));
+            sprite.userData.frame = null;
+            this.parentTag(sprite);
+            this.scaleTagForModel(sprite);
+            const rotation = unturn.clone().multiply(turn);
+            return {
+                id: sprite.name,
+                position: { x: sprite.position.x, y: sprite.position.y, z: sprite.position.z },
+                rotateDirection: ({ x, y, z }) => {
+                    const turned = new THREE.Vector3(x, y, z).applyQuaternion(rotation);
+                    return { x: turned.x, y: turned.y, z: turned.z };
+                },
+            };
+        });
+        this.refreshTagVisibility();
+    }
+    /** Hands over the tags the last calibration rewrote, once, for them to be stored. */
+    takeRebasedTags() {
+        const rebased = this.rebasedTags;
+        this.rebasedTags = [];
+        return rebased;
+    }
+    /**
+     * Chooses the tag for the pair being matched by id, instead of by clicking it.
+     *
+     * Clicking a tag supposes it can be found. On a model that has never been calibrated the tags may
+     * sit far from it, or all on top of one another; a list has neither problem.
+     */
+    selectAlignmentTag(elementId) {
+        const sprite = this.tagSprites.get(elementId);
+        if (!this.aligning || this.alignmentSource || !sprite || !this.calibrationCandidates().includes(sprite)) {
+            return false;
+        }
+        this.setAlignmentSource(sprite);
+        return true;
+    }
+    setAlignmentSource(sprite) {
+        // The sprite's own position is the stored coordinate, untouched by any alignment already
+        // applied - that transform lives on the group, not on the sprite.
+        const stored = sprite.position;
+        this.alignmentSource = { x: stored.x, y: stored.y, z: stored.z };
+        this.alignmentSourceTagId = sprite.name;
+        this.alignmentProgress$.next({
+            pairs: this.alignmentPairs.length,
+            awaiting: 'point',
+            tagId: sprite.name,
+        });
+    }
     /** Handles a click while the alignment walkthrough is running. */
     handleAlignmentClick(event) {
         if (!this.alignmentSource) {
             // First half of a pair: which tag are we talking about?
-            const hit = this.raycaster.intersectObjects(this.tagGroup.children, false)[0];
+            const hit = this.raycaster.intersectObjects(this.calibrationCandidates(), false)[0];
             if (!hit) {
                 return;
             }
-            // The sprite's own position is the stored coordinate, untouched by any alignment already
-            // applied - that transform lives on the group, not on the sprite.
-            const stored = hit.object.position;
-            this.alignmentSource = { x: stored.x, y: stored.y, z: stored.z };
-            this.alignmentProgress$.next({
-                pairs: this.alignmentPairs.length,
-                awaiting: 'point',
-                tagId: hit.object.name,
-            });
+            this.setAlignmentSource(hit.object);
             return;
         }
         // Second half: where that tag actually belongs on the model.
@@ -1020,16 +1322,250 @@ export class ThreeJsService {
         if (!target) {
             return;
         }
-        this.alignmentPairs.push({ source: this.alignmentSource, target });
+        this.alignmentPairs.push({ tagId: this.alignmentSourceTagId, source: this.alignmentSource, target });
         this.alignmentSource = null;
         // The ghost belongs to the click that just happened; the next half is a click on a tag.
         this.pendingPreviewEvent = null;
         this.removePlacementPreview();
         this.alignmentProgress$.next({
             pairs: this.alignmentPairs.length,
-            awaiting: this.alignmentPairs.length >= 3 ? null : 'tag',
+            // Done at three, or sooner when there are no more tags to match: fewer pairs still calibrate,
+            // only less completely.
+            awaiting: this.alignmentPairs.length >= 3 || this.calibrationCandidates().length === 0 ? null : 'tag',
+        });
+    }
+    /**
+     * Starts a measurement: every click on the model adds a point, and each pair of consecutive
+     * points is a measured segment.
+     *
+     * It ends through finishMeasuring() or cancelMeasuring() rather than on its own after two points,
+     * because a measurement may have several segments - the same as Matterport's, whose results are
+     * stored as a list of distances.
+     */
+    startMeasuring() {
+        // One pointer mode at a time: a click cannot be both a tag position and a measured point.
+        this.cancelTagPlacement();
+        if (this.aligning) {
+            this.cancelTagAlignment();
+        }
+        this.clearMeasurement();
+        if (this.measureGroup.parent !== this.tagGroup) {
+            this.tagGroup.add(this.measureGroup);
+        }
+        this.measuring = true;
+        if (this.renderer) {
+            this.renderer.domElement.style.cursor = 'crosshair';
+        }
+        this.measurementProgress$.next({ points: 0, distances: [] });
+    }
+    /**
+     * Abandons the measurement and removes what was drawn.
+     *
+     * Also what clears a finished measurement off the model once its form is saved or closed, which
+     * is why it only reports an abandonment when one was actually in progress.
+     */
+    cancelMeasuring() {
+        const wasMeasuring = this.measuring;
+        this.measuring = false;
+        this.pendingPreviewEvent = null;
+        this.removePlacementPreview();
+        this.clearMeasurement();
+        // Forgotten here so that a form opened later cannot pick up a measurement already dealt with.
+        this.lastMeasurement = null;
+        if (this.renderer) {
+            this.renderer.domElement.style.cursor = 'default';
+        }
+        if (wasMeasuring) {
+            this.measurementProgress$.next(null);
+        }
+    }
+    /**
+     * Ends the measurement and returns it, or null when there are not yet two points to measure
+     * between - in which case measuring simply carries on.
+     *
+     * The drawing stays on the model so it is still visible while the person names the measurement;
+     * cancelMeasuring() takes it away afterwards.
+     */
+    finishMeasuring() {
+        if (!this.measuring || this.measurePoints.length < 2) {
+            return null;
+        }
+        this.measuring = false;
+        this.pendingPreviewEvent = null;
+        this.removePlacementPreview();
+        this.updateMeasureRubberBand(null);
+        this.renderer.domElement.style.cursor = 'default';
+        this.lastMeasurement = {
+            points: this.measurePoints.map((point) => ({ x: point.x, y: point.y, z: point.z })),
+            distances: this.measureDistances(),
+            screenshot: this.captureMeasurementScreenshot(),
+        };
+        return this.lastMeasurement;
+    }
+    isMeasuring() {
+        return this.measuring;
+    }
+    /** The measurement finishMeasuring() last produced, for the form that saves it. */
+    getLastMeasurement() {
+        return this.lastMeasurement;
+    }
+    /** Metres between consecutive points. Tag space is in metres, so no conversion is involved. */
+    measureDistances() {
+        const distances = [];
+        for (let index = 1; index < this.measurePoints.length; index += 1) {
+            const distance = this.measurePoints[index - 1].distanceTo(this.measurePoints[index]);
+            // Two decimals, the precision Matterport's own measurements are stored with.
+            distances.push(Math.round(distance * 100) / 100);
+        }
+        return distances;
+    }
+    addMeasurePoint(point) {
+        const previous = this.measurePoints[this.measurePoints.length - 1];
+        this.measurePoints.push(point);
+        const marker = new THREE.Sprite(new THREE.SpriteMaterial({
+            map: this.createTagTexture(ThreeJsService.MEASURE_COLOR),
+            depthTest: false,
+            transparent: true,
+            // Sized against the viewport, not the model: measuring is done zoomed right in, where
+            // anything sized in metres would cover the very thing being measured.
+            sizeAttenuation: false,
+        }));
+        marker.scale.set(0.022, 0.022, 1);
+        marker.position.copy(point);
+        marker.renderOrder = 1001;
+        this.measureGroup.add(marker);
+        if (previous) {
+            this.measureGroup.add(this.createMeasureLine(previous, point));
+            const distance = Math.round(previous.distanceTo(point) * 100) / 100;
+            const label = new THREE.Sprite(new THREE.SpriteMaterial({
+                map: this.createMeasureLabelTexture(`${distance.toFixed(2)} m`),
+                depthTest: false,
+                transparent: true,
+                sizeAttenuation: false,
+            }));
+            label.scale.set(0.15, 0.05, 1);
+            label.position.copy(previous).add(point).multiplyScalar(0.5);
+            label.renderOrder = 1002;
+            this.measureGroup.add(label);
+        }
+        this.measurementProgress$.next({
+            points: this.measurePoints.length,
+            distances: this.measureDistances(),
+        });
+    }
+    /**
+     * A segment with a width in pixels.
+     *
+     * WebGL's own lines are one pixel wide whatever is asked for, which all but disappears over a
+     * photographic texture. This kind is drawn as screen-facing geometry, so the width holds.
+     */
+    createMeasureLine(from, to) {
+        const geometry = new LineGeometry();
+        geometry.setPositions([from.x, from.y, from.z, to.x, to.y, to.z]);
+        const material = new LineMaterial({
+            color: new THREE.Color(ThreeJsService.MEASURE_COLOR).getHex(),
+            linewidth: 3,
+            depthTest: false,
+            transparent: true,
+        });
+        const size = this.renderer.getSize(new THREE.Vector2());
+        material.resolution.set(size.x, size.y);
+        const line = new Line2(geometry, material);
+        line.renderOrder = 1000;
+        return line;
+    }
+    /** Line widths are in pixels, which the material can only honour if it knows the canvas size. */
+    updateMeasureLineResolution() {
+        if (!this.renderer) {
+            return;
+        }
+        const size = this.renderer.getSize(new THREE.Vector2());
+        this.measureGroup.children.forEach((child) => {
+            if (child.material?.resolution) {
+                child.material.resolution.set(size.x, size.y);
+            }
         });
     }
+    /** Stretches a segment from the last point to the pointer, or hides it when given null. */
+    updateMeasureRubberBand(target) {
+        const last = this.measurePoints[this.measurePoints.length - 1];
+        if (!this.measuring || !last || !target) {
+            if (this.measureRubberBand) {
+                this.measureRubberBand.visible = false;
+            }
+            return;
+        }
+        if (!this.measureRubberBand) {
+            this.measureRubberBand = this.createMeasureLine(last, target);
+            this.measureRubberBand.material.opacity = 0.6;
+            this.measureGroup.add(this.measureRubberBand);
+        }
+        this.measureRubberBand.geometry.setPositions([
+            last.x, last.y, last.z,
+            target.x, target.y, target.z,
+        ]);
+        this.measureRubberBand.visible = true;
+    }
+    createMeasureLabelTexture(text) {
+        const canvas = document.createElement('canvas');
+        canvas.width = 384;
+        canvas.height = 128;
+        const context = canvas.getContext('2d');
+        const radius = 28;
+        context.fillStyle = 'rgba(0, 0, 0, 0.78)';
+        context.beginPath();
+        context.moveTo(radius, 8);
+        context.arcTo(canvas.width - 8, 8, canvas.width - 8, canvas.height - 8, radius);
+        context.arcTo(canvas.width - 8, canvas.height - 8, 8, canvas.height - 8, radius);
+        context.arcTo(8, canvas.height - 8, 8, 8, radius);
+        context.arcTo(8, 8, canvas.width - 8, 8, radius);
+        context.closePath();
+        context.fill();
+        context.fillStyle = '#FFFFFF';
+        context.font = 'bold 60px sans-serif';
+        context.textAlign = 'center';
+        context.textBaseline = 'middle';
+        context.fillText(text, canvas.width / 2, canvas.height / 2 + 4);
+        return new THREE.CanvasTexture(canvas);
+    }
+    /** Removes everything drawn for a measurement and forgets its points. */
+    clearMeasurement() {
+        [...this.measureGroup.children].forEach((child) => {
+            this.measureGroup.remove(child);
+            child.geometry?.dispose?.();
+            child.material?.map?.dispose?.();
+            child.material?.dispose?.();
+        });
+        this.measureRubberBand = undefined;
+        this.measurePoints = [];
+    }
+    /**
+     * A picture of the scene with the measurement on it, as Matterport attaches to its own.
+     *
+     * Tags are left out, as they are there: the picture is about the measurement. It is taken straight
+     * after a render because the drawing buffer is only guaranteed to hold the frame until the
+     * browser presents it, and scaled down since it is uploaded and shown as a thumbnail.
+     */
+    captureMeasurementScreenshot() {
+        const hidden = [];
+        this.tagSprites.forEach((sprite) => {
+            if (sprite.visible) {
+                sprite.visible = false;
+                hidden.push(sprite);
+            }
+        });
+        this.renderer.render(this.scene, this.camera);
+        const source = this.renderer.domElement;
+        const scale = Math.min(1, 800 / source.width, 600 / source.height);
+        const canvas = document.createElement('canvas');
+        canvas.width = Math.max(1, Math.round(source.width * scale));
+        canvas.height = Math.max(1, Math.round(source.height * scale));
+        canvas.getContext('2d').drawImage(source, 0, 0, canvas.width, canvas.height);
+        hidden.forEach((sprite) => {
+            sprite.visible = true;
+        });
+        return canvas.toDataURL('image/jpeg', 0.85);
+    }
     /** Arms tag placement: the next click on the model drops a tag instead of being ignored. */
     startTagPlacement(poiType = null) {
         this.placingTag = true;
@@ -1059,6 +1595,7 @@ export class ThreeJsService {
         const position = this.pickPointOnGpu(event);
         if (!position) {
             this.removePlacementPreview();
+            this.updateMeasureRubberBand(null);
             this.renderer.domElement.style.cursor = 'not-allowed';
             return;
         }
@@ -1075,6 +1612,7 @@ export class ThreeJsService {
             this.scaleTagForModel(this.placementPreview);
         }
         this.placementPreview.position.copy(position);
+        this.updateMeasureRubberBand(position);
     }
     /**
      * The point under the cursor, read from the depth buffer instead of raycast, in tag space.
@@ -1176,9 +1714,250 @@ export class ThreeJsService {
      * filter that happens to match nothing.
      */
     setVisibleTagTypes(types) {
+        this.visibleTagTypes = types;
+        this.tagSprites.forEach((sprite) => this.applyTagVisibility(sprite));
+    }
+    /** Says which capture is on screen, so the tags placed in it can be told from the rest. */
+    setCurrentCapture(captureID) {
+        this.currentCaptureID = captureID;
         this.tagSprites.forEach((sprite) => {
-            sprite.visible = types === null || types.includes(sprite.userData.poiType);
+            this.parentTag(sprite);
+            this.applyTagVisibility(sprite);
+        });
+    }
+    /** Every tag registered in the scene, shown or not. */
+    getTags() {
+        const candidates = new Set(this.calibrationCandidates());
+        return [...this.tagSprites.values()].map((sprite) => ({
+            id: sprite.name,
+            label: sprite.userData.label ?? null,
+            poiType: sprite.userData.poiType ?? null,
+            visible: sprite.visible,
+            calibratable: candidates.has(sprite),
+        }));
+    }
+    /**
+     * How far the tags from elsewhere sit from the model, measured in model radii. Null without both.
+     *
+     * Before a model is calibrated those tags are wherever their own coordinates put them, which for
+     * a model with a different origin can be a long way off - too far to find, let alone click.
+     */
+    getTagDistanceFromModel() {
+        if (!this.modelRoot || !this.modelWorldRadius) {
+            return null;
+        }
+        const centroid = new THREE.Vector3();
+        const candidates = this.calibrationCandidates();
+        candidates.forEach((sprite) => centroid.add(sprite.getWorldPosition(new THREE.Vector3())));
+        const count = candidates.length;
+        if (count === 0) {
+            return null;
+        }
+        // The model is centred on the world origin when it is placed.
+        return centroid.divideScalar(count).length() / this.modelWorldRadius;
+    }
+    /**
+     * Hangs a tag from the group its coordinates belong to: outside the calibration when they are in
+     * this model's own coordinates, under it otherwise.
+     */
+    parentTag(sprite) {
+        const parent = sprite.userData.frame === 'model' && this.isOwnedByVisit(sprite)
+            ? this.modelTagGroup
+            : this.tagGroup;
+        if (sprite.parent !== parent) {
+            parent.add(sprite);
+        }
+    }
+    /**
+     * The tags a calibration can be worked out from: those that came from somewhere else, whether or
+     * not they are on show - before calibrating, most of them will not be.
+     *
+     * Tags placed in this model are where they are because someone clicked there; matching them to
+     * "where they really are" would be circular. A tag in another model's own coordinates cannot be
+     * placed here at all. And a tag already used in this calibration cannot be used again - two
+     * pairs from one tag carry no more than one.
+     */
+    calibrationCandidates() {
+        const used = new Set(this.alignmentPairs.map((pair) => pair.tagId));
+        return [...this.tagSprites.values()].filter((sprite) => sprite.parent === this.tagGroup
+            && sprite.userData.frame !== 'model'
+            && !this.isOwnedByVisit(sprite)
+            && !used.has(sprite.name));
+    }
+    /** How many tags there are to calibrate with, not counting those already used. */
+    getCalibrationCandidateCount() {
+        return this.calibrationCandidates().length;
+    }
+    /**
+     * How many tags from elsewhere are not on this model, and so not shown on it.
+     *
+     * On a model that has not been calibrated, this is what suggests it should be: the tags are out
+     * there, just not where the model is.
+     */
+    getOffModelTagCount() {
+        return this.calibrationCandidates().filter((sprite) => !this.isOnModel(sprite)).length;
+    }
+    /** Whether the tag was placed in the visit on screen. */
+    isOwnedByVisit(sprite) {
+        return !!sprite.userData.originCaptureID
+            && sprite.userData.originCaptureID === this.currentCaptureID;
+    }
+    /**
+     * A tag shows when its type is not filtered out and it belongs on this model.
+     *
+     * One place decides, because the two used to set `visible` separately and whichever ran last
+     * undid the other.
+     */
+    applyTagVisibility(sprite) {
+        const typeAllowed = this.visibleTagTypes === null
+            || this.visibleTagTypes.includes(sprite.userData.poiType);
+        sprite.visible = typeAllowed && this.belongsOnThisModel(sprite);
+    }
+    /**
+     * Whether a tag has a place on this model.
+     *
+     * Every tag of the space is offered to every model - there is one set of tags, not one per model.
+     * What a model shows of it is the part that sits on the model.
+     */
+    belongsOnThisModel(sprite) {
+        // Placed here by a click on this very surface.
+        if (this.isOwnedByVisit(sprite)) {
+            return true;
+        }
+        // Placed in another model before that one was calibrated: its coordinates are that model's own
+        // and say nothing about where it would be in this one.
+        if (sprite.userData.frame === 'model') {
+            return false;
+        }
+        // Calibrating is matching tags to where they belong, so they all have to be on offer.
+        if (this.aligning) {
+            return true;
+        }
+        return this.isOnModel(sprite);
+    }
+    /** Whether a tag, drawn where its coordinates and the calibration put it, sits on the model. */
+    isOnModel(sprite) {
+        if (!this.surfaceCells) {
+            // No model to be on yet.
+            return false;
+        }
+        const parent = sprite.parent ?? this.tagGroup;
+        parent.updateMatrix();
+        // The grid is in the model's own units; the calibration's scale is how many of those a metre is.
+        const reach = ThreeJsService.ON_MODEL_METRES * (parent.scale.x || 1);
+        return this.isNearSurface(sprite.position.clone().applyMatrix4(parent.matrix), reach);
+    }
+    /** Re-decides every tag's visibility: the model, the calibration or the mode changed. */
+    refreshTagVisibility() {
+        this.tagSprites.forEach((sprite) => this.applyTagVisibility(sprite));
+    }
+    surfaceKey(x, y, z) {
+        const span = ThreeJsService.SURFACE_GRID_SPAN;
+        const pad = ThreeJsService.SURFACE_GRID_PAD;
+        const [i, j, k] = [x + pad, y + pad, z + pad];
+        if (i < 0 || j < 0 || k < 0 || i >= span || j >= span || k >= span) {
+            return -1;
+        }
+        return i + span * (j + span * k);
+    }
+    /**
+     * Lays the grid over the model's surface.
+     *
+     * Runs once per model, in one pass over its triangles. A triangle smaller than a cell is marked
+     * by its centre, which is every triangle of a scanned model; a larger one - the two triangles of
+     * a drawn wall - is sampled across its face, or the middle of the wall would read as empty.
+     */
+    buildSurfaceGrid(object, box) {
+        const size = box.getSize(new THREE.Vector3());
+        const longest = Math.max(size.x, size.y, size.z);
+        if (!(longest > 0)) {
+            this.surfaceCells = null;
+            return;
+        }
+        // A quarter of a metre where the model is in metres; coarser on a very large one, so the grid
+        // stays addressable and its memory bounded.
+        const cell = Math.max(0.25, longest / 384);
+        const origin = box.min.clone();
+        const cells = new Set();
+        const mark = (point) => {
+            const key = this.surfaceKey(Math.floor((point.x - origin.x) / cell), Math.floor((point.y - origin.y) / cell), Math.floor((point.z - origin.z) / cell));
+            if (key >= 0) {
+                cells.add(key);
+            }
+        };
+        let triangleCount = 0;
+        object.updateMatrixWorld(true);
+        object.traverse((child) => {
+            const position = child.isMesh && child.geometry?.attributes?.position;
+            if (position) {
+                triangleCount += (child.geometry.index ? child.geometry.index.count : position.count) / 3;
+            }
         });
+        // Past a few million triangles they are far smaller than a cell, and every cell is hit many
+        // times over; a sample marks the same cells.
+        const stride = Math.max(1, Math.ceil(triangleCount / 3000000));
+        const a = new THREE.Vector3();
+        const b = new THREE.Vector3();
+        const c = new THREE.Vector3();
+        const point = new THREE.Vector3();
+        object.traverse((child) => {
+            const position = child.isMesh && child.geometry?.attributes?.position;
+            if (!position) {
+                return;
+            }
+            const index = child.geometry.index;
+            const count = (index ? index.count : position.count) / 3;
+            for (let triangle = 0; triangle < count; triangle += stride) {
+                const offset = triangle * 3;
+                a.fromBufferAttribute(position, index ? index.getX(offset) : offset).applyMatrix4(child.matrixWorld);
+                b.fromBufferAttribute(position, index ? index.getX(offset + 1) : offset + 1).applyMatrix4(child.matrixWorld);
+                c.fromBufferAttribute(position, index ? index.getX(offset + 2) : offset + 2).applyMatrix4(child.matrixWorld);
+                const edge = Math.max(a.distanceTo(b), b.distanceTo(c), c.distanceTo(a));
+                if (edge <= cell) {
+                    mark(point.copy(a).add(b).add(c).multiplyScalar(1 / 3));
+                    continue;
+                }
+                // Half-cell steps across the face. Capped, so one enormous triangle cannot stall the load;
+                // the reach a tag is tested with spans several cells and bridges what the cap leaves.
+                const steps = Math.min(96, Math.ceil((2 * edge) / cell));
+                for (let i = 0; i <= steps; i += 1) {
+                    for (let j = 0; j <= steps - i; j += 1) {
+                        point.copy(a)
+                            .addScaledVector(b.clone().sub(a), i / steps)
+                            .addScaledVector(c.clone().sub(a), j / steps);
+                        mark(point);
+                    }
+                }
+            }
+        });
+        this.surfaceCells = cells;
+        this.surfaceOrigin.copy(origin);
+        this.surfaceCellSize = cell;
+    }
+    /** Whether some part of the model's surface lies within `reach` of a point, in model units. */
+    isNearSurface(point, reach) {
+        const cell = this.surfaceCellSize;
+        const origin = this.surfaceOrigin;
+        const x = (point.x - origin.x) / cell;
+        const y = (point.y - origin.y) / cell;
+        const z = (point.z - origin.z) / cell;
+        // In cells. Capped: beyond this the calibration's scale makes a metre so many cells that the
+        // search would dwarf the model, and a tag that far off is not on it by any reading.
+        const span = Math.min(16, Math.ceil(reach / cell));
+        // A cell is "within reach" when its centre is, give or take the half-diagonal of the cell.
+        const limit = (reach / cell + 0.87) ** 2;
+        const [cx, cy, cz] = [Math.floor(x), Math.floor(y), Math.floor(z)];
+        for (let k = cz - span; k <= cz + span; k += 1) {
+            for (let j = cy - span; j <= cy + span; j += 1) {
+                for (let i = cx - span; i <= cx + span; i += 1) {
+                    const distance = (i + 0.5 - x) ** 2 + (j + 0.5 - y) ** 2 + (k + 0.5 - z) ** 2;
+                    if (distance <= limit && this.surfaceCells.has(this.surfaceKey(i, j, k))) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
     }
     /**
      * Moves the camera to look at a tag, mirroring Matterport's goToTag.
@@ -1309,8 +2088,11 @@ export class ThreeJsService {
         this.tagGroup.position.set(translation?.x ?? 0, translation?.y ?? 0, translation?.z ?? 0);
         this.tagGroup.rotation.set(rotation?.x ?? 0, rotation?.y ?? 0, rotation?.z ?? 0);
         this.tagGroup.scale.setScalar(scale ?? 1);
-        // Tag size is derived from the world scale it inherits, which this call just changed.
+        this.tagGroup.updateMatrix();
+        // Tag size is derived from the world scale it inherits, which this call just changed - and so
+        // is which tags land on the model.
         this.tagSprites.forEach((sprite) => this.scaleTagForModel(sprite));
+        this.refreshTagVisibility();
     }
     /**
      * Adds a tag, or moves/restyles the one already registered for this element.
@@ -1325,6 +2107,10 @@ export class ThreeJsService {
             existing.position.set(tag.position.x, tag.position.y, tag.position.z);
             existing.userData.poiType = tag.poiType ?? existing.userData.poiType;
             existing.userData.label = tag.label ?? existing.userData.label;
+            existing.userData.originCaptureID = tag.originCaptureID ?? existing.userData.originCaptureID;
+            existing.userData.frame = tag.frame ?? existing.userData.frame;
+            this.parentTag(existing);
+            this.applyTagVisibility(existing);
             return;
         }
         const sprite = new THREE.Sprite(new THREE.SpriteMaterial({
@@ -1337,10 +2123,13 @@ export class ThreeJsService {
         sprite.name = tag.id;
         sprite.userData.poiType = tag.poiType ?? null;
         sprite.userData.label = tag.label ?? null;
+        sprite.userData.originCaptureID = tag.originCaptureID ?? null;
+        sprite.userData.frame = tag.frame ?? null;
         sprite.position.set(tag.position.x, tag.position.y, tag.position.z);
         sprite.renderOrder = 999;
+        this.parentTag(sprite);
         this.scaleTagForModel(sprite);
-        this.tagGroup.add(sprite);
+        this.applyTagVisibility(sprite);
         this.tagSprites.set(tag.id, sprite);
         if (tag.iconUrl) {
             this.applyTagIcon(sprite, tag.iconUrl);
@@ -1352,7 +2141,7 @@ export class ThreeJsService {
         if (!sprite) {
             return;
         }
-        this.tagGroup.remove(sprite);
+        sprite.parent?.remove(sprite);
         sprite.material.map?.dispose();
         sprite.material.dispose();
         this.tagSprites.delete(elementId);
@@ -1393,7 +2182,8 @@ export class ThreeJsService {
      * size on screen whatever the model's units are.
      */
     scaleTagForModel(sprite) {
-        const worldScale = this.tagGroup.getWorldScale(new THREE.Vector3()).x || 1;
+        // Its own parent's scale: tags in the model's coordinates do not inherit the calibration's.
+        const worldScale = (sprite.parent ?? this.tagGroup).getWorldScale(new THREE.Vector3()).x || 1;
         const size = 0.4 / worldScale;
         sprite.scale.set(size, size, 1);
     }
@@ -1452,7 +2242,7 @@ export class ThreeJsService {
             this.removePlacementPreview();
             // Tags first: they draw on top of the model, so they have to answer the pointer first too.
             const hoveredTag = this.raycaster
-                .intersectObjects(this.tagGroup.children, false)
+                .intersectObjects([...this.tagSprites.values()], false)
                 .find((hit) => hit.object.visible)?.object;
             if (hoveredTag) {
                 this.renderer.domElement.style.cursor = 'pointer';
@@ -1491,6 +2281,15 @@ export class ThreeJsService {
                 this.handleAlignmentClick(event);
                 return;
             }
+            // Measuring takes every click as a point, the same way placement takes it as a position.
+            if (this.measuring) {
+                const placement = this.pickPlacementOnModel(event);
+                if (placement) {
+                    const { x, y, z } = placement.position;
+                    this.addMeasurePoint(new THREE.Vector3(x, y, z));
+                }
+                return;
+            }
             // Placement wins over everything: while armed, a click means "put it here", not "open that".
             if (this.placingTag) {
                 const placement = this.pickPlacementOnModel(event);
@@ -1506,7 +2305,7 @@ export class ThreeJsService {
             }
             this.raycaster.setFromCamera(this.mouse, this.camera);
             // Same precedence as hover: a tag drawn over the model claims the click.
-            const tagHits = this.raycaster.intersectObjects(this.tagGroup.children, false)
+            const tagHits = this.raycaster.intersectObjects([...this.tagSprites.values()], false)
                 .filter((hit) => hit.object.visible);
             if (tagHits.length > 0) {
                 const tag = tagHits[0].object;
@@ -1541,6 +2340,10 @@ export class ThreeJsService {
             this.cancelTagPlacement();
             return;
         }
+        if (this.measuring) {
+            this.cancelMeasuring();
+            return;
+        }
         if (this.aligning) {
             this.cancelTagAlignment();
         }
@@ -1568,6 +2371,8 @@ export class ThreeJsService {
         }
         this.discardCurrentLoad();
         this.clearTags();
+        this.measuring = false;
+        this.clearMeasurement();
         if (this.renderer) {
             this.renderer.dispose();
         }
@@ -1584,4 +2389,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     providedIn: 'root'
                 }]
         }], ctorParameters: () => [{ type: i0.NgZone }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"threejs.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-smarterplan-core/src/lib/services/threejs.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\r\nimport * as THREE from 'three';\r\nimport { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';\r\nimport { OBJLoader } from 'three/examples/jsm/loaders/OBJLoader';\r\nimport { MTLLoader } from 'three/examples/jsm/loaders/MTLLoader';\r\nimport { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader';\r\nimport { KTX2Loader } from 'three/examples/jsm/loaders/KTX2Loader';\r\nimport { MeshoptDecoder } from 'three/examples/jsm/libs/meshopt_decoder.module.js';\r\nimport { Subject } from 'rxjs';\r\nimport { ThreeJsAlignment } from '../helpers.service';\r\nimport { PoiType } from '../types.service';\r\n\r\n/**\r\n * A tag to draw in the Three.js scene, mirroring a Mattertag.\r\n *\r\n * Positions are in the model's own coordinate space - the same numbers stored in POI.coordinate -\r\n * not scene space. The service reparents tags under the model so they inherit the centering and\r\n * scaling applied at load, which means callers never deal with that transform.\r\n */\r\nexport interface ThreeJsTag {\r\n  /** The tagged element's id (POI.elementID), used to update or remove the tag later. */\r\n  id: string;\r\n  position: { x: number; y: number; z: number };\r\n  /** Drives both the click route and type filtering, so it travels with the tag. */\r\n  poiType?: PoiType | null;\r\n  /** Shown on hover. A marker with no identity is just a dot on a wall. */\r\n  label?: string | null;\r\n  /** Icon drawn on the tag. Falls back to a plain disc when absent or it fails to load. */\r\n  iconUrl?: string | null;\r\n  /** Tint for the fallback disc, as a CSS colour. */\r\n  color?: string;\r\n}\r\n\r\n/** What a click on a tag reports: enough to route to the element's detail page. */\r\nexport interface ThreeJsTagClick {\r\n  elementId: string;\r\n  poiType: PoiType | null;\r\n}\r\n\r\n/**\r\n * A spot picked on the model for a new tag.\r\n *\r\n * Both vectors are in the model's own coordinate space, which is what POI.coordinate stores. Scene\r\n * coordinates deliberately never leave this service: the model is scaled to a fixed size on load, so\r\n * a scene-space position would silently mean somewhere else the moment the .glb is re-exported.\r\n */\r\nexport interface ThreeJsTagPlacement {\r\n  position: { x: number; y: number; z: number };\r\n  /** Surface normal at the picked point - Matterport stores the same thing in POI.metadata. */\r\n  normal: { x: number; y: number; z: number };\r\n  /** What the placement was armed for, so the caller knows which creation form to open. */\r\n  poiType?: PoiType | null;\r\n}\r\n\r\n/** One tag seen in both spaces: where it is stored, and where it really sits on the model. */\r\nexport interface ThreeJsAlignmentPair {\r\n  source: { x: number; y: number; z: number };\r\n  target: { x: number; y: number; z: number };\r\n}\r\n\r\n/**\r\n * Builds an orthonormal frame from three points, or null when they are (nearly) collinear.\r\n *\r\n * Three points define a plane, and a plane plus an origin defines an orientation. Collinear points\r\n * do not: they leave the rotation about their common line undetermined, which is why the caller has\r\n * to reject them rather than produce a confident wrong answer.\r\n */\r\nfunction frameFromPoints(a: THREE.Vector3, b: THREE.Vector3, c: THREE.Vector3): THREE.Matrix4 | null {\r\n  const e1 = b.clone().sub(a);\r\n  if (e1.lengthSq() < 1e-12) {\r\n    return null;\r\n  }\r\n  e1.normalize();\r\n\r\n  const toC = c.clone().sub(a);\r\n  const e2 = toC.clone().sub(e1.clone().multiplyScalar(toC.dot(e1)));\r\n  if (e2.lengthSq() < 1e-12) {\r\n    return null;\r\n  }\r\n  e2.normalize();\r\n\r\n  return new THREE.Matrix4().makeBasis(e1, e2, e1.clone().cross(e2));\r\n}\r\n\r\n/**\r\n * Solves the transform that maps stored tag coordinates onto the loaded model.\r\n *\r\n * Takes exactly the correspondences a person can produce by hand: three tags, each pointed at twice\r\n * - once where it currently sits, once where it belongs. That is the minimum that pins down all\r\n * three parts of the answer. One pair fixes only translation; two leave the rotation about the line\r\n * between them free; three resolve it.\r\n *\r\n * Returns null when the points are collinear or degenerate, because a wrong alignment applied\r\n * silently is worse than none.\r\n */\r\nexport function solveThreeJsAlignment(pairs: ThreeJsAlignmentPair[]): ThreeJsAlignment | null {\r\n  if (!pairs || pairs.length < 3) {\r\n    return null;\r\n  }\r\n\r\n  const sources = pairs.slice(0, 3).map((pair) => new THREE.Vector3(pair.source.x, pair.source.y, pair.source.z));\r\n  const targets = pairs.slice(0, 3).map((pair) => new THREE.Vector3(pair.target.x, pair.target.y, pair.target.z));\r\n\r\n  const sourceFrame = frameFromPoints(sources[0], sources[1], sources[2]);\r\n  const targetFrame = frameFromPoints(targets[0], targets[1], targets[2]);\r\n  if (!sourceFrame || !targetFrame) {\r\n    return null;\r\n  }\r\n\r\n  // A rotation's inverse is its transpose, so this is the rotation carrying one frame onto the other.\r\n  const rotation = targetFrame.multiply(sourceFrame.clone().transpose());\r\n\r\n  // Scale from how far apart the points are in each space, averaged over the three edges so a single\r\n  // sloppy click does not set it on its own.\r\n  const edges = [[0, 1], [1, 2], [0, 2]];\r\n  let ratioSum = 0;\r\n  let ratioCount = 0;\r\n  for (const [i, j] of edges) {\r\n    const sourceLength = sources[i].distanceTo(sources[j]);\r\n    const targetLength = targets[i].distanceTo(targets[j]);\r\n    if (sourceLength > 1e-9) {\r\n      ratioSum += targetLength / sourceLength;\r\n      ratioCount += 1;\r\n    }\r\n  }\r\n  if (ratioCount === 0) {\r\n    return null;\r\n  }\r\n  const scale = ratioSum / ratioCount;\r\n\r\n  // The group applies position, then rotation, then scale, so a point lands at t + s*R*p. Solving\r\n  // that for t at the centroids gives the translation.\r\n  const sourceCentroid = sources.reduce((sum, v) => sum.add(v), new THREE.Vector3()).multiplyScalar(1 / 3);\r\n  const targetCentroid = targets.reduce((sum, v) => sum.add(v), new THREE.Vector3()).multiplyScalar(1 / 3);\r\n  const translation = targetCentroid\r\n    .clone()\r\n    .sub(sourceCentroid.clone().applyMatrix4(rotation).multiplyScalar(scale));\r\n\r\n  const euler = new THREE.Euler().setFromRotationMatrix(rotation);\r\n\r\n  return {\r\n    translation: { x: translation.x, y: translation.y, z: translation.z },\r\n    rotation: { x: euler.x, y: euler.y, z: euler.z },\r\n    scale,\r\n  };\r\n}\r\n\r\nexport interface ObjAdded {\r\n  id: string;\r\n  name: string;\r\n  file: string; // The URL to the .obj file\r\n  position: { x: number; y: number; z: number };\r\n  rotation: { x: number; y: number; z: number };\r\n  scale: { x: number; y: number; z: number };\r\n}\r\n\r\ninterface ParsedMeshGroup {\r\n  start: number;\r\n  count: number;\r\n  materialIndex: number;\r\n}\r\n\r\n/** Raw geometry data extracted from a parsed OBJ mesh, sent back by the parser worker. */\r\ninterface ParsedMeshData {\r\n  name: string;\r\n  // One name per material used by this mesh. A single-material mesh has one entry;\r\n  // a mesh with multiple usemtl switches (geometry.groups) has one per group.\r\n  materialNames: string[];\r\n  groups: ParsedMeshGroup[] | null;\r\n  position: Float32Array;\r\n  normal: Float32Array | null;\r\n  uv: Float32Array | null;\r\n  index: Uint32Array | null;\r\n  boundingBox?: { min: [number, number, number]; max: [number, number, number] };\r\n}\r\n\r\ninterface ObjParserWorkerResponse {\r\n  requestId: string;\r\n  success: boolean;\r\n  meshes?: ParsedMeshData[];\r\n  error?: string;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ThreeJsService {\r\n  private scene!: THREE.Scene;\r\n  private camera!: THREE.PerspectiveCamera;\r\n  private renderer!: THREE.WebGLRenderer;\r\n  private controls!: OrbitControls;\r\n  private animationFrameId!: number;\r\n\r\n  // Raycasting and interaction\r\n  private raycaster = new THREE.Raycaster();\r\n  private mouse = new THREE.Vector2();\r\n  private isDraggingCamera: boolean = false;\r\n  private isDraggingTimer: any;\r\n  private clickableObjects: THREE.Object3D[] = [];\r\n\r\n  // Observables for the viewer component\r\n  public objectHovered$ = new Subject<{ id: string; event: MouseEvent } | null>();\r\n  public objectClicked$ = new Subject<string | null>();\r\n\r\n  /** Emits when the user clicks a tag, mirroring Matterport's tag click. */\r\n  public tagClicked$ = new Subject<ThreeJsTagClick>();\r\n\r\n  /** Emits a tag's label while the pointer is over it, and null when it leaves. */\r\n  public tagHovered$ = new Subject<{ label: string; event: MouseEvent } | null>();\r\n\r\n  // Tags live under the model rather than the scene, so the centering and scaling applied when the\r\n  // model is placed carries over and POI coordinates can stay in the model's own space.\r\n  private tagGroup = new THREE.Group();\r\n  private tagSprites = new Map<string, THREE.Sprite>();\r\n\r\n  private canvasResizeObserver?: ResizeObserver;\r\n\r\n  /** Aborts the in-flight model download. Parsing cannot be interrupted, only not started. */\r\n  private loadAbortController?: AbortController;\r\n\r\n  // The loaded base model, kept so tag placement can raycast against its geometry.\r\n  private modelRoot?: THREE.Object3D;\r\n\r\n  /** True while the next click on the model places a tag instead of orbiting. */\r\n  private placingTag = false;\r\n\r\n  /** What the armed placement is for, echoed back when the spot is picked. */\r\n  private placementPoiType: PoiType | null = null;\r\n\r\n  /** Position and normal of the last placed tag, in model space, awaiting commit to a POI. */\r\n  private pendingTagPlacement: ThreeJsTagPlacement | null = null;\r\n\r\n  /** Pointer position waiting for a preview pick, coalesced to one per frame. */\r\n  private pendingPreviewEvent: MouseEvent | null = null;\r\n\r\n  /**\r\n   * Layer carrying the model alone, so the depth pick can render it without the tags.\r\n   *\r\n   * Layers are tested per object at render time and children are traversed regardless of whether\r\n   * their parent passed, so marking the model's own meshes is enough - no re-parenting.\r\n   */\r\n  private static readonly PICK_LAYER = 1;\r\n\r\n  /** Cache Storage bucket holding downloaded models, and how many to keep. */\r\n  private static readonly MODEL_CACHE = 'smarterplan-3d-models';\r\n\r\n  private static readonly MODEL_CACHE_SIZE = 3;\r\n\r\n  private pickTarget?: THREE.WebGLRenderTarget;\r\n\r\n  private pickCamera?: THREE.PerspectiveCamera;\r\n\r\n  private pickDepthMaterial?: THREE.MeshDepthMaterial;\r\n\r\n  private readonly pickPixel = new Uint8Array(4);\r\n\r\n  /** Emits once a tag is dropped on the model, so the UI can confirm and persist it. */\r\n  public tagPlaced$ = new Subject<ThreeJsTagPlacement>();\r\n\r\n  /** Emits when the calibration walkthrough is abandoned, so the panel driving it can close. */\r\n  public alignmentCancelled$ = new Subject<void>();\r\n\r\n  /** Translucent marker shown under the cursor while placing. */\r\n  private placementPreview?: THREE.Sprite;\r\n\r\n  private aligning = false;\r\n  private alignmentPairs: ThreeJsAlignmentPair[] = [];\r\n  private alignmentSource: { x: number; y: number; z: number } | null = null;\r\n\r\n  /** Drives the alignment walkthrough's UI: how many pairs are done and what it wants next. */\r\n  public alignmentProgress$ = new Subject<{\r\n    pairs: number;\r\n    awaiting: 'tag' | 'point' | null;\r\n    tagId?: string;\r\n  }>();\r\n\r\n  /** In-flight camera move started by goToTag, advanced by the render loop. */\r\n  private cameraTween: {\r\n    fromPosition: THREE.Vector3;\r\n    toPosition: THREE.Vector3;\r\n    fromTarget: THREE.Vector3;\r\n    toTarget: THREE.Vector3;\r\n    startedAt: number;\r\n    durationMs: number;\r\n  } | null = null;\r\n\r\n  /** Emits true while a heavy OBJ file is being parsed (in a worker, when available), false once done. */\r\n  public modelLoading$ = new Subject<boolean>();\r\n\r\n  /**\r\n   * Download progress for GLB models, as a 0-1 fraction, or null when the total size is unknown.\r\n   *\r\n   * A null means the server did not send Content-Length (chunked responses, some proxies) and no\r\n   * percentage can be derived; show an indeterminate indicator rather than guessing at one.\r\n   */\r\n  public modelLoadProgress$ = new Subject<number | null>();\r\n\r\n  /**\r\n   * Emits when a load actually stopped short, which is not the same as asking it to.\r\n   *\r\n   * cancelModelLoad() can arrive after parse() has taken the main thread, and parse cannot be\r\n   * interrupted - the model finishes loading regardless. Only this tells the UI which of the two\r\n   * happened, so it does not offer to reload something that is already on screen.\r\n   */\r\n  public modelLoadCancelled$ = new Subject<void>();\r\n\r\n  // Background parsing of heavy .obj files, provided by the hosting app (see setObjParserWorker).\r\n  // Angular libraries built with ng-packagr can't bundle `new Worker(new URL(...))` themselves,\r\n  // so the app instantiates the worker (its build pipeline supports it) and hands it over here.\r\n  private objParserWorker?: Worker;\r\n  private objParserPendingRequests = new Map<string, { resolve: (meshes: ParsedMeshData[]) => void; reject: (error: Error) => void }>();\r\n\r\n  constructor(private ngZone: NgZone) { }\r\n\r\n  /**\r\n   * Registers a Web Worker used to parse heavy .obj files off the main thread.\r\n   * Must be instantiated by the consuming app (e.g. `new Worker(new URL('./obj-parser.worker', import.meta.url))`),\r\n   * since a library packaged with ng-packagr cannot bundle worker files itself.\r\n   * When no worker is provided, loadObjModel falls back to parsing on the main thread.\r\n   */\r\n  setObjParserWorker(worker: Worker): void {\r\n    this.objParserWorker = worker;\r\n    this.objParserWorker.onmessage = ({ data }: MessageEvent<ObjParserWorkerResponse>) => {\r\n      const pending = this.objParserPendingRequests.get(data.requestId);\r\n      if (!pending) {\r\n        return;\r\n      }\r\n      this.objParserPendingRequests.delete(data.requestId);\r\n      if (data.success && data.meshes) {\r\n        pending.resolve(data.meshes);\r\n      } else {\r\n        pending.reject(new Error(data.error || 'Unknown error while parsing OBJ file in worker'));\r\n      }\r\n    };\r\n  }\r\n\r\n  private requestObjParseInWorker(objUrl: string): Promise<ParsedMeshData[]> {\r\n    return new Promise((resolve, reject) => {\r\n      const requestId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;\r\n      this.objParserPendingRequests.set(requestId, { resolve, reject });\r\n      this.objParserWorker!.postMessage({ requestId, objUrl });\r\n      // Diagnostic only: large models legitimately take a while, this isn't a timeout/abort,\r\n      // just a signal in case the worker went silent (e.g. it ran out of memory mid-parse).\r\n      setTimeout(() => {\r\n        if (this.objParserPendingRequests.has(requestId)) {\r\n          console.warn(`ThreeJsService: obj-parser worker has not replied after 60s for request ${requestId} (objUrl=${objUrl}). Still waiting - large files can take a while, but this may also mean the worker hung or ran out of memory.`);\r\n        }\r\n      }, 60000);\r\n    });\r\n  }\r\n\r\n  /** Rebuilds a THREE.Mesh from the raw typed arrays sent back by the parser worker. */\r\n  private meshFromParsedData(data: ParsedMeshData, materials?: any): THREE.Mesh {\r\n    const geometry = new THREE.BufferGeometry();\r\n    geometry.setAttribute('position', new THREE.BufferAttribute(data.position, 3));\r\n    if (data.uv) {\r\n      geometry.setAttribute('uv', new THREE.BufferAttribute(data.uv, 2));\r\n    }\r\n    // Index has to be set before any normal computation, which reads it to average shared faces.\r\n    if (data.index) {\r\n      geometry.setIndex(new THREE.BufferAttribute(data.index, 1));\r\n    }\r\n    if (data.normal) {\r\n      geometry.setAttribute('normal', new THREE.BufferAttribute(data.normal, 3));\r\n    } else {\r\n      geometry.computeVertexNormals();\r\n    }\r\n    // Box3.setFromObject() reuses an already-set boundingBox instead of walking every vertex,\r\n    // so adopting the worker's makes framing the camera cheap no matter how dense the mesh is.\r\n    if (data.boundingBox) {\r\n      geometry.boundingBox = new THREE.Box3(\r\n        new THREE.Vector3(...data.boundingBox.min),\r\n        new THREE.Vector3(...data.boundingBox.max),\r\n      );\r\n    }\r\n\r\n    const resolvedMaterials = data.materialNames.map((name) => {\r\n      const material = materials && name ? materials.create(name) : undefined;\r\n      if (!material) {\r\n        console.warn(`ThreeJsService: no MTL material named \"${name}\" for mesh \"${data.name}\", using a plain fallback (no texture).`);\r\n      }\r\n      return material || new THREE.MeshPhongMaterial();\r\n    });\r\n\r\n    let mesh: THREE.Mesh;\r\n    if (data.groups && data.groups.length > 0) {\r\n      data.groups.forEach((group) => geometry.addGroup(group.start, group.count, group.materialIndex));\r\n      mesh = new THREE.Mesh(geometry, resolvedMaterials);\r\n    } else {\r\n      mesh = new THREE.Mesh(geometry, resolvedMaterials[0]);\r\n    }\r\n    mesh.name = data.name;\r\n    return mesh;\r\n  }\r\n\r\n  init(canvas: HTMLCanvasElement): void {\r\n    // This service is a singleton but the viewer component is rebuilt on every navigation, so state\r\n    // from the previous scene is still here. Two things outlive it and have to go first:\r\n    //\r\n    //  - A download still in flight. Its onLoaded resolves against whatever `this.scene` points at\r\n    //    by then, so the model being abandoned would be handed to the scene built below.\r\n    //  - The tag group, which is a field and keeps its sprites. They would be re-parented under the\r\n    //    new model and show the previous visit's tags on it.\r\n    this.discardCurrentLoad();\r\n    this.clearTags();\r\n    this.cameraTween = null;\r\n    this.modelRoot = undefined;\r\n\r\n    // 1. Setup Scene\r\n    this.scene = new THREE.Scene();\r\n    this.scene.background = new THREE.Color(0xe0f7ff); // from POC\r\n\r\n    // 2. Setup Camera\r\n    this.camera = new THREE.PerspectiveCamera(75, canvas.clientWidth / canvas.clientHeight, 0.1, 10000);\r\n    this.camera.position.set(0, 5, 10); // will be overridden later if passed\r\n\r\n    // 3. Setup WebGL Renderer\r\n    this.renderer = new THREE.WebGLRenderer({ canvas, antialias: true });\r\n    this.renderer.setSize(canvas.clientWidth, canvas.clientHeight);\r\n    this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 1.5));\r\n    this.observeCanvasResize(canvas);\r\n    \r\n    // Fix for Three.js r147 vs r152+ color management\r\n    if ('outputColorSpace' in this.renderer) {\r\n      (this.renderer as any).outputColorSpace = 'srgb'; // THREE.SRGBColorSpace\r\n    } else {\r\n      (this.renderer as any).outputEncoding = 3001; // THREE.sRGBEncoding\r\n    }\r\n\r\n    // Without tone mapping anything brighter than 1.0 is simply cut off to pure white. Captured\r\n    // textures carry a small fraction of very bright pixels - sky reflected in windows, sunlit\r\n    // render - and once lighting pushes those past the limit they flatten into white specks with\r\n    // no detail left. Rolling the highlights off instead keeps that detail and keeps bright areas\r\n    // reading as bright rather than blown.\r\n    this.renderer.toneMapping = THREE.ACESFilmicToneMapping;\r\n    this.renderer.toneMappingExposure = 1.0;\r\n\r\n    // 4. Lighting, kept deliberately restrained and neutral.\r\n    //\r\n    // Captured/photogrammetry models already have lighting baked into their textures (the sun and\r\n    // shadows came with the photos), so lighting them again distorts what they actually look like.\r\n    // The intensities below add up to roughly 1.0 on a surface facing the viewer, which renders the\r\n    // texture at its true value. Anything above 1.0 is clipped to pure white by the renderer, which\r\n    // is what turns bright areas into flat white patches with no detail left in them.\r\n    //\r\n    // Neutral white is used rather than a warm tint for the same reason: a tinted light shifts every\r\n    // colour in the model away from what was captured.\r\n    const ambientLight = new THREE.AmbientLight(0xffffff, 0.7);\r\n    this.scene.add(ambientLight);\r\n\r\n    // Headlight rather than a fixed sun: parented to the camera so it always points at whatever is\r\n    // being looked at, giving shape to surfaces without ever leaving a face unlit. No shadow casting\r\n    // - shadows would double up with the ones already baked into the textures, and the shadow map\r\n    // was a real cost per frame.\r\n    const headLight = new THREE.DirectionalLight(0xffffff, 0.35);\r\n    headLight.position.set(0, 0, 1);\r\n    this.camera.add(headLight);\r\n    // A light only contributes while it is part of the scene graph, and this one hangs off the camera.\r\n    this.scene.add(this.camera);\r\n\r\n    // 5. Setup Controls (from POC)\r\n    this.controls = new OrbitControls(this.camera, this.renderer.domElement);\r\n    this.controls.rotateSpeed = 1.0;\r\n    this.controls.dampingFactor = 0.1;\r\n    this.controls.enableDamping = true;\r\n    this.controls.mouseButtons = {\r\n      LEFT: THREE.MOUSE.ROTATE,\r\n      MIDDLE: THREE.MOUSE.DOLLY,\r\n      RIGHT: THREE.MOUSE.PAN,\r\n    };\r\n    this.controls.target.set(0, 0, 0);\r\n\r\n    // Event listeners on controls to differentiate dragging vs clicking\r\n    this.controls.addEventListener('start', () => {\r\n      this.isDraggingTimer = setTimeout(() => {\r\n        this.isDraggingCamera = true;\r\n      }, 150);\r\n    });\r\n\r\n    this.controls.addEventListener('end', () => {\r\n      clearTimeout(this.isDraggingTimer);\r\n      if (this.isDraggingCamera) {\r\n        setTimeout(() => {\r\n          this.isDraggingCamera = false;\r\n        }, 250);\r\n      }\r\n    });\r\n\r\n    // Interaction Event Listeners on canvas\r\n    canvas.addEventListener('click', this.onMouseClick.bind(this), false);\r\n    canvas.addEventListener('mousemove', this.onMouseMove.bind(this), false);\r\n\r\n    // Escape backs out of placement and calibration. On the window rather than the canvas, which\r\n    // would need focus the user has no reason to have given it - they are aiming with the mouse.\r\n    // Removed first because this service is a singleton: init() runs again for every canvas, and\r\n    // the previous registration would otherwise still be attached.\r\n    window.removeEventListener('keydown', this.onKeyDown);\r\n    this.pickTarget?.dispose();\r\n    this.pickTarget = undefined;\r\n    this.pickDepthMaterial?.dispose();\r\n    this.pickDepthMaterial = undefined;\r\n    this.pickCamera = undefined;\r\n    window.addEventListener('keydown', this.onKeyDown);\r\n\r\n    // 6. Start the render loop\r\n    this.ngZone.runOutsideAngular(() => {\r\n      this.animate();\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Path (served by the app) holding basis_transcoder.js/.wasm, which KTX2Loader needs to turn\r\n   * Basis Universal textures into whatever compressed format the local GPU actually supports.\r\n   */\r\n  private ktx2TranscoderPath = 'assets/basis/';\r\n\r\n  /** Overrides where the Basis transcoder files are served from. */\r\n  setKtx2TranscoderPath(path: string): void {\r\n    this.ktx2TranscoderPath = path;\r\n  }\r\n\r\n  /**\r\n   * Loads a base 3D model in GLTF/GLB format - the preferred format for large models.\r\n   * Unlike .obj, geometry arrives as binary typed arrays (no text parsing to offload to a worker)\r\n   * and stays indexed, so far less data reaches the GPU. KTX2 textures are supported too: they\r\n   * stay compressed in VRAM instead of being decoded to raw pixels like JPEG/PNG.\r\n   */\r\n  loadGLTFModel(url: string, cameraPosition?: {x: number, y: number, z: number}, rotation?: {x: number, y: number, z: number}, cacheKey?: string): void {\r\n    const loader = new GLTFLoader();\r\n\r\n    // KTX2 needs the renderer to report which compressed formats this GPU accepts, so this has to\r\n    // happen after init(). Guarded so a model without KTX2 textures still loads if it's missing.\r\n    if (this.renderer) {\r\n      try {\r\n        const ktx2Loader = new KTX2Loader()\r\n          .setTranscoderPath(this.ktx2TranscoderPath)\r\n          .detectSupport(this.renderer);\r\n        loader.setKTX2Loader(ktx2Loader);\r\n      } catch (error) {\r\n        console.warn('ThreeJsService: could not set up KTX2 texture support, falling back to uncompressed textures.', error);\r\n      }\r\n    }\r\n    // Lets gltfpack/gltf-transform output using EXT_meshopt_compression load without extra setup.\r\n    loader.setMeshoptDecoder(MeshoptDecoder);\r\n\r\n    this.modelLoading$.next(true);\r\n    this.modelLoadProgress$.next(0);\r\n\r\n    // Order matters: normals must exist before anisotropy, and the Phong conversion has to run\r\n    // before side/flatShading are touched so those settings land on the materials we keep.\r\n    const onLoaded = (gltf: any) => {\r\n      this.convertToPhongMaterials(gltf.scene);\r\n      this.forceDoubleSidedMaterials(gltf.scene);\r\n      this.ensureVertexNormals(gltf.scene);\r\n      this.tuneTextureSampling(gltf.scene);\r\n      this.placeLoadedObjectInScene(gltf.scene, cameraPosition, rotation);\r\n      this.modelLoading$.next(false);\r\n    };\r\n    const onError = (error: any) => {\r\n      // Cancelling is a decision, not a failure: clear the overlay without an error in the console.\r\n      if (error?.name === 'AbortError') {\r\n        // Only a cancel of the load that is still current came from the user; anything else is this\r\n        // load having been superseded or discarded.\r\n        if (this.loadAbortController?.signal.aborted) {\r\n          this.modelLoadCancelled$.next();\r\n        }\r\n      } else {\r\n        console.error('Error loading GLTF model:', error);\r\n      }\r\n      this.modelLoading$.next(false);\r\n      this.modelLoadProgress$.next(null);\r\n    };\r\n\r\n    // GLTFLoader decodes embedded images with createImageBitmap when the browser offers it, and on\r\n    // large texture atlases that path returns visibly corrupt data - scattered white blocks across\r\n    // the model. The exact same bytes decoded through an HTMLImageElement, which is what the .obj\r\n    // path uses via MTLLoader, come out clean. GLTFLoader already falls back to that decoder for\r\n    // Safari and older Firefox; this simply extends the fallback to cover this case too.\r\n    //\r\n    // The decoder is chosen while GLTFParser is being constructed, which happens synchronously\r\n    // inside parse(), so hiding createImageBitmap only has to hold across that call rather than\r\n    // for the whole download.\r\n    this.fetchWithProgress(url, cacheKey)\r\n      // parse() holds the main thread for seconds on a large model. Yield until the browser has\r\n      // actually painted first, otherwise the final progress update never reaches the screen and\r\n      // the bar appears to stall short of the end.\r\n      .then((buffer) => this.afterNextPaint().then(() => buffer))\r\n      .then((buffer) => {\r\n        // parse() cannot be interrupted, so a cancel that lands during the paint yield has to be\r\n        // caught here - the last moment before the main thread is committed for several seconds.\r\n        if (this.loadAbortController?.signal.aborted) {\r\n          throw new DOMException('Model load cancelled', 'AbortError');\r\n        }\r\n        const globalScope = globalThis as any;\r\n        const originalCreateImageBitmap = globalScope.createImageBitmap;\r\n        globalScope.createImageBitmap = undefined;\r\n        try {\r\n          loader.parse(buffer, url.substring(0, url.lastIndexOf('/') + 1), onLoaded, onError);\r\n        } finally {\r\n          globalScope.createImageBitmap = originalCreateImageBitmap;\r\n        }\r\n      })\r\n      .catch(onError);\r\n  }\r\n\r\n  /**\r\n   * Stops the model download in progress, if any.\r\n   *\r\n   * Only the download can be interrupted: parse() runs synchronously and holds the main thread until\r\n   * it finishes, so once it has begun there is nothing to cancel. In practice the download is the\r\n   * long part, which is where someone reaches for this.\r\n   */\r\n  cancelModelLoad(): void {\r\n    this.loadAbortController?.abort();\r\n  }\r\n\r\n  /**\r\n   * Abandons the load in progress without reporting it as cancelled.\r\n   *\r\n   * Dropping the controller is what makes the difference: onError treats an abort as user-initiated\r\n   * only while the controller that aborted is still the current one. Tearing down or rebuilding the\r\n   * scene is not something the person asked for, so it must not surface as \"loading cancelled\".\r\n   */\r\n  private discardCurrentLoad(): void {\r\n    this.loadAbortController?.abort();\r\n    this.loadAbortController = undefined;\r\n  }\r\n\r\n  /**\r\n   * Resolves once the browser has painted at least one frame.\r\n   *\r\n   * A requestAnimationFrame callback runs *before* that frame is painted, so a single one is not\r\n   * enough to guarantee pending DOM changes are on screen; the second fires after the first frame\r\n   * has gone out. Falls back to a timeout where rAF isn't available (SSR, tests).\r\n   */\r\n  private afterNextPaint(): Promise<void> {\r\n    if (typeof requestAnimationFrame !== 'function') {\r\n      return new Promise((resolve) => setTimeout(resolve, 0));\r\n    }\r\n    return new Promise((resolve) => {\r\n      requestAnimationFrame(() => requestAnimationFrame(() => resolve()));\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Downloads a file, reporting progress on modelLoadProgress$ as it arrives.\r\n   *\r\n   * GLTFLoader.load() would report progress through XHR, but this path deliberately uses fetch() +\r\n   * parse() instead (see loadGLTFModel for why), so progress is read off the response stream here.\r\n   * That is also the more useful number: on a model of this size the download dominates, and the\r\n   * stream reports it as it happens rather than in one jump at the end.\r\n   */\r\n  private async fetchWithProgress(url: string, cacheKey?: string): Promise<ArrayBuffer> {\r\n    // A load already running is replaced, not raced: whichever finished last would otherwise win.\r\n    this.loadAbortController?.abort();\r\n    this.loadAbortController = new AbortController();\r\n    const { signal } = this.loadAbortController;\r\n\r\n    const cached = await this.readModelFromCache(cacheKey);\r\n    if (cached) {\r\n      this.modelLoadProgress$.next(1);\r\n      return cached;\r\n    }\r\n\r\n    const response = await fetch(url, { signal });\r\n    if (!response.ok) {\r\n      throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);\r\n    }\r\n\r\n    const contentLength = Number(response.headers.get('Content-Length'));\r\n    const total = Number.isFinite(contentLength) && contentLength > 0 ? contentLength : 0;\r\n\r\n    // Without a readable stream (older browsers, some polyfills) there is nothing to measure, so\r\n    // fall back to a plain buffered read and let the UI show an indeterminate indicator.\r\n    if (!response.body?.getReader) {\r\n      this.modelLoadProgress$.next(null);\r\n      return response.arrayBuffer();\r\n    }\r\n\r\n    const reader = response.body.getReader();\r\n\r\n    // With a known size, write chunks straight into one pre-allocated buffer. Collecting them in an\r\n    // array and concatenating afterwards would hold both copies at once - on a 164 MB model that is\r\n    // an avoidable 300+ MB peak.\r\n    const buffer = total > 0 ? new Uint8Array(total) : null;\r\n    const chunks: Uint8Array[] = [];\r\n    let usingBuffer = buffer !== null;\r\n    let received = 0;\r\n    // Chunks arrive in tens of kilobytes, so a 164 MB model produces thousands of them. Emitting on\r\n    // every one would run change detection just as often to move a bar that is measured in whole\r\n    // percent, so only report when the displayed value would actually change.\r\n    let lastReported = -1;\r\n\r\n    if (total === 0) {\r\n      this.modelLoadProgress$.next(null);\r\n    }\r\n\r\n    for (;;) {\r\n      const { done, value } = await reader.read();\r\n      if (done) {\r\n        break;\r\n      }\r\n      if (signal.aborted) {\r\n        // Free the connection rather than leaving it draining in the background.\r\n        await reader.cancel();\r\n        throw new DOMException('Model load cancelled', 'AbortError');\r\n      }\r\n      if (usingBuffer && received + value.length > total) {\r\n        // Content-Length understated the real size. Move what we have into the chunk list and stay\r\n        // there for the rest of the response, rather than truncating the tail.\r\n        chunks.push(buffer.slice(0, received));\r\n        usingBuffer = false;\r\n      }\r\n      if (usingBuffer) {\r\n        buffer.set(value, received);\r\n      } else {\r\n        chunks.push(value);\r\n      }\r\n      received += value.length;\r\n      if (total > 0) {\r\n        const percent = Math.min(Math.round((received / total) * 100), 100);\r\n        if (percent !== lastReported) {\r\n          lastReported = percent;\r\n          this.modelLoadProgress$.next(percent / 100);\r\n        }\r\n      }\r\n    }\r\n\r\n    // The stream can end below the advertised size (or with no size at all). Land on a full bar\r\n    // rather than leaving it stuck at whatever the last chunk happened to reach.\r\n    if (total > 0 && lastReported !== 100) {\r\n      this.modelLoadProgress$.next(1);\r\n    }\r\n\r\n    let result: ArrayBuffer;\r\n    if (usingBuffer && received === total) {\r\n      result = buffer.buffer;\r\n    } else if (usingBuffer) {\r\n      // Fewer bytes than advertised: hand back exactly what arrived.\r\n      result = buffer.buffer.slice(0, received);\r\n    } else {\r\n      const merged = new Uint8Array(received);\r\n      let offset = 0;\r\n      chunks.forEach((chunk) => {\r\n        merged.set(chunk, offset);\r\n        offset += chunk.length;\r\n      });\r\n      result = merged.buffer;\r\n    }\r\n\r\n    await this.writeModelToCache(cacheKey, result);\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * The model store, or null where the browser will not give us one.\r\n   *\r\n   * Cache Storage needs a secure context, so it is absent over plain http and in some embedded\r\n   * webviews. Every caller treats that as a miss - caching is an optimisation, never a requirement.\r\n   */\r\n  private async openModelCache(): Promise<Cache | null> {\r\n    if (typeof caches === 'undefined') {\r\n      return null;\r\n    }\r\n    try {\r\n      return await caches.open(ThreeJsService.MODEL_CACHE);\r\n    } catch {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * A cached copy of this model, if one was stored.\r\n   *\r\n   * Keyed by the S3 key rather than the URL it is fetched from: that URL is signed, so it carries a\r\n   * fresh signature and expiry every time and would never match twice. The browser's own HTTP cache\r\n   * misses for the same reason, which is why this exists at all.\r\n   */\r\n  private async readModelFromCache(cacheKey?: string): Promise<ArrayBuffer | null> {\r\n    if (!cacheKey) {\r\n      return null;\r\n    }\r\n    try {\r\n      const cache = await this.openModelCache();\r\n      const hit = await cache?.match(this.modelCacheUrl(cacheKey));\r\n      return hit ? await hit.arrayBuffer() : null;\r\n    } catch {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  /** Stores a model for next time, evicting the oldest once a few are held. */\r\n  private async writeModelToCache(cacheKey: string | undefined, model: ArrayBuffer): Promise<void> {\r\n    if (!cacheKey) {\r\n      return;\r\n    }\r\n    try {\r\n      const cache = await this.openModelCache();\r\n      if (!cache) {\r\n        return;\r\n      }\r\n      await cache.put(this.modelCacheUrl(cacheKey), new Response(model));\r\n\r\n      // Models run to hundreds of megabytes, so this cannot grow without limit. Cache Storage keeps\r\n      // insertion order, which makes the front of the list the least recently stored.\r\n      const keys = await cache.keys();\r\n      await Promise.all(\r\n        keys.slice(0, Math.max(0, keys.length - ThreeJsService.MODEL_CACHE_SIZE))\r\n          .map((key) => cache.delete(key))\r\n      );\r\n    } catch {\r\n      // Out of quota, private browsing, storage disabled: the model is already loaded either way.\r\n    }\r\n  }\r\n\r\n  /** Cache Storage keys on a URL, so the S3 key is expressed as one. It is never requested. */\r\n  private modelCacheUrl(cacheKey: string): string {\r\n    return `https://3d-model-cache.smarterplan.local/${encodeURIComponent(cacheKey)}`;\r\n  }\r\n\r\n  /**\r\n   * Fits the camera's clipping planes to how big the model actually is.\r\n   *\r\n   * Depth precision depends on the far/near ratio, and the fixed 0.1 / 10000 the camera starts with\r\n   * is a ratio of 100000 for a model only ~10 units across. That wastes most of the depth buffer on\r\n   * empty space and lets nearly coincident surfaces - which captured meshes have everywhere -\r\n   * flicker against each other.\r\n   */\r\n  private adjustClippingPlanes(radius: number): void {\r\n    if (radius < 10) {\r\n      this.camera.near = 0.01;\r\n      this.camera.far = 100;\r\n    } else if (radius < 100) {\r\n      this.camera.near = 0.1;\r\n      this.camera.far = 1000;\r\n    } else if (radius < 1000) {\r\n      this.camera.near = 10;\r\n      this.camera.far = 10000;\r\n    } else {\r\n      this.camera.near = 100;\r\n      this.camera.far = 1000000;\r\n    }\r\n    this.camera.updateProjectionMatrix();\r\n  }\r\n\r\n  /**\r\n   * Swaps the PBR materials GLTFLoader builds for the plain Phong ones the .obj path produces.\r\n   *\r\n   * MeshStandardMaterial keeps a specular reflection even at metalness 0, since every dielectric\r\n   * reflects some light, and Fresnel drives that reflection towards white as a surface turns away\r\n   * from the viewer. On an aerial view of a facade most surfaces sit at exactly those grazing\r\n   * angles, which paints white highlights over window frames and roof edges - the same model\r\n   * loaded as .obj never shows them, because MTLLoader builds Phong materials and OBJLoader zeroes\r\n   * their specular when the .mtl declares Ns 0.\r\n   *\r\n   * Captured models carry their lighting in the texture and want no specular response at all, so\r\n   * matching the .obj path here is both the fix and the more faithful choice.\r\n   */\r\n  private convertToPhongMaterials(root: THREE.Object3D): void {\r\n    const converted = new Map<any, THREE.MeshPhongMaterial>();\r\n\r\n    root.traverse((child) => {\r\n      const mesh = child as THREE.Mesh;\r\n      if (!(mesh as any).isMesh) {\r\n        return;\r\n      }\r\n\r\n      const convert = (source: any): any => {\r\n        if (!source || !(source as any).isMeshStandardMaterial) {\r\n          return source;\r\n        }\r\n        if (!converted.has(source)) {\r\n          const phong = new THREE.MeshPhongMaterial({\r\n            map: source.map,\r\n            color: source.color,\r\n            transparent: source.transparent,\r\n            opacity: source.opacity,\r\n            alphaTest: source.alphaTest,\r\n            side: source.side,\r\n            specular: new THREE.Color(0x000000),\r\n            shininess: 0,\r\n          });\r\n          phong.name = source.name;\r\n          converted.set(source, phong);\r\n        }\r\n        return converted.get(source);\r\n      };\r\n\r\n      mesh.material = Array.isArray(mesh.material)\r\n        ? mesh.material.map(convert)\r\n        : convert(mesh.material);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Renders every material double-sided.\r\n   *\r\n   * Reality capture meshes routinely contain triangles with reversed winding - an artefact of the\r\n   * reconstruction, not of the file. With the default FrontSide those triangles are culled, leaving\r\n   * scattered holes that show the scene background through the model. Against a light background\r\n   * they read as white specks with no discernible pattern.\r\n   *\r\n   * Drawing both sides costs a little fill rate but is what makes captured geometry render as\r\n   * solid; other viewers of this kind of content do the same unconditionally.\r\n   */\r\n  private forceDoubleSidedMaterials(root: THREE.Object3D): void {\r\n    const seen = new Set<any>();\r\n    root.traverse((child) => {\r\n      const mesh = child as THREE.Mesh;\r\n      if (!(mesh as any).isMesh) {\r\n        return;\r\n      }\r\n      const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];\r\n      materials.forEach((material: any) => {\r\n        if (material && !seen.has(material)) {\r\n          seen.add(material);\r\n          material.side = THREE.DoubleSide;\r\n          material.needsUpdate = true;\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Computes real vertex normals for any geometry that arrived without them.\r\n   *\r\n   * A glTF without a NORMAL attribute is spec-compliant, and GLTFLoader handles it by switching the\r\n   * material to flatShading, which makes the shader derive the normal per pixel from screen-space\r\n   * derivatives. That derivation collapses on the degenerate, needle-thin triangles that reality\r\n   * capture meshes are full of: the face has almost no area, the derived normal is meaningless, and\r\n   * lighting blows those fragments out to white specks - densest exactly where fine detail is.\r\n   *\r\n   * Computing normals from the geometry instead is robust to those triangles, since a degenerate\r\n   * face contributes almost nothing to the average and its neighbours dominate.\r\n   */\r\n  private ensureVertexNormals(root: THREE.Object3D): void {\r\n    root.traverse((child) => {\r\n      const mesh = child as THREE.Mesh;\r\n      if (!(mesh as any).isMesh) {\r\n        return;\r\n      }\r\n      const geometry = mesh.geometry as THREE.BufferGeometry;\r\n      if (geometry.getAttribute('normal')) {\r\n        return;\r\n      }\r\n\r\n      geometry.computeVertexNormals();\r\n\r\n      // GLTFLoader already switched these materials to flatShading because normals were missing;\r\n      // now that real ones exist, let them be used instead of the derivative fallback.\r\n      const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];\r\n      materials.forEach((material: any) => {\r\n        if (material && material.flatShading) {\r\n          material.flatShading = false;\r\n          material.needsUpdate = true;\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Configures how every texture in a model is sampled: maximum anisotropy, and no mipmapping.\r\n   *\r\n   * Photogrammetry atlases pack their UV islands with unused gutter pixels between them. Mipmapping\r\n   * averages neighbouring pixels at each level, so those gutters bleed further into the islands the\r\n   * smaller the level gets - and viewing the whole model at once uses the smallest levels, painting\r\n   * bright gutter pixels over the edges of fine detail. Sampling the full-resolution image avoids\r\n   * that, at the cost of some shimmer on minified surfaces.\r\n   *\r\n   * Note that anisotropy only takes effect while mipmapping is on, so with the settings below it is\r\n   * inert; it is set anyway so the sampling stays correct for anyone who re-enables mipmaps here.\r\n   */\r\n  private tuneTextureSampling(root: THREE.Object3D): void {\r\n    if (!this.renderer) {\r\n      return;\r\n    }\r\n    const maxAnisotropy = this.renderer.capabilities.getMaxAnisotropy();\r\n    if (!maxAnisotropy || maxAnisotropy <= 1) {\r\n      return;\r\n    }\r\n\r\n    const seen = new Set<any>();\r\n    root.traverse((child) => {\r\n      const mesh = child as THREE.Mesh;\r\n      if (!(mesh as any).isMesh) {\r\n        return;\r\n      }\r\n      const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];\r\n      materials.forEach((material: any) => {\r\n        if (!material) {\r\n          return;\r\n        }\r\n        // Same texture is reused across the model's materials; only touch each one once.\r\n        ['map', 'normalMap', 'roughnessMap', 'metalnessMap', 'emissiveMap', 'aoMap'].forEach((slot) => {\r\n          const texture = material[slot];\r\n          if (texture && !seen.has(texture)) {\r\n            seen.add(texture);\r\n            texture.anisotropy = maxAnisotropy;\r\n            texture.generateMipmaps = false;\r\n            texture.minFilter = THREE.LinearFilter;\r\n            texture.needsUpdate = true;\r\n          }\r\n        });\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Loads an OBJ model with MTL.\r\n   * The heavy text-parsing step runs in a Web Worker when one has been registered via\r\n   * setObjParserWorker (see there for why the app, not this library, provides it); this keeps\r\n   * the main thread free while large architecture models (millions of vertices) are parsed.\r\n   * Falls back to parsing on the main thread otherwise.\r\n   */\r\n  loadObjModel(mtlUrl: string, objUrl: string, cameraPosition?: {x: number, y: number, z: number}, rotation?: {x: number, y: number, z: number}): void {\r\n    const mtlLoader = new MTLLoader();\r\n    const basePath = mtlUrl.substring(0, mtlUrl.lastIndexOf('/') + 1);\r\n    mtlLoader.setPath(basePath);\r\n    const mtlFileName = mtlUrl.substring(mtlUrl.lastIndexOf('/') + 1);\r\n\r\n    this.modelLoading$.next(true);\r\n\r\n    mtlLoader.load(mtlFileName, (materials) => {\r\n      materials.preload();\r\n\r\n      if (this.objParserWorker) {\r\n        this.requestObjParseInWorker(objUrl)\r\n          .then((meshes) => {\r\n            const group = new THREE.Group();\r\n            meshes.forEach((meshData) => {\r\n              group.add(this.meshFromParsedData(meshData, materials));\r\n            });\r\n            this.placeLoadedObjectInScene(group, cameraPosition, rotation);\r\n          })\r\n          .catch((error) => {\r\n            console.error('Error parsing OBJ model in worker:', error);\r\n          })\r\n          .finally(() => this.modelLoading$.next(false));\r\n        return;\r\n      }\r\n\r\n      const objLoader = new OBJLoader();\r\n      objLoader.setMaterials(materials);\r\n\r\n      objLoader.load(objUrl, (object) => {\r\n        this.placeLoadedObjectInScene(object, cameraPosition, rotation);\r\n        this.modelLoading$.next(false);\r\n      }, undefined, (error) => {\r\n        console.error('Error loading OBJ model:', error);\r\n        this.modelLoading$.next(false);\r\n      });\r\n    }, undefined, (error) => {\r\n      console.error('Error loading MTL file:', error);\r\n      this.modelLoading$.next(false);\r\n    });\r\n  }\r\n\r\n  /** Centers, scales and adds a loaded object to the scene, then frames the camera on it. */\r\n  private placeLoadedObjectInScene(object: THREE.Object3D, cameraPosition?: {x: number, y: number, z: number}, rotation?: {x: number, y: number, z: number}): void {\r\n    const box = new THREE.Box3().setFromObject(object);\r\n    const center = box.getCenter(new THREE.Vector3());\r\n    const size = box.getSize(new THREE.Vector3());\r\n    const maxDim = Math.max(size.x, size.y, size.z);\r\n    const scale = maxDim > 0 ? 10 / maxDim : 1;\r\n\r\n    // Two nested groups so tags can share the model's frame: `centered` carries the offset that\r\n    // moves the model's own origin to the scene origin, `group` carries the scale. A tag positioned\r\n    // with raw POI coordinates then lands in the same place the model's geometry does.\r\n    const group = new THREE.Group();\r\n    const centered = new THREE.Group();\r\n    centered.position.sub(center);\r\n\r\n    if (rotation) {\r\n      object.rotation.set(rotation.x, rotation.y, rotation.z);\r\n    }\r\n\r\n    this.modelRoot = object;\r\n    // Marks the model for the depth pick, which renders this layer alone - so tags and the ghost\r\n    // itself cannot end up being what the cursor reports as the surface under it.\r\n    object.traverse((child) => child.layers.enable(ThreeJsService.PICK_LAYER));\r\n    centered.add(object);\r\n    centered.add(this.tagGroup);\r\n    group.add(centered);\r\n    group.scale.setScalar(scale);\r\n\r\n    this.scene.add(group);\r\n\r\n    // Tags registered before the model finished loading were sized against the old scale.\r\n    this.tagSprites.forEach((sprite) => this.scaleTagForModel(sprite));\r\n\r\n    this.adjustClippingPlanes((size.length() / 2) * scale);\r\n\r\n    if (cameraPosition) {\r\n      this.camera.position.set(cameraPosition.x, cameraPosition.y, cameraPosition.z);\r\n    } else {\r\n      this.camera.position.set(0, 5, 15);\r\n    }\r\n    this.controls.target.set(0, 0, 0);\r\n    this.controls.update();\r\n  }\r\n\r\n  /**\r\n   * Keeps the drawing buffer and camera matched to the canvas as it is resized.\r\n   *\r\n   * renderer.setSize() writes explicit pixel width/height into the canvas's style, overriding the\r\n   * 100%/100% it starts with. Without this, the canvas keeps whatever size it had at startup: hiding\r\n   * the top menu grows the container, the canvas does not follow, and the strip that opens up shows\r\n   * the page behind it instead of the scene.\r\n   *\r\n   * The parent is observed rather than the canvas, because resizing the canvas is what this reacts\r\n   * to - watching the element we resize would retrigger the observer.\r\n   */\r\n  private observeCanvasResize(canvas: HTMLCanvasElement): void {\r\n    const container = canvas.parentElement;\r\n    if (!container || typeof ResizeObserver === 'undefined') {\r\n      return;\r\n    }\r\n\r\n    this.canvasResizeObserver = new ResizeObserver(() => {\r\n      const width = container.clientWidth;\r\n      const height = container.clientHeight;\r\n      if (width === 0 || height === 0) {\r\n        return;\r\n      }\r\n      this.camera.aspect = width / height;\r\n      this.camera.updateProjectionMatrix();\r\n      this.renderer.setSize(width, height);\r\n    });\r\n    this.canvasResizeObserver.observe(container);\r\n  }\r\n\r\n  /**\r\n   * Starts the alignment walkthrough: pick a tag, then click where it really is, three times.\r\n   *\r\n   * Existing tags are the correspondences - they already carry the stored coordinate, so the person\r\n   * only has to supply the matching spot on the model. No new records are written; nothing is\r\n   * applied until solveAlignmentFromPairs() succeeds.\r\n   */\r\n  startTagAlignment(): void {\r\n    this.aligning = true;\r\n    this.alignmentPairs = [];\r\n    this.alignmentSource = null;\r\n    if (this.renderer) {\r\n      this.renderer.domElement.style.cursor = 'crosshair';\r\n    }\r\n    this.alignmentProgress$.next({ pairs: 0, awaiting: 'tag' });\r\n  }\r\n\r\n  cancelTagAlignment(): void {\r\n    const wasAligning = this.aligning;\r\n    this.aligning = false;\r\n    this.alignmentPairs = [];\r\n    this.alignmentSource = null;\r\n    this.pendingPreviewEvent = null;\r\n    this.removePlacementPreview();\r\n    if (this.renderer) {\r\n      this.renderer.domElement.style.cursor = 'default';\r\n    }\r\n    this.alignmentProgress$.next({ pairs: 0, awaiting: null });\r\n    if (wasAligning) {\r\n      this.alignmentCancelled$.next();\r\n    }\r\n  }\r\n\r\n  isAligningTags(): boolean {\r\n    return this.aligning;\r\n  }\r\n\r\n  /**\r\n   * Whether the pointer should be showing the placement ghost.\r\n   *\r\n   * True while placing a tag, and while calibrating once a tag has been picked - that second click\r\n   * is the same question (\"where on the model?\") and deserves the same aiming aid. Not true for the\r\n   * first half of a pair, which is a click on a tag, not on the model.\r\n   */\r\n  private isPreviewingPlacement(): boolean {\r\n    return this.placingTag || (this.aligning && !!this.alignmentSource);\r\n  }\r\n\r\n  /** Whether a tag is currently registered for this element. */\r\n  hasTag(elementId: string): boolean {\r\n    return this.tagSprites.has(elementId);\r\n  }\r\n\r\n  /**\r\n   * Solves and applies the alignment collected so far, returning it so the caller can persist it.\r\n   *\r\n   * Returns null when the three tags turn out to be collinear, in which case nothing is applied and\r\n   * the walkthrough stays open for the person to pick a better third point.\r\n   */\r\n  solveAlignmentFromPairs(): ThreeJsAlignment | null {\r\n    const alignment = solveThreeJsAlignment(this.alignmentPairs);\r\n    if (!alignment) {\r\n      return null;\r\n    }\r\n    this.setTagAlignment(alignment);\r\n    this.aligning = false;\r\n    this.pendingPreviewEvent = null;\r\n    this.removePlacementPreview();\r\n    this.renderer.domElement.style.cursor = 'default';\r\n    this.alignmentProgress$.next({ pairs: this.alignmentPairs.length, awaiting: null });\r\n    return alignment;\r\n  }\r\n\r\n  /** Handles a click while the alignment walkthrough is running. */\r\n  private handleAlignmentClick(event: MouseEvent): void {\r\n    if (!this.alignmentSource) {\r\n      // First half of a pair: which tag are we talking about?\r\n      const hit = this.raycaster.intersectObjects(this.tagGroup.children, false)[0];\r\n      if (!hit) {\r\n        return;\r\n      }\r\n      // The sprite's own position is the stored coordinate, untouched by any alignment already\r\n      // applied - that transform lives on the group, not on the sprite.\r\n      const stored = hit.object.position;\r\n      this.alignmentSource = { x: stored.x, y: stored.y, z: stored.z };\r\n      this.alignmentProgress$.next({\r\n        pairs: this.alignmentPairs.length,\r\n        awaiting: 'point',\r\n        tagId: hit.object.name,\r\n      });\r\n      return;\r\n    }\r\n\r\n    // Second half: where that tag actually belongs on the model.\r\n    const target = this.pickAlignmentTarget(event);\r\n    if (!target) {\r\n      return;\r\n    }\r\n    this.alignmentPairs.push({ source: this.alignmentSource, target });\r\n    this.alignmentSource = null;\r\n    // The ghost belongs to the click that just happened; the next half is a click on a tag.\r\n    this.pendingPreviewEvent = null;\r\n    this.removePlacementPreview();\r\n    this.alignmentProgress$.next({\r\n      pairs: this.alignmentPairs.length,\r\n      awaiting: this.alignmentPairs.length >= 3 ? null : 'tag',\r\n    });\r\n  }\r\n\r\n  /** Arms tag placement: the next click on the model drops a tag instead of being ignored. */\r\n  startTagPlacement(poiType: PoiType | null = null): void {\r\n    this.placingTag = true;\r\n    this.placementPoiType = poiType;\r\n    this.pendingTagPlacement = null;\r\n    if (this.renderer) {\r\n      this.renderer.domElement.style.cursor = 'crosshair';\r\n    }\r\n  }\r\n\r\n  /** Leaves placement mode without placing anything. */\r\n  cancelTagPlacement(): void {\r\n    this.placingTag = false;\r\n    this.pendingTagPlacement = null;\r\n    this.pendingPreviewEvent = null;\r\n    this.removePlacementPreview();\r\n    if (this.renderer) {\r\n      this.renderer.domElement.style.cursor = 'default';\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Shows a translucent tag under the cursor while placing, so the spot is visible before commiting.\r\n   *\r\n   * Matterport does this with a tag that follows the pointer; the equivalent here is a preview\r\n   * sprite that gets removed the moment the real tag takes its place.\r\n   */\r\n  private updatePlacementPreview(event: MouseEvent): void {\r\n    const position = this.pickPointOnGpu(event);\r\n    if (!position) {\r\n      this.removePlacementPreview();\r\n      this.renderer.domElement.style.cursor = 'not-allowed';\r\n      return;\r\n    }\r\n\r\n    this.renderer.domElement.style.cursor = 'crosshair';\r\n    if (!this.placementPreview) {\r\n      this.placementPreview = new THREE.Sprite(\r\n        new THREE.SpriteMaterial({\r\n          map: this.createTagTexture('#9E9E9E'),\r\n          depthTest: false,\r\n          transparent: true,\r\n          opacity: 0.6,\r\n        })\r\n      );\r\n      this.placementPreview.renderOrder = 999;\r\n      this.tagGroup.add(this.placementPreview);\r\n      this.scaleTagForModel(this.placementPreview);\r\n    }\r\n    this.placementPreview.position.copy(position);\r\n  }\r\n\r\n  /**\r\n   * The point under the cursor, read from the depth buffer instead of raycast, in tag space.\r\n   *\r\n   * A raycast walks every triangle of the mesh it hits: on a captured model that is millions of\r\n   * them, tens of milliseconds, every time the pointer moves. Coalescing to one per frame did not\r\n   * help, because the cost is the pick itself - it simply became one slow frame instead of several.\r\n   *\r\n   * Rendering the model's depth into a single pixel under the cursor answers the same question on\r\n   * the GPU in constant time, whatever the model's size. The camera's view offset is what narrows\r\n   * the whole image down to that one pixel, so the value read back is the depth the cursor is over.\r\n   *\r\n   * Used for the ghost only. The click that actually places a tag still raycasts: it is one pick,\r\n   * its cost does not matter, and it yields the surface normal, which depth alone cannot give.\r\n   */\r\n  private pickPointOnGpu(event: MouseEvent): THREE.Vector3 | null {\r\n    if (!this.modelRoot || !this.renderer || !this.camera) {\r\n      return null;\r\n    }\r\n\r\n    if (!this.pickTarget) {\r\n      this.pickTarget = new THREE.WebGLRenderTarget(1, 1);\r\n      this.pickCamera = new THREE.PerspectiveCamera();\r\n      this.pickCamera.layers.set(ThreeJsService.PICK_LAYER);\r\n      this.pickDepthMaterial = new THREE.MeshDepthMaterial({\r\n        depthPacking: THREE.RGBADepthPacking,\r\n      });\r\n    }\r\n\r\n    const rect = this.renderer.domElement.getBoundingClientRect();\r\n    const x = event.clientX - rect.left;\r\n    const y = event.clientY - rect.top;\r\n    if (x < 0 || y < 0 || x > rect.width || y > rect.height) {\r\n      return null;\r\n    }\r\n\r\n    this.pickCamera.copy(this.camera);\r\n    this.pickCamera.layers.set(ThreeJsService.PICK_LAYER);\r\n    // Renders the one pixel the cursor is over as if it were the whole image - offset by half a\r\n    // pixel so the cursor sits at that pixel's centre, which is where NDC (0, 0) lands.\r\n    this.pickCamera.setViewOffset(rect.width, rect.height, x - 0.5, y - 0.5, 1, 1);\r\n\r\n    // Where the model is not, the pixel must read as \"nothing\", so it is cleared to white - a value\r\n    // no real depth packs to. Two things would otherwise paint over that: the default black clear,\r\n    // which decodes as depth 0 (a hit against the lens), and the scene background, which three.js\r\n    // draws in place of the clear colour whenever one is set.\r\n    const previousClearColor = this.renderer.getClearColor(new THREE.Color());\r\n    const previousClearAlpha = this.renderer.getClearAlpha();\r\n    const previousTarget = this.renderer.getRenderTarget();\r\n    const previousBackground = this.scene.background;\r\n\r\n    this.scene.background = null;\r\n    this.scene.overrideMaterial = this.pickDepthMaterial;\r\n    this.renderer.setClearColor(0xffffff, 1);\r\n    this.renderer.setRenderTarget(this.pickTarget);\r\n    this.renderer.clear();\r\n    this.renderer.render(this.scene, this.pickCamera);\r\n\r\n    this.renderer.readRenderTargetPixels(this.pickTarget, 0, 0, 1, 1, this.pickPixel);\r\n\r\n    this.renderer.setRenderTarget(previousTarget);\r\n    this.renderer.setClearColor(previousClearColor, previousClearAlpha);\r\n    this.scene.overrideMaterial = null;\r\n    this.scene.background = previousBackground;\r\n\r\n    const [r, g, b, a] = this.pickPixel;\r\n    if (r === 255 && g === 255 && b === 255 && a === 255) {\r\n      return null;\r\n    }\r\n\r\n    // The inverse of three's packDepthToRGBA, which stores the value itself in alpha and ever finer\r\n    // fractions of it in blue, green and red - alpha is the most significant byte, not red. Read the\r\n    // other way round, the result is mostly the low-order noise, often near zero, which unprojects\r\n    // onto the near plane: a ghost pressed against the lens, filling the whole screen.\r\n    const downscale = 255 / 256;\r\n    const depth =\r\n      (r / 255) * downscale / (256 * 256 * 256) +\r\n      (g / 255) * downscale / (256 * 256) +\r\n      (b / 255) * downscale / 256 +\r\n      (a / 255) * downscale;\r\n\r\n    // NDC x and y are zero because the pixel read is the centre of that one-pixel image - which only\r\n    // holds while the view offset is in effect. Clearing it first would unproject through the full\r\n    // view instead, landing the point on the ray through the middle of the screen. The offset is\r\n    // simply replaced by the next pick, so it is never cleared.\r\n    const world = new THREE.Vector3(0, 0, depth * 2 - 1).unproject(this.pickCamera);\r\n    this.tagGroup.updateWorldMatrix(true, false);\r\n    return this.tagGroup.worldToLocal(world);\r\n  }\r\n\r\n  private removePlacementPreview(): void {\r\n    if (!this.placementPreview) {\r\n      return;\r\n    }\r\n    this.tagGroup.remove(this.placementPreview);\r\n    this.placementPreview.material.map?.dispose();\r\n    this.placementPreview.material.dispose();\r\n    this.placementPreview = undefined;\r\n  }\r\n\r\n  /** Shows or hides one tag, leaving it registered so it can be brought back without reloading. */\r\n  setTagVisibility(elementId: string, visible: boolean): void {\r\n    const sprite = this.tagSprites.get(elementId);\r\n    if (sprite) {\r\n      sprite.visible = visible;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Shows only tags of the given types, hiding the rest.\r\n   *\r\n   * Passing null shows everything - the \"no filter\" state, distinct from an empty array, which is a\r\n   * filter that happens to match nothing.\r\n   */\r\n  setVisibleTagTypes(types: PoiType[] | null): void {\r\n    this.tagSprites.forEach((sprite) => {\r\n      sprite.visible = types === null || types.includes(sprite.userData.poiType);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Moves the camera to look at a tag, mirroring Matterport's goToTag.\r\n   *\r\n   * Animated rather than teleported: jumping the camera loses the viewer's sense of where they were\r\n   * relative to the model. The approach distance follows the model's size so it frames sensibly\r\n   * whatever the units are.\r\n   */\r\n  goToTag(elementId: string): void {\r\n    const sprite = this.tagSprites.get(elementId);\r\n    if (!sprite || !this.camera) {\r\n      return;\r\n    }\r\n\r\n    const target = sprite.getWorldPosition(new THREE.Vector3());\r\n    const distance = this.modelRoot\r\n      ? new THREE.Box3().setFromObject(this.modelRoot).getSize(new THREE.Vector3()).length() * 0.15\r\n      : 5;\r\n\r\n    // Approach along the current viewing direction, so the camera closes in rather than swinging\r\n    // around to an arbitrary side.\r\n    const direction = this.camera.position.clone().sub(this.controls.target).normalize();\r\n    this.cameraTween = {\r\n      fromPosition: this.camera.position.clone(),\r\n      toPosition: target.clone().add(direction.multiplyScalar(distance)),\r\n      fromTarget: this.controls.target.clone(),\r\n      toTarget: target,\r\n      startedAt: performance.now(),\r\n      durationMs: 600,\r\n    };\r\n  }\r\n\r\n  /** Advances the camera animation started by goToTag, if one is running. */\r\n  private stepCameraTween(): void {\r\n    if (!this.cameraTween) {\r\n      return;\r\n    }\r\n    const { fromPosition, toPosition, fromTarget, toTarget, startedAt, durationMs } = this.cameraTween;\r\n    const linear = Math.min((performance.now() - startedAt) / durationMs, 1);\r\n    // Ease out, so the move settles instead of stopping dead.\r\n    const t = 1 - Math.pow(1 - linear, 3);\r\n\r\n    this.camera.position.lerpVectors(fromPosition, toPosition, t);\r\n    this.controls.target.lerpVectors(fromTarget, toTarget, t);\r\n\r\n    if (linear >= 1) {\r\n      this.cameraTween = null;\r\n    }\r\n  }\r\n\r\n  isPlacingTag(): boolean {\r\n    return this.placingTag;\r\n  }\r\n\r\n  /** The spot picked by the last placement, for whoever commits it to a POI. */\r\n  getPendingTagPlacement(): ThreeJsTagPlacement | null {\r\n    return this.pendingTagPlacement;\r\n  }\r\n\r\n  /**\r\n   * Raycasts a click against the model's geometry and returns the hit, in world space.\r\n   *\r\n   * Returns null when the click missed, which is a normal outcome - the user clicked the sky - and\r\n   * leaves whatever mode is armed still armed, so they can simply try again.\r\n   */\r\n  private raycastModel(event: MouseEvent): THREE.Intersection | null {\r\n    if (!this.modelRoot) {\r\n      return null;\r\n    }\r\n\r\n    const rect = this.renderer.domElement.getBoundingClientRect();\r\n    this.mouse.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;\r\n    this.mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;\r\n    this.raycaster.setFromCamera(this.mouse, this.camera);\r\n\r\n    return this.raycaster.intersectObject(this.modelRoot, true)[0] ?? null;\r\n  }\r\n\r\n  /**\r\n   * Turns a click into a point on the model, in the frame tag coordinates are persisted in.\r\n   *\r\n   * That frame is the tag group's, not the model's. A stored coordinate is read back as a sprite\r\n   * position inside that group, so a coordinate captured in any other frame comes back displaced by\r\n   * exactly however far the alignment moves the group. The two frames agree only while the\r\n   * alignment is identity, which is why this stayed invisible until a model was calibrated.\r\n   */\r\n  private pickPlacementOnModel(event: MouseEvent): ThreeJsTagPlacement | null {\r\n    const hit = this.raycastModel(event);\r\n    if (!hit) {\r\n      return null;\r\n    }\r\n\r\n    this.tagGroup.updateWorldMatrix(true, false);\r\n    const position = this.tagGroup.worldToLocal(hit.point.clone());\r\n\r\n    // A face normal is in the geometry's local space already, but the mesh it belongs to may sit\r\n    // under transforms of its own, so take it out through those and back into the tag frame, so it\r\n    // describes the same orientation the position does.\r\n    let normal = new THREE.Vector3(0, 1, 0);\r\n    if (hit.face) {\r\n      normal = hit.face.normal\r\n        .clone()\r\n        .transformDirection(hit.object.matrixWorld)\r\n        .transformDirection(new THREE.Matrix4().copy(this.tagGroup.matrixWorld).invert())\r\n        .normalize();\r\n    }\r\n\r\n    return {\r\n      position: { x: position.x, y: position.y, z: position.z },\r\n      normal: { x: normal.x, y: normal.y, z: normal.z },\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Where the user says a tag really belongs, in the space the solved alignment maps onto.\r\n   *\r\n   * setTagAlignment writes the solution to the tag group's own transform, which is expressed\r\n   * relative to its parent - so the target has to be in the parent's frame. Measuring it in the\r\n   * group's own frame instead would fold the current alignment into the answer, making each\r\n   * calibration depend on the one before it.\r\n   */\r\n  private pickAlignmentTarget(event: MouseEvent): { x: number; y: number; z: number } | null {\r\n    const hit = this.raycastModel(event);\r\n    if (!hit) {\r\n      return null;\r\n    }\r\n    const frame = this.tagGroup.parent ?? this.scene;\r\n    frame.updateWorldMatrix(true, false);\r\n    const point = frame.worldToLocal(hit.point.clone());\r\n    return { x: point.x, y: point.y, z: point.z };\r\n  }\r\n\r\n  /**\r\n   * Sets the transform mapping captured tag coordinates onto this model's space.\r\n   *\r\n   * Every tag comes from the same source space, so this is one transform on the group rather than\r\n   * per-tag maths - which also means it applies retroactively to tags already placed, and can be\r\n   * adjusted live while someone dials the numbers in.\r\n   *\r\n   * Passing null resets to identity, i.e. tag coordinates are already in model space.\r\n   */\r\n  setTagAlignment(alignment: ThreeJsAlignment | null): void {\r\n    const { translation, rotation, scale } = alignment ?? {};\r\n    this.tagGroup.position.set(translation?.x ?? 0, translation?.y ?? 0, translation?.z ?? 0);\r\n    this.tagGroup.rotation.set(rotation?.x ?? 0, rotation?.y ?? 0, rotation?.z ?? 0);\r\n    this.tagGroup.scale.setScalar(scale ?? 1);\r\n\r\n    // Tag size is derived from the world scale it inherits, which this call just changed.\r\n    this.tagSprites.forEach((sprite) => this.scaleTagForModel(sprite));\r\n  }\r\n\r\n  /**\r\n   * Adds a tag, or moves/restyles the one already registered for this element.\r\n   *\r\n   * Upsert rather than a declarative \"here is the full list\" call, because tags arrive per type\r\n   * (equipment, then tickets, then measurements...) from separate subscriptions - replacing the set\r\n   * on each of those would wipe the types that came before.\r\n   */\r\n  upsertTag(tag: ThreeJsTag): void {\r\n    const existing = this.tagSprites.get(tag.id);\r\n    if (existing) {\r\n      existing.position.set(tag.position.x, tag.position.y, tag.position.z);\r\n      existing.userData.poiType = tag.poiType ?? existing.userData.poiType;\r\n      existing.userData.label = tag.label ?? existing.userData.label;\r\n      return;\r\n    }\r\n\r\n    const sprite = new THREE.Sprite(\r\n      new THREE.SpriteMaterial({\r\n        map: this.createTagTexture(tag.color),\r\n        // Tags read as UI rather than geometry, so they stay visible through the model instead of\r\n        // being occluded by whatever wall happens to be between them and the camera.\r\n        depthTest: false,\r\n        transparent: true,\r\n      })\r\n    );\r\n    sprite.name = tag.id;\r\n    sprite.userData.poiType = tag.poiType ?? null;\r\n    sprite.userData.label = tag.label ?? null;\r\n    sprite.position.set(tag.position.x, tag.position.y, tag.position.z);\r\n    sprite.renderOrder = 999;\r\n    this.scaleTagForModel(sprite);\r\n\r\n    this.tagGroup.add(sprite);\r\n    this.tagSprites.set(tag.id, sprite);\r\n\r\n    if (tag.iconUrl) {\r\n      this.applyTagIcon(sprite, tag.iconUrl);\r\n    }\r\n  }\r\n\r\n  /** Removes the tag registered for an element, if there is one. */\r\n  removeTag(elementId: string): void {\r\n    const sprite = this.tagSprites.get(elementId);\r\n    if (!sprite) {\r\n      return;\r\n    }\r\n    this.tagGroup.remove(sprite);\r\n    sprite.material.map?.dispose();\r\n    sprite.material.dispose();\r\n    this.tagSprites.delete(elementId);\r\n  }\r\n\r\n  /** Removes every tag from the scene. */\r\n  clearTags(): void {\r\n    [...this.tagSprites.keys()].forEach((id) => this.removeTag(id));\r\n  }\r\n\r\n  /** Loads an icon into an existing tag, leaving the fallback disc in place if it fails. */\r\n  private applyTagIcon(sprite: THREE.Sprite, iconUrl: string): void {\r\n    new THREE.TextureLoader().load(\r\n      iconUrl,\r\n      (texture) => {\r\n        sprite.material.map?.dispose();\r\n        sprite.material.map = texture;\r\n        sprite.material.needsUpdate = true;\r\n      },\r\n      undefined,\r\n      () => console.warn(`ThreeJsService: could not load tag icon \"${iconUrl}\", keeping the default marker.`)\r\n    );\r\n  }\r\n\r\n  /** Draws the default tag marker: a filled disc with a white ring, so it reads on any background. */\r\n  private createTagTexture(color = '#1E88E5'): THREE.CanvasTexture {\r\n    const size = 128;\r\n    const canvas = document.createElement('canvas');\r\n    canvas.width = size;\r\n    canvas.height = size;\r\n    const context = canvas.getContext('2d');\r\n\r\n    context.beginPath();\r\n    context.arc(size / 2, size / 2, size / 2 - 8, 0, Math.PI * 2);\r\n    context.fillStyle = color;\r\n    context.fill();\r\n    context.lineWidth = 8;\r\n    context.strokeStyle = '#FFFFFF';\r\n    context.stroke();\r\n\r\n    return new THREE.CanvasTexture(canvas);\r\n  }\r\n\r\n  /**\r\n   * Sizes a tag relative to the model.\r\n   *\r\n   * A sprite inherits the model's scale and the alignment's, so a fixed size would come out tiny on\r\n   * a large model and huge on a small one. Dividing by the group's world scale keeps tags the same\r\n   * size on screen whatever the model's units are.\r\n   */\r\n  private scaleTagForModel(sprite: THREE.Sprite): void {\r\n    const worldScale = this.tagGroup.getWorldScale(new THREE.Vector3()).x || 1;\r\n    const size = 0.4 / worldScale;\r\n    sprite.scale.set(size, size, 1);\r\n  }\r\n\r\n  /**\r\n   * Adds secondary interactive objects (e.g., POIs, sensors) to the scene.\r\n   */\r\n  updateObjsToScene(objsAdded: ObjAdded[]): void {\r\n    const existingIds = this.clickableObjects.map((obj) => obj.name);\r\n    const objLoader = new OBJLoader();\r\n\r\n    // delete objects that are not in the provided array\r\n    this.clickableObjects.forEach((obj) => {\r\n      if (!objsAdded.find((objData) => objData.id === obj.name)) {\r\n        this.scene.remove(obj);\r\n        this.clickableObjects = this.clickableObjects.filter(\r\n          (object) => object.name !== obj.name\r\n        );\r\n      }\r\n    });\r\n\r\n    objsAdded.forEach((objectData: ObjAdded) => {\r\n      if (!existingIds.includes(objectData.id)) {\r\n        objLoader.load(objectData.file, (newObject) => {\r\n          newObject.name = objectData.id;\r\n\r\n          newObject.traverse((child) => {\r\n            if ((child as THREE.Mesh).isMesh) {\r\n              const mesh = child as THREE.Mesh;\r\n              if (mesh.material instanceof THREE.Material) {\r\n                mesh.material.transparent = true;\r\n                mesh.material.opacity = 0.8;\r\n              }\r\n            }\r\n          });\r\n\r\n          // set object position and rotation\r\n          newObject.position.set(\r\n            objectData.position.x,\r\n            objectData.position.y,\r\n            objectData.position.z\r\n          );\r\n          \r\n          // The JSON configuration has rotation already in radians (e.g. 3.1415...)\r\n          newObject.rotation.set(\r\n            objectData.rotation.x,\r\n            objectData.rotation.y,\r\n            objectData.rotation.z\r\n          );\r\n\r\n          newObject.scale.set(objectData.scale.x, objectData.scale.y, objectData.scale.z);\r\n\r\n          this.scene.add(newObject);\r\n          this.clickableObjects.push(newObject);\r\n        });\r\n      }\r\n    });\r\n  }\r\n\r\n  private onMouseMove(event: MouseEvent): void {\r\n    if (!this.isDraggingCamera) {\r\n      const rect = this.renderer.domElement.getBoundingClientRect();\r\n      this.mouse.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;\r\n      this.mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;\r\n\r\n      this.raycaster.setFromCamera(this.mouse, this.camera);\r\n\r\n      // While the ghost is up it follows the pointer and nothing else should react to it. The move\r\n      // is only recorded here: pointer events fire far more often than frames, and picking a point\r\n      // costs a raycast against the whole model, so doing it per event is what made the ghost trail\r\n      // behind the cursor. The render loop picks up the latest position, once, per frame.\r\n      if (this.isPreviewingPlacement()) {\r\n        this.pendingPreviewEvent = event;\r\n        return;\r\n      }\r\n\r\n      // Not previewing any more (a pair was just completed, say): drop a ghost left over from it.\r\n      this.removePlacementPreview();\r\n\r\n      // Tags first: they draw on top of the model, so they have to answer the pointer first too.\r\n      const hoveredTag = this.raycaster\r\n        .intersectObjects(this.tagGroup.children, false)\r\n        .find((hit) => hit.object.visible)?.object;\r\n      if (hoveredTag) {\r\n        this.renderer.domElement.style.cursor = 'pointer';\r\n        this.objectHovered$.next(null);\r\n        const label = hoveredTag.userData.label;\r\n        this.tagHovered$.next(label ? { label, event } : null);\r\n        return;\r\n      }\r\n      this.tagHovered$.next(null);\r\n\r\n      const intersects = this.raycaster.intersectObjects(this.clickableObjects, true);\r\n\r\n      if (intersects.length > 0) {\r\n        this.renderer.domElement.style.cursor = 'pointer';\r\n        const intersectedObjectId = intersects[0].object?.parent?.name;\r\n        if (intersectedObjectId) {\r\n            this.objectHovered$.next({ id: intersectedObjectId, event });\r\n        }\r\n      } else {\r\n        this.renderer.domElement.style.cursor = 'default';\r\n        this.objectHovered$.next(null);\r\n      }\r\n    } else {\r\n      this.renderer.domElement.style.cursor = 'grabbing';\r\n      this.objectHovered$.next(null);\r\n    }\r\n  }\r\n\r\n  private onMouseClick(event: MouseEvent): void {\r\n    if (!this.isDraggingCamera) {\r\n      const rect = this.renderer.domElement.getBoundingClientRect();\r\n      this.mouse.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;\r\n      this.mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;\r\n\r\n      // Alignment and placement both take the click before anything can be opened by it.\r\n      if (this.aligning) {\r\n        this.raycaster.setFromCamera(this.mouse, this.camera);\r\n        this.handleAlignmentClick(event);\r\n        return;\r\n      }\r\n\r\n      // Placement wins over everything: while armed, a click means \"put it here\", not \"open that\".\r\n      if (this.placingTag) {\r\n        const placement = this.pickPlacementOnModel(event);\r\n        if (placement) {\r\n          placement.poiType = this.placementPoiType;\r\n          this.pendingTagPlacement = placement;\r\n          this.placingTag = false;\r\n          this.removePlacementPreview();\r\n          this.renderer.domElement.style.cursor = 'default';\r\n          this.tagPlaced$.next(placement);\r\n        }\r\n        return;\r\n      }\r\n\r\n      this.raycaster.setFromCamera(this.mouse, this.camera);\r\n\r\n      // Same precedence as hover: a tag drawn over the model claims the click.\r\n      const tagHits = this.raycaster.intersectObjects(this.tagGroup.children, false)\r\n        .filter((hit) => hit.object.visible);\r\n      if (tagHits.length > 0) {\r\n        const tag = tagHits[0].object;\r\n        this.tagClicked$.next({ elementId: tag.name, poiType: tag.userData.poiType ?? null });\r\n        return;\r\n      }\r\n\r\n      const intersects = this.raycaster.intersectObjects(this.clickableObjects, true);\r\n\r\n      if (intersects.length > 0) {\r\n        const clickedObject = intersects[0].object;\r\n        const id = clickedObject?.parent?.name;\r\n        if (id) {\r\n            this.objectClicked$.next(id);\r\n        }\r\n      } else {\r\n        this.objectClicked$.next(null);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Escape cancels whatever the pointer is currently committed to.\r\n   *\r\n   * Emits through the same subjects the explicit Cancel buttons use, so the UI driving them follows\r\n   * along instead of being left showing a mode that is no longer armed.\r\n   */\r\n  private onKeyDown = (event: KeyboardEvent): void => {\r\n    if (event.key !== 'Escape') {\r\n      return;\r\n    }\r\n    if (this.placingTag) {\r\n      // Nothing outside the scene tracks placement, so clearing it here is the whole of it.\r\n      this.cancelTagPlacement();\r\n      return;\r\n    }\r\n    if (this.aligning) {\r\n      this.cancelTagAlignment();\r\n    }\r\n  }\r\n\r\n  private animate = (): void => {\r\n    this.animationFrameId = requestAnimationFrame(this.animate);\r\n    this.stepCameraTween();\r\n    this.controls.update();\r\n\r\n    // One pick per frame, against the pointer's latest position - see onMouseMove.\r\n    if (this.pendingPreviewEvent) {\r\n      const event = this.pendingPreviewEvent;\r\n      this.pendingPreviewEvent = null;\r\n      this.updatePlacementPreview(event);\r\n    }\r\n\r\n    this.renderer.render(this.scene, this.camera);\r\n  }\r\n\r\n  destroy(): void {\r\n    if (this.animationFrameId) {\r\n      cancelAnimationFrame(this.animationFrameId);\r\n    }\r\n    window.removeEventListener('keydown', this.onKeyDown);\r\n    if (this.canvasResizeObserver) {\r\n      this.canvasResizeObserver.disconnect();\r\n      this.canvasResizeObserver = undefined;\r\n    }\r\n    this.discardCurrentLoad();\r\n    this.clearTags();\r\n    if (this.renderer) {\r\n      this.renderer.dispose();\r\n    }\r\n    if (this.controls) {\r\n      this.controls.dispose();\r\n    }\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"threejs.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-smarterplan-core/src/lib/services/threejs.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\r\nimport * as THREE from 'three';\r\nimport { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';\r\nimport { OBJLoader } from 'three/examples/jsm/loaders/OBJLoader';\r\nimport { MTLLoader } from 'three/examples/jsm/loaders/MTLLoader';\r\nimport { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader';\r\nimport { KTX2Loader } from 'three/examples/jsm/loaders/KTX2Loader';\r\nimport { MeshoptDecoder } from 'three/examples/jsm/libs/meshopt_decoder.module.js';\r\nimport { Line2 } from 'three/examples/jsm/lines/Line2';\r\nimport { LineGeometry } from 'three/examples/jsm/lines/LineGeometry';\r\nimport { LineMaterial } from 'three/examples/jsm/lines/LineMaterial';\r\nimport { Subject } from 'rxjs';\r\nimport { ThreeJsAlignment, ThreeJsModelUp } from '../helpers.service';\r\nimport { PoiType } from '../types.service';\r\n\r\n/**\r\n * A tag to draw in the Three.js scene, mirroring a Mattertag.\r\n *\r\n * Positions are in the model's own coordinate space - the same numbers stored in POI.coordinate -\r\n * not scene space. The service reparents tags under the model so they inherit the centering and\r\n * scaling applied at load, which means callers never deal with that transform.\r\n */\r\nexport interface ThreeJsTag {\r\n  /** The tagged element's id (POI.elementID), used to update or remove the tag later. */\r\n  id: string;\r\n  position: { x: number; y: number; z: number };\r\n  /** Drives both the click route and type filtering, so it travels with the tag. */\r\n  poiType?: PoiType | null;\r\n  /** Shown on hover. A marker with no identity is just a dot on a wall. */\r\n  label?: string | null;\r\n  /** The Three.js capture this tag was placed in, when it was placed in one. */\r\n  originCaptureID?: string | null;\r\n  /**\r\n   * 'model' when the position is in the model's own coordinates rather than the space tags share:\r\n   * a tag placed in a model before it was calibrated. Only meaningful in the model it was placed in.\r\n   */\r\n  frame?: 'model' | null;\r\n  /** Icon drawn on the tag. Falls back to a plain disc when absent or it fails to load. */\r\n  iconUrl?: string | null;\r\n  /** Tint for the fallback disc, as a CSS colour. */\r\n  color?: string;\r\n}\r\n\r\n/** What a click on a tag reports: enough to route to the element's detail page. */\r\nexport interface ThreeJsTagClick {\r\n  elementId: string;\r\n  poiType: PoiType | null;\r\n}\r\n\r\n/**\r\n * A spot picked on the model for a new tag.\r\n *\r\n * Both vectors are in the model's own coordinate space, which is what POI.coordinate stores. Scene\r\n * coordinates deliberately never leave this service: the model is scaled to a fixed size on load, so\r\n * a scene-space position would silently mean somewhere else the moment the .glb is re-exported.\r\n */\r\nexport interface ThreeJsTagPlacement {\r\n  position: { x: number; y: number; z: number };\r\n  /** Surface normal at the picked point - Matterport stores the same thing in POI.metadata. */\r\n  normal: { x: number; y: number; z: number };\r\n  /** What the placement was armed for, so the caller knows which creation form to open. */\r\n  poiType?: PoiType | null;\r\n}\r\n\r\n/** One tag seen in both spaces: where it is stored, and where it really sits on the model. */\r\n/** A distance measured on the model: its points, each segment's length, and a picture of it. */\r\nexport interface ThreeJsMeasurement {\r\n  /** In the frame tag coordinates are stored in, so the last one can be saved as the POI. */\r\n  points: { x: number; y: number; z: number }[];\r\n  /** Metres between consecutive points, rounded like Matterport's measurements are. */\r\n  distances: number[];\r\n  /** JPEG data URI of the scene with the measurement drawn on it. */\r\n  screenshot: string;\r\n}\r\n\r\n/**\r\n * A tag placed in this model whose stored coordinates had to change for it to stay where it is,\r\n * because the calibration it is drawn under changed.\r\n */\r\nexport interface ThreeJsRebasedTag {\r\n  id: string;\r\n  /** Its coordinates in the space tags share, under the new calibration. */\r\n  position: { x: number; y: number; z: number };\r\n  /** Turns a direction stored with the tag - its surface normal - the same way. */\r\n  rotateDirection: (direction: { x: number; y: number; z: number }) => { x: number; y: number; z: number };\r\n}\r\n\r\nexport interface ThreeJsAlignmentPair {\r\n  /** The tag the pair was made from, when it came from one. */\r\n  tagId?: string;\r\n  source: { x: number; y: number; z: number };\r\n  target: { x: number; y: number; z: number };\r\n}\r\n\r\n/**\r\n * Builds an orthonormal frame from three points, or null when they are (nearly) collinear.\r\n *\r\n * Three points define a plane, and a plane plus an origin defines an orientation. Collinear points\r\n * do not: they leave the rotation about their common line undetermined, which is why the caller has\r\n * to reject them rather than produce a confident wrong answer.\r\n */\r\nfunction frameFromPoints(a: THREE.Vector3, b: THREE.Vector3, c: THREE.Vector3): THREE.Matrix4 | null {\r\n  const e1 = b.clone().sub(a);\r\n  if (e1.lengthSq() < 1e-12) {\r\n    return null;\r\n  }\r\n  e1.normalize();\r\n\r\n  const toC = c.clone().sub(a);\r\n  const e2 = toC.clone().sub(e1.clone().multiplyScalar(toC.dot(e1)));\r\n  if (e2.lengthSq() < 1e-12) {\r\n    return null;\r\n  }\r\n  e2.normalize();\r\n\r\n  return new THREE.Matrix4().makeBasis(e1, e2, e1.clone().cross(e2));\r\n}\r\n\r\n/**\r\n * Solves the transform that maps stored tag coordinates onto the loaded model, from as many matched\r\n * tags as there are - up to three.\r\n *\r\n * Three pairs pin down everything: position, orientation and scale. A model that shares only a\r\n * corner with the tags' space may not have three tags to offer, so fewer are accepted, each\r\n * settling what it can and assuming the rest:\r\n *\r\n *  - Two pairs: position, heading and scale. The one thing two points cannot say is how the model\r\n *    is tilted, so both spaces are taken to agree on which way is up.\r\n *  - One pair: position only. Heading and scale are taken to match already.\r\n *\r\n * `targetUp` is the model's vertical axis, which the tags' own vertical (+Y) is matched to in those\r\n * two cases. Returns null when the points cannot answer the question asked of them - collinear for\r\n * three, one above the other for two - because a wrong calibration applied silently is worse than\r\n * none.\r\n */\r\nexport function solveThreeJsAlignment(\r\n  pairs: ThreeJsAlignmentPair[],\r\n  targetUp: { x: number; y: number; z: number } = { x: 0, y: 1, z: 0 },\r\n): ThreeJsAlignment | null {\r\n  if (!pairs || pairs.length === 0) {\r\n    return null;\r\n  }\r\n  if (pairs.length < 3) {\r\n    return solveReducedAlignment(pairs, new THREE.Vector3(targetUp.x, targetUp.y, targetUp.z).normalize());\r\n  }\r\n\r\n  const sources = pairs.slice(0, 3).map((pair) => new THREE.Vector3(pair.source.x, pair.source.y, pair.source.z));\r\n  const targets = pairs.slice(0, 3).map((pair) => new THREE.Vector3(pair.target.x, pair.target.y, pair.target.z));\r\n\r\n  const sourceFrame = frameFromPoints(sources[0], sources[1], sources[2]);\r\n  const targetFrame = frameFromPoints(targets[0], targets[1], targets[2]);\r\n  if (!sourceFrame || !targetFrame) {\r\n    return null;\r\n  }\r\n\r\n  // A rotation's inverse is its transpose, so this is the rotation carrying one frame onto the other.\r\n  const rotation = targetFrame.multiply(sourceFrame.clone().transpose());\r\n\r\n  // Scale from how far apart the points are in each space, averaged over the three edges so a single\r\n  // sloppy click does not set it on its own.\r\n  const edges = [[0, 1], [1, 2], [0, 2]];\r\n  let ratioSum = 0;\r\n  let ratioCount = 0;\r\n  for (const [i, j] of edges) {\r\n    const sourceLength = sources[i].distanceTo(sources[j]);\r\n    const targetLength = targets[i].distanceTo(targets[j]);\r\n    if (sourceLength > 1e-9) {\r\n      ratioSum += targetLength / sourceLength;\r\n      ratioCount += 1;\r\n    }\r\n  }\r\n  if (ratioCount === 0) {\r\n    return null;\r\n  }\r\n  const scale = ratioSum / ratioCount;\r\n\r\n  // The group applies position, then rotation, then scale, so a point lands at t + s*R*p. Solving\r\n  // that for t at the centroids gives the translation.\r\n  const sourceCentroid = sources.reduce((sum, v) => sum.add(v), new THREE.Vector3()).multiplyScalar(1 / 3);\r\n  const targetCentroid = targets.reduce((sum, v) => sum.add(v), new THREE.Vector3()).multiplyScalar(1 / 3);\r\n  const translation = targetCentroid\r\n    .clone()\r\n    .sub(sourceCentroid.clone().applyMatrix4(rotation).multiplyScalar(scale));\r\n\r\n  const euler = new THREE.Euler().setFromRotationMatrix(rotation);\r\n\r\n  return {\r\n    translation: { x: translation.x, y: translation.y, z: translation.z },\r\n    rotation: { x: euler.x, y: euler.y, z: euler.z },\r\n    scale,\r\n  };\r\n}\r\n\r\n/** The one- and two-pair cases of solveThreeJsAlignment, which share the \"same vertical\" assumption. */\r\nfunction solveReducedAlignment(pairs: ThreeJsAlignmentPair[], up: THREE.Vector3): ThreeJsAlignment | null {\r\n  const sources = pairs.map((pair) => new THREE.Vector3(pair.source.x, pair.source.y, pair.source.z));\r\n  const targets = pairs.map((pair) => new THREE.Vector3(pair.target.x, pair.target.y, pair.target.z));\r\n\r\n  // Starts from the rotation that only stands the tags' vertical on the model's.\r\n  const rotation = new THREE.Quaternion().setFromUnitVectors(new THREE.Vector3(0, 1, 0), up);\r\n  let scale = 1;\r\n\r\n  if (pairs.length === 2) {\r\n    const sourceSpan = sources[1].clone().sub(sources[0]);\r\n    const targetSpan = targets[1].clone().sub(targets[0]);\r\n    if (sourceSpan.length() < 1e-9 || targetSpan.length() < 1e-9) {\r\n      return null;\r\n    }\r\n    scale = targetSpan.length() / sourceSpan.length();\r\n\r\n    // Heading is the turn about the vertical that lines the two spans up, so only their horizontal\r\n    // parts count. Two points one above the other have none, and say nothing about heading.\r\n    const flatten = (v: THREE.Vector3) => v.clone().sub(up.clone().multiplyScalar(v.dot(up)));\r\n    const from = flatten(sourceSpan.clone().applyQuaternion(rotation));\r\n    const to = flatten(targetSpan);\r\n    if (from.length() < 1e-6 * sourceSpan.length() || to.length() < 1e-6 * targetSpan.length()) {\r\n      return null;\r\n    }\r\n    const heading = Math.atan2(new THREE.Vector3().crossVectors(from, to).dot(up), from.dot(to));\r\n    rotation.premultiply(new THREE.Quaternion().setFromAxisAngle(up, heading));\r\n  }\r\n\r\n  // A point lands at t + s*R*p; solved for t at the centroids, as in the three-pair case.\r\n  const centroid = (points: THREE.Vector3[]) =>\r\n    points.reduce((sum, v) => sum.add(v), new THREE.Vector3()).multiplyScalar(1 / points.length);\r\n  const translation = centroid(targets).sub(centroid(sources).applyQuaternion(rotation).multiplyScalar(scale));\r\n  const euler = new THREE.Euler().setFromQuaternion(rotation);\r\n\r\n  return {\r\n    translation: { x: translation.x, y: translation.y, z: translation.z },\r\n    rotation: { x: euler.x, y: euler.y, z: euler.z },\r\n    scale,\r\n  };\r\n}\r\n\r\nexport interface ObjAdded {\r\n  id: string;\r\n  name: string;\r\n  file: string; // The URL to the .obj file\r\n  position: { x: number; y: number; z: number };\r\n  rotation: { x: number; y: number; z: number };\r\n  scale: { x: number; y: number; z: number };\r\n}\r\n\r\ninterface ParsedMeshGroup {\r\n  start: number;\r\n  count: number;\r\n  materialIndex: number;\r\n}\r\n\r\n/** Raw geometry data extracted from a parsed OBJ mesh, sent back by the parser worker. */\r\ninterface ParsedMeshData {\r\n  name: string;\r\n  // One name per material used by this mesh. A single-material mesh has one entry;\r\n  // a mesh with multiple usemtl switches (geometry.groups) has one per group.\r\n  materialNames: string[];\r\n  groups: ParsedMeshGroup[] | null;\r\n  position: Float32Array;\r\n  normal: Float32Array | null;\r\n  uv: Float32Array | null;\r\n  index: Uint32Array | null;\r\n  boundingBox?: { min: [number, number, number]; max: [number, number, number] };\r\n}\r\n\r\ninterface ObjParserWorkerResponse {\r\n  requestId: string;\r\n  success: boolean;\r\n  meshes?: ParsedMeshData[];\r\n  error?: string;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ThreeJsService {\r\n  private scene!: THREE.Scene;\r\n  private camera!: THREE.PerspectiveCamera;\r\n  private renderer!: THREE.WebGLRenderer;\r\n  private controls!: OrbitControls;\r\n  private animationFrameId!: number;\r\n\r\n  // Raycasting and interaction\r\n  private raycaster = new THREE.Raycaster();\r\n  private mouse = new THREE.Vector2();\r\n  private isDraggingCamera: boolean = false;\r\n  private isDraggingTimer: any;\r\n  private clickableObjects: THREE.Object3D[] = [];\r\n\r\n  // Observables for the viewer component\r\n  public objectHovered$ = new Subject<{ id: string; event: MouseEvent } | null>();\r\n  public objectClicked$ = new Subject<string | null>();\r\n\r\n  /** Emits when the user clicks a tag, mirroring Matterport's tag click. */\r\n  public tagClicked$ = new Subject<ThreeJsTagClick>();\r\n\r\n  /** Emits a tag's label while the pointer is over it, and null when it leaves. */\r\n  public tagHovered$ = new Subject<{ label: string; event: MouseEvent } | null>();\r\n\r\n  // Tags live under the model rather than the scene, so the centering and scaling applied when the\r\n  // model is placed carries over and POI coordinates can stay in the model's own space.\r\n  private tagGroup = new THREE.Group();\r\n  private tagSprites = new Map<string, THREE.Sprite>();\r\n\r\n  private canvasResizeObserver?: ResizeObserver;\r\n\r\n  /** Aborts the in-flight model download. Parsing cannot be interrupted, only not started. */\r\n  private loadAbortController?: AbortController;\r\n\r\n  // The loaded base model, kept so tag placement can raycast against its geometry.\r\n  private modelRoot?: THREE.Object3D;\r\n\r\n  /** True while the next click on the model places a tag instead of orbiting. */\r\n  private placingTag = false;\r\n\r\n  /** What the armed placement is for, echoed back when the spot is picked. */\r\n  private placementPoiType: PoiType | null = null;\r\n\r\n  /** Position and normal of the last placed tag, in model space, awaiting commit to a POI. */\r\n  private pendingTagPlacement: ThreeJsTagPlacement | null = null;\r\n\r\n  /** Pointer position waiting for a preview pick, coalesced to one per frame. */\r\n  private pendingPreviewEvent: MouseEvent | null = null;\r\n\r\n  /**\r\n   * Tags whose position is in this model's own coordinates. A sibling of the tag group that does not\r\n   * carry the calibration: calibrating a model for the tags it imports must not move the ones that\r\n   * were placed straight onto it.\r\n   */\r\n  private modelTagGroup = new THREE.Group();\r\n\r\n  /**\r\n   * The capture on screen. A tag placed in a 3D model is recorded with it, which is how the tags\r\n   * placed in this one are told from those that came from elsewhere.\r\n   */\r\n  private currentCaptureID: string | null = null;\r\n\r\n  /**\r\n   * The model's surface as a grid: every cell some part of the surface passes through.\r\n   *\r\n   * It answers \"is this point near the model?\" without visiting the triangles, of which a captured\r\n   * model has millions - the question is asked for every tag, every time the calibration changes.\r\n   */\r\n  private surfaceCells: Set<number> | null = null;\r\n\r\n  private surfaceOrigin = new THREE.Vector3();\r\n\r\n  private surfaceCellSize = 1;\r\n\r\n  /**\r\n   * How far from the model's surface a tag may be and still count as on it, in metres.\r\n   *\r\n   * Every tag of the space is offered to every model; this is what decides which ones a model\r\n   * shows. A tag marks something on a surface, so one that belongs here sits on the surface or\r\n   * close to it. One that lands deep inside the model, or well away from it, marks something that\r\n   * is not part of this model. The allowance covers a calibration done by hand and the model not\r\n   * matching the scan exactly, which together run to a few tens of centimetres.\r\n   */\r\n  private static readonly ON_MODEL_METRES = 0.75;\r\n\r\n  /** Cells per axis the grid's keys can address, with room either side for points off the model. */\r\n  private static readonly SURFACE_GRID_SPAN = 1024;\r\n\r\n  private static readonly SURFACE_GRID_PAD = 128;\r\n\r\n  /** Own tags moved to keep their place under the last calibration, waiting to be stored. */\r\n  private rebasedTags: ThreeJsRebasedTag[] = [];\r\n\r\n  /** The type filter in force. Null shows every type. */\r\n  private visibleTagTypes: PoiType[] | null = null;\r\n\r\n  private measuring = false;\r\n\r\n  /** Points clicked so far, in tag space. */\r\n  private measurePoints: THREE.Vector3[] = [];\r\n\r\n  /**\r\n   * Everything drawn for the measurement. A child of the tag group, so its points share the frame\r\n   * tag coordinates are stored in - which is metres, and what the saved POI has to be in.\r\n   */\r\n  private measureGroup = new THREE.Group();\r\n\r\n  /** The segment that follows the pointer from the last point clicked. */\r\n  private measureRubberBand?: any;\r\n\r\n  private lastMeasurement: ThreeJsMeasurement | null = null;\r\n\r\n  /** Half the model's diagonal as placed in the scene, where it is centred on the origin. */\r\n  private modelWorldRadius = 0;\r\n\r\n  /** The outermost group the model and its tags hang from: where \"which way is up\" is applied. */\r\n  private modelGroup?: THREE.Group;\r\n\r\n  private modelUp: ThreeJsModelUp = 'y';\r\n\r\n  /** While measuring: how many points and each segment's length. Null when it is abandoned. */\r\n  public measurementProgress$ = new Subject<{ points: number; distances: number[] } | null>();\r\n\r\n  /**\r\n   * Layer carrying the model alone, so the depth pick can render it without the tags.\r\n   *\r\n   * Layers are tested per object at render time and children are traversed regardless of whether\r\n   * their parent passed, so marking the model's own meshes is enough - no re-parenting.\r\n   */\r\n  private static readonly PICK_LAYER = 1;\r\n\r\n  /** The app's highlight colour, so a measurement reads as the active thing on screen. */\r\n  private static readonly MEASURE_COLOR = '#FFB103';\r\n\r\n  /** Cache Storage bucket holding downloaded models, and how many to keep. */\r\n  private static readonly MODEL_CACHE = 'smarterplan-3d-models';\r\n\r\n  private static readonly MODEL_CACHE_SIZE = 3;\r\n\r\n  private pickTarget?: THREE.WebGLRenderTarget;\r\n\r\n  private pickCamera?: THREE.PerspectiveCamera;\r\n\r\n  private pickDepthMaterial?: THREE.MeshDepthMaterial;\r\n\r\n  private readonly pickPixel = new Uint8Array(4);\r\n\r\n  /** Emits once a tag is dropped on the model, so the UI can confirm and persist it. */\r\n  public tagPlaced$ = new Subject<ThreeJsTagPlacement>();\r\n\r\n  /** Emits when the calibration walkthrough is abandoned, so the panel driving it can close. */\r\n  public alignmentCancelled$ = new Subject<void>();\r\n\r\n  /** Translucent marker shown under the cursor while placing. */\r\n  private placementPreview?: THREE.Sprite;\r\n\r\n  private aligning = false;\r\n  private alignmentPairs: ThreeJsAlignmentPair[] = [];\r\n  private alignmentSource: { x: number; y: number; z: number } | null = null;\r\n\r\n  /** The tag `alignmentSource` was read from, kept so the same tag is not matched twice. */\r\n  private alignmentSourceTagId: string | undefined;\r\n\r\n  /** Drives the alignment walkthrough's UI: how many pairs are done and what it wants next. */\r\n  public alignmentProgress$ = new Subject<{\r\n    pairs: number;\r\n    awaiting: 'tag' | 'point' | null;\r\n    tagId?: string;\r\n  }>();\r\n\r\n  /** In-flight camera move started by goToTag, advanced by the render loop. */\r\n  private cameraTween: {\r\n    fromPosition: THREE.Vector3;\r\n    toPosition: THREE.Vector3;\r\n    fromTarget: THREE.Vector3;\r\n    toTarget: THREE.Vector3;\r\n    startedAt: number;\r\n    durationMs: number;\r\n  } | null = null;\r\n\r\n  /** Emits true while a heavy OBJ file is being parsed (in a worker, when available), false once done. */\r\n  public modelLoading$ = new Subject<boolean>();\r\n\r\n  /**\r\n   * Download progress for GLB models, as a 0-1 fraction, or null when the total size is unknown.\r\n   *\r\n   * A null means the server did not send Content-Length (chunked responses, some proxies) and no\r\n   * percentage can be derived; show an indeterminate indicator rather than guessing at one.\r\n   */\r\n  public modelLoadProgress$ = new Subject<number | null>();\r\n\r\n  /**\r\n   * Emits when a load actually stopped short, which is not the same as asking it to.\r\n   *\r\n   * cancelModelLoad() can arrive after parse() has taken the main thread, and parse cannot be\r\n   * interrupted - the model finishes loading regardless. Only this tells the UI which of the two\r\n   * happened, so it does not offer to reload something that is already on screen.\r\n   */\r\n  public modelLoadCancelled$ = new Subject<void>();\r\n\r\n  // Background parsing of heavy .obj files, provided by the hosting app (see setObjParserWorker).\r\n  // Angular libraries built with ng-packagr can't bundle `new Worker(new URL(...))` themselves,\r\n  // so the app instantiates the worker (its build pipeline supports it) and hands it over here.\r\n  private objParserWorker?: Worker;\r\n  private objParserPendingRequests = new Map<string, { resolve: (meshes: ParsedMeshData[]) => void; reject: (error: Error) => void }>();\r\n\r\n  constructor(private ngZone: NgZone) { }\r\n\r\n  /**\r\n   * Registers a Web Worker used to parse heavy .obj files off the main thread.\r\n   * Must be instantiated by the consuming app (e.g. `new Worker(new URL('./obj-parser.worker', import.meta.url))`),\r\n   * since a library packaged with ng-packagr cannot bundle worker files itself.\r\n   * When no worker is provided, loadObjModel falls back to parsing on the main thread.\r\n   */\r\n  setObjParserWorker(worker: Worker): void {\r\n    this.objParserWorker = worker;\r\n    this.objParserWorker.onmessage = ({ data }: MessageEvent<ObjParserWorkerResponse>) => {\r\n      const pending = this.objParserPendingRequests.get(data.requestId);\r\n      if (!pending) {\r\n        return;\r\n      }\r\n      this.objParserPendingRequests.delete(data.requestId);\r\n      if (data.success && data.meshes) {\r\n        pending.resolve(data.meshes);\r\n      } else {\r\n        pending.reject(new Error(data.error || 'Unknown error while parsing OBJ file in worker'));\r\n      }\r\n    };\r\n  }\r\n\r\n  private requestObjParseInWorker(objUrl: string): Promise<ParsedMeshData[]> {\r\n    return new Promise((resolve, reject) => {\r\n      const requestId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;\r\n      this.objParserPendingRequests.set(requestId, { resolve, reject });\r\n      this.objParserWorker!.postMessage({ requestId, objUrl });\r\n      // Diagnostic only: large models legitimately take a while, this isn't a timeout/abort,\r\n      // just a signal in case the worker went silent (e.g. it ran out of memory mid-parse).\r\n      setTimeout(() => {\r\n        if (this.objParserPendingRequests.has(requestId)) {\r\n          console.warn(`ThreeJsService: obj-parser worker has not replied after 60s for request ${requestId} (objUrl=${objUrl}). Still waiting - large files can take a while, but this may also mean the worker hung or ran out of memory.`);\r\n        }\r\n      }, 60000);\r\n    });\r\n  }\r\n\r\n  /** Rebuilds a THREE.Mesh from the raw typed arrays sent back by the parser worker. */\r\n  private meshFromParsedData(data: ParsedMeshData, materials?: any): THREE.Mesh {\r\n    const geometry = new THREE.BufferGeometry();\r\n    geometry.setAttribute('position', new THREE.BufferAttribute(data.position, 3));\r\n    if (data.uv) {\r\n      geometry.setAttribute('uv', new THREE.BufferAttribute(data.uv, 2));\r\n    }\r\n    // Index has to be set before any normal computation, which reads it to average shared faces.\r\n    if (data.index) {\r\n      geometry.setIndex(new THREE.BufferAttribute(data.index, 1));\r\n    }\r\n    if (data.normal) {\r\n      geometry.setAttribute('normal', new THREE.BufferAttribute(data.normal, 3));\r\n    } else {\r\n      geometry.computeVertexNormals();\r\n    }\r\n    // Box3.setFromObject() reuses an already-set boundingBox instead of walking every vertex,\r\n    // so adopting the worker's makes framing the camera cheap no matter how dense the mesh is.\r\n    if (data.boundingBox) {\r\n      geometry.boundingBox = new THREE.Box3(\r\n        new THREE.Vector3(...data.boundingBox.min),\r\n        new THREE.Vector3(...data.boundingBox.max),\r\n      );\r\n    }\r\n\r\n    const resolvedMaterials = data.materialNames.map((name) => {\r\n      const material = materials && name ? materials.create(name) : undefined;\r\n      if (!material) {\r\n        console.warn(`ThreeJsService: no MTL material named \"${name}\" for mesh \"${data.name}\", using a plain fallback (no texture).`);\r\n      }\r\n      return material || new THREE.MeshPhongMaterial();\r\n    });\r\n\r\n    let mesh: THREE.Mesh;\r\n    if (data.groups && data.groups.length > 0) {\r\n      data.groups.forEach((group) => geometry.addGroup(group.start, group.count, group.materialIndex));\r\n      mesh = new THREE.Mesh(geometry, resolvedMaterials);\r\n    } else {\r\n      mesh = new THREE.Mesh(geometry, resolvedMaterials[0]);\r\n    }\r\n    mesh.name = data.name;\r\n    return mesh;\r\n  }\r\n\r\n  init(canvas: HTMLCanvasElement): void {\r\n    // This service is a singleton but the viewer component is rebuilt on every navigation, so state\r\n    // from the previous scene is still here. Two things outlive it and have to go first:\r\n    //\r\n    //  - A download still in flight. Its onLoaded resolves against whatever `this.scene` points at\r\n    //    by then, so the model being abandoned would be handed to the scene built below.\r\n    //  - The tag group, which is a field and keeps its sprites. They would be re-parented under the\r\n    //    new model and show the previous visit's tags on it.\r\n    this.discardCurrentLoad();\r\n    this.clearTags();\r\n    this.measuring = false;\r\n    this.clearMeasurement();\r\n    this.cameraTween = null;\r\n    this.modelRoot = undefined;\r\n\r\n    // 1. Setup Scene\r\n    this.scene = new THREE.Scene();\r\n    this.scene.background = new THREE.Color(0xe0f7ff); // from POC\r\n\r\n    // 2. Setup Camera\r\n    this.camera = new THREE.PerspectiveCamera(75, canvas.clientWidth / canvas.clientHeight, 0.1, 10000);\r\n    this.camera.position.set(0, 5, 10); // will be overridden later if passed\r\n\r\n    // 3. Setup WebGL Renderer\r\n    this.renderer = new THREE.WebGLRenderer({ canvas, antialias: true });\r\n    this.renderer.setSize(canvas.clientWidth, canvas.clientHeight);\r\n    this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 1.5));\r\n    this.observeCanvasResize(canvas);\r\n    \r\n    // Fix for Three.js r147 vs r152+ color management\r\n    if ('outputColorSpace' in this.renderer) {\r\n      (this.renderer as any).outputColorSpace = 'srgb'; // THREE.SRGBColorSpace\r\n    } else {\r\n      (this.renderer as any).outputEncoding = 3001; // THREE.sRGBEncoding\r\n    }\r\n\r\n    // Without tone mapping anything brighter than 1.0 is simply cut off to pure white. Captured\r\n    // textures carry a small fraction of very bright pixels - sky reflected in windows, sunlit\r\n    // render - and once lighting pushes those past the limit they flatten into white specks with\r\n    // no detail left. Rolling the highlights off instead keeps that detail and keeps bright areas\r\n    // reading as bright rather than blown.\r\n    this.renderer.toneMapping = THREE.ACESFilmicToneMapping;\r\n    this.renderer.toneMappingExposure = 1.0;\r\n\r\n    // 4. Lighting, kept deliberately restrained and neutral.\r\n    //\r\n    // Captured/photogrammetry models already have lighting baked into their textures (the sun and\r\n    // shadows came with the photos), so lighting them again distorts what they actually look like.\r\n    // The intensities below add up to roughly 1.0 on a surface facing the viewer, which renders the\r\n    // texture at its true value. Anything above 1.0 is clipped to pure white by the renderer, which\r\n    // is what turns bright areas into flat white patches with no detail left in them.\r\n    //\r\n    // Neutral white is used rather than a warm tint for the same reason: a tinted light shifts every\r\n    // colour in the model away from what was captured.\r\n    const ambientLight = new THREE.AmbientLight(0xffffff, 0.7);\r\n    this.scene.add(ambientLight);\r\n\r\n    // Headlight rather than a fixed sun: parented to the camera so it always points at whatever is\r\n    // being looked at, giving shape to surfaces without ever leaving a face unlit. No shadow casting\r\n    // - shadows would double up with the ones already baked into the textures, and the shadow map\r\n    // was a real cost per frame.\r\n    const headLight = new THREE.DirectionalLight(0xffffff, 0.35);\r\n    headLight.position.set(0, 0, 1);\r\n    this.camera.add(headLight);\r\n    // A light only contributes while it is part of the scene graph, and this one hangs off the camera.\r\n    this.scene.add(this.camera);\r\n\r\n    // 5. Setup Controls (from POC)\r\n    this.controls = new OrbitControls(this.camera, this.renderer.domElement);\r\n    this.controls.rotateSpeed = 1.0;\r\n    this.controls.dampingFactor = 0.1;\r\n    this.controls.enableDamping = true;\r\n    this.controls.mouseButtons = {\r\n      LEFT: THREE.MOUSE.ROTATE,\r\n      MIDDLE: THREE.MOUSE.DOLLY,\r\n      RIGHT: THREE.MOUSE.PAN,\r\n    };\r\n    this.controls.target.set(0, 0, 0);\r\n\r\n    // Event listeners on controls to differentiate dragging vs clicking\r\n    this.controls.addEventListener('start', () => {\r\n      this.isDraggingTimer = setTimeout(() => {\r\n        this.isDraggingCamera = true;\r\n      }, 150);\r\n    });\r\n\r\n    this.controls.addEventListener('end', () => {\r\n      clearTimeout(this.isDraggingTimer);\r\n      if (this.isDraggingCamera) {\r\n        setTimeout(() => {\r\n          this.isDraggingCamera = false;\r\n        }, 250);\r\n      }\r\n    });\r\n\r\n    // Interaction Event Listeners on canvas\r\n    canvas.addEventListener('click', this.onMouseClick.bind(this), false);\r\n    canvas.addEventListener('mousemove', this.onMouseMove.bind(this), false);\r\n\r\n    // Escape backs out of placement and calibration. On the window rather than the canvas, which\r\n    // would need focus the user has no reason to have given it - they are aiming with the mouse.\r\n    // Removed first because this service is a singleton: init() runs again for every canvas, and\r\n    // the previous registration would otherwise still be attached.\r\n    window.removeEventListener('keydown', this.onKeyDown);\r\n    this.pickTarget?.dispose();\r\n    this.pickTarget = undefined;\r\n    this.pickDepthMaterial?.dispose();\r\n    this.pickDepthMaterial = undefined;\r\n    this.pickCamera = undefined;\r\n    window.addEventListener('keydown', this.onKeyDown);\r\n\r\n    // 6. Start the render loop\r\n    this.ngZone.runOutsideAngular(() => {\r\n      this.animate();\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Path (served by the app) holding basis_transcoder.js/.wasm, which KTX2Loader needs to turn\r\n   * Basis Universal textures into whatever compressed format the local GPU actually supports.\r\n   */\r\n  private ktx2TranscoderPath = 'assets/basis/';\r\n\r\n  /** Overrides where the Basis transcoder files are served from. */\r\n  setKtx2TranscoderPath(path: string): void {\r\n    this.ktx2TranscoderPath = path;\r\n  }\r\n\r\n  /**\r\n   * Loads a base 3D model in GLTF/GLB format - the preferred format for large models.\r\n   * Unlike .obj, geometry arrives as binary typed arrays (no text parsing to offload to a worker)\r\n   * and stays indexed, so far less data reaches the GPU. KTX2 textures are supported too: they\r\n   * stay compressed in VRAM instead of being decoded to raw pixels like JPEG/PNG.\r\n   */\r\n  loadGLTFModel(url: string, cameraPosition?: {x: number, y: number, z: number}, rotation?: {x: number, y: number, z: number}, cacheKey?: string, up?: ThreeJsModelUp): void {\r\n    const loader = new GLTFLoader();\r\n\r\n    // KTX2 needs the renderer to report which compressed formats this GPU accepts, so this has to\r\n    // happen after init(). Guarded so a model without KTX2 textures still loads if it's missing.\r\n    if (this.renderer) {\r\n      try {\r\n        const ktx2Loader = new KTX2Loader()\r\n          .setTranscoderPath(this.ktx2TranscoderPath)\r\n          .detectSupport(this.renderer);\r\n        loader.setKTX2Loader(ktx2Loader);\r\n      } catch (error) {\r\n        console.warn('ThreeJsService: could not set up KTX2 texture support, falling back to uncompressed textures.', error);\r\n      }\r\n    }\r\n    // Lets gltfpack/gltf-transform output using EXT_meshopt_compression load without extra setup.\r\n    loader.setMeshoptDecoder(MeshoptDecoder);\r\n\r\n    this.modelLoading$.next(true);\r\n    this.modelLoadProgress$.next(0);\r\n\r\n    // Order matters: normals must exist before anisotropy, and the Phong conversion has to run\r\n    // before side/flatShading are touched so those settings land on the materials we keep.\r\n    const onLoaded = (gltf: any) => {\r\n      this.convertToPhongMaterials(gltf.scene);\r\n      this.forceDoubleSidedMaterials(gltf.scene);\r\n      this.ensureVertexNormals(gltf.scene);\r\n      this.tuneTextureSampling(gltf.scene);\r\n      this.placeLoadedObjectInScene(gltf.scene, cameraPosition, rotation, up);\r\n      this.modelLoading$.next(false);\r\n    };\r\n    const onError = (error: any) => {\r\n      // Cancelling is a decision, not a failure: clear the overlay without an error in the console.\r\n      if (error?.name === 'AbortError') {\r\n        // Only a cancel of the load that is still current came from the user; anything else is this\r\n        // load having been superseded or discarded.\r\n        if (this.loadAbortController?.signal.aborted) {\r\n          this.modelLoadCancelled$.next();\r\n        }\r\n      } else {\r\n        console.error('Error loading GLTF model:', error);\r\n      }\r\n      this.modelLoading$.next(false);\r\n      this.modelLoadProgress$.next(null);\r\n    };\r\n\r\n    // GLTFLoader decodes embedded images with createImageBitmap when the browser offers it, and on\r\n    // large texture atlases that path returns visibly corrupt data - scattered white blocks across\r\n    // the model. The exact same bytes decoded through an HTMLImageElement, which is what the .obj\r\n    // path uses via MTLLoader, come out clean. GLTFLoader already falls back to that decoder for\r\n    // Safari and older Firefox; this simply extends the fallback to cover this case too.\r\n    //\r\n    // The decoder is chosen while GLTFParser is being constructed, which happens synchronously\r\n    // inside parse(), so hiding createImageBitmap only has to hold across that call rather than\r\n    // for the whole download.\r\n    this.fetchWithProgress(url, cacheKey)\r\n      // parse() holds the main thread for seconds on a large model. Yield until the browser has\r\n      // actually painted first, otherwise the final progress update never reaches the screen and\r\n      // the bar appears to stall short of the end.\r\n      .then((buffer) => this.afterNextPaint().then(() => buffer))\r\n      .then((buffer) => {\r\n        // parse() cannot be interrupted, so a cancel that lands during the paint yield has to be\r\n        // caught here - the last moment before the main thread is committed for several seconds.\r\n        if (this.loadAbortController?.signal.aborted) {\r\n          throw new DOMException('Model load cancelled', 'AbortError');\r\n        }\r\n        const globalScope = globalThis as any;\r\n        const originalCreateImageBitmap = globalScope.createImageBitmap;\r\n        globalScope.createImageBitmap = undefined;\r\n        try {\r\n          loader.parse(buffer, url.substring(0, url.lastIndexOf('/') + 1), onLoaded, onError);\r\n        } finally {\r\n          globalScope.createImageBitmap = originalCreateImageBitmap;\r\n        }\r\n      })\r\n      .catch(onError);\r\n  }\r\n\r\n  /**\r\n   * Stops the model download in progress, if any.\r\n   *\r\n   * Only the download can be interrupted: parse() runs synchronously and holds the main thread until\r\n   * it finishes, so once it has begun there is nothing to cancel. In practice the download is the\r\n   * long part, which is where someone reaches for this.\r\n   */\r\n  cancelModelLoad(): void {\r\n    this.loadAbortController?.abort();\r\n  }\r\n\r\n  /**\r\n   * Abandons the load in progress without reporting it as cancelled.\r\n   *\r\n   * Dropping the controller is what makes the difference: onError treats an abort as user-initiated\r\n   * only while the controller that aborted is still the current one. Tearing down or rebuilding the\r\n   * scene is not something the person asked for, so it must not surface as \"loading cancelled\".\r\n   */\r\n  private discardCurrentLoad(): void {\r\n    this.loadAbortController?.abort();\r\n    this.loadAbortController = undefined;\r\n  }\r\n\r\n  /**\r\n   * Resolves once the browser has painted at least one frame.\r\n   *\r\n   * A requestAnimationFrame callback runs *before* that frame is painted, so a single one is not\r\n   * enough to guarantee pending DOM changes are on screen; the second fires after the first frame\r\n   * has gone out. Falls back to a timeout where rAF isn't available (SSR, tests).\r\n   */\r\n  private afterNextPaint(): Promise<void> {\r\n    if (typeof requestAnimationFrame !== 'function') {\r\n      return new Promise((resolve) => setTimeout(resolve, 0));\r\n    }\r\n    return new Promise((resolve) => {\r\n      requestAnimationFrame(() => requestAnimationFrame(() => resolve()));\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Downloads a file, reporting progress on modelLoadProgress$ as it arrives.\r\n   *\r\n   * GLTFLoader.load() would report progress through XHR, but this path deliberately uses fetch() +\r\n   * parse() instead (see loadGLTFModel for why), so progress is read off the response stream here.\r\n   * That is also the more useful number: on a model of this size the download dominates, and the\r\n   * stream reports it as it happens rather than in one jump at the end.\r\n   */\r\n  private async fetchWithProgress(url: string, cacheKey?: string): Promise<ArrayBuffer> {\r\n    // A load already running is replaced, not raced: whichever finished last would otherwise win.\r\n    this.loadAbortController?.abort();\r\n    this.loadAbortController = new AbortController();\r\n    const { signal } = this.loadAbortController;\r\n\r\n    const cached = await this.readModelFromCache(cacheKey);\r\n    if (cached) {\r\n      this.modelLoadProgress$.next(1);\r\n      return cached;\r\n    }\r\n\r\n    const response = await fetch(url, { signal });\r\n    if (!response.ok) {\r\n      throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);\r\n    }\r\n\r\n    const contentLength = Number(response.headers.get('Content-Length'));\r\n    const total = Number.isFinite(contentLength) && contentLength > 0 ? contentLength : 0;\r\n\r\n    // Without a readable stream (older browsers, some polyfills) there is nothing to measure, so\r\n    // fall back to a plain buffered read and let the UI show an indeterminate indicator.\r\n    if (!response.body?.getReader) {\r\n      this.modelLoadProgress$.next(null);\r\n      return response.arrayBuffer();\r\n    }\r\n\r\n    const reader = response.body.getReader();\r\n\r\n    // With a known size, write chunks straight into one pre-allocated buffer. Collecting them in an\r\n    // array and concatenating afterwards would hold both copies at once - on a 164 MB model that is\r\n    // an avoidable 300+ MB peak.\r\n    const buffer = total > 0 ? new Uint8Array(total) : null;\r\n    const chunks: Uint8Array[] = [];\r\n    let usingBuffer = buffer !== null;\r\n    let received = 0;\r\n    // Chunks arrive in tens of kilobytes, so a 164 MB model produces thousands of them. Emitting on\r\n    // every one would run change detection just as often to move a bar that is measured in whole\r\n    // percent, so only report when the displayed value would actually change.\r\n    let lastReported = -1;\r\n\r\n    if (total === 0) {\r\n      this.modelLoadProgress$.next(null);\r\n    }\r\n\r\n    for (;;) {\r\n      const { done, value } = await reader.read();\r\n      if (done) {\r\n        break;\r\n      }\r\n      if (signal.aborted) {\r\n        // Free the connection rather than leaving it draining in the background.\r\n        await reader.cancel();\r\n        throw new DOMException('Model load cancelled', 'AbortError');\r\n      }\r\n      if (usingBuffer && received + value.length > total) {\r\n        // Content-Length understated the real size. Move what we have into the chunk list and stay\r\n        // there for the rest of the response, rather than truncating the tail.\r\n        chunks.push(buffer.slice(0, received));\r\n        usingBuffer = false;\r\n      }\r\n      if (usingBuffer) {\r\n        buffer.set(value, received);\r\n      } else {\r\n        chunks.push(value);\r\n      }\r\n      received += value.length;\r\n      if (total > 0) {\r\n        const percent = Math.min(Math.round((received / total) * 100), 100);\r\n        if (percent !== lastReported) {\r\n          lastReported = percent;\r\n          this.modelLoadProgress$.next(percent / 100);\r\n        }\r\n      }\r\n    }\r\n\r\n    // The stream can end below the advertised size (or with no size at all). Land on a full bar\r\n    // rather than leaving it stuck at whatever the last chunk happened to reach.\r\n    if (total > 0 && lastReported !== 100) {\r\n      this.modelLoadProgress$.next(1);\r\n    }\r\n\r\n    let result: ArrayBuffer;\r\n    if (usingBuffer && received === total) {\r\n      result = buffer.buffer;\r\n    } else if (usingBuffer) {\r\n      // Fewer bytes than advertised: hand back exactly what arrived.\r\n      result = buffer.buffer.slice(0, received);\r\n    } else {\r\n      const merged = new Uint8Array(received);\r\n      let offset = 0;\r\n      chunks.forEach((chunk) => {\r\n        merged.set(chunk, offset);\r\n        offset += chunk.length;\r\n      });\r\n      result = merged.buffer;\r\n    }\r\n\r\n    await this.writeModelToCache(cacheKey, result);\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * The model store, or null where the browser will not give us one.\r\n   *\r\n   * Cache Storage needs a secure context, so it is absent over plain http and in some embedded\r\n   * webviews. Every caller treats that as a miss - caching is an optimisation, never a requirement.\r\n   */\r\n  private async openModelCache(): Promise<Cache | null> {\r\n    if (typeof caches === 'undefined') {\r\n      return null;\r\n    }\r\n    try {\r\n      return await caches.open(ThreeJsService.MODEL_CACHE);\r\n    } catch {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * A cached copy of this model, if one was stored.\r\n   *\r\n   * Keyed by the S3 key rather than the URL it is fetched from: that URL is signed, so it carries a\r\n   * fresh signature and expiry every time and would never match twice. The browser's own HTTP cache\r\n   * misses for the same reason, which is why this exists at all.\r\n   */\r\n  private async readModelFromCache(cacheKey?: string): Promise<ArrayBuffer | null> {\r\n    if (!cacheKey) {\r\n      return null;\r\n    }\r\n    try {\r\n      const cache = await this.openModelCache();\r\n      const hit = await cache?.match(this.modelCacheUrl(cacheKey));\r\n      return hit ? await hit.arrayBuffer() : null;\r\n    } catch {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  /** Stores a model for next time, evicting the oldest once a few are held. */\r\n  private async writeModelToCache(cacheKey: string | undefined, model: ArrayBuffer): Promise<void> {\r\n    if (!cacheKey) {\r\n      return;\r\n    }\r\n    try {\r\n      const cache = await this.openModelCache();\r\n      if (!cache) {\r\n        return;\r\n      }\r\n      await cache.put(this.modelCacheUrl(cacheKey), new Response(model));\r\n\r\n      // Models run to hundreds of megabytes, so this cannot grow without limit. Cache Storage keeps\r\n      // insertion order, which makes the front of the list the least recently stored.\r\n      const keys = await cache.keys();\r\n      await Promise.all(\r\n        keys.slice(0, Math.max(0, keys.length - ThreeJsService.MODEL_CACHE_SIZE))\r\n          .map((key) => cache.delete(key))\r\n      );\r\n    } catch {\r\n      // Out of quota, private browsing, storage disabled: the model is already loaded either way.\r\n    }\r\n  }\r\n\r\n  /** Cache Storage keys on a URL, so the S3 key is expressed as one. It is never requested. */\r\n  private modelCacheUrl(cacheKey: string): string {\r\n    return `https://3d-model-cache.smarterplan.local/${encodeURIComponent(cacheKey)}`;\r\n  }\r\n\r\n  /**\r\n   * Fits the camera's clipping planes to how big the model actually is.\r\n   *\r\n   * Depth precision depends on the far/near ratio, and the fixed 0.1 / 10000 the camera starts with\r\n   * is a ratio of 100000 for a model only ~10 units across. That wastes most of the depth buffer on\r\n   * empty space and lets nearly coincident surfaces - which captured meshes have everywhere -\r\n   * flicker against each other.\r\n   */\r\n  private adjustClippingPlanes(radius: number): void {\r\n    if (radius < 10) {\r\n      this.camera.near = 0.01;\r\n      this.camera.far = 100;\r\n    } else if (radius < 100) {\r\n      this.camera.near = 0.1;\r\n      this.camera.far = 1000;\r\n    } else if (radius < 1000) {\r\n      this.camera.near = 10;\r\n      this.camera.far = 10000;\r\n    } else {\r\n      this.camera.near = 100;\r\n      this.camera.far = 1000000;\r\n    }\r\n    this.camera.updateProjectionMatrix();\r\n  }\r\n\r\n  /**\r\n   * Swaps the PBR materials GLTFLoader builds for the plain Phong ones the .obj path produces.\r\n   *\r\n   * MeshStandardMaterial keeps a specular reflection even at metalness 0, since every dielectric\r\n   * reflects some light, and Fresnel drives that reflection towards white as a surface turns away\r\n   * from the viewer. On an aerial view of a facade most surfaces sit at exactly those grazing\r\n   * angles, which paints white highlights over window frames and roof edges - the same model\r\n   * loaded as .obj never shows them, because MTLLoader builds Phong materials and OBJLoader zeroes\r\n   * their specular when the .mtl declares Ns 0.\r\n   *\r\n   * Captured models carry their lighting in the texture and want no specular response at all, so\r\n   * matching the .obj path here is both the fix and the more faithful choice.\r\n   */\r\n  private convertToPhongMaterials(root: THREE.Object3D): void {\r\n    const converted = new Map<any, THREE.MeshPhongMaterial>();\r\n\r\n    root.traverse((child) => {\r\n      const mesh = child as THREE.Mesh;\r\n      if (!(mesh as any).isMesh) {\r\n        return;\r\n      }\r\n\r\n      const convert = (source: any): any => {\r\n        if (!source || !(source as any).isMeshStandardMaterial) {\r\n          return source;\r\n        }\r\n        if (!converted.has(source)) {\r\n          const phong = new THREE.MeshPhongMaterial({\r\n            map: source.map,\r\n            color: source.color,\r\n            transparent: source.transparent,\r\n            opacity: source.opacity,\r\n            alphaTest: source.alphaTest,\r\n            side: source.side,\r\n            specular: new THREE.Color(0x000000),\r\n            shininess: 0,\r\n          });\r\n          phong.name = source.name;\r\n          converted.set(source, phong);\r\n        }\r\n        return converted.get(source);\r\n      };\r\n\r\n      mesh.material = Array.isArray(mesh.material)\r\n        ? mesh.material.map(convert)\r\n        : convert(mesh.material);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Renders every material double-sided.\r\n   *\r\n   * Reality capture meshes routinely contain triangles with reversed winding - an artefact of the\r\n   * reconstruction, not of the file. With the default FrontSide those triangles are culled, leaving\r\n   * scattered holes that show the scene background through the model. Against a light background\r\n   * they read as white specks with no discernible pattern.\r\n   *\r\n   * Drawing both sides costs a little fill rate but is what makes captured geometry render as\r\n   * solid; other viewers of this kind of content do the same unconditionally.\r\n   */\r\n  private forceDoubleSidedMaterials(root: THREE.Object3D): void {\r\n    const seen = new Set<any>();\r\n    root.traverse((child) => {\r\n      const mesh = child as THREE.Mesh;\r\n      if (!(mesh as any).isMesh) {\r\n        return;\r\n      }\r\n      const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];\r\n      materials.forEach((material: any) => {\r\n        if (material && !seen.has(material)) {\r\n          seen.add(material);\r\n          material.side = THREE.DoubleSide;\r\n          material.needsUpdate = true;\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Computes real vertex normals for any geometry that arrived without them.\r\n   *\r\n   * A glTF without a NORMAL attribute is spec-compliant, and GLTFLoader handles it by switching the\r\n   * material to flatShading, which makes the shader derive the normal per pixel from screen-space\r\n   * derivatives. That derivation collapses on the degenerate, needle-thin triangles that reality\r\n   * capture meshes are full of: the face has almost no area, the derived normal is meaningless, and\r\n   * lighting blows those fragments out to white specks - densest exactly where fine detail is.\r\n   *\r\n   * Computing normals from the geometry instead is robust to those triangles, since a degenerate\r\n   * face contributes almost nothing to the average and its neighbours dominate.\r\n   */\r\n  private ensureVertexNormals(root: THREE.Object3D): void {\r\n    root.traverse((child) => {\r\n      const mesh = child as THREE.Mesh;\r\n      if (!(mesh as any).isMesh) {\r\n        return;\r\n      }\r\n      const geometry = mesh.geometry as THREE.BufferGeometry;\r\n      if (geometry.getAttribute('normal')) {\r\n        return;\r\n      }\r\n\r\n      geometry.computeVertexNormals();\r\n\r\n      // GLTFLoader already switched these materials to flatShading because normals were missing;\r\n      // now that real ones exist, let them be used instead of the derivative fallback.\r\n      const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];\r\n      materials.forEach((material: any) => {\r\n        if (material && material.flatShading) {\r\n          material.flatShading = false;\r\n          material.needsUpdate = true;\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Configures how every texture in a model is sampled: maximum anisotropy, and no mipmapping.\r\n   *\r\n   * Photogrammetry atlases pack their UV islands with unused gutter pixels between them. Mipmapping\r\n   * averages neighbouring pixels at each level, so those gutters bleed further into the islands the\r\n   * smaller the level gets - and viewing the whole model at once uses the smallest levels, painting\r\n   * bright gutter pixels over the edges of fine detail. Sampling the full-resolution image avoids\r\n   * that, at the cost of some shimmer on minified surfaces.\r\n   *\r\n   * Note that anisotropy only takes effect while mipmapping is on, so with the settings below it is\r\n   * inert; it is set anyway so the sampling stays correct for anyone who re-enables mipmaps here.\r\n   */\r\n  private tuneTextureSampling(root: THREE.Object3D): void {\r\n    if (!this.renderer) {\r\n      return;\r\n    }\r\n    const maxAnisotropy = this.renderer.capabilities.getMaxAnisotropy();\r\n    if (!maxAnisotropy || maxAnisotropy <= 1) {\r\n      return;\r\n    }\r\n\r\n    const seen = new Set<any>();\r\n    root.traverse((child) => {\r\n      const mesh = child as THREE.Mesh;\r\n      if (!(mesh as any).isMesh) {\r\n        return;\r\n      }\r\n      const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];\r\n      materials.forEach((material: any) => {\r\n        if (!material) {\r\n          return;\r\n        }\r\n        // Same texture is reused across the model's materials; only touch each one once.\r\n        ['map', 'normalMap', 'roughnessMap', 'metalnessMap', 'emissiveMap', 'aoMap'].forEach((slot) => {\r\n          const texture = material[slot];\r\n          if (texture && !seen.has(texture)) {\r\n            seen.add(texture);\r\n            texture.anisotropy = maxAnisotropy;\r\n            texture.generateMipmaps = false;\r\n            texture.minFilter = THREE.LinearFilter;\r\n            texture.needsUpdate = true;\r\n          }\r\n        });\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Loads an OBJ model with MTL.\r\n   * The heavy text-parsing step runs in a Web Worker when one has been registered via\r\n   * setObjParserWorker (see there for why the app, not this library, provides it); this keeps\r\n   * the main thread free while large architecture models (millions of vertices) are parsed.\r\n   * Falls back to parsing on the main thread otherwise.\r\n   */\r\n  loadObjModel(mtlUrl: string, objUrl: string, cameraPosition?: {x: number, y: number, z: number}, rotation?: {x: number, y: number, z: number}): void {\r\n    const mtlLoader = new MTLLoader();\r\n    const basePath = mtlUrl.substring(0, mtlUrl.lastIndexOf('/') + 1);\r\n    mtlLoader.setPath(basePath);\r\n    const mtlFileName = mtlUrl.substring(mtlUrl.lastIndexOf('/') + 1);\r\n\r\n    this.modelLoading$.next(true);\r\n\r\n    mtlLoader.load(mtlFileName, (materials) => {\r\n      materials.preload();\r\n\r\n      if (this.objParserWorker) {\r\n        this.requestObjParseInWorker(objUrl)\r\n          .then((meshes) => {\r\n            const group = new THREE.Group();\r\n            meshes.forEach((meshData) => {\r\n              group.add(this.meshFromParsedData(meshData, materials));\r\n            });\r\n            this.placeLoadedObjectInScene(group, cameraPosition, rotation);\r\n          })\r\n          .catch((error) => {\r\n            console.error('Error parsing OBJ model in worker:', error);\r\n          })\r\n          .finally(() => this.modelLoading$.next(false));\r\n        return;\r\n      }\r\n\r\n      const objLoader = new OBJLoader();\r\n      objLoader.setMaterials(materials);\r\n\r\n      objLoader.load(objUrl, (object) => {\r\n        this.placeLoadedObjectInScene(object, cameraPosition, rotation);\r\n        this.modelLoading$.next(false);\r\n      }, undefined, (error) => {\r\n        console.error('Error loading OBJ model:', error);\r\n        this.modelLoading$.next(false);\r\n      });\r\n    }, undefined, (error) => {\r\n      console.error('Error loading MTL file:', error);\r\n      this.modelLoading$.next(false);\r\n    });\r\n  }\r\n\r\n  /** Centers, scales and adds a loaded object to the scene, then frames the camera on it. */\r\n  private placeLoadedObjectInScene(object: THREE.Object3D, cameraPosition?: {x: number, y: number, z: number}, rotation?: {x: number, y: number, z: number}, up?: ThreeJsModelUp): void {\r\n    const box = new THREE.Box3().setFromObject(object);\r\n    const center = box.getCenter(new THREE.Vector3());\r\n    const size = box.getSize(new THREE.Vector3());\r\n    const maxDim = Math.max(size.x, size.y, size.z);\r\n    const scale = maxDim > 0 ? 10 / maxDim : 1;\r\n\r\n    // Two nested groups so tags can share the model's frame: `centered` carries the offset that\r\n    // moves the model's own origin to the scene origin, `group` carries the scale. A tag positioned\r\n    // with raw POI coordinates then lands in the same place the model's geometry does.\r\n    const group = new THREE.Group();\r\n    const centered = new THREE.Group();\r\n    centered.position.sub(center);\r\n\r\n    if (rotation) {\r\n      object.rotation.set(rotation.x, rotation.y, rotation.z);\r\n    }\r\n    // Which way is up. A choice someone made by hand always wins; otherwise, unless the model came\r\n    // with an orientation of its own, it is worked out from the geometry. Applied to the outer\r\n    // group, above both the model and the tags: they turn together, and every coordinate already\r\n    // stored - tag positions, the calibration - keeps meaning what it meant.\r\n    this.modelGroup = group;\r\n    this.modelUp = up ?? (rotation ? 'y' : this.detectModelUp(object, size));\r\n    group.quaternion.copy(this.uprightRotation(this.modelUp));\r\n\r\n    this.modelRoot = object;\r\n    this.modelWorldRadius = (size.length() / 2) * scale;\r\n    // The box above was measured before any rotation from the metadata was applied; with one, it\r\n    // has to be measured again to be the model as it actually sits.\r\n    this.buildSurfaceGrid(object, rotation ? new THREE.Box3().setFromObject(object) : box);\r\n    this.refreshTagVisibility();\r\n    // Marks the model for the depth pick, which renders this layer alone - so tags and the ghost\r\n    // itself cannot end up being what the cursor reports as the surface under it.\r\n    object.traverse((child) => child.layers.enable(ThreeJsService.PICK_LAYER));\r\n    centered.add(object);\r\n    centered.add(this.tagGroup);\r\n    centered.add(this.modelTagGroup);\r\n    group.add(centered);\r\n    group.scale.setScalar(scale);\r\n\r\n    this.scene.add(group);\r\n\r\n    // Tags registered before the model finished loading were sized against the old scale.\r\n    this.tagSprites.forEach((sprite) => this.scaleTagForModel(sprite));\r\n\r\n    this.adjustClippingPlanes((size.length() / 2) * scale);\r\n\r\n    if (cameraPosition) {\r\n      this.camera.position.set(cameraPosition.x, cameraPosition.y, cameraPosition.z);\r\n    } else {\r\n      this.camera.position.set(0, 5, 15);\r\n    }\r\n    this.controls.target.set(0, 0, 0);\r\n    this.controls.update();\r\n  }\r\n\r\n  /**\r\n   * Which of the model's axes is its vertical: 'y' when it already stands upright, or when it is\r\n   * not clear enough to act on.\r\n   *\r\n   * Models arrive in two conventions: Y up (glTF, and what this viewer assumes) and Z up (most CAD\r\n   * and scanning exports). A Z-up model loads lying on its side. Two independent cues say which\r\n   * axis is the vertical one, and both have to agree before anything is turned:\r\n   *\r\n   *  - Surface area. Floors and ceilings all face along the vertical, while walls are shared out\r\n   *    between the two horizontal axes, so the vertical usually collects the most area.\r\n   *  - Extent. A building is normally wider than it is tall, so the vertical is its shortest side.\r\n   *\r\n   * Either alone is wrong often enough to matter - a long corridor has more wall than floor, a\r\n   * tower is taller than it is wide - and turning a model that was fine is worse than leaving one\r\n   * that was not. A model that already has Y as its vertical is never touched.\r\n   */\r\n  private detectModelUp(object: THREE.Object3D, size: THREE.Vector3): ThreeJsModelUp {\r\n    const axes = ['x', 'y', 'z'] as const;\r\n    // Projected area facing each way along each axis: [positive, negative].\r\n    const area = { x: [0, 0], y: [0, 0], z: [0, 0] };\r\n\r\n    let triangleCount = 0;\r\n    object.updateMatrixWorld(true);\r\n    object.traverse((child: any) => {\r\n      const position = child.isMesh && child.geometry?.attributes?.position;\r\n      if (position) {\r\n        triangleCount += (child.geometry.index ? child.geometry.index.count : position.count) / 3;\r\n      }\r\n    });\r\n    if (triangleCount === 0) {\r\n      return 'y';\r\n    }\r\n    // A sample is plenty to see where the area lies, and keeps this cheap on models with millions\r\n    // of triangles.\r\n    const stride = Math.max(1, Math.ceil(triangleCount / 200000));\r\n\r\n    const a = new THREE.Vector3();\r\n    const b = new THREE.Vector3();\r\n    const c = new THREE.Vector3();\r\n    const normal = new THREE.Vector3();\r\n    object.traverse((child: any) => {\r\n      const position = child.isMesh && child.geometry?.attributes?.position;\r\n      if (!position) {\r\n        return;\r\n      }\r\n      const index = child.geometry.index;\r\n      const count = (index ? index.count : position.count) / 3;\r\n      for (let triangle = 0; triangle < count; triangle += stride) {\r\n        const offset = triangle * 3;\r\n        a.fromBufferAttribute(position, index ? index.getX(offset) : offset).applyMatrix4(child.matrixWorld);\r\n        b.fromBufferAttribute(position, index ? index.getX(offset + 1) : offset + 1).applyMatrix4(child.matrixWorld);\r\n        c.fromBufferAttribute(position, index ? index.getX(offset + 2) : offset + 2).applyMatrix4(child.matrixWorld);\r\n        // The cross product's length is twice the triangle's area, so its components are the\r\n        // area the triangle shows along each axis.\r\n        normal.crossVectors(b.sub(a), c.sub(a));\r\n        axes.forEach((axis) => {\r\n          area[axis][normal[axis] >= 0 ? 0 : 1] += Math.abs(normal[axis]);\r\n        });\r\n      }\r\n    });\r\n\r\n    const total = { x: area.x[0] + area.x[1], y: area.y[0] + area.y[1], z: area.z[0] + area.z[1] };\r\n    const byArea = axes.reduce((best, axis) => (total[axis] > total[best] ? axis : best), 'y' as typeof axes[number]);\r\n    const byExtent = axes.reduce((best, axis) => (size[axis] < size[best] ? axis : best), 'y' as typeof axes[number]);\r\n    if (byArea === 'y' || byArea !== byExtent || total[byArea] < 1.25 * total.y) {\r\n      return 'y';\r\n    }\r\n\r\n    // Which way along that axis is up. Roofs and ground make an outdoor model face mostly upward,\r\n    // which settles it; indoors floors and ceilings balance out, and the convention - positive is\r\n    // up - is the better guess.\r\n    const [positive, negative] = area[byArea];\r\n    const up = `${negative > 0.65 * (positive + negative) ? '-' : ''}${byArea}` as ThreeJsModelUp;\r\n    console.info(`ThreeJsService: this model's vertical axis looks like ${up}, not y - standing it upright.`);\r\n    return up;\r\n  }\r\n\r\n  /** The rotation that brings the given model axis to point up. */\r\n  private uprightRotation(up: ThreeJsModelUp): THREE.Quaternion {\r\n    const axis = new THREE.Vector3();\r\n    axis[up.replace('-', '') as 'x' | 'y' | 'z'] = up.startsWith('-') ? -1 : 1;\r\n    return new THREE.Quaternion().setFromUnitVectors(axis, new THREE.Vector3(0, 1, 0));\r\n  }\r\n\r\n  /** Which of the model's axes is currently treated as up, whether chosen or worked out. */\r\n  getModelUp(): ThreeJsModelUp {\r\n    return this.modelUp;\r\n  }\r\n\r\n  /**\r\n   * Turns the model so the given axis points up, at once.\r\n   *\r\n   * The model and its tags turn as one, so nothing stored has to be recomputed. The caller is\r\n   * expected to store the choice, or the next load goes back to working it out.\r\n   */\r\n  setModelUp(up: ThreeJsModelUp): void {\r\n    this.modelUp = up;\r\n    this.modelGroup?.quaternion.copy(this.uprightRotation(up));\r\n  }\r\n\r\n  /**\r\n   * Keeps the drawing buffer and camera matched to the canvas as it is resized.\r\n   *\r\n   * renderer.setSize() writes explicit pixel width/height into the canvas's style, overriding the\r\n   * 100%/100% it starts with. Without this, the canvas keeps whatever size it had at startup: hiding\r\n   * the top menu grows the container, the canvas does not follow, and the strip that opens up shows\r\n   * the page behind it instead of the scene.\r\n   *\r\n   * The parent is observed rather than the canvas, because resizing the canvas is what this reacts\r\n   * to - watching the element we resize would retrigger the observer.\r\n   */\r\n  private observeCanvasResize(canvas: HTMLCanvasElement): void {\r\n    const container = canvas.parentElement;\r\n    if (!container || typeof ResizeObserver === 'undefined') {\r\n      return;\r\n    }\r\n\r\n    this.canvasResizeObserver = new ResizeObserver(() => {\r\n      const width = container.clientWidth;\r\n      const height = container.clientHeight;\r\n      if (width === 0 || height === 0) {\r\n        return;\r\n      }\r\n      this.camera.aspect = width / height;\r\n      this.camera.updateProjectionMatrix();\r\n      this.renderer.setSize(width, height);\r\n      this.updateMeasureLineResolution();\r\n    });\r\n    this.canvasResizeObserver.observe(container);\r\n  }\r\n\r\n  /**\r\n   * Starts the alignment walkthrough: pick a tag, then click where it really is, three times.\r\n   *\r\n   * Existing tags are the correspondences - they already carry the stored coordinate, so the person\r\n   * only has to supply the matching spot on the model. No new records are written; nothing is\r\n   * applied until solveAlignmentFromPairs() succeeds.\r\n   */\r\n  startTagAlignment(): void {\r\n    // One pointer mode at a time, the same rule startMeasuring() applies the other way round.\r\n    if (this.measuring) {\r\n      this.cancelMeasuring();\r\n    }\r\n    this.aligning = true;\r\n    this.alignmentPairs = [];\r\n    this.alignmentSource = null;\r\n    // While calibrating, the tags from elsewhere are all shown - including the ones off the model,\r\n    // which are exactly the ones a calibration is for.\r\n    this.refreshTagVisibility();\r\n    if (this.renderer) {\r\n      this.renderer.domElement.style.cursor = 'crosshair';\r\n    }\r\n    this.alignmentProgress$.next({ pairs: 0, awaiting: 'tag' });\r\n  }\r\n\r\n  cancelTagAlignment(): void {\r\n    const wasAligning = this.aligning;\r\n    this.aligning = false;\r\n    this.alignmentPairs = [];\r\n    this.alignmentSource = null;\r\n    this.pendingPreviewEvent = null;\r\n    this.removePlacementPreview();\r\n    this.refreshTagVisibility();\r\n    if (this.renderer) {\r\n      this.renderer.domElement.style.cursor = 'default';\r\n    }\r\n    this.alignmentProgress$.next({ pairs: 0, awaiting: null });\r\n    if (wasAligning) {\r\n      this.alignmentCancelled$.next();\r\n    }\r\n  }\r\n\r\n  isAligningTags(): boolean {\r\n    return this.aligning;\r\n  }\r\n\r\n  /**\r\n   * Whether the pointer should be showing the placement ghost.\r\n   *\r\n   * True while placing a tag, and while calibrating once a tag has been picked - that second click\r\n   * is the same question (\"where on the model?\") and deserves the same aiming aid. Not true for the\r\n   * first half of a pair, which is a click on a tag, not on the model.\r\n   */\r\n  private isPreviewingPlacement(): boolean {\r\n    return this.placingTag || this.measuring || (this.aligning && !!this.alignmentSource);\r\n  }\r\n\r\n  /** Whether a tag is currently registered for this element. */\r\n  hasTag(elementId: string): boolean {\r\n    return this.tagSprites.has(elementId);\r\n  }\r\n\r\n  /** How many tags are on show - the ones a person could actually click. */\r\n  getTagCount(): number {\r\n    let visible = 0;\r\n    this.tagSprites.forEach((sprite) => {\r\n      if (sprite.visible) {\r\n        visible += 1;\r\n      }\r\n    });\r\n    return visible;\r\n  }\r\n\r\n  /**\r\n   * Solves and applies the alignment collected so far, returning it so the caller can persist it.\r\n   *\r\n   * Returns null when the three tags turn out to be collinear, in which case nothing is applied and\r\n   * the walkthrough stays open for the person to pick a better third point.\r\n   */\r\n  solveAlignmentFromPairs(): ThreeJsAlignment | null {\r\n    const up = new THREE.Vector3();\r\n    up[this.modelUp.replace('-', '') as 'x' | 'y' | 'z'] = this.modelUp.startsWith('-') ? -1 : 1;\r\n    const alignment = solveThreeJsAlignment(this.alignmentPairs, up);\r\n    if (!alignment) {\r\n      return null;\r\n    }\r\n    // Out of calibrating mode first: applying the result re-decides which tags show, and from here\r\n    // on that is the ones on the model again, not all of them.\r\n    this.aligning = false;\r\n    this.applyAlignmentKeepingOwnTags(alignment);\r\n    this.pendingPreviewEvent = null;\r\n    this.removePlacementPreview();\r\n    this.renderer.domElement.style.cursor = 'default';\r\n    this.alignmentProgress$.next({ pairs: this.alignmentPairs.length, awaiting: null });\r\n    return alignment;\r\n  }\r\n\r\n  /**\r\n   * Applies a new calibration while keeping every tag placed in this model exactly where it is.\r\n   *\r\n   * A calibration is worked out for the tags that came from elsewhere. The model's own tags were put\r\n   * where they are by someone clicking the model, so they must not follow it. Their stored\r\n   * coordinates are rewritten instead: into the shared space as the new calibration defines it.\r\n   * That is also what makes them comparable with other visits from here on - a tag placed before\r\n   * the model was calibrated was in the model's own coordinates, visible nowhere else.\r\n   *\r\n   * The rewritten tags are kept for the caller to store; see takeRebasedTags().\r\n   */\r\n  private applyAlignmentKeepingOwnTags(alignment: ThreeJsAlignment): void {\r\n    const own = [...this.tagSprites.values()].filter((sprite) => this.isOwnedByVisit(sprite));\r\n    // Where each one is now, in the space the model sits in, and how its parent was turned.\r\n    const placed = own.map((sprite) => {\r\n      sprite.parent?.updateMatrix();\r\n      return {\r\n        sprite,\r\n        position: sprite.position.clone().applyMatrix4(sprite.parent?.matrix ?? new THREE.Matrix4()),\r\n        turn: sprite.parent?.quaternion.clone() ?? new THREE.Quaternion(),\r\n      };\r\n    });\r\n\r\n    this.setTagAlignment(alignment);\r\n\r\n    const inverse = this.tagGroup.matrix.clone().invert();\r\n    const unturn = this.tagGroup.quaternion.clone().invert();\r\n    this.rebasedTags = placed.map(({ sprite, position, turn }) => {\r\n      sprite.position.copy(position.applyMatrix4(inverse));\r\n      sprite.userData.frame = null;\r\n      this.parentTag(sprite);\r\n      this.scaleTagForModel(sprite);\r\n      const rotation = unturn.clone().multiply(turn);\r\n      return {\r\n        id: sprite.name,\r\n        position: { x: sprite.position.x, y: sprite.position.y, z: sprite.position.z },\r\n        rotateDirection: ({ x, y, z }) => {\r\n          const turned = new THREE.Vector3(x, y, z).applyQuaternion(rotation);\r\n          return { x: turned.x, y: turned.y, z: turned.z };\r\n        },\r\n      };\r\n    });\r\n    this.refreshTagVisibility();\r\n  }\r\n\r\n  /** Hands over the tags the last calibration rewrote, once, for them to be stored. */\r\n  takeRebasedTags(): ThreeJsRebasedTag[] {\r\n    const rebased = this.rebasedTags;\r\n    this.rebasedTags = [];\r\n    return rebased;\r\n  }\r\n\r\n  /**\r\n   * Chooses the tag for the pair being matched by id, instead of by clicking it.\r\n   *\r\n   * Clicking a tag supposes it can be found. On a model that has never been calibrated the tags may\r\n   * sit far from it, or all on top of one another; a list has neither problem.\r\n   */\r\n  selectAlignmentTag(elementId: string): boolean {\r\n    const sprite = this.tagSprites.get(elementId);\r\n    if (!this.aligning || this.alignmentSource || !sprite || !this.calibrationCandidates().includes(sprite)) {\r\n      return false;\r\n    }\r\n    this.setAlignmentSource(sprite);\r\n    return true;\r\n  }\r\n\r\n  private setAlignmentSource(sprite: THREE.Object3D): void {\r\n    // The sprite's own position is the stored coordinate, untouched by any alignment already\r\n    // applied - that transform lives on the group, not on the sprite.\r\n    const stored = sprite.position;\r\n    this.alignmentSource = { x: stored.x, y: stored.y, z: stored.z };\r\n    this.alignmentSourceTagId = sprite.name;\r\n    this.alignmentProgress$.next({\r\n      pairs: this.alignmentPairs.length,\r\n      awaiting: 'point',\r\n      tagId: sprite.name,\r\n    });\r\n  }\r\n\r\n  /** Handles a click while the alignment walkthrough is running. */\r\n  private handleAlignmentClick(event: MouseEvent): void {\r\n    if (!this.alignmentSource) {\r\n      // First half of a pair: which tag are we talking about?\r\n      const hit = this.raycaster.intersectObjects(this.calibrationCandidates(), false)[0];\r\n      if (!hit) {\r\n        return;\r\n      }\r\n      this.setAlignmentSource(hit.object);\r\n      return;\r\n    }\r\n\r\n    // Second half: where that tag actually belongs on the model.\r\n    const target = this.pickAlignmentTarget(event);\r\n    if (!target) {\r\n      return;\r\n    }\r\n    this.alignmentPairs.push({ tagId: this.alignmentSourceTagId, source: this.alignmentSource, target });\r\n    this.alignmentSource = null;\r\n    // The ghost belongs to the click that just happened; the next half is a click on a tag.\r\n    this.pendingPreviewEvent = null;\r\n    this.removePlacementPreview();\r\n    this.alignmentProgress$.next({\r\n      pairs: this.alignmentPairs.length,\r\n      // Done at three, or sooner when there are no more tags to match: fewer pairs still calibrate,\r\n      // only less completely.\r\n      awaiting: this.alignmentPairs.length >= 3 || this.calibrationCandidates().length === 0 ? null : 'tag',\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Starts a measurement: every click on the model adds a point, and each pair of consecutive\r\n   * points is a measured segment.\r\n   *\r\n   * It ends through finishMeasuring() or cancelMeasuring() rather than on its own after two points,\r\n   * because a measurement may have several segments - the same as Matterport's, whose results are\r\n   * stored as a list of distances.\r\n   */\r\n  startMeasuring(): void {\r\n    // One pointer mode at a time: a click cannot be both a tag position and a measured point.\r\n    this.cancelTagPlacement();\r\n    if (this.aligning) {\r\n      this.cancelTagAlignment();\r\n    }\r\n    this.clearMeasurement();\r\n    if (this.measureGroup.parent !== this.tagGroup) {\r\n      this.tagGroup.add(this.measureGroup);\r\n    }\r\n    this.measuring = true;\r\n    if (this.renderer) {\r\n      this.renderer.domElement.style.cursor = 'crosshair';\r\n    }\r\n    this.measurementProgress$.next({ points: 0, distances: [] });\r\n  }\r\n\r\n  /**\r\n   * Abandons the measurement and removes what was drawn.\r\n   *\r\n   * Also what clears a finished measurement off the model once its form is saved or closed, which\r\n   * is why it only reports an abandonment when one was actually in progress.\r\n   */\r\n  cancelMeasuring(): void {\r\n    const wasMeasuring = this.measuring;\r\n    this.measuring = false;\r\n    this.pendingPreviewEvent = null;\r\n    this.removePlacementPreview();\r\n    this.clearMeasurement();\r\n    // Forgotten here so that a form opened later cannot pick up a measurement already dealt with.\r\n    this.lastMeasurement = null;\r\n    if (this.renderer) {\r\n      this.renderer.domElement.style.cursor = 'default';\r\n    }\r\n    if (wasMeasuring) {\r\n      this.measurementProgress$.next(null);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Ends the measurement and returns it, or null when there are not yet two points to measure\r\n   * between - in which case measuring simply carries on.\r\n   *\r\n   * The drawing stays on the model so it is still visible while the person names the measurement;\r\n   * cancelMeasuring() takes it away afterwards.\r\n   */\r\n  finishMeasuring(): ThreeJsMeasurement | null {\r\n    if (!this.measuring || this.measurePoints.length < 2) {\r\n      return null;\r\n    }\r\n    this.measuring = false;\r\n    this.pendingPreviewEvent = null;\r\n    this.removePlacementPreview();\r\n    this.updateMeasureRubberBand(null);\r\n    this.renderer.domElement.style.cursor = 'default';\r\n\r\n    this.lastMeasurement = {\r\n      points: this.measurePoints.map((point) => ({ x: point.x, y: point.y, z: point.z })),\r\n      distances: this.measureDistances(),\r\n      screenshot: this.captureMeasurementScreenshot(),\r\n    };\r\n    return this.lastMeasurement;\r\n  }\r\n\r\n  isMeasuring(): boolean {\r\n    return this.measuring;\r\n  }\r\n\r\n  /** The measurement finishMeasuring() last produced, for the form that saves it. */\r\n  getLastMeasurement(): ThreeJsMeasurement | null {\r\n    return this.lastMeasurement;\r\n  }\r\n\r\n  /** Metres between consecutive points. Tag space is in metres, so no conversion is involved. */\r\n  private measureDistances(): number[] {\r\n    const distances: number[] = [];\r\n    for (let index = 1; index < this.measurePoints.length; index += 1) {\r\n      const distance = this.measurePoints[index - 1].distanceTo(this.measurePoints[index]);\r\n      // Two decimals, the precision Matterport's own measurements are stored with.\r\n      distances.push(Math.round(distance * 100) / 100);\r\n    }\r\n    return distances;\r\n  }\r\n\r\n  private addMeasurePoint(point: THREE.Vector3): void {\r\n    const previous = this.measurePoints[this.measurePoints.length - 1];\r\n    this.measurePoints.push(point);\r\n\r\n    const marker = new THREE.Sprite(\r\n      new THREE.SpriteMaterial({\r\n        map: this.createTagTexture(ThreeJsService.MEASURE_COLOR),\r\n        depthTest: false,\r\n        transparent: true,\r\n        // Sized against the viewport, not the model: measuring is done zoomed right in, where\r\n        // anything sized in metres would cover the very thing being measured.\r\n        sizeAttenuation: false,\r\n      })\r\n    );\r\n    marker.scale.set(0.022, 0.022, 1);\r\n    marker.position.copy(point);\r\n    marker.renderOrder = 1001;\r\n    this.measureGroup.add(marker);\r\n\r\n    if (previous) {\r\n      this.measureGroup.add(this.createMeasureLine(previous, point));\r\n\r\n      const distance = Math.round(previous.distanceTo(point) * 100) / 100;\r\n      const label = new THREE.Sprite(\r\n        new THREE.SpriteMaterial({\r\n          map: this.createMeasureLabelTexture(`${distance.toFixed(2)} m`),\r\n          depthTest: false,\r\n          transparent: true,\r\n          sizeAttenuation: false,\r\n        })\r\n      );\r\n      label.scale.set(0.15, 0.05, 1);\r\n      label.position.copy(previous).add(point).multiplyScalar(0.5);\r\n      label.renderOrder = 1002;\r\n      this.measureGroup.add(label);\r\n    }\r\n\r\n    this.measurementProgress$.next({\r\n      points: this.measurePoints.length,\r\n      distances: this.measureDistances(),\r\n    });\r\n  }\r\n\r\n  /**\r\n   * A segment with a width in pixels.\r\n   *\r\n   * WebGL's own lines are one pixel wide whatever is asked for, which all but disappears over a\r\n   * photographic texture. This kind is drawn as screen-facing geometry, so the width holds.\r\n   */\r\n  private createMeasureLine(from: THREE.Vector3, to: THREE.Vector3): any {\r\n    const geometry = new LineGeometry();\r\n    geometry.setPositions([from.x, from.y, from.z, to.x, to.y, to.z]);\r\n    const material = new LineMaterial({\r\n      color: new THREE.Color(ThreeJsService.MEASURE_COLOR).getHex(),\r\n      linewidth: 3,\r\n      depthTest: false,\r\n      transparent: true,\r\n    });\r\n    const size = this.renderer.getSize(new THREE.Vector2());\r\n    material.resolution.set(size.x, size.y);\r\n    const line = new Line2(geometry, material);\r\n    line.renderOrder = 1000;\r\n    return line;\r\n  }\r\n\r\n  /** Line widths are in pixels, which the material can only honour if it knows the canvas size. */\r\n  private updateMeasureLineResolution(): void {\r\n    if (!this.renderer) {\r\n      return;\r\n    }\r\n    const size = this.renderer.getSize(new THREE.Vector2());\r\n    this.measureGroup.children.forEach((child: any) => {\r\n      if (child.material?.resolution) {\r\n        child.material.resolution.set(size.x, size.y);\r\n      }\r\n    });\r\n  }\r\n\r\n  /** Stretches a segment from the last point to the pointer, or hides it when given null. */\r\n  private updateMeasureRubberBand(target: THREE.Vector3 | null): void {\r\n    const last = this.measurePoints[this.measurePoints.length - 1];\r\n    if (!this.measuring || !last || !target) {\r\n      if (this.measureRubberBand) {\r\n        this.measureRubberBand.visible = false;\r\n      }\r\n      return;\r\n    }\r\n    if (!this.measureRubberBand) {\r\n      this.measureRubberBand = this.createMeasureLine(last, target);\r\n      this.measureRubberBand.material.opacity = 0.6;\r\n      this.measureGroup.add(this.measureRubberBand);\r\n    }\r\n    this.measureRubberBand.geometry.setPositions([\r\n      last.x, last.y, last.z,\r\n      target.x, target.y, target.z,\r\n    ]);\r\n    this.measureRubberBand.visible = true;\r\n  }\r\n\r\n  private createMeasureLabelTexture(text: string): THREE.CanvasTexture {\r\n    const canvas = document.createElement('canvas');\r\n    canvas.width = 384;\r\n    canvas.height = 128;\r\n    const context = canvas.getContext('2d');\r\n\r\n    const radius = 28;\r\n    context.fillStyle = 'rgba(0, 0, 0, 0.78)';\r\n    context.beginPath();\r\n    context.moveTo(radius, 8);\r\n    context.arcTo(canvas.width - 8, 8, canvas.width - 8, canvas.height - 8, radius);\r\n    context.arcTo(canvas.width - 8, canvas.height - 8, 8, canvas.height - 8, radius);\r\n    context.arcTo(8, canvas.height - 8, 8, 8, radius);\r\n    context.arcTo(8, 8, canvas.width - 8, 8, radius);\r\n    context.closePath();\r\n    context.fill();\r\n\r\n    context.fillStyle = '#FFFFFF';\r\n    context.font = 'bold 60px sans-serif';\r\n    context.textAlign = 'center';\r\n    context.textBaseline = 'middle';\r\n    context.fillText(text, canvas.width / 2, canvas.height / 2 + 4);\r\n\r\n    return new THREE.CanvasTexture(canvas);\r\n  }\r\n\r\n  /** Removes everything drawn for a measurement and forgets its points. */\r\n  private clearMeasurement(): void {\r\n    [...this.measureGroup.children].forEach((child: any) => {\r\n      this.measureGroup.remove(child);\r\n      child.geometry?.dispose?.();\r\n      child.material?.map?.dispose?.();\r\n      child.material?.dispose?.();\r\n    });\r\n    this.measureRubberBand = undefined;\r\n    this.measurePoints = [];\r\n  }\r\n\r\n  /**\r\n   * A picture of the scene with the measurement on it, as Matterport attaches to its own.\r\n   *\r\n   * Tags are left out, as they are there: the picture is about the measurement. It is taken straight\r\n   * after a render because the drawing buffer is only guaranteed to hold the frame until the\r\n   * browser presents it, and scaled down since it is uploaded and shown as a thumbnail.\r\n   */\r\n  private captureMeasurementScreenshot(): string {\r\n    const hidden: THREE.Sprite[] = [];\r\n    this.tagSprites.forEach((sprite) => {\r\n      if (sprite.visible) {\r\n        sprite.visible = false;\r\n        hidden.push(sprite);\r\n      }\r\n    });\r\n\r\n    this.renderer.render(this.scene, this.camera);\r\n    const source = this.renderer.domElement;\r\n    const scale = Math.min(1, 800 / source.width, 600 / source.height);\r\n    const canvas = document.createElement('canvas');\r\n    canvas.width = Math.max(1, Math.round(source.width * scale));\r\n    canvas.height = Math.max(1, Math.round(source.height * scale));\r\n    canvas.getContext('2d').drawImage(source, 0, 0, canvas.width, canvas.height);\r\n\r\n    hidden.forEach((sprite) => {\r\n      sprite.visible = true;\r\n    });\r\n    return canvas.toDataURL('image/jpeg', 0.85);\r\n  }\r\n\r\n  /** Arms tag placement: the next click on the model drops a tag instead of being ignored. */\r\n  startTagPlacement(poiType: PoiType | null = null): void {\r\n    this.placingTag = true;\r\n    this.placementPoiType = poiType;\r\n    this.pendingTagPlacement = null;\r\n    if (this.renderer) {\r\n      this.renderer.domElement.style.cursor = 'crosshair';\r\n    }\r\n  }\r\n\r\n  /** Leaves placement mode without placing anything. */\r\n  cancelTagPlacement(): void {\r\n    this.placingTag = false;\r\n    this.pendingTagPlacement = null;\r\n    this.pendingPreviewEvent = null;\r\n    this.removePlacementPreview();\r\n    if (this.renderer) {\r\n      this.renderer.domElement.style.cursor = 'default';\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Shows a translucent tag under the cursor while placing, so the spot is visible before commiting.\r\n   *\r\n   * Matterport does this with a tag that follows the pointer; the equivalent here is a preview\r\n   * sprite that gets removed the moment the real tag takes its place.\r\n   */\r\n  private updatePlacementPreview(event: MouseEvent): void {\r\n    const position = this.pickPointOnGpu(event);\r\n    if (!position) {\r\n      this.removePlacementPreview();\r\n      this.updateMeasureRubberBand(null);\r\n      this.renderer.domElement.style.cursor = 'not-allowed';\r\n      return;\r\n    }\r\n\r\n    this.renderer.domElement.style.cursor = 'crosshair';\r\n    if (!this.placementPreview) {\r\n      this.placementPreview = new THREE.Sprite(\r\n        new THREE.SpriteMaterial({\r\n          map: this.createTagTexture('#9E9E9E'),\r\n          depthTest: false,\r\n          transparent: true,\r\n          opacity: 0.6,\r\n        })\r\n      );\r\n      this.placementPreview.renderOrder = 999;\r\n      this.tagGroup.add(this.placementPreview);\r\n      this.scaleTagForModel(this.placementPreview);\r\n    }\r\n    this.placementPreview.position.copy(position);\r\n    this.updateMeasureRubberBand(position);\r\n  }\r\n\r\n  /**\r\n   * The point under the cursor, read from the depth buffer instead of raycast, in tag space.\r\n   *\r\n   * A raycast walks every triangle of the mesh it hits: on a captured model that is millions of\r\n   * them, tens of milliseconds, every time the pointer moves. Coalescing to one per frame did not\r\n   * help, because the cost is the pick itself - it simply became one slow frame instead of several.\r\n   *\r\n   * Rendering the model's depth into a single pixel under the cursor answers the same question on\r\n   * the GPU in constant time, whatever the model's size. The camera's view offset is what narrows\r\n   * the whole image down to that one pixel, so the value read back is the depth the cursor is over.\r\n   *\r\n   * Used for the ghost only. The click that actually places a tag still raycasts: it is one pick,\r\n   * its cost does not matter, and it yields the surface normal, which depth alone cannot give.\r\n   */\r\n  private pickPointOnGpu(event: MouseEvent): THREE.Vector3 | null {\r\n    if (!this.modelRoot || !this.renderer || !this.camera) {\r\n      return null;\r\n    }\r\n\r\n    if (!this.pickTarget) {\r\n      this.pickTarget = new THREE.WebGLRenderTarget(1, 1);\r\n      this.pickCamera = new THREE.PerspectiveCamera();\r\n      this.pickCamera.layers.set(ThreeJsService.PICK_LAYER);\r\n      this.pickDepthMaterial = new THREE.MeshDepthMaterial({\r\n        depthPacking: THREE.RGBADepthPacking,\r\n      });\r\n    }\r\n\r\n    const rect = this.renderer.domElement.getBoundingClientRect();\r\n    const x = event.clientX - rect.left;\r\n    const y = event.clientY - rect.top;\r\n    if (x < 0 || y < 0 || x > rect.width || y > rect.height) {\r\n      return null;\r\n    }\r\n\r\n    this.pickCamera.copy(this.camera);\r\n    this.pickCamera.layers.set(ThreeJsService.PICK_LAYER);\r\n    // Renders the one pixel the cursor is over as if it were the whole image - offset by half a\r\n    // pixel so the cursor sits at that pixel's centre, which is where NDC (0, 0) lands.\r\n    this.pickCamera.setViewOffset(rect.width, rect.height, x - 0.5, y - 0.5, 1, 1);\r\n\r\n    // Where the model is not, the pixel must read as \"nothing\", so it is cleared to white - a value\r\n    // no real depth packs to. Two things would otherwise paint over that: the default black clear,\r\n    // which decodes as depth 0 (a hit against the lens), and the scene background, which three.js\r\n    // draws in place of the clear colour whenever one is set.\r\n    const previousClearColor = this.renderer.getClearColor(new THREE.Color());\r\n    const previousClearAlpha = this.renderer.getClearAlpha();\r\n    const previousTarget = this.renderer.getRenderTarget();\r\n    const previousBackground = this.scene.background;\r\n\r\n    this.scene.background = null;\r\n    this.scene.overrideMaterial = this.pickDepthMaterial;\r\n    this.renderer.setClearColor(0xffffff, 1);\r\n    this.renderer.setRenderTarget(this.pickTarget);\r\n    this.renderer.clear();\r\n    this.renderer.render(this.scene, this.pickCamera);\r\n\r\n    this.renderer.readRenderTargetPixels(this.pickTarget, 0, 0, 1, 1, this.pickPixel);\r\n\r\n    this.renderer.setRenderTarget(previousTarget);\r\n    this.renderer.setClearColor(previousClearColor, previousClearAlpha);\r\n    this.scene.overrideMaterial = null;\r\n    this.scene.background = previousBackground;\r\n\r\n    const [r, g, b, a] = this.pickPixel;\r\n    if (r === 255 && g === 255 && b === 255 && a === 255) {\r\n      return null;\r\n    }\r\n\r\n    // The inverse of three's packDepthToRGBA, which stores the value itself in alpha and ever finer\r\n    // fractions of it in blue, green and red - alpha is the most significant byte, not red. Read the\r\n    // other way round, the result is mostly the low-order noise, often near zero, which unprojects\r\n    // onto the near plane: a ghost pressed against the lens, filling the whole screen.\r\n    const downscale = 255 / 256;\r\n    const depth =\r\n      (r / 255) * downscale / (256 * 256 * 256) +\r\n      (g / 255) * downscale / (256 * 256) +\r\n      (b / 255) * downscale / 256 +\r\n      (a / 255) * downscale;\r\n\r\n    // NDC x and y are zero because the pixel read is the centre of that one-pixel image - which only\r\n    // holds while the view offset is in effect. Clearing it first would unproject through the full\r\n    // view instead, landing the point on the ray through the middle of the screen. The offset is\r\n    // simply replaced by the next pick, so it is never cleared.\r\n    const world = new THREE.Vector3(0, 0, depth * 2 - 1).unproject(this.pickCamera);\r\n    this.tagGroup.updateWorldMatrix(true, false);\r\n    return this.tagGroup.worldToLocal(world);\r\n  }\r\n\r\n  private removePlacementPreview(): void {\r\n    if (!this.placementPreview) {\r\n      return;\r\n    }\r\n    this.tagGroup.remove(this.placementPreview);\r\n    this.placementPreview.material.map?.dispose();\r\n    this.placementPreview.material.dispose();\r\n    this.placementPreview = undefined;\r\n  }\r\n\r\n  /** Shows or hides one tag, leaving it registered so it can be brought back without reloading. */\r\n  setTagVisibility(elementId: string, visible: boolean): void {\r\n    const sprite = this.tagSprites.get(elementId);\r\n    if (sprite) {\r\n      sprite.visible = visible;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Shows only tags of the given types, hiding the rest.\r\n   *\r\n   * Passing null shows everything - the \"no filter\" state, distinct from an empty array, which is a\r\n   * filter that happens to match nothing.\r\n   */\r\n  setVisibleTagTypes(types: PoiType[] | null): void {\r\n    this.visibleTagTypes = types;\r\n    this.tagSprites.forEach((sprite) => this.applyTagVisibility(sprite));\r\n  }\r\n\r\n  /** Says which capture is on screen, so the tags placed in it can be told from the rest. */\r\n  setCurrentCapture(captureID: string | null): void {\r\n    this.currentCaptureID = captureID;\r\n    this.tagSprites.forEach((sprite) => {\r\n      this.parentTag(sprite);\r\n      this.applyTagVisibility(sprite);\r\n    });\r\n  }\r\n\r\n  /** Every tag registered in the scene, shown or not. */\r\n  getTags(): {\r\n    id: string;\r\n    label: string | null;\r\n    poiType: PoiType | null;\r\n    visible: boolean;\r\n    /** Whether the calibration walkthrough can use it. */\r\n    calibratable: boolean;\r\n  }[] {\r\n    const candidates = new Set(this.calibrationCandidates());\r\n    return [...this.tagSprites.values()].map((sprite) => ({\r\n      id: sprite.name,\r\n      label: sprite.userData.label ?? null,\r\n      poiType: sprite.userData.poiType ?? null,\r\n      visible: sprite.visible,\r\n      calibratable: candidates.has(sprite),\r\n    }));\r\n  }\r\n\r\n  /**\r\n   * How far the tags from elsewhere sit from the model, measured in model radii. Null without both.\r\n   *\r\n   * Before a model is calibrated those tags are wherever their own coordinates put them, which for\r\n   * a model with a different origin can be a long way off - too far to find, let alone click.\r\n   */\r\n  getTagDistanceFromModel(): number | null {\r\n    if (!this.modelRoot || !this.modelWorldRadius) {\r\n      return null;\r\n    }\r\n    const centroid = new THREE.Vector3();\r\n    const candidates = this.calibrationCandidates();\r\n    candidates.forEach((sprite) => centroid.add(sprite.getWorldPosition(new THREE.Vector3())));\r\n    const count = candidates.length;\r\n    if (count === 0) {\r\n      return null;\r\n    }\r\n    // The model is centred on the world origin when it is placed.\r\n    return centroid.divideScalar(count).length() / this.modelWorldRadius;\r\n  }\r\n\r\n  /**\r\n   * Hangs a tag from the group its coordinates belong to: outside the calibration when they are in\r\n   * this model's own coordinates, under it otherwise.\r\n   */\r\n  private parentTag(sprite: THREE.Object3D): void {\r\n    const parent = sprite.userData.frame === 'model' && this.isOwnedByVisit(sprite)\r\n      ? this.modelTagGroup\r\n      : this.tagGroup;\r\n    if (sprite.parent !== parent) {\r\n      parent.add(sprite);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * The tags a calibration can be worked out from: those that came from somewhere else, whether or\r\n   * not they are on show - before calibrating, most of them will not be.\r\n   *\r\n   * Tags placed in this model are where they are because someone clicked there; matching them to\r\n   * \"where they really are\" would be circular. A tag in another model's own coordinates cannot be\r\n   * placed here at all. And a tag already used in this calibration cannot be used again - two\r\n   * pairs from one tag carry no more than one.\r\n   */\r\n  private calibrationCandidates(): THREE.Object3D[] {\r\n    const used = new Set(this.alignmentPairs.map((pair) => pair.tagId));\r\n    return [...this.tagSprites.values()].filter((sprite) =>\r\n      sprite.parent === this.tagGroup\r\n      && sprite.userData.frame !== 'model'\r\n      && !this.isOwnedByVisit(sprite)\r\n      && !used.has(sprite.name));\r\n  }\r\n\r\n  /** How many tags there are to calibrate with, not counting those already used. */\r\n  getCalibrationCandidateCount(): number {\r\n    return this.calibrationCandidates().length;\r\n  }\r\n\r\n  /**\r\n   * How many tags from elsewhere are not on this model, and so not shown on it.\r\n   *\r\n   * On a model that has not been calibrated, this is what suggests it should be: the tags are out\r\n   * there, just not where the model is.\r\n   */\r\n  getOffModelTagCount(): number {\r\n    return this.calibrationCandidates().filter((sprite) => !this.isOnModel(sprite)).length;\r\n  }\r\n\r\n  /** Whether the tag was placed in the visit on screen. */\r\n  private isOwnedByVisit(sprite: THREE.Object3D): boolean {\r\n    return !!sprite.userData.originCaptureID\r\n      && sprite.userData.originCaptureID === this.currentCaptureID;\r\n  }\r\n\r\n  /**\r\n   * A tag shows when its type is not filtered out and it belongs on this model.\r\n   *\r\n   * One place decides, because the two used to set `visible` separately and whichever ran last\r\n   * undid the other.\r\n   */\r\n  private applyTagVisibility(sprite: THREE.Object3D): void {\r\n    const typeAllowed = this.visibleTagTypes === null\r\n      || this.visibleTagTypes.includes(sprite.userData.poiType);\r\n    sprite.visible = typeAllowed && this.belongsOnThisModel(sprite);\r\n  }\r\n\r\n  /**\r\n   * Whether a tag has a place on this model.\r\n   *\r\n   * Every tag of the space is offered to every model - there is one set of tags, not one per model.\r\n   * What a model shows of it is the part that sits on the model.\r\n   */\r\n  private belongsOnThisModel(sprite: THREE.Object3D): boolean {\r\n    // Placed here by a click on this very surface.\r\n    if (this.isOwnedByVisit(sprite)) {\r\n      return true;\r\n    }\r\n    // Placed in another model before that one was calibrated: its coordinates are that model's own\r\n    // and say nothing about where it would be in this one.\r\n    if (sprite.userData.frame === 'model') {\r\n      return false;\r\n    }\r\n    // Calibrating is matching tags to where they belong, so they all have to be on offer.\r\n    if (this.aligning) {\r\n      return true;\r\n    }\r\n    return this.isOnModel(sprite);\r\n  }\r\n\r\n  /** Whether a tag, drawn where its coordinates and the calibration put it, sits on the model. */\r\n  private isOnModel(sprite: THREE.Object3D): boolean {\r\n    if (!this.surfaceCells) {\r\n      // No model to be on yet.\r\n      return false;\r\n    }\r\n    const parent = sprite.parent ?? this.tagGroup;\r\n    parent.updateMatrix();\r\n    // The grid is in the model's own units; the calibration's scale is how many of those a metre is.\r\n    const reach = ThreeJsService.ON_MODEL_METRES * (parent.scale.x || 1);\r\n    return this.isNearSurface(sprite.position.clone().applyMatrix4(parent.matrix), reach);\r\n  }\r\n\r\n  /** Re-decides every tag's visibility: the model, the calibration or the mode changed. */\r\n  private refreshTagVisibility(): void {\r\n    this.tagSprites.forEach((sprite) => this.applyTagVisibility(sprite));\r\n  }\r\n\r\n  private surfaceKey(x: number, y: number, z: number): number {\r\n    const span = ThreeJsService.SURFACE_GRID_SPAN;\r\n    const pad = ThreeJsService.SURFACE_GRID_PAD;\r\n    const [i, j, k] = [x + pad, y + pad, z + pad];\r\n    if (i < 0 || j < 0 || k < 0 || i >= span || j >= span || k >= span) {\r\n      return -1;\r\n    }\r\n    return i + span * (j + span * k);\r\n  }\r\n\r\n  /**\r\n   * Lays the grid over the model's surface.\r\n   *\r\n   * Runs once per model, in one pass over its triangles. A triangle smaller than a cell is marked\r\n   * by its centre, which is every triangle of a scanned model; a larger one - the two triangles of\r\n   * a drawn wall - is sampled across its face, or the middle of the wall would read as empty.\r\n   */\r\n  private buildSurfaceGrid(object: THREE.Object3D, box: THREE.Box3): void {\r\n    const size = box.getSize(new THREE.Vector3());\r\n    const longest = Math.max(size.x, size.y, size.z);\r\n    if (!(longest > 0)) {\r\n      this.surfaceCells = null;\r\n      return;\r\n    }\r\n    // A quarter of a metre where the model is in metres; coarser on a very large one, so the grid\r\n    // stays addressable and its memory bounded.\r\n    const cell = Math.max(0.25, longest / 384);\r\n    const origin = box.min.clone();\r\n    const cells = new Set<number>();\r\n    const mark = (point: THREE.Vector3) => {\r\n      const key = this.surfaceKey(\r\n        Math.floor((point.x - origin.x) / cell),\r\n        Math.floor((point.y - origin.y) / cell),\r\n        Math.floor((point.z - origin.z) / cell),\r\n      );\r\n      if (key >= 0) {\r\n        cells.add(key);\r\n      }\r\n    };\r\n\r\n    let triangleCount = 0;\r\n    object.updateMatrixWorld(true);\r\n    object.traverse((child: any) => {\r\n      const position = child.isMesh && child.geometry?.attributes?.position;\r\n      if (position) {\r\n        triangleCount += (child.geometry.index ? child.geometry.index.count : position.count) / 3;\r\n      }\r\n    });\r\n    // Past a few million triangles they are far smaller than a cell, and every cell is hit many\r\n    // times over; a sample marks the same cells.\r\n    const stride = Math.max(1, Math.ceil(triangleCount / 3000000));\r\n\r\n    const a = new THREE.Vector3();\r\n    const b = new THREE.Vector3();\r\n    const c = new THREE.Vector3();\r\n    const point = new THREE.Vector3();\r\n    object.traverse((child: any) => {\r\n      const position = child.isMesh && child.geometry?.attributes?.position;\r\n      if (!position) {\r\n        return;\r\n      }\r\n      const index = child.geometry.index;\r\n      const count = (index ? index.count : position.count) / 3;\r\n      for (let triangle = 0; triangle < count; triangle += stride) {\r\n        const offset = triangle * 3;\r\n        a.fromBufferAttribute(position, index ? index.getX(offset) : offset).applyMatrix4(child.matrixWorld);\r\n        b.fromBufferAttribute(position, index ? index.getX(offset + 1) : offset + 1).applyMatrix4(child.matrixWorld);\r\n        c.fromBufferAttribute(position, index ? index.getX(offset + 2) : offset + 2).applyMatrix4(child.matrixWorld);\r\n        const edge = Math.max(a.distanceTo(b), b.distanceTo(c), c.distanceTo(a));\r\n        if (edge <= cell) {\r\n          mark(point.copy(a).add(b).add(c).multiplyScalar(1 / 3));\r\n          continue;\r\n        }\r\n        // Half-cell steps across the face. Capped, so one enormous triangle cannot stall the load;\r\n        // the reach a tag is tested with spans several cells and bridges what the cap leaves.\r\n        const steps = Math.min(96, Math.ceil((2 * edge) / cell));\r\n        for (let i = 0; i <= steps; i += 1) {\r\n          for (let j = 0; j <= steps - i; j += 1) {\r\n            point.copy(a)\r\n              .addScaledVector(b.clone().sub(a), i / steps)\r\n              .addScaledVector(c.clone().sub(a), j / steps);\r\n            mark(point);\r\n          }\r\n        }\r\n      }\r\n    });\r\n\r\n    this.surfaceCells = cells;\r\n    this.surfaceOrigin.copy(origin);\r\n    this.surfaceCellSize = cell;\r\n  }\r\n\r\n  /** Whether some part of the model's surface lies within `reach` of a point, in model units. */\r\n  private isNearSurface(point: THREE.Vector3, reach: number): boolean {\r\n    const cell = this.surfaceCellSize;\r\n    const origin = this.surfaceOrigin;\r\n    const x = (point.x - origin.x) / cell;\r\n    const y = (point.y - origin.y) / cell;\r\n    const z = (point.z - origin.z) / cell;\r\n    // In cells. Capped: beyond this the calibration's scale makes a metre so many cells that the\r\n    // search would dwarf the model, and a tag that far off is not on it by any reading.\r\n    const span = Math.min(16, Math.ceil(reach / cell));\r\n    // A cell is \"within reach\" when its centre is, give or take the half-diagonal of the cell.\r\n    const limit = (reach / cell + 0.87) ** 2;\r\n    const [cx, cy, cz] = [Math.floor(x), Math.floor(y), Math.floor(z)];\r\n    for (let k = cz - span; k <= cz + span; k += 1) {\r\n      for (let j = cy - span; j <= cy + span; j += 1) {\r\n        for (let i = cx - span; i <= cx + span; i += 1) {\r\n          const distance = (i + 0.5 - x) ** 2 + (j + 0.5 - y) ** 2 + (k + 0.5 - z) ** 2;\r\n          if (distance <= limit && this.surfaceCells.has(this.surfaceKey(i, j, k))) {\r\n            return true;\r\n          }\r\n        }\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /**\r\n   * Moves the camera to look at a tag, mirroring Matterport's goToTag.\r\n   *\r\n   * Animated rather than teleported: jumping the camera loses the viewer's sense of where they were\r\n   * relative to the model. The approach distance follows the model's size so it frames sensibly\r\n   * whatever the units are.\r\n   */\r\n  goToTag(elementId: string): void {\r\n    const sprite = this.tagSprites.get(elementId);\r\n    if (!sprite || !this.camera) {\r\n      return;\r\n    }\r\n\r\n    const target = sprite.getWorldPosition(new THREE.Vector3());\r\n    const distance = this.modelRoot\r\n      ? new THREE.Box3().setFromObject(this.modelRoot).getSize(new THREE.Vector3()).length() * 0.15\r\n      : 5;\r\n\r\n    // Approach along the current viewing direction, so the camera closes in rather than swinging\r\n    // around to an arbitrary side.\r\n    const direction = this.camera.position.clone().sub(this.controls.target).normalize();\r\n    this.cameraTween = {\r\n      fromPosition: this.camera.position.clone(),\r\n      toPosition: target.clone().add(direction.multiplyScalar(distance)),\r\n      fromTarget: this.controls.target.clone(),\r\n      toTarget: target,\r\n      startedAt: performance.now(),\r\n      durationMs: 600,\r\n    };\r\n  }\r\n\r\n  /** Advances the camera animation started by goToTag, if one is running. */\r\n  private stepCameraTween(): void {\r\n    if (!this.cameraTween) {\r\n      return;\r\n    }\r\n    const { fromPosition, toPosition, fromTarget, toTarget, startedAt, durationMs } = this.cameraTween;\r\n    const linear = Math.min((performance.now() - startedAt) / durationMs, 1);\r\n    // Ease out, so the move settles instead of stopping dead.\r\n    const t = 1 - Math.pow(1 - linear, 3);\r\n\r\n    this.camera.position.lerpVectors(fromPosition, toPosition, t);\r\n    this.controls.target.lerpVectors(fromTarget, toTarget, t);\r\n\r\n    if (linear >= 1) {\r\n      this.cameraTween = null;\r\n    }\r\n  }\r\n\r\n  isPlacingTag(): boolean {\r\n    return this.placingTag;\r\n  }\r\n\r\n  /** The spot picked by the last placement, for whoever commits it to a POI. */\r\n  getPendingTagPlacement(): ThreeJsTagPlacement | null {\r\n    return this.pendingTagPlacement;\r\n  }\r\n\r\n  /**\r\n   * Raycasts a click against the model's geometry and returns the hit, in world space.\r\n   *\r\n   * Returns null when the click missed, which is a normal outcome - the user clicked the sky - and\r\n   * leaves whatever mode is armed still armed, so they can simply try again.\r\n   */\r\n  private raycastModel(event: MouseEvent): THREE.Intersection | null {\r\n    if (!this.modelRoot) {\r\n      return null;\r\n    }\r\n\r\n    const rect = this.renderer.domElement.getBoundingClientRect();\r\n    this.mouse.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;\r\n    this.mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;\r\n    this.raycaster.setFromCamera(this.mouse, this.camera);\r\n\r\n    return this.raycaster.intersectObject(this.modelRoot, true)[0] ?? null;\r\n  }\r\n\r\n  /**\r\n   * Turns a click into a point on the model, in the frame tag coordinates are persisted in.\r\n   *\r\n   * That frame is the tag group's, not the model's. A stored coordinate is read back as a sprite\r\n   * position inside that group, so a coordinate captured in any other frame comes back displaced by\r\n   * exactly however far the alignment moves the group. The two frames agree only while the\r\n   * alignment is identity, which is why this stayed invisible until a model was calibrated.\r\n   */\r\n  private pickPlacementOnModel(event: MouseEvent): ThreeJsTagPlacement | null {\r\n    const hit = this.raycastModel(event);\r\n    if (!hit) {\r\n      return null;\r\n    }\r\n\r\n    this.tagGroup.updateWorldMatrix(true, false);\r\n    const position = this.tagGroup.worldToLocal(hit.point.clone());\r\n\r\n    // A face normal is in the geometry's local space already, but the mesh it belongs to may sit\r\n    // under transforms of its own, so take it out through those and back into the tag frame, so it\r\n    // describes the same orientation the position does.\r\n    let normal = new THREE.Vector3(0, 1, 0);\r\n    if (hit.face) {\r\n      normal = hit.face.normal\r\n        .clone()\r\n        .transformDirection(hit.object.matrixWorld)\r\n        .transformDirection(new THREE.Matrix4().copy(this.tagGroup.matrixWorld).invert())\r\n        .normalize();\r\n    }\r\n\r\n    return {\r\n      position: { x: position.x, y: position.y, z: position.z },\r\n      normal: { x: normal.x, y: normal.y, z: normal.z },\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Where the user says a tag really belongs, in the space the solved alignment maps onto.\r\n   *\r\n   * setTagAlignment writes the solution to the tag group's own transform, which is expressed\r\n   * relative to its parent - so the target has to be in the parent's frame. Measuring it in the\r\n   * group's own frame instead would fold the current alignment into the answer, making each\r\n   * calibration depend on the one before it.\r\n   */\r\n  private pickAlignmentTarget(event: MouseEvent): { x: number; y: number; z: number } | null {\r\n    const hit = this.raycastModel(event);\r\n    if (!hit) {\r\n      return null;\r\n    }\r\n    const frame = this.tagGroup.parent ?? this.scene;\r\n    frame.updateWorldMatrix(true, false);\r\n    const point = frame.worldToLocal(hit.point.clone());\r\n    return { x: point.x, y: point.y, z: point.z };\r\n  }\r\n\r\n  /**\r\n   * Sets the transform mapping captured tag coordinates onto this model's space.\r\n   *\r\n   * Every tag comes from the same source space, so this is one transform on the group rather than\r\n   * per-tag maths - which also means it applies retroactively to tags already placed, and can be\r\n   * adjusted live while someone dials the numbers in.\r\n   *\r\n   * Passing null resets to identity, i.e. tag coordinates are already in model space.\r\n   */\r\n  setTagAlignment(alignment: ThreeJsAlignment | null): void {\r\n    const { translation, rotation, scale } = alignment ?? {};\r\n    this.tagGroup.position.set(translation?.x ?? 0, translation?.y ?? 0, translation?.z ?? 0);\r\n    this.tagGroup.rotation.set(rotation?.x ?? 0, rotation?.y ?? 0, rotation?.z ?? 0);\r\n    this.tagGroup.scale.setScalar(scale ?? 1);\r\n    this.tagGroup.updateMatrix();\r\n\r\n    // Tag size is derived from the world scale it inherits, which this call just changed - and so\r\n    // is which tags land on the model.\r\n    this.tagSprites.forEach((sprite) => this.scaleTagForModel(sprite));\r\n    this.refreshTagVisibility();\r\n  }\r\n\r\n  /**\r\n   * Adds a tag, or moves/restyles the one already registered for this element.\r\n   *\r\n   * Upsert rather than a declarative \"here is the full list\" call, because tags arrive per type\r\n   * (equipment, then tickets, then measurements...) from separate subscriptions - replacing the set\r\n   * on each of those would wipe the types that came before.\r\n   */\r\n  upsertTag(tag: ThreeJsTag): void {\r\n    const existing = this.tagSprites.get(tag.id);\r\n    if (existing) {\r\n      existing.position.set(tag.position.x, tag.position.y, tag.position.z);\r\n      existing.userData.poiType = tag.poiType ?? existing.userData.poiType;\r\n      existing.userData.label = tag.label ?? existing.userData.label;\r\n      existing.userData.originCaptureID = tag.originCaptureID ?? existing.userData.originCaptureID;\r\n      existing.userData.frame = tag.frame ?? existing.userData.frame;\r\n      this.parentTag(existing);\r\n      this.applyTagVisibility(existing);\r\n      return;\r\n    }\r\n\r\n    const sprite = new THREE.Sprite(\r\n      new THREE.SpriteMaterial({\r\n        map: this.createTagTexture(tag.color),\r\n        // Tags read as UI rather than geometry, so they stay visible through the model instead of\r\n        // being occluded by whatever wall happens to be between them and the camera.\r\n        depthTest: false,\r\n        transparent: true,\r\n      })\r\n    );\r\n    sprite.name = tag.id;\r\n    sprite.userData.poiType = tag.poiType ?? null;\r\n    sprite.userData.label = tag.label ?? null;\r\n    sprite.userData.originCaptureID = tag.originCaptureID ?? null;\r\n    sprite.userData.frame = tag.frame ?? null;\r\n    sprite.position.set(tag.position.x, tag.position.y, tag.position.z);\r\n    sprite.renderOrder = 999;\r\n    this.parentTag(sprite);\r\n    this.scaleTagForModel(sprite);\r\n    this.applyTagVisibility(sprite);\r\n\r\n    this.tagSprites.set(tag.id, sprite);\r\n\r\n    if (tag.iconUrl) {\r\n      this.applyTagIcon(sprite, tag.iconUrl);\r\n    }\r\n  }\r\n\r\n  /** Removes the tag registered for an element, if there is one. */\r\n  removeTag(elementId: string): void {\r\n    const sprite = this.tagSprites.get(elementId);\r\n    if (!sprite) {\r\n      return;\r\n    }\r\n    sprite.parent?.remove(sprite);\r\n    sprite.material.map?.dispose();\r\n    sprite.material.dispose();\r\n    this.tagSprites.delete(elementId);\r\n  }\r\n\r\n  /** Removes every tag from the scene. */\r\n  clearTags(): void {\r\n    [...this.tagSprites.keys()].forEach((id) => this.removeTag(id));\r\n  }\r\n\r\n  /** Loads an icon into an existing tag, leaving the fallback disc in place if it fails. */\r\n  private applyTagIcon(sprite: THREE.Sprite, iconUrl: string): void {\r\n    new THREE.TextureLoader().load(\r\n      iconUrl,\r\n      (texture) => {\r\n        sprite.material.map?.dispose();\r\n        sprite.material.map = texture;\r\n        sprite.material.needsUpdate = true;\r\n      },\r\n      undefined,\r\n      () => console.warn(`ThreeJsService: could not load tag icon \"${iconUrl}\", keeping the default marker.`)\r\n    );\r\n  }\r\n\r\n  /** Draws the default tag marker: a filled disc with a white ring, so it reads on any background. */\r\n  private createTagTexture(color = '#1E88E5'): THREE.CanvasTexture {\r\n    const size = 128;\r\n    const canvas = document.createElement('canvas');\r\n    canvas.width = size;\r\n    canvas.height = size;\r\n    const context = canvas.getContext('2d');\r\n\r\n    context.beginPath();\r\n    context.arc(size / 2, size / 2, size / 2 - 8, 0, Math.PI * 2);\r\n    context.fillStyle = color;\r\n    context.fill();\r\n    context.lineWidth = 8;\r\n    context.strokeStyle = '#FFFFFF';\r\n    context.stroke();\r\n\r\n    return new THREE.CanvasTexture(canvas);\r\n  }\r\n\r\n  /**\r\n   * Sizes a tag relative to the model.\r\n   *\r\n   * A sprite inherits the model's scale and the alignment's, so a fixed size would come out tiny on\r\n   * a large model and huge on a small one. Dividing by the group's world scale keeps tags the same\r\n   * size on screen whatever the model's units are.\r\n   */\r\n  private scaleTagForModel(sprite: THREE.Sprite): void {\r\n    // Its own parent's scale: tags in the model's coordinates do not inherit the calibration's.\r\n    const worldScale = (sprite.parent ?? this.tagGroup).getWorldScale(new THREE.Vector3()).x || 1;\r\n    const size = 0.4 / worldScale;\r\n    sprite.scale.set(size, size, 1);\r\n  }\r\n\r\n  /**\r\n   * Adds secondary interactive objects (e.g., POIs, sensors) to the scene.\r\n   */\r\n  updateObjsToScene(objsAdded: ObjAdded[]): void {\r\n    const existingIds = this.clickableObjects.map((obj) => obj.name);\r\n    const objLoader = new OBJLoader();\r\n\r\n    // delete objects that are not in the provided array\r\n    this.clickableObjects.forEach((obj) => {\r\n      if (!objsAdded.find((objData) => objData.id === obj.name)) {\r\n        this.scene.remove(obj);\r\n        this.clickableObjects = this.clickableObjects.filter(\r\n          (object) => object.name !== obj.name\r\n        );\r\n      }\r\n    });\r\n\r\n    objsAdded.forEach((objectData: ObjAdded) => {\r\n      if (!existingIds.includes(objectData.id)) {\r\n        objLoader.load(objectData.file, (newObject) => {\r\n          newObject.name = objectData.id;\r\n\r\n          newObject.traverse((child) => {\r\n            if ((child as THREE.Mesh).isMesh) {\r\n              const mesh = child as THREE.Mesh;\r\n              if (mesh.material instanceof THREE.Material) {\r\n                mesh.material.transparent = true;\r\n                mesh.material.opacity = 0.8;\r\n              }\r\n            }\r\n          });\r\n\r\n          // set object position and rotation\r\n          newObject.position.set(\r\n            objectData.position.x,\r\n            objectData.position.y,\r\n            objectData.position.z\r\n          );\r\n          \r\n          // The JSON configuration has rotation already in radians (e.g. 3.1415...)\r\n          newObject.rotation.set(\r\n            objectData.rotation.x,\r\n            objectData.rotation.y,\r\n            objectData.rotation.z\r\n          );\r\n\r\n          newObject.scale.set(objectData.scale.x, objectData.scale.y, objectData.scale.z);\r\n\r\n          this.scene.add(newObject);\r\n          this.clickableObjects.push(newObject);\r\n        });\r\n      }\r\n    });\r\n  }\r\n\r\n  private onMouseMove(event: MouseEvent): void {\r\n    if (!this.isDraggingCamera) {\r\n      const rect = this.renderer.domElement.getBoundingClientRect();\r\n      this.mouse.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;\r\n      this.mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;\r\n\r\n      this.raycaster.setFromCamera(this.mouse, this.camera);\r\n\r\n      // While the ghost is up it follows the pointer and nothing else should react to it. The move\r\n      // is only recorded here: pointer events fire far more often than frames, and picking a point\r\n      // costs a raycast against the whole model, so doing it per event is what made the ghost trail\r\n      // behind the cursor. The render loop picks up the latest position, once, per frame.\r\n      if (this.isPreviewingPlacement()) {\r\n        this.pendingPreviewEvent = event;\r\n        return;\r\n      }\r\n\r\n      // Not previewing any more (a pair was just completed, say): drop a ghost left over from it.\r\n      this.removePlacementPreview();\r\n\r\n      // Tags first: they draw on top of the model, so they have to answer the pointer first too.\r\n      const hoveredTag = this.raycaster\r\n        .intersectObjects([...this.tagSprites.values()], false)\r\n        .find((hit) => hit.object.visible)?.object;\r\n      if (hoveredTag) {\r\n        this.renderer.domElement.style.cursor = 'pointer';\r\n        this.objectHovered$.next(null);\r\n        const label = hoveredTag.userData.label;\r\n        this.tagHovered$.next(label ? { label, event } : null);\r\n        return;\r\n      }\r\n      this.tagHovered$.next(null);\r\n\r\n      const intersects = this.raycaster.intersectObjects(this.clickableObjects, true);\r\n\r\n      if (intersects.length > 0) {\r\n        this.renderer.domElement.style.cursor = 'pointer';\r\n        const intersectedObjectId = intersects[0].object?.parent?.name;\r\n        if (intersectedObjectId) {\r\n            this.objectHovered$.next({ id: intersectedObjectId, event });\r\n        }\r\n      } else {\r\n        this.renderer.domElement.style.cursor = 'default';\r\n        this.objectHovered$.next(null);\r\n      }\r\n    } else {\r\n      this.renderer.domElement.style.cursor = 'grabbing';\r\n      this.objectHovered$.next(null);\r\n    }\r\n  }\r\n\r\n  private onMouseClick(event: MouseEvent): void {\r\n    if (!this.isDraggingCamera) {\r\n      const rect = this.renderer.domElement.getBoundingClientRect();\r\n      this.mouse.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;\r\n      this.mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;\r\n\r\n      // Alignment and placement both take the click before anything can be opened by it.\r\n      if (this.aligning) {\r\n        this.raycaster.setFromCamera(this.mouse, this.camera);\r\n        this.handleAlignmentClick(event);\r\n        return;\r\n      }\r\n\r\n      // Measuring takes every click as a point, the same way placement takes it as a position.\r\n      if (this.measuring) {\r\n        const placement = this.pickPlacementOnModel(event);\r\n        if (placement) {\r\n          const { x, y, z } = placement.position;\r\n          this.addMeasurePoint(new THREE.Vector3(x, y, z));\r\n        }\r\n        return;\r\n      }\r\n\r\n      // Placement wins over everything: while armed, a click means \"put it here\", not \"open that\".\r\n      if (this.placingTag) {\r\n        const placement = this.pickPlacementOnModel(event);\r\n        if (placement) {\r\n          placement.poiType = this.placementPoiType;\r\n          this.pendingTagPlacement = placement;\r\n          this.placingTag = false;\r\n          this.removePlacementPreview();\r\n          this.renderer.domElement.style.cursor = 'default';\r\n          this.tagPlaced$.next(placement);\r\n        }\r\n        return;\r\n      }\r\n\r\n      this.raycaster.setFromCamera(this.mouse, this.camera);\r\n\r\n      // Same precedence as hover: a tag drawn over the model claims the click.\r\n      const tagHits = this.raycaster.intersectObjects([...this.tagSprites.values()], false)\r\n        .filter((hit) => hit.object.visible);\r\n      if (tagHits.length > 0) {\r\n        const tag = tagHits[0].object;\r\n        this.tagClicked$.next({ elementId: tag.name, poiType: tag.userData.poiType ?? null });\r\n        return;\r\n      }\r\n\r\n      const intersects = this.raycaster.intersectObjects(this.clickableObjects, true);\r\n\r\n      if (intersects.length > 0) {\r\n        const clickedObject = intersects[0].object;\r\n        const id = clickedObject?.parent?.name;\r\n        if (id) {\r\n            this.objectClicked$.next(id);\r\n        }\r\n      } else {\r\n        this.objectClicked$.next(null);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Escape cancels whatever the pointer is currently committed to.\r\n   *\r\n   * Emits through the same subjects the explicit Cancel buttons use, so the UI driving them follows\r\n   * along instead of being left showing a mode that is no longer armed.\r\n   */\r\n  private onKeyDown = (event: KeyboardEvent): void => {\r\n    if (event.key !== 'Escape') {\r\n      return;\r\n    }\r\n    if (this.placingTag) {\r\n      // Nothing outside the scene tracks placement, so clearing it here is the whole of it.\r\n      this.cancelTagPlacement();\r\n      return;\r\n    }\r\n    if (this.measuring) {\r\n      this.cancelMeasuring();\r\n      return;\r\n    }\r\n    if (this.aligning) {\r\n      this.cancelTagAlignment();\r\n    }\r\n  }\r\n\r\n  private animate = (): void => {\r\n    this.animationFrameId = requestAnimationFrame(this.animate);\r\n    this.stepCameraTween();\r\n    this.controls.update();\r\n\r\n    // One pick per frame, against the pointer's latest position - see onMouseMove.\r\n    if (this.pendingPreviewEvent) {\r\n      const event = this.pendingPreviewEvent;\r\n      this.pendingPreviewEvent = null;\r\n      this.updatePlacementPreview(event);\r\n    }\r\n\r\n    this.renderer.render(this.scene, this.camera);\r\n  }\r\n\r\n  destroy(): void {\r\n    if (this.animationFrameId) {\r\n      cancelAnimationFrame(this.animationFrameId);\r\n    }\r\n    window.removeEventListener('keydown', this.onKeyDown);\r\n    if (this.canvasResizeObserver) {\r\n      this.canvasResizeObserver.disconnect();\r\n      this.canvasResizeObserver = undefined;\r\n    }\r\n    this.discardCurrentLoad();\r\n    this.clearTags();\r\n    this.measuring = false;\r\n    this.clearMeasurement();\r\n    if (this.renderer) {\r\n      this.renderer.dispose();\r\n    }\r\n    if (this.controls) {\r\n      this.controls.dispose();\r\n    }\r\n  }\r\n}\r\n"]}