@ohif/app 3.7.0-beta.100 → 3.7.0-beta.102

package/dist/{221.bundle.0b9f7401294213262852.js → 221.bundle.1abd77673494f2d5e335.js}

@@ -642,6 +642,11 @@ function PanelSegmentation(_ref) {
       });
     }
   };
+  const onSegmentationDownloadRTSS = segmentationId => {
+    commandsManager.runCommand('downloadRTSS', {
+      segmentationId
+    });
+  };
   return /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement("div", {
     className: "ohif-scrollbar flex min-h-0 flex-auto select-none flex-col justify-between overflow-auto"
   }, /*#__PURE__*/react.createElement(ui_src/* SegmentationGroupTable */.cX, {
@@ -653,6 +658,7 @@ function PanelSegmentation(_ref) {
     onSegmentationClick: onSegmentationClick,
     onSegmentationDelete: onSegmentationDelete,
     onSegmentationDownload: onSegmentationDownload,
+    onSegmentationDownloadRTSS: onSegmentationDownloadRTSS,
     storeSegmentation: storeSegmentation,
     onSegmentationEdit: onSegmentationEdit,
     onSegmentClick: onSegmentClick,
@@ -706,9 +712,9 @@ const TOOL_TYPES = {
   SPHERE_BRUSH: 'SphereBrush',
   CIRCULAR_ERASER: 'CircularEraser',
   SPHERE_ERASER: 'SphereEraser',
-  CIRCLE_SCISSOR: 'CircleScissor',
-  RECTANGLE_SCISSOR: 'RectangleScissor',
-  SPHERE_SCISSOR: 'SphereScissor',
+  CIRCLE_SHAPE: 'CircleScissor',
+  RECTANGLE_SHAPE: 'RectangleScissor',
+  SPHERE_SHAPE: 'SphereScissor',
   THRESHOLD_CIRCULAR_BRUSH: 'ThresholdCircularBrush',
   THRESHOLD_SPHERE_BRUSH: 'ThresholdSphereBrush'
 };
@@ -727,7 +733,7 @@ const initialState = {
     mode: 'CircularEraser' // Can be 'CircularEraser' or 'SphereEraser'
   },
 
-  Scissors: {
+  Shapes: {
     brushSize: 15,
     mode: 'CircleScissor' // E.g., 'CircleScissor', 'RectangleScissor', or 'SphereScissor'
   },
@@ -966,24 +972,24 @@ function SegmentationToolbox(_ref) {
         onChange: value => setToolActive(value)
       }]
     }, {
-      name: 'Scissor',
-      icon: 'icon-tool-scissor',
+      name: 'Shapes',
+      icon: 'icon-tool-shape',
       disabled: !toolsEnabled,
-      active: state.activeTool === TOOL_TYPES.CIRCLE_SCISSOR || state.activeTool === TOOL_TYPES.RECTANGLE_SCISSOR || state.activeTool === TOOL_TYPES.SPHERE_SCISSOR,
-      onClick: () => setToolActive(TOOL_TYPES.CIRCLE_SCISSOR),
+      active: state.activeTool === TOOL_TYPES.CIRCLE_SHAPE || state.activeTool === TOOL_TYPES.RECTANGLE_SHAPE || state.activeTool === TOOL_TYPES.SPHERE_SHAPE,
+      onClick: () => setToolActive(TOOL_TYPES.CIRCLE_SHAPE),
       options: [{
         name: 'Mode',
         type: 'radio',
-        value: state.Scissors.mode,
-        id: 'scissor-mode',
+        value: state.Shapes.mode,
+        id: 'shape-mode',
         values: [{
-          value: TOOL_TYPES.CIRCLE_SCISSOR,
+          value: TOOL_TYPES.CIRCLE_SHAPE,
           label: 'Circle'
         }, {
-          value: TOOL_TYPES.RECTANGLE_SCISSOR,
+          value: TOOL_TYPES.RECTANGLE_SHAPE,
           label: 'Rectangle'
         }, {
-          value: TOOL_TYPES.SPHERE_SCISSOR,
+          value: TOOL_TYPES.SPHERE_SHAPE,
           label: 'Sphere'
         }],
         onChange: value => setToolActive(value)
@@ -1118,6 +1124,12 @@ const getPanelModule = _ref => {
   }];
 };
 /* harmony default export */ const src_getPanelModule = (getPanelModule);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Filters/General/ImageMarchingSquares.js + 2 modules
+var ImageMarchingSquares = __webpack_require__(49399);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/DataArray.js
+var DataArray = __webpack_require__(54131);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/ImageData.js + 2 modules
+var ImageData = __webpack_require__(96372);
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-seg/src/utils/hydrationUtils.ts
 
 
@@ -1287,6 +1299,12 @@ function getUpdatedViewportsForSegmentation(_ref3) {
 
 
 
+
+
+
+const {
+  datasetToBlob
+} = dcmjs_es["default"].data;
 const {
   Cornerstone3D: {
     Segmentation: {
@@ -1295,6 +1313,13 @@ const {
     }
   }
 } = adapters_es.adaptersSEG;
+const {
+  Cornerstone3D: {
+    RTSS: {
+      generateRTSSFromSegmentations
+    }
+  }
+} = adapters_es.adaptersRT;
 const {
   downloadDICOMData
 } = adapters_es.helpers;
@@ -1608,6 +1633,34 @@ const commandsModule = _ref => {
       naturalizedReport.wadoRoot = dataSource.getConfig().wadoRoot;
       src.DicomMetadataStore.addInstances([naturalizedReport], true);
       return naturalizedReport;
+    },
+    /**
+     * Converts segmentations into RTSS for download.
+     * This sample function retrieves all segentations and passes to
+     * cornerstone tool adapter to convert to DICOM RTSS format. It then
+     * converts dataset to downloadable blob.
+     *
+     */
+    downloadRTSS: _ref8 => {
+      let {
+        segmentationId
+      } = _ref8;
+      const segmentations = segmentationService.getSegmentation(segmentationId);
+      const vtkUtils = {
+        vtkImageMarchingSquares: ImageMarchingSquares/* default */.ZP,
+        vtkDataArray: DataArray/* default */.ZP,
+        vtkImageData: ImageData/* default */.ZP
+      };
+      const RTSS = generateRTSSFromSegmentations(segmentations, src.classes.MetadataProvider, src.DicomMetadataStore, esm.cache, dist_esm.Enums, vtkUtils);
+      try {
+        const reportBlob = datasetToBlob(RTSS);
+
+        //Create a URL for the binary.
+        const objectUrl = URL.createObjectURL(reportBlob);
+        window.location.assign(objectUrl);
+      } catch (e) {
+        console.warn(e);
+      }
     }
   };
   const definitions = {
@@ -1631,6 +1684,9 @@ const commandsModule = _ref => {
     },
     storeSegmentation: {
       commandFn: actions.storeSegmentation
+    },
+    downloadRTSS: {
+      commandFn: actions.downloadRTSS
     }
   };
   return {

package/dist/{342.bundle.6edc7ac022b4218ec99f.js → 342.bundle.d48025ca2b3e0c124c93.js}

@@ -831,7 +831,7 @@ class StaticWadoClient extends dicomweb_client_es.api.DICOMwebClient {
     if (!valueElem) {
       return false;
     }
-    if (valueElem.vr == 'DA') {
+    if (valueElem.vr === 'DA' && valueElem.Value?.[0]) {
       return this.compareDateRange(testValue, valueElem.Value[0]);
     }
     const value = valueElem.Value;
@@ -2166,8 +2166,8 @@ function ViewerHeader(_ref) {
     hotkeyDefinitions,
     hotkeyDefaults
   } = hotkeysManager;
-  const versionNumber = "3.7.0-beta.100";
-  const commitHash = "1fd98d922094d10fe0c6e9df726314ec9fce49e8";
+  const versionNumber = "3.7.0-beta.102";
+  const commitHash = "40673f64b36b1150149c55632aa1825178a39e65";
   const menuOptions = [{
     title: t('Header:About'),
     icon: 'info',
@@ -2508,7 +2508,6 @@ function PanelStudyBrowser(_ref) {
   const [studyDisplayList, setStudyDisplayList] = (0,react.useState)([]);
   const [displaySets, setDisplaySets] = (0,react.useState)([]);
   const [thumbnailImageSrcMap, setThumbnailImageSrcMap] = (0,react.useState)({});
-  const isMounted = (0,react.useRef)(true);
   const onDoubleClickThumbnailHandler = displaySetInstanceUID => {
     let updatedViewports = [];
     const viewportId = activeViewportId;
@@ -2585,9 +2584,6 @@ function PanelStudyBrowser(_ref) {
       }
       // When the image arrives, render it and store the result in the thumbnailImgSrcMap
       newImageSrcEntry[dSet.displaySetInstanceUID] = await getImageSrc(imageId);
-      if (!isMounted.current) {
-        return;
-      }
       setThumbnailImageSrcMap(prevState => {
         return {
           ...prevState,
@@ -2595,9 +2591,6 @@ function PanelStudyBrowser(_ref) {
         };
       });
     });
-    return () => {
-      isMounted.current = false;
-    };
   }, [StudyInstanceUIDs, dataSource, displaySetService, getImageSrc]);
 
   // ~~ displaySets
@@ -5570,6 +5563,7 @@ const commandsModule = _ref => {
         stageIndex,
         reset = false
       } = _ref3;
+      const primaryToolBeforeHPChange = toolbarService.getActivePrimaryTool();
       try {
         // Stores in the state the display set selector id to displaySetUID mapping
         // Pass in viewportId for the active viewport.  This item will get set as
@@ -5632,7 +5626,27 @@ const commandsModule = _ref => {
         const {
           protocol
         } = hangingProtocolService.getActiveProtocol();
-        actions.toggleHpTools(protocol);
+        actions.toggleHpTools();
+
+        // try to use the same tool in the new hanging protocol stage
+        const primaryButton = toolbarService.getButton(primaryToolBeforeHPChange);
+        if (primaryButton) {
+          // is there any type of interaction on this button, if not it might be in the
+          // items. This is a bit of a hack, but it works for now.
+
+          let interactionType = primaryButton.props?.interactionType;
+          if (!interactionType && primaryButton.props?.items) {
+            const firstItem = primaryButton.props.items[0];
+            interactionType = firstItem.props?.interactionType || firstItem.props?.type;
+          }
+          if (interactionType) {
+            toolbarService.recordInteraction({
+              interactionType,
+              ...primaryButton.props
+            });
+          }
+        }
+
         // Send the notification about updating the state
         if (protocolId !== hpInfo.protocolId) {
           // The old protocol callbacks are used for turning off things
@@ -5645,7 +5659,8 @@ const commandsModule = _ref => {
         commandsManager.run(protocol.callbacks?.onProtocolEnter);
         return true;
       } catch (e) {
-        actions.toggleHpTools(hangingProtocolService.getActiveProtocol());
+        console.error(e);
+        actions.toggleHpTools();
         uiNotificationService.show({
           title: 'Apply Hanging Protocol',
           message: 'The hanging protocol could not be applied.',

package/dist/{831.bundle.83658f62fcc769043605.js → 757.bundle.ec8301d8e70d2b990f65.js}

@@ -1,4 +1,4 @@
-(self["webpackChunk"] = self["webpackChunk"] || []).push([[831],{
+(self["webpackChunk"] = self["webpackChunk"] || []).push([[757],{
 
 /***/ 82803:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
@@ -90,6 +90,373 @@ exports.Z = function (_ref) {
   );
 };
 
+/***/ }),
+
+/***/ 49399:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  ZP: () => (/* binding */ vtkImageMarchingSquares$1)
+});
+
+// UNUSED EXPORTS: extend, newInstance
+
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/macros.js + 6 modules
+var macros = __webpack_require__(41168);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 9 modules
+var PolyData = __webpack_require__(1299);
+// EXTERNAL MODULE: ../../../node_modules/@babel/runtime/helpers/esm/classCallCheck.js
+var classCallCheck = __webpack_require__(72688);
+// EXTERNAL MODULE: ../../../node_modules/@babel/runtime/helpers/esm/createClass.js
+var createClass = __webpack_require__(75755);
+;// CONCATENATED MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/EdgeLocator.js
+
+
+
+var EdgeLocator = /*#__PURE__*/function () {
+  function EdgeLocator() {
+    var oriented = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
+    (0,classCallCheck/* default */.Z)(this, EdgeLocator);
+
+    this.oriented = oriented;
+    this.edgeMap = new Map();
+  }
+
+  (0,createClass/* default */.Z)(EdgeLocator, [{
+    key: "initialize",
+    value: function initialize() {
+      this.edgeMap.clear();
+    }
+  }, {
+    key: "computeEdgeKey",
+    value: function computeEdgeKey(pointId0, pointId1) {
+      return this.oriented || pointId0 < pointId1 ? // Cantor pairing function:
+      0.5 * (pointId0 * pointId1) * (pointId0 * pointId1 + 1) + pointId1 : 0.5 * (pointId1 * pointId0) * (pointId1 * pointId0 + 1) + pointId0;
+    }
+  }, {
+    key: "insertUniqueEdge",
+    value: function insertUniqueEdge(pointId0, pointId1, newEdgeValue) {
+      // Generate a unique key
+      var key = this.computeEdgeKey(pointId0, pointId1);
+      var node = this.edgeMap.get(key);
+
+      if (!node) {
+        // Didn't find key, so add a new edge entry
+        node = {
+          key: key,
+          edgeId: this.edgeMap.size,
+          value: newEdgeValue
+        };
+        this.edgeMap.set(key, node);
+      }
+
+      return node;
+    }
+  }, {
+    key: "insertEdge",
+    value: function insertEdge(pointId0, pointId1, newEdgeValue) {
+      // Generate a unique key
+      var key = this.computeEdgeKey(pointId0, pointId1);
+      var node = {
+        key: key,
+        edgeId: this.edgeMap.size,
+        value: newEdgeValue
+      };
+      this.edgeMap.set(key, node);
+      return node;
+    }
+  }, {
+    key: "isInsertedEdge",
+    value: function isInsertedEdge(pointId0, pointId1) {
+      var key = this.computeEdgeKey(pointId0, pointId1);
+      return this.edgeMap.get(key);
+    }
+  }], [{
+    key: "getEdgePointIds",
+    value: function getEdgePointIds(node) {
+      var n = 0.5 * (-1 + Math.sqrt(8 * node.key + 1));
+      var pointId0 = node.key - 0.5 * (n + 1) * n;
+      var pointId1 = n - pointId0;
+      return [pointId0, pointId1];
+    }
+  }]);
+
+  return EdgeLocator;
+}();
+
+function newInstance() {
+  var initialValues = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return new EdgeLocator(initialValues.oriented);
+}
+
+var vtkEdgeLocator = {
+  newInstance: newInstance
+};
+
+
+
+;// CONCATENATED MODULE: ../../../node_modules/@kitware/vtk.js/Filters/General/ImageMarchingSquares/caseTable.js
+// ----------------------------------------------------------------------------
+// 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.
+// ----------------------------------------------------------------------------
+var 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 */
+];
+var 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: getCase,
+  getEdge: getEdge
+};
+
+
+
+;// CONCATENATED MODULE: ../../../node_modules/@kitware/vtk.js/Filters/General/ImageMarchingSquares.js
+
+
+
+
+
+var vtkErrorMacro = macros["default"].vtkErrorMacro,
+    vtkDebugMacro = macros["default"].vtkDebugMacro; // ----------------------------------------------------------------------------
+// vtkImageMarchingSquares methods
+// ----------------------------------------------------------------------------
+
+function vtkImageMarchingSquares(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkImageMarchingSquares');
+
+  publicAPI.getContourValues = function () {
+    return model.contourValues;
+  };
+
+  publicAPI.setContourValues = function (cValues) {
+    model.contourValues = cValues;
+    publicAPI.modified();
+  };
+
+  var ids = [];
+  var pixelScalars = [];
+  var pixelPts = [];
+  var edgeLocator = vtkEdgeLocator.newInstance(); // Retrieve scalars and pixel coordinates. i-j-k is origin of pixel.
+
+  publicAPI.getPixelScalars = function (i, j, k, slice, dims, origin, spacing, s) {
+    // First get the indices for the pixel
+    ids[0] = k * slice + j * dims[0] + i; // i, j, k
+
+    ids[1] = ids[0] + 1; // i+1, j, k
+
+    ids[2] = ids[0] + dims[0]; // i, j+1, k
+
+    ids[3] = ids[2] + 1; // i+1, j+1, k
+    // Now retrieve the scalars
+
+    for (var ii = 0; ii < 4; ++ii) {
+      pixelScalars[ii] = s[ids[ii]];
+    }
+  }; // Retrieve pixel coordinates. i-j-k is origin of pixel.
+
+
+  publicAPI.getPixelPoints = function (i, j, k, dims, origin, spacing) {
+    // (i,i+1),(j,j+1),(k,k+1) - i varies fastest; then j; then k
+    pixelPts[0] = origin[0] + i * spacing[0]; // 0
+
+    pixelPts[1] = origin[1] + j * spacing[1];
+    pixelPts[2] = pixelPts[0] + spacing[0]; // 1
+
+    pixelPts[3] = pixelPts[1];
+    pixelPts[4] = pixelPts[0]; // 2
+
+    pixelPts[5] = pixelPts[1] + spacing[1];
+    pixelPts[6] = pixelPts[2]; // 3
+
+    pixelPts[7] = pixelPts[5];
+  };
+
+  publicAPI.produceLines = function (cVal, i, j, k, slice, dims, origin, spacing, scalars, points, lines) {
+    var CASE_MASK = [1, 2, 8, 4]; // case table is actually for quad
+
+    var xyz = [];
+    var pId;
+    publicAPI.getPixelScalars(i, j, k, slice, dims, origin, spacing, scalars);
+    var index = 0;
+
+    for (var idx = 0; idx < 4; idx++) {
+      if (pixelScalars[idx] >= cVal) {
+        index |= CASE_MASK[idx]; // eslint-disable-line no-bitwise
+      }
+    }
+
+    var pixelLines = vtkCaseTable.getCase(index);
+
+    if (pixelLines[0] < 0) {
+      return; // don't get the pixel coordinates, nothing to do
+    }
+
+    publicAPI.getPixelPoints(i, j, k, dims, origin, spacing);
+    var z = origin[2] + k * spacing[2];
+
+    for (var _idx = 0; pixelLines[_idx] >= 0; _idx += 3) {
+      lines.push(2);
+
+      for (var eid = 0; eid < 2; eid++) {
+        var edgeVerts = vtkCaseTable.getEdge(pixelLines[_idx + eid]);
+        pId = undefined;
+
+        if (model.mergePoints) {
+          var _edgeLocator$isInsert;
+
+          pId = (_edgeLocator$isInsert = edgeLocator.isInsertedEdge(ids[edgeVerts[0]], ids[edgeVerts[1]])) === null || _edgeLocator$isInsert === void 0 ? void 0 : _edgeLocator$isInsert.value;
+        }
+
+        if (pId === undefined) {
+          var t = (cVal - pixelScalars[edgeVerts[0]]) / (pixelScalars[edgeVerts[1]] - pixelScalars[edgeVerts[0]]);
+          var x0 = pixelPts.slice(edgeVerts[0] * 2, (edgeVerts[0] + 1) * 2);
+          var x1 = pixelPts.slice(edgeVerts[1] * 2, (edgeVerts[1] + 1) * 2);
+          xyz[0] = x0[0] + t * (x1[0] - x0[0]);
+          xyz[1] = x0[1] + t * (x1[1] - x0[1]);
+          pId = points.length / 3;
+          points.push(xyz[0], xyz[1], z);
+
+          if (model.mergePoints) {
+            edgeLocator.insertEdge(ids[edgeVerts[0]], ids[edgeVerts[1]], pId);
+          }
+        }
+
+        lines.push(pId);
+      }
+    }
+  };
+
+  publicAPI.requestData = function (inData, outData) {
+    // implement requestData
+    var input = inData[0];
+
+    if (!input) {
+      vtkErrorMacro('Invalid or missing input');
+      return;
+    }
+
+    console.time('msquares'); // Retrieve output and volume data
+
+    var origin = input.getOrigin();
+    var spacing = input.getSpacing();
+    var dims = input.getDimensions();
+    var s = input.getPointData().getScalars().getData(); // Points - dynamic array
+
+    var pBuffer = []; // Cells - dynamic array
+
+    var lBuffer = []; // Ensure slice is valid
+
+    var slice = dims[0] * dims[1];
+    var k = Math.round(model.slice);
+
+    if (k >= dims[2]) {
+      k = 0;
+    } // Loop over all contour values, and then pixels, determine case and process
+
+
+    for (var cv = 0; cv < model.contourValues.length; ++cv) {
+      for (var j = 0; j < dims[1] - 1; ++j) {
+        for (var i = 0; i < dims[0] - 1; ++i) {
+          publicAPI.produceLines(model.contourValues[cv], i, j, k, slice, dims, origin, spacing, s, pBuffer, lBuffer);
+        }
+      }
+
+      edgeLocator.initialize();
+    } // Update output
+
+
+    var polydata = PolyData/* default.newInstance */.ZP.newInstance();
+    polydata.getPoints().setData(new Float32Array(pBuffer), 3);
+    polydata.getLines().setData(new Uint32Array(lBuffer));
+    outData[0] = polydata;
+    vtkDebugMacro('Produced output');
+    console.timeEnd('msquares');
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  contourValues: [],
+  slice: 0,
+  mergePoints: false
+}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Make this a VTK object
+
+  macros["default"].obj(publicAPI, model); // Also make it an algorithm with one input and one output
+
+  macros["default"].algo(publicAPI, model, 1, 1);
+  macros["default"].setGet(publicAPI, model, ['slice', 'mergePoints']); // Object specific methods
+
+  macros["default"].algo(publicAPI, model, 1, 1);
+  vtkImageMarchingSquares(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var ImageMarchingSquares_newInstance = macros["default"].newInstance(extend, 'vtkImageMarchingSquares'); // ----------------------------------------------------------------------------
+
+var vtkImageMarchingSquares$1 = {
+  newInstance: ImageMarchingSquares_newInstance,
+  extend: extend
+};
+
+
+
+
 /***/ }),
 
 /***/ 55187: