copper3d 1.15.0

package/dist/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/lib/environment/index.js

@@ -0,0 +1,28 @@
+// let footprint = "./footprint_court_2k.hdr";
+// let sunset = "./venice_sunset_1k.hdr";
+let footprint = "";
+let sunset = "";
+export function setHDRFilePath(url) {
+    environments[1].path = url;
+}
+export const environments = [
+    {
+        id: "",
+        name: "None",
+        path: null,
+        format: ".hdr",
+    },
+    {
+        id: "venice-sunset",
+        name: "Venice Sunset",
+        path: sunset,
+        format: ".hdr",
+    },
+    {
+        id: "footprint-court",
+        name: "Footprint Court (HDR Labs)",
+        path: footprint,
+        format: ".hdr",
+    },
+];
+//# sourceMappingURL=index.js.map

package/dist/lib/environment/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/environment/index.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,yCAAyC;AAEzC,IAAI,SAAS,GAAG,EAAE,CAAC;AACnB,IAAI,MAAM,GAAG,EAAE,CAAC;AAQhB,MAAM,UAAU,cAAc,CAAC,GAAW;IACxC,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,GAAG,CAAC;AAC7B,CAAC;AAED,MAAM,CAAC,MAAM,YAAY,GAA2B;IAClD;QACE,EAAE,EAAE,EAAE;QACN,IAAI,EAAE,MAAM;QACZ,IAAI,EAAE,IAAI;QACV,MAAM,EAAE,MAAM;KACf;IACD;QACE,EAAE,EAAE,eAAe;QACnB,IAAI,EAAE,eAAe;QACrB,IAAI,EAAE,MAAM;QACZ,MAAM,EAAE,MAAM;KACf;IACD;QACE,EAAE,EAAE,iBAAiB;QACrB,IAAI,EAAE,4BAA4B;QAClC,IAAI,EAAE,SAAS;QACf,MAAM,EAAE,MAAM;KACf;CACF,CAAC"}

package/dist/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/lib/three-vignette.js

@@ -0,0 +1,93 @@
+import { Color, DoubleSide, Mesh, PlaneGeometry, RawShaderMaterial, Vector2, } from "three";
+import vert from "./three-vignette.vert";
+import frag from "./three-vignette.frag";
+function createBackground(opt) {
+    opt = opt || {};
+    let geometry = opt.geometry || new PlaneGeometry(2, 2, 1);
+    let material = new RawShaderMaterial({
+        vertexShader: vert,
+        fragmentShader: frag,
+        side: DoubleSide,
+        uniforms: {
+            aspectCorrection: { value: false },
+            aspect: { value: 1 },
+            grainScale: { value: 0.005 },
+            grainTime: { value: 0 },
+            noiseAlpha: { value: 0.25 },
+            offset: { value: new Vector2(0, 0) },
+            scale: { value: new Vector2(1, 1) },
+            smooth: { value: new Vector2(0.0, 1.0) },
+            color1: { value: new Color("#fff") },
+            color2: { value: new Color("#283844") },
+        },
+        depthTest: false,
+    });
+    let mesh = new Mesh(geometry, material);
+    mesh.frustumCulled = false;
+    const customMesh = {
+        mesh: mesh,
+        style: () => { },
+    };
+    // customMesh.style = style;
+    // if (opt) customMesh.style = style(opt);
+    customMesh.style = (opt) => {
+        opt = opt || {};
+        if (Array.isArray(opt.colors)) {
+            let colors = opt.colors.map(function (c) {
+                if (typeof c === "string" || typeof c === "number") {
+                    return new Color(c);
+                }
+                return c;
+            });
+            material.uniforms.color1.value.copy(colors[0]);
+            material.uniforms.color2.value.copy(colors[1]);
+        }
+        if (typeof opt.aspect === "number") {
+            material.uniforms.aspect.value = opt.aspect;
+        }
+        if (typeof opt.grainScale === "number") {
+            material.uniforms.grainScale.value = opt.grainScale;
+        }
+        if (typeof opt.grainTime === "number") {
+            material.uniforms.grainTime.value = opt.grainTime;
+        }
+        if (opt.smooth) {
+            const smooth = fromArray(opt.smooth);
+            material.uniforms.smooth.value.copy(smooth);
+        }
+        if (opt.offset) {
+            const offset = fromArray(opt.offset);
+            material.uniforms.offset.value.copy(offset);
+        }
+        if (typeof opt.noiseAlpha === "number") {
+            material.uniforms.noiseAlpha.value = opt.noiseAlpha;
+        }
+        if (typeof opt.scale !== "undefined") {
+            const scale = opt.scale;
+            let scaleArray = [];
+            if (typeof scale === "number") {
+                scaleArray = [scale, scale];
+            }
+            let scaleVect = fromArray(scaleArray);
+            material.uniforms.scale.value.copy(scaleVect);
+        }
+        if (typeof opt.aspectCorrection !== "undefined") {
+            material.uniforms.aspectCorrection.value = Boolean(opt.aspectCorrection);
+        }
+    };
+    function fromArray(array) {
+        if (Array.isArray(array)) {
+            return new Vector2().fromArray(array);
+        }
+        return array;
+    }
+    if (opt) {
+        customMesh.style(opt);
+    }
+    else {
+        customMesh.style();
+    }
+    return customMesh;
+}
+export { createBackground };
+//# sourceMappingURL=three-vignette.js.map

