@cornerstonejs/core 3.8.6 → 3.9.0

package/dist/esm/cache/classes/Mesh.d.ts

@@ -0,0 +1,17 @@
+import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
+import type { MeshData, RGB } from '../../types';
+type MeshProps = MeshData;
+export declare class Mesh {
+    readonly id: string;
+    readonly sizeInBytes: number;
+    private _color;
+    private _actors;
+    private _format;
+    constructor(props: MeshProps);
+    private _getSizeInBytes;
+    get defaultActor(): vtkActor;
+    get actors(): vtkActor[];
+    get color(): RGB;
+    get format(): string;
+}
+export {};

package/dist/esm/cache/classes/Mesh.js

@@ -0,0 +1,90 @@
+import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
+import vtkMapper from '@kitware/vtk.js/Rendering/Core/Mapper';
+import vtkPLYReader from '@kitware/vtk.js/IO/Geometry/PLYReader';
+import vtkSTLReader from '@kitware/vtk.js/IO/Geometry/STLReader';
+import vtkXMLPolyDataReader from '@kitware/vtk.js/IO/XML/XMLPolyDataReader';
+import vtkOBJReader from '@kitware/vtk.js/IO/Misc/OBJReader';
+import vtkProperty from '@kitware/vtk.js/Rendering/Core/Property';
+import vtkPolyDataNormals from '@kitware/vtk.js/Filters/Core/PolyDataNormals';
+import { MeshType } from '../../enums';
+export class Mesh {
+    constructor(props) {
+        this._color = [255, 255, 255];
+        this._actors = [];
+        this.id = props.id;
+        this._color = props.color ?? this._color;
+        this._format = props.format;
+        const textDecoder = new TextDecoder();
+        const normals = vtkPolyDataNormals.newInstance();
+        const createActorWithMapper = (mapper) => {
+            const actor = vtkActor.newInstance();
+            actor.setMapper(mapper);
+            const property = vtkProperty.newInstance();
+            property.setColor(this._color[0] / 255, this._color[1] / 255, this._color[2] / 255);
+            actor.setProperty(property);
+            return actor;
+        };
+        if (this._format === MeshType.PLY) {
+            const mapper = vtkMapper.newInstance();
+            const reader = vtkPLYReader.newInstance();
+            reader.parseAsArrayBuffer(props.arrayBuffer);
+            mapper.setInputConnection(reader.getOutputPort());
+            this._actors.push(createActorWithMapper(mapper));
+        }
+        else if (this._format === MeshType.STL) {
+            const mapper = vtkMapper.newInstance();
+            const reader = vtkSTLReader.newInstance();
+            reader.parseAsArrayBuffer(props.arrayBuffer);
+            normals.setInputConnection(reader.getOutputPort());
+            mapper.setInputConnection(normals.getOutputPort());
+            this._actors.push(createActorWithMapper(mapper));
+        }
+        else if (this._format === MeshType.OBJ) {
+            const reader = vtkOBJReader.newInstance({
+                splitMode: props.materialUrl ? 'usemtl' : null,
+            });
+            reader.parseAsText(textDecoder.decode(props.arrayBuffer));
+            const size = reader.getNumberOfOutputPorts();
+            for (let i = 0; i < size; i++) {
+                const source = reader.getOutputData(i);
+                const mapper = vtkMapper.newInstance();
+                mapper.setInputData(source);
+                this._actors.push(createActorWithMapper(mapper));
+            }
+        }
+        else if (this._format === MeshType.VTP) {
+            const mapper = vtkMapper.newInstance();
+            const reader = vtkXMLPolyDataReader.newInstance();
+            reader.parseAsArrayBuffer(props.arrayBuffer);
+            mapper.setInputConnection(reader.getOutputPort());
+            this._actors.push(createActorWithMapper(mapper));
+        }
+        this.sizeInBytes = this._getSizeInBytes();
+    }
+    _getSizeInBytes() {
+        let size = 0;
+        for (let i = 0; i < this._actors.length; i++) {
+            const actor = this._actors[i];
+            const mapper = actor.getMapper();
+            const pd = mapper.getInputData();
+            const points = pd.getPoints();
+            const polys = pd.getPolys();
+            const pointsLength = points.getData().length;
+            const polysLength = polys.getData().length;
+            size += pointsLength * 4 + polysLength * 4;
+        }
+        return size;
+    }
+    get defaultActor() {
+        return this._actors[0];
+    }
+    get actors() {
+        return this._actors;
+    }
+    get color() {
+        return this._color;
+    }
+    get format() {
+        return this._format;
+    }
+}

