@kitware/vtk.js 34.6.0 → 34.8.0

package/Filters/Sources/ArcSource.js

@@ -0,0 +1,138 @@
+import { m as macro } from '../../macros2.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
+import vtkDataArray from '../../Common/Core/DataArray.js';
+import { f as vtkMath } from '../../Common/Core/Math/index.js';
+import vtkPoints from '../../Common/Core/Points.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import { DesiredOutputPrecision } from '../../Common/DataModel/DataSetAttributes/Constants.js';
+
+const {
+  VtkDataTypes
+} = vtkDataArray;
+
+// ----------------------------------------------------------------------------
+// vtkArcSource methods
+// ----------------------------------------------------------------------------
+
+function vtkArcSource(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkArcSource');
+  publicAPI.requestData = (inData, outData) => {
+    const numLines = model.resolution;
+    const numPts = model.resolution + 1;
+    const tc = [0.0, 0.0];
+    const output = outData[0] || vtkPolyData.newInstance();
+    let angle = 0.0;
+    let radius = 0.5;
+    const perpendicular = [0, 0, 0];
+    const v1 = [0, 0, 0];
+    if (model.useNormalAndAngle) {
+      angle = vtkMath.radiansFromDegrees(model.angle);
+      v1[0] = model.polarVector[0];
+      v1[1] = model.polarVector[1];
+      v1[2] = model.polarVector[2];
+      vtkMath.cross(model.normal, model.polarVector, perpendicular);
+      radius = vtkMath.normalize(v1);
+    } else {
+      vtkMath.subtract(model.point1, model.center, v1);
+      const v2 = [0, 0, 0];
+      vtkMath.subtract(model.point2, model.center, v2);
+      const normal = [0, 0, 0];
+      vtkMath.cross(v1, v2, normal);
+      vtkMath.cross(normal, v1, perpendicular);
+      const dotProduct = vtkMath.dot(v1, v2) / (vtkMath.norm(v1) * vtkMath.norm(v2));
+      angle = Math.acos(dotProduct);
+      if (model.negative) {
+        angle -= 2.0 * Math.PI;
+      }
+      radius = vtkMath.normalize(v1);
+    }
+    const angleInc = angle / model.resolution;
+    vtkMath.normalize(perpendicular);
+    let pointType = 0;
+    if (model.outputPointsPrecision === DesiredOutputPrecision.SINGLE) {
+      pointType = VtkDataTypes.FLOAT;
+    } else if (model.outputPointsPrecision === DesiredOutputPrecision.DOUBLE) {
+      pointType = VtkDataTypes.DOUBLE;
+    }
+    const points = vtkPoints.newInstance({
+      dataType: pointType
+    });
+    points.setNumberOfPoints(numPts);
+    const tcoords = vtkDataArray.newInstance({
+      numberOfComponents: 2,
+      size: numPts * 2,
+      dataType: VtkDataTypes.FLOAT,
+      name: 'TextureCoordinates'
+    });
+    const lines = vtkCellArray.newInstance();
+    lines.allocate(numLines);
+    let theta = 0.0;
+    for (let i = 0; i <= model.resolution; ++i, theta += angleInc) {
+      const cosine = Math.cos(theta);
+      const sine = Math.sin(theta);
+      const p = [model.center[0] + cosine * radius * v1[0] + sine * radius * perpendicular[0], model.center[1] + cosine * radius * v1[1] + sine * radius * perpendicular[1], model.center[2] + cosine * radius * v1[2] + sine * radius * perpendicular[2]];
+      tc[0] = i / model.resolution;
+      tc[1] = 0.0;
+      points.setPoint(i, ...p);
+      tcoords.setTuple(i, tc);
+    }
+    const pointIds = Array.from({
+      length: numPts
+    }, (_, i) => i);
+    lines.insertNextCell(pointIds);
+    output.setPoints(points);
+    output.getPointData().setTCoords(tcoords);
+    output.setLines(lines);
+    outData[0] = output;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  point1: [0.0, 0.5, 0.0],
+  point2: [0.5, 0.0, 0.0],
+  center: [0.0, 0.0, 0.0],
+  normal: [0.0, 0.0, 1.0],
+  polarVector: [1.0, 0.0, 0.0],
+  angle: 90.0,
+  resolution: 6,
+  negative: false,
+  useNormalAndAngle: false,
+  outputPointsPrecision: DesiredOutputPrecision.SINGLE
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Ensure resolution is at least 1
+  if (model.resolution < 1) {
+    model.resolution = 1;
+  }
+
+  // Build VTK API
+  macro.obj(publicAPI, model);
+  macro.algo(publicAPI, model, 0, 1);
+  macro.setGet(publicAPI, model, ['resolution', 'angle', 'negative', 'useNormalAndAngle', 'outputPointsPrecision']);
+  macro.setGetArray(publicAPI, model, ['point1', 'point2', 'center', 'normal', 'polarVector'], 3);
+  vtkArcSource(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkArcSource');
+
+// ----------------------------------------------------------------------------
+
+var vtkArcSource$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkArcSource$1 as default, extend, newInstance };

package/Filters/Sources/EllipseArcSource.d.ts

@@ -0,0 +1,212 @@
+import { DesiredOutputPrecision } from './../../Common/DataModel/DataSetAttributes';
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import { Vector3 } from './../../types';
+
+/**
+ *
+ */
+export interface IEllipseArcSourceInitialValues {
+  center?: Vector3;
+  normal?: Vector3;
+  majorRadiusVector?: Vector3;
+  startAngle?: number;
+  segmentAngle?: number;
+  resolution?: number;
+  close?: boolean;
+  outputPointsPrecision?: DesiredOutputPrecision;
+  ratio?: number;
+}
+
+type vtkEllipseArcSourceBase = vtkObject &
+  Omit<
+    vtkAlgorithm,
+    | 'getInputData'
+    | 'setInputData'
+    | 'setInputConnection'
+    | 'getInputConnection'
+    | 'addInputConnection'
+    | 'addInputData'
+  >;
+
+export interface vtkEllipseArcSource extends vtkEllipseArcSourceBase {
+  /**
+   * Get whether the arc is closed.
+   */
+  getClose(): boolean;
+
+  /**
+   * Get the center of the arc.
+   */
+  getCenter(): Vector3;
+
+  /**
+   * Get the center of the arc by reference.
+   */
+  getCenterByReference(): Vector3;
+
+  /**
+   * Get the major radius vector of the arc.
+   */
+  getMajorRadiusVector(): Vector3;
+
+  /**
+   * Get the major radius vector of the arc by reference.
+   */
+  getMajorRadiusVectorByReference(): Vector3;
+
+  /**
+   * Get the normal vector of the arc.
+   */
+  getNormal(): Vector3;
+
+  /**
+   * Get the normal vector of the arc by reference.
+   */
+  getNormalByReference(): Vector3;
+
+  /**
+   * Get the output points precision.
+   */
+  getOutputPointsPrecision(): DesiredOutputPrecision;
+
+  /**
+   * Get the ratio of the arc.
+   */
+  getRatio(): number;
+
+  /**
+   * Get the resolution of the arc.
+   */
+  getResolution(): number;
+
+  /**
+   * Get the segment angle of the arc.
+   */
+  getSegmentAngle(): number;
+
+  /**
+   * Get the start angle of the arc.
+   */
+  getStartAngle(): number;
+
+  /**
+   *
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   * Set whether the arc is closed.
+   * @param {Boolean} close Whether the arc is closed.
+   */
+  setClose(close: boolean): boolean;
+
+  /**
+   * Set the center of the arc.
+   * @param {Vector3} center The center's coordinates.
+   */
+  setCenter(center: Vector3): boolean;
+
+  /**
+   * Set the center of the arc by reference.
+   * @param {Vector3} center The center's coordinates.
+   */
+  setCenterFrom(center: Vector3): boolean;
+
+  /**
+   * Set the major radius vector of the arc.
+   * @param {Vector3} majorRadiusVector The major radius vector's coordinates.
+   */
+  setMajorRadiusVector(majorRadiusVector: Vector3): boolean;
+
+  /**
+   * Set the major radius vector of the arc by reference.
+   * @param {Vector3} majorRadiusVector The major radius vector's coordinates.
+   */
+  setMajorRadiusVectorFrom(majorRadiusVector: Vector3): boolean;
+
+  /**
+   * Set the normal vector of the arc.
+   * @param {Vector3} normal The normal vector's coordinates.
+   */
+  setNormal(normal: Vector3): boolean;
+
+  /**
+   * Set the normal vector of the arc by reference.
+   * @param {Vector3} normal The normal vector's coordinates.
+   */
+  setNormalFrom(normal: Vector3): boolean;
+
+  /**
+   * Set the output points precision.
+   * @param {DesiredOutputPrecision} precision The desired output precision.
+   */
+  setOutputPointsPrecision(precision: DesiredOutputPrecision): boolean;
+
+  /**
+   * Set the ratio of the arc.
+   * @param {Number} ratio The ratio of the arc.
+   */
+  setRatio(ratio: number): boolean;
+
+  /**
+   * Set the resolution of the arc.
+   * @param {Number} resolution The number of points in the arc.
+   */
+  setResolution(resolution: number): boolean;
+
+  /**
+   * Set the segment angle of the arc.
+   * @param {Number} segmentAngle The segment angle in degrees.
+   */
+  setSegmentAngle(segmentAngle: number): boolean;
+
+  /**
+   * Set the start angle of the arc.
+   * @param {Number} startAngle The start angle in degrees.
+   */
+  setStartAngle(startAngle: number): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with
+ * vtkEllipseArcSource characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IEllipseArcSourceInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IEllipseArcSourceInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkEllipseArcSource.
+ * @param {IEllipseArcSourceInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IEllipseArcSourceInitialValues
+): vtkEllipseArcSource;
+
+/**
+ * vtkEllipseArcSource is a source object that creates an elliptical arc defined
+ * by a normal, a center and the major radius vector. You can define an angle to
+ * draw only a section of the ellipse. The number of segments composing the
+ * polyline is controlled by setting the object resolution.
+ *
+ * @example
+ * ```js
+ * import vtkEllipseArcSource from '@kitware/vtk.js/Filters/Sources/EllipseArcSource';
+ *
+ * const arc = vtkEllipseArcSource.newInstance();
+ * const polydata = arc.getOutputData();
+ * ```
+ */
+export declare const vtkEllipseArcSource: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkEllipseArcSource;

package/Filters/Sources/EllipseArcSource.js

@@ -0,0 +1,159 @@
+import { m as macro } from '../../macros2.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
+import vtkDataArray from '../../Common/Core/DataArray.js';
+import { f as vtkMath } from '../../Common/Core/Math/index.js';
+import vtkPoints from '../../Common/Core/Points.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import { DesiredOutputPrecision } from '../../Common/DataModel/DataSetAttributes/Constants.js';
+
+const {
+  vtkErrorMacro
+} = macro;
+const {
+  VtkDataTypes
+} = vtkDataArray;
+
+// ----------------------------------------------------------------------------
+// vtkEllipseArcSource methods
+// ----------------------------------------------------------------------------
+
+function vtkEllipseArcSource(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkEllipseArcSource');
+  publicAPI.requestData = (inData, outData) => {
+    const isClosedShape = Math.abs(model.segmentAngle - 360.0) < 1e-5;
+    const resolution = model.close && !isClosedShape ? model.resolution + 1 : model.resolution;
+    const numLines = resolution;
+    const numPts = resolution + 1;
+    const tc = [0.0, 0.0];
+    const output = outData[0] || vtkPolyData.newInstance();
+
+    // Make sure the normal vector is normalized
+    const normal = [...model.normal];
+    vtkMath.normalize(normal);
+
+    // Get orthogonal vector between user-defined major radius and normal
+    const orthogonalVect = [0, 0, 0];
+    vtkMath.cross(normal, model.majorRadiusVector, orthogonalVect);
+    if (vtkMath.norm(orthogonalVect) < 1e-10) {
+      vtkErrorMacro('Ellipse normal vector and major radius axis are collinear');
+      return;
+    }
+    vtkMath.normalize(orthogonalVect);
+    const majorRadiusVect = [0, 0, 0];
+    vtkMath.cross(orthogonalVect, normal, majorRadiusVect);
+    vtkMath.normalize(majorRadiusVect);
+    const a = vtkMath.norm(model.majorRadiusVector);
+    const b = a * model.ratio;
+    let startAngleRad = vtkMath.radiansFromDegrees(model.startAngle);
+    if (startAngleRad < 0) {
+      startAngleRad += 2.0 * Math.PI;
+    }
+    const segmentAngleRad = vtkMath.radiansFromDegrees(model.segmentAngle);
+    const angleIncRad = segmentAngleRad / model.resolution;
+    let pointType = VtkDataTypes.FLOAT;
+    if (model.outputPointsPrecision === DesiredOutputPrecision.SINGLE) {
+      pointType = VtkDataTypes.FLOAT;
+    } else if (model.outputPointsPrecision === DesiredOutputPrecision.DOUBLE) {
+      pointType = VtkDataTypes.DOUBLE;
+    }
+    const points = vtkPoints.newInstance({
+      dataType: pointType
+    });
+    points.setNumberOfPoints(numPts);
+    const tcoords = vtkDataArray.newInstance({
+      numberOfComponents: 2,
+      size: numPts * 2,
+      dataType: VtkDataTypes.FLOAT,
+      name: 'TextureCoordinates'
+    });
+    const lines = vtkCellArray.newInstance();
+    lines.allocate(numLines);
+    const skipLastPoint = model.close && isClosedShape;
+    let theta = startAngleRad;
+    let pointIndex = 0;
+    for (let i = 0; i <= resolution; ++i, theta += angleIncRad) {
+      const quotient = Math.floor(theta / (2.0 * Math.PI));
+      const normalizedTheta = theta - quotient * 2.0 * Math.PI;
+      let thetaEllipse = Math.atan(Math.tan(normalizedTheta) * model.ratio);
+      if (normalizedTheta > Math.PI / 2 && normalizedTheta <= Math.PI) {
+        thetaEllipse += Math.PI;
+      } else if (normalizedTheta > Math.PI && normalizedTheta <= 1.5 * Math.PI) {
+        thetaEllipse -= Math.PI;
+      }
+      const cosTheta = Math.cos(thetaEllipse);
+      const sinTheta = Math.sin(thetaEllipse);
+      const p = [model.center[0] + a * cosTheta * majorRadiusVect[0] + b * sinTheta * orthogonalVect[0], model.center[1] + a * cosTheta * majorRadiusVect[1] + b * sinTheta * orthogonalVect[1], model.center[2] + a * cosTheta * majorRadiusVect[2] + b * sinTheta * orthogonalVect[2]];
+      tc[0] = i / resolution;
+      tc[1] = 0.0;
+      if (i !== resolution || !skipLastPoint) {
+        points.setPoint(pointIndex, ...p);
+        tcoords.setTuple(pointIndex, tc);
+        pointIndex++;
+      }
+    }
+    const actualNumPts = pointIndex;
+    const pointIds = [];
+    for (let k = 0; k < actualNumPts - 1; ++k) {
+      pointIds.push(k);
+    }
+    if (model.close) {
+      pointIds.push(0);
+    } else {
+      pointIds.push(actualNumPts - 1);
+    }
+    lines.insertNextCell(pointIds);
+    output.setPoints(points);
+    output.getPointData().setTCoords(tcoords);
+    output.setLines(lines);
+    outData[0] = output;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  center: [0.0, 0.0, 0.0],
+  normal: [0.0, 0.0, 1.0],
+  majorRadiusVector: [1.0, 0.0, 0.0],
+  startAngle: 0.0,
+  segmentAngle: 90.0,
+  resolution: 100,
+  close: false,
+  outputPointsPrecision: DesiredOutputPrecision.SINGLE,
+  ratio: 1.0
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Ensure resolution is at least 1
+  if (model.resolution < 1) {
+    model.resolution = 1;
+  }
+
+  // Build VTK API
+  macro.obj(publicAPI, model);
+  macro.algo(publicAPI, model, 0, 1);
+  macro.setGet(publicAPI, model, ['resolution', 'startAngle', 'segmentAngle', 'close', 'outputPointsPrecision', 'ratio']);
+  macro.setGetArray(publicAPI, model, ['center', 'normal', 'majorRadiusVector'], 3);
+  vtkEllipseArcSource(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkEllipseArcSource');
+
+// ----------------------------------------------------------------------------
+
+var vtkEllipseArcSource$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkEllipseArcSource$1 as default, extend, newInstance };

package/Filters/Sources/PlatonicSolidSource/Constants.d.ts

@@ -0,0 +1,12 @@
+export declare enum SolidType {
+  VTK_SOLID_TETRAHEDRON = 0,
+  VTK_SOLID_CUBE = 1,
+  VTK_SOLID_OCTAHEDRON = 2,
+  VTK_SOLID_ICOSAHEDRON = 3,
+  VTK_SOLID_DODECAHEDRON = 4,
+}
+
+declare const _default: {
+  SolidType: typeof SolidType;
+};
+export default _default;

package/Filters/Sources/PlatonicSolidSource/Constants.js

@@ -0,0 +1,12 @@
+const SolidType = {
+  VTK_SOLID_TETRAHEDRON: 0,
+  VTK_SOLID_CUBE: 1,
+  VTK_SOLID_OCTAHEDRON: 2,
+  VTK_SOLID_ICOSAHEDRON: 3,
+  VTK_SOLID_DODECAHEDRON: 4
+};
+var Constants = {
+  SolidType
+};
+
+export { SolidType, Constants as default };

package/Filters/Sources/PlatonicSolidSource.d.ts

@@ -0,0 +1,109 @@
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import { DesiredOutputPrecision } from './../../Common/DataModel/DataSetAttributes';
+import { SolidType } from './PlatonicSolidSource/Constants';
+
+/**
+ *
+ */
+export interface IPlatonicSolidSourceInitialValues {
+  solidType?: SolidType;
+  outputPointsPrecision?: DesiredOutputPrecision;
+  scale?: number;
+}
+
+type vtkPlatonicSolidSourceBase = vtkObject &
+  Omit<
+    vtkAlgorithm,
+    | 'getInputData'
+    | 'setInputData'
+    | 'setInputConnection'
+    | 'getInputConnection'
+    | 'addInputConnection'
+    | 'addInputData'
+  >;
+
+export interface vtkPlatonicSolidSource extends vtkPlatonicSolidSourceBase {
+  /**
+   * Get the desired output precision.
+   * @returns {DesiredOutputPrecision}
+   */
+  getOutputPointsPrecision(): DesiredOutputPrecision;
+
+  /**
+   * Get the scale factor of the source.
+   */
+  getScale(): number;
+
+  /**
+   * Get the solid type of the source.
+   * @returns {SolidType}
+   */
+  getSolidType(): SolidType;
+
+  /**
+   * Request data for the source.
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   * Set the desired output precision.
+   * @param {DesiredOutputPrecision} outputPointsPrecision
+   */
+  setOutputPointsPrecision(
+    outputPointsPrecision: DesiredOutputPrecision
+  ): boolean;
+
+  /**
+   * Set the scale factor of the source.
+   * @param {Number} scale The scale factor.
+   */
+  setScale(scale: number): boolean;
+
+  /**
+   * Set the solid type of the source.
+   * @param {SolidType} solidType
+   */
+  setSolidType(solidType: SolidType): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkPlatonicSolidSource characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IPlatonicSolidSourceInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IPlatonicSolidSourceInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkPlatonicSolidSource.
+ * @param {IPlatonicSolidSourceInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IPlatonicSolidSourceInitialValues
+): vtkPlatonicSolidSource;
+
+/**
+ * vtkPlatonicSolidSource can generate each of the five Platonic solids:
+ * tetrahedron, cube, octahedron, icosahedron, and dodecahedron. Each of the
+ * solids is placed inside a sphere centered at the origin with radius 1.0.
+ *
+ * @example
+ * ```js
+ * import vtkPlatonicSolidSource from '@kitware/vtk.js/Filters/Sources/RegularPolygonSource';
+ *
+ * const regularPolygonSource = vtkPlatonicSolidSource.newInstance();
+ * const polydata = regularPolygonSource.getOutputData();
+ * ```
+ */
+export declare const vtkPlatonicSolidSource: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkPlatonicSolidSource;