@cornerstonejs/core 2.0.0-beta.8 → 2.0.0

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

@@ -0,0 +1,85 @@
+import { ImageQualityStatus, RequestType } from '../../enums';
+import type { IImagesLoader, ImageLoadRequests, ImageVolumeProps, IStreamingVolumeProperties, ScalingParameters } from '../../types';
+import ImageVolume from './ImageVolume';
+export default class BaseStreamingImageVolume extends ImageVolume implements IImagesLoader {
+    private framesLoaded;
+    private framesProcessed;
+    private framesUpdated;
+    protected autoRenderOnLoad: boolean;
+    protected cachedFrames: any[];
+    protected reRenderTarget: number;
+    protected reRenderFraction: number;
+    loadStatus: {
+        loaded: boolean;
+        loading: boolean;
+        cancelled: boolean;
+        callbacks: Array<(...args: unknown[]) => void>;
+    };
+    imagesLoader: IImagesLoader;
+    constructor(imageVolumeProperties: ImageVolumeProps, streamingProperties: IStreamingVolumeProperties);
+    protected invalidateVolume(immediate: boolean): void;
+    cancelLoading: () => void;
+    clearLoadCallbacks(): void;
+    protected callLoadStatusCallback(evt: any): void;
+    protected updateTextureAndTriggerEvents(imageIdIndex: any, imageId: any, imageQualityStatus?: ImageQualityStatus): void;
+    successCallback(imageId: string, image: any): void;
+    errorCallback(imageId: any, permanent: any, error: any): void;
+    load: (callback: (...args: unknown[]) => void) => void;
+    getLoaderImageOptions(imageId: string): {
+        targetBuffer: {
+            type: import("../../types").PixelDataTypedArrayString;
+            rows: any;
+            columns: any;
+        };
+        allowFloatRendering: boolean;
+        preScale: {
+            enabled: boolean;
+            scalingParameters: ScalingParameters;
+        };
+        transferPixelData: boolean;
+        requestType: RequestType;
+        transferSyntaxUID: any;
+        additionalDetails: {
+            imageId: string;
+            imageIdIndex: number;
+            volumeId: string;
+        };
+    };
+    callLoadImage(imageId: any, imageIdIndex: any, options: any): any;
+    protected getImageIdsRequests(imageIds: string[], priorityDefault: number): {
+        callLoadImage: (imageId: any, imageIdIndex: any, options: any) => any;
+        imageId: string;
+        imageIdIndex: number;
+        options: {
+            targetBuffer: {
+                type: import("../../types").PixelDataTypedArrayString;
+                rows: any;
+                columns: any;
+            };
+            allowFloatRendering: boolean;
+            preScale: {
+                enabled: boolean;
+                scalingParameters: ScalingParameters;
+            };
+            transferPixelData: boolean;
+            requestType: RequestType;
+            transferSyntaxUID: any;
+            additionalDetails: {
+                imageId: string;
+                imageIdIndex: number;
+                volumeId: string;
+            };
+        };
+        priority: number;
+        requestType: RequestType;
+        additionalDetails: {
+            volumeId: string;
+        };
+    }[];
+    getImageLoadRequests(priority: number): ImageLoadRequests[];
+    getImageIdsToLoad(): string[];
+    loadImages(): Promise<boolean>;
+    private _prefetchImageIds;
+    private _addScalingToVolume;
+    protected checkTimePointCompletion(imageIdIndex: number): void;
+}

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

