@kitware/vtk.js 34.3.1 → 34.4.0

package/Filters/Sources/DiskSource.d.ts

@@ -0,0 +1,154 @@
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import { Vector3 } from './../../types';
+
+/**
+ *
+ */
+export interface IDiskSourceInitialValues {
+  innerRadius?: number;
+  outerRadius?: number;
+  center?: Vector3;
+  normal?: Vector3;
+  radialResolution?: number;
+  circumferentialResolution?: number;
+  pointType?: string;
+}
+
+type vtkDiskSourceBase = vtkObject &
+  Omit<
+    vtkAlgorithm,
+    | 'getInputData'
+    | 'setInputData'
+    | 'setInputConnection'
+    | 'getInputConnection'
+    | 'addInputConnection'
+    | 'addInputData'
+  >;
+
+export interface vtkDiskSource extends vtkDiskSourceBase {
+  /**
+   * Get the center of the disk.
+   */
+  getCenter(): Vector3;
+
+  /**
+   * Get the circumferential resolution of the disk.
+   */
+  getCircumferentialResolution(): number;
+
+  /**
+   * Get the inner radius of the disk.
+   */
+  getInnerRadius(): number;
+
+  /**
+   * Get the normal of the disk.
+   */
+  getNormal(): Vector3;
+
+  /**
+   * Get the outer radius of the disk.
+   */
+  getOuterRadius(): number;
+
+  /**
+   * Get the point type used for the disk.
+   */
+  getPointType(): string;
+
+  /**
+   * Get the radial resolution of the disk.
+   */
+  getRadialResolution(): number;
+
+  /**
+   * Expose methods
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   * Set the center of the disk.
+   * @param {Vector3} center
+   */
+  setCenter(center: Vector3): boolean;
+
+  /**
+   * Set the circumferential resolution of the disk.
+   * @param {number} resolution
+   */
+  setCircumferentialResolution(resolution: number): boolean;
+
+  /**
+   * Set the inner radius of the disk.
+   * @param {number} radius
+   */
+  setInnerRadius(radius: number): boolean;
+
+  /**
+   * Set the normal of the disk.
+   * @param {Vector3} normal
+   */
+  setNormal(normal: Vector3): boolean;
+
+  /**
+   * Set the outer radius of the disk.
+   * @param {number} radius
+   */
+  setOuterRadius(radius: number): boolean;
+
+  /**
+   * Set the point type used for the disk.
+   * @param {string} type
+   */
+  setPointType(type: string): boolean;
+
+  /**
+   * Set the radial resolution of the disk.
+   * @param {number} resolution
+   */
+  setRadialResolution(resolution: number): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkDiskSource characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IDiskSourceInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IDiskSourceInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkDiskSource.
+ * @param {IDiskSourceInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IDiskSourceInitialValues
+): vtkDiskSource;
+
+/**
+ * vtkDiskSource creates a polygonal disk with a hole in the center. The disk
+ * has zero height. The user can specify the inner and outer radius of the disk,
+ * the radial and circumferential resolution of the polygonal representation,
+ * and the center and plane normal of the disk (i.e., the center and disk normal
+ * control the position and orientation of the disk).
+ *
+ * @example
+ * ```js
+ * import vtkDiskSource from '@kitware/vtk.js/Filters/Sources/DiskSource';
+ *
+ * const disk = vtkDiskSource.newInstance({ radius: 1, resolution: 80 });
+ * const polydata = disk.getOutputData();
+ * ```
+ */
+export declare const vtkDiskSource: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkDiskSource;

package/Filters/Sources/DiskSource.js

@@ -0,0 +1,137 @@
+import { m as macro } from '../../macros2.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import vtkPoints from '../../Common/Core/Points.js';
+import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
+
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
+// vtkDiskSource methods
+// ----------------------------------------------------------------------------
+
+function vtkDiskSource(publicAPI, model) {
+  // Set our classname
+  model.classHierarchy.push('vtkDiskSource');
+  publicAPI.requestData = (inData, outData) => {
+    const {
+      innerRadius,
+      outerRadius,
+      center,
+      normal,
+      radialResolution,
+      circumferentialResolution,
+      pointType
+    } = model;
+    if (model.deleted) {
+      return;
+    }
+    let dataset = outData[0];
+
+    // Points
+    const points = vtkPoints.newInstance({
+      dataType: pointType
+    });
+    const n = [normal[0], normal[1], normal[2]];
+    const length = Math.hypot(n[0], n[1], n[2]);
+    if (length === 0) {
+      vtkErrorMacro('Normal vector cannot be zero-length');
+      return;
+    }
+    n[0] /= length;
+    n[1] /= length;
+    n[2] /= length;
+    const matrix = vtkMatrixBuilder.buildFromDegree().identity().translate(-center[0], -center[1], -center[2]).rotateFromDirections([0, 0, 1], n).translate(center[0], center[1], center[2]).getMatrix();
+    const polys = vtkCellArray.newInstance();
+
+    // Generate points
+    const deltaR = (outerRadius - innerRadius) / radialResolution;
+    const thetaStep = 2.0 * Math.PI / circumferentialResolution;
+    for (let i = 0; i < circumferentialResolution; i++) {
+      const theta = i * thetaStep;
+      const cosT = Math.cos(theta);
+      const sinT = Math.sin(theta);
+      for (let j = 0; j <= radialResolution; j++) {
+        const r = innerRadius + j * deltaR;
+        // point in XY plane before transform
+        const localPoint = [center[0] + r * cosT, center[1] + r * sinT, center[2]];
+        // apply matrix transform
+        const x = matrix[0] * localPoint[0] + matrix[4] * localPoint[1] + matrix[8] * localPoint[2] + matrix[12];
+        const y = matrix[1] * localPoint[0] + matrix[5] * localPoint[1] + matrix[9] * localPoint[2] + matrix[13];
+        const z = matrix[2] * localPoint[0] + matrix[6] * localPoint[1] + matrix[10] * localPoint[2] + matrix[14];
+        points.insertNextPoint(x, y, z);
+      }
+    }
+
+    // Generate cell connectivity (quads)
+    const cellCount = radialResolution * circumferentialResolution;
+    const cellData = new Uint8Array(cellCount * 5);
+    let offset = 0;
+    for (let i = 0; i < model.circumferentialResolution; i++) {
+      for (let j = 0; j < model.radialResolution; j++) {
+        const p0 = i * (model.radialResolution + 1) + j;
+        const p1 = p0 + 1;
+        const p2 = i < model.circumferentialResolution - 1 ? p1 + (model.radialResolution + 1) : j + 1; // wrap around
+        const p3 = p2 - 1;
+        cellData[offset++] = 4;
+        cellData[offset++] = p0;
+        cellData[offset++] = p1;
+        cellData[offset++] = p2;
+        cellData[offset++] = p3;
+      }
+    }
+    polys.setData(cellData, cellCount, 1);
+    dataset = vtkPolyData.newInstance();
+    dataset.setPoints(points);
+    dataset.setPolys(polys);
+
+    // Update output
+    outData[0] = dataset;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+function defaultValues(initialValues) {
+  return {
+    innerRadius: 0.25,
+    outerRadius: 0.5,
+    center: [0, 0, 0],
+    normal: [0, 0, 1],
+    radialResolution: 1,
+    circumferentialResolution: 6,
+    pointType: 'Float64Array',
+    ...initialValues
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, defaultValues(initialValues));
+
+  // Build VTK API
+  macro.obj(publicAPI, model);
+  macro.setGet(publicAPI, model, ['innerRadius', 'outerRadius', 'radialResolution', 'circumferentialResolution', 'pointType']);
+  macro.setGetArray(publicAPI, model, ['center', 'normal'], 3);
+  macro.algo(publicAPI, model, 0, 1);
+  vtkDiskSource(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkDiskSource');
+
+// ----------------------------------------------------------------------------
+
+var vtkDiskSource$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkDiskSource$1 as default, extend, newInstance };

package/Filters/Sources.js

@@ -5,6 +5,7 @@ import vtkConeSource from './Sources/ConeSource.js';
 import vtkCubeSource from './Sources/CubeSource.js';
 import vtkCursor3D from './Sources/Cursor3D.js';
 import vtkCylinderSource from './Sources/CylinderSource.js';
+import vtkDiskSource from './Sources/DiskSource.js';
 import vtkImageGridSource from './Sources/ImageGridSource.js';
 import vtkLineSource from './Sources/LineSource.js';
 import vtkPlaneSource from './Sources/PlaneSource.js';
@@ -21,6 +22,7 @@ var Sources = {
   vtkCubeSource,
   vtkCursor3D,
   vtkCylinderSource,
+  vtkDiskSource,
   vtkImageGridSource,
   vtkLineSource,
   vtkPlaneSource,

package/Proxy/Representations/GlyphRepresentationProxy.js

@@ -14,6 +14,7 @@ import '../../Filters/Sources/ConeSource.js';
 import '../../Filters/Sources/CubeSource.js';
 import '../../Filters/Sources/Cursor3D.js';
 import '../../Filters/Sources/CylinderSource.js';
+import '../../Filters/Sources/DiskSource.js';
 import '../../Filters/Sources/ImageGridSource.js';
 import '../../Filters/Sources/LineSource.js';
 import '../../Filters/Sources/PlaneSource.js';

package/index.d.ts

@@ -75,6 +75,7 @@
 /// <reference path="./Filters/Sources/CubeSource.d.ts" />
 /// <reference path="./Filters/Sources/Cursor3D.d.ts" />
 /// <reference path="./Filters/Sources/CylinderSource.d.ts" />
+/// <reference path="./Filters/Sources/DiskSource.d.ts" />
 /// <reference path="./Filters/Sources/LineSource.d.ts" />
 /// <reference path="./Filters/Sources/PlaneSource.d.ts" />
 /// <reference path="./Filters/Sources/PointSource.d.ts" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "34.3.1",
+  "version": "34.4.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",