copper3d 3.6.6 → 3.6.8

package/dist/bundle.umd.js

@@ -49760,8 +49760,11 @@ void main() {
 	            this.renderer.setSize(this.container.clientWidth, this.container.clientHeight);
 	        };
 	        this.renderer = renderer;
-	        this.ambientLight = new AmbientLight(0x606060, 0.8);
-	        this.directionalLight = new DirectionalLight(0xffffff, 1.0);
+	        // three r165+ removed `useLegacyLights`; lighting is always physically
+	        // correct now, which makes the same intensity ~1/PI as dim as the old
+	        // (three <=0.150) legacy default. Scale by PI to keep the prior brightness.
+	        this.ambientLight = new AmbientLight(0x606060, 0.8 * Math.PI);
+	        this.directionalLight = new DirectionalLight(0xffffff, 1.0 * Math.PI);
 	        if (!(opt === null || opt === void 0 ? void 0 : opt.alpha)) {
 	            this.vignette = createBackground({
 	                aspect: this.container.clientWidth / this.container.clientHeight,
@@ -49846,7 +49849,7 @@ void main() {
 	    }
 	    addLights() {
 	        // Hemisphere light: sky/ground for broad ambient fill
-	        const hemiLight = new HemisphereLight(0xddeeff, 0x0f0e0d, 0.6);
+	        const hemiLight = new HemisphereLight(0xddeeff, 0x0f0e0d, 0.6 * Math.PI);
 	        hemiLight.name = "hemi_light";
 	        this.scene.add(hemiLight);
 	        // Main key light — front-right, slightly above
@@ -49856,12 +49859,12 @@ void main() {
 	        this.camera.add(this.ambientLight);
 	        this.camera.add(this.directionalLight);
 	        // Fill light — opposite side to soften shadows
-	        const fillLight = new DirectionalLight(0xffffff, 0.4);
+	        const fillLight = new DirectionalLight(0xffffff, 0.4 * Math.PI);
 	        fillLight.name = "fill_light";
 	        fillLight.position.set(-0.5, -0.2, -0.866);
 	        this.camera.add(fillLight);
 	        // Top light — illuminates the top surface that key/fill lights miss
-	        const topLight = new DirectionalLight(0xffffff, 0.5);
+	        const topLight = new DirectionalLight(0xffffff, 0.5 * Math.PI);
 	        topLight.name = "top_light";
 	        topLight.position.set(0, 1, 0.2);
 	        this.camera.add(topLight);
@@ -61173,6 +61176,15 @@ void main() {
 	        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 {
@@ -61398,6 +61410,13 @@ void main() {
 	            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";
@@ -61422,6 +61441,7 @@ void main() {
 	                label: a.label,
 	                color: a.color,
 	                closed: a.closed,
+	                visible: a.visible,
 	                points: a.vertices.map(toPt),
 	            })),
 	        };
@@ -61441,6 +61461,10 @@ void main() {
 	        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();
@@ -61467,14 +61491,18 @@ void main() {
 	                (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;
@@ -61488,13 +61516,14 @@ void main() {
 	                    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);
@@ -61504,7 +61533,7 @@ void main() {
 	                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) {
@@ -61531,15 +61560,26 @@ void main() {
 	            }
 	        };
 	        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) {
@@ -61564,6 +61604,7 @@ void main() {
 	                        label: `Contour ${this.seq}`,
 	                        color: this.freehandColor,
 	                        closed: false,
+	                        visible: true,
 	                        vertices: verts,
 	                        object3D: this.activeLine,
 	                    };
@@ -61581,11 +61622,17 @@ void main() {
 	            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;
 	            }
@@ -61618,7 +61665,11 @@ void main() {
 	        };
 	        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();
 	            }
 	        };
@@ -61674,6 +61725,10 @@ void main() {
 	        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);
 	    }
@@ -61736,10 +61791,92 @@ void main() {
 	    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() {
@@ -61757,6 +61894,11 @@ void main() {
 	                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());
 	    }
@@ -61764,6 +61906,8 @@ void main() {
 	        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;
@@ -61996,6 +62140,7 @@ void main() {
 	                label: `Contour ${this.seq}`,
 	                color: this.geodesicColor,
 	                closed,
+	                visible: true,
 	                vertices: verts,
 	                object3D: this.activeGeoLine,
 	            };
@@ -62029,7 +62174,8 @@ void main() {
 	        window.removeEventListener("keyup", this.onKeyUp);
 	        window.removeEventListener("resize", this.onResize);
 	    }
-	}
+	}
+	SurfaceAnnotator.TAP_MS = 250;
 
 	class copperScene extends baseScene {
 	    // rayster pick
@@ -83452,15 +83598,15 @@ void main() {
 	}
 
 	// import * as kiwrious from "copper3d_plugin_heart_k";
-	// "v3.6.6" is injected at build time by rollup @rollup/plugin-replace, sourced from package.json version.
+	// "v3.6.8" 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.6";
+	    _revision = "v3.6.8";
 	}
 	catch (_a) {
-	    /* "v3.6.6" not injected (local source build) */
+	    /* "v3.6.8" 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__

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

@@ -29,6 +29,10 @@ export declare class MeshGraph {
     shortestPath(startV: number, endV: number): number[];
     vertexWorld(i: number, matrixWorld: THREE.Matrix4): THREE.Vector3;
     vertexNormalWorld(i: number, mesh: THREE.Mesh): THREE.Vector3;
+    /** Vertex local normal at index i (reads from the welded graphGeo normal attribute). */
+    vertexNormalLocal(i: number): THREE.Vector3;
+    /** Normal at the vertex nearest to localPoint (for recovering normals from imported point coordinates). */
+    nearestNormalLocal(p: THREE.Vector3): THREE.Vector3;
     /** Vertex local coordinates + local normal (the graph geometry is already local space). */
     vertexLocal(i: number): {
         x: number;

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

@@ -31,6 +31,12 @@ 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). */
+    onInteractionChange?: (s: {
+        drawing: boolean;
+        armed: AnnotationMode;
+        locked: boolean;
+    }) => void;
 }
 /**
  * Main surface-annotation controller (Phase 4): four modes navigate / freehand / geodesic / point,
@@ -42,6 +48,11 @@ export declare class SurfaceAnnotator {
     private o;
     private mode;
     private spaceHeld;
+    private drawLock;
+    private armed;
+    private spaceDownAt;
+    private spaceDragged;
+    private static readonly TAP_MS;
     private pointerDown;
     private readonly markerRadius;
     private readonly epsilon;
@@ -91,9 +102,29 @@ export declare class SurfaceAnnotator {
             label: string;
             color: string;
             closed: boolean;
+            visible: boolean;
             points: number[][];
         }[];
     };
+    setVisible(id: string, visible: boolean): void;
+    /**
+     * 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: {
+        annotations: Array<{
+            id?: string;
+            type: "contour" | "points";
+            mode: "freehand" | "geodesic" | null;
+            label: string;
+            color: string;
+            closed: boolean;
+            visible?: boolean;
+            points: number[][];
+        }>;
+    }): number;
+    private get drawing();
     private applyCameraGating;
     /** Reconcile the scene against store.list(): add missing objects, remove deleted ones (no dispose, kept for undo restore). */
     private reconcile;

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

@@ -20,6 +20,7 @@ export declare class AnnotationStore {
     get(id: string): Annotation | undefined;
     setLabel(id: string, label: string): void;
     setColor(id: string, color: string): void;
+    setVisible(id: string, visible: boolean): void;
     toJSON(modelName: string, mesh: THREE.Mesh, opts?: ExportOptions): {
         model: string;
         exportedAt: string;
@@ -31,6 +32,7 @@ export declare class AnnotationStore {
             label: string;
             color: string;
             closed: boolean;
+            visible: boolean;
             points: number[][];
         }[];
     };

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

@@ -22,6 +22,7 @@ export interface Annotation {
     label: string;
     color: string;
     closed: boolean;
+    visible: boolean;
     vertices: AnnotationVertex[];
     object3D: THREE.Object3D | null;
 }

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.6",
+  "version": "3.6.8",
   "main": "dist/bundle.umd.js",
   "moudle": "dist/bundle.esm.js",
   "types": "dist/types/index.d.ts",