@@ -0,0 +1,343 @@
+import * as metaData from '../../metaData';
+import { Events, ImageQualityStatus, RequestType } from '../../enums';
+import eventTarget from '../../eventTarget';
+import imageLoadPoolManager from '../../requestPool/imageLoadPoolManager';
+import { ProgressiveIterator, imageRetrieveMetadataProvider, hasFloatScalingParameters, autoLoad, triggerEvent, } from '../../utilities';
+import ImageVolume from './ImageVolume';
+import ProgressiveRetrieveImages from '../../loaders/ProgressiveRetrieveImages';
+import { canRenderFloatTextures } from '../../init';
+import { loadAndCacheImage } from '../../loaders/imageLoader';
+const requestTypeDefault = RequestType.Prefetch;
+export default class BaseStreamingImageVolume extends ImageVolume {
+    constructor(imageVolumeProperties, streamingProperties) {
+        super(imageVolumeProperties);
+        this.framesLoaded = 0;
+        this.framesProcessed = 0;
+        this.framesUpdated = 0;
+        this.autoRenderOnLoad = true;
+        this.cachedFrames = [];
+        this.reRenderTarget = 0;
+        this.reRenderFraction = 2;
+        this.imagesLoader = this;
+        this.cancelLoading = () => {
+            const { loadStatus } = this;
+            if (!loadStatus || !loadStatus.loading) {
+                return;
+            }
+            loadStatus.loading = false;
+            loadStatus.cancelled = true;
+            this.clearLoadCallbacks();
+            const filterFunction = ({ additionalDetails }) => {
+                return additionalDetails.volumeId !== this.volumeId;
+            };
+            imageLoadPoolManager.filterRequests(filterFunction);
+        };
+        this.load = (callback) => {
+            const { imageIds, loadStatus, numFrames } = this;
+            const { transferSyntaxUID } = metaData.get('transferSyntax', imageIds[0]) || {};
+            const imageRetrieveConfiguration = metaData.get(imageRetrieveMetadataProvider.IMAGE_RETRIEVE_CONFIGURATION, this.volumeId, transferSyntaxUID, 'volume');
+            this.imagesLoader = this.isDynamicVolume()
+                ? this
+                : imageRetrieveConfiguration
+                    ? (imageRetrieveConfiguration.create ||
+                        ProgressiveRetrieveImages.createProgressive)(imageRetrieveConfiguration)
+                    : this;
+            if (loadStatus.loading === true) {
+                return;
+            }
+            const { loaded } = this.loadStatus;
+            const totalNumFrames = imageIds.length;
+            if (loaded) {
+                if (callback) {
+                    callback({
+                        success: true,
+                        framesLoaded: totalNumFrames,
+                        framesProcessed: totalNumFrames,
+                        numFrames,
+                        totalNumFrames,
+                    });
+                }
+                return;
+            }
+            if (callback) {
+                this.loadStatus.callbacks.push(callback);
+            }
+            this._prefetchImageIds();
+        };
+        this.loadStatus = streamingProperties.loadStatus;
+    }
+    invalidateVolume(immediate) {
+        const { vtkOpenGLTexture } = this;
+        const { numFrames } = this;
+        for (let i = 0; i < numFrames; i++) {
+            vtkOpenGLTexture.setUpdatedFrame(i);
+        }
+        this.modified();
+        if (immediate) {
+            autoLoad(this.volumeId);
+        }
+    }
+    clearLoadCallbacks() {
+        this.loadStatus.callbacks = [];
+    }
+    callLoadStatusCallback(evt) {
+        const { framesUpdated, framesProcessed, totalNumFrames } = evt;
+        const { volumeId, reRenderFraction, loadStatus, metadata } = this;
+        const { FrameOfReferenceUID } = metadata;
+        if (this.autoRenderOnLoad) {
+            if (framesUpdated > this.reRenderTarget ||
+                framesProcessed === totalNumFrames) {
+                this.reRenderTarget += reRenderFraction;
+                autoLoad(volumeId);
+            }
+        }
+        if (framesProcessed === totalNumFrames) {
+            loadStatus.callbacks.forEach((callback) => callback(evt));
+            const eventDetail = {
+                FrameOfReferenceUID,
+                volumeId: volumeId,
+            };
+            triggerEvent(eventTarget, Events.IMAGE_VOLUME_LOADING_COMPLETED, eventDetail);
+        }
+    }
+    updateTextureAndTriggerEvents(imageIdIndex, imageId, imageQualityStatus = ImageQualityStatus.FULL_RESOLUTION) {
+        const frameIndex = this.imageIdIndexToFrameIndex(imageIdIndex);
+        const { cachedFrames, numFrames, totalNumFrames } = this;
+        const { FrameOfReferenceUID } = this.metadata;
+        const currentStatus = cachedFrames[frameIndex];
+        if (currentStatus > imageQualityStatus) {
+            return;
+        }
+        if (cachedFrames[frameIndex] === ImageQualityStatus.FULL_RESOLUTION) {
+            return;
+        }
+        const complete = imageQualityStatus === ImageQualityStatus.FULL_RESOLUTION;
+        cachedFrames[imageIdIndex] = imageQualityStatus;
+        this.framesUpdated++;
+        if (complete) {
+            this.framesLoaded++;
+            this.framesProcessed++;
+        }
+        const eventDetail = {
+            FrameOfReferenceUID,
+            volumeId: this.volumeId,
+            numberOfFrames: numFrames,
+            framesProcessed: this.framesProcessed,
+        };
+        triggerEvent(eventTarget, Events.IMAGE_VOLUME_MODIFIED, eventDetail);
+        if (complete && this.framesProcessed === this.totalNumFrames) {
+            this.loadStatus.loaded = true;
+            this.loadStatus.loading = false;
+        }
+        this.callLoadStatusCallback({
+            success: true,
+            imageIdIndex,
+            imageId,
+            framesLoaded: this.framesLoaded,
+            framesProcessed: this.framesProcessed,
+            framesUpdated: this.framesUpdated,
+            numFrames,
+            totalNumFrames,
+            complete,
+            imageQualityStatus,
+        });
+        this.vtkOpenGLTexture.setUpdatedFrame(frameIndex);
+        if (this.loadStatus.loaded) {
+            this.loadStatus.callbacks = [];
+        }
+    }
+    successCallback(imageId, image) {
+        const imageIdIndex = this.getImageIdIndex(imageId);
+        const { imageQualityStatus } = image;
+        if (this.loadStatus.cancelled) {
+            console.warn('volume load cancelled, returning for imageIdIndex: ', imageIdIndex);
+            return;
+        }
+        this.updateTextureAndTriggerEvents(imageIdIndex, imageId, imageQualityStatus);
+        if (this.isDynamicVolume()) {
+            this.checkTimePointCompletion(imageIdIndex);
+        }
+    }
+    errorCallback(imageId, permanent, error) {
+        if (!permanent) {
+            return;
+        }
+        const { totalNumFrames, numFrames } = this;
+        const imageIdIndex = this.getImageIdIndex(imageId);
+        this.framesProcessed++;
+        if (this.framesProcessed === totalNumFrames) {
+            this.loadStatus.loaded = true;
+            this.loadStatus.loading = false;
+        }
+        this.callLoadStatusCallback({
+            success: false,
+            imageId,
+            imageIdIndex,
+            error,
+            framesLoaded: this.framesLoaded,
+            framesProcessed: this.framesProcessed,
+            framesUpdated: this.framesUpdated,
+            numFrames,
+            totalNumFrames,
+        });
+        if (this.loadStatus.loaded) {
+            this.loadStatus.callbacks = [];
+        }
+        const eventDetail = {
+            error,
+            imageIdIndex,
+            imageId,
+        };
+        triggerEvent(eventTarget, Events.IMAGE_LOAD_ERROR, eventDetail);
+    }
+    getLoaderImageOptions(imageId) {
+        const { transferSyntaxUID: transferSyntaxUID } = metaData.get('transferSyntax', imageId) || {};
+        const imagePlaneModule = metaData.get('imagePlaneModule', imageId) || {};
+        const { rows, columns } = imagePlaneModule;
+        const imageIdIndex = this.getImageIdIndex(imageId);
+        const modalityLutModule = metaData.get('modalityLutModule', imageId) || {};
+        const generalSeriesModule = metaData.get('generalSeriesModule', imageId) || {};
+        const scalingParameters = {
+            rescaleSlope: modalityLutModule.rescaleSlope,
+            rescaleIntercept: modalityLutModule.rescaleIntercept,
+            modality: generalSeriesModule.modality,
+        };
+        if (scalingParameters.modality === 'PT') {
+            const suvFactor = metaData.get('scalingModule', imageId);
+            if (suvFactor) {
+                this._addScalingToVolume(suvFactor);
+                scalingParameters.suvbw = suvFactor.suvbw;
+            }
+        }
+        const floatAfterScale = hasFloatScalingParameters(scalingParameters);
+        const allowFloatRendering = canRenderFloatTextures();
+        this.isPreScaled = true;
+        if (scalingParameters &&
+            scalingParameters.rescaleSlope !== undefined &&
+            scalingParameters.rescaleIntercept !== undefined) {
+            const { rescaleSlope, rescaleIntercept } = scalingParameters;
+            this.isPreScaled =
+                typeof rescaleSlope === 'number' &&
+                    typeof rescaleIntercept === 'number';
+        }
+        if (!allowFloatRendering && floatAfterScale) {
+            this.isPreScaled = false;
+        }
+        const targetBuffer = {
+            type: this.dataType,
+            rows,
+            columns,
+        };
+        return {
+            targetBuffer,
+            allowFloatRendering,
+            preScale: {
+                enabled: this.isPreScaled,
+                scalingParameters,
+            },
+            transferPixelData: true,
+            requestType: requestTypeDefault,
+            transferSyntaxUID,
+            additionalDetails: {
+                imageId,
+                imageIdIndex,
+                volumeId: this.volumeId,
+            },
+        };
+    }
+    callLoadImage(imageId, imageIdIndex, options) {
+        const { cachedFrames } = this;
+        if (cachedFrames[imageIdIndex] === ImageQualityStatus.FULL_RESOLUTION) {
+            return;
+        }
+        const handleImageCacheAdded = (event) => {
+            const { image } = event.detail;
+            if (image.imageId === imageId) {
+                this.vtkOpenGLTexture.setUpdatedFrame(imageIdIndex);
+                eventTarget.removeEventListener(Events.IMAGE_CACHE_IMAGE_ADDED, handleImageCacheAdded);
+            }
+        };
+        eventTarget.addEventListener(Events.IMAGE_CACHE_IMAGE_ADDED, handleImageCacheAdded);
+        const uncompressedIterator = ProgressiveIterator.as(loadAndCacheImage(imageId, options));
+        return uncompressedIterator.forEach((image) => {
+            this.successCallback(imageId, image);
+        }, this.errorCallback.bind(this, imageIdIndex, imageId));
+    }
+    getImageIdsRequests(imageIds, priorityDefault) {
+        this.totalNumFrames = this.imageIds.length;
+        const autoRenderPercentage = 2;
+        if (this.autoRenderOnLoad) {
+            this.reRenderFraction =
+                this.totalNumFrames * (autoRenderPercentage / 100);
+            this.reRenderTarget = this.reRenderFraction;
+        }
+        const requests = imageIds.map((imageId) => {
+            const imageIdIndex = this.getImageIdIndex(imageId);
+            const requestType = requestTypeDefault;
+            const priority = priorityDefault;
+            const options = this.getLoaderImageOptions(imageId);
+            return {
+                callLoadImage: this.callLoadImage.bind(this),
+                imageId,
+                imageIdIndex,
+                options,
+                priority,
+                requestType,
+                additionalDetails: {
+                    volumeId: this.volumeId,
+                },
+            };
+        });
+        return requests;
+    }
+    getImageLoadRequests(priority) {
+        throw new Error('Abstract method');
+    }
+    getImageIdsToLoad() {
+        throw new Error('Abstract method');
+    }
+    loadImages() {
+        this.loadStatus.loading = true;
+        const requests = this.getImageLoadRequests(5);
+        requests.reverse().forEach((request) => {
+            if (!request) {
+                return;
+            }
+            const { callLoadImage, imageId, imageIdIndex, options, priority, requestType, additionalDetails, } = request;
+            imageLoadPoolManager.addRequest(callLoadImage.bind(this, imageId, imageIdIndex, options), requestType, additionalDetails, priority);
+        });
+        return Promise.resolve(true);
+    }
+    _prefetchImageIds() {
+        this.loadStatus.loading = true;
+        const imageIds = [...this.getImageIdsToLoad()];
+        this.totalNumFrames = this.imageIds.length;
+        const autoRenderPercentage = 2;
+        if (this.autoRenderOnLoad) {
+            this.reRenderFraction =
+                this.totalNumFrames * (autoRenderPercentage / 100);
+            this.reRenderTarget = this.reRenderFraction;
+        }
+        return this.imagesLoader.loadImages(imageIds, this).catch((e) => {
+            console.debug('progressive loading failed to complete', e);
+        });
+    }
+    _addScalingToVolume(suvFactor) {
+        if (this.scaling) {
+            return;
+        }
+        const { suvbw, suvlbm, suvbsa } = suvFactor;
+        const petScaling = {};
+        if (suvlbm) {
+            petScaling.suvbwToSuvlbm = suvlbm / suvbw;
+        }
+        if (suvbsa) {
+            petScaling.suvbwToSuvbsa = suvbsa / suvbw;
+        }
+        if (suvbw) {
+            petScaling.suvbw = suvbw;
+        }
+        this.scaling = { PT: petScaling };
+    }
+    checkTimePointCompletion(imageIdIndex) { }
+}

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

