@ohif/app 3.8.0 → 3.9.0-beta.1

package/dist/{203.bundle.3581da3a32a0b720d3a7.js → 806.bundle.50e039eb624382ee1fce.js}

@@ -1,4 +1,4 @@
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[203],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[806],{
 
 /***/ 93858:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
@@ -2511,6 +2511,128 @@ class AdvancedMagnifyViewportManager {
 
 
 
+/***/ }),
+
+/***/ 16639:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(92136);
+/* harmony import */ var _distancePointToContour__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7783);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2746);
+/* harmony import */ var _utilities_math__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(73047);
+
+
+
+
+class CircleSculptCursor {
+    constructor() {
+        this.toolInfo = {
+            toolSize: null,
+            maxToolSize: null,
+        };
+    }
+    static { this.shapeName = 'Circle'; }
+    renderShape(svgDrawingHelper, canvasLocation, options) {
+        const circleUID = '0';
+        (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_2__.drawCircle)(svgDrawingHelper, 'SculptorTool', circleUID, canvasLocation, this.toolInfo.toolSize, options);
+    }
+    pushHandles(viewport, sculptData) {
+        const { points, mouseCanvasPoint } = sculptData;
+        const pushedHandles = { first: undefined, last: undefined };
+        for (let i = 0; i < points.length; i++) {
+            const handleCanvasPoint = viewport.worldToCanvas(points[i]);
+            const distanceToHandle = _utilities_math__WEBPACK_IMPORTED_MODULE_3__.point.distanceToPoint(handleCanvasPoint, mouseCanvasPoint);
+            if (distanceToHandle > this.toolInfo.toolSize) {
+                continue;
+            }
+            this.pushOneHandle(i, distanceToHandle, sculptData);
+            if (pushedHandles.first === undefined) {
+                pushedHandles.first = i;
+                pushedHandles.last = i;
+            }
+            else {
+                pushedHandles.last = i;
+            }
+        }
+        return pushedHandles;
+    }
+    configureToolSize(evt) {
+        const toolInfo = this.toolInfo;
+        if (toolInfo.toolSize && toolInfo.maxToolSize) {
+            return;
+        }
+        const eventData = evt.detail;
+        const element = eventData.element;
+        const minDim = Math.min(element.clientWidth, element.clientHeight);
+        const maxRadius = minDim / 12;
+        toolInfo.toolSize = maxRadius;
+        toolInfo.maxToolSize = maxRadius;
+    }
+    updateToolSize(canvasCoords, viewport, activeAnnotation) {
+        const toolInfo = this.toolInfo;
+        const radius = (0,_distancePointToContour__WEBPACK_IMPORTED_MODULE_1__/* .distancePointToContour */ .X)(viewport, activeAnnotation, canvasCoords);
+        if (radius > 0) {
+            toolInfo.toolSize = Math.min(toolInfo.maxToolSize, radius);
+        }
+    }
+    getMaxSpacing(minSpacing) {
+        return Math.max(this.toolInfo.toolSize / 4, minSpacing);
+    }
+    getInsertPosition(previousIndex, nextIndex, sculptData) {
+        let insertPosition;
+        const { points, element, mouseCanvasPoint } = sculptData;
+        const toolSize = this.toolInfo.toolSize;
+        const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
+        const { viewport } = enabledElement;
+        const previousCanvasPoint = viewport.worldToCanvas(points[previousIndex]);
+        const nextCanvasPoint = viewport.worldToCanvas(points[nextIndex]);
+        const midPoint = [
+            (previousCanvasPoint[0] + nextCanvasPoint[0]) / 2.0,
+            (previousCanvasPoint[1] + nextCanvasPoint[1]) / 2.0,
+        ];
+        const distanceToMidPoint = _utilities_math__WEBPACK_IMPORTED_MODULE_3__.point.distanceToPoint(mouseCanvasPoint, midPoint);
+        if (distanceToMidPoint < toolSize) {
+            const directionUnitVector = {
+                x: (midPoint[0] - mouseCanvasPoint[0]) / distanceToMidPoint,
+                y: (midPoint[1] - mouseCanvasPoint[1]) / distanceToMidPoint,
+            };
+            insertPosition = [
+                mouseCanvasPoint[0] + toolSize * directionUnitVector.x,
+                mouseCanvasPoint[1] + toolSize * directionUnitVector.y,
+            ];
+        }
+        else {
+            insertPosition = midPoint;
+        }
+        const worldPosition = viewport.canvasToWorld(insertPosition);
+        return worldPosition;
+    }
+    pushOneHandle(i, distanceToHandle, sculptData) {
+        const { points, mousePoint } = sculptData;
+        const toolSize = this.toolInfo.toolSize;
+        const handle = points[i];
+        const directionUnitVector = {
+            x: (handle[0] - mousePoint[0]) / distanceToHandle,
+            y: (handle[1] - mousePoint[1]) / distanceToHandle,
+            z: (handle[2] - mousePoint[2]) / distanceToHandle,
+        };
+        const position = {
+            x: mousePoint[0] + toolSize * directionUnitVector.x,
+            y: mousePoint[1] + toolSize * directionUnitVector.y,
+            z: mousePoint[2] + toolSize * directionUnitVector.z,
+        };
+        handle[0] = position.x;
+        handle[1] = position.y;
+        handle[2] = position.z;
+    }
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (CircleSculptCursor);
+
+
 /***/ }),
 
 /***/ 30911:
