copper3d 3.6.8 → 3.6.10

package/dist/types/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;

package/dist/types/Utils/surfaceAnnotation/annotationStore.d.ts

@@ -21,19 +21,12 @@ export declare class AnnotationStore {
     setLabel(id: string, label: string): void;
     setColor(id: string, color: string): void;
     setVisible(id: string, visible: boolean): void;
+    /** Notify subscribers after an in-place mutation of an existing annotation (e.g. geodesic edit re-commit). */
+    touch(): void;
     toJSON(modelName: string, mesh: THREE.Mesh, 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>[];
     };
 }

package/dist/types/Utils/surfaceAnnotation/geodesicContour.d.ts

@@ -17,6 +17,22 @@ export declare class GeodesicContour {
     private snapshot;
     /** Given a local hit point, snap to the nearest vertex and compute the path to the previous anchor. */
     addAnchor(localHitPoint: THREE.Vector3): void;
+    /** Move the anchor at `index` to the vertex nearest `localHitPoint`, rebuilding adjacent segments live. */
+    moveAnchorTo(index: number, localHitPoint: THREE.Vector3): void;
+    /** Anchor vertex indices (persisted on a committed geodesic so it can be re-opened for editing). */
+    getAnchorIndices(): number[];
+    /** Rebuild an editable contour from stored anchor vertex indices (re-opening a committed geodesic). */
+    static fromAnchors(graph: MeshGraph, mesh: THREE.Mesh, indices: number[]): GeodesicContour;
+    /** Insert a new anchor (snapped to the nearest vertex) at position `index`, rebuilding segments. */
+    insertAnchorAt(index: number, localHitPoint: THREE.Vector3): void;
+    /**
+     * Which anchor interval's surface path passes closest to `worldPoint` — i.e. the edge the user
+     * clicked on, so a new anchor can be inserted there. Returns the interval index (insert after that
+     * anchor, i.e. at index+1), or -1 when there are fewer than 2 anchors or the click is farther than
+     * `maxDist` (world units) from every edge. For a closed contour the trailing closing edge
+     * (last→first) is considered and maps to appending at the end.
+     */
+    nearestInsertIndex(worldPoint: THREE.Vector3, matrixWorld: THREE.Matrix4, closed: boolean, maxDist: number): number;
     /** Remove the anchor at the given index and recompute adjacent segments (allows canceling any middle point). */
     removeAnchorAt(index: number): void;
     /** Whether there is still an editable change to undo (add/remove point). */
@@ -30,4 +46,14 @@ export declare class GeodesicContour {
     get anchorCount(): number;
     /** Stitch all path vertices (world) + normals into a polyline; when closed, add one first-to-last segment. */
     buildVertices(closed: boolean): AnnotationVertex[];
+    /**
+     * Relax the stitched shortest-path polyline so it reads as a smooth curve instead of the raw
+     * voxel staircase, WITHOUT changing the point count (keeps editing/index mapping simple) and
+     * WITHOUT moving the anchors (they stay exact control points). A few Laplacian passes pull each
+     * interior point toward the midpoint of its neighbours; anchors and (for open paths) the two
+     * endpoints are pinned. Normals are carried over from each point's original graph vertex — the
+     * points only shift slightly and the line already floats above the surface by `epsilon`, so the
+     * approximation is invisible and avoids an O(V) nearest-vertex scan per point on every redraw.
+     */
+    private smoothPath;
 }

package/dist/types/Utils/surfaceAnnotation/pointMarkers.d.ts

@@ -6,3 +6,11 @@ import type { AnnotationVertex } from "./types";
  * radius is passed in by the caller, scaled to the model bbox.
  */
 export declare function makePointMarker(v: AnnotationVertex, mesh: THREE.Mesh, color: string, radius: number): THREE.Mesh;
+/**
+ * Create a draggable ANCHOR HANDLE (for the geodesic editor): a white outer rim around a
+ * tool-colored core, so the handle stands out against both the (same-colored) contour line and the
+ * grey surface. Returned as a Group; scale it to show hover/selection feedback. depthTest stays ON
+ * (occluded by the model on the far side) and it's lifted a touch more than a plain marker so it
+ * sits above the thickened line rather than sinking into it.
+ */
+export declare function makeAnchorHandle(v: AnnotationVertex, mesh: THREE.Mesh, coreColor: string, radius: number): THREE.Group;

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

@@ -24,6 +24,12 @@ export interface Annotation {
     closed: boolean;
     visible: boolean;
     vertices: AnnotationVertex[];
+    /**
+     * Geodesic control points (local-space positions) — present only for geodesic contours. Lets a
+     * committed contour be re-opened for editing (drag/delete/insert its anchors). Stored as positions
+     * (not graph indices) so it survives export/import across sessions.
+     */
+    anchors?: AnnotationVertex[];
     object3D: THREE.Object3D | null;
 }
 export interface ExportOptions {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "copper3d",
   "description": "A 3d visualisation package base on threejs provides multiple scenes and Nrrd image load funtion.",
-  "version": "3.6.8",
+  "version": "3.6.10",
   "main": "dist/bundle.umd.js",
   "moudle": "dist/bundle.esm.js",
   "types": "dist/types/index.d.ts",