copper3d 1.15.0

package/dist/types/Utils/nrrd_tool.d.ts

@@ -0,0 +1,187 @@
+import { GUI } from "dat.gui";
+import { nrrdSliceType, nrrdDragImageOptType, nrrdDrawImageOptType, paintImagesType, storedPaintImagesType, storeExportPaintImageType, loadingBarType } from "../types/types";
+import copperMScene from "../Scene/copperMScene";
+import copperScene from "../Scene/copperScene";
+export declare class nrrd_tools {
+    container: HTMLDivElement;
+    paintImagesLabel1: paintImagesType;
+    paintImagesLabel2: paintImagesType;
+    paintImagesLabel3: paintImagesType;
+    storedPaintImages: storedPaintImagesType;
+    paintImages: paintImagesType;
+    private allSlicesArray;
+    private displaySlices;
+    private backUpDisplaySlices;
+    private skipSlicesDic;
+    private axis;
+    private mainAreaContainer;
+    private showDragNumberDiv;
+    private drawingCanvas;
+    private displayCanvas;
+    private downloadCanvas;
+    private emptyCanvas;
+    private downloadImage;
+    private drawingCanvasLayerMaster;
+    private drawingCanvasLayerOne;
+    private drawingCanvasLayerTwo;
+    private drawingCanvasLayerThree;
+    private currentShowingSlice;
+    private displayCtx;
+    private drawingCtx;
+    private emptyCtx;
+    private drawingLayerMasterCtx;
+    private drawingLayerOneCtx;
+    private drawingLayerTwoCtx;
+    private drawingLayerThreeCtx;
+    private originCanvas;
+    private mainPreSlice;
+    private sceneIn;
+    private Is_Shift_Pressed;
+    private Is_Draw;
+    private sensitiveArray;
+    private handleWheelMove;
+    start: () => void;
+    private paintedImage;
+    private previousDrawingImage;
+    private undoArray;
+    private initState;
+    private preTimer;
+    private eraserUrls;
+    private nrrd_states;
+    private cursorPage;
+    private gui_states;
+    constructor(container: HTMLDivElement);
+    /**
+     * A initialise function for nrrd_tools
+     */
+    private init;
+    /**
+     *
+     * entry function
+     *
+     * @param allSlices - all nrrd contrast slices
+     * {
+     *    x:slice,
+     *    y:slice,
+     *    z:slice
+     * }
+     */
+    setAllSlices(allSlices: Array<nrrdSliceType>): void;
+    private loadingMaskByLabel;
+    setMasksData(masksData: storeExportPaintImageType, loadingBar?: loadingBarType): void;
+    setEraserUrls(urls: string[]): void;
+    getCurrentImageDimension(): never[];
+    getVoxelSpacing(): never[];
+    getSpaceOrigin(): never[];
+    private getSharedPlace;
+    /**
+     * init all painted images for store images
+     * @param dimensions
+     */
+    private initPaintImages;
+    private createEmptyPaintImage;
+    /**
+     * Switch all contrast slices' orientation
+     * @param {string} aixs:"x" | "y" | "z"
+     *  */
+    setSliceOrientation(axis: "x" | "y" | "z"): void;
+    addSkip(index: number): void;
+    removeSkip(index: number): void;
+    clear(): void;
+    setSliceMoving(step: number): void;
+    setShowInMainArea(isShowContrast: boolean): void;
+    setMainAreaSize(factor: number): void;
+    getMaxSliceNum(): number[];
+    getCurrentSlicesNumAndContrastNum(): {
+        currentIndex: number;
+        contrastIndex: number;
+    };
+    getCurrentSliceIndex(): number;
+    getIsShowContrastState(): boolean;
+    private setIsDrawFalse;
+    private setDisplaySlicesBaseOnAxis;
+    private loadDisplaySlicesArray;
+    private resetDisplaySlicesStatus;
+    private setupConfigs;
+    private setMainPreSlice;
+    private setOriginCanvasAndPre;
+    private afterLoadSlice;
+    private updateMaxIndex;
+    private updateCurrentContrastSlice;
+    private createShowSliceNumberDiv;
+    private updateOriginAndChangedWH;
+    private initAllCanvas;
+    private autoFocusDiv;
+    private setSyncsliceNum;
+    private repraintCurrentContrastSlice;
+    private repraintAllContrastSlices;
+    private updateShowNumDiv;
+    appendLoadingbar(loadingbar: HTMLDivElement): void;
+    drag(opts?: nrrdDragImageOptType): void;
+    private updateIndex;
+    private drawDragSlice;
+    private drawMaskToLabelCtx;
+    draw(sceneIn: copperMScene | copperScene, gui: GUI, opts?: nrrdDrawImageOptType): void;
+    private paintOnCanvas;
+    private drawLine;
+    private undoLastPainting;
+    private getCurrentUndo;
+    private configMouseWheel;
+    private useEraser;
+    private clearPaint;
+    private getRestLabel;
+    private clearStoreImages;
+    private enableDownload;
+    private paintOnCanvasLayer;
+    private drawLinesOnLayer;
+    private setCurrentLayer;
+    private configGui;
+    private updateSlicesContrast;
+    private resetPaintArea;
+    private resetLayerCanvas;
+    private redrawDisplayCanvas;
+    redrawMianPreOnDisplayCanvas(): void;
+    private resizePaintArea;
+    /**
+     * Used to init the mask on each label and reload
+     * @param paintImages
+     * @param ctx
+     */
+    private reloadMaskToLabel;
+    private flipDisplayImageByAxis;
+    private filterDrawedImage;
+    removeGuiFolderChilden(modeFolder: GUI): void;
+    private verifyCanvasIsEmpty;
+    private clearDictionary;
+    private storeAllImages;
+    private storeImageToAxis;
+    private storeImageToLabel;
+    private storeEachLayerImage;
+    private sliceArrayH;
+    private sliceArrayV;
+    /**
+     *
+     * @param paintImageArray : the target view slice's marked images array
+     * @param length : the target view slice's dimention (total slice index num)
+     * @param ratio : the target slice image's width/height ratio of its dimention length
+     * @param markedArr : current painted image's vertical 2d Array
+     * @param targetWidth : the target image width
+     * @param convertIndex : Mapping current image's index to target slice image's width/height pixel start point
+     */
+    private replaceVerticalColPixels;
+    /**
+     *
+     * @param paintImageArray : the target view slice's marked images array
+     * @param length : the target view slice's dimention (total slice index num)
+     * @param ratio : the target slice image's width/height ratio of its dimention length
+     * @param markedArr : current painted image's horizontal 2d Array
+     * @param targetWidth : the target image width
+     * @param convertIndex : Mapping current image's index to target slice image's width/height pixel start point
+     */
+    private replaceHorizontalRowPixels;
+    private setEmptyCanvasSize;
+    private checkSharedPlaceSlice;
+    private replaceArray;
+    private findSliceInSharedPlace;
+    private exportData;
+}