@@ -4956,7 +5078,7 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
 const defaultContourConfig = {
     renderOutline: true,
     outlineWidthAutoGenerated: 3,
-    outlineWidthActive: 2,
+    outlineWidthActive: 1,
     outlineWidthInactive: 1,
     outlineOpacity: 1,
     outlineOpacityInactive: 0.85,
@@ -4964,7 +5086,7 @@ const defaultContourConfig = {
     outlineDashInactive: undefined,
     outlineDashAutoGenerated: '5,3',
     activeSegmentOutlineWidthDelta: 0,
-    renderFill: true,
+    renderFill: false,
     fillAlpha: 0.5,
     fillAlphaInactive: 0.3,
     fillAlphaAutoGenerated: 0.3,
@@ -4977,7 +5099,7 @@ function getDefaultContourConfig() {
 
 /***/ }),
 
-/***/ 69714:
+/***/ 57784:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -4995,21 +5117,45 @@ var SegmentationRepresentations = __webpack_require__(83946);
 var segmentationState = __webpack_require__(30322);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/store/ToolGroupManager/index.js
 var ToolGroupManager = __webpack_require__(52610);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/DataArray.js
-var DataArray = __webpack_require__(45128);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Filters/General/AppendPolyData.js
-var AppendPolyData = __webpack_require__(28136);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/Actor.js
-var Actor = __webpack_require__(48987);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/Mapper.js
-var Mapper = __webpack_require__(22745);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/index.js
+var stateManagement = __webpack_require__(95778);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Contour/removeContourFromElement.js
+
+
+function removeContourFromElement(segmentationRepresentationUID, toolGroupId, removeFromCache = false) {
+    const segmentationRepresentation = (0,segmentationState.getSegmentationRepresentationByUID)(toolGroupId, segmentationRepresentationUID);
+    const { segmentationId } = segmentationRepresentation;
+    const segmentation = (0,segmentationState.getSegmentation)(segmentationId);
+    const { annotationUIDsMap } = segmentation.representationData.CONTOUR;
+    annotationUIDsMap.forEach((annotationSet) => {
+        annotationSet.forEach((annotationUID) => {
+            (0,stateManagement/* removeAnnotation */.O8)(annotationUID);
+        });
+    });
+}
+/* harmony default export */ const Contour_removeContourFromElement = (removeContourFromElement);
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Contour/contourHandler/contourConfigCache.js
+const configCachePerSegmentationRepresentationUID = new Map();
+function getConfigCache(segmentationRepresentationUID) {
+    return configCachePerSegmentationRepresentationUID.get(segmentationRepresentationUID);
+}
+function setConfigCache(segmentationRepresentationUID, config) {
+    configCachePerSegmentationRepresentationUID.set(segmentationRepresentationUID, config);
+}
+function deleteConfigCache(segmentationRepresentationUID) {
+    configCachePerSegmentationRepresentationUID.delete(segmentationRepresentationUID);
+}
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/index.js + 31 modules
+var stateManagement_segmentation = __webpack_require__(63421);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/CellArray.js
 var CellArray = __webpack_require__(24768);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/Points.js
 var Points = __webpack_require__(18310);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 9 modules
 var PolyData = __webpack_require__(27398);
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Contour/vtkContour/utils.js
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Contour/contourHandler/utils.js
 
 
 
@@ -5040,15 +5186,15 @@ function validateGeometry(geometry) {
 }
 function getPolyData(contourSet) {
     const pointArray = [];
-    const points = Points/* default.newInstance */.Ay.newInstance();
-    const lines = CellArray/* default.newInstance */.Ay.newInstance();
+    const points = vtkPoints.newInstance();
+    const lines = vtkCellArray.newInstance();
     let pointIndex = 0;
     contourSet.getContours().forEach((contour) => {
         const pointList = contour.getPoints();
         const flatPoints = contour.getFlatPointsArray();
         const type = contour.getType();
         const pointIndexes = pointList.map((_, pointListIndex) => pointListIndex + pointIndex);
-        if (type === esm.Enums.ContourType.CLOSED_PLANAR) {
+        if (type === Enums.ContourType.CLOSED_PLANAR) {
             pointIndexes.push(pointIndexes[0]);
         }
         const linePoints = Float32Array.from(flatPoints);
@@ -5057,116 +5203,37 @@ function getPolyData(contourSet) {
         pointIndex = pointIndex + pointList.length;
     });
     points.setData(pointArray, 3);
-    const polygon = PolyData/* default.newInstance */.Ay.newInstance();
+    const polygon = vtkPolyData.newInstance();
     polygon.setPoints(points);
     polygon.setLines(lines);
     return polygon;
 }
 
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Contour/vtkContour/contourConfigCache.js
-const configCachePerSegmentationRepresentationUID = new Map();
-function getConfigCache(segmentationRepresentationUID) {
-    return configCachePerSegmentationRepresentationUID.get(segmentationRepresentationUID);
-}
-function setConfigCache(segmentationRepresentationUID, config) {
-    configCachePerSegmentationRepresentationUID.set(segmentationRepresentationUID, config);
-}
-function deleteConfigCache(segmentationRepresentationUID) {
-    configCachePerSegmentationRepresentationUID.delete(segmentationRepresentationUID);
-}
-
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Contour/vtkContour/addContourSetsToElement.js
-
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/contourSegmentation/index.js
+var contourSegmentation = __webpack_require__(7259);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Contour/contourHandler/handleContourSegmentation.js
 
 
 
 
 
 
-function addContourSetsToElement(viewport, geometryIds, contourRepresentation, contourRepresentationConfig, contourActorUID) {
-    const { segmentationRepresentationUID, segmentsHidden } = contourRepresentation;
-    const appendPolyData = AppendPolyData/* default.newInstance */.Ay.newInstance();
-    const scalarToColorMap = new Map();
-    const segmentSpecificMap = new Map();
-    geometryIds.forEach((geometryId) => {
-        const geometry = esm.cache.getGeometry(geometryId);
-        if (!geometry) {
-            console.warn(`No geometry found for geometryId ${geometryId}. Skipping render.`);
-            return;
-        }
-        const segmentIndex = geometry.data.getSegmentIndex();
-        validateGeometry(geometry);
-        const segmentSpecificConfig = getSegmentSpecificConfig(contourRepresentation, geometryId, segmentIndex);
-        const contourSet = geometry.data;
-        const polyData = getPolyData(contourSet);
-        const color = contourSet.getColor();
-        const size = polyData.getPoints().getNumberOfPoints();
-        const scalars = DataArray/* default.newInstance */.Ay.newInstance({
-            size: size * 4,
-            numberOfComponents: 4,
-            dataType: 'Uint8Array',
-        });
-        for (let i = 0; i < size; ++i) {
-            scalars.setTuple(i, [...color, 255]);
-        }
-        polyData.getPointData().setScalars(scalars);
-        if (segmentSpecificConfig) {
-            segmentSpecificMap.set(segmentIndex, segmentSpecificConfig);
-        }
-        scalarToColorMap.set(segmentIndex, [
-            ...color,
-            segmentsHidden.has(segmentIndex) ? 0 : 255,
-        ]);
-        segmentIndex === 0
-            ? appendPolyData.setInputData(polyData)
-            : appendPolyData.addInputData(polyData);
-    });
-    const polyDataOutput = appendPolyData.getOutputData();
-    const outlineWidthActive = contourRepresentationConfig.representations.CONTOUR.outlineWidthActive;
-    const mapper = Mapper/* default.newInstance */.Ay.newInstance();
-    mapper.setInputData(polyDataOutput);
-    const actor = Actor/* default.newInstance */.Ay.newInstance();
-    actor.setMapper(mapper);
-    actor.getProperty().setLineWidth(outlineWidthActive);
-    setConfigCache(segmentationRepresentationUID, Object.assign({}, getConfigCache(segmentationRepresentationUID), {
-        segmentsHidden: new Set(segmentsHidden),
-        segmentSpecificMap,
-        outlineWidthActive,
-    }));
-    actor.setForceOpaque(true);
-    viewport.addActor({
-        uid: contourActorUID,
-        actor: actor,
-    });
-    viewport.resetCamera();
-    viewport.render();
+function handleContourSegmentation(viewport, geometryIds, annotationUIDsMap, contourRepresentation, contourRepresentationConfig) {
+    const addOrUpdateFn = annotationUIDsMap.size
+        ? updateContourSets
+        : addContourSetsToElement;
+    addOrUpdateFn(viewport, geometryIds, contourRepresentation, contourRepresentationConfig);
 }
-
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Contour/vtkContour/updateVTKContourSets.js
-
-
-
-function updateVTKContourSets(viewport, geometryIds, contourRepresentation, contourRepresentationConfig, contourActorUID) {
+function updateContourSets(viewport, geometryIds, contourRepresentation, contourRepresentationConfig) {
     const { segmentationRepresentationUID, segmentsHidden } = contourRepresentation;
     const newContourConfig = contourRepresentationConfig.representations.CONTOUR;
     const cachedConfig = getConfigCache(segmentationRepresentationUID);
-    const contourSetsActor = viewport.getActor(contourActorUID);
-    if (!contourSetsActor) {
-        console.warn(`No contour actor found for actorUID ${contourActorUID}. Skipping render.`);
-        return;
-    }
-    const { actor } = contourSetsActor;
     const newOutlineWithActive = newContourConfig.outlineWidthActive;
     if (cachedConfig?.outlineWidthActive !== newOutlineWithActive) {
-        actor
-            .getProperty()
-            .setLineWidth(newOutlineWithActive);
         setConfigCache(segmentationRepresentationUID, Object.assign({}, cachedConfig, {
             outlineWidthActive: newOutlineWithActive,
         }));
     }
-    const mapper = actor.getMapper();
-    const lut = mapper.getLookupTable();
     const segmentsToSetToInvisible = [];
     const segmentsToSetToVisible = [];
     for (const segmentIndex of segmentsHidden) {
@@ -5182,12 +5249,11 @@ function updateVTKContourSets(viewport, geometryIds, contourRepresentation, cont
     const mergedInvisibleSegments = Array.from(cachedConfig.segmentsHidden)
         .filter((segmentIndex) => !segmentsToSetToVisible.includes(segmentIndex))
         .concat(segmentsToSetToInvisible);
-    const { contourSets, segmentSpecificConfigs } = geometryIds.reduce((acc, geometryId) => {
+    const { segmentSpecificConfigs } = geometryIds.reduce((acc, geometryId) => {
         const geometry = esm.cache.getGeometry(geometryId);
         const { data: contourSet } = geometry;
         const segmentIndex = contourSet.getSegmentIndex();
         const segmentSpecificConfig = getSegmentSpecificConfig(contourRepresentation, geometryId, segmentIndex);
-        acc.contourSets.push(contourSet);
         acc.segmentSpecificConfigs[segmentIndex] = segmentSpecificConfig ?? {};
         return acc;
     }, { contourSets: [], segmentSpecificConfigs: {} });
@@ -5196,72 +5262,75 @@ function updateVTKContourSets(viewport, geometryIds, contourRepresentation, cont
         ...segmentsToSetToVisible,
     ];
     const hasCustomSegmentSpecificConfig = Object.values(segmentSpecificConfigs).some((config) => Object.keys(config).length > 0);
-    let polyDataModified = false;
     if (affectedSegments.length || hasCustomSegmentSpecificConfig) {
-        const appendPolyData = mapper.getInputData();
-        const appendScalars = appendPolyData.getPointData().getScalars();
-        const appendScalarsData = appendScalars.getData();
-        let offset = 0;
-        contourSets.forEach((contourSet) => {
-            const segmentIndex = contourSet.getSegmentIndex();
-            const size = contourSet.getTotalNumberOfPoints();
-            if (affectedSegments.includes(segmentIndex) ||
-                segmentSpecificConfigs[segmentIndex]?.fillAlpha) {
-                const color = contourSet.getColor();
-                let visibility = mergedInvisibleSegments.includes(segmentIndex)
-                    ? 0
-                    : 255;
-                const segmentConfig = segmentSpecificConfigs[segmentIndex];
-                if (segmentConfig.fillAlpha !== undefined) {
-                    visibility = segmentConfig.fillAlpha * 255;
-                }
-                for (let i = 0; i < size; ++i) {
-                    appendScalarsData[offset + i * 4] = color[0];
-                    appendScalarsData[offset + i * 4 + 1] = color[1];
-                    appendScalarsData[offset + i * 4 + 2] = color[2];
-                    appendScalarsData[offset + i * 4 + 3] = visibility;
-                }
-                polyDataModified = true;
-            }
-            offset = offset + size * 4;
-        });
-        if (polyDataModified) {
-            appendPolyData.modified();
-        }
         setConfigCache(segmentationRepresentationUID, Object.assign({}, cachedConfig, {
             segmentsHidden: new Set(segmentsHidden),
         }));
-        mapper.setLookupTable(lut);
     }
     viewport.render();
 }
-
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Contour/vtkContour/addOrUpdateVTKContourSets.js
-
-
-function addOrUpdateVTKContourSets(viewport, geometryIds, contourRepresentation, contourRepresentationConfig) {
-    const { segmentationRepresentationUID } = contourRepresentation;
-    const actorUID = `CONTOUR_${segmentationRepresentationUID}`;
-    const actor = viewport.getActor(actorUID);
-    const addOrUpdateFn = actor ? updateVTKContourSets : addContourSetsToElement;
-    addOrUpdateFn(viewport, geometryIds, contourRepresentation, contourRepresentationConfig, actorUID);
+function addContourSetsToElement(viewport, geometryIds, contourRepresentation, contourRepresentationConfig) {
+    const { segmentationRepresentationUID, segmentationId, segmentsHidden } = contourRepresentation;
+    const segmentSpecificMap = new Map();
+    geometryIds.forEach((geometryId) => {
+        const geometry = esm.cache.getGeometry(geometryId);
+        if (!geometry) {
+            console.warn(`No geometry found for geometryId ${geometryId}. Skipping render.`);
+            return;
+        }
+        const segmentIndex = geometry.data.getSegmentIndex();
+        validateGeometry(geometry);
+        const segmentSpecificConfig = getSegmentSpecificConfig(contourRepresentation, geometryId, segmentIndex);
+        const contourSet = geometry.data;
+        contourSet.contours.forEach((contour) => {
+            const { points, color, id } = contour;
+            const contourSegmentationAnnotation = {
+                annotationUID: esm.utilities.uuidv4(),
+                data: {
+                    contour: {
+                        closed: true,
+                        polyline: points,
+                    },
+                    segmentation: {
+                        segmentationId,
+                        segmentIndex,
+                        color,
+                        id,
+                    },
+                    handles: {},
+                },
+                handles: {},
+                highlighted: false,
+                autoGenerated: false,
+                invalidated: false,
+                isLocked: false,
+                isVisible: true,
+                metadata: {
+                    referencedImageId: viewport.getCurrentImageId(),
+                    toolName: 'PlanarFreehandContourSegmentationTool',
+                    FrameOfReferenceUID: viewport.getFrameOfReferenceUID(),
+                    viewPlaneNormal: viewport.getCamera().viewPlaneNormal,
+                },
+            };
+            const annotationGroupSelector = viewport.element;
+            (0,stateManagement/* addAnnotation */.lC)(contourSegmentationAnnotation, annotationGroupSelector);
+            (0,contourSegmentation.addContourSegmentationAnnotation)(contourSegmentationAnnotation);
+        });
+        if (segmentSpecificConfig) {
+            segmentSpecificMap.set(segmentIndex, segmentSpecificConfig);
+        }
+    });
+    const outlineWidthActive = contourRepresentationConfig.representations.CONTOUR.outlineWidthActive;
+    setConfigCache(segmentationRepresentationUID, Object.assign({}, getConfigCache(segmentationRepresentationUID), {
+        segmentsHidden: new Set(segmentsHidden),
+        segmentSpecificMap,
+        outlineWidthActive,
+    }));
+    viewport.resetCamera();
+    viewport.render();
 }
 
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Contour/removeContourFromElement.js
-
-function removeContourFromElement(element, segmentationRepresentationUID, removeFromCache = false) {
-    const enabledElement = (0,esm.getEnabledElement)(element);
-    const { viewport } = enabledElement;
-    const actorEntries = viewport.getActors();
-    const actorUIDsToRemove = actorEntries
-        .map(({ uid }) => uid.includes(segmentationRepresentationUID) ? uid : undefined)
-        .filter(Boolean);
-    viewport.removeActors(actorUIDsToRemove);
-}
-/* harmony default export */ const Contour_removeContourFromElement = (removeContourFromElement);
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/index.js + 31 modules
-var stateManagement_segmentation = __webpack_require__(63421);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Contour/contourDisplay.js
 
 
@@ -5300,11 +5369,12 @@ async function render(viewport, representationConfig, toolGroupConfig) {
             viewport,
         });
     }
-    const { geometryIds } = contourData;
-    if (!geometryIds?.length || !(viewport instanceof esm.BaseVolumeViewport)) {
+    if (!contourData) {
         return;
     }
-    addOrUpdateVTKContourSets(viewport, geometryIds, representationConfig, toolGroupConfig);
+    if (contourData?.geometryIds?.length) {
+        handleContourSegmentation(viewport, contourData.geometryIds, contourData.annotationUIDsMap, representationConfig, toolGroupConfig);
+    }
 }
 function _removeContourFromToolGroupViewports(toolGroupId, segmentationRepresentationUID) {
     const toolGroup = (0,ToolGroupManager.getToolGroup)(toolGroupId);
@@ -5315,7 +5385,7 @@ function _removeContourFromToolGroupViewports(toolGroupId, segmentationRepresent
     for (const viewportInfo of viewportsInfo) {
         const { viewportId, renderingEngineId } = viewportInfo;
         const enabledElement = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
-        Contour_removeContourFromElement(enabledElement.viewport.element, segmentationRepresentationUID);
+        Contour_removeContourFromElement(segmentationRepresentationUID, toolGroupId);
     }
 }
 /* harmony default export */ const contourDisplay = ({
@@ -5643,6 +5713,36 @@ function getDefaultSurfaceConfig() {
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (getDefaultSurfaceConfig);
 
 
+/***/ }),
+
+/***/ 7783:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   X: () => (/* binding */ distancePointToContour)
+/* harmony export */ });
+/* harmony import */ var _utilities_math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73047);
+
+const distancePointToContour = (viewport, annotation, coords) => {
+    if (!annotation?.data?.contour?.polyline?.length) {
+        return;
+    }
+    const { polyline } = annotation.data.contour;
+    const { length } = polyline;
+    let distance = Infinity;
+    for (let i = 0; i < length; i++) {
+        const canvasPoint = viewport.worldToCanvas(polyline[i]);
+        const distanceToPoint = _utilities_math__WEBPACK_IMPORTED_MODULE_0__.point.distanceToPoint(canvasPoint, coords);
+        distance = Math.min(distance, distanceToPoint);
+    }
+    if (distance === Infinity || isNaN(distance)) {
+        return;
+    }
+    return distance;
+};
+
+
 /***/ }),
 
 /***/ 57439:
@@ -9649,292 +9749,48 @@ var vtkEdgeLocator = {
 
 /***/ }),
 
-/***/ 28136:
+/***/ 68749:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   Ay: () => (/* binding */ vtkAppendPolyData$1)
+/* harmony export */   A: () => (/* binding */ vtkCaseTable)
 /* harmony export */ });
-/* unused harmony exports extend, newInstance */
-/* harmony import */ var _macros2_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(50906);
-/* harmony import */ var _Common_Core_DataArray_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(45128);
-/* harmony import */ var _Common_Core_Points_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(18310);
-/* harmony import */ var _Common_DataModel_PolyData_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(27398);
-/* harmony import */ var _Common_DataModel_DataSetAttributes_Constants_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(94884);
-/* harmony import */ var _Common_Core_DataArray_Constants_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(82946);
+// ----------------------------------------------------------------------------
+// Marching squares case functions (using lines to generate the 2D tessellation).
+// For each case, a list of edge ids that form the triangles. A -1 marks the
+// end of the list of edges. Edges are taken three at a time to generate
+// triangle points.
+// ----------------------------------------------------------------------------
+const MARCHING_SQUARES_CASES = [[-1, -1, -1, -1, -1] /* 0 */, [0, 3, -1, -1, -1] /* 1 */, [1, 0, -1, -1, -1] /* 2 */, [1, 3, -1, -1, -1] /* 3 */, [2, 1, -1, -1, -1] /* 4 */, [0, 3, 2, 1, -1] /* 5 */, [2, 0, -1, -1, -1] /* 6 */, [2, 3, -1, -1, -1] /* 7 */, [3, 2, -1, -1, -1] /* 8 */, [0, 2, -1, -1, -1] /* 9 */, [1, 0, 3, 2, -1] /* 10 */, [1, 2, -1, -1, -1] /* 11 */, [3, 1, -1, -1, -1] /* 12 */, [0, 1, -1, -1, -1] /* 13 */, [3, 0, -1, -1, -1] /* 14 */, [-1, -1, -1, -1, -1] /* 15 */];
 
+const EDGES = [[0, 1], [1, 3], [2, 3], [0, 2]];
+function getCase(index) {
+  return MARCHING_SQUARES_CASES[index];
+}
 
+// Define the four edges of the pixel by the following pairs of vertices
+function getEdge(eid) {
+  return EDGES[eid];
+}
 
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+var vtkCaseTable = {
+  getCase,
+  getEdge
+};
 
 
 
 
-const {
-  vtkErrorMacro
-} = _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m;
-function offsetCellArray(typedArray, offset) {
-  let currentIdx = 0;
-  return typedArray.map((value, index) => {
-    if (index === currentIdx) {
-      currentIdx += value + 1;
-      return value;
-    }
-    return value + offset;
-  });
-}
-function appendCellData(dest, src, ptOffset, cellOffset) {
-  dest.set(offsetCellArray(src, ptOffset), cellOffset);
-}
+/***/ }),
 
