copper3d 3.6.2 → 3.6.5

package/dist/Utils/segmentation/tools/AiAssistTool.d.ts

@@ -26,7 +26,7 @@ import type { SliceRenderHostDeps } from "./ToolHost";
 /** Scratch volume key in maskData.volumes — kept OUT of image.layers so
  *  compositeAllLayers ignores it (we render it ourselves in start()). */
 export declare const AI_SCRATCH_LAYER = "aiScratch";
-export type AiPromptTool = "point" | "box" | "scribble";
+export type AiPromptTool = "point" | "box" | "scribble" | "lasso";
 export interface AiPromptPoint {
     x: number;
     y: number;
@@ -48,6 +48,9 @@ export interface AiPromptPayload {
     };
     scribble?: AiPromptPoint[];
     scribbleRadius?: number;
+    /** Closed-contour lasso: ordered contour points (implicitly closed — the
+     *  backend connects the last point back to the first). One contour per gesture. */
+    lasso?: AiPromptPoint[];
 }
 export interface AiMaskResult {
     axis: "x" | "y" | "z";
@@ -73,29 +76,70 @@ export declare class AiAssistTool extends BaseTool {
     private committedVol;
     private promptTool;
     private polarity;
-    /** Target channel/label (1-8) the AI paints into — the "AI layer" channel. */
-    private channel;
+    /** The label value (1-255) the AI currently paints into = the active Segmentation.
+     *  Each Segmentation is a label value in the single-channel scratch volume; its
+     *  colour lives in the volume's colorMap (set via setSegmentColor). */
+    private activeLabel;
     /** Scribble brush radius (px), user-adjustable via slider. */
     private scribbleSize;
     /** Accumulated prompts for the CURRENT slice; reset on slice/axis change. */
     private points;
     private scribble;
+    /** Lasso contour sent to the backend (densified along the curve at finish). */
+    private lasso;
     private box;
     private activeSlice;
+    /** Placed lasso vertices (voxel + screen + polarity). Empty = not editing. */
+    private lassoVerts;
+    /** Undo / redo snapshot stacks of the vertex list (for Ctrl+Z / Ctrl+Y). */
+    private lassoUndo;
+    private lassoRedo;
+    /** Index of the vertex currently hovered (shows a red ✕; click removes it). −1 = none. */
+    private lassoHoverIdx;
+    /** Screen-pixel radius for hit-testing a hovered vertex. */
+    private static readonly LASSO_HIT_R;
+    /** Double-click detection (a dbl-click finishes the lasso). */
+    private lastLassoDownTime;
+    private lastLassoDownPos;
     private dragging;
     private dragStart;
     private dragScreenStart;
     private dragScreen;
     private screenScribble;
     private hoverScreen;
+    /** Hide the point seed markers once a prediction has painted (only the mask
+     *  should remain). A new point click re-shows them until its mask returns. */
+    private hidePointMarkers;
     /** Fired when a prompt gesture completes — app calls backend, then applyMask(). */
     onPrompt: ((payload: AiPromptPayload) => void) | null;
+    /** Fired whenever the lasso vertex set changes (add/delete/undo/redo/finish/cancel),
+     *  so the panel can reactively show the Finish button + vertex count. */
+    onLassoChange: ((count: number, editing: boolean) => void) | null;
     constructor(ctx: ToolContext, host: AiAssistHostDeps);
     setPromptTool(tool: AiPromptTool): void;
     setPolarity(label: number): void;
     setScribbleSize(size: number): void;
-    setChannel(channel: number): void;
-    getChannel(): number;
+    /** Select the active Segmentation by its label value (1-255). Switching starts a
+     *  fresh prompt set — otherwise accumulated prompts would be re-predicted and
+     *  repainted into the new label, recolouring the previous segmentation's region. */
+    setActiveSegment(label: number): void;
+    getActiveLabel(): number;
+    /** Set a Segmentation's colour (its label's entry in the scratch volume colorMap).
+     *  The 2D overlay repaints next frame (copper3d's render loop re-reads the map). */
+    setSegmentColor(label: number, color: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    }): void;
+    /** "New segmentation": freeze the current regions (so they persist) and switch to
+     *  a fresh label, exactly like the old "New region" but targeting a new label. */
+    newSegment(label: number): void;
+    /** Delete a Segmentation: erase every voxel painted with its label from BOTH the
+     *  live scratch and the frozen (committed) volume, so the region disappears from
+     *  the view (otherwise orphaned label voxels would render with the wrong colour).
+     *  Goes via setRawData so the volume's version counter bumps (overlay repaints). */
+    clearSegment(label: number): void;
     getScratchVolume(): MaskVolume | null;
     /** Serialize the scratch volume as per-z-slice RLE (only NON-empty slices),
      *  for persisting to ai_generated_nii_LPS on the backend. Binary (any channel →
@@ -111,6 +155,22 @@ export declare class AiAssistTool extends BaseTool {
             rle: number[];
         }[];
     } | null;
+    /** Per-SEGMENTATION serialization for the 3D build: one binary RLE per non-empty
+     *  z-slice PER label (no binarize-merge), so the backend writes a multi-label
+     *  NIfTI and colours the GLB per segmentation. Includes both live and frozen
+     *  regions (both live in scratchVol). */
+    getScratchSegments(): {
+        axis: "z";
+        width: number;
+        height: number;
+        segments: {
+            label: number;
+            slices: {
+                sliceIndex: number;
+                rle: number[];
+            }[];
+        }[];
+    } | null;
     /** Create (or reuse) the scratch volume sized to the layer grid and register
      *  it under maskData.volumes['aiScratch']. Snapshots the empty buffer. */
     enter(): void;
@@ -126,21 +186,64 @@ export declare class AiAssistTool extends BaseTool {
     /** Clear the in-progress prompt set (e.g. slice/axis change). Does NOT freeze —
      *  use commitRegion() for the "New region" action. */
     resetPrompts(): void;
+    /** Drop the in-progress lasso vertices + undo/redo history (does not touch a
+     *  prediction already painted from a finished lasso). */
+    private clearLassoEditing;
+    /** Tell the app layer the lasso vertex set changed (drives the Finish button). */
+    private notifyLasso;
     /** Voxel-slice (width,height) for the current axis. */
     private sliceDims;
     /** Screen offset → voxel-slice (vx,vy) for the current axis. */
     private toVoxel;
+    /** Voxel-slice (vx,vy) → screen offset (px). Exact inverse of toVoxel, so
+     *  markers / lasso curves drawn from voxel coords track pan AND zoom each frame
+     *  (the freehand previews store screen px directly; persistent overlays don't). */
+    private voxelToScreen;
     onPointerDown(e: MouseEvent): void;
+    /** Lasso click: double-click finishes; click on a vertex deletes it; otherwise
+     *  add a vertex. Nothing is sent to the backend until finishLasso(). */
+    private onLassoPointerDown;
     onPointerMove(e: MouseEvent): void;
     onPointerUp(_e: MouseEvent): void;
     /** Reset the accumulated prompt set when the user scrubs to a new slice. */
     private syncSlice;
     private emit;
+    /** Index of the lasso vertex under (sx,sy) within the hit radius, else −1.
+     *  Uses live voxel→screen so it tracks pan/zoom. Topmost (latest) wins. */
+    private lassoVertAt;
+    /** Snapshot the vertex list for undo (clears redo). */
+    private pushLassoUndo;
+    /** Public: undo the last add/delete of a lasso vertex (Ctrl+Z while editing). */
+    lassoUndoAction(): void;
+    /** Public: redo (Ctrl+Y / Ctrl+Shift+Z while editing). */
+    lassoRedoAction(): void;
+    /** Public: abandon the in-progress lasso (Esc). */
+    cancelLasso(): void;
+    /** Public: true while the user is placing lasso vertices (≥1 vertex). */
+    isLassoEditing(): boolean;
+    /** Public: number of placed lasso vertices (drives the Finish button label/enable). */
+    getLassoVertCount(): number;
+    /** Vertices ordered by polar angle around their centroid, so the closed curve is
+     *  a SIMPLE (non-self-intersecting) loop regardless of click order — otherwise
+     *  connecting points in click order + closing easily produces a bow-tie crossing.
+     *  Trade-off: deep concavities collapse to their star-shaped hull, which is fine
+     *  for a "rough loop around a blob". */
+    private orderedLassoVerts;
+    /** Public: close the curve, densify it, and send it to the backend as the lasso
+     *  contour. Needs ≥3 vertices (a real area). Then clears the editing state. */
+    finishLasso(): void;
+    /** Sample a smooth CLOSED Catmull-Rom spline through `pts` → denser polyline.
+     *  `segs` samples per control-point span. <3 pts → returns a copy unchanged. */
+    private sampleClosedSpline;
     applyMask(result: AiMaskResult): void;
     /** Merge one RLE-encoded predicted slice into the scratch volume at sliceIndex.
      *  Predicted pixels → current channel; stale current-channel pixels cleared
      *  UNLESS they belong to a frozen (committed) region; OTHER channels preserved. */
     private applySliceRle;
     renderOverlay(targetCtx: CanvasRenderingContext2D): void;
+    /** A seed marker (small filled dot + ring) for point prompts. */
+    private drawSeedMarker;
+    /** Render the lasso editing overlay (curve + fill + vertices + hover ✕). */
+    private renderLassoOverlay;
 }
 export {};