package/dist/types/Utils/raycaster.d.ts

@@ -0,0 +1,9 @@
+import * as THREE from "three";
+import { mouseMovePositionType } from "../types/types";
+export declare function pickModelDefault(camera: THREE.PerspectiveCamera, container: HTMLDivElement, pickableObjects: THREE.Mesh[], callback: (selectMesh: THREE.Mesh | undefined) => void): void;
+export declare function throttle(callback: (event: MouseEvent) => void, wait: number): (event: MouseEvent) => void;
+export declare function isPickedModel(camera: THREE.PerspectiveCamera, container: HTMLDivElement, pickableObjects: THREE.Mesh[], mouseMovePosition: mouseMovePositionType): {
+    intersectedObject: THREE.Object3D<THREE.Event> | null;
+    intersects: THREE.Intersection<THREE.Object3D<THREE.Event>>[];
+};
+export declare function dragImage(): void;

package/dist/types/Utils/texture2d.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from "three";
+import { copperVolumeType } from "../types/types";
+import { GUI } from "dat.gui";
+export declare function createTexture2D_Zip(url: string, scene: THREE.Scene): void;
+export declare function createTexture2D_NRRD(data: Uint8Array, width: number, height: number, depth: number, callback: (mesh: THREE.Mesh) => void): void;
+export declare function createTexture2D_Array(copperVolume: copperVolumeType, depth: number, scene: THREE.Scene, gui?: GUI): {
+    mesh: THREE.Mesh<THREE.PlaneGeometry, THREE.ShaderMaterial>;
+    copperVolume: copperVolumeType;
+    updateTexture: (copperVolumeUp: copperVolumeType) => void;
+};

package/dist/types/Utils/utils.d.ts