-// ----------------------------------------------------------------------------
-// vtkAppendPolyData methods
-// ----------------------------------------------------------------------------
+/***/ 88099:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-function vtkAppendPolyData(publicAPI, model) {
-  // Set our classname
-  model.classHierarchy.push('vtkAppendPolyData');
-  publicAPI.requestData = (inData, outData) => {
-    // implement requestData
-    const numberOfInputs = publicAPI.getNumberOfInputPorts();
-    if (!numberOfInputs) {
-      vtkErrorMacro('No input specified.');
-      return;
-    }
-    if (numberOfInputs === 1) {
-      // pass through filter
-      outData[0] = inData[0];
-      return;
-    }
-
-    // Allocate output
-    const output = _Common_DataModel_PolyData_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"].newInstance */ .Ay.newInstance();
-    let numPts = 0;
-    let pointType = 0;
-    let ttype = 1;
-    let firstType = 1;
-    let numVerts = 0;
-    let numLines = 0;
-    let numStrips = 0;
-    let numPolys = 0;
-
-    // Field data is propagated to output only if present in all inputs
-    let hasPtNormals = true; // assume present by default
-    let hasPtTCoords = true;
-    let hasPtScalars = true;
-    for (let i = 0; i < numberOfInputs; i++) {
-      const ds = inData[i];
-      if (!ds) {
-        // eslint-disable-next-line
-        continue;
-      }
-      const dsNumPts = ds.getPoints().getNumberOfPoints();
-      numPts += dsNumPts;
-      numVerts += ds.getVerts().getNumberOfValues();
-      numLines += ds.getLines().getNumberOfValues();
-      numStrips += ds.getStrips().getNumberOfValues();
-      numPolys += ds.getPolys().getNumberOfValues();
-      if (dsNumPts) {
-        if (firstType) {
-          firstType = 0;
-          pointType = ds.getPoints().getDataType();
-        }
-        ttype = ds.getPoints().getDataType();
-        pointType = pointType > ttype ? pointType : ttype;
-      }
-      const ptD = ds.getPointData();
-      if (ptD) {
-        hasPtNormals = hasPtNormals && ptD.getNormals() !== null;
-        hasPtTCoords = hasPtTCoords && ptD.getTCoords() !== null;
-        hasPtScalars = hasPtScalars && ptD.getScalars() !== null;
-      } else {
-        hasPtNormals = false;
-        hasPtTCoords = false;
-        hasPtScalars = false;
-      }
-    }
-    if (model.outputPointsPrecision === _Common_DataModel_DataSetAttributes_Constants_js__WEBPACK_IMPORTED_MODULE_4__/* .DesiredOutputPrecision */ .kP.SINGLE) {
-      pointType = _Common_Core_DataArray_Constants_js__WEBPACK_IMPORTED_MODULE_5__/* .VtkDataTypes */ .JA.FLOAT;
-    } else if (model.outputPointsPrecision === _Common_DataModel_DataSetAttributes_Constants_js__WEBPACK_IMPORTED_MODULE_4__/* .DesiredOutputPrecision */ .kP.DOUBLE) {
-      pointType = _Common_Core_DataArray_Constants_js__WEBPACK_IMPORTED_MODULE_5__/* .VtkDataTypes */ .JA.DOUBLE;
-    }
-    const points = _Common_Core_Points_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"].newInstance */ .Ay.newInstance({
-      dataType: pointType
-    });
-    points.setNumberOfPoints(numPts);
-    const pointData = points.getData();
-    const vertData = new Uint32Array(numVerts);
-    const lineData = new Uint32Array(numLines);
-    const stripData = new Uint32Array(numStrips);
-    const polyData = new Uint32Array(numPolys);
-    let newPtNormals = null;
-    let newPtTCoords = null;
-    let newPtScalars = null;
-    const lds = inData[numberOfInputs - 1];
-    if (hasPtNormals) {
-      const dsNormals = lds.getPointData().getNormals();
-      newPtNormals = _Common_Core_DataArray_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"].newInstance */ .Ay.newInstance({
-        numberOfComponents: 3,
-        numberOfTuples: numPts,
-        size: 3 * numPts,
-        dataType: dsNormals.getDataType(),
-        name: dsNormals.getName()
-      });
-    }
-    if (hasPtTCoords) {
-      const dsTCoords = lds.getPointData().getTCoords();
-      newPtTCoords = _Common_Core_DataArray_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"].newInstance */ .Ay.newInstance({
-        numberOfComponents: 2,
-        numberOfTuples: numPts,
-        size: 2 * numPts,
-        dataType: dsTCoords.getDataType(),
-        name: dsTCoords.getName()
-      });
-    }
-    if (hasPtScalars) {
-      const dsScalars = lds.getPointData().getScalars();
-      newPtScalars = _Common_Core_DataArray_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"].newInstance */ .Ay.newInstance({
-        numberOfComponents: dsScalars.getNumberOfComponents(),
-        numberOfTuples: numPts,
-        size: numPts * dsScalars.getNumberOfComponents(),
-        dataType: dsScalars.getDataType(),
-        name: dsScalars.getName()
-      });
-    }
-    numPts = 0;
-    numVerts = 0;
-    numLines = 0;
-    numStrips = 0;
-    numPolys = 0;
-    for (let i = 0; i < numberOfInputs; i++) {
-      const ds = inData[i];
-      pointData.set(ds.getPoints().getData(), numPts * 3);
-      appendCellData(vertData, ds.getVerts().getData(), numPts, numVerts);
-      numVerts += ds.getVerts().getNumberOfValues();
-      appendCellData(lineData, ds.getLines().getData(), numPts, numLines);
-      numLines += ds.getLines().getNumberOfValues();
-      appendCellData(stripData, ds.getStrips().getData(), numPts, numStrips);
-      numStrips += ds.getStrips().getNumberOfValues();
-      appendCellData(polyData, ds.getPolys().getData(), numPts, numPolys);
-      numPolys += ds.getPolys().getNumberOfValues();
-      const dsPD = ds.getPointData();
-      if (hasPtNormals) {
-        const ptNorms = dsPD.getNormals();
-        newPtNormals.getData().set(ptNorms.getData(), numPts * 3);
-      }
-      if (hasPtTCoords) {
-        const ptTCoords = dsPD.getTCoords();
-        newPtTCoords.getData().set(ptTCoords.getData(), numPts * 2);
-      }
-      if (hasPtScalars) {
-        const ptScalars = dsPD.getScalars();
-        newPtScalars.getData().set(ptScalars.getData(), numPts * newPtScalars.getNumberOfComponents());
-      }
-      numPts += ds.getPoints().getNumberOfPoints();
-    }
-    output.setPoints(points);
-    output.getVerts().setData(vertData);
-    output.getLines().setData(lineData);
-    output.getStrips().setData(stripData);
-    output.getPolys().setData(polyData);
-    if (newPtNormals) {
-      output.getPointData().setNormals(newPtNormals);
-    }
-    if (newPtTCoords) {
-      output.getPointData().setTCoords(newPtTCoords);
-    }
-    if (newPtScalars) {
-      output.getPointData().setScalars(newPtScalars);
-    }
-    outData[0] = output;
-  };
-}
-
-// ----------------------------------------------------------------------------
-// Object factory
-// ----------------------------------------------------------------------------
-
-const DEFAULT_VALUES = {
-  outputPointsPrecision: _Common_DataModel_DataSetAttributes_Constants_js__WEBPACK_IMPORTED_MODULE_4__/* .DesiredOutputPrecision */ .kP.DEFAULT
-};
-
-// ----------------------------------------------------------------------------
-
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
-
-  // Build VTK API
-  _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.setGet(publicAPI, model, ['outputPointsPrecision']);
-
-  // Make this a VTK object
-  _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.obj(publicAPI, model);
-
-  // Also make it an algorithm with one input and one output
-  _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.algo(publicAPI, model, 1, 1);
-
-  // Object specific methods
-  vtkAppendPolyData(publicAPI, model);
-}
-
-// ----------------------------------------------------------------------------
-
-const newInstance = _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.newInstance(extend, 'vtkAppendPolyData');
-
-// ----------------------------------------------------------------------------
-
-var vtkAppendPolyData$1 = {
-  newInstance,
-  extend
-};
-
-
-
-
-/***/ }),
-
-/***/ 68749:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   A: () => (/* binding */ vtkCaseTable)
-/* harmony export */ });
-// ----------------------------------------------------------------------------
-// Marching squares case functions (using lines to generate the 2D tessellation).
-// For each case, a list of edge ids that form the triangles. A -1 marks the
-// end of the list of edges. Edges are taken three at a time to generate
-// triangle points.
-// ----------------------------------------------------------------------------
-const MARCHING_SQUARES_CASES = [[-1, -1, -1, -1, -1] /* 0 */, [0, 3, -1, -1, -1] /* 1 */, [1, 0, -1, -1, -1] /* 2 */, [1, 3, -1, -1, -1] /* 3 */, [2, 1, -1, -1, -1] /* 4 */, [0, 3, 2, 1, -1] /* 5 */, [2, 0, -1, -1, -1] /* 6 */, [2, 3, -1, -1, -1] /* 7 */, [3, 2, -1, -1, -1] /* 8 */, [0, 2, -1, -1, -1] /* 9 */, [1, 0, 3, 2, -1] /* 10 */, [1, 2, -1, -1, -1] /* 11 */, [3, 1, -1, -1, -1] /* 12 */, [0, 1, -1, -1, -1] /* 13 */, [3, 0, -1, -1, -1] /* 14 */, [-1, -1, -1, -1, -1] /* 15 */];
-
-const EDGES = [[0, 1], [1, 3], [2, 3], [0, 2]];
-function getCase(index) {
-  return MARCHING_SQUARES_CASES[index];
-}
-
-// Define the four edges of the pixel by the following pairs of vertices
-function getEdge(eid) {
-  return EDGES[eid];
-}
-
-// ----------------------------------------------------------------------------
-// Static API
-// ----------------------------------------------------------------------------
-var vtkCaseTable = {
-  getCase,
-  getEdge
-};
-
-
-
-
-/***/ }),
-
-/***/ 88099:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
+"use strict";
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -14500,7 +14356,7 @@ var vtkAnnotatedCubeActor$1 = {
 
 /***/ }),
 
-/***/ 65373:
+/***/ 43387:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -14522,10 +14378,242 @@ var DataArray = __webpack_require__(45128);
 var Actor = __webpack_require__(48987);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/Mapper.js
 var Mapper = __webpack_require__(22745);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Filters/General/AppendPolyData.js
-var AppendPolyData = __webpack_require__(28136);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/Points.js
+var Points = __webpack_require__(18310);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 9 modules
 var PolyData = __webpack_require__(27398);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/DataSetAttributes/Constants.js
+var Constants = __webpack_require__(94884);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/DataArray/Constants.js
+var DataArray_Constants = __webpack_require__(82946);
+;// CONCATENATED MODULE: ../../../node_modules/@kitware/vtk.js/Filters/General/AppendPolyData.js
+
+
+
+
+
+
+
+const {
+  vtkErrorMacro
+} = macros2.m;
+function offsetCellArray(typedArray, offset) {
+  let currentIdx = 0;
+  return typedArray.map((value, index) => {
+    if (index === currentIdx) {
+      currentIdx += value + 1;
+      return value;
+    }
+    return value + offset;
+  });
+}
+function appendCellData(dest, src, ptOffset, cellOffset) {
+  dest.set(offsetCellArray(src, ptOffset), cellOffset);
+}
+
+// ----------------------------------------------------------------------------
+// vtkAppendPolyData methods
+// ----------------------------------------------------------------------------
+
+function vtkAppendPolyData(publicAPI, model) {
+  // Set our classname
+  model.classHierarchy.push('vtkAppendPolyData');
+  publicAPI.requestData = (inData, outData) => {
+    // implement requestData
+    const numberOfInputs = publicAPI.getNumberOfInputPorts();
+    if (!numberOfInputs) {
+      vtkErrorMacro('No input specified.');
+      return;
+    }
+    if (numberOfInputs === 1) {
+      // pass through filter
+      outData[0] = inData[0];
+      return;
+    }
+
+    // Allocate output
+    const output = PolyData/* default.newInstance */.Ay.newInstance();
+    let numPts = 0;
+    let pointType = 0;
+    let ttype = 1;
+    let firstType = 1;
+    let numVerts = 0;
+    let numLines = 0;
+    let numStrips = 0;
+    let numPolys = 0;
+
+    // Field data is propagated to output only if present in all inputs
+    let hasPtNormals = true; // assume present by default
+    let hasPtTCoords = true;
+    let hasPtScalars = true;
+    for (let i = 0; i < numberOfInputs; i++) {
+      const ds = inData[i];
+      if (!ds) {
+        // eslint-disable-next-line
+        continue;
+      }
+      const dsNumPts = ds.getPoints().getNumberOfPoints();
+      numPts += dsNumPts;
+      numVerts += ds.getVerts().getNumberOfValues();
+      numLines += ds.getLines().getNumberOfValues();
+      numStrips += ds.getStrips().getNumberOfValues();
+      numPolys += ds.getPolys().getNumberOfValues();
+      if (dsNumPts) {
+        if (firstType) {
+          firstType = 0;
+          pointType = ds.getPoints().getDataType();
+        }
+        ttype = ds.getPoints().getDataType();
+        pointType = pointType > ttype ? pointType : ttype;
+      }
+      const ptD = ds.getPointData();
+      if (ptD) {
+        hasPtNormals = hasPtNormals && ptD.getNormals() !== null;
+        hasPtTCoords = hasPtTCoords && ptD.getTCoords() !== null;
+        hasPtScalars = hasPtScalars && ptD.getScalars() !== null;
+      } else {
+        hasPtNormals = false;
+        hasPtTCoords = false;
+        hasPtScalars = false;
+      }
+    }
+    if (model.outputPointsPrecision === Constants/* DesiredOutputPrecision */.kP.SINGLE) {
+      pointType = DataArray_Constants/* VtkDataTypes */.JA.FLOAT;
+    } else if (model.outputPointsPrecision === Constants/* DesiredOutputPrecision */.kP.DOUBLE) {
+      pointType = DataArray_Constants/* VtkDataTypes */.JA.DOUBLE;
+    }
+    const points = Points/* default.newInstance */.Ay.newInstance({
+      dataType: pointType
+    });
+    points.setNumberOfPoints(numPts);
+    const pointData = points.getData();
+    const vertData = new Uint32Array(numVerts);
+    const lineData = new Uint32Array(numLines);
+    const stripData = new Uint32Array(numStrips);
+    const polyData = new Uint32Array(numPolys);
+    let newPtNormals = null;
+    let newPtTCoords = null;
+    let newPtScalars = null;
+    const lds = inData[numberOfInputs - 1];
+    if (hasPtNormals) {
+      const dsNormals = lds.getPointData().getNormals();
+      newPtNormals = DataArray/* default.newInstance */.Ay.newInstance({
+        numberOfComponents: 3,
+        numberOfTuples: numPts,
+        size: 3 * numPts,
+        dataType: dsNormals.getDataType(),
+        name: dsNormals.getName()
+      });
+    }
+    if (hasPtTCoords) {
+      const dsTCoords = lds.getPointData().getTCoords();
+      newPtTCoords = DataArray/* default.newInstance */.Ay.newInstance({
+        numberOfComponents: 2,
+        numberOfTuples: numPts,
+        size: 2 * numPts,
+        dataType: dsTCoords.getDataType(),
+        name: dsTCoords.getName()
+      });
+    }
+    if (hasPtScalars) {
+      const dsScalars = lds.getPointData().getScalars();
+      newPtScalars = DataArray/* default.newInstance */.Ay.newInstance({
+        numberOfComponents: dsScalars.getNumberOfComponents(),
+        numberOfTuples: numPts,
+        size: numPts * dsScalars.getNumberOfComponents(),
+        dataType: dsScalars.getDataType(),
+        name: dsScalars.getName()
+      });
+    }
+    numPts = 0;
+    numVerts = 0;
+    numLines = 0;
+    numStrips = 0;
+    numPolys = 0;
+    for (let i = 0; i < numberOfInputs; i++) {
+      const ds = inData[i];
+      pointData.set(ds.getPoints().getData(), numPts * 3);
+      appendCellData(vertData, ds.getVerts().getData(), numPts, numVerts);
+      numVerts += ds.getVerts().getNumberOfValues();
+      appendCellData(lineData, ds.getLines().getData(), numPts, numLines);
+      numLines += ds.getLines().getNumberOfValues();
+      appendCellData(stripData, ds.getStrips().getData(), numPts, numStrips);
+      numStrips += ds.getStrips().getNumberOfValues();
+      appendCellData(polyData, ds.getPolys().getData(), numPts, numPolys);
+      numPolys += ds.getPolys().getNumberOfValues();
+      const dsPD = ds.getPointData();
+      if (hasPtNormals) {
+        const ptNorms = dsPD.getNormals();
+        newPtNormals.getData().set(ptNorms.getData(), numPts * 3);
+      }
+      if (hasPtTCoords) {
+        const ptTCoords = dsPD.getTCoords();
+        newPtTCoords.getData().set(ptTCoords.getData(), numPts * 2);
+      }
+      if (hasPtScalars) {
+        const ptScalars = dsPD.getScalars();
+        newPtScalars.getData().set(ptScalars.getData(), numPts * newPtScalars.getNumberOfComponents());
+      }
+      numPts += ds.getPoints().getNumberOfPoints();
+    }
+    output.setPoints(points);
+    output.getVerts().setData(vertData);
+    output.getLines().setData(lineData);
+    output.getStrips().setData(stripData);
+    output.getPolys().setData(polyData);
+    if (newPtNormals) {
+      output.getPointData().setNormals(newPtNormals);
+    }
+    if (newPtTCoords) {
+      output.getPointData().setTCoords(newPtTCoords);
+    }
+    if (newPtScalars) {
+      output.getPointData().setScalars(newPtScalars);
+    }
+    outData[0] = output;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  outputPointsPrecision: Constants/* DesiredOutputPrecision */.kP.DEFAULT
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Build VTK API
+  macros2.m.setGet(publicAPI, model, ['outputPointsPrecision']);
+
+  // Make this a VTK object
+  macros2.m.obj(publicAPI, model);
+
+  // Also make it an algorithm with one input and one output
+  macros2.m.algo(publicAPI, model, 1, 1);
+
+  // Object specific methods
+  vtkAppendPolyData(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macros2.m.newInstance(extend, 'vtkAppendPolyData');
+
+// ----------------------------------------------------------------------------
+
+var vtkAppendPolyData$1 = {
+  newInstance,
+  extend
+};
+
+
+
 ;// CONCATENATED MODULE: ../../../node_modules/@kitware/vtk.js/Filters/Sources/ConeSource.js
 
 
@@ -14605,7 +14693,7 @@ function vtkConeSource(publicAPI, model) {
 // Object factory
 // ----------------------------------------------------------------------------
 
-const DEFAULT_VALUES = {
+const ConeSource_DEFAULT_VALUES = {
   height: 1.0,
   radius: 0.5,
   resolution: 6,
@@ -14617,9 +14705,9 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
+function ConeSource_extend(publicAPI, model) {
   let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, ConeSource_DEFAULT_VALUES, initialValues);
 
   // Build VTK API
   macros2.m.obj(publicAPI, model);
@@ -14631,13 +14719,13 @@ function extend(publicAPI, model) {
 
 // ----------------------------------------------------------------------------
 
-const newInstance = macros2.m.newInstance(extend, 'vtkConeSource');
+const ConeSource_newInstance = macros2.m.newInstance(ConeSource_extend, 'vtkConeSource');
 
 // ----------------------------------------------------------------------------
 
 var vtkConeSource$1 = {
-  newInstance,
-  extend
+  newInstance: ConeSource_newInstance,
+  extend: ConeSource_extend
 };
 
 
@@ -14888,7 +14976,7 @@ function vtkArrowSource(publicAPI, model) {
 
     // Apply transformation to the cone
     MatrixBuilder/* default */.A.buildFromRadian().translate(1.0 - model.tipLength * 0.5, 0.0, 0.0).apply(conePts);
-    const append = AppendPolyData/* default.newInstance */.Ay.newInstance();
+    const append = vtkAppendPolyData$1.newInstance();
     append.setInputData(cylinderPD);
     append.addInputData(conePD);
     const appendPD = append.getOutputData();
@@ -15054,7 +15142,7 @@ function vtkAxesActor(publicAPI, model) {
       shiftDataset(zAxis, 2, currentConfig.invert);
     }
     addColor(zAxis, ...currentConfig.color);
-    const source = AppendPolyData/* default.newInstance */.Ay.newInstance();
+    const source = vtkAppendPolyData$1.newInstance();
     source.setInputData(xAxis);
     source.addInputData(yAxis);
     source.addInputData(zAxis);