package/dist/esm/cache/index.d.ts

@@ -1,6 +1,7 @@
 import { Cache } from './cache';
 import ImageVolume from './classes/ImageVolume';
 import { Surface } from './classes/Surface';
+import { Mesh } from './classes/Mesh';
 import StreamingImageVolume from './classes/StreamingImageVolume';
 import StreamingDynamicImageVolume from './classes/StreamingDynamicImageVolume';
-export { ImageVolume, Cache, Surface, StreamingImageVolume, StreamingDynamicImageVolume, };
+export { ImageVolume, Cache, Surface, Mesh, StreamingImageVolume, StreamingDynamicImageVolume, };

package/dist/esm/cache/index.js

@@ -1,6 +1,7 @@
 import { Cache } from './cache';
 import ImageVolume from './classes/ImageVolume';
 import { Surface } from './classes/Surface';
+import { Mesh } from './classes/Mesh';
 import StreamingImageVolume from './classes/StreamingImageVolume';
 import StreamingDynamicImageVolume from './classes/StreamingDynamicImageVolume';
-export { ImageVolume, Cache, Surface, StreamingImageVolume, StreamingDynamicImageVolume, };
+export { ImageVolume, Cache, Surface, Mesh, StreamingImageVolume, StreamingDynamicImageVolume, };

package/dist/esm/enums/Events.d.ts

@@ -41,6 +41,7 @@ declare enum Events {
     DYNAMIC_VOLUME_DIMENSION_GROUP_LOADED = "DYNAMIC_VOLUME_DIMENSION_GROUP_LOADED",
     DYNAMIC_VOLUME_TIME_POINT_LOADED = "DYNAMIC_VOLUME_TIME_POINT_LOADED",
     GEOMETRY_LOADED = "GEOMETRY_LOADED",
+    GEOMETRY_LOAD_PROGRESS = "GEOMETRY_LOAD_PROGRESS",
     GEOMETRY_LOADED_FAILED = "GEOMETRY_LOADED_FAILED"
 }
 export default Events;

package/dist/esm/enums/Events.js

@@ -42,6 +42,7 @@ var Events;
     Events["DYNAMIC_VOLUME_DIMENSION_GROUP_LOADED"] = "DYNAMIC_VOLUME_DIMENSION_GROUP_LOADED";
     Events["DYNAMIC_VOLUME_TIME_POINT_LOADED"] = "DYNAMIC_VOLUME_TIME_POINT_LOADED";
     Events["GEOMETRY_LOADED"] = "GEOMETRY_LOADED";
+    Events["GEOMETRY_LOAD_PROGRESS"] = "GEOMETRY_LOAD_PROGRESS";
     Events["GEOMETRY_LOADED_FAILED"] = "GEOMETRY_LOADED_FAILED";
 })(Events || (Events = {}));
 export default Events;

package/dist/esm/enums/GeometryType.d.ts

@@ -1,5 +1,6 @@
 declare enum GeometryType {
     CONTOUR = "CONTOUR",
-    SURFACE = "SURFACE"
+    SURFACE = "SURFACE",
+    MESH = "MESH"
 }
 export default GeometryType;

package/dist/esm/enums/GeometryType.js

