@cornerstonejs/tools 4.18.4 → 4.19.0

package/dist/esm/utilities/vtkjs/OrientationControllerWidget/index.js

@@ -0,0 +1,486 @@
+import vtkCellPicker from '@kitware/vtk.js/Rendering/Core/CellPicker';
+import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
+import { Enums } from '@cornerstonejs/core';
+import vtkAnnotatedRhombicuboctahedronActor from '../AnnotatedRhombicuboctahedronActor';
+export class vtkOrientationControllerWidget {
+    constructor() {
+        this.actors = new Map();
+        this.pickers = new Map();
+        this.highlightedFace = null;
+        this.mouseHandlers = new Map();
+    }
+    createActors(config) {
+        const rgbToHex = (rgb) => {
+            return `#${rgb
+                .map((x) => {
+                const hex = Math.round(x).toString(16);
+                return hex.length === 1 ? '0' + hex : hex;
+            })
+                .join('')}`;
+        };
+        const rgbToHexColor = (rgb) => {
+            return `rgb(${rgb[0]}, ${rgb[1]}, ${rgb[2]})`;
+        };
+        const actorFactory = vtkAnnotatedRhombicuboctahedronActor.newInstance();
+        const defaultStyle = {
+            fontStyle: 'bold',
+            fontFamily: 'Arial',
+            fontColor: 'black',
+            fontSizeScale: (res) => res / 2,
+            faceColor: rgbToHex(config.faceColors.topBottom),
+            edgeThickness: 0.1,
+            edgeColor: 'black',
+            resolution: 400,
+        };
+        actorFactory.setDefaultStyle(defaultStyle);
+        actorFactory.setXPlusFaceProperty({
+            text: 'L',
+            faceColor: rgbToHex(config.faceColors.leftRight),
+            fontColor: rgbToHexColor(config.letterColors.xPlus),
+            faceRotation: 0,
+        });
+        actorFactory.setXMinusFaceProperty({
+            text: 'R',
+            faceColor: rgbToHex(config.faceColors.leftRight),
+            fontColor: rgbToHexColor(config.letterColors.xMinus),
+            faceRotation: 0,
+        });
+        actorFactory.setYPlusFaceProperty({
+            text: 'P',
+            faceColor: rgbToHex(config.faceColors.frontBack),
+            fontColor: rgbToHexColor(config.letterColors.yPlus),
+            faceRotation: 180,
+        });
+        actorFactory.setYMinusFaceProperty({
+            text: 'A',
+            faceColor: rgbToHex(config.faceColors.frontBack),
+            fontColor: rgbToHexColor(config.letterColors.yMinus),
+            faceRotation: 0,
+        });
+        actorFactory.setZPlusFaceProperty({
+            text: 'S',
+            faceColor: rgbToHex(config.faceColors.topBottom),
+            fontColor: rgbToHexColor(config.letterColors.zPlus),
+        });
+        actorFactory.setZMinusFaceProperty({
+            text: 'I',
+            faceColor: rgbToHex(config.faceColors.topBottom),
+            fontColor: rgbToHexColor(config.letterColors.zMinus),
+        });
+        actorFactory.setShowMainFaces(true);
+        actorFactory.setShowEdgeFaces(config.showEdgeFaces);
+        actorFactory.setShowCornerFaces(config.showCornerFaces);
+        const actors = actorFactory.getActors();
+        actors.forEach((actor) => {
+            const property = actor.getProperty();
+            property.setOpacity(config.opacity);
+            actor.setVisibility(true);
+        });
+        return actors;
+    }
+    addActorsToViewport(viewportId, viewport, actors) {
+        const existingActors = this.actors.get(viewportId);
+        if (existingActors) {
+            this.removeActorsFromViewport(viewportId, viewport);
+        }
+        actors.forEach((actor, index) => {
+            const uid = `orientation-controller-${viewportId}-${index}`;
+            viewport.addActor({ actor, uid });
+        });
+        this.actors.set(viewportId, actors);
+    }
+    removeActorsFromViewport(viewportId, viewport) {
+        const actors = this.actors.get(viewportId);
+        if (actors) {
+            const uids = actors.map((_, index) => `orientation-controller-${viewportId}-${index}`);
+            viewport.removeActors(uids);
+            this.actors.delete(viewportId);
+        }
+    }
+    setupPicker(viewportId, actors) {
+        const picker = vtkCellPicker.newInstance({ opacityThreshold: 0.0001 });
+        picker.setPickFromList(true);
+        picker.setTolerance(0.001);
+        picker.initializePickList();
+        actors.forEach((actor) => {
+            picker.addPickList(actor);
+        });
+        this.pickers.set(viewportId, picker);
+        return picker;
+    }
+    pickAtPosition(evt, viewportId, viewport, element, actors) {
+        const picker = this.pickers.get(viewportId);
+        if (!picker) {
+            return null;
+        }
+        const mainRenderer = viewport
+            .getRenderingEngine()
+            ?.getRenderer(viewportId) ?? viewport.getRenderer();
+        const renderer = mainRenderer;
+        if (!renderer) {
+            return null;
+        }
+        const rect = element.getBoundingClientRect();
+        const x = evt.clientX - rect.left;
+        const y = evt.clientY - rect.top;
+        const devicePixelRatio = window.devicePixelRatio || 1;
+        const canvasPosWithDPR = [x * devicePixelRatio, y * devicePixelRatio];
+        const canvas = viewport.canvas;
+        const { width, height } = canvas;
+        const [xMin, yMin, xMax, yMax] = renderer.getViewport();
+        const viewportWidth = xMax - xMin;
+        const viewportHeight = yMax - yMin;
+        const scaledX = (canvasPosWithDPR[0] / width) * viewportWidth * width;
+        const scaledY = (canvasPosWithDPR[1] / height) * viewportHeight * height;
+        const displayCoord = [scaledX, viewportHeight * height - scaledY];
+        const displayCoords = [
+            displayCoord[0],
+            displayCoord[1],
+            0,
+        ];
+        picker.pick(displayCoords, renderer);
+        const pickedActors = picker.getActors();
+        if (pickedActors.length === 0) {
+            return null;
+        }
+        const pickedActor = pickedActors[0];
+        const cellId = picker.getCellId();
+        if (actors.includes(pickedActor) && cellId !== -1) {
+            const actorIndex = actors.indexOf(pickedActor);
+            return { pickedActor, cellId, actorIndex };
+        }
+        return null;
+    }
+    calculateMarkerPosition(viewport, position) {
+        const canvas = viewport.canvas;
+        if (!canvas) {
+            return null;
+        }
+        const devicePixelRatio = window.devicePixelRatio || 1;
+        const canvasWidth = canvas.clientWidth || canvas.width / devicePixelRatio;
+        const canvasHeight = canvas.clientHeight || canvas.height / devicePixelRatio;
+        const cornerOffset = viewport.type === Enums.ViewportType.VOLUME_3D ? 55 : 35;
+        let canvasX;
+        let canvasY;
+        switch (position) {
+            case 'top-left':
+                canvasX = cornerOffset;
+                canvasY = cornerOffset;
+                break;
+            case 'top-right':
+                canvasX = canvasWidth - cornerOffset;
+                canvasY = cornerOffset;
+                break;
+            case 'bottom-left':
+                canvasX = cornerOffset;
+                canvasY = canvasHeight - cornerOffset;
+                break;
+            default:
+                canvasX = canvasWidth - cornerOffset;
+                canvasY = canvasHeight - cornerOffset;
+        }
+        const canvasPos = [canvasX, canvasY];
+        const worldPos = viewport.canvasToWorld(canvasPos);
+        return [worldPos[0], worldPos[1], worldPos[2]];
+    }
+    positionActors(viewport, actors, config) {
+        const canvas = viewport.canvas;
+        if (!canvas) {
+            console.warn('OrientationControllerWidget: No canvas available');
+            return false;
+        }
+        const mainRenderer = viewport
+            .getRenderingEngine()
+            ?.getRenderer(viewport.id) ?? viewport.getRenderer();
+        const camera = mainRenderer?.getActiveCamera();
+        if (!camera) {
+            return false;
+        }
+        const parallelScale = camera.getParallelScale();
+        const worldHeight = parallelScale * 2;
+        const devicePixelRatio = window.devicePixelRatio || 1;
+        const canvasHeight = canvas.clientHeight || canvas.height / devicePixelRatio;
+        const canvasWidth = canvas.clientWidth || canvas.width / devicePixelRatio;
+        const worldUnitsPerPixel = worldHeight / canvasHeight;
+        const canvasSize = Math.min(canvasWidth, canvasHeight);
+        const screenSizePixels = canvasSize * config.size;
+        const markerSize = screenSizePixels * worldUnitsPerPixel;
+        actors.forEach((actor) => {
+            actor.setScale(markerSize, markerSize, markerSize);
+            const worldPos = this.calculateMarkerPosition(viewport, config.position);
+            if (!worldPos) {
+                console.warn('OrientationControllerWidget: Could not get world position');
+                return;
+            }
+            actor.setPosition(worldPos[0], worldPos[1], worldPos[2]);
+            actor.setOrientation(0, 0, 0);
+        });
+        return true;
+    }
+    highlightFace(actor, cellId, viewport, isMainFace = false) {
+        if (this.highlightedFace &&
+            this.highlightedFace.actor === actor &&
+            this.highlightedFace.cellId === cellId &&
+            this.highlightedFace.isMainFace === isMainFace) {
+            return;
+        }
+        this.clearHighlight();
+        if (isMainFace) {
+            return;
+        }
+        const mapper = actor.getMapper();
+        const inputData = mapper.getInputData();
+        if (!inputData) {
+            return;
+        }
+        const cellData = inputData.getCellData();
+        const colors = cellData.getScalars();
+        if (!colors) {
+            return;
+        }
+        const colorArray = colors.getData();
+        const offset = cellId * 4;
+        const originalColor = [
+            colorArray[offset],
+            colorArray[offset + 1],
+            colorArray[offset + 2],
+            colorArray[offset + 3],
+        ];
+        this.highlightedFace = {
+            actor,
+            cellId,
+            originalColor,
+            viewport,
+            isMainFace: false,
+        };
+        colorArray[offset] = 255;
+        colorArray[offset + 1] = 255;
+        colorArray[offset + 2] = 255;
+        colorArray[offset + 3] = 255;
+        colors.modified();
+        inputData.modified();
+        viewport.render();
+    }
+    clearHighlight() {
+        if (!this.highlightedFace) {
+            return;
+        }
+        const { actor, cellId, originalColor, viewport, isMainFace } = this.highlightedFace;
+        if (isMainFace && this.highlightedFace.originalScale) {
+            const scale = this.highlightedFace.originalScale;
+            actor.setScale(scale[0], scale[1], scale[2]);
+            viewport.render();
+            this.highlightedFace = null;
+            return;
+        }
+        const mapper = actor.getMapper();
+        const inputData = mapper.getInputData();
+        if (!inputData) {
+            this.highlightedFace = null;
+            return;
+        }
+        const cellData = inputData.getCellData();
+        const colors = cellData.getScalars();
+        if (!colors) {
+            this.highlightedFace = null;
+            return;
+        }
+        const colorArray = colors.getData();
+        const offset = cellId * 4;
+        colorArray[offset] = originalColor[0];
+        colorArray[offset + 1] = originalColor[1];
+        colorArray[offset + 2] = originalColor[2];
+        colorArray[offset + 3] = originalColor[3];
+        colors.modified();
+        inputData.modified();
+        viewport.render();
+        this.highlightedFace = null;
+    }
+    setupMouseHandlers(viewportId, element, viewport, actors, callbacks) {
+        let isMouseDown = false;
+        const hoverHandler = (evt) => {
+            if (isMouseDown) {
+                return;
+            }
+            const pickResult = this.pickAtPosition(evt, viewportId, viewport, element, actors);
+            if (pickResult) {
+                const { pickedActor, cellId, actorIndex } = pickResult;
+                if (actorIndex !== 0) {
+                    this.highlightFace(pickedActor, cellId, viewport, false);
+                }
+                if (callbacks.onFaceHover) {
+                    callbacks.onFaceHover(pickResult);
+                }
+            }
+            else {
+                this.clearHighlight();
+                if (callbacks.onFaceHover) {
+                    callbacks.onFaceHover(null);
+                }
+            }
+        };
+        const clickHandler = (evt) => {
+            if (evt.button !== 0) {
+                return;
+            }
+            const pickResult = this.pickAtPosition(evt, viewportId, viewport, element, actors);
+            if (!pickResult) {
+                return;
+            }
+            isMouseDown = true;
+            let globalCellId = pickResult.cellId;
+            if (pickResult.actorIndex === 1) {
+                globalCellId = pickResult.cellId + 6;
+            }
+            else if (pickResult.actorIndex === 2) {
+                globalCellId = pickResult.cellId + 18;
+            }
+            callbacks.onFacePicked({
+                ...pickResult,
+                cellId: globalCellId,
+            });
+            evt.preventDefault();
+            evt.stopPropagation();
+        };
+        const mouseUpHandler = () => {
+            isMouseDown = false;
+            this.clearHighlight();
+        };
+        const dblclickHandler = (evt) => {
+            const pickResult = this.pickAtPosition(evt, viewportId, viewport, element, actors);
+            if (pickResult) {
+                evt.preventDefault();
+                evt.stopImmediatePropagation();
+            }
+        };
+        element.addEventListener('mousemove', hoverHandler);
+        element.addEventListener('mousedown', clickHandler);
+        element.addEventListener('mouseup', mouseUpHandler);
+        element.addEventListener('mouseleave', mouseUpHandler);
+        element.addEventListener('dblclick', dblclickHandler, true);
+        const cleanup = () => {
+            element.removeEventListener('mousemove', hoverHandler);
+            element.removeEventListener('mousedown', clickHandler);
+            element.removeEventListener('mouseup', mouseUpHandler);
+            element.removeEventListener('mouseleave', mouseUpHandler);
+            element.removeEventListener('dblclick', dblclickHandler, true);
+        };
+        this.mouseHandlers.set(viewportId, { cleanup });
+        return { cleanup };
+    }
+    getActors(viewportId) {
+        return this.actors.get(viewportId);
+    }
+    syncOverlayViewport(_viewportId, _viewport) {
+    }
+    getOrientationForFace(cellId) {
+        const orientations = new Map();
+        orientations.set(0, { viewPlaneNormal: [0, 0, -1], viewUp: [0, -1, 0] });
+        orientations.set(1, { viewPlaneNormal: [0, 0, 1], viewUp: [0, 1, 0] });
+        orientations.set(2, { viewPlaneNormal: [0, -1, 0], viewUp: [0, 0, 1] });
+        orientations.set(3, { viewPlaneNormal: [0, 1, 0], viewUp: [0, 0, 1] });
+        orientations.set(4, { viewPlaneNormal: [-1, 0, 0], viewUp: [0, 0, 1] });
+        orientations.set(5, { viewPlaneNormal: [1, 0, 0], viewUp: [0, 0, 1] });
+        const sqrt2 = 1 / Math.sqrt(2);
+        orientations.set(6, {
+            viewPlaneNormal: [0, -sqrt2, -sqrt2],
+            viewUp: [0, -sqrt2, sqrt2],
+        });
+        orientations.set(7, {
+            viewPlaneNormal: [sqrt2, 0, -sqrt2],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(8, {
+            viewPlaneNormal: [0, sqrt2, -sqrt2],
+            viewUp: [0, -sqrt2, -sqrt2],
+        });
+        orientations.set(9, {
+            viewPlaneNormal: [-sqrt2, 0, -sqrt2],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(10, {
+            viewPlaneNormal: [0, -sqrt2, sqrt2],
+            viewUp: [0, sqrt2, sqrt2],
+        });
+        orientations.set(11, {
+            viewPlaneNormal: [sqrt2, 0, sqrt2],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(12, {
+            viewPlaneNormal: [0, sqrt2, sqrt2],
+            viewUp: [0, sqrt2, -sqrt2],
+        });
+        orientations.set(13, {
+            viewPlaneNormal: [-sqrt2, 0, sqrt2],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(14, {
+            viewPlaneNormal: [-sqrt2, -sqrt2, 0],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(15, {
+            viewPlaneNormal: [sqrt2, -sqrt2, 0],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(16, {
+            viewPlaneNormal: [sqrt2, sqrt2, 0],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(17, {
+            viewPlaneNormal: [-sqrt2, sqrt2, 0],
+            viewUp: [0, 0, 1],
+        });
+        const sqrt3 = 1 / Math.sqrt(3);
+        orientations.set(18, {
+            viewPlaneNormal: [-sqrt3, -sqrt3, -sqrt3],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(19, {
+            viewPlaneNormal: [sqrt3, -sqrt3, -sqrt3],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(20, {
+            viewPlaneNormal: [sqrt3, sqrt3, -sqrt3],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(21, {
+            viewPlaneNormal: [-sqrt3, sqrt3, -sqrt3],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(22, {
+            viewPlaneNormal: [-sqrt3, -sqrt3, sqrt3],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(23, {
+            viewPlaneNormal: [sqrt3, -sqrt3, sqrt3],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(24, {
+            viewPlaneNormal: [sqrt3, sqrt3, sqrt3],
+            viewUp: [0, 0, 1],
+        });
+        orientations.set(25, {
+            viewPlaneNormal: [-sqrt3, sqrt3, sqrt3],
+            viewUp: [0, 0, 1],
+        });
+        return orientations.get(cellId) || null;
+    }
+    cleanup(viewportId) {
+        if (viewportId) {
+            const handler = this.mouseHandlers.get(viewportId);
+            if (handler) {
+                handler.cleanup();
+                this.mouseHandlers.delete(viewportId);
+            }
+            this.actors.delete(viewportId);
+            this.pickers.delete(viewportId);
+        }
+        else {
+            this.mouseHandlers.forEach((handler) => handler.cleanup());
+            this.mouseHandlers.clear();
+            this.actors.clear();
+            this.pickers.clear();
+        }
+        this.clearHighlight();
+    }
+}

package/dist/esm/utilities/vtkjs/RhombicuboctahedronSource/index.d.ts

@@ -0,0 +1,7 @@
+export function extend(publicAPI: any, model: any, initialValues?: {}): void;
+export const newInstance: any;
+declare namespace _default {
+    export { newInstance };
+    export { extend };
+}
+export default _default;

package/dist/esm/utilities/vtkjs/RhombicuboctahedronSource/index.js

@@ -0,0 +1,144 @@
+import macro from '@kitware/vtk.js/macros';
+import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray';
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+const MAIN_FACES = [
+    4, 0, 1, 2, 3, 4, 4, 5, 6, 7, 4, 8, 9, 10, 11, 4, 12, 13, 14, 15, 4, 16, 17,
+    18, 19, 4, 20, 21, 22, 23,
+];
+const CORNER_FACES = [
+    3, 0, 16, 8, 3, 1, 9, 20, 3, 2, 23, 13, 3, 3, 12, 19, 3, 4, 17, 11, 3, 5, 10,
+    21, 3, 6, 14, 22, 3, 7, 18, 15,
+];
+const EDGE_FACES = [
+    4, 0, 1, 9, 8, 4, 1, 2, 23, 20, 4, 2, 3, 12, 13, 4, 3, 0, 16, 19, 4, 4, 5, 10,
+    11, 4, 5, 6, 22, 21, 4, 6, 7, 15, 14, 4, 7, 4, 17, 18, 4, 8, 11, 17, 16, 4, 9,
+    20, 21, 10, 4, 13, 23, 22, 14, 4, 12, 19, 18, 15,
+];
+function vtkRhombicuboctahedronSource(publicAPI, model) {
+    model.classHierarchy.push('vtkRhombicuboctahedronSource');
+    publicAPI.requestData = (inData, outData) => {
+        const polyData = outData[0]?.initialize() || vtkPolyData.newInstance();
+        outData[0] = polyData;
+        let scale = 1.0;
+        if (model.scale !== undefined && model.scale !== null) {
+            if (Array.isArray(model.scale)) {
+                scale = model.scale[0] || 1.0;
+            }
+            else if (typeof model.scale === 'number') {
+                scale = model.scale;
+            }
+        }
+        const phi = 1.4;
+        const faceSize = 0.88;
+        const vertices = [];
+        vertices.push(-faceSize, -faceSize, -phi);
+        vertices.push(faceSize, -faceSize, -phi);
+        vertices.push(faceSize, faceSize, -phi);
+        vertices.push(-faceSize, faceSize, -phi);
+        vertices.push(-faceSize, -faceSize, phi);
+        vertices.push(faceSize, -faceSize, phi);
+        vertices.push(faceSize, faceSize, phi);
+        vertices.push(-faceSize, faceSize, phi);
+        vertices.push(-faceSize, -phi, -faceSize);
+        vertices.push(faceSize, -phi, -faceSize);
+        vertices.push(faceSize, -phi, faceSize);
+        vertices.push(-faceSize, -phi, faceSize);
+        vertices.push(-faceSize, phi, -faceSize);
+        vertices.push(faceSize, phi, -faceSize);
+        vertices.push(faceSize, phi, faceSize);
+        vertices.push(-faceSize, phi, faceSize);
+        vertices.push(-phi, -faceSize, -faceSize);
+        vertices.push(-phi, -faceSize, faceSize);
+        vertices.push(-phi, faceSize, faceSize);
+        vertices.push(-phi, faceSize, -faceSize);
+        vertices.push(phi, -faceSize, -faceSize);
+        vertices.push(phi, -faceSize, faceSize);
+        vertices.push(phi, faceSize, faceSize);
+        vertices.push(phi, faceSize, -faceSize);
+        let textureCoords = null;
+        if (model.generate3DTextureCoordinates) {
+            textureCoords = new Float64Array(24 * 3);
+            for (let i = 0; i < 24; i++) {
+                const vx = vertices[i * 3];
+                const vy = vertices[i * 3 + 1];
+                const vz = vertices[i * 3 + 2];
+                const len = Math.sqrt(vx * vx + vy * vy + vz * vz) || 1;
+                textureCoords[i * 3] = vx / len;
+                textureCoords[i * 3 + 1] = vy / len;
+                textureCoords[i * 3 + 2] = vz / len;
+            }
+        }
+        for (let i = 0; i < vertices.length; i++) {
+            vertices[i] *= scale;
+        }
+        const vertexArray = Float64Array.from(vertices);
+        polyData.getPoints().setData(vertexArray, 3);
+        const normals = new Float64Array(24 * 3);
+        for (let i = 0; i < 24; i++) {
+            const x = vertexArray[i * 3];
+            const y = vertexArray[i * 3 + 1];
+            const z = vertexArray[i * 3 + 2];
+            const len = Math.sqrt(x * x + y * y + z * z);
+            normals[i * 3] = x / len;
+            normals[i * 3 + 1] = y / len;
+            normals[i * 3 + 2] = z / len;
+        }
+        const normalArray = vtkDataArray.newInstance({
+            name: 'Normals',
+            values: normals,
+            numberOfComponents: 3,
+        });
+        polyData.getPointData().setNormals(normalArray);
+        if (textureCoords) {
+            const tcoords = vtkDataArray.newInstance({
+                name: 'TextureCoordinates',
+                values: textureCoords,
+                numberOfComponents: 3,
+            });
+            polyData.getPointData().setTCoords(tcoords);
+        }
+        const allFaces = [];
+        if (model.generateMainFaces) {
+            allFaces.push(...MAIN_FACES);
+        }
+        if (model.generateEdgeFaces) {
+            allFaces.push(...EDGE_FACES);
+        }
+        if (model.generateCornerFaces) {
+            allFaces.push(...CORNER_FACES);
+        }
+        if (allFaces.length > 0) {
+            const polys = vtkCellArray.newInstance({
+                values: Uint16Array.from(allFaces),
+            });
+            polyData.getPolys().deepCopy(polys);
+        }
+        else {
+            polyData.getPolys().initialize();
+        }
+        polyData.modified();
+    };
+}
+const DEFAULT_VALUES = {
+    scale: 1.0,
+    generate3DTextureCoordinates: false,
+    generateMainFaces: true,
+    generateEdgeFaces: true,
+    generateCornerFaces: true,
+};
+export function extend(publicAPI, model, initialValues = {}) {
+    Object.assign(model, DEFAULT_VALUES, initialValues);
+    macro.obj(publicAPI, model);
+    macro.setGet(publicAPI, model, [
+        'scale',
+        'generate3DTextureCoordinates',
+        'generateMainFaces',
+        'generateEdgeFaces',
+        'generateCornerFaces',
+    ]);
+    macro.algo(publicAPI, model, 0, 1);
+    vtkRhombicuboctahedronSource(publicAPI, model);
+}
+export const newInstance = macro.newInstance(extend, 'vtkRhombicuboctahedronSource');
+export default { newInstance, extend };

package/dist/esm/utilities/vtkjs/index.d.ts

@@ -0,0 +1,3 @@
+import vtkRhombicuboctahedronSource from './RhombicuboctahedronSource';
+import vtkAnnotatedRhombicuboctahedronActor from './AnnotatedRhombicuboctahedronActor';
+export { vtkRhombicuboctahedronSource, vtkAnnotatedRhombicuboctahedronActor };

package/dist/esm/utilities/vtkjs/index.js

@@ -0,0 +1,3 @@
+import vtkRhombicuboctahedronSource from './RhombicuboctahedronSource';
+import vtkAnnotatedRhombicuboctahedronActor from './AnnotatedRhombicuboctahedronActor';
+export { vtkRhombicuboctahedronSource, vtkAnnotatedRhombicuboctahedronActor };

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.18.4";
+export declare const version = "4.19.0";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '4.18.4';
+export const version = '4.19.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "4.18.4",
+  "version": "4.19.0",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -108,7 +108,7 @@
     "canvas": "3.2.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "4.18.4",
+    "@cornerstonejs/core": "4.19.0",
     "@kitware/vtk.js": "34.15.1",
     "@types/d3-array": "3.2.1",
     "@types/d3-interpolate": "3.0.4",
@@ -127,5 +127,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "372895aea2372079dd442ef54ea110fd3c1d1eef"
+  "gitHead": "3faab410b5de23e66a5eddaafe70508dab84da5f"
 }