@smarterplan/ngx-smarterplan-core 1.4.21 → 1.4.22

package/lib/services/threejs.service.d.ts

@@ -33,6 +33,35 @@ export interface ThreeJsTag {
     iconUrl?: string | null;
     /** Tint for the fallback disc, as a CSS colour. */
     color?: string;
+    /**
+     * Which way the surface the tag is on faces, in the tag's frame: Matterport's stem, which the
+     * splat viewer draws the tag at the end of.
+     */
+    normal?: {
+        x: number;
+        y: number;
+        z: number;
+    } | null;
+}
+/** A tag as a viewer drawing the scene elsewhere needs it - the splat viewer, in its iframe. */
+export interface ThreeJsTagSnapshot {
+    id: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    label: string | null;
+    poiType: PoiType | null;
+    iconUrl: string | null;
+    /** In the model's own coordinates, so not moved by the calibration. */
+    inModelFrame: boolean;
+    /** Which way its surface faces, in the same frame as its position; null when not known. */
+    normal: {
+        x: number;
+        y: number;
+        z: number;
+    } | null;
 }
 /** What a click on a tag reports: enough to route to the element's detail page. */
 export interface ThreeJsTagClick {
@@ -112,6 +141,28 @@ export interface ThreeJsAlignmentPair {
         z: number;
     };
 }