package/dist/lib/three-vignette.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"three-vignette.js","sourceRoot":"","sources":["../../src/lib/three-vignette.ts"],"names":[],"mappings":"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"}

package/dist/types/Controls/Copper3dTrackballControls.d.ts

@@ -0,0 +1,45 @@
+import { EventDispatcher, MOUSE, Vector3, PerspectiveCamera, OrthographicCamera } from "three";
+declare class Copper3dTrackballControls extends EventDispatcher {
+    object: PerspectiveCamera | OrthographicCamera;
+    domElement: HTMLElement;
+    enabled: boolean;
+    screen: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    rotateSpeed: number;
+    zoomSpeed: number;
+    panSpeed: number;
+    noRotate: boolean;
+    noZoom: boolean;
+    noPan: boolean;
+    staticMoving: boolean;
+    dynamicDampingFactor: number;
+    minDistance: number;
+    maxDistance: number;
+    minZoom: number;
+    maxZoom: number;
+    keys: ["KeyA", "KeyS", "KeyD"];
+    mouseButtons: {
+        LEFT: MOUSE.ROTATE;
+        MIDDLE: MOUSE.DOLLY;
+        RIGHT: MOUSE.PAN;
+    };
+    target: Vector3;
+    target0: Vector3;
+    position0: Vector3;
+    up0: Vector3;
+    zoom0: number;
+    handleResize: () => void;
+    rotateCamera: () => void;
+    zoomCamera: () => void;
+    panCamera: () => void;
+    checkDistances: () => void;
+    update: () => void;
+    reset: () => void;
+    dispose: () => void;
+    constructor(object: PerspectiveCamera | OrthographicCamera, domElement: HTMLElement);
+}
+export { Copper3dTrackballControls };

package/dist/types/Controls/copperControls.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from "three";
+export declare class Controls {
+    private currentCamera;
+    private directionalLight;
+    private viewpoint;
+    constructor(camera: THREE.PerspectiveCamera);
+    setCameraViewPoint(): void;
+    updateCameraViewPoint(viewpoint: CameraViewPoint): void;
+    updateDirectionalLight(directionalLight?: THREE.DirectionalLight): void;
+}
+export declare class CameraViewPoint {
+    nearPlane: number;
+    farPlane: number;
+    eyePosition: Array<number>;
+    targetPosition: Array<number>;
+    upVector: Array<number>;
+}

package/dist/types/Loader/convet.d.ts

@@ -0,0 +1 @@
+export declare function resize3dnrrd(pixels: Float32Array, dimOrigin: Array<number>, dimTarget: Array<number>): Float32Array;

package/dist/types/Loader/copperDicomLoader.d.ts

@@ -0,0 +1,7 @@
+import { copperVolumeType } from "../types/types";
+export declare function copperDicomLoader(url: string, callback?: (copperVolume: copperVolumeType) => void): void;
+export declare function getLut(data: Uint16Array, windowWidth: number, windowCenter: number, invert: boolean, voiLUT: any): {
+    minPixelValue: number;
+    maxPixelValue: number;
+    lutArray: Uint8ClampedArray;
+};