@@ -2,5 +2,6 @@ var GeometryType;
 (function (GeometryType) {
     GeometryType["CONTOUR"] = "CONTOUR";
     GeometryType["SURFACE"] = "SURFACE";
+    GeometryType["MESH"] = "MESH";
 })(GeometryType || (GeometryType = {}));
 export default GeometryType;

package/dist/esm/enums/MeshType.d.ts

@@ -0,0 +1,7 @@
+declare enum MeshType {
+    PLY = "PLY",
+    STL = "STL",
+    OBJ = "OBJ",
+    VTP = "VTP"
+}
+export default MeshType;

package/dist/esm/enums/MeshType.js

@@ -0,0 +1,8 @@
+var MeshType;
+(function (MeshType) {
+    MeshType["PLY"] = "PLY";
+    MeshType["STL"] = "STL";
+    MeshType["OBJ"] = "OBJ";
+    MeshType["VTP"] = "VTP";
+})(MeshType || (MeshType = {}));
+export default MeshType;

package/dist/esm/enums/index.d.ts

@@ -6,6 +6,7 @@ import BlendModes from './BlendModes';
 import OrientationAxis from './OrientationAxis';
 import GeometryType from './GeometryType';
 import ContourType from './ContourType';
+import MeshType from './MeshType';
 import VOILUTFunctionType from './VOILUTFunctionType';
 import DynamicOperatorType from './DynamicOperatorType';
 import CalibrationTypes from './CalibrationTypes';
@@ -15,4 +16,4 @@ import * as VideoEnums from './VideoEnums';
 import MetadataModules from './MetadataModules';
 import { GenerateImageType } from './GenerateImageType';
 import VoxelManagerEnum from './VoxelManagerEnum';
-export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, };
+export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, };

package/dist/esm/enums/index.js

@@ -6,6 +6,7 @@ import BlendModes from './BlendModes';
 import OrientationAxis from './OrientationAxis';
 import GeometryType from './GeometryType';
 import ContourType from './ContourType';
+import MeshType from './MeshType';
 import VOILUTFunctionType from './VOILUTFunctionType';
 import DynamicOperatorType from './DynamicOperatorType';
 import CalibrationTypes from './CalibrationTypes';
@@ -15,4 +16,4 @@ import * as VideoEnums from './VideoEnums';
 import MetadataModules from './MetadataModules';
 import { GenerateImageType } from './GenerateImageType';
 import VoxelManagerEnum from './VoxelManagerEnum';
-export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, };
+export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, };

package/dist/esm/index.d.ts

@@ -33,6 +33,7 @@ import { registerImageLoader } from './loaders/imageLoader';
 import triggerEvent from './utilities/triggerEvent';
 import { cornerstoneStreamingImageVolumeLoader } from './loaders/cornerstoneStreamingImageVolumeLoader';
 import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerstoneStreamingDynamicImageVolumeLoader';
+import { cornerstoneMeshLoader } from './loaders/cornerstoneMeshLoader';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports } from './RenderingEngine/helpers';
 export type { Types, IRetrieveConfiguration, RetrieveOptions, RetrieveStage, ImageLoadListener, IImagesLoader, };
-export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, };
+export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, };

package/dist/esm/index.js

@@ -31,5 +31,6 @@ import { registerImageLoader } from './loaders/imageLoader';
 import triggerEvent from './utilities/triggerEvent';
 import { cornerstoneStreamingImageVolumeLoader } from './loaders/cornerstoneStreamingImageVolumeLoader';
 import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerstoneStreamingDynamicImageVolumeLoader';
+import { cornerstoneMeshLoader } from './loaders/cornerstoneMeshLoader';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, } from './RenderingEngine/helpers';
-export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, };
+export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, };

package/dist/esm/loaders/cornerstoneMeshLoader.d.ts