+/** A tag already matched in the calibration under way, as the panel lists it. */
+export interface ThreeJsAlignmentMatch {
+    tagId: string;
+    label: string | null;
+    poiType: PoiType | null;
+    /** Where it was said to really be, in the model's own coordinates: for another viewer to draw its pin. */
+    target: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+/** Where a calibration under way has got to, for the panel that drives it. */
+export interface ThreeJsAlignmentProgress {
+    pairs: number;
+    /** What the next click is expected to be, or null when there is nothing left to click. */
+    awaiting: 'tag' | 'point' | null;
+    /** The tag whose place on the model is being asked for, while `awaiting` is 'point'. */
+    tagId?: string;
+    /** The tags matched so far, in the order they were matched - the order they are numbered in. */
+    matched: ThreeJsAlignmentMatch[];
+}
 /**
  * Solves the transform that maps stored tag coordinates onto the loaded model, from as many matched
  * tags as there are - up to three.
@@ -134,6 +185,11 @@ export declare function solveThreeJsAlignment(pairs: ThreeJsAlignmentPair[], tar
     y: number;
     z: number;
 }): ThreeJsAlignment | null;
+/**
+ * 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 declare const VIEWER_BACKGROUND = "#e0f7ff";
 export interface ObjAdded {
     id: string;
     name: string;
@@ -173,6 +229,17 @@ export declare class ThreeJsService {
     objectClicked$: Subject<string>;
     /** Emits when the user clicks a tag, mirroring Matterport's tag click. */
     tagClicked$: Subject<ThreeJsTagClick>;
+    /**
+     * Emits the tag the camera is sent to (goToTag): for a viewer drawing the model elsewhere, the
+     * splat viewer, to point it out.
+     */
+    tagFocused$: Subject<string>;
+    /**
+     * 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$: Subject<void>;
+    private tagsChangeQueued;
     /** Emits a tag's label while the pointer is over it, and null when it leaves. */
     tagHovered$: Subject<{
         label: string;
@@ -183,6 +250,22 @@ export declare class ThreeJsService {
     private canvasResizeObserver?;
     /** Aborts the in-flight model download. Parsing cannot be interrupted, only not started. */
     private 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.
+     */
+    private loadGeneration;
+    /** Whether the wanted load is still on its way, so abandoning it can say that it stopped. */
+    private loadInProgress;
+    /** Whether a scene is up: started by init() and not yet taken down by destroy(). */
+    private live;
+    /** Takes off each listener init() put on the canvas. */
+    private canvasListeners;
     private modelRoot?;
     /** True while the next click on the model places a tag instead of orbiting. */
     private placingTag;
@@ -203,6 +286,12 @@ export declare class ThreeJsService {
      * placed in this one are told from those that came from elsewhere.
      */
     private currentCaptureID;
+    /**
+     * 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.
+     */
+    private soleVisit;
     /**
      * The model's surface as a grid: every cell some part of the surface passes through.
      *
@@ -250,6 +339,17 @@ export declare class ThreeJsService {
         points: number;
         distances: number[];
     }>;
+    /**
+     * 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$: Subject<boolean>;
+    /**
+     * 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$: Subject<void>;
     /**
      * Layer carrying the model alone, so the depth pick can render it without the tags.
      *
@@ -257,8 +357,18 @@ export declare class ThreeJsService {
      * their parent passed, so marking the model's own meshes is enough - no re-parenting.
      */
     private static readonly PICK_LAYER;
+    /** How large a tag is drawn, in CSS pixels. About what Matterport draws its own at. */
+    private static readonly TAG_SCREEN_PX;
     /** The app's highlight colour, so a measurement reads as the active thing on screen. */
     private static readonly MEASURE_COLOR;
+    /** Green for the points of a calibration that are settled, as opposed to the one in hand. */
+    private static readonly CALIBRATION_DONE_COLOR;
+    /** Size on screen of the numbered pin left where a tag was matched: a little under a tag's. */
+    private static readonly CALIBRATION_PIN_PX;
+    /** How long a mark just dropped takes to settle to its size, in milliseconds. */
+    private static readonly CONFIRM_PULSE_MS;
+    /** How many matched tags a calibration takes. Three settle everything there is to settle. */
+    private static readonly CALIBRATION_PAIRS;
     /** Cache Storage bucket holding downloaded models, and how many to keep. */
     private static readonly MODEL_CACHE;
     private static readonly MODEL_CACHE_SIZE;
@@ -273,16 +383,36 @@ export declare class ThreeJsService {
     /** Translucent marker shown under the cursor while placing. */
     private placementPreview?;
     private aligning;
+    /**
+     * 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.
+     */
+    private revealingCalibrationTags;
     private alignmentPairs;
     private alignmentSource;
     /** The tag `alignmentSource` was read from, kept so the same tag is not matched twice. */
     private 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.
+     */
+    private calibrationGroup;
+    /** Marks still settling after being dropped, advanced by the render loop. */
+    private pulses;
     /** Drives the alignment walkthrough's UI: how many pairs are done and what it wants next. */
-    alignmentProgress$: Subject<{
-        pairs: number;
-        awaiting: 'tag' | 'point' | null;
-        tagId?: string;
-    }>;
+    alignmentProgress$: Subject<ThreeJsAlignmentProgress>;
+    /**
+     * 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$: Subject<"tag" | "point">;
     /** In-flight camera move started by goToTag, advanced by the render loop. */
     private cameraTween;
     /** Emits true while a heavy OBJ file is being parsed (in a worker, when available), false once done. */
@@ -338,6 +468,8 @@ export declare class ThreeJsService {
         y: number;
         z: number;
     }, cacheKey?: string, up?: ThreeJsModelUp): void;
+    /** Ends a load that failed, unless another load has replaced it in the meantime. */
+    private loadFailed;
     /**
      * Stops the model download in progress, if any.
      *
@@ -354,6 +486,13 @@ export declare class ThreeJsService {
      * scene is not something the person asked for, so it must not surface as "loading cancelled".
      */
     private discardCurrentLoad;
+    /**
+     * 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?
+     */
+    private beginLoad;
+    /** Marks the wanted load as over, whichever way it ended. */
+    private endLoad;
     /**
      * Resolves once the browser has painted at least one frame.
      *
@@ -474,16 +613,25 @@ export declare 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.
      *
-     * 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.
+     * 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.
+     *
+     * 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.
      */
     private detectModelUp;
     /** The rotation that brings the given model axis to point up. */
@@ -516,6 +664,22 @@ export declare 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?: boolean): void;
+    /**
+     * 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(): boolean;
+    /** Says a tag was clicked in a viewer drawing the model elsewhere, as a click on it here would. */
+    clickTag(elementId: string): void;
     startTagAlignment(): void;
     cancelTagAlignment(): void;
     isAligningTags(): boolean;
@@ -560,8 +724,66 @@ export declare class ThreeJsService {
      */
     selectAlignmentTag(elementId: string): boolean;
     private setAlignmentSource;
+    private clearAlignmentSource;
+    /** Whether the calibration still has room for a pair and a tag to make it from. */
+    private canMatchAnotherTag;
     /** Handles a click while the alignment walkthrough is running. */
     private handleAlignmentClick;
+    /**
+     * 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: {
+        x: number;
+        y: number;
+        z: number;
+    }): boolean;
+    /**
+     * 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(): boolean;
+    /**
+     * 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: number): boolean;
+    /** The tags matched so far in the calibration under way, in the order they are numbered in. */
+    getAlignmentPairs(): ThreeJsAlignmentMatch[];
+    /**
+     * 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.
+     */
+    private alignmentChanged;
+    /**
+     * 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.
+     */
+    private redrawCalibrationMarks;
+    /** Removes everything drawn for a calibration, and gives the tags it dimmed their look back. */
+    private clearCalibrationMarks;
+    /**
+     * 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.
+     */
+    private createCalibrationMark;
+    /** Shows a mark arriving: it starts oversized and settles. */
+    private pulse;
+    private stepPulses;
     /**
      * Starts a measurement: every click on the model adds a point, and each pair of consecutive
      * points is a measured segment.
@@ -585,7 +807,23 @@ export declare 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(): ThreeJsMeasurement | null;
+    finishMeasuring(screenshot?: string): ThreeJsMeasurement | null;
+    /**
+     * 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: {
+        x: number;
+        y: number;
+        z: number;
+    }): boolean;
+    /** The measurement's points, under way or finished, in the model's own coordinates: for a viewer drawing it elsewhere. */
+    getMeasurePointsInModelFrame(): {
+        x: number;
+        y: number;
+        z: number;
+    }[];
     isMeasuring(): boolean;
     /** The measurement finishMeasuring() last produced, for the form that saves it. */
     getLastMeasurement(): ThreeJsMeasurement | null;
@@ -614,8 +852,28 @@ export declare class ThreeJsService {
      * browser presents it, and scaled down since it is uploaded and shown as a thumbnail.
      */
     private captureMeasurementScreenshot;
+    /**
+     * 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.
+     */
+    readonly placementChanged$: Subject<boolean>;
     /** Arms tag placement: the next click on the model drops a tag instead of being ignored. */
     startTagPlacement(poiType?: PoiType | null): void;
+    /**
+     * 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: {
+        x: number;
+        y: number;
+        z: number;
+    }, normal?: {
+        x: number;
+        y: number;
+        z: number;
+    } | null): ThreeJsTagPlacement | null;
     /** Leaves placement mode without placing anything. */
     cancelTagPlacement(): void;
     /**
@@ -650,6 +908,8 @@ export declare class ThreeJsService {
      * filter that happens to match nothing.
      */
     setVisibleTagTypes(types: PoiType[] | null): void;
+    /** Says whether the visit on screen is the site's only one; see soleVisit. */
+    setSoleVisit(sole: boolean): void;
     /** Says which capture is on screen, so the tags placed in it can be told from the rest. */
     setCurrentCapture(captureID: string | null): void;
     /** Every tag registered in the scene, shown or not. */
@@ -779,6 +1039,18 @@ export declare class ThreeJsService {
      * on each of those would wipe the types that came before.
      */
     upsertTag(tag: ThreeJsTag): void;
+    /**
+     * 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(): {
+        tags: ThreeJsTagSnapshot[];
+        alignment: ThreeJsAlignment;
+    };
+    private announceTagsChanged;
     /** Removes the tag registered for an element, if there is one. */
     removeTag(elementId: string): void;
     /** Removes every tag from the scene. */
@@ -787,14 +1059,32 @@ export declare class ThreeJsService {
     private applyTagIcon;
     /** Draws the default tag marker: a filled disc with a white ring, so it reads on any background. */
     private createTagTexture;
+    /** The default marker with a number on it: the nth point of a calibration. */
+    private createNumberedTexture;
+    /** A ring with nothing in the middle, to go round a tag and leave it showing. */
+    private createRingTexture;
     /**
-     * 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.
      */
     private scaleTagForModel;
+    /**
+     * 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.
+     */
+    private setScreenSize;
+    /** What one screen pixel is worth in the scale of a sprite drawn without size attenuation. */
+    private worldUnitsPerPixel;
+    /** Re-applies every marker's on-screen size: the viewport, the model or the calibration changed. */
+    private refreshScreenSizes;
     /**
      * Adds secondary interactive objects (e.g., POIs, sensors) to the scene.
      */
@@ -802,13 +1092,43 @@ export declare class ThreeJsService {
     private onMouseMove;
     private onMouseClick;
     /**
-     * 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.
      */
     private onKeyDown;
+    /**
+     * Ctrl+Z (Cmd+Z on a Mac) or Backspace, unless typed into a field - where they mean something
+     * else, to whatever the field is.
+     */
+    private isUndoKey;
     private animate;
+    /**
+     * 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: boolean): void;
+    /** Stops the render loop, if one is running. */
+    private stopRendering;
+    /**
+     * 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.
+     */
+    private removeModel;
+    /**
+     * 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.
+     */
+    private disposeModel;
     destroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ThreeJsService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ThreeJsService>;

package/lib/services/viewer.service.d.ts

@@ -8,6 +8,24 @@ import { PoiService } from './models/poi.service';
 import { ThreeJsModelUp } from '../helpers.service';
 import { Config } from '../config';
 import * as i0 from "@angular/core";
+/**
+ * What a Gaussian splat file is named with, when it is a .ply: the content is what tells it from
+ * another .ply, and the key is all a visit stores (see isGaussianSplatPly).
+ */
+export declare const GAUSSIAN_SPLAT_PLY_SUFFIX = ".splat.ply";
+/**
+ * Whether a 3D model file holds Gaussian splats, which the Three.js viewer cannot draw: .spz,
+ * .splat, .ksplat, SuperSplat's .sog, a .ply named with GAUSSIAN_SPLAT_PLY_SUFFIX, or the
+ * lod-meta.json of a Streamed SOG - SuperSplat's levels of detail, in pieces beside it.
+ */
+export declare function isGaussianSplatFile(name: string): boolean;
+/**
+ * Whether a .ply holds Gaussian splats: what splat tools export carries, for each splat, its colour
+ * as spherical harmonics (f_dc_0...) and its size (scale_0...). Only the header is read.
+ */
+export declare function isGaussianSplatPly(file: Blob): Promise<boolean>;
+/** Whether a 3D model file is the lod-meta.json of a Streamed SOG; see isGaussianSplatFile. */
+export declare function isStreamedSplatFile(name: string): boolean;
 export declare class ViewerService {
     private readonly sdkKey;
     private readonly config;
@@ -155,6 +173,22 @@ export declare class ViewerService {
     private defaultTagIconUrl;
     /** Moves the Three.js camera to frame a tag, mirroring Matterport's goToTag. */
     goToThreeJsTag(elementId: string): void;
+    /** The tag the Three.js camera is sent to, for the splat viewer to point out; see goToThreeJsTag. */
+    get threeJsTagFocused$(): Subject<string>;
+    /** A tag clicked in the splat viewer, said as threeJsTagClicked$ says one clicked in the scene. */
+    clickThreeJsTag(elementId: string): void;
+    /** Whether the visit's 3D model has a calibration, from its capture's metadata. */
+    isThreeJsCalibrated(): boolean;
+    /** Whether the tags a calibration works with are on show; see ThreeJsService.showsCalibrationTags. */
+    isThreeJsShowingCalibrationTags(): boolean;
+    /** Whether a calibration is under way in the Three.js scene. */
+    isThreeJsAligningTags(): boolean;
+    /** Whether a measurement is taking clicks in the Three.js scene. */
+    isThreeJsMeasuring(): boolean;
+    /** True when a measurement starts taking clicks, false when it stops; see ThreeJsService.measuringChanged$. */
+    get threeJsMeasuringChanged$(): Subject<boolean>;
+    /** Says a click in the splat viewer was of no use to the calibration, as one in the scene would. */
+    ignoreThreeJsAlignmentClick(expected: 'tag' | 'point'): void;
     /** Shows only tags of the given POI types; null clears the filter. */
     setVisibleThreeJsTagTypes(types: PoiType[] | null): void;
     /**
@@ -165,11 +199,17 @@ export declare class ViewerService {
      */
     startThreeJsTagAlignment(): void;
     cancelThreeJsTagAlignment(): void;
-    get threeJsAlignmentProgress$(): Subject<{
-        pairs: number;
-        awaiting: "tag" | "point";
-        tagId?: string;
-    }>;
+    /**
+     * Says whether the 3D model on screen is the site's only visit. Then there is nowhere else for a
+     * tag to have come from, and the tags that do not record where they were placed are its own.
+     */
+    setThreeJsSoleVisit(sole: boolean): void;
+    /**
+     * Shows the tags a calibration would work with, including those hidden for not landing on the
+     * model, before anything is armed. Cancelling or saving the calibration hides them again.
+     */
+    revealThreeJsCalibrationTags(): void;
+    get threeJsAlignmentProgress$(): Subject<import("./threejs.service").ThreeJsAlignmentProgress>;
     /**
      * Solves the alignment and applies it to the scene, returning it as the JSON to store in the
      * capture's metadata. Null means the three tags were collinear and nothing was applied.
@@ -224,8 +264,28 @@ export declare class ViewerService {
         points: number;
         distances: number[];
     }>;
-    /** Ends the Three.js measurement in progress, or returns null when it has fewer than two points. */
-    finishThreeJsMeasurement(): ThreeJsMeasurement | null;
+    /**
+     * Ends the Three.js measurement in progress, or returns null when it has fewer than two points.
+     * `screenshot` is the picture of it, when the model is drawn by another viewer than the scene.
+     */
+    finishThreeJsMeasurement(screenshot?: string): ThreeJsMeasurement | null;
+    /** A measurement was taken off the model, finished or not; see ThreeJsService.measurementCleared$. */
+    get threeJsMeasurementCleared$(): Subject<void>;
+    /**
+     * Adds a point to the measurement under way, picked on the model in another viewer - the splat
+     * viewer - in the model's own coordinates. False when no measurement is under way.
+     */
+    addThreeJsMeasurePointAtModelPoint(point: {
+        x: number;
+        y: number;
+        z: number;
+    }): boolean;
+    /** The points of the measurement on the model, in the model's own coordinates, for another viewer to draw. */
+    getThreeJsMeasurePointsInModelFrame(): {
+        x: number;
+        y: number;
+        z: number;
+    }[];
     /** The measurement last finished in the Three.js viewer, for the form that saves it. */
     getThreeJsLastMeasurement(): ThreeJsMeasurement | null;
     /**
@@ -259,6 +319,22 @@ export declare class ViewerService {
     } | null;
     /** Chooses the tag for the calibration pair being matched by id, instead of by clicking it. */
     selectThreeJsAlignmentTag(elementId: string): boolean;
+    /**
+     * Gives the tag being matched in the calibration under way its real place, picked on the model in
+     * another viewer - the splat viewer - in the model's own coordinates. False when no tag was waiting.
+     */
+    matchThreeJsAlignmentTagAtModelPoint(point: {
+        x: number;
+        y: number;
+        z: number;
+    }): boolean;
+    /**
+     * Takes back the last step of the calibration under way: the tag just chosen, or else the last
+     * pair matched. False when there was nothing to take back.
+     */
+    undoThreeJsAlignmentStep(): boolean;
+    /** Removes one matched pair of the calibration under way, by its place in the list. */
+    removeThreeJsAlignmentPair(index: number): boolean;
     /** How far the visible tags sit from the 3D model, in model radii. Null without both. */
     getThreeJsTagDistanceFromModel(): number | null;
     /** How many tags the Three.js scene is showing. */
@@ -281,11 +357,37 @@ export declare class ViewerService {
      *
      * Returns null when there is no pending placement, which is the normal case in Matterport mode.
      */
-    createPoiForThreeJsPlacement(element: DbObjectType, poiType: PoiType): Promise<POI | null>;
+    createPoiForThreeJsPlacement(element: DbObjectType, poiType: PoiType, extra?: Partial<POI>): Promise<POI | null>;
     /** Emits when a tag is dropped on the model in the Three.js scene. */
     get threeJsTagPlaced$(): Subject<import("./threejs.service").ThreeJsTagPlacement>;
     /** Emits when the calibration walkthrough is abandoned, including via Escape. */
     get threeJsAlignmentCancelled$(): Subject<void>;
+    /** Emits when the Three.js tags change; see getThreeJsTagSnapshot. */
+    get threeJsTagsChanged$(): Subject<void>;
+    /** The tags, and their calibration, as a viewer drawing the scene elsewhere needs them. */
+    getThreeJsTagSnapshot(): {
+        tags: import("./threejs.service").ThreeJsTagSnapshot[];
+        alignment: import("../helpers.service").ThreeJsAlignment;
+    };
+    /** Stops drawing the Three.js scene while another viewer covers it, or starts again. */
+    setThreeJsRenderingPaused(paused: boolean): void;
+    /** Emits when a click during calibration landed on nothing it could use: a tag, or the model. */
+    get threeJsAlignmentClickIgnored$(): Subject<"tag" | "point">;
+    /** Emits when Three.js tag placement is armed (true) and when it ends (false). */
+    get threeJsPlacementChanged$(): Subject<boolean>;
+    /**
+     * Completes an armed Three.js tag placement at a spot the splat viewer picked, in the model's own
+     * coordinates: the creation form then opens as for a click in the Three.js scene.
+     */
+    placeThreeJsTagAtModelPoint(point: {
+        x: number;
+        y: number;
+        z: number;
+    }, normal?: {
+        x: number;
+        y: number;
+        z: number;
+    } | null): void;
     /** Leaves Three.js tag placement mode without placing anything. */
     cancelThreeJsTagPlacement(): void;
     editOnlyTagStyleForPoi(poi: POI, object: DbObjectType): void;