@@ -0,0 +1,8 @@
+export declare function fullScreenListenner(container: HTMLDivElement | HTMLCanvasElement): void;
+export declare function isIOS(): boolean;
+export declare function traverseMaterials(object: THREE.Group, callback: (material: any) => void): void;
+export declare function loading(): {
+    loadingContainer: HTMLDivElement;
+    progress: HTMLDivElement;
+};
+export declare function switchEraserSize(size: number, urls?: string[]): string;

package/dist/types/Utils/workers/reformatSaveDataWorker.d.ts

@@ -0,0 +1,13 @@
+import { paintImageType } from "../../types/types";
+declare function pruningData(originArr: paintImageType[]): Uint8ClampedArray[];
+declare function restructData(originArr: paintImageType[], len: number, width: number, height: number): {
+    sliceIndex: number;
+    dataFormat: string;
+    width: number;
+    height: number;
+    voxelSpacing: number;
+    spaceOrigin: number;
+    data: never[];
+}[];
+declare function convertReformatDataToBlob(maskData: any): false | Blob;
+export { pruningData, restructData, convertReformatDataToBlob };

package/dist/types/index.d.ts

@@ -0,0 +1,21 @@
+import copperRenderer from "./Renderer/copperRenderer";
+import { setHDRFilePath } from "./lib/environment/index";
+import copperScene from "./Scene/copperScene";
+import { CameraViewPoint } from "./Controls/copperControls";
+import { addLabelToScene, positionType, screenPosType, convert3DPostoScreenPos, convertScreenPosto3DPos } from "./Utils/add3DLabel";
+import { addBoxHelper, optsType } from "./Loader/copperNrrdLoader";
+import { fullScreenListenner, loading } from "./Utils/utils";
+import copperRendererOnDemond from "./Renderer/copperRendererOnDemond";
+import copperSceneOnDemond from "./Scene/copperSceneOnDemond";
+import copperMSceneRenderer from "./Renderer/copperMSceneRenderer";
+import copperMScene from "./Scene/copperMScene";
+import { createTexture2D_NRRD } from "./Utils/texture2d";
+import { configKiwriousHeart } from "./Utils/kiwrious/configKiwrious";
+import kiwrious from "./Utils/kiwrious/configKiwrious";
+import { nrrd_tools } from "./Utils/nrrd_tool";
+import { Copper3dTrackballControls } from "./Controls/Copper3dTrackballControls";
+import { nrrdMeshesType, nrrdSliceType, SensorDecodedValue_kiwrious, SensorReadResult_kiwrious, HeartRateResult_kiwrious, loadingBarType, paintImageType, exportPaintImageType, IOptVTKLoader } from "./types/types";
+import "./css/style.css";
+export declare const REVISION = "v1.15.0";
+export { copperRenderer, copperRendererOnDemond, copperMSceneRenderer, setHDRFilePath, addLabelToScene, convert3DPostoScreenPos, convertScreenPosto3DPos, addBoxHelper, fullScreenListenner, configKiwriousHeart, copperScene, copperSceneOnDemond, copperMScene, CameraViewPoint, kiwrious, nrrd_tools, loading, Copper3dTrackballControls, createTexture2D_NRRD, };
+export type { positionType, screenPosType, optsType, nrrdMeshesType, nrrdSliceType, SensorDecodedValue_kiwrious, SensorReadResult_kiwrious, HeartRateResult_kiwrious, loadingBarType, paintImageType, exportPaintImageType, IOptVTKLoader, };

package/dist/types/lib/dicom_pharser_dictionary.d.ts

@@ -0,0 +1 @@
+export declare var TAG_DICT: any;

package/dist/types/lib/environment/index.d.ts

@@ -0,0 +1,8 @@
+export type environmentType = {
+    id: string;
+    name: string;
+    path: string | null;
+    format: string;
+};
+export declare function setHDRFilePath(url: string): void;
+export declare const environments: Array<environmentType>;

package/dist/types/lib/three-vignette.d.ts

@@ -0,0 +1,11 @@
+import { Mesh, RawShaderMaterial } from "three";
+interface optType {
+    [key: string]: any;
+}
+interface customMeshType {
+    mesh: Mesh<any, RawShaderMaterial>;
+    [key: string]: any;
+}
+declare function createBackground(opt?: optType): customMeshType;
+export { createBackground };
+export type { customMeshType };

package/dist/types/types/types.d.ts

