copper3d 3.0.1 → 3.0.2

package/dist/types/Utils/segmentation/tools/SphereTool.d.ts

@@ -1,6 +1,43 @@
 /**
  * SphereTool - Sphere drawing and calculator sphere operations
  *
+ * Provides 3D sphere placement across multiple slice views.
+ * Supports 4 sphere types: tumour, skin, nipple, ribcage.
+ * Each type maps to a specific layer and channel for future MaskVolume integration.
+ *
+ * ## Interaction Flow
+ * 1. Sphere mode activated (gui_states.sphere = true)
+ *    - Draw mode (Shift key) is disabled
+ *    - Crosshair toggle is disabled
+ * 2. Left-click down: record sphere center (mouseX, mouseY, sliceIndex)
+ *    - Remove zoom/slice wheel event
+ *    - Bind sphere wheel event
+ *    - Draw preview circle on sphereCanvas
+ * 3. While holding left-click, scroll wheel adjusts sphereRadius [1, 50]
+ * 4. Left-click up:
+ *    - Fire getSphere / getCalculateSpherePositions callbacks
+ *    - (Plan B) Draw 3D sphere across x/y/z axes into sphereMaskVolume
+ *    - Remove sphere wheel event
+ *    - Restore zoom/slice wheel event
+ *
+ * ## Channel Mapping
+ * Each sphere type defaults to layer1 with a specific channel:
+ * - tumour  → layer1, channel 1
+ * - ribcage → layer1, channel 3
+ * - skin    → layer1, channel 4
+ * - nipple  → layer1, channel 5
+ *
+ * ## SphereMaskVolume
+ * Sphere 3D data is stored in a dedicated MaskVolume (nrrd_states.sphereMaskVolume)
+ * separate from the layer draw mask volumes, to avoid polluting layer1's draw data.
+ * This volume is created in setAllSlices() and cleared in reset().
+ *
+ * ## Future: Writing to Layer MaskVolume
+ * Currently sphere data does NOT write to layer1's MaskVolume.
+ * The channel mapping and interfaces are reserved for future integration.
+ * When enabled, use SPHERE_CHANNEL_MAP to determine the target layer & channel,
+ * then call volume.setVoxel() or similar to persist sphere data.
+ *
  * Extracted from DrawToolCore.ts:
  * - drawSphere / drawSphereCore / clearSphereCanvas
  * - drawSphereOnEachViews / drawCalculatorSphereOnEachViews
@@ -10,27 +47,197 @@
  */
 import { BaseTool } from "./BaseTool";
 import type { ToolContext } from "./BaseTool";
+/** The 4 supported sphere marker types. */
+export type SphereType = 'tumour' | 'skin' | 'nipple' | 'ribcage';
+/**
+ * Default layer and channel for each sphere type.
+ *
+ * This mapping is used to:
+ * 1. Determine the color for sphere preview rendering
+ * 2. (Future) Write sphere data into the corresponding layer's MaskVolume channel
+ *
+ * @example
+ * ```ts
+ * const { layer, channel } = SPHERE_CHANNEL_MAP['tumour'];
+ * // layer = 'layer1', channel = 1
+ * ```
+ */
+export declare const SPHERE_CHANNEL_MAP: Record<SphereType, {
+    layer: string;
+    channel: number;
+}>;
+/**
+ * Label values for sphere types stored in sphereMaskVolume.
+ * Regular sphere mode uses SPHERE_LABEL (1).
+ * Calculator mode uses type-specific labels (1-4).
+ */
+export declare const SPHERE_LABELS: Record<SphereType | 'default', number>;
 /**
  * Callbacks that DrawToolCore must provide for sphere operations.
+ * These are internal canvas manipulation callbacks, NOT external data callbacks.
+ *
+ * External data output uses:
+ * - annotationCallbacks.onSphereChanged(origin, radius) — sphere mode
+ * - annotationCallbacks.onCalculatorPositionsChanged(...) — calculator mode
  */
 export interface SphereCallbacks {
     setEmptyCanvasSize: (axis?: "x" | "y" | "z") => void;
     drawImageOnEmptyImage: (canvas: HTMLCanvasElement) => void;
-    storeImageToAxis: (index: number, imageData: ImageData, axis?: "x" | "y" | "z") => void;
 }
 export declare class SphereTool extends BaseTool {
     private callbacks;
     constructor(ctx: ToolContext, callbacks: SphereCallbacks);
     setCallbacks(callbacks: SphereCallbacks): void;
+    /**
+     * Get the channel number for a sphere type.
+     *
+     * @param type - Sphere type ('tumour', 'skin', 'ribcage', 'nipple')
+     * @returns Channel number (1-8) mapped to this sphere type
+     *
+     * @example
+     * ```ts
+     * sphereTool.getChannelForSphereType('tumour');  // → 1
+     * sphereTool.getChannelForSphereType('skin');    // → 4
+     * ```
+     */
+    getChannelForSphereType(type: SphereType): number;
+    /**
+     * Get the default layer for a sphere type.
+     *
+     * @param type - Sphere type
+     * @returns Layer ID (e.g. 'layer1')
+     */
+    getLayerForSphereType(type: SphereType): string;
+    /**
+     * Get the preview color for a sphere type.
+     *
+     * If a volume is available for the target layer, uses the volume's
+     * custom color map (respects per-layer color customization).
+     * Otherwise falls back to SPHERE_COLORS (derived from CHANNEL_HEX_COLORS).
+     *
+     * @param type - Sphere type
+     * @returns CSS color string (hex)
+     */
+    getColorForSphereType(type: SphereType): string;
     setSphereCanvasSize(axis?: "x" | "y" | "z"): void;
+    /**
+     * Draw a filled circle on the given context.
+     *
+     * @param ctx - Canvas 2D context
+     * @param x - Center X coordinate
+     * @param y - Center Y coordinate
+     * @param radius - Circle radius in pixels
+     * @param color - Fill color (CSS string)
+     */
     drawSphereCore(ctx: CanvasRenderingContext2D, x: number, y: number, radius: number, color: string): void;
     clearSphereCanvas(): [HTMLCanvasElement, CanvasRenderingContext2D];
+    /**
+     * Draw a sphere preview circle on the sphere canvas using the current
+     * gui_states.fillColor. Called during sphere mode pointer-down.
+     *
+     * NOTE: Does NOT composite to master canvas — the start() render loop
+     * draws the sphere canvas directly to drawingCtx for proper layering.
+     */
     drawSphere(mouseX: number, mouseY: number, radius: number): void;
+    /**
+     * Returns a wheel event handler that adjusts sphere radius while the user
+     * holds left-click in sphere mode.
+     *
+     * Radius is clamped to [1, 50].
+     */
     configMouseSphereWheel(): (e: WheelEvent) => void;
+    /**
+     * Store sphere slice image into SphereMaskVolume.
+     *
+     * Currently a no-op — sphere slice data is rendered as overlay only.
+     *
+     * TODO: Future — write sphere circle data into nrrd_states.sphereMaskVolume
+     * at the specified slice index and axis. Use SPHERE_CHANNEL_MAP to determine
+     * the target channel when integrating with layer MaskVolume.
+     */
     private storeSphereImages;
+    /**
+     * Draw a sphere cross-section at a given decay distance from center,
+     * for a specific axis view.
+     *
+     * Called for each decay value [0..sphereRadius] for all 3 axes,
+     * creating the 3D sphere effect.
+     *
+     * The sphere circle radius at each slice = sphereRadius - decay (linear decay).
+     *
+     * @param decay - Distance from sphere center slice
+     * @param axis - Axis to render on ('x', 'y', 'z')
+     */
     drawSphereOnEachViews(decay: number, axis: "x" | "y" | "z"): void;
     private getSpherePosition;
+    /**
+     * Draw all 4 calculator sphere types on each view axis.
+     *
+     * Groups sphere positions by their slice index so that spheres on the
+     * same slice are drawn together before storing.
+     *
+     * Uses SPHERE_COLORS for each sphere type instead of nrrd_states.*Color.
+     */
     drawCalculatorSphereOnEachViews(axis: "x" | "y" | "z"): void;
+    /**
+     * Draw all placed calculator spheres on the current slice.
+     *
+     * Called every frame to show existing sphere markers on the current view.
+     * Uses SPHERE_COLORS for consistent type-based coloring.
+     *
+     * @param radius - Sphere radius to draw
+     */
     drawCalculatorSphere(radius: number): void;
+    /**
+     * Clear sphere overlay images.
+     *
+     * No-op in current implementation — sphere data is rendered as overlay
+     * and stored in the dedicated sphereMaskVolume (not in layer volumes).
+     */
     clearSpherePrintStoreImages(): void;
+    /**
+     * Convert canvas (mm-space) coordinates to 3D voxel coordinates.
+     *
+     * @param canvasX - X position in canvas mm-space
+     * @param canvasY - Y position in canvas mm-space
+     * @param sliceIndex - Slice index along the viewing axis
+     * @param axis - Viewing axis where the sphere was placed
+     * @returns 3D voxel coordinates { x, y, z }
+     */
+    canvasToVoxelCenter(canvasX: number, canvasY: number, sliceIndex: number, axis: "x" | "y" | "z"): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /**
+     * Write a 3D solid sphere to sphereMaskVolume.
+     *
+     * Converts the sphere center from canvas mm-space to voxel coordinates,
+     * then iterates over a bounding box and sets voxels within the sphere.
+     * The sphere is an ellipsoid in voxel space to appear circular in
+     * physical (mm) space on all axis views.
+     *
+     * @param label - Label value to write (1-4, default 1)
+     */
+    write3DSphereToVolume(label?: number): void;
+    /**
+     * Write a calculator sphere type to sphereMaskVolume.
+     * Uses the stored origin for the specified sphere type.
+     *
+     * @param type - Sphere type ('tumour', 'skin', 'nipple', 'ribcage')
+     */
+    writeCalculatorSphereToVolume(type: SphereType): void;
+    /**
+     * Write all placed calculator spheres to the volume.
+     * Clears the volume first, then writes each placed sphere type.
+     */
+    writeAllCalculatorSpheresToVolume(): void;
+    /**
+     * Render the current slice of sphereMaskVolume to drawingSphereCanvas.
+     *
+     * Called after any operation that changes the view (slice, axis, zoom)
+     * to keep the sphere overlay visible. Uses the same render pipeline as
+     * layer masks (emptyCanvas → sphere canvas at display scale).
+     */
+    refreshSphereCanvas(): void;
 }

package/dist/types/Utils/segmentation/tools/index.d.ts

@@ -9,10 +9,14 @@
 export { BaseTool } from "./BaseTool";
 export type { ToolContext } from "./BaseTool";
 export { EraserTool } from "./EraserTool";
+export { DrawingTool } from "./DrawingTool";
+export type { DrawingCallbacks } from "./DrawingTool";
+export { PanTool } from "./PanTool";
+export type { PanCallbacks } from "./PanTool";
 export { ZoomTool } from "./ZoomTool";
 export type { ZoomCallbacks } from "./ZoomTool";
-export { SphereTool } from "./SphereTool";
-export type { SphereCallbacks } from "./SphereTool";
+export { SphereTool, SPHERE_CHANNEL_MAP } from "./SphereTool";
+export type { SphereCallbacks, SphereType } from "./SphereTool";
 export { CrosshairTool } from "./CrosshairTool";
 export { ContrastTool } from "./ContrastTool";
 export type { ContrastCallbacks } from "./ContrastTool";

package/dist/types/index.d.ts

@@ -17,10 +17,13 @@ import { Copper3dTrackballControls } from "./Controls/Copper3dTrackballControls"
 import { MeshNodeTool } from "./Utils/MeshNodeTool";
 import { removeGuiFolderChilden } from "./Utils/segmentation/coreTools/gui";
 import { nrrdMeshesType, nrrdSliceType, SensorDecodedValue_kiwrious, SensorReadResult_kiwrious, HeartRateResult_kiwrious, loadingBarType, exportPaintImageType, IOptVTKLoader } from "./types/types";
-import { IPaintImage, ICommXYZ, IGUIStates, IGuiParameterSettings, INrrdStates } from "./Utils/segmentation/coreTools/coreType";
+import { IPaintImage, ICommXYZ, IGUIStates, IGuiParameterSettings, INrrdStates, IGuiMeta } from "./Utils/segmentation/coreTools/coreType";
+import { NrrdState } from "./Utils/segmentation/coreTools/NrrdState";
+import { GuiState } from "./Utils/segmentation/coreTools/GuiState";
+import type { ToolMode, IAnnotationCallbacks } from "./Utils/segmentation/coreTools/coreType";
 import { CHANNEL_COLORS, CHANNEL_HEX_COLORS, rgbaToHex, rgbaToCss } from "./Utils/segmentation/core/index";
 import type { LayerId, ChannelValue } from "./Utils/segmentation/core/index";
 import "./css/style.css";
-export declare const REVISION = "v3.0.1-beta";
+export declare const REVISION = "v3.0.2-beta";
 export { copperRenderer, copperRendererOnDemond, copperMSceneRenderer, setHDRFilePath, addLabelToScene, convert3DPostoScreenPos, convertScreenPosto3DPos, addBoxHelper, fullScreenListenner, configKiwriousHeart, copperScene, copperSceneOnDemond, copperMScene, CameraViewPoint, kiwrious, NrrdTools, loading, Copper3dTrackballControls, createTexture2D_NRRD, MeshNodeTool, throttle, removeGuiFolderChilden, CHANNEL_COLORS, CHANNEL_HEX_COLORS, rgbaToHex, rgbaToCss, };
-export type { positionType, screenPosType, optsType, nrrdMeshesType, nrrdSliceType, SensorDecodedValue_kiwrious, SensorReadResult_kiwrious, HeartRateResult_kiwrious, loadingBarType, IPaintImage, exportPaintImageType, IOptVTKLoader, ICommXYZ, IGUIStates, IGuiParameterSettings, INrrdStates, LayerId, ChannelValue, };
+export type { positionType, screenPosType, optsType, nrrdMeshesType, nrrdSliceType, SensorDecodedValue_kiwrious, SensorReadResult_kiwrious, HeartRateResult_kiwrious, loadingBarType, IPaintImage, exportPaintImageType, IOptVTKLoader, ICommXYZ, IGUIStates, IGuiParameterSettings, INrrdStates, NrrdState, GuiState, IGuiMeta, ToolMode, IAnnotationCallbacks, LayerId, ChannelValue, };

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

package/dist/Utils/segmentation/core/MigrationUtils.d.ts

@@ -1,97 +0,0 @@
-/**
- * Migration Utilities for MaskVolume
- *
- * Provides bidirectional conversion between the legacy per-slice
- * ImageData storage (`IPaintImages`) and the new contiguous 3D
- * volumetric storage (`MaskVolume`).
- *
- * These utilities enable:
- *  - **Forward migration**: Import existing annotation data into MaskVolume.
- *  - **Rollback compatibility**: Export MaskVolume back to IPaintImages.
- *
- * @example
- * ```ts
- * // Forward: legacy → volume
- * const volume = convertIPaintImagesToVolume(paintImages, { width: 512, height: 512, depth: 100 });
- *
- * // Backward: volume → legacy
- * const legacy = convertVolumeToIPaintImages(volume);
- * ```
- */
-import type { Dimensions } from './types';
-import { MaskVolume } from './MaskVolume';
-/**
- * A single painted slice (legacy format).
- */
-export interface IPaintImage {
-    index: number;
-    image: ImageData;
-}
-/**
- * Per-axis collection of painted slices (legacy format).
- */
-export interface IPaintImages {
-    x: IPaintImage[];
-    y: IPaintImage[];
-    z: IPaintImage[];
-}
-/**
- * Convert legacy per-slice ImageData storage into a MaskVolume.
- *
- * The function iterates over all three axes (`x`, `y`, `z`) and inserts
- * each slice into the volume using `setSliceFromImageData`.
- *
- * **Sparse data handling**: Slices that are absent from the arrays are
- * left as zero (the MaskVolume default). Duplicate indices are
- * overwritten in order (last wins).
- *
- * @param paintImages Legacy per-axis slice collection.
- * @param dimensions  Volume dimensions (must match the ImageData sizes).
- * @param channel     Target channel in the volume (default 0).
- *
- * @returns A new MaskVolume populated with the legacy data.
- *
- * @throws {Error} If a slice's ImageData dimensions don't match the
- *                 expected size for its axis.
- *
- * @example
- * ```ts
- * const volume = convertIPaintImagesToVolume(
- *   maskData.paintImagesLayer1,
- *   { width: 512, height: 512, depth: 100 },
- * );
- * ```
- */
-export declare function convertIPaintImagesToVolume(paintImages: IPaintImages, dimensions: Dimensions, channel?: number): MaskVolume;
-/**
- * Convert a MaskVolume back to legacy per-slice ImageData storage.
- *
- * Extracts **all** slices along the Z axis (axial) into an
- * `IPaintImages` structure. X and Y axes are left as empty arrays
- * since the legacy system can reconstruct them on demand.
- *
- * Only non-empty slices (those containing at least one non-zero pixel)
- * are included, matching the sparse behaviour of the original storage.
- *
- * @param volume  The MaskVolume to export.
- * @param channel Channel to extract (default 0).
- * @param options Export options.
- * @param options.includeAllAxes If true, also export X and Y axis slices
- *                               (expensive — use only if needed for full
- *                               backward compatibility). Default: false.
- * @param options.includeEmpty   If true, include slices that are entirely
- *                               zero. Default: false.
- *
- * @returns A legacy IPaintImages structure.
- *
- * @example
- * ```ts
- * const legacy = convertVolumeToIPaintImages(volume);
- * // legacy.z contains non-empty axial slices
- * // legacy.x and legacy.y are empty by default
- * ```
- */
-export declare function convertVolumeToIPaintImages(volume: MaskVolume, channel?: number, options?: {
-    includeAllAxes?: boolean;
-    includeEmpty?: boolean;
-}): IPaintImages;

package/dist/Utils/segmentation/core/MigrationUtils.js

