copper3d 3.6.5 → 3.6.7

package/dist/bundle.esm.js

@@ -61165,6 +61165,15 @@ class MeshGraph {
         const nm = new Matrix3().getNormalMatrix(mesh.matrixWorld);
         return n.applyMatrix3(nm).normalize();
     }
+    /** Vertex local normal at index i (reads from the welded graphGeo normal attribute). */
+    vertexNormalLocal(i) {
+        return new Vector3(this.normals ? this.normals[i * 3] : 0, this.normals ? this.normals[i * 3 + 1] : 0, this.normals ? this.normals[i * 3 + 2] : 1);
+    }
+    /** Normal at the vertex nearest to localPoint (for recovering normals from imported point coordinates). */
+    nearestNormalLocal(p) {
+        const i = this.nearestVertex(p);
+        return this.vertexNormalLocal(i);
+    }
     /** Vertex local coordinates + local normal (the graph geometry is already local space). */
     vertexLocal(i) {
         return {
@@ -61390,6 +61399,13 @@ class AnnotationStore {
             this.notify();
         }
     }
+    setVisible(id, visible) {
+        const a = this.get(id);
+        if (a) {
+            a.visible = visible;
+            this.notify();
+        }
+    }
     toJSON(modelName, mesh, opts = {}) {
         var _a;
         const space = (_a = opts.space) !== null && _a !== void 0 ? _a : "local";
@@ -61414,6 +61430,7 @@ class AnnotationStore {
                 label: a.label,
                 color: a.color,
                 closed: a.closed,
+                visible: a.visible,
                 points: a.vertices.map(toPt),
             })),
         };