@@ -0,0 +1,198 @@
+import copperScene from "../Scene/copperScene";
+import baseScene from "../Scene/baseScene";
+import copperMScene from "../Scene/copperMScene";
+import { GUI } from "dat.gui";
+interface SceneMapType {
+    [key: string]: copperScene | baseScene | copperMScene;
+}
+interface optType {
+    guiOpen: boolean;
+    camera?: boolean;
+    performance?: boolean;
+    light?: boolean;
+    alpha?: boolean;
+    [key: string]: string | boolean | undefined;
+}
+interface stateType {
+    playbackSpeed: number;
+    wireframe: boolean;
+    skeleton: boolean;
+    grid: boolean;
+    addLights: boolean;
+    exposure: number;
+    ambientIntensity: number;
+    ambientColor: number;
+    directIntensity: number;
+    directColor: number;
+    bgColor1: string;
+    bgColor2: string;
+    [key: string]: string | number | boolean | {};
+}
+interface modelVisualisationDataType {
+    name: string;
+    visible: boolean;
+    mesh: THREE.Mesh;
+}
+interface preRenderCallbackFunctionType {
+    index: number;
+    cache: Function[];
+    add: (fn: any) => void;
+    remove: (id: number) => void;
+}
+interface baseStateType {
+    [key: string]: string | number | boolean | {};
+}
+interface nrrdMeshesType {
+    x: THREE.Mesh;
+    y: THREE.Mesh;
+    z: THREE.Mesh;
+}
+interface nrrdSliceType {
+    x: any;
+    y: any;
+    z: any;
+}
+interface loadingBarType {
+    loadingContainer: HTMLDivElement;
+    progress: HTMLDivElement;
+}
+interface nrrdDragImageOptType {
+    showNumber?: boolean;
+    getSliceNum?: (index: number, contrastNum: number) => void;
+}
+interface nrrdDrawImageOptType {
+    getMaskData?: (mask: ImageData, sliceId: number, label: string, width: number, height: number, clearAllFlag?: boolean) => void;
+}
+interface SensorDecodedValue_kiwrious {
+    type: string;
+    label: string;
+    value: any;
+}
+interface SensorReadResult_kiwrious {
+    sensorType: string;
+    decodedValues: SensorDecodedValue_kiwrious[];
+}
+interface HeartRateResult_kiwrious {
+    status: string;
+    value?: number;
+}
+declare class SerialService_kiwrious {
+    onSerialData?: (data: SensorReadResult_kiwrious) => void;
+    onSerialConnection?: (connect: boolean) => void;
+    private _isConnected;
+    private _isReading;
+    private _port;
+    private _reader;
+    constructor();
+    private _log;
+    private _err;
+    get isReading(): boolean;
+    get canResumeReading(): boolean;
+    triggerStopReading(): void;
+    private closeReader;
+    private closePortAsync;
+    resumeReading(): Promise<void>;
+    disconnectAsync(): Promise<void>;
+    connectAndReadAsync(): Promise<void>;
+    private startStage1RequestPortAsync;
+    private startStage2ConnectPortAsync;
+    private stopStage2ClosePortAsync;
+    private connectPortAsync;
+    private startReading;
+}
+interface kiwriousType {
+    serialService: SerialService_kiwrious;
+    setBinUrl: (url: string) => void;
+    setWasm: (url: string) => void;
+}
+interface mouseMovePositionType {
+    x: number;
+    y: number;
+}
+interface positionType {
+    x?: number;
+    y?: number;
+    z?: number;
+}
+interface paintImagesType {
+    x: Array<paintImageType>;
+    y: Array<paintImageType>;
+    z: Array<paintImageType>;
+}
+interface paintImageType {
+    index: number;
+    image: ImageData;
+}
+interface storedPaintImagesType {
+    label1: paintImagesType;
+    label2: paintImagesType;
+    label3: paintImagesType;
+}
+interface exportPaintImagesType {
+    x: Array<exportPaintImageType>;
+    y: Array<exportPaintImageType>;
+    z: Array<exportPaintImageType>;
+}
+interface exportPaintImageType {
+    sliceIndex: number;
+    dataFormat: string;
+    width: number;
+    height: number;
+    voxelSpacing: number[];
+    spaceOrigin: number[];
+    data: number[];
+}
+interface storeExportPaintImageType {
+    label1: exportPaintImageType[];
+    label2: exportPaintImageType[];
+    label3: exportPaintImageType[];
+}
+interface optionsGltfExporterType {
+    trs?: boolean;
+    onlyVisible?: boolean;
+    truncateDrawRange?: boolean;
+    binary?: boolean;
+    maxTextureSize?: number;
+    animations?: Array<THREE.AnimationClip>;
+}
+interface vtkModels {
+    name: string;
+    urls: Array<string>;
+    opts?: IOptVTKLoader;
+}
+interface undoLayerType {
+    label1: Array<HTMLImageElement>;
+    label2: Array<HTMLImageElement>;
+    label3: Array<HTMLImageElement>;
+}
+interface undoType {
+    sliceIndex: number;
+    layers: undoLayerType;
+}
+interface copperVolumeType {
+    tags: any;
+    width: number;
+    height: number;
+    windowCenter: number;
+    windowWidth: number;
+    invert: boolean;
+    uint16: Uint16Array;
+    uint8: Uint8ClampedArray;
+    order: number;
+}
+interface dicomLoaderOptsType {
+    gui?: GUI;
+    getMesh?: (mesh: THREE.Mesh) => void;
+    getCopperVolume?: (copperVolume: copperVolumeType, updateTexture: Function) => void;
+    setAnimation?: (currentValue: number, depth: number, depthStep: number, copperVolume: copperVolumeType) => number;
+}
+interface skipSlicesDictType {
+    [key: string]: any;
+}
+interface IOptVTKLoader {
+    wireframe?: boolean;
+    color?: string | number;
+    transparent?: boolean;
+    opacity?: number;
+}
+export type { SceneMapType, optType, stateType, modelVisualisationDataType, preRenderCallbackFunctionType, baseStateType, nrrdMeshesType, nrrdSliceType, nrrdDragImageOptType, nrrdDrawImageOptType, loadingBarType, SensorDecodedValue_kiwrious, SensorReadResult_kiwrious, HeartRateResult_kiwrious, SerialService_kiwrious, kiwriousType, mouseMovePositionType, positionType, paintImagesType, paintImageType, storedPaintImagesType, optionsGltfExporterType, vtkModels, undoType, copperVolumeType, dicomLoaderOptsType, skipSlicesDictType, exportPaintImagesType, exportPaintImageType, storeExportPaintImageType, IOptVTKLoader, };

