@smarterplan/ngx-smarterplan-core 1.4.21 → 1.4.22

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

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