@bettermedicine/imeasure 0.0.1

package/.github/workflows/test-build-imeasure-package.yml

@@ -0,0 +1,30 @@
+name: Test and Build imeasure package
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+jobs:
+  test-and-build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "18"
+      - name: Install dependencies
+        run: npm install
+      - name: Lint
+        run: npm run lint
+      - name: Run tests
+        run: npm test
+      - name: Build package
+        run: npm run build
+  # TODO: Add steps to publish the package on main branch?

package/Makefile

@@ -0,0 +1,21 @@
+.PHONY: test build lint dev-docs build-docs build-publish-docs
+
+bootstrap:
+	npm install
+	cd ./docs && npm install
+
+test:
+	npm test
+build:
+	npm run build
+lint:
+	npm run lint
+
+dev-docs:
+	cd ./docs && npm run dev
+
+build-docs:
+	cd ./docs && npm run build
+
+build-publish-docs:
+	@make build-docs

package/README.md

@@ -0,0 +1,31 @@
+# Imeasure SDK
+
+This is a collection of TypeScript types and utility functions for working with
+Better Medicine's iMeasure API.
+
+## Installation
+
+```bash
+npm install @bettermedicine/imeasure
+```
+
+## Usage
+
+### API request & response types
+
+TODO: a brief summary of how to import the I/O types
+
+### Cropping
+
+TODO: A brief explanation of how cropping works and which utilities we provide for it.
+
+Note: mention how cornerstone3 volumes mostly live in the GPU buffer and how these need to be
+converted to CPU buffers for cropping operations.
+
+#### Bounding box calculations
+
+TODO: A brief explanation on how these work and why they are necessary
+
+### World metadata
+
+TODO: A brief explanation of the world metadata we require for the request and how to derive it

package/dist/affines/from-cs-volume.d.ts

@@ -0,0 +1,2 @@
+import { ImageVolume } from "../types/cornerstone";
+export declare const getAffineFromCornerstoneVolume: (volume: ImageVolume) => import("gl-matrix").mat4;

package/dist/affines/from-cs-volume.js

@@ -0,0 +1,12 @@
+import { getAffineMatrixFromPrimitives, } from "./from-primitives";
+export const getAffineFromCornerstoneVolume = (volume) => {
+    const spacing = volume.spacing;
+    const origin = volume.origin;
+    const direction = volume.direction;
+    const bounds = volume.voxelManager?.getDefaultBounds();
+    const extent = bounds.flatMap((b) => [
+        b[0],
+        b[1],
+    ]);
+    return getAffineMatrixFromPrimitives({ spacing, origin, direction, extent });
+};

package/dist/affines/from-primitives.d.ts

@@ -0,0 +1,8 @@
+import { mat3, mat4, vec3 } from "gl-matrix";
+export type TAffinePrimitivesInput = {
+    spacing: vec3;
+    origin: vec3;
+    direction: mat3;
+    extent: [number, number, number, number, number, number];
+};
+export declare const getAffineMatrixFromPrimitives: (input: TAffinePrimitivesInput) => mat4;

package/dist/affines/from-primitives.js

@@ -0,0 +1,24 @@
+import { mat4 } from "gl-matrix";
+export const getAffineMatrixFromPrimitives = (input) => {
+    const { spacing, origin, direction, extent } = input;
+    const adjustedOrigin = [
+        origin[0] + extent[0] * spacing[0],
+        origin[1] + extent[2] * spacing[1],
+        origin[2] + extent[4] * spacing[2],
+    ];
+    const mat = mat4.create();
+    mat[0] = spacing[0] * direction[0]; // X-axis
+    mat[1] = spacing[0] * direction[3];
+    mat[2] = spacing[0] * direction[6];
+    mat[4] = spacing[1] * direction[1]; // Y-axis
+    mat[5] = spacing[1] * direction[4];
+    mat[6] = spacing[1] * direction[7];
+    mat[8] = spacing[2] * direction[2]; // Z-axis
+    mat[9] = spacing[2] * direction[5];
+    mat[10] = spacing[2] * direction[8];
+    // Set the translation (origin)
+    mat[12] = adjustedOrigin[0];
+    mat[13] = adjustedOrigin[1];
+    mat[14] = adjustedOrigin[2];
+    return mat;
+};

package/dist/affines/from-vtk-image-data.d.ts

@@ -0,0 +1,2 @@
+import vtkImageData from "@kitware/vtk.js/Common/DataModel/ImageData";
+export declare const getAffineMatrix: (imageData: vtkImageData) => import("gl-matrix").mat4;

package/dist/affines/from-vtk-image-data.js