package/dist/types/types.d.ts

@@ -0,0 +1,198 @@
+import copperScene from "../Scene/copperScene";
+import baseScene from "../Scene/baseScene";
+import copperMScene from "../Scene/copperMScene";
+import { GUI } from "dat.gui";
+interface SceneMapType {
+    [key: string]: copperScene | baseScene | copperMScene;
+}
+interface optType {
+    guiOpen: boolean;
+    camera?: boolean;
+    performance?: boolean;
+    light?: boolean;
+    alpha?: boolean;
+    [key: string]: string | boolean | undefined;
+}
+interface stateType {
+    playbackSpeed: number;
+    wireframe: boolean;
+    skeleton: boolean;
+    grid: boolean;
+    addLights: boolean;
+    exposure: number;
+    ambientIntensity: number;
+    ambientColor: number;
+    directIntensity: number;
+    directColor: number;
+    bgColor1: string;
+    bgColor2: string;
+    [key: string]: string | number | boolean | {};
+}
+interface modelVisualisationDataType {
+    name: string;
+    visible: boolean;
+    mesh: THREE.Mesh;
+}
+interface preRenderCallbackFunctionType {
+    index: number;
+    cache: Function[];
+    add: (fn: any) => void;
+    remove: (id: number) => void;
+}
+interface baseStateType {
+    [key: string]: string | number | boolean | {};
+}
+interface nrrdMeshesType {
+    x: THREE.Mesh;
+    y: THREE.Mesh;
+    z: THREE.Mesh;
+}
+interface nrrdSliceType {
+    x: any;
+    y: any;
+    z: any;
+}
+interface loadingBarType {
+    loadingContainer: HTMLDivElement;
+    progress: HTMLDivElement;
+}
+interface nrrdDragImageOptType {
+    showNumber?: boolean;
+    getSliceNum?: (index: number, contrastNum: number) => void;
+}
+interface nrrdDrawImageOptType {
+    getMaskData?: (mask: ImageData, sliceId: number, label: string, width: number, height: number, clearAllFlag?: boolean) => void;
+}
+interface SensorDecodedValue_kiwrious {
+    type: string;
+    label: string;
+    value: any;
+}
+interface SensorReadResult_kiwrious {
+    sensorType: string;
+    decodedValues: SensorDecodedValue_kiwrious[];
+}
+interface HeartRateResult_kiwrious {
+    status: string;
+    value?: number;
+}
+declare class SerialService_kiwrious {
+    onSerialData?: (data: SensorReadResult_kiwrious) => void;
+    onSerialConnection?: (connect: boolean) => void;
+    private _isConnected;
+    private _isReading;
+    private _port;
+    private _reader;
+    constructor();
+    private _log;
+    private _err;
+    get isReading(): boolean;
+    get canResumeReading(): boolean;
+    triggerStopReading(): void;
+    private closeReader;
+    private closePortAsync;
+    resumeReading(): Promise<void>;
+    disconnectAsync(): Promise<void>;
+    connectAndReadAsync(): Promise<void>;
+    private startStage1RequestPortAsync;
+    private startStage2ConnectPortAsync;
+    private stopStage2ClosePortAsync;
+    private connectPortAsync;
+    private startReading;
+}
+interface kiwriousType {
+    serialService: SerialService_kiwrious;
+    setBinUrl: (url: string) => void;
+    setWasm: (url: string) => void;
+}
+interface mouseMovePositionType {
+    x: number;
+    y: number;
+}
+interface positionType {
+    x?: number;
+    y?: number;
+    z?: number;
+}
+interface paintImagesType {
+    x: Array<paintImageType>;
+    y: Array<paintImageType>;
+    z: Array<paintImageType>;
+}
+interface paintImageType {
+    index: number;
+    image: ImageData;
+}
+interface storedPaintImagesType {
+    label1: paintImagesType;
+    label2: paintImagesType;
+    label3: paintImagesType;
+}
+interface exportPaintImagesType {
+    x: Array<exportPaintImageType>;
+    y: Array<exportPaintImageType>;
+    z: Array<exportPaintImageType>;
+}
+interface exportPaintImageType {
+    sliceIndex: number;
+    dataFormat: string;
+    width: number;
+    height: number;
+    voxelSpacing: number[];
+    spaceOrigin: number[];
+    data: number[];
+}
+interface storeExportPaintImageType {
+    label1: exportPaintImageType[];
+    label2: exportPaintImageType[];
+    label3: exportPaintImageType[];
+}
+interface optionsGltfExporterType {
+    trs?: boolean;
+    onlyVisible?: boolean;
+    truncateDrawRange?: boolean;
+    binary?: boolean;
+    maxTextureSize?: number;
+    animations?: Array<THREE.AnimationClip>;
+}
+interface vtkModels {
+    name: string;
+    urls: Array<string>;
+    opts?: IOptVTKLoader;
+}
+interface undoLayerType {
+    label1: Array<HTMLImageElement>;
+    label2: Array<HTMLImageElement>;
+    label3: Array<HTMLImageElement>;
+}
+interface undoType {
+    sliceIndex: number;
+    layers: undoLayerType;
+}
+interface copperVolumeType {
+    tags: any;
+    width: number;
+    height: number;
+    windowCenter: number;
+    windowWidth: number;
+    invert: boolean;
+    uint16: Uint16Array;
+    uint8: Uint8ClampedArray;
+    order: number;
+}
+interface dicomLoaderOptsType {
+    gui?: GUI;
+    getMesh?: (mesh: THREE.Mesh) => void;
+    getCopperVolume?: (copperVolume: copperVolumeType, updateTexture: Function) => void;
+    setAnimation?: (currentValue: number, depth: number, depthStep: number, copperVolume: copperVolumeType) => number;
+}
+interface skipSlicesDictType {
+    [key: string]: any;
+}
+interface IOptVTKLoader {
+    wireframe?: boolean;
+    color?: string | number;
+    transparent?: boolean;
+    opacity?: number;
+}
+export type { SceneMapType, optType, stateType, modelVisualisationDataType, preRenderCallbackFunctionType, baseStateType, nrrdMeshesType, nrrdSliceType, nrrdDragImageOptType, nrrdDrawImageOptType, loadingBarType, SensorDecodedValue_kiwrious, SensorReadResult_kiwrious, HeartRateResult_kiwrious, SerialService_kiwrious, kiwriousType, mouseMovePositionType, positionType, paintImagesType, paintImageType, storedPaintImagesType, optionsGltfExporterType, vtkModels, undoType, copperVolumeType, dicomLoaderOptsType, skipSlicesDictType, exportPaintImagesType, exportPaintImageType, storeExportPaintImageType, IOptVTKLoader, };

package/dist/types/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types/types.ts"],"names":[],"mappings":""}