copper3d 3.6.9 → 3.6.10

package/dist/Utils/surfaceAnnotation/SurfaceAnnotator.d.ts

@@ -31,11 +31,15 @@ export interface SurfaceAnnotatorOptions {
     onModeChange?: (m: AnnotationMode) => void;
     /** Callback when the annotation list changes (add/remove/undo/clear). */
     onChange?: (annotations: Annotation[]) => void;
-    /** Callback when interaction state changes (drawing, armed tool, draw-lock status). */
+    /** Callback when the engine changes the selection itself (delete, deselect-on-navigate) so the UI can mirror it. */
+    onSelectionChange?: (id: string | null) => void;
+    /** Callback when interaction state changes (drawing, armed tool, draw-lock status, geodesic-editing). */
     onInteractionChange?: (s: {
         drawing: boolean;
         armed: AnnotationMode;
         locked: boolean;
+        /** True while a geodesic is editable (in-progress or a re-opened committed one) → its anchors can be dragged/deleted/inserted. */
+        editing: boolean;
     }) => void;
 }
 /**
@@ -71,10 +75,15 @@ export declare class SurfaceAnnotator {
     private activeGeoMarkers;
     private geoRay;
     private geoNdc;
-    private geoHoverBadge?;
     private hoveredGeoMarker;
+    private draggingAnchor;
+    private geoRedrawScheduled;
+    private editingId;
+    private geoClosed;
     private _projV;
     constructor(opts: SurfaceAnnotatorOptions);
+    /** Block the OS right-click menu when the pointer is over the WebGL canvas (not the HTML panels). */
+    private onContextMenu;
     /** Update the pixel resolution of all fat lines on window resize, otherwise line width distorts. */
     private onResize;
     private get freehandColor();
@@ -89,22 +98,15 @@ export declare class SurfaceAnnotator {
     clearAll(): void;
     deleteAnnotation(id: string): void;
     selectAnnotation(id: string | null): void;
+    /** Change the selection from inside the engine (delete / deselect-on-navigate) and mirror it to the UI. */
+    private setSelected;
     /** Redraw the corresponding three object after a color change. */
     refreshAnnotation(id: string): void;
     exportJSON(modelName: string, opts?: ExportOptions): {
         model: string;
         exportedAt: string;
         space: "local" | "world";
-        annotations: {
-            id: string;
-            type: "contour" | "points";
-            mode: "freehand" | "geodesic" | null;
-            label: string;
-            color: string;
-            closed: boolean;
-            visible: boolean;
-            points: number[][];
-        }[];
+        annotations: Record<string, unknown>[];
     };
     setVisible(id: string, visible: boolean): void;
     /**
@@ -122,15 +124,20 @@ export declare class SurfaceAnnotator {
             closed: boolean;
             visible?: boolean;
             points: number[][];
+            anchors?: number[][];
         }>;
     }): number;
     private get drawing();
     private applyCameraGating;
+    /** Emit the current interaction state (camera gating + whether a geodesic is editable). */
+    private emitInteraction;
     /** Reconcile the scene against store.list(): add missing objects, remove deleted ones (no dispose, kept for undo restore). */
     private reconcile;
     private applySelection;
     private disposeObject;
     private nextId;
+    /** Parse a raw exported point ([x,y,z] or [x,y,z,nx,ny,nz], local space) into an AnnotationVertex, recovering the normal from the nearest graph vertex when absent. */
+    private rawToVertex;
     private hit;
     /**
      * Whether the event target is the WebGL canvas inside the container.
@@ -141,6 +148,10 @@ export declare class SurfaceAnnotator {
      */
     private insideContainer;
     private onPointerDown;
+    /** After any anchor edit: refresh markers + line; drop/delete the contour when it becomes degenerate. */
+    private afterGeoEdit;
+    /** Coalesce live drag redraws to one per animation frame (moveAnchorTo runs Dijkstra per move). */
+    private scheduleGeoRedraw;
     /**
      * Pick an in-progress anchor: return the index of the nearest anchor (screen pixel distance <
      * tolerance), or -1 on a miss.
@@ -154,15 +165,14 @@ export declare class SurfaceAnnotator {
      * radius to make it easy to hit.
      */
     private pickGeoMarker;
-    /** Set the currently hovered anchor (-1 = none): update highlight scale, cursor, and the "✕ (cancel)" floating badge. */
+    /**
+     * Set the currently hovered anchor (-1 = none): scale it up as a highlight and show a "grab"
+     * cursor to signal it's draggable. Delete is now a right-click (no floating ✕ affordance).
+     */
     private setGeoHover;
-    /** Lazily create the floating ✕ badge (appended inside the container, pointer-events:none so it doesn't block clicks). */
-    private ensureGeoBadge;
-    /** Position the ✕ badge at the anchor's screen projection (dead center, i.e. where the cursor hovers, to avoid ambiguity). */
-    private positionGeoBadge;
-    /** Rebuild the visible anchor spheres from the current anchors (slightly larger than placed points, so they're easy to see and click to cancel). */
+    /** Rebuild the visible anchor spheres from the current anchors (slightly larger than placed points, so they're easy to see and grab). */
     private rebuildGeoMarkers;
-    /** Redraw the in-progress geodesic from the current anchors (not closed); remove the line when fewer than two points. */
+    /** Redraw the active geodesic from its current anchors (honoring the closed state); when editing a committed contour, also keep the stored annotation data in sync so export stays correct. */
     private redrawGeoLine;
     /** Discard the in-progress geodesic: remove and dispose the line and all anchors. */
     private clearActiveGeo;
@@ -175,6 +185,18 @@ export declare class SurfaceAnnotator {
     private surfacePathBetween;
     /** Finish the current geodesic: close it into a ring and commit it as one contour. */
     private finishGeodesic;
+    /**
+     * Re-open a committed geodesic contour for editing: rebuild its anchors (from the stored positions)
+     * as draggable markers and reuse its line for live updates. No-op for non-geodesic / anchorless
+     * annotations. The edit session ends on Enter / mode-switch / selecting another / Esc.
+     */
+    private tryOpenGeoEdit;
+    /**
+     * Finalize an edit session on a committed geodesic: the annotation data was kept in sync live
+     * (redrawGeoLine), so here we just remove the edit markers, notify subscribers, and end the
+     * session — or delete the annotation if it was reduced below 2 anchors.
+     */
+    private recommitGeodesic;
     private isTypingTarget;
     private onKeyDown;
     private onKeyUp;