@@ -1,163 +0,0 @@
-/**
- * Migration Utilities for MaskVolume
- *
- * Provides bidirectional conversion between the legacy per-slice
- * ImageData storage (`IPaintImages`) and the new contiguous 3D
- * volumetric storage (`MaskVolume`).
- *
- * These utilities enable:
- *  - **Forward migration**: Import existing annotation data into MaskVolume.
- *  - **Rollback compatibility**: Export MaskVolume back to IPaintImages.
- *
- * @example
- * ```ts
- * // Forward: legacy → volume
- * const volume = convertIPaintImagesToVolume(paintImages, { width: 512, height: 512, depth: 100 });
- *
- * // Backward: volume → legacy
- * const legacy = convertVolumeToIPaintImages(volume);
- * ```
- */
-import { MaskVolume } from './MaskVolume';
-// ── Forward migration: IPaintImages → MaskVolume ────────────────────────
-/**
- * Convert legacy per-slice ImageData storage into a MaskVolume.
- *
- * The function iterates over all three axes (`x`, `y`, `z`) and inserts
- * each slice into the volume using `setSliceFromImageData`.
- *
- * **Sparse data handling**: Slices that are absent from the arrays are
- * left as zero (the MaskVolume default). Duplicate indices are
- * overwritten in order (last wins).
- *
- * @param paintImages Legacy per-axis slice collection.
- * @param dimensions  Volume dimensions (must match the ImageData sizes).
- * @param channel     Target channel in the volume (default 0).
- *
- * @returns A new MaskVolume populated with the legacy data.
- *
- * @throws {Error} If a slice's ImageData dimensions don't match the
- *                 expected size for its axis.
- *
- * @example
- * ```ts
- * const volume = convertIPaintImagesToVolume(
- *   maskData.paintImagesLayer1,
- *   { width: 512, height: 512, depth: 100 },
- * );
- * ```
- */
-export function convertIPaintImagesToVolume(paintImages, dimensions, channel = 0) {
-    if (!paintImages) {
-        throw new Error('paintImages is null or undefined');
-    }
-    if (dimensions.width < 1 ||
-        dimensions.height < 1 ||
-        dimensions.depth < 1) {
-        throw new RangeError(`Dimensions must be ≥ 1, got (${dimensions.width}, ${dimensions.height}, ${dimensions.depth})`);
-    }
-    const volume = new MaskVolume(dimensions.width, dimensions.height, dimensions.depth);
-    // Process each axis
-    const axes = [
-        { key: 'z', axis: 'z' },
-        { key: 'y', axis: 'y' },
-        { key: 'x', axis: 'x' },
-    ];
-    for (const { key, axis } of axes) {
-        const slices = paintImages[key];
-        if (!slices || !Array.isArray(slices))
-            continue;
-        for (const paintImage of slices) {
-            if (!paintImage || paintImage.image == null)
-                continue;
-            const { index, image } = paintImage;
-            // Validate slice index bounds
-            const maxIndex = axis === 'x' ? dimensions.width :
-                axis === 'y' ? dimensions.height :
-                    dimensions.depth;
-            if (index < 0 || index >= maxIndex) {
-                continue; // Skip out-of-bounds slices silently
-            }
-            volume.setSliceFromImageData(index, image, axis, channel);
-        }
-    }
-    return volume;
-}
-// ── Backward migration: MaskVolume → IPaintImages ───────────────────────
-/**
- * Convert a MaskVolume back to legacy per-slice ImageData storage.
- *
- * Extracts **all** slices along the Z axis (axial) into an
- * `IPaintImages` structure. X and Y axes are left as empty arrays
- * since the legacy system can reconstruct them on demand.
- *
- * Only non-empty slices (those containing at least one non-zero pixel)
- * are included, matching the sparse behaviour of the original storage.
- *
- * @param volume  The MaskVolume to export.
- * @param channel Channel to extract (default 0).
- * @param options Export options.
- * @param options.includeAllAxes If true, also export X and Y axis slices
- *                               (expensive — use only if needed for full
- *                               backward compatibility). Default: false.
- * @param options.includeEmpty   If true, include slices that are entirely
- *                               zero. Default: false.
- *
- * @returns A legacy IPaintImages structure.
- *
- * @example
- * ```ts
- * const legacy = convertVolumeToIPaintImages(volume);
- * // legacy.z contains non-empty axial slices
- * // legacy.x and legacy.y are empty by default
- * ```
- */
-export function convertVolumeToIPaintImages(volume, channel = 0, options = {}) {
-    if (!volume) {
-        throw new Error('volume is null or undefined');
-    }
-    const { includeAllAxes = false, includeEmpty = false } = options;
-    const dims = volume.getDimensions();
-    const result = { x: [], y: [], z: [] };
-    const renderOpts = { channel };
-    // Always export Z axis (axial slices — most commonly used)
-    for (let z = 0; z < dims.depth; z++) {
-        const imageData = volume.getSliceImageData(z, 'z', renderOpts);
-        if (includeEmpty || hasNonZeroPixels(imageData)) {
-            result.z.push({ index: z, image: imageData });
-        }
-    }
-    // Optionally export X and Y axes
-    if (includeAllAxes) {
-        for (let y = 0; y < dims.height; y++) {
-            const imageData = volume.getSliceImageData(y, 'y', renderOpts);
-            if (includeEmpty || hasNonZeroPixels(imageData)) {
-                result.y.push({ index: y, image: imageData });
-            }
-        }
-        for (let x = 0; x < dims.width; x++) {
-            const imageData = volume.getSliceImageData(x, 'x', renderOpts);
-            if (includeEmpty || hasNonZeroPixels(imageData)) {
-                result.x.push({ index: x, image: imageData });
-            }
-        }
-    }
-    return result;
-}
-// ── Helpers ──────────────────────────────────────────────────────────────
-/**
- * Check whether an ImageData has any non-zero pixel data.
- *
- * Only checks the R channel (index 0 of every 4-byte group) since
- * MaskVolume stores grayscale values in the R channel.
- */
-function hasNonZeroPixels(imageData) {
-    const data = imageData.data;
-    // Check R channel of each pixel (stride 4)
-    for (let i = 0; i < data.length; i += 4) {
-        if (data[i] !== 0)
-            return true;
-    }
-    return false;
-}
-//# sourceMappingURL=MigrationUtils.js.map