@@ -0,0 +1,13 @@
+import { getAffineMatrixFromPrimitives } from "./from-primitives";
+// Given a vtkImageData object, this function returns the affine matrix that allows us to convert
+// voxel-space coordinates to world-space coordinates & vice versa.
+// Respects origin, extent, spacing, and direction of the vtkImageData object.
+export const getAffineMatrix = (imageData) => {
+    const spacing = imageData.getSpacing(); // [sx, sy, sz]
+    const origin = imageData.getOrigin(); // [ox, oy, oz]
+    const direction = imageData.getDirection(); // 3x3 direction matrix
+    const extent = imageData.getExtent(); // [xmin, xmax, ymin, ymax, zmin, zmax]
+    // the affine matrix should work in "isolation" so that when applied to voxel-space point
+    // coordinates, we get the world-space coordinates.
+    return getAffineMatrixFromPrimitives({ spacing, origin, direction, extent });
+};

package/dist/affines/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./from-primitives";
+export * from "./from-cs-volume";
+export * from "./from-vtk-image-data";
+export * from "./invert";
+export * from "./translate";

package/dist/affines/index.js

@@ -0,0 +1,5 @@
+export * from "./from-primitives";
+export * from "./from-cs-volume";
+export * from "./from-vtk-image-data";
+export * from "./invert";
+export * from "./translate";

package/dist/affines/invert.d.ts

@@ -0,0 +1,2 @@
+import { mat4 } from "gl-matrix";
+export declare const invertAffineMatrix: (matrix: mat4) => mat4;

package/dist/affines/invert.js

@@ -0,0 +1,6 @@
+import { mat4 } from "gl-matrix";
+export const invertAffineMatrix = (matrix) => {
+    const inv = mat4.create();
+    mat4.invert(inv, matrix);
+    return inv;
+};

package/dist/affines/serialize.d.ts

@@ -0,0 +1,2 @@
+import { mat4, vec4 } from "gl-matrix";
+export declare const serializeAffineMatrix: (mat: mat4) => [vec4, vec4, vec4, vec4];

package/dist/affines/serialize.js

@@ -0,0 +1,12 @@
+import { vec4 } from "gl-matrix";
+// A serialized plain mat4 looks like a float32array of 16 elements.
+// For it to be readable (esp. in a format that Numpy likes), we chunk it
+// into 4 vec4s.
+export const serializeAffineMatrix = (mat) => {
+    return [
+        vec4.fromValues(mat[0], mat[4], mat[8], mat[12]),
+        vec4.fromValues(mat[1], mat[5], mat[9], mat[13]),
+        vec4.fromValues(mat[2], mat[6], mat[10], mat[14]),
+        vec4.fromValues(mat[3], mat[7], mat[11], mat[15]),
+    ];
+};

package/dist/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/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/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const INTERACTIVE_IMEASURE_BASE_X_VOXELS = 128;
+export declare const INTERACTIVE_IMEASURE_BASE_Y_VOXELS = 128;
+export declare const INTERACTIVE_IMEASURE_BASE_Z_VOXELS = 32;
+export declare const INTERACTIVE_IMEASURE_BASE_PADDING_VOXELS = 8;
+export declare const INTERACTIVE_IMEASURE_BASE: {
+    X: number;
+    Y: number;
+    Z: number;
+    PADDING: number;
+};

package/dist/constants.js

@@ -0,0 +1,10 @@
+export const INTERACTIVE_IMEASURE_BASE_X_VOXELS = 128;
+export const INTERACTIVE_IMEASURE_BASE_Y_VOXELS = 128;
+export const INTERACTIVE_IMEASURE_BASE_Z_VOXELS = 32;
+export const INTERACTIVE_IMEASURE_BASE_PADDING_VOXELS = 8;
+export const INTERACTIVE_IMEASURE_BASE = {
+    X: INTERACTIVE_IMEASURE_BASE_X_VOXELS,
+    Y: INTERACTIVE_IMEASURE_BASE_Y_VOXELS,
+    Z: INTERACTIVE_IMEASURE_BASE_Z_VOXELS,
+    PADDING: INTERACTIVE_IMEASURE_BASE_PADDING_VOXELS,
+};

package/dist/cropping/index.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/cropping/index.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/dist/formatting/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./static";
+export * from "./interactive";
+export * from "./utils";

package/dist/formatting/index.js

@@ -0,0 +1,3 @@
+export * from "./static";
+export * from "./interactive";
+export * from "./utils";

package/dist/formatting/interactive.d.ts