package/dist/types/Loader/copperGltfLoader.d.ts

@@ -0,0 +1,3 @@
+import * as THREE from "three";
+import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader";
+export declare function copperGltfLoader(renderer: THREE.WebGLRenderer): GLTFLoader;

package/dist/types/Loader/copperNrrdLoader.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+import copperScene from "../Scene/copperScene";
+import { GUI } from "dat.gui";
+import { nrrdMeshesType, nrrdSliceType, loadingBarType } from "../types/types";
+import { Copper3dTrackballControls } from "../Controls/Copper3dTrackballControls";
+export interface optsType {
+    openGui: boolean;
+    container?: HTMLDivElement;
+}
+export declare function copperNrrdLoader(url: string, loadingBar: loadingBarType, segmentation: boolean, callback?: (volume: any, nrrdMeshes: nrrdMeshesType, nrrdSlices: nrrdSliceType, gui?: GUI) => void, opts?: optsType): void;
+export declare function copperNrrdTexture3dLoader(url: string, scene: THREE.Scene, container: HTMLDivElement, callback?: (volume: any, gui?: GUI) => void): void;
+export declare function getWholeSlices(nrrdSlices: nrrdSliceType, scene: THREE.Scene, gui: GUI, controls: Copper3dTrackballControls): void;
+export declare function addBoxHelper(scene: copperScene, volume: any, boxCube?: THREE.Object3D<THREE.Event>): void;

package/dist/types/Loader/copperOBJLoader.d.ts

@@ -0,0 +1,3 @@
+import { OBJLoader } from "three/examples/jsm/loaders/OBJLoader";
+declare const objLoader: OBJLoader;
+export { objLoader };

package/dist/types/Loader/copperVtkLoader.d.ts

@@ -0,0 +1,8 @@
+import { VTKLoader } from "three/examples/jsm/loaders/VTKLoader.js";
+import * as THREE from "three";
+import { IOptVTKLoader } from "../types/types";
+export declare function copperVtkLoader(url: string, scene: THREE.Scene, content: THREE.Group, opts?: IOptVTKLoader): void;
+export declare function copperMultipleVtk(opts?: IOptVTKLoader): {
+    vtkLoader: VTKLoader;
+    vtkmaterial: THREE.MeshStandardMaterial;
+};

package/dist/types/Renderer/baseRenderer.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="stats.js" />
+import * as THREE from "three";
+import baseScene from "../Scene/baseScene";
+import { customMeshType } from "../lib/three-vignette";
+import Stats from "three/examples/jsm/libs/stats.module";
+import { GUI } from "dat.gui";
+import { optType } from "../types/types";
+export default class baseRenderer {
+    container: HTMLDivElement;
+    renderer: THREE.WebGLRenderer;
+    gui: GUI | null;
+    stats: Stats;
+    currentScene: baseScene;
+    pmremGenerator: THREE.PMREMGenerator;
+    options: optType | undefined;
+    private state;
+    private visualiseFolder;
+    private visualCtrls;
+    private cameraFolder;
+    constructor(container: HTMLDivElement, options?: optType);
+    init(): void;
+    updateEnvironment(vignette?: customMeshType): void;
+    private getCubeMapTexture;
+    getCurrentScene(): baseScene;
+    hideGui(): void;
+    closeGui(): void;
+    setClearColor(clearColor?: number, alpha?: number): void;
+    addGui(): void;
+    updateGui(): void;
+}

package/dist/types/Renderer/copperMSceneRenderer.d.ts

@@ -0,0 +1,21 @@
+import * as THREE from "three";
+import copperMScene from "../Scene/copperMScene";
+import { positionType } from "../types/types";
+export default class copperMSceneRenderer {
+    numberOfScene: number;
+    container: HTMLDivElement;
+    elems: Array<HTMLDivElement>;
+    scenes: Array<THREE.Scene>;
+    cameras: Array<THREE.PerspectiveCamera>;
+    renderer: THREE.WebGLRenderer;
+    canvas: HTMLCanvasElement;
+    sceneInfos: Array<copperMScene>;
+    pmremGenerator: THREE.PMREMGenerator;
+    constructor(container: HTMLDivElement, numberOfScene: number, cameraPosition?: positionType);
+    init(): void;
+    updateEnvironment(sceneIn: copperMScene): void;
+    private getCubeMapTexture;
+    renderSceneInfo: (sceneInfo: copperMScene) => void;
+    resizeRendererToDisplaySize: () => void;
+    animate: () => void;
+}