@@ -0,0 +1,4 @@
+import type { IGeometryLoadObject } from '../types';
+import type { GeometryLoaderOptions } from '../types/GeometryLoaderFn';
+declare function cornerstoneMeshLoader(meshId: string, options: Record<string, unknown>, loaderOptions: GeometryLoaderOptions): IGeometryLoadObject;
+export { cornerstoneMeshLoader };

package/dist/esm/loaders/cornerstoneMeshLoader.js

@@ -0,0 +1,75 @@
+import { createMesh } from './utils/mesh/createMesh';
+import { Events } from '../enums';
+import eventTarget from '../eventTarget';
+import { triggerEvent } from '../utilities';
+function fetchArrayBuffer({ url, signal, onload, loaderOptions, }) {
+    return new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        xhr.open('GET', url, true);
+        const defaultHeaders = {};
+        const beforeSendHeaders = loaderOptions.beforeSend(xhr, defaultHeaders);
+        const headers = Object.assign({}, defaultHeaders, beforeSendHeaders);
+        xhr.responseType = 'arraybuffer';
+        Object.keys(headers).forEach(function (key) {
+            if (headers[key] === null) {
+                return;
+            }
+            xhr.setRequestHeader(key, headers[key]);
+        });
+        const onLoadHandler = function (e) {
+            if (onload && typeof onload === 'function') {
+                onload();
+            }
+            if (signal) {
+                signal.removeEventListener('abort', onAbortHandler);
+            }
+            resolve(xhr.response);
+        };
+        const onAbortHandler = () => {
+            xhr.abort();
+            xhr.removeEventListener('load', onLoadHandler);
+            reject(new Error('Request aborted'));
+        };
+        xhr.addEventListener('load', onLoadHandler);
+        const onProgress = (loaded, total) => {
+            const data = { url, loaded, total };
+            triggerEvent(eventTarget, Events.GEOMETRY_LOAD_PROGRESS, { data });
+        };
+        xhr.onprogress = function (e) {
+            onProgress(e.loaded, e.total);
+        };
+        if (signal && signal.aborted) {
+            xhr.abort();
+            reject(new Error('Request aborted'));
+        }
+        else if (signal) {
+            signal.addEventListener('abort', onAbortHandler);
+        }
+        xhr.send();
+    });
+}
+function cornerstoneMeshLoader(meshId, options, loaderOptions) {
+    const promise = new Promise((resolve, reject) => {
+        fetchAndProcessMeshData(meshId, options, loaderOptions)
+            .then(resolve)
+            .catch(reject);
+    });
+    return {
+        promise: promise,
+        cancelFn: undefined,
+        decache: () => { },
+    };
+}
+async function fetchAndProcessMeshData(meshId, options, loaderOptions) {
+    const parts = meshId.split(':');
+    const url = parts.slice(1).join(':');
+    const meshBuffer = await fetchArrayBuffer({ url, loaderOptions });
+    if (!options || !('geometryData' in options)) {
+        throw new Error('Mesh must have a geometryData');
+    }
+    return createMesh(url, {
+        ...options.geometryData,
+        arrayBuffer: meshBuffer,
+    });
+}
+export { cornerstoneMeshLoader };

package/dist/esm/loaders/geometryLoader.d.ts

@@ -1,9 +1,12 @@
 import '@kitware/vtk.js/Rendering/Profiles/Geometry';
 import { GeometryType } from '../enums';