@@ -61433,6 +61450,10 @@ class SurfaceAnnotator {
         var _a, _b, _c;
         this.mode = "navigate";
         this.spaceHeld = false;
+        this.drawLock = false;
+        this.armed = "freehand";
+        this.spaceDownAt = 0;
+        this.spaceDragged = false;
         this.pointerDown = false;
         this.store = new AnnotationStore();
         this.managed = new Set();
@@ -61459,14 +61480,18 @@ class SurfaceAnnotator {
                 (this.activeGeoLine.material.resolution.set(w, h));
         };
         this.onPointerDown = (e) => {
-            if (this.spaceHeld)
-                return;
             if (e.button !== 0)
                 return; // left button only
             if (!this.insideContainer(e))
                 return;
             this.pointerDown = true;
-            if (this.mode === "point") {
+            // Only act with the armed tool when in drawing mode (drawLock or spaceHeld).
+            // When not drawing, navigation is the default — pointer events go to camera controls.
+            if (!this.drawing)
+                return;
+            // Use armed tool (not this.mode which may be "navigate")
+            const activeTool = this.armed;
+            if (activeTool === "point") {
                 const h = this.hit(e);
                 if (!h)
                     return;
@@ -61480,13 +61505,14 @@ class SurfaceAnnotator {
                     label: `Point ${this.seq}`,
                     color: this.pointColorVal,
                     closed: false,
+                    visible: true,
                     vertices: [v],
                     object3D: marker,
                 };
                 this.store.add(ann);
                 return;
             }
-            if (this.mode === "freehand") {
+            if (activeTool === "freehand") {
                 this.activeStroke = new StrokeContour(this.minGap, this.maxJump, this.o.mesh);
                 this.activeStroke.begin();
                 const h = this.hit(e);
@@ -61496,7 +61522,7 @@ class SurfaceAnnotator {
                 this.o.scene.add(this.activeLine);
                 return;
             }
-            if (this.mode === "geodesic") {
+            if (activeTool === "geodesic") {
                 // First check whether an existing anchor was clicked → cancel that point (any point can be canceled).
                 const pick = this.pickGeoMarker(e);
                 if (pick >= 0 && this.activeGeo) {
@@ -61523,15 +61549,26 @@ class SurfaceAnnotator {
             }
         };
         this.onPointerMove = (e) => {
-            if (this.spaceHeld) {
-                this.setGeoHover(-1);
+            // Track if user dragged while space was held (so a hold-drag is not treated as a tap).
+            if (this.spaceHeld && this.pointerDown) {
+                this.spaceDragged = true;
+            }
+            // When not drawing, navigation is default — don't interfere with camera controls.
+            if (!this.drawing) {
+                // In geodesic mode we can still show the hover hint when not drawing.
+                if (this.armed === "geodesic" && !this.pointerDown) {
+                    this.setGeoHover(this.insideContainer(e) ? this.pickGeoMarker(e) : -1);
+                }
+                else {
+                    this.setGeoHover(-1);
+                }
                 return;
             }
-            // In geodesic mode, show the "✕" hint when hovering an anchor sphere (that point can be clicked to cancel).
-            if (this.mode === "geodesic" && !this.pointerDown) {
+            // Drawing mode: geodesic hover hint
+            if (this.armed === "geodesic" && !this.pointerDown) {
                 this.setGeoHover(this.insideContainer(e) ? this.pickGeoMarker(e) : -1);
             }
-            if (this.mode === "freehand" &&
+            if (this.armed === "freehand" &&
                 this.pointerDown &&
                 this.activeStroke &&
                 this.activeLine) {
@@ -61556,6 +61593,7 @@ class SurfaceAnnotator {
                         label: `Contour ${this.seq}`,
                         color: this.freehandColor,
                         closed: false,
+                        visible: true,
                         vertices: verts,
                         object3D: this.activeLine,
                     };
@@ -61573,11 +61611,17 @@ class SurfaceAnnotator {
             if (this.isTypingTarget(e))
                 return;
             if (e.code === "Space") {
+                if (!this.spaceHeld) {
+                    this.spaceDownAt = performance.now();
+                    this.spaceDragged = false;
+                }
                 this.spaceHeld = true;
                 this.applyCameraGating();
+                e.preventDefault();
                 return;
             }
             if (e.key === "Escape") {
+                this.drawLock = false;
                 this.setMode("navigate");
                 return;
             }
@@ -61610,7 +61654,11 @@ class SurfaceAnnotator {
         };
         this.onKeyUp = (e) => {
             if (e.code === "Space") {
+                const held = performance.now() - this.spaceDownAt;
                 this.spaceHeld = false;
+                if (held <= SurfaceAnnotator.TAP_MS && !this.spaceDragged) {
+                    this.drawLock = !this.drawLock; // tap toggles lock
+                }
                 this.applyCameraGating();
             }
         };
@@ -61666,6 +61714,10 @@ class SurfaceAnnotator {
         if (m !== "geodesic" && this.activeGeo)
             this.clearActiveGeo();
         this.mode = m;
+        // Record armed tool when choosing a drawing mode (not navigate).
+        // Camera gating is NOT changed here — the user must use Space to enter drawing.
+        if (m !== "navigate")
+            this.armed = m;
         this.applyCameraGating();
         (_b = (_a = this.o).onModeChange) === null || _b === void 0 ? void 0 : _b.call(_a, m);
     }
@@ -61728,10 +61780,92 @@ class SurfaceAnnotator {
     exportJSON(modelName, opts) {
         return this.store.toJSON(modelName, this.o.mesh, opts);
     }
+    setVisible(id, visible) {
+        this.store.setVisible(id, visible);
+    }
+    /**
+     * Rebuild annotations from an exported payload (local-space points). Normals are taken from the
+     * point when present ([x,y,z,nx,ny,nz]); otherwise recovered from the welded graph's nearest
+     * vertex. Each imported item becomes first-class (select/recolor/hide/delete/export).
+     */
+    importAnnotations(payload) {
+        var _a, _b, _c, _d;
+        let count = 0;
+        let maxImported = this.seq;
+        for (const a of (_a = payload.annotations) !== null && _a !== void 0 ? _a : []) {
+            const verts = a.points.map((p) => {
+                const [x, y, z] = p;
+                let nx = p[3], ny = p[4], nz = p[5];
+                if (nx === undefined || ny === undefined || nz === undefined) {
+                    const nrm = this.graph.nearestNormalLocal(new Vector3(x, y, z));
+                    nx = nrm.x;
+                    ny = nrm.y;
+                    nz = nrm.z;
+                }
+                return { x, y, z, nx, ny, nz, faceIndex: 0 };
+            });
+            if (a.type === "points") {
+                for (const v of verts) {
+                    // Only reuse the provided id for a single-point entry (the round-trip case);
+                    // a multi-point points entry must get a fresh id per marker to avoid duplicate keys.
+                    const id = a.id && verts.length === 1 ? a.id : this.nextId();
+                    const marker = makePointMarker(v, this.o.mesh, a.color, this.markerRadius);
+                    this.o.scene.add(marker);
+                    this.store.add({
+                        id,
+                        type: "points",
+                        mode: null,
+                        label: a.label,
+                        color: a.color,
+                        closed: false,
+                        visible: (_b = a.visible) !== null && _b !== void 0 ? _b : true,
+                        vertices: [v],
+                        object3D: marker,
+                    });
+                    // track max numeric id
+                    const m = id.match(/^a(\d+)$/);
+                    if (m)
+                        maxImported = Math.max(maxImported, parseInt(m[1], 10));
+                    count++;
+                }
+            }
+            else {
+                if (verts.length < 2)
+                    continue;
+                const id = (_c = a.id) !== null && _c !== void 0 ? _c : this.nextId();
+                const line = makeContourLine(verts, a.color, a.closed, this.o.container, this.epsilon, this.o.mesh);
+                this.o.scene.add(line);
+                this.store.add({
+                    id,
+                    type: "contour",
+                    mode: a.mode,
+                    label: a.label,
+                    color: a.color,
+                    closed: a.closed,
+                    visible: (_d = a.visible) !== null && _d !== void 0 ? _d : true,
+                    vertices: verts,
+                    object3D: line,
+                });
+                const m = id.match(/^a(\d+)$/);
+                if (m)
+                    maxImported = Math.max(maxImported, parseInt(m[1], 10));
+                count++;
+            }
+        }
+        // keep seq ahead of any imported numeric ids to avoid collisions
+        if (maxImported > this.seq)
+            this.seq = maxImported;
+        return count;
+    }
     // ---- Internal ----
+    get drawing() {
+        return this.drawLock || this.spaceHeld;
+    }
     applyCameraGating() {
-        // Holding Space for temporary rotation takes priority; otherwise enable the camera only in navigate mode.
-        this.o.controls.enabled = this.spaceHeld || this.mode === "navigate";
+        var _a, _b;
+        // Default is navigate (camera enabled). Drawing only when drawLock or spaceHeld.
+        this.o.controls.enabled = !this.drawing;
+        (_b = (_a = this.o).onInteractionChange) === null || _b === void 0 ? void 0 : _b.call(_a, { drawing: this.drawing, armed: this.armed, locked: this.drawLock });
     }
     /** Reconcile the scene against store.list(): add missing objects, remove deleted ones (no dispose, kept for undo restore). */
     reconcile() {
@@ -61749,6 +61883,11 @@ class SurfaceAnnotator {
                 this.o.scene.add(o);
         }
         this.managed = present;
+        // Apply per-annotation visibility
+        for (const a of this.store.list()) {
+            if (a.object3D)
+                a.object3D.visible = a.visible;
+        }
         this.applySelection();
         (_b = (_a = this.o).onChange) === null || _b === void 0 ? void 0 : _b.call(_a, this.store.list());
     }
@@ -61756,6 +61895,8 @@ class SurfaceAnnotator {
         for (const a of this.store.list()) {
             if (!a.object3D)
                 continue;
+            if (!a.visible)
+                continue;
             const sel = a.id === this.selectedId;
             if (a.type === "contour") {
                 const mat = a.object3D.material;
@@ -61988,6 +62129,7 @@ class SurfaceAnnotator {
                 label: `Contour ${this.seq}`,
                 color: this.geodesicColor,
                 closed,
+                visible: true,
                 vertices: verts,
                 object3D: this.activeGeoLine,
             };
@@ -62021,7 +62163,8 @@ class SurfaceAnnotator {
         window.removeEventListener("keyup", this.onKeyUp);
         window.removeEventListener("resize", this.onResize);
     }
-}
+}
+SurfaceAnnotator.TAP_MS = 250;
 
 class copperScene extends baseScene {
     // rayster pick
@@ -83011,12 +83154,20 @@ class NrrdTools {
         return this.drawCore.aiAssistTool.getScratchSegments();
     }
     /**
-     * Merge the AI scratch into a target layer as a single undoable group (sandbox
-     * merge — best-practice: non-destructive + one Ctrl+Z). The scratch's channel
-     * labels are PRESERVED (each AI channel maps onto the same channel of the
-     * target layer). Scans all z-slices, so voxels painted from any view are caught.
+     * Merge the AI scratch into a target layer with an explicit per-segmentation
+     * mapping, as a single undoable group (sandbox merge — non-destructive + one
+     * Ctrl+Z). `mapping` is `{ AI scratch label -> target channel(1-8) }`; any label
+     * absent from the mapping (or mapped to 0) is DISCARDED (not merged). Several AI
+     * labels MAY map to the SAME channel — after merge the channel is the identity
+     * (CLAUDE.md decision M2), so the merged voxels take that channel's fixed colour.
+     *
+     * UNION semantics (M4): an AI voxel only fills a target voxel that is currently
+     * EMPTY (0) — existing manual annotation is NEVER erased. Where two AI labels map
+     * to different channels and overlap the same voxel, the first one written wins
+     * (iteration order), an accepted edge case for a single-value-per-voxel mask.
+     * Scans all z-slices, so voxels painted from any view are caught.
      */
-    aiCommitToLayer(targetLayer = "layer1") {
+    aiCommitToLayerMapped(targetLayer, mapping) {
         const scratch = this.drawCore.aiAssistTool.getScratchVolume();
         if (!scratch)
             return;
@@ -83038,10 +83189,21 @@ class NrrdTools {
                 continue;
             const oldSlice = target.getSliceUint8(z, "z").data; // copy
             const newSlice = oldSlice.slice();
+            let changed = false;
             for (let i = 0; i < newSlice.length; i++) {
-                if (sc[i] !== 0)
-                    newSlice[i] = sc[i]; // preserve the AI channel label
+                const label = sc[i];
+                if (label === 0)
+                    continue;
+                const ch = mapping[label];
+                if (!ch)
+                    continue; // unmapped / discarded segmentation
+                if (newSlice[i] === 0) { // union: fill only EMPTY voxels (M4)
+                    newSlice[i] = ch;
+                    changed = true;
+                }
             }
+            if (!changed)
+                continue; // nothing landed on this slice → no delta
             target.setSliceUint8(z, newSlice, "z");
             deltas.push({ layerId: targetLayer, axis: "z", sliceIndex: z, oldSlice, newSlice: newSlice.slice() });
         }
@@ -83049,6 +83211,19 @@ class NrrdTools {
             this.drawCore.undoManager.pushGroup(deltas);
         this.reloadMasksFromVolume();
     }
+    /**
+     * Back-compat shim: merge with an IDENTITY mapping (each AI label → the same
+     * channel number) via the mapped path above. Newer callers should use
+     * `aiCommitToLayerMapped` with an explicit per-segmentation mapping.
+     */
+    aiCommitToLayer(targetLayer = "layer1") {
+        var _a;
+        const segs = this.drawCore.aiAssistTool.getScratchSegments();
+        const mapping = {};
+        for (const s of (_a = segs === null || segs === void 0 ? void 0 : segs.segments) !== null && _a !== void 0 ? _a : [])
+            mapping[s.label] = s.label;
+        this.aiCommitToLayerMapped(targetLayer, mapping);
+    }
     // ═══════════════════════════════════════════════════════════════════════════
     // 11. Clear / Reset
     // ═══════════════════════════════════════════════════════════════════════════
@@ -83412,8 +83587,17 @@ function evaluateElement(element, weights) {
 }
 
 // import * as kiwrious from "copper3d_plugin_heart_k";
-// "v3.6.5" is injected at build time by rollup @rollup/plugin-replace, sourced from package.json version
-const REVISION = "v3.6.5";
+// "v3.6.7" is injected at build time by rollup @rollup/plugin-replace, sourced from package.json version.
+// When copper3d is consumed from local source (no rollup replace step), the identifier is undefined and
+// referencing it throws a ReferenceError — guard it so local loading still works.
+let _revision = "unknown";
+try {
+    _revision = "v3.6.7";
+}
+catch (_a) {
+    /* "v3.6.7" not injected (local source build) */
+}
+const REVISION = _revision;
 // Expose on global so the version can be read in a production browser console via window.__COPPER3D_VERSION__
 if (typeof window !== "undefined") {
     window.__COPPER3D_VERSION__ = REVISION;