@@ -0,0 +1,7 @@
+import { TInteractiveIMeasureModeClicks } from "../types/io";
+import { TWorldMetadata, TCropMetadata } from "../types/metadata";
+export type TInteractiveImeasureInput = {
+    id: string;
+    clicks: TInteractiveIMeasureModeClicks[];
+} & TWorldMetadata & TCropMetadata;
+export declare const formatInteractivePayload: (input: TInteractiveImeasureInput, image: Int16Array, mask?: Uint8Array) => import("undici-types").FormData;

package/dist/formatting/interactive.js

@@ -0,0 +1,39 @@
+import { vec3ToPoint3D } from "./utils";
+export const formatInteractivePayload = (input, image, mask) => {
+    const fd = new FormData();
+    const metadata = {
+        id: input.id,
+        clicks: input.clicks,
+        world_origin: vec3ToPoint3D(input.worldOrigin),
+        world_shape: vec3ToPoint3D(input.worldShape),
+        world_spacing: vec3ToPoint3D(input.worldSpacing),
+        rescale_intercept: input.rescaleIntercept,
+        rescale_slope: input.rescaleSlope,
+        image_orientation_patient: input.imageOrientationPatient,
+        crop_boundaries_world: input.cropBoundariesWorld,
+        crop_boundaries_voxel: input.cropBoundariesVoxel,
+        crop_boundaries_unclipped_voxel: input.cropBoundariesUnclippedVoxel,
+        crop_cuboid_center_voxel: input.cropCuboidCenterVoxel,
+        shape: input.shape,
+        world_bounding_image_positions: [
+            vec3ToPoint3D(input.worldBoundingImagePositions[0]),
+            vec3ToPoint3D(input.worldBoundingImagePositions[1]),
+        ],
+        image_count: input.imageCount,
+    };
+    const metadataBlob = new Blob([JSON.stringify(metadata)], {
+        type: "application/json",
+    });
+    const imageBlob = new Blob([image.buffer], {
+        type: "application/octet-stream",
+    });
+    fd.append("metadata", metadataBlob, "metadata.json");
+    fd.append("image", imageBlob, "image.bin");
+    if (mask) {
+        const maskBlob = new Blob([mask.buffer], {
+            type: "application/octet-stream",
+        });
+        fd.append("mask", maskBlob, "mask.bin");
+    }
+    return fd;
+};

package/dist/formatting/static.d.ts

@@ -0,0 +1,7 @@
+import { Point3D } from "../types/cornerstone";
+import { TWorldMetadata, TCropMetadata } from "../types/metadata";
+export type TStaticImeasureInput = {
+    id: string;
+    clicks: [Point3D, Point3D];
+} & TWorldMetadata & TCropMetadata;
+export declare const formatStaticPayload: (input: TStaticImeasureInput, image: Int16Array) => import("undici-types").FormData;

package/dist/formatting/static.js

@@ -0,0 +1,33 @@
+import { vec3ToPoint3D } from "./utils";
+export const formatStaticPayload = (input, image) => {
+    const fd = new FormData();
+    const metadata = {
+        id: input.id,
+        clicks: input.clicks,
+        world_origin: vec3ToPoint3D(input.worldOrigin),
+        world_shape: vec3ToPoint3D(input.worldShape),
+        world_spacing: vec3ToPoint3D(input.worldSpacing),
+        rescale_intercept: input.rescaleIntercept,
+        rescale_slope: input.rescaleSlope,
+        image_orientation_patient: input.imageOrientationPatient,
+        crop_boundaries_world: input.cropBoundariesWorld,
+        crop_boundaries_voxel: input.cropBoundariesVoxel,
+        crop_boundaries_unclipped_voxel: input.cropBoundariesUnclippedVoxel,
+        crop_cuboid_center_voxel: input.cropCuboidCenterVoxel,
+        shape: input.shape,
+        world_bounding_image_positions: [
+            vec3ToPoint3D(input.worldBoundingImagePositions[0]),
+            vec3ToPoint3D(input.worldBoundingImagePositions[1]),
+        ],
+        image_count: input.imageCount,
+    };
+    const metadataBlob = new Blob([JSON.stringify(metadata)], {
+        type: "application/json",
+    });
+    const imageBlob = new Blob([image.buffer], {
+        type: "application/octet-stream",
+    });
+    fd.append("metadata", metadataBlob, "metadata.json");
+    fd.append("image", imageBlob, "image.bin");
+    return fd;
+};

package/dist/formatting/utils.d.ts

@@ -0,0 +1,4 @@
+import { vec3 } from "gl-matrix";
+import { Point3D } from "../types/cornerstone";
+export declare const float32arrayToInt16: (float32Array: Float32Array) => Int16Array;
+export declare const vec3ToPoint3D: (vec: vec3) => Point3D;