-import type { IGeometry, PublicContourSetData, PublicSurfaceData, GeometryLoaderFn } from '../types';
-interface GeometryOptions {
+import type { IGeometry, PublicContourSetData, PublicSurfaceData, PublicMeshData, GeometryLoaderFn } from '../types';
+import type { GeometryLoaderOptions } from '../types/GeometryLoaderFn';
+export declare function setOptions(newOptions: GeometryLoaderOptions): void;
+export declare function getOptions(): GeometryLoaderOptions;
+export interface GeometryOptions {
     type: GeometryType;
-    geometryData: PublicContourSetData | PublicSurfaceData;
+    geometryData: PublicContourSetData | PublicSurfaceData | PublicMeshData;
     sizeInBytes?: number;
     segmentIndex?: number;
 }
@@ -12,4 +15,3 @@ export declare function loadAndCacheGeometry(geometryId: string, options?: Geome
 export declare function createAndCacheGeometry(geometryId: string, options: GeometryOptions): IGeometry;
 export declare function registerGeometryLoader(scheme: string, geometryLoader: GeometryLoaderFn): void;
 export declare function registerUnknownGeometryLoader(geometryLoader: GeometryLoaderFn): GeometryLoaderFn | undefined;
-export {};

package/dist/esm/loaders/geometryLoader.js

@@ -3,9 +3,21 @@ import cache from '../cache/cache';
 import { GeometryType } from '../enums';
 import { createContourSet } from './utils/contourSet/createContourSet';
 import { createSurface } from './utils/surface/createSurface';
+import { createMesh } from './utils/mesh/createMesh';
 import Events from '../enums/Events';
 import eventTarget from '../eventTarget';
 import triggerEvent from '../utilities/triggerEvent';
+import { cornerstoneMeshLoader } from './cornerstoneMeshLoader';
+let loaderOptions = {
+    beforeSend(xhr) {
+    },
+};
+export function setOptions(newOptions) {
+    loaderOptions = Object.assign(loaderOptions, newOptions);
+}
+export function getOptions() {
+    return loaderOptions;
+}
 const geometryLoaders = {};
 let unknownGeometryLoader;
 function loadGeometryFromGeometryLoader(geometryId, options) {
@@ -19,7 +31,7 @@ function loadGeometryFromGeometryLoader(geometryId, options) {
         }
         loader = unknownGeometryLoader;
     }
-    const geometryLoadObject = loader(geometryId, options);
+    const geometryLoadObject = loader(geometryId, options, loaderOptions);
     geometryLoadObject.promise.then(function (geometry) {
         triggerEvent(eventTarget, Events.GEOMETRY_LOADED, { geometry });
     }, function (error) {
@@ -68,8 +80,13 @@ export function createAndCacheGeometry(geometryId, options) {
     else if (options.type === GeometryType.SURFACE) {
         geometry = createSurface(geometryId, options.geometryData);
     }
+    else if (options.type === GeometryType.MESH) {
+        createMesh(geometryId, options.geometryData).then((mesh) => {
+            geometry = mesh;
+        });
+    }
     else {
-        throw new Error('Unknown geometry type');
+        throw new Error(`Unknown geometry type: ${options.type}`);
     }
     cache.putGeometrySync(geometryId, geometry);
     return geometry;
@@ -82,3 +99,4 @@ export function registerUnknownGeometryLoader(geometryLoader) {
     unknownGeometryLoader = geometryLoader;
     return oldGeometryLoader;
 }
+registerGeometryLoader('mesh', cornerstoneMeshLoader);

package/dist/esm/loaders/index.d.ts

@@ -1,6 +1,7 @@
 import { cornerstoneStreamingImageVolumeLoader } from './cornerstoneStreamingImageVolumeLoader';
 import { cornerstoneStreamingDynamicImageVolumeLoader } from './cornerstoneStreamingDynamicImageVolumeLoader';
+import { cornerstoneMeshLoader } from './cornerstoneMeshLoader';
 import * as geometryLoader from './geometryLoader';
 import * as imageLoader from './imageLoader';
 import * as volumeLoader from './volumeLoader';
-export { cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, geometryLoader, imageLoader, volumeLoader, };
+export { cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, cornerstoneMeshLoader, geometryLoader, imageLoader, volumeLoader, };

package/dist/esm/loaders/index.js

@@ -1,6 +1,7 @@
 import { cornerstoneStreamingImageVolumeLoader } from './cornerstoneStreamingImageVolumeLoader';
 import { cornerstoneStreamingDynamicImageVolumeLoader } from './cornerstoneStreamingDynamicImageVolumeLoader';
+import { cornerstoneMeshLoader } from './cornerstoneMeshLoader';
 import * as geometryLoader from './geometryLoader';
 import * as imageLoader from './imageLoader';
 import * as volumeLoader from './volumeLoader';
-export { cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, geometryLoader, imageLoader, volumeLoader, };
+export { cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, cornerstoneMeshLoader, geometryLoader, imageLoader, volumeLoader, };

package/dist/esm/loaders/utils/mesh/createMesh.d.ts

@@ -0,0 +1,2 @@
+import type { IGeometry, PublicMeshData } from '../../../types';
+export declare function createMesh(geometryId: string, meshData: PublicMeshData): Promise<IGeometry>;

package/dist/esm/loaders/utils/mesh/createMesh.js

@@ -0,0 +1,69 @@
+import { GeometryType, MeshType } from '../../../enums';
+import { Mesh } from '../../../cache/classes/Mesh';
+import { validateMesh } from './validateMesh';
+import vtkMTLReader from '@kitware/vtk.js/IO/Misc/MTLReader';
+import vtkTexture from '@kitware/vtk.js/Rendering/Core/Texture';
+export function createMesh(geometryId, meshData) {
+    validateMesh(meshData);
+    const mesh = new Mesh({
+        ...meshData,
+    });
+    const geometry = {
+        id: geometryId,
+        type: GeometryType.MESH,
+        data: mesh,
+        sizeInBytes: mesh.sizeInBytes,
+    };
+    switch (meshData.format) {
+        case MeshType.PLY:
+            if (meshData.materialUrl) {
+                const img = new Image();
+                return new Promise((resolve, reject) => {
+                    img.onload = () => {
+                        try {
+                            const texture = vtkTexture.newInstance();
+                            texture.setInterpolate(true);
+                            texture.setImage(img);
+                            mesh.defaultActor.addTexture(texture);
+                            resolve(geometry);
+                        }
+                        catch (error) {
+                            reject(error);
+                        }
+                    };
+                    img.onerror = (error) => reject(error);
+                    img.src = meshData.materialUrl;
+                });
+            }
+            return Promise.resolve(geometry);
+        case MeshType.OBJ:
+            if (meshData.materialUrl) {
+                const reader = vtkMTLReader.newInstance();
+                return reader
+                    .setUrl(meshData.materialUrl)
+                    .then(() => {
+                    for (let i = 0; i < mesh.actors.length; i++) {
+                        const actor = mesh.actors[i];
+                        const mapper = actor.getMapper();
+                        if (mapper) {
+                            const inputData = mapper.getInputData();
+                            if (inputData) {
+                                const name = inputData.get('name').name;
+                                reader.applyMaterialToActor(name, actor);
+                            }
+                        }
+                    }
+                    return geometry;
+                })
+                    .catch((error) => {
+                    throw new Error(`Failed to load material: ${error}`);
+                });
+            }
+            return Promise.resolve(geometry);
+        case MeshType.STL:
+        case MeshType.VTP:
+            return Promise.resolve(geometry);
+        default:
+            return Promise.reject(new Error(`Unsupported format: ${meshData.format}`));
+    }
+}

package/dist/esm/loaders/utils/mesh/validateMesh.d.ts

@@ -0,0 +1,2 @@
+import type { PublicMeshData } from '../../../types';
+export declare function validateMesh(meshData: PublicMeshData): void;

package/dist/esm/loaders/utils/mesh/validateMesh.js

@@ -0,0 +1,12 @@
+import { MeshType } from '../../../enums';
+export function validateMesh(meshData) {
+    if (!meshData.id) {
+        throw new Error('Mesh must have an id');
+    }
+    if (!meshData.arrayBuffer) {
+        throw new Error('Mesh must have an arrayBuffer');
+    }
+    if (!(meshData.format in MeshType)) {
+        throw new Error(`Mesh format must be one of the following: ${Object.values(MeshType).join(', ')}`);
+    }
+}

package/dist/esm/types/GeometryLoaderFn.d.ts

@@ -1,7 +1,10 @@
 import type IGeometry from './IGeometry';
-type GeometryLoaderFn = (geometryId: string, options?: Record<string, unknown>) => {
+type GeometryLoaderFn = (geometryId: string, options?: Record<string, unknown>, loaderOptions?: GeometryLoaderOptions) => {
     promise: Promise<IGeometry>;
     cancelFn?: () => void | undefined;
     decache?: () => void | undefined;
 };
+export interface GeometryLoaderOptions {
+    beforeSend?: (xhr: XMLHttpRequest, defaultHeaders: Record<string, string>) => Record<string, string> | void;
+}
 export type { GeometryLoaderFn as default };

package/dist/esm/types/IGeometry.d.ts

@@ -1,10 +1,11 @@
 import type { GeometryType } from '../enums';
 import type { IContourSet } from './IContourSet';
+import type { IMesh } from './IMesh';
 import type { ISurface } from './ISurface';
 interface IGeometry {
     id: string;
     type: GeometryType;
-    data: IContourSet | ISurface;
+    data: IContourSet | ISurface | IMesh;
     sizeInBytes: number;
 }
 export type { IGeometry as default };

package/dist/esm/types/IMesh.d.ts

@@ -0,0 +1,2 @@
+import type { Mesh } from '../cache/classes/Mesh';
+export type IMesh = Mesh;

package/dist/esm/types/MeshData.d.ts

@@ -0,0 +1,11 @@
+import type { MeshType } from '../enums';
+import type Point3 from './Point3';
+type PublicMeshData = MeshData;
+interface MeshData {
+    id: string;
+    format: MeshType;
+    arrayBuffer?: ArrayBuffer;
+    color?: Point3;
+    materialUrl?: string;
+}
+export type { PublicMeshData, MeshData };

package/dist/esm/types/index.d.ts

@@ -64,9 +64,11 @@ import type ImageSliceData from './ImageSliceData';
 import type IGeometry from './IGeometry';
 import type { PublicContourSetData, ContourSetData, ContourData } from './ContourData';
 import type { PublicSurfaceData, SurfaceData } from './SurfaceData';
+import type { PublicMeshData, MeshData } from './MeshData';
 import type ICachedGeometry from './ICachedGeometry';
 import type { IContourSet } from './IContourSet';
 import type { IContour } from './IContour';
+import type { IMesh } from './IMesh';
 import type RGB from './RGB';
 import type { Memo, HistoryMemo } from '../utilities/historyMemo';
 import type { VoxelManager } from '../utilities/VoxelManager';
@@ -99,4 +101,4 @@ import type { IBaseVolumeViewport } from './IBaseVolumeViewport';
 import type ScrollOptions from './ScrollOptions';
 import type JumpToSliceOptions from './JumpToSliceOptions';
 import type GeometryLoaderFn from './GeometryLoaderFn';
-export type { Cornerstone3DConfig, ICamera, IStackViewport, IVideoViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, WSIViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, IBaseVolumeViewport, GeometryLoaderFn, ScrollOptions, JumpToSliceOptions, Memo, HistoryMemo, VoxelManager, RLEVoxelMap, };
+export type { Cornerstone3DConfig, ICamera, IStackViewport, IVideoViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, WSIViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, PublicMeshData, MeshData, IMesh, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, IBaseVolumeViewport, GeometryLoaderFn, ScrollOptions, JumpToSliceOptions, Memo, HistoryMemo, VoxelManager, RLEVoxelMap, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "3.8.6",
+  "version": "3.9.0",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -91,5 +91,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "02c3b0d68c4a450e2b2abdb4e4c6295d923e91b2"
+  "gitHead": "e44475d4c419201d7042d4648c0335d1b2eebe41"
 }