@ohif/app 3.10.0 → 3.10.2

package/dist/{3396.bundle.858cfdfc5ab560840958.js → 2482.bundle.0947bc67ad4429d5fda3.js}

@@ -1,4 +1,4 @@
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[3396],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[2482],{
 
 /***/ 46347:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
@@ -7,7 +7,7 @@
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _kitware_vtk_js_Rendering_Core_ColorTransferFunction__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(33739);
+/* harmony import */ var _kitware_vtk_js_Rendering_Core_ColorTransferFunction__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(642);
 /* harmony import */ var _kitware_vtk_js_Rendering_Core_ColorTransferFunction_ColorMaps__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(660);
 /* harmony import */ var _kitware_vtk_js_Common_DataModel_PiecewiseFunction__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(99341);
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(3823);
@@ -372,19 +372,14 @@ class BaseVolumeViewport extends _Viewport__WEBPACK_IMPORTED_MODULE_18__/* ["def
         const { volumeActor } = applicableVolumeActorInfo;
         const ofun = _kitware_vtk_js_Common_DataModel_PiecewiseFunction__WEBPACK_IMPORTED_MODULE_2__/* ["default"].newInstance */ .Ay.newInstance();
         if (typeof colormap.opacity === 'number') {
-            const range = volumeActor
-                .getProperty()
-                .getRGBTransferFunction(0)
-                .getRange();
-            ofun.addPoint(range[0], colormap.opacity);
-            ofun.addPoint(range[1], colormap.opacity);
+            (0,_utilities_colormap__WEBPACK_IMPORTED_MODULE_11__.updateOpacity)(volumeActor, colormap.opacity);
         }
         else {
             colormap.opacity.forEach(({ opacity, value }) => {
                 ofun.addPoint(value, opacity);
             });
+            volumeActor.getProperty().setScalarOpacity(0, ofun);
         }
-        volumeActor.getProperty().setScalarOpacity(0, ofun);
         if (!this.viewportProperties.colormap) {
             this.viewportProperties.colormap = {};
         }
@@ -571,6 +566,7 @@ class BaseVolumeViewport extends _Viewport__WEBPACK_IMPORTED_MODULE_18__/* ["def
         const isNegativeNormal = (0,_utilities_isEqual__WEBPACK_IMPORTED_MODULE_24__/* .isEqualNegative */ .WC)(viewPlaneNormal, refViewPlaneNormal);
         const isSameNormal = (0,_utilities_isEqual__WEBPACK_IMPORTED_MODULE_24__/* ["default"] */ .Ay)(viewPlaneNormal, refViewPlaneNormal);
         if (typeof sliceIndex === 'number' &&
+            volumeId !== undefined &&
             viewRef.volumeId === volumeId &&
             (isNegativeNormal || isSameNormal)) {
             const { currentStepIndex, sliceRangeInfo, numScrollSteps } = (0,_utilities_getVolumeViewportScrollInfo__WEBPACK_IMPORTED_MODULE_20__/* ["default"] */ .A)(this, volumeId, true);
@@ -588,17 +584,6 @@ class BaseVolumeViewport extends _Viewport__WEBPACK_IMPORTED_MODULE_18__/* ["def
                 this.setViewReference(viewRef);
                 return;
             }
-            if (cameraFocalPoint) {
-                const focalDelta = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.subtract */ .eR.subtract([0, 0, 0], cameraFocalPoint, focalPoint);
-                const useNormal = refViewPlaneNormal ?? viewPlaneNormal;
-                const normalDot = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.dot */ .eR.dot(focalDelta, useNormal);
-                if (!(0,_utilities_isEqual__WEBPACK_IMPORTED_MODULE_24__/* ["default"] */ .Ay)(normalDot, 0)) {
-                    gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.scale */ .eR.scale(focalDelta, useNormal, normalDot);
-                }
-                const newFocal = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.add */ .eR.add([0, 0, 0], focalPoint, focalDelta);
-                const newPosition = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.add */ .eR.add([0, 0, 0], position, focalDelta);
-                this.setCamera({ focalPoint: newFocal, position: newPosition });
-            }
             if (referencedImageId && this.isInAcquisitionPlane()) {
                 const imagePlaneModule = _metaData__WEBPACK_IMPORTED_MODULE_28__.get(_enums__WEBPACK_IMPORTED_MODULE_6__.MetadataModules.IMAGE_PLANE, referencedImageId);
                 const { imagePositionPatient } = imagePlaneModule;
@@ -610,12 +595,36 @@ class BaseVolumeViewport extends _Viewport__WEBPACK_IMPORTED_MODULE_18__/* ["def
                     focalPoint: newImagePositionPatient,
                 });
                 this.render();
+                return;
+            }
+            if (cameraFocalPoint) {
+                const focalDelta = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.subtract */ .eR.subtract([0, 0, 0], cameraFocalPoint, focalPoint);
+                const useNormal = refViewPlaneNormal ?? viewPlaneNormal;
+                const normalDot = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.dot */ .eR.dot(focalDelta, useNormal);
+                if (!(0,_utilities_isEqual__WEBPACK_IMPORTED_MODULE_24__/* ["default"] */ .Ay)(normalDot, 0)) {
+                    gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.scale */ .eR.scale(focalDelta, useNormal, normalDot);
+                }
+                const newFocal = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.add */ .eR.add([0, 0, 0], focalPoint, focalDelta);
+                const newPosition = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.add */ .eR.add([0, 0, 0], position, focalDelta);
+                this.setCamera({ focalPoint: newFocal, position: newPosition });
             }
         }
         else {
             throw new Error(`Incompatible view refs: ${refFrameOfReference}!==${this.getFrameOfReferenceUID()}`);
         }
     }