package/dist/types/Renderer/copperRenderer.d.ts

@@ -0,0 +1,15 @@
+import baseRenderer from "./baseRenderer";
+import copperScene from "../Scene/copperScene";
+import { optType } from "../types/types";
+export default class copperRenderer extends baseRenderer {
+    private sceneMap;
+    preRenderCallbackFunctions: Array<Function>;
+    constructor(container: HTMLDivElement, options?: optType);
+    getSceneByName(name: string): copperScene | import("../Scene/baseScene").default | import("../index").copperMScene;
+    setCurrentScene(sceneIn: copperScene): void;
+    createScene(name: string): copperScene | undefined;
+    addPreRenderCallbackFunction(callbackFunction: Function): void;
+    onWindowResize(): void;
+    animate: () => void;
+    render(): void;
+}

package/dist/types/Renderer/copperRendererOnDemond.d.ts

@@ -0,0 +1,13 @@
+import baseRenderer from "./baseRenderer";
+import copperScene from "../Scene/copperScene";
+import { optType } from "../types/types";
+import copperSceneOnDemond from "../Scene/copperSceneOnDemond";
+export default class copperRendererOnDemond extends baseRenderer {
+    private sceneMap;
+    constructor(container: HTMLDivElement, options?: optType);
+    getSceneByName(name: string): copperScene | import("../Scene/baseScene").default | import("../index").copperMScene;
+    setCurrentScene(sceneIn: copperSceneOnDemond): void;
+    createScene(name: string): copperSceneOnDemond | undefined;
+    animate: () => void;
+    render(): void;
+}

package/dist/types/Scene/baseScene.d.ts

@@ -0,0 +1,38 @@
+import * as THREE from "three";
+import { Controls, CameraViewPoint } from "../Controls/copperControls";
+import { customMeshType } from "../lib/three-vignette";
+import { baseStateType } from "../types/types";
+import commonScene from "./commonSceneMethod";
+export default class baseScene extends commonScene {
+    renderer: THREE.WebGLRenderer;
+    sceneName: string;
+    vignette: customMeshType | undefined;
+    directionalLight: THREE.DirectionalLight;
+    ambientLight: THREE.AmbientLight;
+    copperControl: Controls;
+    cameraPositionFlag: boolean;
+    content: THREE.Group;
+    exportContent: THREE.Group;
+    isHalfed: boolean;
+    viewPoint: CameraViewPoint;
+    private color1;
+    private color2;
+    private lights;
+    constructor(container: HTMLDivElement, renderer: THREE.WebGLRenderer, alpha?: boolean);
+    init(): void;
+    loadMetadataUrl(url: string): void;
+    loadViewUrl(url: string): void;
+    loadView(viewpointData: CameraViewPoint): void;
+    getDefaultViewPoint(): CameraViewPoint;
+    setViewPoint(camera: THREE.PerspectiveCamera, target?: number[]): CameraViewPoint;
+    addObject(obj: any): void;
+    addLights(): void;
+    removeLights(): void;
+    updateLights(state: baseStateType): void;
+    updateDisplay(state: baseStateType): void;
+    updateBackground(color1: string, color2: string): void;
+    updateModelChildrenVisualisation(child: THREE.Mesh): void;
+    onRenderCameraChange(): void;
+    onWindowResize: () => void;
+    render(): void;
+}

package/dist/types/Scene/commonSceneMethod.d.ts