package/dist/formatting/utils.js

@@ -0,0 +1,20 @@
+// Since DICOM CT HU values always fall well within the int16 range
+// of (-32768, 32767), we can safely convert the output array to int16-s.
+// This reduces the size of our payload by half compared to float32.
+export const float32arrayToInt16 = (float32Array) => {
+    // if we're already dealing with an Int16Array, just return it
+    if (float32Array instanceof Int16Array) {
+        return float32Array;
+    }
+    const int16Buffer = new ArrayBuffer(float32Array.length * Int16Array.BYTES_PER_ELEMENT);
+    const int16Array = new Int16Array(int16Buffer);
+    const float32View = new DataView(float32Array.buffer);
+    for (let i = 0; i < float32Array.length; i++) {
+        const floatValue = float32View.getFloat32(i * Float32Array.BYTES_PER_ELEMENT, true);
+        int16Array[i] = floatValue;
+    }
+    return int16Array;
+};
+export const vec3ToPoint3D = (vec) => {
+    return [vec[0], vec[1], vec[2]];
+};

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export type * as Types from "./types";
+export * as constants from "./constants";
+export * as formatting from "./formatting";
+export * as math from "./math";
+export * as metadata from "./metadata/world";
+export * as cropping from "./cropping";

package/dist/index.js

@@ -0,0 +1,15 @@
+export * as constants from "./constants";
+export * as formatting from "./formatting";
+export * as math from "./math";
+export * as metadata from "./metadata/world";
+export * as cropping from "./cropping";
+// TODO:
+// expose utils, volumes, metadata, math modules
+// write/port tests, especially for math module
+// document math flow - how do we go from a measurement to a crop region
+// write docs with docusaurus (and typedoc?)
+//   include API docs
+// add readme
+// add publish script
+// make this repo public
+// set up hosting for docs

package/dist/math/affines/from-cs-volume.d.ts

@@ -0,0 +1,8 @@
+import { ImageVolume } from "../../types/cornerstone";
+/**
+ * Computes a voxel-to-world affine transformation matrix for a given Cornerstone ImageVolume.
+ *
+ * This function extracts the spacing, origin, direction, and voxel bounds from the provided
+ * volume and constructs the affine matrix using these primitives.
+ */
+export declare const getAffineFromCornerstoneVolume: (volume: ImageVolume) => import("gl-matrix").mat4;

package/dist/math/affines/from-cs-volume.js

@@ -0,0 +1,18 @@
+import { getAffineMatrixFromPrimitives, } from "./from-primitives";
+/**
+ * Computes a voxel-to-world affine transformation matrix for a given Cornerstone ImageVolume.
+ *
+ * This function extracts the spacing, origin, direction, and voxel bounds from the provided
+ * volume and constructs the affine matrix using these primitives.
+ */
+export const getAffineFromCornerstoneVolume = (volume) => {
+    const spacing = volume.spacing;
+    const origin = volume.origin;
+    const direction = volume.direction;
+    const bounds = volume.voxelManager?.getDefaultBounds();
+    const extent = bounds.flatMap((b) => [
+        b[0],
+        b[1],
+    ]);
+    return getAffineMatrixFromPrimitives({ spacing, origin, direction, extent });
+};

package/dist/math/affines/from-primitives.d.ts

@@ -0,0 +1,12 @@
+import { mat3, mat4, vec3 } from "gl-matrix";
+export type TAffinePrimitivesInput = {
+    spacing: vec3;
+    origin: vec3;
+    direction: mat3;
+    extent: [number, number, number, number, number, number];
+};
+/**
+ * Computes a voxel-to-world affine transformation matrix based on
+ * the provided set of world metadata.
+ */
+export declare const getAffineMatrixFromPrimitives: (input: TAffinePrimitivesInput) => mat4;

package/dist/math/affines/from-primitives.js