+    setThreshold(colormap, volumeId) {
+        const applicableVolumeActorInfo = this._getApplicableVolumeActor(volumeId);
+        if (!applicableVolumeActorInfo) {
+            return;
+        }
+        const { volumeActor } = applicableVolumeActorInfo;
+        (0,_utilities_colormap__WEBPACK_IMPORTED_MODULE_11__.updateThreshold)(volumeActor, colormap.threshold);
+        if (!this.viewportProperties.colormap) {
+            this.viewportProperties.colormap = {};
+        }
+        this.viewportProperties.colormap.threshold = colormap.threshold;
+    }
     setProperties({ voiRange, VOILUTFunction, invert, colormap, preset, interpolationType, slabThickness, } = {}, volumeId, suppressEvents = false) {
         if (this.globalDefaultProperties == null) {
             this.setDefaultProperties({
@@ -636,6 +645,9 @@ class BaseVolumeViewport extends _Viewport__WEBPACK_IMPORTED_MODULE_18__/* ["def
         if (colormap?.opacity != null) {
             this.setOpacity(colormap, volumeId);
         }
+        if (colormap?.threshold != null) {
+            this.setThreshold(colormap, volumeId);
+        }
         if (voiRange !== undefined) {
             this.setVOI(voiRange, volumeId, suppressEvents);
         }
@@ -898,14 +910,34 @@ class BaseVolumeViewport extends _Viewport__WEBPACK_IMPORTED_MODULE_18__/* ["def
                 throw new Error('Invalid orientation object. It must contain viewPlaneNormal and viewUp');
             }
         }
-        else if (typeof orientation === 'string' &&
-            _constants__WEBPACK_IMPORTED_MODULE_5__.MPR_CAMERA_VALUES[orientation]) {
-            this.viewportProperties.orientation = orientation;
-            return _constants__WEBPACK_IMPORTED_MODULE_5__.MPR_CAMERA_VALUES[orientation];
+        else if (typeof orientation === 'string') {
+            if (orientation === 'acquisition') {
+                return this._getAcquisitionPlaneOrientation();
+            }
+            else if (_constants__WEBPACK_IMPORTED_MODULE_5__.MPR_CAMERA_VALUES[orientation]) {
+                this.viewportProperties.orientation = orientation;
+                return _constants__WEBPACK_IMPORTED_MODULE_5__.MPR_CAMERA_VALUES[orientation];
+            }
         }
-        else {
-            throw new Error(`Invalid orientation: ${orientation}. Valid orientations are: ${Object.keys(_constants__WEBPACK_IMPORTED_MODULE_5__.MPR_CAMERA_VALUES).join(', ')}`);
+        throw new Error(`Invalid orientation: ${orientation}. Valid orientations are: ${Object.keys(_constants__WEBPACK_IMPORTED_MODULE_5__.MPR_CAMERA_VALUES).join(', ')}`);
+    }
+    _getAcquisitionPlaneOrientation() {
+        const actorEntry = this.getDefaultActor();
+        if (!actorEntry) {
+            return;
+        }
+        const volumeId = this.getVolumeId();
+        const imageVolume = _cache_cache__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .Ay.getVolume(volumeId);
+        if (!imageVolume) {
+            throw new Error(`imageVolume with id: ${volumeId} does not exist in cache`);
         }
+        const { direction } = imageVolume;
+        const viewPlaneNormal = direction.slice(6, 9).map((x) => -x);
+        const viewUp = direction.slice(3, 6).map((x) => -x);
+        return {
+            viewPlaneNormal,
+            viewUp,
+        };
     }
     getSlabThickness() {
         const actors = this.getActors();
@@ -984,8 +1016,8 @@ var DataArray = __webpack_require__(42008);
 var ImageData = __webpack_require__(58498);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/Camera.js
 var Camera = __webpack_require__(26719);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/ColorTransferFunction.js + 1 modules
-var ColorTransferFunction = __webpack_require__(33739);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/ColorTransferFunction.js
+var ColorTransferFunction = __webpack_require__(642);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps.js + 1 modules
 var ColorMaps = __webpack_require__(660);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/ImageMapper/Constants.js
@@ -3260,6 +3292,10 @@ class StackViewport extends Viewport/* default */.A {
             origin = [0, 0, 0];
         }
         this._imageData.setOrigin(origin);
+        const actor = this.getActor(this.id);
+        if (actor) {
+            actor.referencedId = image.imageId;
+        }
         (0,updateVTKImageDataWithCornerstoneImage/* updateVTKImageDataWithCornerstoneImage */.J)(this._imageData, image);
     }
     _loadAndDisplayImage(imageId, imageIdIndex) {
@@ -3527,7 +3563,7 @@ class StackViewport extends Viewport/* default */.A {
             oldActors[0].actor = actor;
         }
         else {
-            oldActors.unshift({ uid: this.id, actor });
+            oldActors.unshift({ uid: this.id, actor, referencedId: image.imageId });
         }
         this.setActors(oldActors);
         const { viewPlaneNormal, viewUp } = this._getCameraOrientation(direction);
@@ -3677,6 +3713,7 @@ class StackViewport extends Viewport/* default */.A {
             return Promise.resolve(this.getCurrentImageId());
         }
         const imageIdPromise = this._setImageIdIndex(imageIdIndex);
+        this.targetImageIdIndex = imageIdIndex;
         return imageIdPromise;
     }
     calibrateSpacing(imageId) {
@@ -5168,22 +5205,41 @@ class Viewport {
         return this.getActors()[index];
     }
     setActors(actors) {
+        const currentActors = this.getActors();
         this.removeAllActors();
         this.addActors(actors, { resetCamera: true });
+        (0,_utilities_triggerEvent__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(this.element, _enums_Events__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A.ACTORS_CHANGED, {
+            viewportId: this.id,
+            removedActors: currentActors,
+            addedActors: actors,
+            currentActors: actors,
+        });
     }
     _removeActor(actorUID) {
         const actorEntry = this.getActor(actorUID);
         if (!actorEntry) {
-            console.warn(`Actor ${actorUID} does not exist for this viewport`);
+            console.warn(`Actor ${actorUID} does not exist in ${this.id}, can't remove`);
             return;
         }
         const renderer = this.getRenderer();
-        renderer.removeViewProp(actorEntry.actor);
+        renderer.removeActor(actorEntry.actor);
         this._actors.delete(actorUID);
+        return actorEntry;
     }
     removeActors(actorUIDs) {
+        const removedActors = [];
         actorUIDs.forEach((actorUID) => {
-            this._removeActor(actorUID);
+            const removedActor = this._removeActor(actorUID);
+            if (removedActor) {
+                removedActors.push(removedActor);
+            }
+        });
+        const currentActors = this.getActors();
+        (0,_utilities_triggerEvent__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(this.element, _enums_Events__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A.ACTORS_CHANGED, {
+            viewportId: this.id,
+            removedActors,
+            addedActors: [],
+            currentActors,
         });
     }
     addActors(actors, options = {}) {
@@ -5203,6 +5259,12 @@ class Viewport {
             this.setViewReference(prevViewRef);
             this.setViewPresentation(prevViewPresentation);
         }
+        (0,_utilities_triggerEvent__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(this.element, _enums_Events__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A.ACTORS_CHANGED, {
+            viewportId: this.id,
+            removedActors: [],
+            addedActors: actors,
+            currentActors: this.getActors(),
+        });
     }
     addActor(actorEntry) {
         const { uid: actorUID, actor } = actorEntry;
@@ -5222,10 +5284,23 @@ class Viewport {
         renderer?.addActor(actor);
         this._actors.set(actorUID, Object.assign({}, actorEntry));
         this.updateCameraClippingPlanesAndRange();
+        (0,_utilities_triggerEvent__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(this.element, _enums_Events__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A.ACTORS_CHANGED, {
+            viewportId: this.id,
+            removedActors: [],
+            addedActors: [actorEntry],
+            currentActors: this.getActors(),
+        });
     }
     removeAllActors() {
+        const currentActors = this.getActors();
         this.getRenderer()?.removeAllViewProps();
         this._actors = new Map();
+        (0,_utilities_triggerEvent__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(this.element, _enums_Events__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A.ACTORS_CHANGED, {
+            viewportId: this.id,
+            removedActors: currentActors,
+            addedActors: [],
+            currentActors: [],
+        });
         return;
     }
     resetCameraNoEvent() {
@@ -5385,7 +5460,15 @@ class Viewport {
             flipVertical: false,
         });
         const previousCamera = this.getCamera();
-        const bounds = renderer.computeVisiblePropBounds();
+        let bounds;
+        const defaultActor = this.getDefaultActor();
+        if (defaultActor && (0,_utilities_actorCheck__WEBPACK_IMPORTED_MODULE_8__/* .isImageActor */ .e)(defaultActor)) {
+            const imageData = defaultActor.actor.getMapper().getInputData();
+            bounds = imageData.getBounds();
+        }
+        else {
+            bounds = renderer.computeVisiblePropBounds();
+        }
         const focalPoint = [0, 0, 0];
         const imageData = this.getDefaultImageData();
         if (imageData) {
@@ -6136,11 +6219,11 @@ class VolumeViewport extends BaseVolumeViewport/* default */.A {
     setOrientation(orientation, immediate = true) {
         let viewPlaneNormal, viewUp;
         if (typeof orientation === 'string') {
-            if (constants.MPR_CAMERA_VALUES[orientation]) {
-                ({ viewPlaneNormal, viewUp } = constants.MPR_CAMERA_VALUES[orientation]);
+            if (orientation === enums.OrientationAxis.ACQUISITION) {
+                ({ viewPlaneNormal, viewUp } = super._getAcquisitionPlaneOrientation());
             }
-            else if (orientation === 'acquisition') {
-                ({ viewPlaneNormal, viewUp } = this._getAcquisitionPlaneOrientation());
+            else if (constants.MPR_CAMERA_VALUES[orientation]) {
+                ({ viewPlaneNormal, viewUp } = constants.MPR_CAMERA_VALUES[orientation]);
             }
             else {
                 throw new Error(`Invalid orientation: ${orientation}. Use Enums.OrientationAxis instead.`);
@@ -6173,24 +6256,6 @@ class VolumeViewport extends BaseVolumeViewport/* default */.A {
             activeCamera.setClippingRange(constants.RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS, constants.RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
         }
     }
-    _getAcquisitionPlaneOrientation() {
-        const actorEntry = this.getDefaultActor();
-        if (!actorEntry) {
-            return;
-        }
-        const volumeId = this.getVolumeId();
-        const imageVolume = cache/* default */.Ay.getVolume(volumeId);
-        if (!imageVolume) {
-            throw new Error(`imageVolume with id: ${volumeId} does not exist in cache`);
-        }
-        const { direction } = imageVolume;
-        const viewPlaneNormal = direction.slice(6, 9).map((x) => -x);
-        const viewUp = direction.slice(3, 6).map((x) => -x);
-        return {
-            viewPlaneNormal,
-            viewUp,
-        };
-    }
     _setViewPlaneToAcquisitionPlane(imageVolume) {
         let viewPlaneNormal, viewUp;
         if (imageVolume) {
@@ -9195,8 +9260,8 @@ var macros2 = __webpack_require__(28906);
 var BoundingBox = __webpack_require__(21734);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/Prop3D.js
 var Prop3D = __webpack_require__(62502);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/ColorTransferFunction.js + 1 modules
-var ColorTransferFunction = __webpack_require__(33739);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/ColorTransferFunction.js
+var ColorTransferFunction = __webpack_require__(642);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PiecewiseFunction.js
 var PiecewiseFunction = __webpack_require__(99341);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/VolumeProperty/Constants.js
@@ -17783,11 +17848,12 @@ class BaseStreamingImageVolume extends _ImageVolume__WEBPACK_IMPORTED_MODULE_9__
             rescaleIntercept: modalityLutModule.rescaleIntercept,
             modality: generalSeriesModule.modality,
         };
-        if (scalingParameters.modality === 'PT') {
-            const suvFactor = _metaData__WEBPACK_IMPORTED_MODULE_0__.get('scalingModule', imageId);
-            if (suvFactor) {
-                this._addScalingToVolume(suvFactor);
-                scalingParameters.suvbw = suvFactor.suvbw;
+        const modality = scalingParameters.modality;
+        if (modality === 'PT' || modality === 'RTDOSE') {
+            const scalingFactor = _metaData__WEBPACK_IMPORTED_MODULE_0__.get('scalingModule', imageId);
+            if (scalingFactor) {
+                this._addScalingToVolume(scalingFactor);
+                Object.assign(scalingParameters, scalingFactor);
             }
         }
         const floatAfterScale = (0,_utilities_hasFloatScalingParameters__WEBPACK_IMPORTED_MODULE_6__/* .hasFloatScalingParameters */ .a)(scalingParameters);
@@ -22025,6 +22091,7 @@ var Events;
     Events["GEOMETRY_LOADED"] = "GEOMETRY_LOADED";
     Events["GEOMETRY_LOAD_PROGRESS"] = "GEOMETRY_LOAD_PROGRESS";
     Events["GEOMETRY_LOADED_FAILED"] = "GEOMETRY_LOADED_FAILED";
+    Events["ACTORS_CHANGED"] = "CORNERSTONE_ACTORS_CHANGED";
 })(Events || (Events = {}));
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Events);
 
@@ -32800,6 +32867,8 @@ function getConstructorFromType(bufferType, isVolumeBuffer) {
             return Float32Array;
         case 'Uint8Array':
             return Uint8Array;
+        case 'Uint32Array':
+            return Uint32Array;
         case 'Uint16Array':
         case 'Int16Array':
             if (!isVolumeBuffer) {
@@ -32811,7 +32880,7 @@ function getConstructorFromType(bufferType, isVolumeBuffer) {
             }
         default:
             if (bufferType) {
-                throw new Error('TargetBuffer should be Float32Array, Uint8Array, Uint16Array, or Int16Array');
+                throw new Error('TargetBuffer should be Float32Array, Uint8Array, Uint16Array, Int16Array, or Uint32Array');
             }
             else {
                 return Float32Array;
@@ -32894,6 +32963,10 @@ function uuidv4() {
 /* harmony export */   zj: () => (/* binding */ getConfig)
 /* harmony export */ });
 /* unused harmony exports setConfig, getAddOns */
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
+/* harmony import */ var _enums_Events__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(94021);
+
+
 let config = {};
 function getConfig() {
     return config;
@@ -35210,6 +35283,7 @@ class ToolStyle {
             textBoxLinkLineDash: '2,3',
             textBoxShadow: true,
             markerSize: '10',
+            angleArcLineDash: '',
         };
         this._initializeConfig(defaultConfig);
     }
@@ -36769,6 +36843,9 @@ BaseTool.toolName = 'BaseTool';
 /* harmony import */ var _removeContourFromElement__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(87420);
 /* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(36625);
 /* harmony import */ var _utilities_segmentation_computeAndAddRepresentation__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(27479);
+/* harmony import */ var _utilities_segmentation_getUniqueSegmentIndices__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(25758);
+/* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(82056);
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(3823);
 
 
 
@@ -36776,7 +36853,10 @@ BaseTool.toolName = 'BaseTool';
 
 
 
-let polySegConversionInProgress = false;
+
+
+
+const polySegConversionInProgressForViewportId = new Map();
 const processedViewportSegmentations = new Map();
 function removeRepresentation(viewportId, segmentationId, renderImmediate = false) {
     const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElementByViewportId)(viewportId);
@@ -36784,10 +36864,10 @@ function removeRepresentation(viewportId, segmentationId, renderImmediate = fals
         return;
     }
     const { viewport } = enabledElement;
+    (0,_removeContourFromElement__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A)(viewportId, segmentationId);
     if (!renderImmediate) {
         return;
     }
-    (0,_removeContourFromElement__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A)(viewportId, segmentationId);
     viewport.render();
 }
 async function render(viewport, contourRepresentation) {
@@ -36797,13 +36877,13 @@ async function render(viewport, contourRepresentation) {
         return;
     }
     let contourData = segmentation.representationData[_enums_SegmentationRepresentations__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.Contour];
+    const polySeg = (0,_config__WEBPACK_IMPORTED_MODULE_5__/* .getPolySeg */ .Qy)();
     if (!contourData &&
         (0,_config__WEBPACK_IMPORTED_MODULE_5__/* .getPolySeg */ .Qy)()?.canComputeRequestedRepresentation(segmentationId, _enums_SegmentationRepresentations__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.Contour) &&
-        !polySegConversionInProgress) {
-        polySegConversionInProgress = true;
-        const polySeg = (0,_config__WEBPACK_IMPORTED_MODULE_5__/* .getPolySeg */ .Qy)();
+        !polySegConversionInProgressForViewportId.get(viewport.id)) {
+        polySegConversionInProgressForViewportId.set(viewport.id, true);
         contourData = await (0,_utilities_segmentation_computeAndAddRepresentation__WEBPACK_IMPORTED_MODULE_6__/* .computeAndAddRepresentation */ .d)(segmentationId, _enums_SegmentationRepresentations__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.Contour, () => polySeg.computeContourData(segmentationId, { viewport }), () => undefined);
-        polySegConversionInProgress = false;
+        polySegConversionInProgressForViewportId.set(viewport.id, false);
     }
     else if (!contourData && !(0,_config__WEBPACK_IMPORTED_MODULE_5__/* .getPolySeg */ .Qy)()) {
         console.debug(`No contour data found for segmentationId ${segmentationId} and PolySeg add-on is not configured. Unable to convert from other representations to contour. Please register PolySeg using cornerstoneTools.init({ addons: { polySeg } }) to enable automatic conversion.`);
@@ -36814,8 +36894,101 @@ async function render(viewport, contourRepresentation) {
     if (!contourData.geometryIds?.length) {
         return;
     }
+    let hasContourDataButNotMatchingViewport = false;
+    const viewportNormal = viewport.getCamera().viewPlaneNormal;
+    if (contourData.annotationUIDsMap) {
+        hasContourDataButNotMatchingViewport = !_checkContourNormalsMatchViewport(contourData.annotationUIDsMap, viewportNormal);
+    }
+    if (contourData.geometryIds.length > 0) {
+        hasContourDataButNotMatchingViewport = !_checkContourGeometryMatchViewport(contourData.geometryIds, viewportNormal);
+    }
+    const viewportProcessed = processedViewportSegmentations.get(viewport.id) || new Set();
+    if (hasContourDataButNotMatchingViewport &&
+        !polySegConversionInProgressForViewportId.get(viewport.id) &&
+        !viewportProcessed.has(segmentationId) &&
+        viewport.viewportStatus === _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.Enums.ViewportStatus.RENDERED) {
+        polySegConversionInProgressForViewportId.set(viewport.id, true);
+        const segmentIndices = (0,_utilities_segmentation_getUniqueSegmentIndices__WEBPACK_IMPORTED_MODULE_7__/* .getUniqueSegmentIndices */ .O)(segmentationId);
+        const surfacesInfo = await polySeg.computeSurfaceData(segmentationId, {
+            segmentIndices,
+            viewport,
+        });
+        const geometryIds = surfacesInfo.geometryIds;
+        const pointsAndPolys = [];
+        for (const geometryId of geometryIds.values()) {
+            const geometry = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getGeometry(geometryId);
+            const data = geometry.data;
+            pointsAndPolys.push({
+                points: data.points,
+                polys: data.polys,
+                segmentIndex: data.segmentIndex,
+                id: data.segmentIndex,
+            });
+        }
+        const polyDataCache = await polySeg.clipAndCacheSurfacesForViewport(pointsAndPolys, viewport);
+        const rawResults = polySeg.extractContourData(polyDataCache);
+        const annotationUIDsMap = polySeg.createAndAddContourSegmentationsFromClippedSurfaces(rawResults, viewport, segmentationId);
+        contourData.annotationUIDsMap = new Map([
+            ...contourData.annotationUIDsMap,
+            ...annotationUIDsMap,
+        ]);
+        viewportProcessed.add(segmentationId);
+        processedViewportSegmentations.set(viewport.id, viewportProcessed);
+        polySegConversionInProgressForViewportId.set(viewport.id, false);
+    }
     (0,_contourHandler_handleContourSegmentation__WEBPACK_IMPORTED_MODULE_2__/* .handleContourSegmentation */ .d)(viewport, contourData.geometryIds, contourData.annotationUIDsMap, contourRepresentation);
 }
+function _checkContourGeometryMatchViewport(geometryIds, viewportNormal) {
+    let validGeometry = null;
+    let geometryData = null;
+    for (const geometryId of geometryIds) {
+        const geometry = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getGeometry(geometryId);
+        if (!geometry) {
+            continue;
+        }
+        const data = geometry.data;
+        if (data.contours?.[0]?.points?.length >= 3) {
+            validGeometry = geometry;
+            geometryData = data;
+            break;
+        }
+    }
+    if (!validGeometry || !geometryData) {
+        return false;
+    }
+    const contours = geometryData.contours;
+    const points = contours[0].points;
+    const point1 = points[0];
+    const point2 = points[1];
+    const point3 = points[2];
+    let normal = gl_matrix__WEBPACK_IMPORTED_MODULE_9__/* .vec3.cross */ .eR.cross(gl_matrix__WEBPACK_IMPORTED_MODULE_9__/* .vec3.create */ .eR.create(), gl_matrix__WEBPACK_IMPORTED_MODULE_9__/* .vec3.sub */ .eR.sub(gl_matrix__WEBPACK_IMPORTED_MODULE_9__/* .vec3.create */ .eR.create(), point2, point1), gl_matrix__WEBPACK_IMPORTED_MODULE_9__/* .vec3.sub */ .eR.sub(gl_matrix__WEBPACK_IMPORTED_MODULE_9__/* .vec3.create */ .eR.create(), point3, point1));
+    normal = gl_matrix__WEBPACK_IMPORTED_MODULE_9__/* .vec3.normalize */ .eR.normalize(gl_matrix__WEBPACK_IMPORTED_MODULE_9__/* .vec3.create */ .eR.create(), normal);
+    const dotProduct = gl_matrix__WEBPACK_IMPORTED_MODULE_9__/* .vec3.dot */ .eR.dot(normal, viewportNormal);
+    return Math.abs(dotProduct) > 0.9;
+}
+function _checkContourNormalsMatchViewport(annotationUIDsMap, viewportNormal) {
+    const annotationUIDs = Array.from(annotationUIDsMap.values())
+        .flat()
+        .map((uidSet) => Array.from(uidSet))
+        .flat();
+    const randomAnnotationUIDs = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.getRandomSampleFromArray(annotationUIDs, 3);
+    for (const annotationUID of randomAnnotationUIDs) {
+        const annotation = (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_8__.getAnnotation)(annotationUID);
+        if (annotation?.metadata) {
+            if (!annotation.metadata.viewPlaneNormal) {
+                continue;
+            }
+            const annotationNormal = annotation.metadata.viewPlaneNormal;
+            const dotProduct = Math.abs(viewportNormal[0] * annotationNormal[0] +
+                viewportNormal[1] * annotationNormal[1] +
+                viewportNormal[2] * annotationNormal[2]);
+            if (Math.abs(dotProduct - 1) > 0.01) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
     render,
     removeRepresentation,
@@ -37634,9 +37807,6 @@ class RectangleROIStartEndThresholdTool extends _annotation_RectangleROITool__WE
         if (this.configuration.calculatePointsInsideVolume) {
             this._computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement);
         }
-        if (this.configuration.calculatePointsInsideVolume) {
-            this._computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement);
-        }
         annotation.invalidated = false;
         (0,_stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_13__.triggerAnnotationModified)(annotation, viewport.element);
         return cachedStats;
@@ -39855,10 +40025,14 @@ async function calculateVolumeStatistics({ operationData, indices, unit, mode, }
         origin: imageData.getOrigin(),
         direction: imageData.getDirection(),
     };
+    if (!imageInfo.scalarData?.length) {
+        return;
+    }
     const stats = await (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getWebWorkerManager)().executeTask('compute', 'calculateSegmentsStatisticsVolume', {
         segmentationInfo,
         imageInfo,
         indices,
+        unit,
         mode,
     });
     (0,_utilsForWorker__WEBPACK_IMPORTED_MODULE_1__/* .triggerWorkerProgress */ .sg)(_enums__WEBPACK_IMPORTED_MODULE_4__.WorkerTypes.COMPUTE_STATISTICS, 100);
@@ -40017,7 +40191,9 @@ function getSphereStats(testMax, radiusIJK, segData, imageVoxels, spacing) {
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
-/* unused harmony export getUniqueSegmentIndices */
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   O: () => (/* binding */ getUniqueSegmentIndices)
+/* harmony export */ });
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(99737);
 /* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(64063);
@@ -40027,11 +40203,11 @@ function getSphereStats(testMax, radiusIJK, segData, imageVoxels, spacing) {
 
 
 function getUniqueSegmentIndices(segmentationId) {
-    const cachedResult = getCachedSegmentIndices(segmentationId);
+    const cachedResult = (0,_utilities__WEBPACK_IMPORTED_MODULE_2__/* .getCachedSegmentIndices */ .R1)(segmentationId);
     if (cachedResult) {
         return cachedResult;
     }
-    const segmentation = getSegmentation(segmentationId);
+    const segmentation = (0,_stateManagement_segmentation_getSegmentation__WEBPACK_IMPORTED_MODULE_3__/* .getSegmentation */ .T)(segmentationId);
     if (!segmentation) {
         throw new Error(`No segmentation found for segmentationId ${segmentationId}`);
     }
@@ -40048,11 +40224,11 @@ function getUniqueSegmentIndices(segmentationId) {
     else {
         throw new Error(`Unsupported segmentation type: ${segmentation.representationData}`);
     }
-    setCachedSegmentIndices(segmentationId, indices);
+    (0,_utilities__WEBPACK_IMPORTED_MODULE_2__/* .setCachedSegmentIndices */ .Dm)(segmentationId, indices);
     return indices;
 }
 function handleLabelmapSegmentation(segmentation, segmentationId) {
-    const labelmapData = segmentation.representationData[SegmentationRepresentations.Labelmap];
+    const labelmapData = segmentation.representationData[_enums__WEBPACK_IMPORTED_MODULE_1__.SegmentationRepresentations.Labelmap];
     const keySet = new Set();
     if (labelmapData.imageIds) {
         addImageSegmentIndices(keySet, labelmapData.imageIds);
@@ -40065,7 +40241,7 @@ function handleLabelmapSegmentation(segmentation, segmentationId) {
         .sort((a, b) => a - b);
 }
 function addVolumeSegmentIndices(keySet, segmentationId) {
-    const volume = cache.getVolume(segmentationId);
+    const volume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(segmentationId);
     volume.voxelManager.forEach(({ value }) => {
         if (value !== 0) {
             keySet.add(value);
@@ -40074,7 +40250,7 @@ function addVolumeSegmentIndices(keySet, segmentationId) {
 }
 function addImageSegmentIndices(keySet, imageIds) {
     imageIds.forEach((segmentationImageId) => {
-        const image = cache.getImage(segmentationImageId);
+        const image = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getImage(segmentationImageId);
         const scalarData = image.voxelManager.getScalarData();
         scalarData.forEach((segmentIndex) => {
             if (segmentIndex !== 0) {
@@ -40090,7 +40266,7 @@ function handleContourSegmentation(segmentation) {
     }
     const indices = new Set([...annotationUIDsMap.keys()]);
     geometryIds.forEach((geometryId) => {
-        const geometry = cache.getGeometry(geometryId);
+        const geometry = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getGeometry(geometryId);
         indices.add(geometry.data.segmentIndex);
     });
     return Array.from(indices).sort((a, b) => a - b);
@@ -40630,9 +40806,11 @@ function thresholdVolumeByRange(segmentationVolume, thresholdVolumeInformation,
 
 "use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   HM: () => (/* binding */ setSegmentationDirty)
+/* harmony export */   Dm: () => (/* binding */ setCachedSegmentIndices),
+/* harmony export */   HM: () => (/* binding */ setSegmentationDirty),
+/* harmony export */   R1: () => (/* binding */ getCachedSegmentIndices)
 /* harmony export */ });
-/* unused harmony exports getVoxelOverlap, processVolumes, setSegmentationClean, getCachedSegmentIndices, setCachedSegmentIndices */
+/* unused harmony exports getVoxelOverlap, processVolumes, setSegmentationClean */
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
 /* harmony import */ var _boundingBox_getBoundingBoxAroundShape__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(87063);
 
@@ -40866,7 +41044,7 @@ const getImageReferenceInfo = (segVolumeId, segImageIds) => {
     const refImage = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getImage(refImageId);
     const scalingModule = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.metaData.get('scalingModule', refImageId);
     const modalityUnitOptions = {
-        isPreScaled: Boolean(refImage.preScale?.scaled),
+        isPreScaled: Boolean(refImage?.preScale?.scaled),
         isSuvScaled: typeof scalingModule?.suvbw === 'number',
     };
     return { refImageId, modalityUnitOptions };
@@ -53554,1276 +53732,6 @@ var vtkCamera$1 = {
 
 
 
-/***/ }),
-
-/***/ 33739:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  Ay: () => (/* binding */ vtkColorTransferFunction$1)
-});
-
-// UNUSED EXPORTS: extend, newInstance
-
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/macros2.js
-var macros2 = __webpack_require__(28906);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/Math/index.js
-var Core_Math = __webpack_require__(16632);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/ScalarsToColors.js
-var ScalarsToColors = __webpack_require__(80993);
-;// CONCATENATED MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/ColorTransferFunction/Constants.js
-const ColorSpace = {
-  RGB: 0,
-  HSV: 1,
-  LAB: 2,
-  DIVERGING: 3
-};
-const Scale = {
-  LINEAR: 0,
-  LOG10: 1
-};
-var Constants = {
-  ColorSpace,
-  Scale
-};
-
-
-
-;// CONCATENATED MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/ColorTransferFunction.js
-
-
-
-
-
-const {
-  ColorSpace: ColorTransferFunction_ColorSpace,
-  Scale: ColorTransferFunction_Scale
-} = Constants;
-const {
-  ScalarMappingTarget
-} = ScalarsToColors/* default */.Ay;
-const {
-  vtkDebugMacro,
-  vtkErrorMacro,
-  vtkWarningMacro
-} = macros2.m;
-
-// ----------------------------------------------------------------------------
-// Global methods
-// ----------------------------------------------------------------------------
-/* eslint-disable no-continue                                                */
-
-// Convert to and from a special polar version of CIELAB (useful for creating
-// continuous diverging color maps).
-function vtkColorTransferFunctionLabToMsh(lab, msh) {
-  const L = lab[0];
-  const a = lab[1];
-  const b = lab[2];
-  const M = Math.sqrt(L * L + a * a + b * b);
-  const s = M > 0.001 ? Math.acos(L / M) : 0.0;
-  const h = s > 0.001 ? Math.atan2(b, a) : 0.0;
-  msh[0] = M;
-  msh[1] = s;
-  msh[2] = h;
-}
-function vtkColorTransferFunctionMshToLab(msh, lab) {
-  const M = msh[0];
-  const s = msh[1];
-  const h = msh[2];
-  lab[0] = M * Math.cos(s);
-  lab[1] = M * Math.sin(s) * Math.cos(h);
-  lab[2] = M * Math.sin(s) * Math.sin(h);
-}
-
-// For the case when interpolating from a saturated color to an unsaturated
-// color, find a hue for the unsaturated color that makes sense.
-function vtkColorTransferFunctionAdjustHue(msh, unsatM) {
-  if (msh[0] >= unsatM - 0.1) {
-    // The best we can do is hold hue constant.
-    return msh[2];
-  }
-
-  // This equation is designed to make the perceptual change of the
-  // interpolation to be close to constant.
-  const hueSpin = msh[1] * Math.sqrt(unsatM * unsatM - msh[0] * msh[0]) / (msh[0] * Math.sin(msh[1]));
-  // Spin hue away from 0 except in purple hues.
-  if (msh[2] > -0.3 * Math.PI) {
-    return msh[2] + hueSpin;
-  }
-  return msh[2] - hueSpin;
-}
-function vtkColorTransferFunctionAngleDiff(a1, a2) {
-  let adiff = a1 - a2;
-  if (adiff < 0.0) {
-    adiff = -adiff;
-  }
-  while (adiff >= 2.0 * Math.PI) {
-    adiff -= 2.0 * Math.PI;
-  }
-  if (adiff > Math.PI) {
-    adiff = 2.0 * Math.PI - adiff;
-  }
-  return adiff;
-}
-
-// Interpolate a diverging color map.
-function vtkColorTransferFunctionInterpolateDiverging(s, rgb1, rgb2, result) {
-  const lab1 = [];
-  const lab2 = [];
-  (0,Core_Math.N)(rgb1, lab1);
-  (0,Core_Math.N)(rgb2, lab2);
-  const msh1 = [];
-  const msh2 = [];
-  vtkColorTransferFunctionLabToMsh(lab1, msh1);
-  vtkColorTransferFunctionLabToMsh(lab2, msh2);
-
-  // If the endpoints are distinct saturated colors, then place white in between
-  // them.
-  let localS = s;
-  if (msh1[1] > 0.05 && msh2[1] > 0.05 && vtkColorTransferFunctionAngleDiff(msh1[2], msh2[2]) > 0.33 * Math.PI) {
-    // Insert the white midpoint by setting one end to white and adjusting the
-    // scalar value.
-    let Mmid = Math.max(msh1[0], msh2[0]);
-    Mmid = Math.max(88.0, Mmid);
-    if (s < 0.5) {
-      msh2[0] = Mmid;
-      msh2[1] = 0.0;
-      msh2[2] = 0.0;
-      localS *= 2.0;
-    } else {
-      msh1[0] = Mmid;
-      msh1[1] = 0.0;
-      msh1[2] = 0.0;
-      localS = 2.0 * localS - 1.0;
-    }
-  }
-
-  // If one color has no saturation, then its hue value is invalid.  In this
-  // case, we want to set it to something logical so that the interpolation of
-  // hue makes sense.
-  if (msh1[1] < 0.05 && msh2[1] > 0.05) {
-    msh1[2] = vtkColorTransferFunctionAdjustHue(msh2, msh1[0]);
-  } else if (msh2[1] < 0.05 && msh1[1] > 0.05) {
-    msh2[2] = vtkColorTransferFunctionAdjustHue(msh1, msh2[0]);
-  }
-  const mshTmp = [];
-  mshTmp[0] = (1 - localS) * msh1[0] + localS * msh2[0];
-  mshTmp[1] = (1 - localS) * msh1[1] + localS * msh2[1];
-  mshTmp[2] = (1 - localS) * msh1[2] + localS * msh2[2];
-
-  // Now convert back to RGB
-  const labTmp = [];
-  vtkColorTransferFunctionMshToLab(mshTmp, labTmp);
-  (0,Core_Math.O)(labTmp, result);
-}
-
-// ----------------------------------------------------------------------------
-// vtkColorTransferFunction methods
-// ----------------------------------------------------------------------------
-
-function vtkColorTransferFunction(publicAPI, model) {
-  // Set our className
-  model.classHierarchy.push('vtkColorTransferFunction');
-
-  // Return the number of points which specify this function
-  publicAPI.getSize = () => model.nodes.length;
-
-  //----------------------------------------------------------------------------
-  // Add a point defined in RGB
-  publicAPI.addRGBPoint = (x, r, g, b) => publicAPI.addRGBPointLong(x, r, g, b, 0.5, 0.0);
-
-  //----------------------------------------------------------------------------
-  // Add a point defined in RGB
-  publicAPI.addRGBPointLong = function (x, r, g, b) {
-    let midpoint = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0.5;
-    let sharpness = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0.0;
-    // Error check
-    if (midpoint < 0.0 || midpoint > 1.0) {
-      vtkErrorMacro('Midpoint outside range [0.0, 1.0]');
-      return -1;
-    }
-    if (sharpness < 0.0 || sharpness > 1.0) {
-      vtkErrorMacro('Sharpness outside range [0.0, 1.0]');
-      return -1;
-    }
-
-    // remove any node already at this X location
-    if (!model.allowDuplicateScalars) {
-      publicAPI.removePoint(x);
-    }
-
-    // Create the new node
-    const node = {
-      x,
-      r,
-      g,
-      b,
-      midpoint,
-      sharpness
-    };
-
-    // Add it, then sort to get everything in order
-    model.nodes.push(node);
-    publicAPI.sortAndUpdateRange();
-
-    // We need to find the index of the node we just added in order
-    // to return this value
-    let i = 0;
-    for (; i < model.nodes.length; i++) {
-      if (model.nodes[i].x === x) {
-        break;
-      }
-    }
-
-    // If we didn't find it, something went horribly wrong so
-    // return -1
-    if (i < model.nodes.length) {
-      return i;
-    }
-    return -1;
-  };
-
-  //----------------------------------------------------------------------------
-  // Add a point defined in HSV
-  publicAPI.addHSVPoint = (x, h, s, v) => publicAPI.addHSVPointLong(x, h, s, v, 0.5, 0.0);
-
-  //----------------------------------------------------------------------------
-  // Add a point defined in HSV
-  publicAPI.addHSVPointLong = function (x, h, s, v) {
-    let midpoint = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0.5;
-    let sharpness = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0.0;
-    const rgb = [];
-    const hsv = [h, s, v];
-    (0,Core_Math.h)(hsv, rgb);
-    return publicAPI.addRGBPoint(x, rgb[0], rgb[1], rgb[2], midpoint, sharpness);
-  };
-
-  //----------------------------------------------------------------------------
-  // Set nodes directly
-  publicAPI.setNodes = nodes => {
-    if (model.nodes !== nodes) {
-      const before = JSON.stringify(model.nodes);
-      model.nodes = nodes;
-      const after = JSON.stringify(model.nodes);
-      if (publicAPI.sortAndUpdateRange() || before !== after) {
-        publicAPI.modified();
-        return true;
-      }
-    }
-    return false;
-  };
-
-  //----------------------------------------------------------------------------
-  // Sort the vector in increasing order, then fill in
-  // the Range
-  publicAPI.sortAndUpdateRange = () => {
-    const before = JSON.stringify(model.nodes);
-    model.nodes.sort((a, b) => a.x - b.x);
-    const after = JSON.stringify(model.nodes);
-    const modifiedInvoked = publicAPI.updateRange();
-    // If range is updated, Modified() has been called, don't call it again.
-    if (!modifiedInvoked && before !== after) {
-      publicAPI.modified();
-      return true;
-    }
-    return modifiedInvoked;
-  };
-
-  //----------------------------------------------------------------------------
-  publicAPI.updateRange = () => {
-    const oldRange = [2];
-    oldRange[0] = model.mappingRange[0];
-    oldRange[1] = model.mappingRange[1];
-    const size = model.nodes.length;
-    if (size) {
-      model.mappingRange[0] = model.nodes[0].x;
-      model.mappingRange[1] = model.nodes[size - 1].x;
-    } else {
-      model.mappingRange[0] = 0;
-      model.mappingRange[1] = 0;
-    }
-
-    // If the range is the same, then no need to call Modified()
-    if (oldRange[0] === model.mappingRange[0] && oldRange[1] === model.mappingRange[1]) {
-      return false;
-    }
-    publicAPI.modified();
-    return true;
-  };
-
-  //----------------------------------------------------------------------------
-  // Remove a point
-  publicAPI.removePoint = x => {
-    // First find the node since we need to know its
-    // index as our return value
-    let i = 0;
-    for (; i < model.nodes.length; i++) {
-      if (model.nodes[i].x === x) {
-        break;
-      }
-    }
-    const retVal = i;
-
-    // If the node doesn't exist, we return -1
-    if (i >= model.nodes.length) {
-      return -1;
-    }
-
-    // If the first or last point has been removed, then we update the range
-    // No need to sort here as the order of points hasn't changed.
-    let modifiedInvoked = false;
-    model.nodes.splice(i, 1);
-    if (i === 0 || i === model.nodes.length) {
-      modifiedInvoked = publicAPI.updateRange();
-    }
-    if (!modifiedInvoked) {
-      publicAPI.modified();
-    }
-    return retVal;
-  };
-
-  //----------------------------------------------------------------------------
-  publicAPI.movePoint = (oldX, newX) => {
-    if (oldX === newX) {
-      // Nothing to do.
-      return;
-    }
-    publicAPI.removePoint(newX);
-    for (let i = 0; i < model.nodes.length; i++) {
-      if (model.nodes[i].x === oldX) {
-        model.nodes[i].x = newX;
-        publicAPI.sortAndUpdateRange();
-        break;
-      }
-    }
-  };
-
-  //----------------------------------------------------------------------------
-  // Remove all points
-  publicAPI.removeAllPoints = () => {
-    model.nodes = [];
-    publicAPI.sortAndUpdateRange();
-  };
-
-  //----------------------------------------------------------------------------
-  // Add a line defined in RGB
-  publicAPI.addRGBSegment = (x1, r1, g1, b1, x2, r2, g2, b2) => {
-    // First, find all points in this range and remove them
-    publicAPI.sortAndUpdateRange();
-    for (let i = 0; i < model.nodes.length;) {
-      if (model.nodes[i].x >= x1 && model.nodes[i].x <= x2) {
-        model.nodes.splice(i, 1);
-      } else {
-        i++;
-      }
-    }
-
-    // Now add the points
-    publicAPI.addRGBPointLong(x1, r1, g1, b1, 0.5, 0.0);
-    publicAPI.addRGBPointLong(x2, r2, g2, b2, 0.5, 0.0);
-    publicAPI.modified();
-  };
-
-  //----------------------------------------------------------------------------
-  // Add a line defined in HSV
-  publicAPI.addHSVSegment = (x1, h1, s1, v1, x2, h2, s2, v2) => {
-    const hsv1 = [h1, s1, v1];
-    const hsv2 = [h2, s2, v2];
-    const rgb1 = [];
-    const rgb2 = [];
-    (0,Core_Math.h)(hsv1, rgb1);
-    (0,Core_Math.h)(hsv2, rgb2);
-    publicAPI.addRGBSegment(x1, rgb1[0], rgb1[1], rgb1[2], x2, rgb2[0], rgb2[1], rgb2[2]);
-  };
-
-  //----------------------------------------------------------------------------
-  // Returns the RGBA color evaluated at the specified location
-  publicAPI.mapValue = x => {
-    const rgb = [];
-    publicAPI.getColor(x, rgb);
-    return [Math.floor(255.0 * rgb[0] + 0.5), Math.floor(255.0 * rgb[1] + 0.5), Math.floor(255.0 * rgb[2] + 0.5), 255];
-  };
-
-  //----------------------------------------------------------------------------
-  // Returns the RGB color evaluated at the specified location
-  publicAPI.getColor = (x, rgb) => {
-    if (model.indexedLookup) {
-      const numNodes = publicAPI.getSize();
-      // todo
-      const idx = publicAPI.getAnnotatedValueIndexInternal(x);
-      if (idx < 0 || numNodes === 0) {
-        const nanColor = publicAPI.getNanColorByReference();
-        rgb[0] = nanColor[0];
-        rgb[1] = nanColor[1];
-        rgb[2] = nanColor[2];
-      } else {
-        const nodeVal = [];
-        publicAPI.getNodeValue(idx % numNodes, nodeVal);
-        // nodeVal[0] is the x value. nodeVal[1...3] is rgb.
-        rgb[0] = nodeVal[1];
-        rgb[1] = nodeVal[2];
-        rgb[2] = nodeVal[3];
-      }
-      return;
-    }
-    publicAPI.getTable(x, x, 1, rgb);
-  };
-
-  //----------------------------------------------------------------------------
-  // Returns the red color evaluated at the specified location
-  publicAPI.getRedValue = x => {
-    const rgb = [];
-    publicAPI.getColor(x, rgb);
-    return rgb[0];
-  };
-
-  //----------------------------------------------------------------------------
-  // Returns the green color evaluated at the specified location
-  publicAPI.getGreenValue = x => {
-    const rgb = [];
-    publicAPI.getColor(x, rgb);
-    return rgb[1];
-  };
-
-  //----------------------------------------------------------------------------
-  // Returns the blue color evaluated at the specified location
-  publicAPI.getBlueValue = x => {
-    const rgb = [];
-    publicAPI.getColor(x, rgb);
-    return rgb[2];
-  };
-
-  //----------------------------------------------------------------------------
-  // Returns a table of RGB colors at regular intervals along the function
-  publicAPI.getTable = (xStart_, xEnd_, size, table) => {
-    // To handle BigInt limitation
-    const xStart = Number(xStart_);
-    const xEnd = Number(xEnd_);
-
-    // Special case: If either the start or end is a NaN, then all any
-    // interpolation done on them is also a NaN.  Therefore, fill the table with
-    // the NaN color.
-    if ((0,Core_Math.i)(xStart) || (0,Core_Math.i)(xEnd)) {
-      for (let i = 0; i < size; i++) {
-        table[i * 3 + 0] = model.nanColor[0];
-        table[i * 3 + 1] = model.nanColor[1];
-        table[i * 3 + 2] = model.nanColor[2];
-      }
-      return;
-    }
-    let idx = 0;
-    const numNodes = model.nodes.length;
-
-    // Need to keep track of the last value so that
-    // we can fill in table locations past this with
-    // this value if Clamping is On.
-    let lastR = 0.0;
-    let lastG = 0.0;
-    let lastB = 0.0;
-    if (numNodes !== 0) {
-      lastR = model.nodes[numNodes - 1].r;
-      lastG = model.nodes[numNodes - 1].g;
-      lastB = model.nodes[numNodes - 1].b;
-    }
-    let x = 0.0;
-    let x1 = 0.0;
-    let x2 = 0.0;
-    const rgb1 = [0.0, 0.0, 0.0];
-    const rgb2 = [0.0, 0.0, 0.0];
-    let midpoint = 0.0;
-    let sharpness = 0.0;
-    const tmpVec = [];
-
-    // If the scale is logarithmic, make sure the range is valid.
-    let usingLogScale = model.scale === ColorTransferFunction_Scale.LOG10;
-    if (usingLogScale) {
-      // Note: This requires range[0] <= range[1].
-      usingLogScale = model.mappingRange[0] > 0.0;
-    }
-    let logStart = 0.0;
-    let logEnd = 0.0;
-    let logX = 0.0;
-    if (usingLogScale) {
-      logStart = Math.log10(xStart);
-      logEnd = Math.log10(xEnd);
-    }
-
-    // For each table entry
-    for (let i = 0; i < size; i++) {
-      // Find our location in the table
-      const tidx = 3 * i;
-
-      // Find our X location. If we are taking only 1 sample, make
-      // it halfway between start and end (usually start and end will
-      // be the same in this case)
-      if (size > 1) {
-        if (usingLogScale) {
-          logX = logStart + i / (size - 1.0) * (logEnd - logStart);
-          x = 10.0 ** logX;
-        } else {
-          x = xStart + i / (size - 1.0) * (xEnd - xStart);
-        }
-      } else if (usingLogScale) {
-        logX = 0.5 * (logStart + logEnd);
-        x = 10.0 ** logX;
-      } else {
-        x = 0.5 * (xStart + xEnd);
-      }
-
-      // Linearly map x from mappingRange to [0, numberOfValues-1],
-      // discretize (round down to the closest integer),
-      // then map back to mappingRange
-      if (model.discretize) {
-        const range = model.mappingRange;
-        if (x >= range[0] && x <= range[1]) {
-          const numberOfValues = model.numberOfValues;
-          const deltaRange = range[1] - range[0];
-          if (numberOfValues <= 1) {
-            x = range[0] + deltaRange / 2.0;
-          } else {
-            // normalize x
-            const xn = (x - range[0]) / deltaRange;
-            // discretize
-            const discretizeIndex = (0,Core_Math.K)(numberOfValues * xn);
-            // get discretized x
-            x = range[0] + discretizeIndex / (numberOfValues - 1) * deltaRange;
-          }
-        }
-      }
-
-      // Do we need to move to the next node?
-      while (idx < numNodes && x > model.nodes[idx].x) {
-        idx++;
-        // If we are at a valid point index, fill in
-        // the value at this node, and the one before (the
-        // two that surround our current sample location)
-        // idx cannot be 0 since we just incremented it.
-        if (idx < numNodes) {
-          x1 = model.nodes[idx - 1].x;
-          x2 = model.nodes[idx].x;
-          if (usingLogScale) {
-            x1 = Math.log10(x1);
-            x2 = Math.log10(x2);
-          }
-          rgb1[0] = model.nodes[idx - 1].r;
-          rgb2[0] = model.nodes[idx].r;
-          rgb1[1] = model.nodes[idx - 1].g;
-          rgb2[1] = model.nodes[idx].g;
-          rgb1[2] = model.nodes[idx - 1].b;
-          rgb2[2] = model.nodes[idx].b;
-
-          // We only need the previous midpoint and sharpness
-          // since these control this region
-          midpoint = model.nodes[idx - 1].midpoint;
-          sharpness = model.nodes[idx - 1].sharpness;
-
-          // Move midpoint away from extreme ends of range to avoid
-          // degenerate math
-          if (midpoint < 0.00001) {
-            midpoint = 0.00001;
-          }
-          if (midpoint > 0.99999) {
-            midpoint = 0.99999;
-          }
-        }
-      }
-
-      // Are we at or past the end? If so, just use the last value
-      if (x > model.mappingRange[1]) {
-        table[tidx] = 0.0;
-        table[tidx + 1] = 0.0;
-        table[tidx + 2] = 0.0;
-        if (model.clamping) {
-          if (publicAPI.getUseAboveRangeColor()) {
-            table[tidx] = model.aboveRangeColor[0];
-            table[tidx + 1] = model.aboveRangeColor[1];
-            table[tidx + 2] = model.aboveRangeColor[2];
-          } else {
-            table[tidx] = lastR;
-            table[tidx + 1] = lastG;
-            table[tidx + 2] = lastB;
-          }
-        }
-      } else if (x < model.mappingRange[0] || (0,Core_Math.L)(x) && x < 0) {
-        // we are before the first node? If so, duplicate this node's values.
-        // We have to deal with -inf here
-        table[tidx] = 0.0;
-        table[tidx + 1] = 0.0;
-        table[tidx + 2] = 0.0;
-        if (model.clamping) {
-          if (publicAPI.getUseBelowRangeColor()) {
-            table[tidx] = model.belowRangeColor[0];
-            table[tidx + 1] = model.belowRangeColor[1];
-            table[tidx + 2] = model.belowRangeColor[2];
-          } else if (numNodes > 0) {
-            table[tidx] = model.nodes[0].r;
-            table[tidx + 1] = model.nodes[0].g;
-            table[tidx + 2] = model.nodes[0].b;
-          }
-        }
-      } else if (idx === 0 && (Math.abs(x - xStart) < 1e-6 || model.discretize)) {
-        if (numNodes > 0) {
-          table[tidx] = model.nodes[0].r;
-          table[tidx + 1] = model.nodes[0].g;
-          table[tidx + 2] = model.nodes[0].b;
-        } else {
-          table[tidx] = 0.0;
-          table[tidx + 1] = 0.0;
-          table[tidx + 2] = 0.0;
-        }
-      } else {
-        // OK, we are between two nodes - interpolate
-        // Our first attempt at a normalized location [0,1] -
-        // we will be modifying this based on midpoint and
-        // sharpness to get the curve shape we want and to have
-        // it pass through (y1+y2)/2 at the midpoint.
-        let s = 0.0;
-        if (usingLogScale) {
-          s = (logX - x1) / (x2 - x1);
-        } else {
-          s = (x - x1) / (x2 - x1);
-        }
-
-        // Readjust based on the midpoint - linear adjustment
-        if (s < midpoint) {
-          s = 0.5 * s / midpoint;
-        } else {
-          s = 0.5 + 0.5 * (s - midpoint) / (1.0 - midpoint);
-        }
-
-        // override for sharpness > 0.99
-        // In this case we just want piecewise constant
-        if (sharpness > 0.99) {
-          // Use the first value since we are below the midpoint
-          if (s < 0.5) {
-            table[tidx] = rgb1[0];
-            table[tidx + 1] = rgb1[1];
-            table[tidx + 2] = rgb1[2];
-            continue;
-          } else {
-            // Use the second value at or above the midpoint
-            table[tidx] = rgb2[0];
-            table[tidx + 1] = rgb2[1];
-            table[tidx + 2] = rgb2[2];
-            continue;
-          }
-        }
-
-        // Override for sharpness < 0.01
-        // In this case we want piecewise linear
-        if (sharpness < 0.01) {
-          // Simple linear interpolation
-          if (model.colorSpace === ColorTransferFunction_ColorSpace.RGB) {
-            table[tidx] = (1 - s) * rgb1[0] + s * rgb2[0];
-            table[tidx + 1] = (1 - s) * rgb1[1] + s * rgb2[1];
-            table[tidx + 2] = (1 - s) * rgb1[2] + s * rgb2[2];
-          } else if (model.colorSpace === ColorTransferFunction_ColorSpace.HSV) {
-            const hsv1 = [];
-            const hsv2 = [];
-            (0,Core_Math.M)(rgb1, hsv1);
-            (0,Core_Math.M)(rgb2, hsv2);
-            if (model.hSVWrap && (hsv1[0] - hsv2[0] > 0.5 || hsv2[0] - hsv1[0] > 0.5)) {
-              if (hsv1[0] > hsv2[0]) {
-                hsv1[0] -= 1.0;
-              } else {
-                hsv2[0] -= 1.0;
-              }
-            }
-            const hsvTmp = [];
-            hsvTmp[0] = (1.0 - s) * hsv1[0] + s * hsv2[0];
-            if (hsvTmp[0] < 0.0) {
-              hsvTmp[0] += 1.0;
-            }
-            hsvTmp[1] = (1.0 - s) * hsv1[1] + s * hsv2[1];
-            hsvTmp[2] = (1.0 - s) * hsv1[2] + s * hsv2[2];
-
-            // Now convert this back to RGB
-            (0,Core_Math.h)(hsvTmp, tmpVec);
-            table[tidx] = tmpVec[0];
-            table[tidx + 1] = tmpVec[1];
-            table[tidx + 2] = tmpVec[2];
-          } else if (model.colorSpace === ColorTransferFunction_ColorSpace.LAB) {
-            const lab1 = [];
-            const lab2 = [];
-            (0,Core_Math.N)(rgb1, lab1);
-            (0,Core_Math.N)(rgb2, lab2);
-            const labTmp = [];
-            labTmp[0] = (1 - s) * lab1[0] + s * lab2[0];
-            labTmp[1] = (1 - s) * lab1[1] + s * lab2[1];
-            labTmp[2] = (1 - s) * lab1[2] + s * lab2[2];
-
-            // Now convert back to RGB
-            (0,Core_Math.O)(labTmp, tmpVec);
-            table[tidx] = tmpVec[0];
-            table[tidx + 1] = tmpVec[1];
-            table[tidx + 2] = tmpVec[2];
-          } else if (model.colorSpace === ColorTransferFunction_ColorSpace.DIVERGING) {
-            vtkColorTransferFunctionInterpolateDiverging(s, rgb1, rgb2, tmpVec);
-            table[tidx] = tmpVec[0];
-            table[tidx + 1] = tmpVec[1];
-            table[tidx + 2] = tmpVec[2];
-          } else {
-            vtkErrorMacro('ColorSpace set to invalid value.', model.colorSpace);
-          }
-          continue;
-        }
-
-        // We have a sharpness between [0.01, 0.99] - we will
-        // used a modified hermite curve interpolation where we
-        // derive the slope based on the sharpness, and we compress
-        // the curve non-linearly based on the sharpness
-
-        // First, we will adjust our position based on sharpness in
-        // order to make the curve sharper (closer to piecewise constant)
-        if (s < 0.5) {
-          s = 0.5 * (s * 2.0) ** (1.0 + 10.0 * sharpness);
-        } else if (s > 0.5) {
-          s = 1.0 - 0.5 * ((1.0 - s) * 2) ** (1 + 10.0 * sharpness);
-        }
-
-        // Compute some coefficients we will need for the hermite curve
-        const ss = s * s;
-        const sss = ss * s;
-        const h1 = 2.0 * sss - 3 * ss + 1;
-        const h2 = -2 * sss + 3 * ss;
-        const h3 = sss - 2 * ss + s;
-        const h4 = sss - ss;
-        let slope;
-        let t;
-        if (model.colorSpace === ColorTransferFunction_ColorSpace.RGB) {
-          for (let j = 0; j < 3; j++) {
-            // Use one slope for both end points
-            slope = rgb2[j] - rgb1[j];
-            t = (1.0 - sharpness) * slope;
-
-            // Compute the value
-            table[tidx + j] = h1 * rgb1[j] + h2 * rgb2[j] + h3 * t + h4 * t;
-          }
-        } else if (model.colorSpace === ColorTransferFunction_ColorSpace.HSV) {
-          const hsv1 = [];
-          const hsv2 = [];
-          (0,Core_Math.M)(rgb1, hsv1);
-          (0,Core_Math.M)(rgb2, hsv2);
-          if (model.hSVWrap && (hsv1[0] - hsv2[0] > 0.5 || hsv2[0] - hsv1[0] > 0.5)) {
-            if (hsv1[0] > hsv2[0]) {
-              hsv1[0] -= 1.0;
-            } else {
-              hsv2[0] -= 1.0;
-            }
-          }
-          const hsvTmp = [];
-          for (let j = 0; j < 3; j++) {
-            // Use one slope for both end points
-            slope = hsv2[j] - hsv1[j];
-            t = (1.0 - sharpness) * slope;
-
-            // Compute the value
-            hsvTmp[j] = h1 * hsv1[j] + h2 * hsv2[j] + h3 * t + h4 * t;
-            if (j === 0 && hsvTmp[j] < 0.0) {
-              hsvTmp[j] += 1.0;
-            }
-          }
-          // Now convert this back to RGB
-          (0,Core_Math.h)(hsvTmp, tmpVec);
-          table[tidx] = tmpVec[0];
-          table[tidx + 1] = tmpVec[1];
-          table[tidx + 2] = tmpVec[2];
-        } else if (model.colorSpace === ColorTransferFunction_ColorSpace.LAB) {
-          const lab1 = [];
-          const lab2 = [];
-          (0,Core_Math.N)(rgb1, lab1);
-          (0,Core_Math.N)(rgb2, lab2);
-          const labTmp = [];
-          for (let j = 0; j < 3; j++) {
-            // Use one slope for both end points
-            slope = lab2[j] - lab1[j];
-            t = (1.0 - sharpness) * slope;
-
-            // Compute the value
-            labTmp[j] = h1 * lab1[j] + h2 * lab2[j] + h3 * t + h4 * t;
-          }
-          // Now convert this back to RGB
-          (0,Core_Math.O)(labTmp, tmpVec);
-          table[tidx] = tmpVec[0];
-          table[tidx + 1] = tmpVec[1];
-          table[tidx + 2] = tmpVec[2];
-        } else if (model.colorSpace === ColorTransferFunction_ColorSpace.DIVERGING) {
-          // I have not implemented proper interpolation by a hermite curve for
-          // the diverging color map, but I cannot think of a good use case for
-          // that anyway.
-          vtkColorTransferFunctionInterpolateDiverging(s, rgb1, rgb2, tmpVec);
-          table[tidx] = tmpVec[0];
-          table[tidx + 1] = tmpVec[1];
-          table[tidx + 2] = tmpVec[2];
-        } else {
-          vtkErrorMacro('ColorSpace set to invalid value.');
-        }
-
-        // Final error check to make sure we don't go outside [0,1]
-        for (let j = 0; j < 3; j++) {
-          table[tidx + j] = table[tidx + j] < 0.0 ? 0.0 : table[tidx + j];
-          table[tidx + j] = table[tidx + j] > 1.0 ? 1.0 : table[tidx + j];
-        }
-      }
-    }
-  };
-
-  //----------------------------------------------------------------------------
-  publicAPI.getUint8Table = function (xStart, xEnd, size) {
-    let withAlpha = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-    if (publicAPI.getMTime() <= model.buildTime && model.tableSize === size && model.tableWithAlpha !== withAlpha) {
-      return model.table;
-    }
-    if (model.nodes.length === 0) {
-      vtkErrorMacro('Attempting to lookup a value with no points in the function');
-      return model.table;
-    }
-    const nbChannels = withAlpha ? 4 : 3;
-    if (model.tableSize !== size || model.tableWithAlpha !== withAlpha) {
-      model.table = new Uint8Array(size * nbChannels);
-      model.tableSize = size;
-      model.tableWithAlpha = withAlpha;
-    }
-    const tmpTable = [];
-    publicAPI.getTable(xStart, xEnd, size, tmpTable);
-    for (let i = 0; i < size; i++) {
-      model.table[i * nbChannels + 0] = Math.floor(tmpTable[i * 3 + 0] * 255.0 + 0.5);
-      model.table[i * nbChannels + 1] = Math.floor(tmpTable[i * 3 + 1] * 255.0 + 0.5);
-      model.table[i * nbChannels + 2] = Math.floor(tmpTable[i * 3 + 2] * 255.0 + 0.5);
-      if (withAlpha) {
-        model.table[i * nbChannels + 3] = 255;
-      }
-    }
-    model.buildTime.modified();
-    return model.table;
-  };
-  publicAPI.buildFunctionFromArray = array => {
-    publicAPI.removeAllPoints();
-    const numComponents = array.getNumberOfComponents();
-    for (let i = 0; i < array.getNumberOfTuples(); i++) {
-      switch (numComponents) {
-        case 3:
-          {
-            model.nodes.push({
-              x: i,
-              r: array.getComponent(i, 0),
-              g: array.getComponent(i, 1),
-              b: array.getComponent(i, 2),
-              midpoint: 0.5,
-              sharpness: 0.0
-            });
-            break;
-          }
-        case 4:
-          {
-            model.nodes.push({
-              x: array.getComponent(i, 0),
-              r: array.getComponent(i, 1),
-              g: array.getComponent(i, 2),
-              b: array.getComponent(i, 3),
-              midpoint: 0.5,
-              sharpness: 0.0
-            });
-            break;
-          }
-        case 5:
-          {
-            model.nodes.push({
-              x: i,
-              r: array.getComponent(i, 0),
-              g: array.getComponent(i, 1),
-              b: array.getComponent(i, 2),
-              midpoint: array.getComponent(i, 4),
-              sharpness: array.getComponent(i, 5)
-            });
-            break;
-          }
-        case 6:
-          {
-            model.nodes.push({
-              x: array.getComponent(i, 0),
-              r: array.getComponent(i, 1),
-              g: array.getComponent(i, 2),
-              b: array.getComponent(i, 3),
-              midpoint: array.getComponent(i, 4),
-              sharpness: array.getComponent(i, 5)
-            });
-            break;
-          }
-      }
-    }
-    publicAPI.sortAndUpdateRange();
-  };
-
-  //----------------------------------------------------------------------------
-  publicAPI.buildFunctionFromTable = (xStart, xEnd, size, table) => {
-    let inc = 0.0;
-    publicAPI.removeAllPoints();
-    if (size > 1) {
-      inc = (xEnd - xStart) / (size - 1.0);
-    }
-    for (let i = 0; i < size; i++) {
-      const node = {
-        x: xStart + inc * i,
-        r: table[i * 3],
-        g: table[i * 3 + 1],
-        b: table[i * 3 + 2],
-        sharpness: 0.0,
-        midpoint: 0.5
-      };
-      model.nodes.push(node);
-    }
-    publicAPI.sortAndUpdateRange();
-  };
-
-  //----------------------------------------------------------------------------
-  // For a specified index value, get the node parameters
-  publicAPI.getNodeValue = (index, val) => {
-    if (index < 0 || index >= model.nodes.length) {
-      vtkErrorMacro('Index out of range!');
-      return -1;
-    }
-    val[0] = model.nodes[index].x;
-    val[1] = model.nodes[index].r;
-    val[2] = model.nodes[index].g;
-    val[3] = model.nodes[index].b;
-    val[4] = model.nodes[index].midpoint;
-    val[5] = model.nodes[index].sharpness;
-    return 1;
-  };
-
-  //----------------------------------------------------------------------------
-  // For a specified index value, get the node parameters
-  publicAPI.setNodeValue = (index, val) => {
-    if (index < 0 || index >= model.nodes.length) {
-      vtkErrorMacro('Index out of range!');
-      return -1;
-    }
-    const oldX = model.nodes[index].x;
-    model.nodes[index].x = val[0];
-    model.nodes[index].r = val[1];
-    model.nodes[index].g = val[2];
-    model.nodes[index].b = val[3];
-    model.nodes[index].midpoint = val[4];
-    model.nodes[index].sharpness = val[5];
-    if (oldX !== val[0]) {
-      // The point has been moved, the order of points or the range might have
-      // been modified.
-      publicAPI.sortAndUpdateRange();
-      // No need to call Modified() here because SortAndUpdateRange() has done it
-      // already.
-    } else {
-      publicAPI.modified();
-    }
-    return 1;
-  };
-
-  //----------------------------------------------------------------------------
-  publicAPI.getNumberOfAvailableColors = () => {
-    if (model.indexedLookup && publicAPI.getSize()) {
-      return publicAPI.getSize();
-    }
-    if (model.tableSize) {
-      // Not sure if this is correct since it is only set if
-      // "const unsigned char *::GetTable(double xStart, double xEnd,int size)"
-      // has been called.
-      return model.tableSize;
-    }
-    const nNodes = model.nodes?.length ?? 0;
-    // The minimum is 4094 colors so that it fills in the 4096 texels texture in `mapScalarsToTexture`
-    return Math.max(4094, nNodes);
-  };
-
-  //----------------------------------------------------------------------------
-  publicAPI.getIndexedColor = (idx, rgba) => {
-    const n = publicAPI.getSize();
-    if (n > 0 && idx >= 0) {
-      const nodeValue = [];
-      publicAPI.getNodeValue(idx % n, nodeValue);
-      for (let j = 0; j < 3; ++j) {
-        rgba[j] = nodeValue[j + 1];
-      }
-      rgba[3] = 1.0; // NodeColor is RGB-only.
-      return;
-    }
-    const nanColor = publicAPI.getNanColorByReference();
-    rgba[0] = nanColor[0];
-    rgba[1] = nanColor[1];
-    rgba[2] = nanColor[2];
-    rgba[3] = 1.0; // NanColor is RGB-only.
-  };
-
-  //----------------------------------------------------------------------------
-  publicAPI.fillFromDataPointer = (nb, ptr) => {
-    if (nb <= 0 || !ptr) {
-      return;
-    }
-    publicAPI.removeAllPoints();
-    for (let i = 0; i < nb; i++) {
-      publicAPI.addRGBPoint(ptr[i * 4], ptr[i * 4 + 1], ptr[i * 4 + 2], ptr[i * 4 + 3]);
-    }
-  };
-
-  //----------------------------------------------------------------------------
-  publicAPI.setMappingRange = (min, max) => {
-    const range = [min, max];
-    const originalRange = publicAPI.getRange();
-    if (originalRange[1] === range[1] && originalRange[0] === range[0]) {
-      return;
-    }
-    if (range[1] === range[0]) {
-      vtkErrorMacro('attempt to set zero width color range');
-      return;
-    }
-    const scale = (range[1] - range[0]) / (originalRange[1] - originalRange[0]);
-    const shift = range[0] - originalRange[0] * scale;
-    for (let i = 0; i < model.nodes.length; ++i) {
-      model.nodes[i].x = model.nodes[i].x * scale + shift;
-    }
-    model.mappingRange[0] = range[0];
-    model.mappingRange[1] = range[1];
-    publicAPI.modified();
-  };
-
-  //----------------------------------------------------------------------------
-  publicAPI.adjustRange = range => {
-    const functionRange = publicAPI.getRange();
-
-    // Make sure we have points at each end of the range
-    const rgb = [];
-    if (functionRange[0] < range[0]) {
-      publicAPI.getColor(range[0], rgb);
-      publicAPI.addRGBPoint(range[0], rgb[0], rgb[1], rgb[2]);
-    } else {
-      publicAPI.getColor(functionRange[0], rgb);
-      publicAPI.addRGBPoint(range[0], rgb[0], rgb[1], rgb[2]);
-    }
-    if (functionRange[1] > range[1]) {
-      publicAPI.getColor(range[1], rgb);
-      publicAPI.addRGBPoint(range[1], rgb[0], rgb[1], rgb[2]);
-    } else {
-      publicAPI.getColor(functionRange[1], rgb);
-      publicAPI.addRGBPoint(range[1], rgb[0], rgb[1], rgb[2]);
-    }
-
-    // Remove all points out-of-range
-    publicAPI.sortAndUpdateRange();
-    for (let i = 0; i < model.nodes.length;) {
-      if (model.nodes[i].x >= range[0] && model.nodes[i].x <= range[1]) {
-        model.nodes.splice(i, 1);
-      } else {
-        ++i;
-      }
-    }
-    return 1;
-  };
-
-  //--------------------------------------------------------------------------
-  publicAPI.estimateMinNumberOfSamples = (x1, x2) => {
-    const d = publicAPI.findMinimumXDistance();
-    return Math.ceil((x2 - x1) / d);
-  };
-
-  //----------------------------------------------------------------------------
-  publicAPI.findMinimumXDistance = () => {
-    if (model.nodes.length < 2) {
-      return -1.0;
-    }
-    let distance = Number.MAX_VALUE;
-    for (let i = 0; i < model.nodes.length - 1; i++) {
-      const currentDist = model.nodes[i + 1].x - model.nodes[i].x;
-      if (currentDist < distance) {
-        distance = currentDist;
-      }
-    }
-    return distance;
-  };
-  publicAPI.mapScalarsThroughTable = (input, output, outFormat, inputOffset) => {
-    if (publicAPI.getSize() === 0) {
-      vtkDebugMacro('Transfer Function Has No Points!');
-      return;
-    }
-    if (model.indexedLookup) {
-      publicAPI.mapDataIndexed(input, output, outFormat, inputOffset);
-    } else {
-      publicAPI.mapData(input, output, outFormat, inputOffset);
-    }
-  };
-
-  //----------------------------------------------------------------------------
-  publicAPI.mapData = (input, output, outFormat, inputOffset) => {
-    if (publicAPI.getSize() === 0) {
-      vtkWarningMacro('Transfer Function Has No Points!');
-      return;
-    }
-    const alpha = Math.floor(publicAPI.getAlpha() * 255.0 + 0.5);
-    const length = input.getNumberOfTuples();
-    const inIncr = input.getNumberOfComponents();
-    const outputV = output.getData();
-    const inputV = input.getData();
-    const rgb = [];
-    if (outFormat === ScalarMappingTarget.RGBA) {
-      for (let i = 0; i < length; i++) {
-        const x = inputV[i * inIncr + inputOffset];
-        publicAPI.getColor(x, rgb);
-        outputV[i * 4] = Math.floor(rgb[0] * 255.0 + 0.5);
-        outputV[i * 4 + 1] = Math.floor(rgb[1] * 255.0 + 0.5);
-        outputV[i * 4 + 2] = Math.floor(rgb[2] * 255.0 + 0.5);
-        outputV[i * 4 + 3] = alpha;
-      }
-    }
-    if (outFormat === ScalarMappingTarget.RGB) {
-      for (let i = 0; i < length; i++) {
-        const x = inputV[i * inIncr + inputOffset];
-        publicAPI.getColor(x, rgb);
-        outputV[i * 3] = Math.floor(rgb[0] * 255.0 + 0.5);
-        outputV[i * 3 + 1] = Math.floor(rgb[1] * 255.0 + 0.5);
-        outputV[i * 3 + 2] = Math.floor(rgb[2] * 255.0 + 0.5);
-      }
-    }
-    if (outFormat === ScalarMappingTarget.LUMINANCE) {
-      for (let i = 0; i < length; i++) {
-        const x = inputV[i * inIncr + inputOffset];
-        publicAPI.getColor(x, rgb);
-        outputV[i] = Math.floor(rgb[0] * 76.5 + rgb[1] * 150.45 + rgb[2] * 28.05 + 0.5);
-      }
-    }
-    if (outFormat === ScalarMappingTarget.LUMINANCE_ALPHA) {
-      for (let i = 0; i < length; i++) {
-        const x = inputV[i * inIncr + inputOffset];
-        publicAPI.getColor(x, rgb);
-        outputV[i * 2] = Math.floor(rgb[0] * 76.5 + rgb[1] * 150.45 + rgb[2] * 28.05 + 0.5);
-        outputV[i * 2 + 1] = alpha;
-      }
-    }
-  };
-
-  //----------------------------------------------------------------------------
-  publicAPI.applyColorMap = colorMap => {
-    const oldColorSpace = JSON.stringify(model.colorSpace);
-    if (colorMap.ColorSpace) {
-      model.colorSpace = ColorTransferFunction_ColorSpace[colorMap.ColorSpace.toUpperCase()];
-      if (model.colorSpace === undefined) {
-        vtkErrorMacro(`ColorSpace ${colorMap.ColorSpace} not supported, using RGB instead`);
-        model.colorSpace = ColorTransferFunction_ColorSpace.RGB;
-      }
-    }
-    let isModified = oldColorSpace !== JSON.stringify(model.colorSpace);
-    const oldNanColor = isModified || JSON.stringify(model.nanColor);
-    if (colorMap.NanColor) {
-      model.nanColor = [].concat(colorMap.NanColor);
-      while (model.nanColor.length < 4) {
-        model.nanColor.push(1.0);
-      }
-    }
-    isModified = isModified || oldNanColor !== JSON.stringify(model.nanColor);
-    const oldNodes = isModified || JSON.stringify(model.nodes);
-    if (colorMap.RGBPoints) {
-      const size = colorMap.RGBPoints.length;
-      model.nodes = [];
-      const midpoint = 0.5;
-      const sharpness = 0.0;
-      for (let i = 0; i < size; i += 4) {
-        model.nodes.push({
-          x: colorMap.RGBPoints[i],
-          r: colorMap.RGBPoints[i + 1],
-          g: colorMap.RGBPoints[i + 2],
-          b: colorMap.RGBPoints[i + 3],
-          midpoint,
-          sharpness
-        });
-      }
-    }
-    const modifiedInvoked = publicAPI.sortAndUpdateRange();
-    const callModified = !modifiedInvoked && (isModified || oldNodes !== JSON.stringify(model.nodes));
-    if (callModified) publicAPI.modified();
-    return modifiedInvoked || callModified;
-  };
-}
-
-// ----------------------------------------------------------------------------
-// Object factory
-// ----------------------------------------------------------------------------
-
-const DEFAULT_VALUES = {
-  clamping: true,
-  colorSpace: ColorTransferFunction_ColorSpace.RGB,
-  hSVWrap: true,
-  scale: ColorTransferFunction_Scale.LINEAR,
-  nanColor: null,
-  belowRangeColor: null,
-  aboveRangeColor: null,
-  useAboveRangeColor: false,
-  useBelowRangeColor: false,
-  allowDuplicateScalars: false,
-  table: null,
-  tableSize: 0,
-  buildTime: null,
-  nodes: null,
-  discretize: false,
-  numberOfValues: 256
-};
-
-// ----------------------------------------------------------------------------
-
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
-
-  // Inheritance
-  ScalarsToColors/* default.extend */.Ay.extend(publicAPI, model, initialValues);
-
-  // Internal objects initialization
-  model.table = [];
-  model.nodes = [];
-  model.nanColor = [0.5, 0.0, 0.0, 1.0];
-  model.belowRangeColor = [0.0, 0.0, 0.0, 1.0];
-  model.aboveRangeColor = [1.0, 1.0, 1.0, 1.0];
-  model.buildTime = {};
-  macros2.m.obj(model.buildTime);
-
-  // Create get-only macros
-  macros2.m.get(publicAPI, model, ['buildTime', 'mappingRange']);
-
-  // Create get-set macros
-  macros2.m.setGet(publicAPI, model, ['useAboveRangeColor', 'useBelowRangeColor', 'discretize', 'numberOfValues', {
-    type: 'enum',
-    name: 'colorSpace',
-    enum: ColorTransferFunction_ColorSpace
-  }, {
-    type: 'enum',
-    name: 'scale',
-    enum: ColorTransferFunction_Scale
-  }]);
-  macros2.m.setArray(publicAPI, model, ['nanColor', 'belowRangeColor', 'aboveRangeColor'], 4);
-
-  // Create get macros for array
-  macros2.m.getArray(publicAPI, model, ['nanColor', 'belowRangeColor', 'aboveRangeColor']);
-
-  // For more macro methods, see "Sources/macros.js"
-
-  // Object specific methods
-  vtkColorTransferFunction(publicAPI, model);
-}
-
-// ----------------------------------------------------------------------------
-
-const newInstance = macros2.m.newInstance(extend, 'vtkColorTransferFunction');
-
-// ----------------------------------------------------------------------------
-
-var vtkColorTransferFunction$1 = {
-  newInstance,
-  extend,
-  ...Constants
-};
-
-
-
-
 /***/ }),
 
 /***/ 660:
@@ -69364,6 +68272,34 @@ var ColorMaps_vtkColorMaps = {
 
 
 
+/***/ }),
+
+/***/ 25128:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Ay: () => (/* binding */ Constants)
+/* harmony export */ });
+/* unused harmony exports ColorSpace, Scale */
+const ColorSpace = {
+  RGB: 0,
+  HSV: 1,
+  LAB: 2,
+  DIVERGING: 3
+};
+const Scale = {
+  LINEAR: 0,
+  LOG10: 1
+};
+var Constants = {
+  ColorSpace,
+  Scale
+};
+
+
+
+
 /***/ }),
 
 /***/ 94520: