@smarterplan/ngx-smarterplan-core 1.4.19 → 1.4.21

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

@@ -1,6 +1,6 @@
 import { NgZone } from '@angular/core';
 import { Subject } from 'rxjs';
-import { ThreeJsAlignment } from '../helpers.service';
+import { ThreeJsAlignment, ThreeJsModelUp } from '../helpers.service';
 import { PoiType } from '../types.service';
 import * as i0 from "@angular/core";
 /**
@@ -22,6 +22,13 @@ export interface ThreeJsTag {
     poiType?: PoiType | null;
     /** Shown on hover. A marker with no identity is just a dot on a wall. */
     label?: string | null;
+    /** The Three.js capture this tag was placed in, when it was placed in one. */
+    originCaptureID?: string | null;
+    /**
+     * 'model' when the position is in the model's own coordinates rather than the space tags share:
+     * a tag placed in a model before it was calibrated. Only meaningful in the model it was placed in.
+     */
+    frame?: 'model' | null;
     /** Icon drawn on the tag. Falls back to a plain disc when absent or it fails to load. */
     iconUrl?: string | null;
     /** Tint for the fallback disc, as a CSS colour. */
@@ -55,7 +62,45 @@ export interface ThreeJsTagPlacement {
     poiType?: PoiType | null;
 }
 /** One tag seen in both spaces: where it is stored, and where it really sits on the model. */
+/** A distance measured on the model: its points, each segment's length, and a picture of it. */
+export interface ThreeJsMeasurement {
+    /** In the frame tag coordinates are stored in, so the last one can be saved as the POI. */
+    points: {
+        x: number;
+        y: number;
+        z: number;
+    }[];
+    /** Metres between consecutive points, rounded like Matterport's measurements are. */
+    distances: number[];
+    /** JPEG data URI of the scene with the measurement drawn on it. */
+    screenshot: string;
+}
+/**
+ * A tag placed in this model whose stored coordinates had to change for it to stay where it is,
+ * because the calibration it is drawn under changed.
+ */
+export interface ThreeJsRebasedTag {
+    id: string;
+    /** Its coordinates in the space tags share, under the new calibration. */
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Turns a direction stored with the tag - its surface normal - the same way. */
+    rotateDirection: (direction: {
+        x: number;
+        y: number;
+        z: number;
+    }) => {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
 export interface ThreeJsAlignmentPair {
+    /** The tag the pair was made from, when it came from one. */
+    tagId?: string;
     source: {
         x: number;
         y: number;
@@ -68,17 +113,27 @@ export interface ThreeJsAlignmentPair {
     };
 }
 /**
- * Solves the transform that maps stored tag coordinates onto the loaded model.
+ * Solves the transform that maps stored tag coordinates onto the loaded model, from as many matched
+ * tags as there are - up to three.
  *
- * Takes exactly the correspondences a person can produce by hand: three tags, each pointed at twice
- * - once where it currently sits, once where it belongs. That is the minimum that pins down all
- * three parts of the answer. One pair fixes only translation; two leave the rotation about the line
- * between them free; three resolve it.
+ * Three pairs pin down everything: position, orientation and scale. A model that shares only a
+ * corner with the tags' space may not have three tags to offer, so fewer are accepted, each
+ * settling what it can and assuming the rest:
  *
- * Returns null when the points are collinear or degenerate, because a wrong alignment applied
- * silently is worse than none.
+ *  - Two pairs: position, heading and scale. The one thing two points cannot say is how the model
+ *    is tilted, so both spaces are taken to agree on which way is up.
+ *  - One pair: position only. Heading and scale are taken to match already.
+ *
+ * `targetUp` is the model's vertical axis, which the tags' own vertical (+Y) is matched to in those
+ * two cases. Returns null when the points cannot answer the question asked of them - collinear for
+ * three, one above the other for two - because a wrong calibration applied silently is worse than
+ * none.
  */
-export declare function solveThreeJsAlignment(pairs: ThreeJsAlignmentPair[]): ThreeJsAlignment | null;
+export declare function solveThreeJsAlignment(pairs: ThreeJsAlignmentPair[], targetUp?: {
+    x: number;
+    y: number;
+    z: number;
+}): ThreeJsAlignment | null;
 export interface ObjAdded {
     id: string;
     name: string;
@@ -137,6 +192,64 @@ export declare class ThreeJsService {
     private pendingTagPlacement;
     /** Pointer position waiting for a preview pick, coalesced to one per frame. */
     private pendingPreviewEvent;
+    /**
+     * Tags whose position is in this model's own coordinates. A sibling of the tag group that does not
+     * carry the calibration: calibrating a model for the tags it imports must not move the ones that
+     * were placed straight onto it.
+     */
+    private modelTagGroup;
+    /**
+     * The capture on screen. A tag placed in a 3D model is recorded with it, which is how the tags
+     * placed in this one are told from those that came from elsewhere.
+     */
+    private currentCaptureID;
+    /**
+     * The model's surface as a grid: every cell some part of the surface passes through.
+     *
+     * It answers "is this point near the model?" without visiting the triangles, of which a captured
+     * model has millions - the question is asked for every tag, every time the calibration changes.
+     */
+    private surfaceCells;
+    private surfaceOrigin;
+    private surfaceCellSize;
+    /**
+     * How far from the model's surface a tag may be and still count as on it, in metres.
+     *
+     * Every tag of the space is offered to every model; this is what decides which ones a model
+     * shows. A tag marks something on a surface, so one that belongs here sits on the surface or
+     * close to it. One that lands deep inside the model, or well away from it, marks something that
+     * is not part of this model. The allowance covers a calibration done by hand and the model not
+     * matching the scan exactly, which together run to a few tens of centimetres.
+     */
+    private static readonly ON_MODEL_METRES;
+    /** Cells per axis the grid's keys can address, with room either side for points off the model. */
+    private static readonly SURFACE_GRID_SPAN;
+    private static readonly SURFACE_GRID_PAD;
+    /** Own tags moved to keep their place under the last calibration, waiting to be stored. */
+    private rebasedTags;
+    /** The type filter in force. Null shows every type. */
+    private visibleTagTypes;
+    private measuring;
+    /** Points clicked so far, in tag space. */
+    private measurePoints;
+    /**
+     * Everything drawn for the measurement. A child of the tag group, so its points share the frame
+     * tag coordinates are stored in - which is metres, and what the saved POI has to be in.
+     */
+    private measureGroup;
+    /** The segment that follows the pointer from the last point clicked. */
+    private measureRubberBand?;
+    private lastMeasurement;
+    /** Half the model's diagonal as placed in the scene, where it is centred on the origin. */
+    private modelWorldRadius;
+    /** The outermost group the model and its tags hang from: where "which way is up" is applied. */
+    private modelGroup?;
+    private modelUp;
+    /** While measuring: how many points and each segment's length. Null when it is abandoned. */
+    measurementProgress$: Subject<{
+        points: number;
+        distances: number[];
+    }>;
     /**
      * Layer carrying the model alone, so the depth pick can render it without the tags.
      *
@@ -144,6 +257,8 @@ export declare class ThreeJsService {
      * their parent passed, so marking the model's own meshes is enough - no re-parenting.
      */
     private static readonly PICK_LAYER;
+    /** The app's highlight colour, so a measurement reads as the active thing on screen. */
+    private static readonly MEASURE_COLOR;
     /** Cache Storage bucket holding downloaded models, and how many to keep. */
     private static readonly MODEL_CACHE;
     private static readonly MODEL_CACHE_SIZE;
@@ -160,6 +275,8 @@ export declare class ThreeJsService {
     private aligning;
     private alignmentPairs;
     private alignmentSource;
+    /** The tag `alignmentSource` was read from, kept so the same tag is not matched twice. */
+    private alignmentSourceTagId;
     /** Drives the alignment walkthrough's UI: how many pairs are done and what it wants next. */
     alignmentProgress$: Subject<{
         pairs: number;
@@ -220,7 +337,7 @@ export declare class ThreeJsService {
         x: number;
         y: number;
         z: number;
-    }, cacheKey?: string): void;
+    }, cacheKey?: string, up?: ThreeJsModelUp): void;
     /**
      * Stops the model download in progress, if any.
      *
@@ -352,6 +469,34 @@ export declare class ThreeJsService {
     }): void;
     /** Centers, scales and adds a loaded object to the scene, then frames the camera on it. */
     private placeLoadedObjectInScene;
+    /**
+     * Which of the model's axes is its vertical: 'y' when it already stands upright, or when it is
+     * not clear enough to act on.
+     *
+     * Models arrive in two conventions: Y up (glTF, and what this viewer assumes) and Z up (most CAD
+     * and scanning exports). A Z-up model loads lying on its side. Two independent cues say which
+     * axis is the vertical one, and both have to agree before anything is turned:
+     *
+     *  - Surface area. Floors and ceilings all face along the vertical, while walls are shared out
+     *    between the two horizontal axes, so the vertical usually collects the most area.
+     *  - Extent. A building is normally wider than it is tall, so the vertical is its shortest side.
+     *
+     * Either alone is wrong often enough to matter - a long corridor has more wall than floor, a
+     * tower is taller than it is wide - and turning a model that was fine is worse than leaving one
+     * that was not. A model that already has Y as its vertical is never touched.
+     */
+    private detectModelUp;
+    /** The rotation that brings the given model axis to point up. */
+    private uprightRotation;
+    /** Which of the model's axes is currently treated as up, whether chosen or worked out. */
+    getModelUp(): ThreeJsModelUp;
+    /**
+     * Turns the model so the given axis points up, at once.
+     *
+     * The model and its tags turn as one, so nothing stored has to be recomputed. The caller is
+     * expected to store the choice, or the next load goes back to working it out.
+     */
+    setModelUp(up: ThreeJsModelUp): void;
     /**
      * Keeps the drawing buffer and camera matched to the canvas as it is resized.
      *
@@ -384,6 +529,8 @@ export declare class ThreeJsService {
     private isPreviewingPlacement;
     /** Whether a tag is currently registered for this element. */
     hasTag(elementId: string): boolean;
+    /** How many tags are on show - the ones a person could actually click. */
+    getTagCount(): number;
     /**
      * Solves and applies the alignment collected so far, returning it so the caller can persist it.
      *
@@ -391,8 +538,82 @@ export declare class ThreeJsService {
      * the walkthrough stays open for the person to pick a better third point.
      */
     solveAlignmentFromPairs(): ThreeJsAlignment | null;
+    /**
+     * Applies a new calibration while keeping every tag placed in this model exactly where it is.
+     *
+     * A calibration is worked out for the tags that came from elsewhere. The model's own tags were put
+     * where they are by someone clicking the model, so they must not follow it. Their stored
+     * coordinates are rewritten instead: into the shared space as the new calibration defines it.
+     * That is also what makes them comparable with other visits from here on - a tag placed before
+     * the model was calibrated was in the model's own coordinates, visible nowhere else.
+     *
+     * The rewritten tags are kept for the caller to store; see takeRebasedTags().
+     */
+    private applyAlignmentKeepingOwnTags;
+    /** Hands over the tags the last calibration rewrote, once, for them to be stored. */
+    takeRebasedTags(): ThreeJsRebasedTag[];
+    /**
+     * Chooses the tag for the pair being matched by id, instead of by clicking it.
+     *
+     * Clicking a tag supposes it can be found. On a model that has never been calibrated the tags may
+     * sit far from it, or all on top of one another; a list has neither problem.
+     */
+    selectAlignmentTag(elementId: string): boolean;
+    private setAlignmentSource;
     /** Handles a click while the alignment walkthrough is running. */
     private handleAlignmentClick;
+    /**
+     * Starts a measurement: every click on the model adds a point, and each pair of consecutive
+     * points is a measured segment.
+     *
+     * It ends through finishMeasuring() or cancelMeasuring() rather than on its own after two points,
+     * because a measurement may have several segments - the same as Matterport's, whose results are
+     * stored as a list of distances.
+     */
+    startMeasuring(): void;
+    /**
+     * Abandons the measurement and removes what was drawn.
+     *
+     * Also what clears a finished measurement off the model once its form is saved or closed, which
+     * is why it only reports an abandonment when one was actually in progress.
+     */
+    cancelMeasuring(): void;
+    /**
+     * Ends the measurement and returns it, or null when there are not yet two points to measure
+     * between - in which case measuring simply carries on.
+     *
+     * The drawing stays on the model so it is still visible while the person names the measurement;
+     * cancelMeasuring() takes it away afterwards.
+     */
+    finishMeasuring(): ThreeJsMeasurement | null;
+    isMeasuring(): boolean;
+    /** The measurement finishMeasuring() last produced, for the form that saves it. */
+    getLastMeasurement(): ThreeJsMeasurement | null;
+    /** Metres between consecutive points. Tag space is in metres, so no conversion is involved. */
+    private measureDistances;
+    private addMeasurePoint;
+    /**
+     * A segment with a width in pixels.
+     *
+     * WebGL's own lines are one pixel wide whatever is asked for, which all but disappears over a
+     * photographic texture. This kind is drawn as screen-facing geometry, so the width holds.
+     */
+    private createMeasureLine;
+    /** Line widths are in pixels, which the material can only honour if it knows the canvas size. */
+    private updateMeasureLineResolution;
+    /** Stretches a segment from the last point to the pointer, or hides it when given null. */
+    private updateMeasureRubberBand;
+    private createMeasureLabelTexture;
+    /** Removes everything drawn for a measurement and forgets its points. */
+    private clearMeasurement;
+    /**
+     * A picture of the scene with the measurement on it, as Matterport attaches to its own.
+     *
+     * Tags are left out, as they are there: the picture is about the measurement. It is taken straight
+     * after a render because the drawing buffer is only guaranteed to hold the frame until the
+     * browser presents it, and scaled down since it is uploaded and shown as a thumbnail.
+     */
+    private captureMeasurementScreenshot;
     /** Arms tag placement: the next click on the model drops a tag instead of being ignored. */
     startTagPlacement(poiType?: PoiType | null): void;
     /** Leaves placement mode without placing anything. */
@@ -429,6 +650,79 @@ export declare class ThreeJsService {
      * filter that happens to match nothing.
      */
     setVisibleTagTypes(types: PoiType[] | null): 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. */
+    getTags(): {
+        id: string;
+        label: string | null;
+        poiType: PoiType | null;
+        visible: boolean;
+        /** Whether the calibration walkthrough can use it. */
+        calibratable: boolean;
+    }[];
+    /**
+     * How far the tags from elsewhere sit from the model, measured in model radii. Null without both.
+     *
+     * Before a model is calibrated those tags are wherever their own coordinates put them, which for
+     * a model with a different origin can be a long way off - too far to find, let alone click.
+     */
+    getTagDistanceFromModel(): number | null;
+    /**
+     * Hangs a tag from the group its coordinates belong to: outside the calibration when they are in
+     * this model's own coordinates, under it otherwise.
+     */
+    private parentTag;
+    /**
+     * The tags a calibration can be worked out from: those that came from somewhere else, whether or
+     * not they are on show - before calibrating, most of them will not be.
+     *
+     * Tags placed in this model are where they are because someone clicked there; matching them to
+     * "where they really are" would be circular. A tag in another model's own coordinates cannot be
+     * placed here at all. And a tag already used in this calibration cannot be used again - two
+     * pairs from one tag carry no more than one.
+     */
+    private calibrationCandidates;
+    /** How many tags there are to calibrate with, not counting those already used. */
+    getCalibrationCandidateCount(): number;
+    /**
+     * How many tags from elsewhere are not on this model, and so not shown on it.
+     *
+     * On a model that has not been calibrated, this is what suggests it should be: the tags are out
+     * there, just not where the model is.
+     */
+    getOffModelTagCount(): number;
+    /** Whether the tag was placed in the visit on screen. */
+    private isOwnedByVisit;
+    /**
+     * A tag shows when its type is not filtered out and it belongs on this model.
+     *
+     * One place decides, because the two used to set `visible` separately and whichever ran last
+     * undid the other.
+     */
+    private applyTagVisibility;
+    /**
+     * Whether a tag has a place on this model.
+     *
+     * Every tag of the space is offered to every model - there is one set of tags, not one per model.
+     * What a model shows of it is the part that sits on the model.
+     */
+    private belongsOnThisModel;
+    /** Whether a tag, drawn where its coordinates and the calibration put it, sits on the model. */
+    private isOnModel;
+    /** Re-decides every tag's visibility: the model, the calibration or the mode changed. */
+    private refreshTagVisibility;
+    private surfaceKey;
+    /**
+     * Lays the grid over the model's surface.
+     *
+     * Runs once per model, in one pass over its triangles. A triangle smaller than a cell is marked
+     * by its centre, which is every triangle of a scanned model; a larger one - the two triangles of
+     * a drawn wall - is sampled across its face, or the middle of the wall would read as empty.
+     */
+    private buildSurfaceGrid;
+    /** Whether some part of the model's surface lies within `reach` of a point, in model units. */
+    private isNearSurface;
     /**
      * Moves the camera to look at a tag, mirroring Matterport's goToTag.
      *

package/lib/services/utils/matterport-framing.util.d.ts

@@ -0,0 +1,40 @@
+import { Point3D } from '../../types.service';
+/** Matterport camera rotation, in degrees (x: pitch, y: yaw) */
+export interface CameraRotation {
+    x: number;
+    y: number;
+}
+/**
+ * Camera rotation that shows `target` from `camera`, at a given horizontal place of the viewer.
+ * Matterport yaw is 0 when looking toward -Z and grows when turning left; pitch is positive upward.
+ * @param horizontalTanHalfFov tan(horizontal FOV / 2), i.e. 1 / projection[0] of the camera pose
+ * @param screenX where the target must appear, from -1 (left edge) to 1 (right edge); 0 = center.
+ *                Used when part of the viewer is covered (side panel), to frame the visible area.
+ */
+export declare function computeFramingRotation(camera: Point3D, target: Point3D, horizontalTanHalfFov?: number, screenX?: number): CameraRotation;
+/**
+ * Horizontal place (-1..1) of the center of the visible part of the viewer.
+ * @param viewer client rect of the viewer iframe
+ * @param visibleLeft / visibleRight client X bounds of the part not covered by other panels
+ */
+export declare function visibleCenterScreenX(viewer: {
+    left: number;
+    width: number;
+}, visibleLeft: number, visibleRight: number): number;
+/** Height of the floor under a sweep: its puck, or 1.5 m under the camera when the SDK gives none */
+export declare function sweepFloorY(sweep: {
+    position: Point3D;
+    puckPosition?: Point3D;
+    floorPosition?: Point3D;
+}): number;
+/**
+ * Sweep closest to an object placed at `position`, among the sweeps of the same storey: the camera
+ * of the storey below is often nearer in 3D than a sweep of the same room. A sweep is on the same
+ * storey when the object stands between 0.5 m under its floor and 3 m above it; without any such
+ * sweep, all of them are considered. Distances are measured horizontally.
+ */
+export declare function pickNearestSweepOnSameStorey(sweeps: {
+    sid: string;
+    position: Point3D;
+    floorY: number;
+}[], position: Point3D): string | null;

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

@@ -1,9 +1,11 @@
 import { Subject } from 'rxjs';
 import { MatterportService } from './matterport.service';
-import { ThreeJsService } from './threejs.service';
+import { ThreeJsMeasurement, ThreeJsService } from './threejs.service';
+import { SweepLocatorService } from './sweep-locator.service';
 import { BaseTagService } from './tag.service';
 import { DbObjectType, POI, PoiType, Comment, Equipment, Ticket, Feature, SpModule } from '../types.service';
 import { PoiService } from './models/poi.service';
+import { ThreeJsModelUp } from '../helpers.service';
 import { Config } from '../config';
 import * as i0 from "@angular/core";
 export declare class ViewerService {
@@ -12,6 +14,7 @@ export declare class ViewerService {
     private poiService;
     private matterportService;
     private threeJsService;
+    private sweepLocator;
     private viewerMode;
     currentModel3D: string;
     private tourUrl;
@@ -35,6 +38,20 @@ export declare class ViewerService {
      * lists that feed tags are exactly that.
      */
     currentSpaceID: string | null;
+    /**
+     * The Three.js capture on screen, or null in Matterport.
+     *
+     * A space can hold several 3D models. A tag placed in one is recorded with it, so that model
+     * keeps showing the tag whatever selection of tags it is otherwise restricted to.
+     */
+    currentCaptureID: string | null;
+    /**
+     * Whether the 3D model on screen has been calibrated against the tags' shared space.
+     *
+     * Calibrating is what says the model and that space overlap. Until then a tag placed in the model
+     * is in the model's own coordinates: it belongs to no Matterport sweep and to no other visit.
+     */
+    private threeJsCalibrated;
     sweepToMove: string | null;
     rotationToMove: {
         x: number;
@@ -62,7 +79,7 @@ export declare class ViewerService {
         };
     };
     private isObjectLoaded;
-    constructor(sdkKey: string, config: Config, poiService: PoiService, matterportService: MatterportService, threeJsService: ThreeJsService);
+    constructor(sdkKey: string, config: Config, poiService: PoiService, matterportService: MatterportService, threeJsService: ThreeJsService, sweepLocator: SweepLocatorService);
     checkMode(indexMode: string): boolean;
     setMode(indexMode: string): void;
     setTourUrl(options: {
@@ -102,6 +119,30 @@ export declare class ViewerService {
      * of the pipeline that already drives Matterport.
      */
     private addThreeJsTagFromPOI;
+    /**
+     * Stores the tags the last calibration had to rewrite, and returns how many it could not.
+     *
+     * Calibrating keeps the tags placed in this model where they are by changing their coordinates
+     * rather than their place (see ThreeJsService.applyAlignmentKeepingOwnTags). The scene already
+     * shows the result; this writes it down. Call it once the calibration itself is stored - with the
+     * old calibration still on record, the old coordinates are the ones that match it.
+     */
+    persistRebasedThreeJsTags(): Promise<{
+        stored: number;
+        failed: number;
+    }>;
+    /** How many tags the calibration walkthrough could still use: the ones from elsewhere. */
+    getThreeJsCalibrationCandidateCount(): number;
+    /** How many tags from elsewhere are not on the 3D model, and so are not shown on it. */
+    getThreeJsOffModelTagCount(): number;
+    /** The tags registered in the Three.js scene, shown or not. */
+    getThreeJsTags(): {
+        id: string;
+        label: string;
+        poiType: PoiType;
+        visible: boolean;
+        calibratable: boolean;
+    }[];
     /**
      * The image to draw a tag with, mirroring what Matterport shows for the same POI.
      *
@@ -178,6 +219,50 @@ export declare class ViewerService {
     action_floorplan(): Promise<void>;
     action_toolbox_mesure(): void;
     action_toolbox_cancel_mesure(): void;
+    /** While measuring in the Three.js viewer: points and segment lengths so far, null if abandoned. */
+    get threeJsMeasurementProgress$(): Subject<{
+        points: number;
+        distances: number[];
+    }>;
+    /** Ends the Three.js measurement in progress, or returns null when it has fewer than two points. */
+    finishThreeJsMeasurement(): ThreeJsMeasurement | null;
+    /** The measurement last finished in the Three.js viewer, for the form that saves it. */
+    getThreeJsLastMeasurement(): ThreeJsMeasurement | null;
+    /**
+     * The Matterport sweep nearest to a point picked in the Three.js viewer, or null.
+     *
+     * For callers that write their own POI, as the measurement form does - anything created through
+     * createPoiForThreeJsPlacement already gets this.
+     */
+    findNearestSweepForThreeJs(point: {
+        x: number;
+        y: number;
+        z: number;
+    }): Promise<string | null>;
+    /**
+     * The metadata a POI placed in the Three.js viewer is stored with: which 3D model it was placed
+     * in, and - when that model is not calibrated - that its coordinates are the model's own.
+     */
+    buildThreeJsPoiMetadata(extra?: Record<string, any>): string;
+    /** Which of the 3D model's axes is being treated as up. */
+    getThreeJsModelUp(): ThreeJsModelUp;
+    /**
+     * Turns the 3D model to the next candidate for "which axis is up", and returns the capture
+     * metadata with that choice written in, for the caller to store.
+     *
+     * The vertical axis is worked out from the geometry when a model loads, and that can be wrong:
+     * a narrow corridor and a low slab are the same shape turned over. This is the way to correct it.
+     */
+    cycleThreeJsModelUp(existingMetadata: string | null | undefined): {
+        up: ThreeJsModelUp;
+        metadata: string;
+    } | null;
+    /** Chooses the tag for the calibration pair being matched by id, instead of by clicking it. */
+    selectThreeJsAlignmentTag(elementId: string): 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. */
+    getThreeJsTagCount(): number;
     action_update_poi(poi: POI, isValid: boolean, element: DbObjectType): Promise<POI>;
     /**
      * Writes the spot picked in the Three.js scene into the POI, mirroring the Matterport branch.

package/lib/types.service.d.ts

@@ -405,7 +405,9 @@ export type POI = {
 export declare enum ViewerInteractions {
     DEFAULT = 0,
     ADDING = 1,
-    POSITIONING = 2
+    POSITIONING = 2,
+    /** A loaded 3D object follows the cursor until the user clicks (validate) or cancels */
+    PLACING_OBJECT3D = 3
 }
 export type Mission = {
     userID: string;
@@ -820,6 +822,8 @@ export type IObject3D = {
     id?: string;
     object: string;
     format: string;
+    /** Full url of the model file; when set it replaces the url built from the bundled assets */
+    url?: string;
     mode: string;
     position: {
         x: number;
@@ -838,6 +842,43 @@ export type IObject3D = {
     };
     viewFrustum: boolean;
 };
+export type Point3D = {
+    x: number;
+    y: number;
+    z: number;
+};
+/** World-space bounding box of a 3D object */
+export type Object3DBoundingBox = {
+    min: Point3D;
+    max: Point3D;
+    size: Point3D;
+    center: Point3D;
+};
+/** Local transform of a 3D object (rotation in radians, Euler XYZ) */
+export type Object3DTransform = {
+    position: Point3D;
+    rotation: Point3D;
+    scale: Point3D;
+};
+/** Emitted when the transform of a 3D object changes (gizmo drag or setObject3DTransform) */
+export type Object3DTransformChange = Object3DTransform & {
+    uuid: string;
+};
+export type GizmoMode = 'translate' | 'rotate' | 'scale';
+/** Snapping steps of the gizmo. A missing / null value disables snapping for that mode */
+export type GizmoSnap = {
+    /** meters */
+    translation?: number | null;
+    /** degrees */
+    rotationDeg?: number | null;
+    /** scale step */
+    scale?: number | null;
+};
+/** Result of an interactive placement (surface point under the cursor and its normal) */
+export type Object3DPlacementResult = {
+    position: Point3D;
+    normal: Point3D;
+};
 /**
  * DynamoDb object3D
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smarterplan/ngx-smarterplan-core",
-  "version": "1.4.19",
+  "version": "1.4.21",
   "dependencies": {
     "tslib": "^2.5.0"
   },

package/public-api.d.ts

@@ -7,6 +7,7 @@ export * from './lib/services/baseVisibility.service';
 export * from './lib/services/content.service';
 export * from './lib/services/viewer.service';
 export * from './lib/services/threejs.service';
+export * from './lib/services/sweep-locator.service';
 export * from './lib/services/navigator.service';
 export * from './lib/services/zoneChange.service';
 export * from './lib/config';