@@ -0,0 +1,45 @@
+import { preRenderCallbackFunctionType, nrrdMeshesType, nrrdSliceType, loadingBarType, dicomLoaderOptsType, mouseMovePositionType } from "../types/types";
+import * as THREE from "three";
+import { GUI } from "dat.gui";
+import { optsType } from "../Loader/copperNrrdLoader";
+import { Controls } from "../Controls/copperControls";
+import { Copper3dTrackballControls } from "../Controls/Copper3dTrackballControls";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls";
+import { TrackballControls } from "three/examples/jsm/controls/TrackballControls";
+export default class commonScene {
+    container: HTMLDivElement;
+    scene: THREE.Scene;
+    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    subDiv: HTMLDivElement | null;
+    subScene: THREE.Scene;
+    subCamera: THREE.PerspectiveCamera | null;
+    controls: Copper3dTrackballControls | OrbitControls | TrackballControls;
+    protected subRender: THREE.WebGLRenderer | null;
+    protected subCopperControl: Controls | null;
+    protected renderNrrdVolume: boolean;
+    protected preRenderCallbackFunctions: preRenderCallbackFunctionType;
+    protected sort: boolean;
+    protected depthStep: number;
+    protected pickableObjects: THREE.Mesh[];
+    constructor(container: HTMLDivElement);
+    createDemoMesh(): void;
+    addObject(obj: any): void;
+    setDepth(value: number): void;
+    setDicomFilesOrder(value: "ascending" | "descending"): void;
+    addPreRenderCallbackFunction(callbackFunction: Function): number;
+    removePreRenderCallbackFunction(id: number): void;
+    pickModel(content: THREE.Group, callback: (selectMesh: THREE.Mesh | undefined) => void, options?: string[]): void;
+    pickSpecifiedModel(content: THREE.Mesh | Array<THREE.Mesh>, mousePosition: mouseMovePositionType): {
+        intersectedObject: THREE.Object3D<THREE.Event> | null;
+        intersects: THREE.Intersection<THREE.Object3D<THREE.Event>>[];
+    };
+    /**
+     * create a new sub view to display models
+     */
+    addSubView(): HTMLDivElement;
+    loadDicom(urls: string | Array<string>, opts?: dicomLoaderOptsType): void;
+    loadNrrd(url: string, loadingBar: loadingBarType, segmentation: boolean, callback?: (volume: any, nrrdMeshes: nrrdMeshesType, nrrdSlices: nrrdSliceType, gui?: GUI) => void, opts?: optsType): void;
+    updateControls(camera: THREE.PerspectiveCamera | THREE.OrthographicCamera): void;
+    loadNrrdTexture3d(url: string, callback?: (volume: any, gui?: GUI) => void): void;
+    loadOBJ(url: string, callback?: (mesh: THREE.Group) => void): void;
+}

package/dist/types/Scene/copperMScene.d.ts

@@ -0,0 +1,42 @@
+import * as THREE from "three";
+import { GUI } from "dat.gui";
+import { Controls, CameraViewPoint } from "../Controls/copperControls";
+import { customMeshType } from "../lib/three-vignette";
+import { positionType, nrrdSliceType } from "../types/types";
+import commonScene from "./commonSceneMethod";
+export default class copperMScene extends commonScene {
+    gui: GUI;
+    container: HTMLDivElement;
+    renderer: THREE.WebGLRenderer;
+    sceneName: string;
+    vignette: customMeshType;
+    directionalLight: THREE.DirectionalLight;
+    ambientLight: THREE.AmbientLight;
+    copperControl: Controls;
+    viewPoint: CameraViewPoint;
+    cameraPositionFlag: boolean;
+    content: THREE.Group;
+    isHalfed: boolean;
+    private color1;
+    private color2;
+    private lights;
+    private guiContainer;
+    constructor(container: HTMLDivElement, renderer: THREE.WebGLRenderer);
+    init(): void;
+    setControls(type: number): void;
+    loadGltf(url: string, callback?: (content: THREE.Group) => void): void;
+    setViewPoint(camera: THREE.PerspectiveCamera, target?: number[]): CameraViewPoint;
+    loadOBJ(url: string, callback?: (mesh: THREE.Group) => void): void;
+    drawWholeNrrd(nrrdSlices: nrrdSliceType): void;
+    updateBackground(color1: string, color2: string): void;
+    addLights(): void;
+    removeLights(): void;
+    loadViewUrl(url: string): void;
+    loadView(viewpointData: CameraViewPoint): void;
+    updateCamera(viewpoint: CameraViewPoint): void;
+    setCameraPosition(position: positionType): void;
+    removePreRenderCallbackFunction(id: number): void;
+    resetView(): void;
+    onWindowResize: () => void;
+    render(): void;
+}

package/dist/types/Scene/copperScene.d.ts

