@ohif/app 3.9.0-beta.45 → 3.9.0-beta.47

package/dist/250.bundle.4743b359797751102600.js

@@ -0,0 +1,663 @@
+"use strict";
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[250],{
+
+/***/ 8455:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   ZP: () => (/* binding */ vtkImageData$1)
+/* harmony export */ });
+/* unused harmony exports extend, newInstance */
+/* harmony import */ var _macros2_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(68470);
+/* harmony import */ var _Core_Math_index_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(59474);
+/* harmony import */ var _BoundingBox_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(91382);
+/* harmony import */ var _DataSet_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(14418);
+/* harmony import */ var _StructuredData_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(57036);
+/* harmony import */ var _StructuredData_Constants_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(35368);
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(72076);
+
+
+
+
+
+
+
+
+const {
+  vtkErrorMacro
+} = _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m;
+
+// ----------------------------------------------------------------------------
+// vtkImageData methods
+// ----------------------------------------------------------------------------
+
+function vtkImageData(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkImageData');
+  publicAPI.setExtent = function () {
+    if (model.deleted) {
+      vtkErrorMacro('instance deleted - cannot call any method');
+      return false;
+    }
+    for (var _len = arguments.length, inExtent = new Array(_len), _key = 0; _key < _len; _key++) {
+      inExtent[_key] = arguments[_key];
+    }
+    const extentArray = inExtent.length === 1 ? inExtent[0] : inExtent;
+    if (extentArray.length !== 6) {
+      return false;
+    }
+    const changeDetected = model.extent.some((item, index) => item !== extentArray[index]);
+    if (changeDetected) {
+      model.extent = extentArray.slice();
+      model.dataDescription = _StructuredData_js__WEBPACK_IMPORTED_MODULE_4__/* ["default"].getDataDescriptionFromExtent */ .Z.getDataDescriptionFromExtent(model.extent);
+      publicAPI.modified();
+    }
+    return changeDetected;
+  };
+  publicAPI.setDimensions = function () {
+    let i;
+    let j;
+    let k;
+    if (model.deleted) {
+      vtkErrorMacro('instance deleted - cannot call any method');
+      return;
+    }
+    if (arguments.length === 1) {
+      const array = arguments.length <= 0 ? undefined : arguments[0];
+      i = array[0];
+      j = array[1];
+      k = array[2];
+    } else if (arguments.length === 3) {
+      i = arguments.length <= 0 ? undefined : arguments[0];
+      j = arguments.length <= 1 ? undefined : arguments[1];
+      k = arguments.length <= 2 ? undefined : arguments[2];
+    } else {
+      vtkErrorMacro('Bad dimension specification');
+      return;
+    }
+    publicAPI.setExtent(0, i - 1, 0, j - 1, 0, k - 1);
+  };
+  publicAPI.getDimensions = () => [model.extent[1] - model.extent[0] + 1, model.extent[3] - model.extent[2] + 1, model.extent[5] - model.extent[4] + 1];
+  publicAPI.getNumberOfCells = () => {
+    const dims = publicAPI.getDimensions();
+    let nCells = 1;
+    for (let i = 0; i < 3; i++) {
+      if (dims[i] === 0) {
+        return 0;
+      }
+      if (dims[i] > 1) {
+        nCells *= dims[i] - 1;
+      }
+    }
+    return nCells;
+  };
+  publicAPI.getNumberOfPoints = () => {
+    const dims = publicAPI.getDimensions();
+    return dims[0] * dims[1] * dims[2];
+  };
+  publicAPI.getPoint = index => {
+    const dims = publicAPI.getDimensions();
+    if (dims[0] === 0 || dims[1] === 0 || dims[2] === 0) {
+      vtkErrorMacro('Requesting a point from an empty image.');
+      return null;
+    }
+    const ijk = new Float64Array(3);
+    switch (model.dataDescription) {
+      case _StructuredData_Constants_js__WEBPACK_IMPORTED_MODULE_5__/* .StructuredType */ ._.EMPTY:
+        return null;
+      case _StructuredData_Constants_js__WEBPACK_IMPORTED_MODULE_5__/* .StructuredType */ ._.SINGLE_POINT:
+        break;
+      case _StructuredData_Constants_js__WEBPACK_IMPORTED_MODULE_5__/* .StructuredType */ ._.X_LINE:
+        ijk[0] = index;
+        break;
+      case _StructuredData_Constants_js__WEBPACK_IMPORTED_MODULE_5__/* .StructuredType */ ._.Y_LINE:
+        ijk[1] = index;
+        break;
+      case _StructuredData_Constants_js__WEBPACK_IMPORTED_MODULE_5__/* .StructuredType */ ._.Z_LINE:
+        ijk[2] = index;
+        break;
+      case _StructuredData_Constants_js__WEBPACK_IMPORTED_MODULE_5__/* .StructuredType */ ._.XY_PLANE:
+        ijk[0] = index % dims[0];
+        ijk[1] = index / dims[0];
+        break;
+      case _StructuredData_Constants_js__WEBPACK_IMPORTED_MODULE_5__/* .StructuredType */ ._.YZ_PLANE:
+        ijk[1] = index % dims[1];
+        ijk[2] = index / dims[1];
+        break;
+      case _StructuredData_Constants_js__WEBPACK_IMPORTED_MODULE_5__/* .StructuredType */ ._.XZ_PLANE:
+        ijk[0] = index % dims[0];
+        ijk[2] = index / dims[0];
+        break;
+      case _StructuredData_Constants_js__WEBPACK_IMPORTED_MODULE_5__/* .StructuredType */ ._.XYZ_GRID:
+        ijk[0] = index % dims[0];
+        ijk[1] = index / dims[0] % dims[1];
+        ijk[2] = index / (dims[0] * dims[1]);
+        break;
+      default:
+        vtkErrorMacro('Invalid dataDescription');
+        break;
+    }
+    const coords = [0, 0, 0];
+    publicAPI.indexToWorld(ijk, coords);
+    return coords;
+  };
+
+  // vtkCell *GetCell(vtkIdType cellId) VTK_OVERRIDE;
+  // void GetCell(vtkIdType cellId, vtkGenericCell *cell) VTK_OVERRIDE;
+  // void GetCellBounds(vtkIdType cellId, double bounds[6]) VTK_OVERRIDE;
+  // virtual vtkIdType FindPoint(double x, double y, double z)
+  // {
+  //   return this->vtkDataSet::FindPoint(x, y, z);
+  // }
+  // vtkIdType FindPoint(double x[3]) VTK_OVERRIDE;
+  // vtkIdType FindCell(
+  //   double x[3], vtkCell *cell, vtkIdType cellId, double tol2,
+  //   int& subId, double pcoords[3], double *weights) VTK_OVERRIDE;
+  // vtkIdType FindCell(
+  //   double x[3], vtkCell *cell, vtkGenericCell *gencell,
+  //   vtkIdType cellId, double tol2, int& subId,
+  //   double pcoords[3], double *weights) VTK_OVERRIDE;
+  // vtkCell *FindAndGetCell(double x[3], vtkCell *cell, vtkIdType cellId,
+  //                                 double tol2, int& subId, double pcoords[3],
+  //                                 double *weights) VTK_OVERRIDE;
+  // int GetCellType(vtkIdType cellId) VTK_OVERRIDE;
+  // void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds) VTK_OVERRIDE
+  //   {vtkStructuredData::GetCellPoints(cellId,ptIds,this->DataDescription,
+  //                                     this->GetDimensions());}
+  // void GetPointCells(vtkIdType ptId, vtkIdList *cellIds) VTK_OVERRIDE
+  //   {vtkStructuredData::GetPointCells(ptId,cellIds,this->GetDimensions());}
+  // void ComputeBounds() VTK_OVERRIDE;
+  // int GetMaxCellSize() VTK_OVERRIDE {return 8;}; //voxel is the largest
+
+  publicAPI.getBounds = () => publicAPI.extentToBounds(publicAPI.getSpatialExtent());
+  publicAPI.extentToBounds = ex => _BoundingBox_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"].transformBounds */ .ZP.transformBounds(ex, model.indexToWorld);
+  publicAPI.getSpatialExtent = () => _BoundingBox_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"].inflate */ .ZP.inflate([...model.extent], 0.5);
+
+  // Internal, shouldn't need to call this manually.
+  publicAPI.computeTransforms = () => {
+    gl_matrix__WEBPACK_IMPORTED_MODULE_6__/* .mat4.fromTranslation */ ._E.fromTranslation(model.indexToWorld, model.origin);
+    model.indexToWorld[0] = model.direction[0];
+    model.indexToWorld[1] = model.direction[1];
+    model.indexToWorld[2] = model.direction[2];
+    model.indexToWorld[4] = model.direction[3];
+    model.indexToWorld[5] = model.direction[4];
+    model.indexToWorld[6] = model.direction[5];
+    model.indexToWorld[8] = model.direction[6];
+    model.indexToWorld[9] = model.direction[7];
+    model.indexToWorld[10] = model.direction[8];
+    gl_matrix__WEBPACK_IMPORTED_MODULE_6__/* .mat4.scale */ ._E.scale(model.indexToWorld, model.indexToWorld, model.spacing);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_6__/* .mat4.invert */ ._E.invert(model.worldToIndex, model.indexToWorld);
+  };
+  publicAPI.indexToWorld = function (ain) {
+    let aout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    gl_matrix__WEBPACK_IMPORTED_MODULE_6__/* .vec3.transformMat4 */ .R3.transformMat4(aout, ain, model.indexToWorld);
+    return aout;
+  };
+  publicAPI.indexToWorldVec3 = publicAPI.indexToWorld;
+  publicAPI.worldToIndex = function (ain) {
+    let aout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    gl_matrix__WEBPACK_IMPORTED_MODULE_6__/* .vec3.transformMat4 */ .R3.transformMat4(aout, ain, model.worldToIndex);
+    return aout;
+  };
+  publicAPI.worldToIndexVec3 = publicAPI.worldToIndex;
+  publicAPI.indexToWorldBounds = function (bin) {
+    let bout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    return _BoundingBox_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"].transformBounds */ .ZP.transformBounds(bin, model.indexToWorld, bout);
+  };
+  publicAPI.worldToIndexBounds = function (bin) {
+    let bout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    return _BoundingBox_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"].transformBounds */ .ZP.transformBounds(bin, model.worldToIndex, bout);
+  };
+
+  // Make sure the transform is correct
+  publicAPI.onModified(publicAPI.computeTransforms);
+  publicAPI.computeTransforms();
+  publicAPI.getCenter = () => _BoundingBox_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"].getCenter */ .ZP.getCenter(publicAPI.getBounds());
+  publicAPI.computeHistogram = function (worldBounds) {
+    let voxelFunc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    const bounds = [0, 0, 0, 0, 0, 0];
+    publicAPI.worldToIndexBounds(worldBounds, bounds);
+    const point1 = [0, 0, 0];
+    const point2 = [0, 0, 0];
+    _BoundingBox_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"].computeCornerPoints */ .ZP.computeCornerPoints(bounds, point1, point2);
+    (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_1__.b)(point1, point1);
+    (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_1__.b)(point2, point2);
+    const dimensions = publicAPI.getDimensions();
+    (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_1__.c)(point1, [0, 0, 0], [dimensions[0] - 1, dimensions[1] - 1, dimensions[2] - 1], point1);
+    (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_1__.c)(point2, [0, 0, 0], [dimensions[0] - 1, dimensions[1] - 1, dimensions[2] - 1], point2);
+    const yStride = dimensions[0];
+    const zStride = dimensions[0] * dimensions[1];
+    const pixels = publicAPI.getPointData().getScalars().getData();
+    let maximum = -Infinity;
+    let minimum = Infinity;
+    let sumOfSquares = 0;
+    let isum = 0;
+    let inum = 0;
+    for (let z = point1[2]; z <= point2[2]; z++) {
+      for (let y = point1[1]; y <= point2[1]; y++) {
+        let index = point1[0] + y * yStride + z * zStride;
+        for (let x = point1[0]; x <= point2[0]; x++) {
+          if (!voxelFunc || voxelFunc([x, y, z], bounds)) {
+            const pixel = pixels[index];
+            if (pixel > maximum) maximum = pixel;
+            if (pixel < minimum) minimum = pixel;
+            sumOfSquares += pixel * pixel;
+            isum += pixel;
+            inum += 1;
+          }
+          ++index;
+        }
+      }
+    }
+    const average = inum > 0 ? isum / inum : 0;
+    const variance = inum ? Math.abs(sumOfSquares / inum - average * average) : 0;
+    const sigma = Math.sqrt(variance);
+    return {
+      minimum,
+      maximum,
+      average,
+      variance,
+      sigma,
+      count: inum
+    };
+  };
+
+  // TODO: use the unimplemented `vtkDataSetAttributes` for scalar length, that is currently also a TODO (GetNumberOfComponents).
+  // Scalar data could be tuples for color information?
+  publicAPI.computeIncrements = function (extent) {
+    let numberOfComponents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+    const increments = [];
+    let incr = numberOfComponents;
+
+    // Calculate array increment offsets
+    // similar to c++ vtkImageData::ComputeIncrements
+    for (let idx = 0; idx < 3; ++idx) {
+      increments[idx] = incr;
+      incr *= extent[idx * 2 + 1] - extent[idx * 2] + 1;
+    }
+    return increments;
+  };
+
+  /**
+   * @param {Number[]} index the localized `[i,j,k]` pixel array position. Float values will be rounded.
+   * @return {Number} the corresponding flattened index in the scalar array
+   */
+  publicAPI.computeOffsetIndex = _ref => {
+    let [i, j, k] = _ref;
+    const extent = publicAPI.getExtent();
+    const numberOfComponents = publicAPI.getPointData().getScalars().getNumberOfComponents();
+    const increments = publicAPI.computeIncrements(extent, numberOfComponents);
+    // Use the array increments to find the pixel index
+    // similar to c++ vtkImageData::GetArrayPointer
+    // Math.floor to catch "practically 0" e^-15 scenarios.
+    return Math.floor((Math.round(i) - extent[0]) * increments[0] + (Math.round(j) - extent[2]) * increments[1] + (Math.round(k) - extent[4]) * increments[2]);
+  };
+
+  /**
+   * @param {Number[]} xyz the [x,y,z] Array in world coordinates
+   * @return {Number|NaN} the corresponding pixel's index in the scalar array
+   */
+  publicAPI.getOffsetIndexFromWorld = xyz => {
+    const extent = publicAPI.getExtent();
+    const index = publicAPI.worldToIndex(xyz);
+
+    // Confirm indexed i,j,k coords are within the bounds of the volume
+    for (let idx = 0; idx < 3; ++idx) {
+      if (index[idx] < extent[idx * 2] || index[idx] > extent[idx * 2 + 1]) {
+        vtkErrorMacro(`GetScalarPointer: Pixel ${index} is not in memory. Current extent = ${extent}`);
+        return NaN;
+      }
+    }
+
+    // Assumed the index here is within 0 <-> scalarData.length, but doesn't hurt to check upstream
+    return publicAPI.computeOffsetIndex(index);
+  };
+  /**
+   * @param {Number[]} xyz the [x,y,z] Array in world coordinates
+   * @param {Number?} comp the scalar component index for multi-component scalars
+   * @return {Number|NaN} the corresponding pixel's scalar value
+   */
+  publicAPI.getScalarValueFromWorld = function (xyz) {
+    let comp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    const numberOfComponents = publicAPI.getPointData().getScalars().getNumberOfComponents();
+    if (comp < 0 || comp >= numberOfComponents) {
+      vtkErrorMacro(`GetScalarPointer: Scalar Component ${comp} is not within bounds. Current Scalar numberOfComponents: ${numberOfComponents}`);
+      return NaN;
+    }
+    const offsetIndex = publicAPI.getOffsetIndexFromWorld(xyz);
+    if (Number.isNaN(offsetIndex)) {
+      // VTK Error Macro will have been tripped already, no need to do it again,
+      return offsetIndex;
+    }
+    return publicAPI.getPointData().getScalars().getComponent(offsetIndex, comp);
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  direction: null,
+  // a mat3
+  indexToWorld: null,
+  // a mat4
+  worldToIndex: null,
+  // a mat4
+  spacing: [1.0, 1.0, 1.0],
+  origin: [0.0, 0.0, 0.0],
+  extent: [0, -1, 0, -1, 0, -1],
+  dataDescription: _StructuredData_Constants_js__WEBPACK_IMPORTED_MODULE_5__/* .StructuredType */ ._.EMPTY
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Inheritance
+  _DataSet_js__WEBPACK_IMPORTED_MODULE_3__["default"].extend(publicAPI, model, initialValues);
+  if (!model.direction) {
+    model.direction = gl_matrix__WEBPACK_IMPORTED_MODULE_6__/* .mat3.identity */ .wO.identity(new Float64Array(9));
+  } else if (Array.isArray(model.direction)) {
+    model.direction = new Float64Array(model.direction.slice(0, 9));
+  }
+  model.indexToWorld = new Float64Array(16);
+  model.worldToIndex = new Float64Array(16);
+
+  // Set/Get methods
+  _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.get(publicAPI, model, ['indexToWorld', 'worldToIndex']);
+  _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.setGetArray(publicAPI, model, ['origin', 'spacing'], 3);
+  _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.setGetArray(publicAPI, model, ['direction'], 9);
+  _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.getArray(publicAPI, model, ['extent'], 6);
+
+  // Object specific methods
+  vtkImageData(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = _macros2_js__WEBPACK_IMPORTED_MODULE_0__.m.newInstance(extend, 'vtkImageData');
+
+// ----------------------------------------------------------------------------
+
+var vtkImageData$1 = {
+  newInstance,
+  extend
+};
+
+
+
+
+/***/ }),
+
+/***/ 3969:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   ZP: () => (/* binding */ vtkPlane$1)
+/* harmony export */ });
+/* unused harmony exports STATIC, extend, newInstance, vtkPlane */
+/* harmony import */ var _Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(59474);
+/* harmony import */ var _macros2_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(68470);
+
+
+
+const PLANE_TOLERANCE = 1.0e-6;
+const COINCIDE = 'coincide';
+const DISJOINT = 'disjoint';
+
+// ----------------------------------------------------------------------------
+// Global methods
+// ----------------------------------------------------------------------------
+
+function evaluate(normal, origin, x) {
+  return normal[0] * (x[0] - origin[0]) + normal[1] * (x[1] - origin[1]) + normal[2] * (x[2] - origin[2]);
+}
+function distanceToPlane(x, origin, normal) {
+  const distance = normal[0] * (x[0] - origin[0]) + normal[1] * (x[1] - origin[1]) + normal[2] * (x[2] - origin[2]);
+  return Math.abs(distance);
+}
+function projectPoint(x, origin, normal, xproj) {
+  const xo = [];
+  (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.s)(x, origin, xo);
+  const t = (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(normal, xo);
+  xproj[0] = x[0] - t * normal[0];
+  xproj[1] = x[1] - t * normal[1];
+  xproj[2] = x[2] - t * normal[2];
+}
+function projectVector(v, normal, vproj) {
+  const t = (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(v, normal);
+  let n2 = (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(normal, normal);
+  if (n2 === 0) {
+    n2 = 1.0;
+  }
+  vproj[0] = v[0] - t * normal[0] / n2;
+  vproj[1] = v[1] - t * normal[1] / n2;
+  vproj[2] = v[2] - t * normal[2] / n2;
+  return vproj;
+}
+function generalizedProjectPoint(x, origin, normal, xproj) {
+  const xo = [];
+  (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.s)(x, origin, xo);
+  const t = (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(normal, xo);
+  const n2 = (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(normal, normal);
+  if (n2 !== 0) {
+    xproj[0] = x[0] - t * normal[0] / n2;
+    xproj[1] = x[1] - t * normal[1] / n2;
+    xproj[2] = x[2] - t * normal[2] / n2;
+  } else {
+    xproj[0] = x[0];
+    xproj[1] = x[1];
+    xproj[2] = x[2];
+  }
+}
+function intersectWithLine(p1, p2, origin, normal) {
+  const outObj = {
+    intersection: false,
+    betweenPoints: false,
+    t: Number.MAX_VALUE,
+    x: []
+  };
+  const p21 = [];
+  const p1Origin = [];
+  // Compute line vector
+  (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.s)(p2, p1, p21);
+  (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.s)(origin, p1, p1Origin);
+
+  // Compute denominator.  If ~0, line and plane are parallel.
+  // const num = vtkMath.dot(normal, origin) - vtkMath.dot(normal, p1);
+  const num = (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(normal, p1Origin);
+  const den = (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(normal, p21);
+
+  // If denominator with respect to numerator is "zero", then the line and
+  // plane are considered parallel.
+  let fabsden;
+  let fabstolerance;
+
+  // Trying to avoid an expensive call to fabs()
+  if (den < 0.0) {
+    fabsden = -den;
+  } else {
+    fabsden = den;
+  }
+  if (num < 0.0) {
+    fabstolerance = -num * PLANE_TOLERANCE;
+  } else {
+    fabstolerance = num * PLANE_TOLERANCE;
+  }
+  if (fabsden <= fabstolerance) {
+    return outObj;
+  }
+
+  // Where on the line between p1 and p2 is the intersection
+  // If between 0 and 1, it is between the two points. If < 0 it's before p1, if > 1 it's after p2
+  outObj.t = num / den;
+  outObj.x[0] = p1[0] + outObj.t * p21[0];
+  outObj.x[1] = p1[1] + outObj.t * p21[1];
+  outObj.x[2] = p1[2] + outObj.t * p21[2];
+  outObj.intersection = true;
+  outObj.betweenPoints = outObj.t >= 0.0 && outObj.t <= 1.0;
+  return outObj;
+}
+function intersectWithPlane(plane1Origin, plane1Normal, plane2Origin, plane2Normal) {
+  const outObj = {
+    intersection: false,
+    l0: [],
+    l1: [],
+    error: null
+  };
+  const cross$1 = [];
+  (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.j)(plane1Normal, plane2Normal, cross$1);
+  const absCross = cross$1.map(n => Math.abs(n));
+
+  // test if the two planes are parallel
+  if (absCross[0] + absCross[1] + absCross[2] < PLANE_TOLERANCE) {
+    // test if disjoint or coincide
+    const v = [];
+    (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.s)(plane1Origin, plane2Origin, v);
+    if ((0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(plane1Normal, v) === 0) {
+      outObj.error = COINCIDE;
+    } else {
+      outObj.error = DISJOINT;
+    }
+    return outObj;
+  }
+
+  // Plane1 and Plane2 intersect in a line
+  // first determine max abs coordinate of the cross product
+  let maxc;
+  if (absCross[0] > absCross[1] && absCross[0] > absCross[2]) {
+    maxc = 'x';
+  } else if (absCross[1] > absCross[2]) {
+    maxc = 'y';
+  } else {
+    maxc = 'z';
+  }
+
+  // To get a point on the intersect line, zero the max coord, and solve for the other two
+  const iP = []; // intersectionPoint
+  // the constants in the 2 plane equations
+  const d1 = -(0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(plane1Normal, plane1Origin);
+  const d2 = -(0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.d)(plane2Normal, plane2Origin);
+
+  // eslint-disable-next-line default-case
+  switch (maxc) {
+    case 'x':
+      // intersect with x=0
+      iP[0] = 0;
+      iP[1] = (d2 * plane1Normal[2] - d1 * plane2Normal[2]) / cross$1[0];
+      iP[2] = (d1 * plane2Normal[1] - d2 * plane1Normal[1]) / cross$1[0];
+      break;
+    case 'y':
+      // intersect with y=0
+      iP[0] = (d1 * plane2Normal[2] - d2 * plane1Normal[2]) / cross$1[1];
+      iP[1] = 0;
+      iP[2] = (d2 * plane1Normal[0] - d1 * plane2Normal[0]) / cross$1[1];
+      break;
+    case 'z':
+      // intersect with z=0
+      iP[0] = (d2 * plane1Normal[1] - d1 * plane2Normal[1]) / cross$1[2];
+      iP[1] = (d1 * plane2Normal[0] - d2 * plane1Normal[0]) / cross$1[2];
+      iP[2] = 0;
+      break;
+  }
+  outObj.l0 = iP;
+  (0,_Core_Math_index_js__WEBPACK_IMPORTED_MODULE_0__.k)(iP, cross$1, outObj.l1);
+  outObj.intersection = true;
+  return outObj;
+}
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+const STATIC = {
+  evaluate,
+  distanceToPlane,
+  projectPoint,
+  projectVector,
+  generalizedProjectPoint,
+  intersectWithLine,
+  intersectWithPlane,
+  DISJOINT,
+  COINCIDE
+};
+
+// ----------------------------------------------------------------------------
+// vtkPlane methods
+// ----------------------------------------------------------------------------
+
+function vtkPlane(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkPlane');
+  publicAPI.distanceToPlane = x => distanceToPlane(x, model.origin, model.normal);
+  publicAPI.projectPoint = (x, xproj) => {
+    projectPoint(x, model.origin, model.normal, xproj);
+  };
+  publicAPI.projectVector = (v, vproj) => projectVector(v, model.normal, vproj);
+  publicAPI.push = distance => {
+    if (distance === 0.0) {
+      return;
+    }
+    for (let i = 0; i < 3; i++) {
+      model.origin[i] += distance * model.normal[i];
+    }
+  };
+  publicAPI.generalizedProjectPoint = (x, xproj) => {
+    generalizedProjectPoint(x, model.origin, model.normal, xproj);
+  };
+  publicAPI.evaluateFunction = (x, y, z) => {
+    if (!Array.isArray(x)) {
+      return model.normal[0] * (x - model.origin[0]) + model.normal[1] * (y - model.origin[1]) + model.normal[2] * (z - model.origin[2]);
+    }
+    return model.normal[0] * (x[0] - model.origin[0]) + model.normal[1] * (x[1] - model.origin[1]) + model.normal[2] * (x[2] - model.origin[2]);
+  };
+  publicAPI.evaluateGradient = xyz => {
+    const retVal = [model.normal[0], model.normal[1], model.normal[2]];
+    return retVal;
+  };
+  publicAPI.intersectWithLine = (p1, p2) => intersectWithLine(p1, p2, model.origin, model.normal);
+  publicAPI.intersectWithPlane = (planeOrigin, planeNormal) => intersectWithPlane(planeOrigin, planeNormal, model.origin, model.normal);
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  normal: [0.0, 0.0, 1.0],
+  origin: [0.0, 0.0, 0.0]
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Object methods
+  _macros2_js__WEBPACK_IMPORTED_MODULE_1__.m.obj(publicAPI, model);
+  _macros2_js__WEBPACK_IMPORTED_MODULE_1__.m.setGetArray(publicAPI, model, ['normal', 'origin'], 3);
+  vtkPlane(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = _macros2_js__WEBPACK_IMPORTED_MODULE_1__.m.newInstance(extend, 'vtkPlane');
+
+// ----------------------------------------------------------------------------
+
+var vtkPlane$1 = {
+  newInstance,
+  extend,
+  ...STATIC
+};
+
+
+
+
+/***/ })
+
+}]);