@@ -0,0 +1,28 @@
+import { mat4 } from "gl-matrix";
+/**
+ * Computes a voxel-to-world affine transformation matrix based on
+ * the provided set of world metadata.
+ */
+export const getAffineMatrixFromPrimitives = (input) => {
+    const { spacing, origin, direction, extent } = input;
+    const adjustedOrigin = [
+        origin[0] + extent[0] * spacing[0],
+        origin[1] + extent[2] * spacing[1],
+        origin[2] + extent[4] * spacing[2],
+    ];
+    const mat = mat4.create();
+    mat[0] = spacing[0] * direction[0]; // X-axis
+    mat[1] = spacing[0] * direction[3];
+    mat[2] = spacing[0] * direction[6];
+    mat[4] = spacing[1] * direction[1]; // Y-axis
+    mat[5] = spacing[1] * direction[4];
+    mat[6] = spacing[1] * direction[7];
+    mat[8] = spacing[2] * direction[2]; // Z-axis
+    mat[9] = spacing[2] * direction[5];
+    mat[10] = spacing[2] * direction[8];
+    // Set the translation (origin)
+    mat[12] = adjustedOrigin[0];
+    mat[13] = adjustedOrigin[1];
+    mat[14] = adjustedOrigin[2];
+    return mat;
+};

package/dist/math/affines/from-vtk-image-data.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Computes a voxel-to-world affine transformation matrix from a vtkImageData object.
+ */
+import vtkImageData from "@kitware/vtk.js/Common/DataModel/ImageData";
+export declare const getAffineMatrixFromVtkImageData: (imageData: vtkImageData) => import("gl-matrix").mat4;

package/dist/math/affines/from-vtk-image-data.js

@@ -0,0 +1,8 @@
+import { getAffineMatrixFromPrimitives } from "./from-primitives";
+export const getAffineMatrixFromVtkImageData = (imageData) => {
+    const spacing = imageData.getSpacing(); // [sx, sy, sz]
+    const origin = imageData.getOrigin(); // [ox, oy, oz]
+    const direction = imageData.getDirection(); // 3x3 direction matrix
+    const extent = imageData.getExtent(); // [xmin, xmax, ymin, ymax, zmin, zmax]
+    return getAffineMatrixFromPrimitives({ spacing, origin, direction, extent });
+};

package/dist/math/affines/from-vtk-image-data.test.d.ts

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

package/dist/math/affines/from-vtk-image-data.test.js

@@ -0,0 +1,15 @@
+import vtkImageData from "@kitware/vtk.js/Common/DataModel/ImageData";
+import { it, describe, expect } from "vitest";
+import { getAffineMatrixFromVtkImageData } from "./from-vtk-image-data";
+import { sampleFFSMatrix } from "../../test/testdata";
+describe("getAffineMatrixFromVtkImageData", () => {
+    it("returns the expected affine matrix for a sample vtkImageData object", () => {
+        const imageData = vtkImageData.newInstance({
+            spacing: [0.880859375, 0.880859375, 1],
+            origin: [-224.0595703125, -397.5695703125, -511.4],
+            extent: [0, 512, 0, 512, 0, 524],
+        });
+        const matrix = getAffineMatrixFromVtkImageData(imageData);
+        expect(matrix).toEqual(sampleFFSMatrix);
+    });
+});

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

@@ -0,0 +1,6 @@
+export * from "./from-primitives";
+export * from "./from-cs-volume";
+export * from "./from-vtk-image-data";
+export * from "./invert";
+export * from "./translate";
+export * from "./serialize";

package/dist/math/affines/index.js

@@ -0,0 +1,6 @@
+export * from "./from-primitives";
+export * from "./from-cs-volume";
+export * from "./from-vtk-image-data";
+export * from "./invert";
+export * from "./translate";
+export * from "./serialize";

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

@@ -0,0 +1,2 @@
+import { mat4 } from "gl-matrix";
+export declare const invertAffineMatrix: (matrix: mat4) => mat4;

package/dist/math/affines/invert.js

@@ -0,0 +1,6 @@
+import { mat4 } from "gl-matrix";
+export const invertAffineMatrix = (matrix) => {
+    const inv = mat4.create();
+    mat4.invert(inv, matrix);
+    return inv;
+};

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

@@ -0,0 +1,2 @@
+import { mat4, vec4 } from "gl-matrix";
+export declare const serializeAffineMatrix: (mat: mat4) => [vec4, vec4, vec4, vec4];

package/dist/math/affines/serialize.js

@@ -0,0 +1,12 @@
+import { vec4 } from "gl-matrix";
+// A serialized plain mat4 looks like a float32array of 16 elements.
+// For it to be readable (esp. in a format that Numpy likes), we chunk it
+// into 4 vec4s.
+export const serializeAffineMatrix = (mat) => {
+    return [
+        vec4.fromValues(mat[0], mat[4], mat[8], mat[12]),
+        vec4.fromValues(mat[1], mat[5], mat[9], mat[13]),
+        vec4.fromValues(mat[2], mat[6], mat[10], mat[14]),
+        vec4.fromValues(mat[3], mat[7], mat[11], mat[15]),
+    ];
+};

package/dist/math/affines/translate-and-invert.test.d.ts

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