package/dist/Utils/segmentation/core/MigrationUtils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"MigrationUtils.js","sourceRoot":"","sources":["../../../../src/Utils/segmentation/core/MigrationUtils.ts"],"names":[],"mappings":"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"}

package/dist/types/Utils/segmentation/core/MigrationUtils.d.ts

@@ -1,97 +0,0 @@
-/**
- * Migration Utilities for MaskVolume
- *
- * Provides bidirectional conversion between the legacy per-slice
- * ImageData storage (`IPaintImages`) and the new contiguous 3D
- * volumetric storage (`MaskVolume`).
- *
- * These utilities enable:
- *  - **Forward migration**: Import existing annotation data into MaskVolume.
- *  - **Rollback compatibility**: Export MaskVolume back to IPaintImages.
- *
- * @example
- * ```ts
- * // Forward: legacy → volume
- * const volume = convertIPaintImagesToVolume(paintImages, { width: 512, height: 512, depth: 100 });
- *
- * // Backward: volume → legacy
- * const legacy = convertVolumeToIPaintImages(volume);
- * ```
- */
-import type { Dimensions } from './types';
-import { MaskVolume } from './MaskVolume';
-/**
- * A single painted slice (legacy format).
- */
-export interface IPaintImage {
-    index: number;
-    image: ImageData;
-}
-/**
- * Per-axis collection of painted slices (legacy format).
- */
-export interface IPaintImages {
-    x: IPaintImage[];
-    y: IPaintImage[];
-    z: IPaintImage[];
-}
-/**
- * Convert legacy per-slice ImageData storage into a MaskVolume.
- *
- * The function iterates over all three axes (`x`, `y`, `z`) and inserts
- * each slice into the volume using `setSliceFromImageData`.
- *
- * **Sparse data handling**: Slices that are absent from the arrays are
- * left as zero (the MaskVolume default). Duplicate indices are
- * overwritten in order (last wins).
- *
- * @param paintImages Legacy per-axis slice collection.
- * @param dimensions  Volume dimensions (must match the ImageData sizes).
- * @param channel     Target channel in the volume (default 0).
- *
- * @returns A new MaskVolume populated with the legacy data.
- *
- * @throws {Error} If a slice's ImageData dimensions don't match the
- *                 expected size for its axis.
- *
- * @example
- * ```ts
- * const volume = convertIPaintImagesToVolume(
- *   maskData.paintImagesLayer1,
- *   { width: 512, height: 512, depth: 100 },
- * );
- * ```
- */
-export declare function convertIPaintImagesToVolume(paintImages: IPaintImages, dimensions: Dimensions, channel?: number): MaskVolume;
-/**
- * Convert a MaskVolume back to legacy per-slice ImageData storage.
- *
- * Extracts **all** slices along the Z axis (axial) into an
- * `IPaintImages` structure. X and Y axes are left as empty arrays
- * since the legacy system can reconstruct them on demand.
- *
- * Only non-empty slices (those containing at least one non-zero pixel)
- * are included, matching the sparse behaviour of the original storage.
- *
- * @param volume  The MaskVolume to export.
- * @param channel Channel to extract (default 0).
- * @param options Export options.
- * @param options.includeAllAxes If true, also export X and Y axis slices
- *                               (expensive — use only if needed for full
- *                               backward compatibility). Default: false.
- * @param options.includeEmpty   If true, include slices that are entirely
- *                               zero. Default: false.
- *
- * @returns A legacy IPaintImages structure.
- *
- * @example
- * ```ts
- * const legacy = convertVolumeToIPaintImages(volume);
- * // legacy.z contains non-empty axial slices
- * // legacy.x and legacy.y are empty by default
- * ```
- */
-export declare function convertVolumeToIPaintImages(volume: MaskVolume, channel?: number, options?: {
-    includeAllAxes?: boolean;
-    includeEmpty?: boolean;
-}): IPaintImages;