@bettermedicine/imeasure 0.0.1

package/dist/math/affines/translate-and-invert.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect } from "vitest";
+import { affineTranslateVec3 } from "./translate";
+import { mat4 } from "gl-matrix";
+import { invertAffineMatrix } from "./invert";
+import { sampleFFSMatrix } from "../../test/testdata";
+describe("translate and invert", () => {
+    const identityAffine = mat4.fromValues(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+    describe("translate", () => {
+        it("correctly translates a point using an identity affine", () => {
+            const point = [1, 2, 3];
+            const translatedPoint = affineTranslateVec3(point, identityAffine);
+            expect(translatedPoint).toEqual([1, 2, 3]);
+        });
+        it("predictably translates given coordinates with known expected result", () => {
+            const points = [
+                [246, 185, 212],
+                [357, 297, 310],
+            ];
+            const expectedResults = [
+                [-7.3681640625, -234.610595703125, -299.3999938964844],
+                [90.4072265625, -135.954345703125, -201.39999389648438],
+            ];
+            points.forEach((point, index) => {
+                const translatedPoint = affineTranslateVec3(point, sampleFFSMatrix);
+                expect(translatedPoint).toEqual(expectedResults[index]);
+            });
+        });
+    });
+    describe("invert", () => {
+        it("correctly inverts an identity matrix", () => {
+            const invertedMatrix = invertAffineMatrix(identityAffine);
+            expect(invertedMatrix).toEqual(identityAffine);
+        });
+        it("correctly inverts a sample matrix", () => {
+            const invertedMatrix = invertAffineMatrix(sampleFFSMatrix);
+            const expectedInvertedMatrix = mat4.fromValues(1.135254979133606, 0, 0, 0, 0, 1.135254979133606, 0, 0, 0, 0, 1, 0, 254.36474609375, 451.34283447265625, 511.3999938964844, 1);
+            expect(invertedMatrix).toEqual(expectedInvertedMatrix);
+        });
+    });
+});

package/dist/math/affines/translate.d.ts

@@ -0,0 +1,3 @@
+import { mat4, vec3 } from "gl-matrix";
+import { Point3D } from "../../types/cornerstone";
+export declare const affineTranslateVec3: (voxelCoord: vec3 | Point3D, affine: mat4) => vec3;

package/dist/math/affines/translate.js

@@ -0,0 +1,10 @@
+import { vec4 } from "gl-matrix";
+// We use affines to convert between voxel-space and world-space coordinates.
+// Takes a coordinate and an affine matrix, returns the translated coordinate.
+// This is useful for converting between voxel-space and world-space coordinates.
+export const affineTranslateVec3 = (voxelCoord, affine) => {
+    const homogeneousVoxel = vec4.fromValues(voxelCoord[0], voxelCoord[1], voxelCoord[2], 1);
+    const worldCoord = vec4.create(); // Output container for the translated coordinate
+    vec4.transformMat4(worldCoord, homogeneousVoxel, affine);
+    return [worldCoord[0], worldCoord[1], worldCoord[2]];
+};

package/dist/math/cropping.d.ts

@@ -0,0 +1,23 @@
+import { mat4 } from "gl-matrix";
+import { Point3D } from "../types/cornerstone";
+import { TIMeasureCropRegion } from "../types/crop";
+export declare const getInteractiveImeasureCropCuboidDimensions: (measurement: [Point3D, Point3D], worldToVoxelAffine: mat4) => number[];
+export declare const calculateInteractiveImeasureCropRegion: (worldBasePoints: Point3D[], voxelToWorldAffine: mat4) => TIMeasureCropRegion;
+/**
+ * Calculates a bounding box for iMeasure cropping based on user clicks and world affines.
+ *
+ * Expands the crop region if extra clicks are detected outside the initial box, ensuring the region includes all relevant points.
+ * Handles conversion between world and voxel space, and adjusts the crop box dimensions accordingly.
+ *
+ * The function maintains the center and cropping planes, and updates edge lengths if necessary.
+ */
+export declare const calculateInteractiveImeasureBoundingBox: (firstClicks: [Point3D, Point3D] | [Point3D], extraClicks: Point3D[] | undefined, voxelToWorldAffine: mat4) => TIMeasureCropRegion;
+/**
+ * Calculates a bounding box for iMeasure cropping based on user clicks and world affines.
+ *
+ * Expands the crop region if extra clicks are detected outside the initial box, ensuring the region includes all relevant points.
+ * Handles conversion between world and voxel space, and adjusts the crop box dimensions accordingly.
+ *
+ * The function maintains the center and cropping planes, and updates edge lengths if necessary.
+ */
+export declare const calculateStaticImeasureBoundingBox: (clicks: [Point3D, Point3D], voxelToWorldAffine: mat4) => TIMeasureCropRegion;

package/dist/math/cropping.js

@@ -0,0 +1,142 @@
+import { affineTranslateVec3, invertAffineMatrix } from "./affines";
+import { INTERACTIVE_IMEASURE_BASE } from "../constants";
+import { calculateZAxisLength, roundPoint3 } from "./utility";
+// TODO: should expand scale based on z-axis input point diff.
+// Tests first.
+export const getInteractiveImeasureCropCuboidDimensions = (measurement, worldToVoxelAffine) => {
+    const [voxelStart, voxelEnd] = measurement.map((pt) => roundPoint3(affineTranslateVec3(pt, worldToVoxelAffine)));
+    const x_size = Math.abs(voxelStart[0] - voxelEnd[0]) +
+        INTERACTIVE_IMEASURE_BASE.PADDING * 2;
+    const y_size = Math.abs(voxelStart[1] - voxelEnd[1]) +
+        INTERACTIVE_IMEASURE_BASE.PADDING * 2;
+    let xyCubeSize = Math.max(x_size, y_size, INTERACTIVE_IMEASURE_BASE.X);
+    // the model always expects an even number of voxels on each axis
+    if (xyCubeSize % 2 !== 0) {
+        xyCubeSize += 1;
+    }
+    const voxelToWorldAffine = invertAffineMatrix(worldToVoxelAffine);
+    const maxDistanceBetweenPoints = Math.max(x_size, y_size);
+    const zLength = calculateZAxisLength(maxDistanceBetweenPoints, voxelToWorldAffine);
+    return [xyCubeSize, xyCubeSize, zLength];
+};
+const getCropCuboidFromCenterAndEdgeLengths = (voxelSpaceCenter, edgeLengths) => {
+    const minCropCoordinates = [
+        voxelSpaceCenter[0] - edgeLengths.x / 2,
+        voxelSpaceCenter[1] - edgeLengths.y / 2,
+        voxelSpaceCenter[2] - edgeLengths.z / 2,
+    ];
+    const maxCropCoordinates = [
+        minCropCoordinates[0] + edgeLengths.x - 1,
+        minCropCoordinates[1] + edgeLengths.y - 1,
+        minCropCoordinates[2] + edgeLengths.z - 1,
+    ];
+    const croppingPlanes = [
+        minCropCoordinates[0], // minX
+        maxCropCoordinates[0], // maxX
+        minCropCoordinates[1], // minY
+        maxCropCoordinates[1], // maxY
+        minCropCoordinates[2], // minZ
+        maxCropCoordinates[2], // maxZ
+    ];
+    return {
+        cropCubePoints: [minCropCoordinates, maxCropCoordinates],
+        croppingPlanes,
+        voxelSpaceCenter,
+    };
+};
+export const calculateInteractiveImeasureCropRegion = (worldBasePoints, voxelToWorldAffine) => {
+    let center;
+    const singlePoint = worldBasePoints.length === 1;
+    if (singlePoint) {
+        center = worldBasePoints[0];
+    }
+    else {
+        center = [
+            (worldBasePoints[0][0] + worldBasePoints[1][0]) / 2,
+            (worldBasePoints[0][1] + worldBasePoints[1][1]) / 2,
+            (worldBasePoints[0][2] + worldBasePoints[1][2]) / 2,
+        ];
+    }
+    // we want to convert (and round) this to voxel coordinates
+    const worldToVoxelAffine = invertAffineMatrix(voxelToWorldAffine);
+    const voxelSpaceCenter = roundPoint3(affineTranslateVec3(center, worldToVoxelAffine));
+    // if we only have a single click, use constants for edge lengths.
+    let x_edge = INTERACTIVE_IMEASURE_BASE.X;
+    let y_edge = INTERACTIVE_IMEASURE_BASE.Y;
+    let z_edge = INTERACTIVE_IMEASURE_BASE.Z;
+    if (!singlePoint) {
+        // if we have two clicks, calculate the edges based on the points
+        const tempProposedCuboidEdges = getInteractiveImeasureCropCuboidDimensions(worldBasePoints, worldToVoxelAffine);
+        [x_edge, y_edge, z_edge] = tempProposedCuboidEdges;
+    }
+    const { cropCubePoints, croppingPlanes } = getCropCuboidFromCenterAndEdgeLengths(voxelSpaceCenter, {
+        x: x_edge,
+        y: y_edge,
+        z: z_edge,
+    });
+    return {
+        center,
+        voxelSpaceCenter,
+        cropCubePoints,
+        croppingPlanes,
+        edgeLengths: {
+            x: x_edge,
+            y: y_edge,
+            z: z_edge,
+        },
+    };
+};
+/**
+ * Calculates a bounding box for iMeasure cropping based on user clicks and world affines.
+ *
+ * Expands the crop region if extra clicks are detected outside the initial box, ensuring the region includes all relevant points.
+ * Handles conversion between world and voxel space, and adjusts the crop box dimensions accordingly.
+ *
+ * The function maintains the center and cropping planes, and updates edge lengths if necessary.
+ */
+export const calculateInteractiveImeasureBoundingBox = (firstClicks, extraClicks = [], voxelToWorldAffine) => {
+    const worldToVoxelAffine = invertAffineMatrix(voxelToWorldAffine);
+    const { center, voxelSpaceCenter, cropCubePoints, croppingPlanes, edgeLengths, } = calculateInteractiveImeasureCropRegion(firstClicks, voxelToWorldAffine);
+    let maxDistanceFromCenter = 0;
+    const extraClicksInVoxelSpace = extraClicks.map((pt) => roundPoint3(affineTranslateVec3(pt, worldToVoxelAffine)));
+    extraClicksInVoxelSpace.forEach((point) => {
+        maxDistanceFromCenter = Math.max(Math.abs(point[0] - voxelSpaceCenter[0]), Math.abs(point[1] - voxelSpaceCenter[1]), maxDistanceFromCenter);
+        // TODO: handle z-axis differences
+    });
+    const halfEdgeLength = maxDistanceFromCenter + INTERACTIVE_IMEASURE_BASE.PADDING;
+    // check if we need to expand the box at all?
+    if (halfEdgeLength * 2 < edgeLengths.x) {
+        return {
+            center,
+            voxelSpaceCenter,
+            cropCubePoints,
+            croppingPlanes,
+            edgeLengths,
+        };
+    }
+    const zLength = calculateZAxisLength(halfEdgeLength * 2, voxelToWorldAffine);
+    const newEdgeLengths = {
+        x: halfEdgeLength * 2,
+        y: halfEdgeLength * 2,
+        z: zLength,
+    };
+    const { cropCubePoints: newCropCubePoints, croppingPlanes: newCroppingPlanes, } = getCropCuboidFromCenterAndEdgeLengths(voxelSpaceCenter, newEdgeLengths);
+    return {
+        center,
+        voxelSpaceCenter,
+        cropCubePoints: newCropCubePoints,
+        croppingPlanes: newCroppingPlanes,
+        edgeLengths: newEdgeLengths,
+    };
+};
+/**
+ * Calculates a bounding box for iMeasure cropping based on user clicks and world affines.
+ *
+ * Expands the crop region if extra clicks are detected outside the initial box, ensuring the region includes all relevant points.
+ * Handles conversion between world and voxel space, and adjusts the crop box dimensions accordingly.
+ *
+ * The function maintains the center and cropping planes, and updates edge lengths if necessary.
+ */
+export const calculateStaticImeasureBoundingBox = (clicks, voxelToWorldAffine) => {
+    return calculateInteractiveImeasureBoundingBox(clicks, [], voxelToWorldAffine);
+};

package/dist/math/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./cropping";
+export * as affines from "./affines";
+export * as utility from "./utility";
+export * as cropping from "./cropping";

package/dist/math/index.js

@@ -0,0 +1,4 @@
+export * from "./cropping";
+export * as affines from "./affines";
+export * as utility from "./utility";
+export * as cropping from "./cropping";

package/dist/math/utility.d.ts

@@ -0,0 +1,4 @@
+import { mat4, vec3 } from "gl-matrix";
+import { Point3D } from "../types/cornerstone";
+export declare function roundPoint3(m: Point3D | vec3): Point3D;
+export declare const calculateZAxisLength: (xyLength: number, voxelToWorldAffine: mat4) => number;

package/dist/math/utility.js

@@ -0,0 +1,19 @@
+import { INTERACTIVE_IMEASURE_BASE } from "../constants";
+export function roundPoint3(m) {
+    if (!Array.isArray(m) || m.length !== 3) {
+        throw new Error("Input must be an array of three numbers.");
+    }
+    return m.map((coord) => Math.round(coord));
+}
+// an utility used to calculate the proportional z-axis length based on
+// a cuboid's XY length, based on the relationship between x/y pixel spacing and
+// series slice thickness.
+export const calculateZAxisLength = (xyLength, voxelToWorldAffine) => {
+    const pixelSpacing = voxelToWorldAffine[0];
+    const sliceThickness = voxelToWorldAffine[10];
+    let zLength = Math.max(Math.round((xyLength * pixelSpacing) / sliceThickness), INTERACTIVE_IMEASURE_BASE.Z);
+    if (zLength % 2 !== 0) {
+        zLength += 1; // ensure even number
+    }
+    return zLength;
+};

package/dist/metadata/world.d.ts

@@ -0,0 +1,10 @@
+import vtkImageData from "@kitware/vtk.js/Common/DataModel/ImageData";
+import { TWorldMetadata } from "../types/metadata";
+import { TOhifDisplaySetStub } from "../types/ohif";
+/**
+ * Extracts world metadata from a vtkImageData object and an OHIF DisplaySet.
+ * Combines spatial information from the image data and OHIF display set to produce
+ * metadata describing the world origin, shape, spacing, bounding image positions,
+ * rescale parameters, and image orientation.
+ */
+export declare const extractWorldMetaFromImageDataAndDisplaySet: (imageData: vtkImageData, displaySet: TOhifDisplaySetStub) => TWorldMetadata;

package/dist/metadata/world.js

@@ -0,0 +1,25 @@
+/**
+ * Extracts world metadata from a vtkImageData object and an OHIF DisplaySet.
+ * Combines spatial information from the image data and OHIF display set to produce
+ * metadata describing the world origin, shape, spacing, bounding image positions,
+ * rescale parameters, and image orientation.
+ */
+export const extractWorldMetaFromImageDataAndDisplaySet = (imageData, displaySet) => {
+    const firstInstance = displaySet.instances[0];
+    const rescaleIntercept = firstInstance.RescaleIntercept;
+    const rescaleSlope = firstInstance.RescaleSlope;
+    const imageOrientationPatient = firstInstance.ImageOrientationPatient;
+    const imageCount = displaySet.instances.length;
+    const firstDsPosition = displaySet.instances[0].ImagePositionPatient;
+    const lastDsPosition = displaySet.instances[imageCount - 1].ImagePositionPatient;
+    return {
+        worldOrigin: imageData.getOrigin(),
+        worldShape: imageData.getDimensions(),
+        worldSpacing: imageData.getSpacing(),
+        imageCount,
+        worldBoundingImagePositions: [firstDsPosition, lastDsPosition],
+        rescaleIntercept,
+        rescaleSlope,
+        imageOrientationPatient,
+    };
+};

package/dist/test/testdata.d.ts

@@ -0,0 +1,2 @@
+import { mat4 } from "gl-matrix";
+export declare const sampleFFSMatrix: mat4;

package/dist/test/testdata.js

@@ -0,0 +1,2 @@
+import { mat4 } from "gl-matrix";
+export const sampleFFSMatrix = mat4.fromValues(0.880859375, 0, 0, 0, 0, 0.880859375, 0, 0, 0, 0, 1, 0, -224.0595703125, -397.569580078125, -511.3999938964844, 1);

package/dist/types/arrays.d.ts

@@ -0,0 +1 @@
+export type TypedArray = Uint8Array | Int16Array | Float32Array;

package/dist/types/arrays.js

@@ -0,0 +1 @@
+export {};

package/dist/types/cornerstone.d.ts

@@ -0,0 +1,3 @@
+import { Types } from "@cornerstonejs/core";
+export type Point3D = Types.Point3;
+export type { ImageVolume } from "@cornerstonejs/core";

package/dist/types/cornerstone.js

@@ -0,0 +1 @@
+export {};

package/dist/types/crop.d.ts

@@ -0,0 +1,16 @@
+import { Point3D } from "./cornerstone";
+export type TCroppingPlanes = [number, number, number, number, number, number];
+export type TCropCubePoints = [Point3D, Point3D];
+export type TCropCuboid = {
+    cropCubePoints: TCropCubePoints;
+    croppingPlanes: TCroppingPlanes;
+    voxelSpaceCenter: Point3D;
+};
+export type TIMeasureCropRegion = TCropCuboid & {
+    center: Point3D;
+    edgeLengths: {
+        x: number;
+        y: number;
+        z: number;
+    };
+};

package/dist/types/crop.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * as IO from "./io";
+export * as Cornerstone from "./cornerstone";
+export * as Metadata from "./metadata";

package/dist/types/index.js

@@ -0,0 +1,3 @@
+export * as IO from "./io";
+export * as Cornerstone from "./cornerstone";
+export * as Metadata from "./metadata";

package/dist/types/io.d.ts

@@ -0,0 +1,52 @@
+import { Point3D } from "./cornerstone";
+export type TRawMeasurement = {
+    coords_voxel: [Point3D, Point3D];
+    coords_world: [Point3D, Point3D];
+    length_voxel: number;
+    length_world: number;
+};
+export type TCrossMeasurement = {
+    short: TRawMeasurement;
+    long: TRawMeasurement;
+};
+export type TIMeasure3DResponse = {
+    mask: string;
+    measurements: {
+        cross: {
+            0: TCrossMeasurement;
+            1: TCrossMeasurement;
+            2: TCrossMeasurement;
+        };
+        diagonal: TRawMeasurement;
+        height: TRawMeasurement;
+    };
+};
+export type TIMeasure3DGenericPayload = {
+    id: string;
+    world_origin: Point3D;
+    world_shape: Point3D;
+    world_spacing: Point3D;
+    rescale_intercept: number;
+    rescale_slope: number;
+    image_orientation_patient: [number, number, number, number, number, number];
+    crop_boundaries_world: [Point3D, Point3D];
+    crop_boundaries_voxel: [Point3D, Point3D];
+    crop_boundaries_unclipped_voxel: [Point3D, Point3D];
+    crop_cuboid_center_voxel: Point3D;
+    shape: Point3D;
+    world_bounding_image_positions: [Point3D, Point3D];
+    image_count: number;
+};
+export type TStaticImeasurePayload = TIMeasure3DGenericPayload & {
+    clicks: [Point3D, Point3D];
+};
+export type TInteractiveIMeasureMode = "positive" | "negative";
+export type TInteractiveIMeasureModeClicks = {
+    mode: TInteractiveIMeasureMode;
+    points: Point3D[];
+    firstClick?: true;
+};
+export type TInteractiveImeasurePayload = TIMeasure3DGenericPayload & {
+    finding_id?: string;
+    clicks: TInteractiveIMeasureModeClicks[];
+};

package/dist/types/io.js

@@ -0,0 +1 @@
+export {};

package/dist/types/metadata.d.ts

@@ -0,0 +1,19 @@
+import type { vec3 } from "gl-matrix";
+import { Point3D } from "./cornerstone";
+export type TWorldMetadata = {
+    worldOrigin: vec3;
+    worldShape: vec3;
+    worldSpacing: vec3;
+    rescaleIntercept: number;
+    rescaleSlope: number;
+    imageOrientationPatient: [number, number, number, number, number, number];
+    worldBoundingImagePositions: [vec3, vec3];
+    imageCount: number;
+};
+export type TCropMetadata = {
+    cropCuboidCenterVoxel: Point3D;
+    cropBoundariesUnclippedVoxel: [Point3D, Point3D];
+    cropBoundariesVoxel: [Point3D, Point3D];
+    cropBoundariesWorld: [Point3D, Point3D];
+    shape: [number, number, number];
+};

package/dist/types/metadata.js

@@ -0,0 +1 @@
+export {};

package/dist/types/ohif.d.ts

@@ -0,0 +1,10 @@
+import { Point3D } from "./cornerstone";
+export type TOhifDisplaySetInstanceStub = {
+    RescaleIntercept: number;
+    RescaleSlope: number;
+    ImageOrientationPatient: [number, number, number, number, number, number];
+    ImagePositionPatient: Point3D;
+};
+export type TOhifDisplaySetStub = {
+    instances: TOhifDisplaySetInstanceStub[];
+};

package/dist/types/ohif.js

@@ -0,0 +1 @@
+export {};

package/dist/types/series-metadata.d.ts

@@ -0,0 +1,19 @@
+import type { vec3 } from "gl-matrix";
+import { Point3D } from "./cornerstone";
+export type TWorldMetadata = {
+    worldOrigin: vec3;
+    worldShape: vec3;
+    worldSpacing: vec3;
+    rescaleIntercept: number;
+    rescaleSlope: number;
+    imageOrientationPatient: [number, number, number, number, number, number];
+    worldBoundingImagePositions: [vec3, vec3];
+    imageCount: number;
+};
+export type TCropMetadata = {
+    cropCuboidCenterVoxel: Point3D;
+    cropBoundariesUnclippedVoxel: [Point3D, Point3D];
+    cropBoundariesVoxel: [Point3D, Point3D];
+    cropBoundariesWorld: [Point3D, Point3D];
+    shape: [number, number, number];
+};

package/dist/types/series-metadata.js

@@ -0,0 +1 @@
+export {};

package/dist/volumes/crop.d.ts

@@ -0,0 +1,24 @@
+import vtkImageData from "@kitware/vtk.js/Common/DataModel/ImageData";
+import { TCropMetadata } from "../types/metadata";
+import { TCroppingPlanes, TIMeasureCropRegion } from "../types/crop";
+export type TInteractiveImeasureCropResult = {
+    voxelValues: Uint8Array | Int16Array | Float32Array;
+    volume: vtkImageData;
+    cropMeta: TCropMetadata;
+};
+/**
+ * Crops a VTK volume using specified crop boundaries and returns the cropped volume data along with metadata.
+ *
+ * This function takes a `vtkImageData` volume and a crop region definition, applies cropping planes,
+ * and computes the effective cropped boundaries in both voxel and world coordinates. The result includes
+ * the cropped volume, its scalar voxel values, and metadata about the crop operation.
+ */
+export declare const cropFromVTKVolumeByCropBoundaries: (vtkVolume: vtkImageData, cropRegion: TIMeasureCropRegion) => TInteractiveImeasureCropResult;
+/**
+ * Crops a VTK volume using specified cropping planes.
+ *
+ * This function applies cropping planes to a `vtkImageData` volume and returns the cropped volume.
+ * The cropping planes define the boundaries of the crop operation in voxel coordinates, ordered as:
+ * [minX, maxX, minY, maxY, minZ, maxZ].
+ */
+export declare const cropVolumeByCroppingPlanes: (vtkVolume: vtkImageData, croppingPlanes: TCroppingPlanes) => vtkImageData;

package/dist/volumes/crop.js

@@ -0,0 +1,52 @@
+import cropFilter from "@kitware/vtk.js/Filters/General/ImageCropFilter";
+import { affineTranslateVec3, getAffineMatrixFromVtkImageData, } from "../math/affines";
+import { vec3ToPoint3D } from "../formatting";
+/**
+ * Crops a VTK volume using specified crop boundaries and returns the cropped volume data along with metadata.
+ *
+ * This function takes a `vtkImageData` volume and a crop region definition, applies cropping planes,
+ * and computes the effective cropped boundaries in both voxel and world coordinates. The result includes
+ * the cropped volume, its scalar voxel values, and metadata about the crop operation.
+ */
+export const cropFromVTKVolumeByCropBoundaries = (vtkVolume, cropRegion) => {
+    const voxelToWorldAffine = getAffineMatrixFromVtkImageData(vtkVolume);
+    const croppedVolume = cropVolumeByCroppingPlanes(vtkVolume, cropRegion.croppingPlanes);
+    // Our resulting crop may differ from the crop cube we passed in in case the
+    // crop cube exceeded the bounds of the original volume. To get its exact, effective
+    // coordinates, we get its extent...
+    const [minX, maxX, minY, maxY, minZ, maxZ] = croppedVolume.getExtent();
+    const actualCroppedBounds = [
+        [minX, minY, minZ],
+        [maxX, maxY, maxZ],
+    ];
+    // ...and translate it to world coordinates
+    const cropBoundariesWorld = actualCroppedBounds.map((pt) => vec3ToPoint3D(affineTranslateVec3(pt, voxelToWorldAffine)));
+    return {
+        voxelValues: croppedVolume
+            .getPointData()
+            .getScalars()
+            .getData(),
+        volume: croppedVolume,
+        cropMeta: {
+            cropCuboidCenterVoxel: cropRegion.voxelSpaceCenter,
+            cropBoundariesUnclippedVoxel: cropRegion.cropCubePoints,
+            cropBoundariesVoxel: actualCroppedBounds,
+            cropBoundariesWorld: cropBoundariesWorld,
+            shape: croppedVolume.getDimensions(),
+        },
+    };
+};
+/**
+ * Crops a VTK volume using specified cropping planes.
+ *
+ * This function applies cropping planes to a `vtkImageData` volume and returns the cropped volume.
+ * The cropping planes define the boundaries of the crop operation in voxel coordinates, ordered as:
+ * [minX, maxX, minY, maxY, minZ, maxZ].
+ */
+export const cropVolumeByCroppingPlanes = (vtkVolume, croppingPlanes) => {
+    const cropper = cropFilter.newInstance();
+    cropper.setInputData(vtkVolume);
+    cropper.setCroppingPlanes(croppingPlanes);
+    cropper.update();
+    return cropper.getOutputData();
+};

package/docs/README.md

@@ -0,0 +1,26 @@
+# Website
+
+This website is built using [Docusaurus](https://docusaurus.io/), a modern static website generator.
+> :bulb:  Note: `docs/sdk` is automatically generated using Typedoc
+
+## Installation
+
+```bash
+npm i
+```
+
+## Local Development
+
+```bash
+npm run dev
+```
+
+This command starts a local development server and opens up a browser window. Most changes are reflected live without having to restart the server.
+
+## Build
+
+```bash
+npm run build
+```
+
+This command generates static content into the `build` directory and can be served using any static contents hosting service.

package/docs/docs/api.md

@@ -0,0 +1,5 @@
+---
+sidebar_position: 1
+---
+
+# IMeasure API documentation