@@ -0,0 +1,28 @@
+import type { Point3, ContourData } from '../../types';
+import type { ContourType } from '../../enums';
+interface ContourProps {
+    id: string;
+    data: ContourData;
+    color: Point3;
+    segmentIndex: number;
+}
+export declare class Contour {
+    readonly id: string;
+    readonly sizeInBytes: number;
+    private _points;
+    private _color;
+    private _type;
+    private _segmentIndex;
+    constructor(props: ContourProps);
+    private _getSizeInBytes;
+    get points(): Point3[];
+    set points(value: Point3[]);
+    get color(): Point3;
+    set color(value: Point3);
+    get type(): ContourType;
+    set type(value: ContourType);
+    get segmentIndex(): number;
+    set segmentIndex(value: number);
+    get flatPointsArray(): number[];
+}
+export default Contour;

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

@@ -2,29 +2,41 @@ export class Contour {
     constructor(props) {
         const { points, type } = props.data;
         this.id = props.id;
-        this.points = points;
-        this.type = type;
-        this.color = props.color;
-        this.segmentIndex = props.segmentIndex;
+        this._points = points;
+        this._type = type;
+        this._color = props.color;
+        this._segmentIndex = props.segmentIndex;
         this.sizeInBytes = this._getSizeInBytes();
     }
     _getSizeInBytes() {
-        let sizeInBytes = 0;
-        sizeInBytes += this.points.length * 3;
-        return sizeInBytes;
+        return this._points.length * 3;
     }
-    getPoints() {
-        return this.points;
+    get points() {
+        return this._points;
     }
-    getFlatPointsArray() {
-        return this.points.map((point) => [...point]).flat();
+    set points(value) {
+        this._points = value;
     }
-    getColor() {
-        return this.color;
+    get color() {
+        return this._color;
     }
-    getType() {
-        return this.type;
+    set color(value) {
+        this._color = value;
+    }
+    get type() {
+        return this._type;
+    }
+    set type(value) {
+        this._type = value;
+    }
+    get segmentIndex() {
+        return this._segmentIndex;
+    }
+    set segmentIndex(value) {
+        this._segmentIndex = value;
+    }
+    get flatPointsArray() {
+        return this._points.map((point) => [...point]).flat();
     }
 }
 export default Contour;
-//# sourceMappingURL=Contour.js.map

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

@@ -0,0 +1,34 @@
+import type { Point3, IContour, ContourData } from '../../types';
+interface ContourSetProps {
+    id: string;
+    data: ContourData[];
+    frameOfReferenceUID: string;
+    segmentIndex: number;
+    color?: Point3;
+}
+export declare class ContourSet {
+    readonly id: string;
+    readonly sizeInBytes: number;
+    readonly frameOfReferenceUID: string;
+    private _color;
+    private _segmentIndex;
+    private _centroid;
+    private _contours;
+    constructor(props: ContourSetProps);
+    private _createEachContour;
+    private _updateContourSetCentroid;
+    private _getSizeInBytes;
+    private _getDistance;
+    get centroid(): Point3;
+    get segmentIndex(): number;
+    get color(): Point3;
+    set color(value: Point3);
+    get contours(): IContour[];
+    get flatPointsArray(): Point3[];
+    get numberOfContours(): number;
+    get totalNumberOfPoints(): number;
+    get numberOfPointsArray(): number[];
+    getPointsInContour(contourIndex: number): Point3[];
+    getNumberOfPointsInAContour(contourIndex: number): number;
+}
+export default ContourSet;

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

@@ -1,12 +1,12 @@
 import Contour from './Contour';
 export class ContourSet {
     constructor(props) {
-        this.color = [200, 0, 0];
+        this._color = [200, 0, 0];
         this.id = props.id;
-        this.contours = [];
-        this.color = props.color ?? this.color;
+        this._contours = [];
+        this._color = props.color ?? this._color;
         this.frameOfReferenceUID = props.frameOfReferenceUID;
-        this.segmentIndex = props.segmentIndex;
+        this._segmentIndex = props.segmentIndex;
         this._createEachContour(props.data);
         this.sizeInBytes = this._getSizeInBytes();
     }
@@ -14,23 +14,23 @@ export class ContourSet {
         contourDataArray.forEach((contourData) => {
             const { points, type, color } = contourData;
             const contour = new Contour({
-                id: `${this.id}-segment-${this.segmentIndex}`,
+                id: `${this.id}-segment-${this._segmentIndex}`,
                 data: {
                     points,
                     type,
-                    segmentIndex: this.segmentIndex,
-                    color: color ?? this.color,
+                    segmentIndex: this._segmentIndex,
+                    color: color ?? this._color,
                 },
-                segmentIndex: this.segmentIndex,
-                color: color ?? this.color,
+                segmentIndex: this._segmentIndex,
+                color: color ?? this._color,
             });
-            this.contours.push(contour);
+            this._contours.push(contour);
         });
         this._updateContourSetCentroid();
     }
     _updateContourSetCentroid() {
-        const numberOfPoints = this.getTotalNumberOfPoints();
-        const flatPointsArray = this.getFlatPointsArray();
+        const numberOfPoints = this.totalNumberOfPoints;
+        const flatPointsArray = this.flatPointsArray;
         const sumOfPoints = flatPointsArray.reduce((acc, point) => {
             return [acc[0] + point[0], acc[1] + point[1], acc[2] + point[2]];
         }, [0, 0, 0]);
@@ -49,56 +49,57 @@ export class ContourSet {
                 return closestPoint;
             }
         }, flatPointsArray[0]);
-        this.centroid = closestPoint;
+        this._centroid = closestPoint;
     }
     _getSizeInBytes() {
-        return this.contours.reduce((sizeInBytes, contour) => {
+        return this._contours.reduce((sizeInBytes, contour) => {
             return sizeInBytes + contour.sizeInBytes;
         }, 0);
     }
-    getCentroid() {
-        return this.centroid;
+    _getDistance(pointA, pointB) {
+        return Math.sqrt((pointA[0] - pointB[0]) ** 2 +
+            (pointA[1] - pointB[1]) ** 2 +
+            (pointA[2] - pointB[2]) ** 2);
+    }
+    get centroid() {
+        return this._centroid;
     }
-    getSegmentIndex() {
-        return this.segmentIndex;
+    get segmentIndex() {
+        return this._segmentIndex;
     }
-    getColor() {
-        return this.color;
+    get color() {
+        return this._color;
     }
-    getContours() {
-        return this.contours;
+    set color(value) {
+        this._color = value;
+        this._contours.forEach((contour) => {
+            if (contour instanceof Contour) {
+                contour.color = value;
+            }
+        });
     }
-    getSizeInBytes() {
-        return this.sizeInBytes;
+    get contours() {
+        return this._contours;
     }
-    getFlatPointsArray() {
-        return this.contours.map((contour) => contour.getPoints()).flat();
+    get flatPointsArray() {
+        return this._contours.flatMap((contour) => contour.points);
     }
-    getNumberOfContours() {
-        return this.contours.length;
+    get numberOfContours() {
+        return this._contours.length;
     }
-    getTotalNumberOfPoints() {
-        return this.contours.reduce((numberOfPoints, contour) => {
-            return numberOfPoints + contour.getPoints().length;
+    get totalNumberOfPoints() {
+        return this._contours.reduce((numberOfPoints, contour) => {
+            return numberOfPoints + contour.points.length;
         }, 0);
     }
-    getNumberOfPointsArray() {
-        return this.contours.reduce((acc, _, i) => {
-            acc[i] = this.getNumberOfPointsInAContour(i);
-            return acc;
-        }, []);
+    get numberOfPointsArray() {
+        return this._contours.map((contour) => contour.points.length);
     }
     getPointsInContour(contourIndex) {
-        return this.contours[contourIndex].getPoints();
+        return this._contours[contourIndex].points;
     }
     getNumberOfPointsInAContour(contourIndex) {
         return this.getPointsInContour(contourIndex).length;
     }
-    _getDistance(pointA, pointB) {
-        return Math.sqrt((pointA[0] - pointB[0]) ** 2 +
-            (pointA[1] - pointB[1]) ** 2 +
-            (pointA[2] - pointB[2]) ** 2);
-    }
 }
-export default Contour;
-//# sourceMappingURL=ContourSet.js.map
+export default ContourSet;