@@ -0,0 +1,34 @@
+import * as THREE from "three";
+import { Copper3dTrackballControls } from "../Controls/Copper3dTrackballControls";
+import { CameraViewPoint } from "../Controls/copperControls";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls";
+import baseScene from "./baseScene";
+import { vtkModels } from "../types/types";
+export default class copperScene extends baseScene {
+    clock: THREE.Clock;
+    controls: Copper3dTrackballControls | OrbitControls;
+    private mixer;
+    private playRate;
+    private modelReady;
+    private clipAction;
+    private texture2dMesh;
+    constructor(container: HTMLDivElement, renderer: THREE.WebGLRenderer, alpha?: boolean);
+    loadGltf(url: string, callback?: (content: THREE.Group) => void): void;
+    loadVtk(url: string): void;
+    loadVtks(models: Array<vtkModels>): void;
+    texture2d(url: string): void;
+    getPlayRate(): number;
+    setPlayRate(playRate: number): void;
+    setModelPosition(model: THREE.Group | THREE.Mesh, position: {
+        x?: number;
+        y?: number;
+        z?: number;
+    }): void;
+    resetView(): void;
+    updateCamera(viewpoint: CameraViewPoint): void;
+    getCurrentTime(): number;
+    getCurrentMixer(): THREE.AnimationMixer | null;
+    updateControls(camera: THREE.PerspectiveCamera | THREE.OrthographicCamera): void;
+    onRenderCameraChange(): void;
+    render(): void;
+}

package/dist/types/Scene/copperSceneOnDemond.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+import baseScene from "./baseScene";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls";
+export default class copperSceneOnDemond extends baseScene {
+    controls: OrbitControls;
+    renderRequested: boolean | undefined;
+    isResize: boolean;
+    constructor(container: HTMLDivElement, renderer: THREE.WebGLRenderer);
+    loadGltf(url: string, callback?: (content: THREE.Group) => void): void;
+    confirmResize: () => void;
+    render: () => void;
+    requestRenderIfNotRequested: () => void;
+}

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

@@ -0,0 +1,18 @@
+import baseScene from "../Scene/baseScene";
+import copperMScene from "../Scene/copperMScene";
+import * as THREE from "three";
+export declare function addLabelToScene(scene: baseScene | copperMScene, text: string, x: number, y: number, z: number, scaling: number, option?: {
+    font_size: string;
+    font: string;
+}): void;
+export interface positionType {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface screenPosType {
+    x: number;
+    y: number;
+}
+export declare function convertScreenPosto3DPos(container: HTMLDivElement | HTMLCanvasElement, camera: THREE.PerspectiveCamera, pos: screenPosType): positionType;
+export declare function convert3DPostoScreenPos(container: HTMLDivElement | HTMLCanvasElement, camera: THREE.PerspectiveCamera, mesh: THREE.Object3D | THREE.Mesh | THREE.Sprite): screenPosType;

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

@@ -0,0 +1 @@
+export declare function saveFileAsJson(blob: Blob, name: string): void;

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

@@ -0,0 +1,13 @@
+/**
+ * Retrieve a VOI LUT mapping function given the current windowing settings
+ * and the VOI LUT for the image
+ *
+ * @param {Number} windowWidth Window Width
+ * @param {Number} windowCenter Window Center
+ * @param {LUT} [voiLUT] Volume of Interest Lookup Table Object
+ * @param {Boolean} roundModalityLUTValues Do a Math.round of modality lut to compute non linear voilut
+ *
+ * @return {VOILUTFunction} VOI LUT mapping function
+ * @memberof VOILUT
+ */
+export default function getVOILUT(windowWidth: number, windowCenter: number, voiLUT: any, roundModalityLUTValues: boolean): (modalityLutValue: number) => number;

package/dist/types/Utils/kiwrious/configKiwrious.d.ts

@@ -0,0 +1,4 @@
+import { kiwriousType } from "../../types/types";
+declare const kiwrious: kiwriousType;
+export default kiwrious;
+export declare function configKiwriousHeart(connectBtn: HTMLButtonElement, disconnectBtn: HTMLButtonElement, binUrl: string, wasmUrl: string, connectionCallback: (isConnected: boolean) => void, heartDataCallback: (heartData: any, status: string, hrVal: number) => void): void;