@kitware/vtk.js 34.16.7 → 34.17.0

package/Filters/Modeling/RibbonFilter.d.ts

@@ -0,0 +1,196 @@
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import { Vector3 } from './../../types';
+
+export type IGenerateTCoords =
+  | 'TCOORDS_OFF'
+  | 'TCOORDS_FROM_SCALARS'
+  | 'TCOORDS_FROM_LENGTH'
+  | 'TCOORDS_FROM_NORMALIZED_LENGTH';
+
+/**
+ *
+ */
+export interface IRibbonFilterInitialValues {
+  useDefaultNormal?: boolean;
+  width?: number;
+  varyWidth?: boolean;
+  angle?: number;
+  generateTCoords?: IGenerateTCoords;
+  widthFactor?: number;
+  textureLength?: number;
+  defaultNormal?: Vector3;
+}
+
+type vtkRibbonFilterBase = vtkObject & vtkAlgorithm;
+
+export interface vtkRibbonFilter extends vtkRibbonFilterBase {
+  /**
+   * Get the angle (in degrees) of rotation about the line tangent used to
+   * orient the ribbon.
+   */
+  getAngle(): number;
+
+  /**
+   * Get the default normal used to orient the ribbon when no normals are
+   * provided in the input.
+   */
+  getDefaultNormal(): Vector3;
+
+  /**
+   * Get the default normal used to orient the ribbon when no normals are
+   * provided in the input.
+   */
+  getDefaultNormalByReference(): Vector3;
+
+  /**
+   * Get the method used to generate texture coordinates.
+   */
+  getGenerateTCoords(): IGenerateTCoords;
+
+  /**
+   * Get the method used to generate texture coordinates as a string.
+   */
+  getGenerateTCoordsAsString(): string;
+
+  /**
+   * Get the texture length, used when generating texture coordinates from
+   * length.
+   */
+  getTextureLength(): number;
+
+  /**
+   * Get whether to use the default normal to orient the ribbon when no
+   * normals are provided in the input.
+   */
+  getUseDefaultNormal(): boolean;
+
+  /**
+   * Get whether to vary the width of the ribbon using scalar data.
+   */
+  getVaryWidth(): boolean;
+
+  /**
+   * Get the width of the ribbon.
+   */
+  getWidth(): number;
+
+  /**
+   * Get the width factor, used to scale the width when varying the width.
+   */
+  getWidthFactor(): number;
+
+  /**
+   *
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   * Set the angle (in degrees) of rotation about the line tangent used to orient the ribbon.
+   * Default is 0.0.
+   * @param angle The angle in degrees.
+   * @returns true if the angle is set successfully.
+   */
+  setAngle(angle: number): boolean;
+
+  /**
+   * Set the default normal used to orient the ribbon when no normals are provided in the input.
+   * The default normal is a vector defined by three components (x,y,z). The
+   * default is (0,0,1).
+   * @param defaultNormal The default normal as an array of three numbers or a Vector3.
+   * @returns true if the default normal is set successfully.
+   */
+  setDefaultNormal(defaultNormal: Vector3): boolean;
+
+  /**
+   * Set the default normal used to orient the ribbon when no normals are provided in the input.
+   * The default normal is a vector defined by three components (x,y,z). The
+   * default is (0,0,1).
+   * @returns true if the default normal is set successfully.
+   */
+  setDefaultNormalFrom(defaultNormal: Vector3): boolean;
+
+  /**
+   * Set the method used to generate texture coordinates. By default, texture
+   * coordinates are not generated.
+   * @param generateTCoords The method to generate texture coordinates.
+   * @returns true if the method is set successfully.
+   */
+  setGenerateTCoords(generateTCoords: IGenerateTCoords): boolean;
+
+  /**
+   * Set the texture length, used when generating texture coordinates from length.
+   * The default is 1.0.
+   * @param textureLength The texture length.
+   * @returns true if the texture length is set successfully.
+   */
+  setTextureLength(textureLength: number): boolean;
+
+  /**
+   * Set whether to use the default normal to orient the ribbon when no normals are provided in the input.
+   * The default is false.
+   * @param useDefaultNormal Whether to use the default normal.
+   * @returns true if the flag is set successfully.
+   */
+  setUseDefaultNormal(useDefaultNormal: boolean): boolean;
+
+  /**
+   * Set whether to vary the width of the ribbon using scalar data. By default,
+   * the width of the ribbon is uniform.
+   * @param varyWidth Whether to vary the width of the ribbon.
+   * @returns true if the flag is set successfully.
+   */
+  setVaryWidth(varyWidth: boolean): boolean;
+
+  /**
+   * Set the width of the ribbon. The width is the total width of the ribbon;
+   * the ribbon extends width/2 on either side of the line. The default is 0.5.
+   * @param width The width of the ribbon.
+   * @returns true if the width is set successfully.
+   */
+  setWidth(width: number): boolean;
+
+  /**
+   * Set the width factor, used to scale the width when varying the width.
+   * The default is 1.0.
+   * @param widthFactor The width factor.
+   * @returns true if the width factor is set successfully.
+   */
+  setWidthFactor(widthFactor: number): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkRibbonFilter characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IRibbonFilterInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IRibbonFilterInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkRibbonFilter
+ * @param {IRibbonFilterInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IRibbonFilterInitialValues
+): vtkRibbonFilter;
+
+/**
+ * vtkRibbonFilter is a filter to create oriented ribbons from lines defined in
+ * polygonal dataset. The orientation of the ribbon is along the line segments
+ * and perpendicular to "projected" line normals. Projected line normals are the
+ * original line normals projected to be perpendicular to the local line
+ * segment. An offset angle can be specified to rotate the ribbon with respect
+ * to the normal.
+ */
+export declare const vtkRibbonFilter: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkRibbonFilter;

package/Filters/Modeling/RibbonFilter.js

@@ -0,0 +1,386 @@
+import { m as macro } from '../../macros2.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import vtkPoints from '../../Common/Core/Points.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
+import vtkDataArray from '../../Common/Core/DataArray.js';
+import { b as vtkMath } from '../../Common/Core/Math/index.js';
+
+/* eslint-disable no-continue */
+const {
+  vtkWarningMacro
+} = macro;
+
+// Texture coordinate generation modes
+const GenerateTCoords = {
+  TCOORDS_OFF: 0,
+  TCOORDS_FROM_SCALARS: 1,
+  TCOORDS_FROM_LENGTH: 2,
+  TCOORDS_FROM_NORMALIZED_LENGTH: 3
+};
+
+// ----------------------------------------------------------------------------
+// vtkRibbonFilter methods
+// ----------------------------------------------------------------------------
+
+function vtkRibbonFilter(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkRibbonFilter');
+
+  // Private methods
+  function generateSlidingNormals(points, lines, normals) {
+    // Simplified normal generation for polylines
+    // This is a basic implementation - you might want to use the actual vtk.js implementation
+    const lineArray = lines.getData();
+    let offset = 0;
+    for (let cellId = 0; cellId < lines.getNumberOfCells(); cellId++) {
+      const npts = lineArray[offset++];
+      const pts = lineArray.slice(offset, offset + npts);
+      offset += npts;
+      if (npts < 2) continue;
+      for (let i = 0; i < npts; i++) {
+        const v1 = [0, 0, 0];
+        const v2 = [0, 0, 0];
+        if (i === 0) {
+          points.getPoint(pts[1], v2);
+          points.getPoint(pts[0], v1);
+        } else if (i === npts - 1) {
+          points.getPoint(pts[i], v2);
+          points.getPoint(pts[i - 1], v1);
+        } else {
+          points.getPoint(pts[i + 1], v2);
+          points.getPoint(pts[i - 1], v1);
+        }
+        const tangent = [v2[0] - v1[0], v2[1] - v1[1], v2[2] - v1[2]];
+        vtkMath.normalize(tangent);
+
+        // Generate a normal perpendicular to the tangent
+        let normal = [0, 0, 1];
+        if (Math.abs(vtkMath.dot(tangent, normal)) > 0.9) {
+          normal = [1, 0, 0];
+        }
+        const binormal = [0, 0, 0];
+        vtkMath.cross(tangent, normal, binormal);
+        vtkMath.normalize(binormal);
+        vtkMath.cross(binormal, tangent, normal);
+        vtkMath.normalize(normal);
+        normals.setTuple(pts[i], normal);
+      }
+    }
+    return true;
+  }
+  function generatePoints(offset, npts, pts, inPts, newPts, inScalars, range, inNormals, outPD, pd, newNormals) {
+    const theta = model.angle * Math.PI / 180.0;
+    let ptId = offset;
+    const p = [0, 0, 0];
+    const pNext = [0, 0, 0];
+    const sNext = [0, 0, 0];
+    const sPrev = [0, 0, 0];
+    for (let j = 0; j < npts; j++) {
+      if (j === 0) {
+        inPts.getPoint(pts[0], p);
+        inPts.getPoint(pts[1], pNext);
+        for (let i = 0; i < 3; i++) {
+          sNext[i] = pNext[i] - p[i];
+          sPrev[i] = sNext[i];
+        }
+      } else if (j === npts - 1) {
+        for (let i = 0; i < 3; i++) {
+          sPrev[i] = sNext[i];
+          p[i] = pNext[i];
+        }
+      } else {
+        for (let i = 0; i < 3; i++) {
+          p[i] = pNext[i];
+        }
+        inPts.getPoint(pts[j + 1], pNext);
+        for (let i = 0; i < 3; i++) {
+          sPrev[i] = sNext[i];
+          sNext[i] = pNext[i] - p[i];
+        }
+      }
+      const n = [0, 0, 0];
+      inNormals.getTuple(pts[j], n);
+      if (vtkMath.normalize(sNext) === 0.0) {
+        vtkWarningMacro('Coincident points!');
+        return false;
+      }
+      const s = [(sPrev[0] + sNext[0]) / 2.0, (sPrev[1] + sNext[1]) / 2.0, (sPrev[2] + sNext[2]) / 2.0];
+      if (vtkMath.normalize(s) === 0.0) {
+        vtkMath.cross(sPrev, n, s);
+        if (vtkMath.normalize(s) === 0.0) {
+          vtkWarningMacro('Using alternate bevel vector');
+        }
+      }
+      const w = vtkMath.cross(s, n, []);
+      if (vtkMath.normalize(w) === 0.0) {
+        vtkWarningMacro(`Bad normal s = ${s} n = ${n}`);
+        return false;
+      }
+      const nP = vtkMath.cross(w, s, []);
+      vtkMath.normalize(nP);
+      let sFactor = 1.0;
+      if (inScalars && model.varyWidth) {
+        sFactor = 1.0 + (model.widthFactor - 1.0) * (inScalars.getValue(pts[j]) - range[0]) / (range[1] - range[0]);
+      }
+      const v = [w[0] * Math.cos(theta) + nP[0] * Math.sin(theta), w[1] * Math.cos(theta) + nP[1] * Math.sin(theta), w[2] * Math.cos(theta) + nP[2] * Math.sin(theta)];
+      const sp = [p[0] + model.width * sFactor * v[0], p[1] + model.width * sFactor * v[1], p[2] + model.width * sFactor * v[2]];
+      const sm = [p[0] - model.width * sFactor * v[0], p[1] - model.width * sFactor * v[1], p[2] - model.width * sFactor * v[2]];
+      newPts.setPoint(ptId, ...sm);
+      newNormals.setTuple(ptId, nP);
+      outPD.passData(pd, pts[j], ptId);
+      ptId++;
+      newPts.setPoint(ptId, ...sp);
+      newNormals.setTuple(ptId, nP);
+      outPD.passData(pd, pts[j], ptId);
+      ptId++;
+    }
+    return true;
+  }
+  function generateStrip(offset, npts, inCellId, outCD, cd, newStrips) {
+    const stripData = [];
+    for (let i = 0; i < npts; i++) {
+      const idx = 2 * i;
+      stripData.push(offset + idx);
+      stripData.push(offset + idx + 1);
+    }
+    newStrips.insertNextCell(stripData);
+    const outCellId = newStrips.getNumberOfCells() - 1;
+    outCD.passData(cd, inCellId, outCellId);
+  }
+  function generateTextureCoords(offset, npts, pts, inPts, inScalars, newTCoords) {
+    // First texture coordinate is always 0
+    for (let k = 0; k < 2; k++) {
+      newTCoords.setTuple(offset + k, [0.0, 0.0]);
+    }
+    if (model.generateTCoords === GenerateTCoords.TCOORDS_FROM_SCALARS && inScalars) {
+      const s0 = inScalars.getValue(pts[0]);
+      for (let i = 1; i < npts; i++) {
+        const s = inScalars.getValue(pts[i]);
+        const tc = (s - s0) / model.textureLength;
+        for (let k = 0; k < 2; k++) {
+          newTCoords.setTuple(offset + i * 2 + k, [tc, 0.0]);
+        }
+      }
+    } else if (model.generateTCoords === GenerateTCoords.TCOORDS_FROM_LENGTH) {
+      const xPrev = [0, 0, 0];
+      const x = [0, 0, 0];
+      let len = 0.0;
+      inPts.getPoint(pts[0], xPrev);
+      for (let i = 1; i < npts; i++) {
+        inPts.getPoint(pts[i], x);
+        len += Math.sqrt(vtkMath.distance2BetweenPoints(x, xPrev));
+        const tc = len / model.textureLength;
+        for (let k = 0; k < 2; k++) {
+          newTCoords.setTuple(offset + i * 2 + k, [tc, 0.0]);
+        }
+        xPrev[0] = x[0];
+        xPrev[1] = x[1];
+        xPrev[2] = x[2];
+      }
+    } else if (model.generateTCoords === GenerateTCoords.TCOORDS_FROM_NORMALIZED_LENGTH) {
+      const xPrev = [0, 0, 0];
+      const x = [0, 0, 0];
+      let length = 0.0;
+      let len = 0.0;
+
+      // Calculate total length
+      inPts.getPoint(pts[0], xPrev);
+      for (let i = 1; i < npts; i++) {
+        inPts.getPoint(pts[i], x);
+        length += Math.sqrt(vtkMath.distance2BetweenPoints(x, xPrev));
+        xPrev[0] = x[0];
+        xPrev[1] = x[1];
+        xPrev[2] = x[2];
+      }
+
+      // Generate normalized coordinates
+      inPts.getPoint(pts[0], xPrev);
+      for (let i = 1; i < npts; i++) {
+        inPts.getPoint(pts[i], x);
+        len += Math.sqrt(vtkMath.distance2BetweenPoints(x, xPrev));
+        const tc = len / length;
+        for (let k = 0; k < 2; k++) {
+          newTCoords.setTuple(offset + i * 2 + k, [tc, 0.0]);
+        }
+        xPrev[0] = x[0];
+        xPrev[1] = x[1];
+        xPrev[2] = x[2];
+      }
+    }
+  }
+  publicAPI.requestData = (inData, outData) => {
+    const input = inData[0];
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
+    outData[0] = output;
+    if (!input || !input.getPoints() || !input.getLines()) {
+      return;
+    }
+    const inPts = input.getPoints();
+    const inLines = input.getLines();
+    const pd = input.getPointData();
+    const cd = input.getCellData();
+    const numPts = inPts.getNumberOfPoints();
+    const numLines = inLines.getNumberOfCells();
+    if (numPts < 1 || numLines < 1) {
+      return;
+    }
+
+    // Get scalar data if available
+    let inScalars = null;
+    const scalarsArray = pd.getScalars();
+    if (scalarsArray) {
+      inScalars = scalarsArray;
+    }
+    let inNormals = pd.getNormals();
+    let generateNormals = false;
+    if (!inNormals || model.useDefaultNormal) {
+      inNormals = vtkDataArray.newInstance({
+        numberOfComponents: 3,
+        size: numPts * 3,
+        dataType: 'Float32Array'
+      });
+      if (model.useDefaultNormal) {
+        for (let i = 0; i < numPts; i++) {
+          inNormals.setTuple(i, model.defaultNormal);
+        }
+      } else {
+        generateNormals = true;
+      }
+    }
+
+    // Calculate scalar range if varying width
+    let range = [0, 1];
+    if (model.varyWidth && inScalars) {
+      range = inScalars.getRange();
+      if (range[1] - range[0] === 0.0) {
+        vtkWarningMacro('Scalar range is zero!');
+        range[1] = range[0] + 1.0;
+      }
+    }
+    const numNewPts = 2 * numPts;
+    const newPts = vtkPoints.newInstance();
+    newPts.setNumberOfPoints(numNewPts);
+    const newNormals = vtkDataArray.newInstance({
+      numberOfComponents: 3,
+      size: numNewPts * 3
+    });
+    const newStrips = vtkCellArray.newInstance();
+    const outPD = output.getPointData();
+    outPD.copyStructure(pd);
+    const outCD = output.getCellData();
+    outCD.copyStructure(cd);
+    let newTCoords = null;
+    if (model.generateTCoords !== GenerateTCoords.TCOORDS_OFF) {
+      newTCoords = vtkDataArray.newInstance({
+        numberOfComponents: 2,
+        size: numNewPts * 2
+      });
+    }
+
+    // Process each polyline
+    const lineArray = inLines.getData();
+    let offset = 0;
+    let arrayOffset = 0;
+    for (let inCellId = 0; inCellId < numLines; inCellId++) {
+      const npts = lineArray[arrayOffset++];
+      const pts = lineArray.slice(arrayOffset, arrayOffset + npts);
+      arrayOffset += npts;
+      if (npts < 2) {
+        vtkWarningMacro('Less than two points in line!');
+        continue;
+      }
+
+      // Generate normals if needed
+      if (generateNormals) {
+        const singlePolyline = vtkCellArray.newInstance();
+        singlePolyline.insertNextCell(pts);
+        if (!generateSlidingNormals(inPts, singlePolyline, inNormals)) ;
+      }
+
+      // Generate points for this polyline
+      if (!generatePoints(offset, npts, pts, inPts, newPts, inScalars, range, inNormals, outPD, pd, newNormals)) {
+        vtkWarningMacro('Could not generate points!');
+        continue;
+      }
+
+      // Generate strip for this polyline
+      generateStrip(offset, npts, inCellId, outCD, cd, newStrips);
+
+      // Generate texture coordinates if needed
+      if (newTCoords) {
+        generateTextureCoords(offset, npts, pts, inPts, inScalars, newTCoords);
+      }
+
+      // Update offset for next polyline
+      offset += 2 * npts;
+    }
+
+    // Set output data
+    output.setPoints(newPts);
+    output.setStrips(newStrips);
+    outPD.setNormals(newNormals);
+    if (newTCoords) {
+      outPD.setTCoords(newTCoords);
+    }
+  };
+  publicAPI.getGenerateTCoordsAsString = () => {
+    switch (model.generateTCoords) {
+      case GenerateTCoords.TCOORDS_OFF:
+        return 'GenerateTCoordsOff';
+      case GenerateTCoords.TCOORDS_FROM_SCALARS:
+        return 'GenerateTCoordsFromScalar';
+      case GenerateTCoords.TCOORDS_FROM_LENGTH:
+        return 'GenerateTCoordsFromLength';
+      case GenerateTCoords.TCOORDS_FROM_NORMALIZED_LENGTH:
+        return 'GenerateTCoordsFromNormalizedLength';
+      default:
+        return 'GenerateTCoordsOff';
+    }
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  width: 0.5,
+  angle: 0.0,
+  varyWidth: false,
+  widthFactor: 2.0,
+  defaultNormal: [0.0, 0.0, 1.0],
+  useDefaultNormal: false,
+  generateTCoords: GenerateTCoords.TCOORDS_OFF,
+  textureLength: 1.0
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Build VTK API
+  macro.obj(publicAPI, model);
+  macro.algo(publicAPI, model, 1, 1);
+
+  // Set/Get methods
+  macro.setGet(publicAPI, model, ['width', 'angle', 'varyWidth', 'widthFactor', 'useDefaultNormal', 'generateTCoords', 'textureLength']);
+  macro.setGetArray(publicAPI, model, ['defaultNormal'], 3);
+
+  // Object specific methods
+  vtkRibbonFilter(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkRibbonFilter');
+
+// ----------------------------------------------------------------------------
+
+var vtkRibbonFilter$1 = {
+  newInstance,
+  extend,
+  GenerateTCoords
+};
+
+export { vtkRibbonFilter$1 as default, extend, newInstance };

package/Filters/Modeling.js

@@ -0,0 +1,7 @@
+import vtkRibbonFilter from './Modeling/RibbonFilter.js';
+
+var index = {
+  vtkRibbonFilter
+};
+
+export { index as default };

package/Filters/Sources/PlatonicSolidSource.d.ts

@@ -96,10 +96,10 @@ export function newInstance(
  *
  * @example
  * ```js
- * import vtkPlatonicSolidSource from '@kitware/vtk.js/Filters/Sources/RegularPolygonSource';
+ * import vtkPlatonicSolidSource from '@kitware/vtk.js/Filters/Sources/PlatonicSolidSource';
  *
- * const regularPolygonSource = vtkPlatonicSolidSource.newInstance();
- * const polydata = regularPolygonSource.getOutputData();
+ * const platonicSolidSource = vtkPlatonicSolidSource.newInstance();
+ * const polydata = platonicSolidSource.getOutputData();
  * ```
  */
 export declare const vtkPlatonicSolidSource: {

package/Filters/Sources/RegularPolygonSource.d.ts

@@ -0,0 +1,183 @@
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import { Vector3 } from './../../types';
+import { DesiredOutputPrecision } from './../../Common/DataModel/DataSetAttributes';
+
+/**
+ *
+ */
+export interface IPlaneSourceInitialValues {
+  numberOfSides?: number;
+  center?: Vector3;
+  normal?: Vector3;
+  radius?: number;
+  generatePolygon?: boolean;
+  generatePolyline?: boolean;
+  outputPointsPrecision?: DesiredOutputPrecision;
+}
+
+type vtkRegularPolygonSourceBase = vtkObject &
+  Omit<
+    vtkAlgorithm,
+    | 'getInputData'
+    | 'setInputData'
+    | 'setInputConnection'
+    | 'getInputConnection'
+    | 'addInputConnection'
+    | 'addInputData'
+  >;
+
+export interface vtkRegularPolygonSource extends vtkRegularPolygonSourceBase {
+  /**
+   * Get the center of the regular polygon.
+   * @returns {Vector3} center of the polygon
+   */
+  getCenter(): Vector3;
+
+  /**
+   * Get a reference to the center of the regular polygon.
+   * @returns {Vector3} reference to the center of the polygon
+   */
+  getCenterByReference(): Vector3;
+
+  /**
+   * Get whether to generate polygon points.
+   * @returns {Boolean} true if polygon points are generated, false otherwise
+   */
+  getGeneratePolygon(): boolean;
+
+  /**
+   * Get whether to generate polyline points.
+   * @returns {Boolean} true if polyline points are generated, false otherwise
+   */
+  getGeneratePolyline(): boolean;
+
+  /**
+   * Get the normal of the regular polygon.
+   * @returns {Vector3} normal of the polygon
+   */
+  getNormal(): Vector3;
+
+  /**
+   * Get a reference to the normal of the regular polygon.
+   * @returns {Vector3} reference to the normal of the polygon
+   */
+  getNormalByReference(): Vector3;
+
+  /**
+   * Get the number of sides for the regular polygon.
+   * @returns {Number} number of sides
+   */
+  getNumberOfSides(): number;
+
+  /**
+   * Get the output points precision.
+   * @returns {DesiredOutputPrecision} the output points precision
+   */
+  getOutputPointsPrecision(): DesiredOutputPrecision;
+
+  /**
+   * Get the radius of the regular polygon.
+   * @returns {Number} radius of the polygon
+   */
+  getRadius(): number;
+
+  /**
+   *
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   * Set the center of the regular polygon.
+   * @param {Vector3} center
+   * @returns {Boolean} true if the value was changed, false otherwise
+   */
+  setCenter(center: Vector3): boolean;
+
+  /**
+   * Set whether to generate polygon points.
+   * @param generatePolygon
+   * @returns {Boolean} true if the value was changed, false otherwise
+   */
+  setGeneratePolygon(generatePolygon: boolean): boolean;
+
+  /**
+   * Set whether to generate polyline points.
+   * @param generatePolyline
+   * @returns {Boolean} true if the value was changed, false otherwise
+   */
+  setGeneratePolyline(generatePolyline: boolean): boolean;
+
+  /**
+   * Set the normal of the regular polygon.
+   * @param {Vector3} normal
+   * @returns {Boolean} true if the value was changed, false otherwise
+   */
+  setNormal(normal: Vector3): boolean;
+
+  /**
+   * Set the number of sides for the regular polygon.
+   * @param numberOfSides
+   * @returns {Boolean} true if the value was changed, false otherwise
+   */
+  setNumberOfSides(numberOfSides: number): boolean;
+
+  /**
+   * Set the output points precision.
+   * @param outputPointsPrecision
+   * @returns {Boolean} true if the value was changed, false otherwise
+   */
+  setOutputPointsPrecision(
+    outputPointsPrecision: DesiredOutputPrecision
+  ): boolean;
+
+  /**
+   * Set the radius of the regular polygon.
+   * @param radius
+   * @returns {Boolean} true if the value was changed, false otherwise
+   */
+  setRadius(radius: number): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkRegularPolygonSource characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IPlaneSourceInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IPlaneSourceInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkRegularPolygonSource.
+ * @param {IPlaneSourceInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IPlaneSourceInitialValues
+): vtkRegularPolygonSource;
+
+/**
+ * vtkRegularPolygonSource is a source object that creates a single n-sided
+ * polygon and/or polyline. The polygon is centered at a specified point,
+ * orthogonal to a specified normal, and with a circumscribing radius set by the
+ * user. The user can also specify the number of sides of the polygon ranging
+ * from [3,N].
+ *
+ * @example
+ * ```js
+ * import vtkRegularPolygonSource from '@kitware/vtk.js/Filters/Sources/RegularPolygonSource';
+ *
+ * const regularPolygonSource = vtkRegularPolygonSource.newInstance();
+ * const polydata = regularPolygonSource.getOutputData();
+ * ```
+ */
+export declare const vtkRegularPolygonSource: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkRegularPolygonSource;

package/Filters/Sources/RegularPolygonSource.js

@@ -0,0 +1,150 @@
+import { m as macro } from '../../macros2.js';
+import { b as vtkMath } from '../../Common/Core/Math/index.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import vtkPoints from '../../Common/Core/Points.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
+import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
+import { DesiredOutputPrecision } from '../../Common/DataModel/DataSetAttributes/Constants.js';
+
+// ----------------------------------------------------------------------------
+// vtkRegularPolygonSource methods
+// ----------------------------------------------------------------------------
+
+function vtkRegularPolygonSource(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkRegularPolygonSource');
+  publicAPI.requestData = (inData, outData) => {
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
+    const numPts = model.numberOfSides;
+    const newPoints = vtkPoints.newInstance({
+      dataType: model.outputPointsPrecision === DesiredOutputPrecision.DOUBLE ? VtkDataTypes.DOUBLE : VtkDataTypes.FLOAT
+    });
+
+    // Generate polyline if requested
+    if (model.generatePolyline) {
+      const newLine = vtkCellArray.newInstance();
+      const linePoints = [];
+      for (let i = 0; i < numPts; i++) {
+        linePoints.push(i);
+      }
+      linePoints.push(0); // close the polyline
+      newLine.insertNextCell(linePoints);
+      output.setLines(newLine);
+    }
+
+    // Generate polygon if requested
+    if (model.generatePolygon) {
+      const newPoly = vtkCellArray.newInstance();
+      const polyPoints = [];
+      for (let i = 0; i < numPts; i++) {
+        polyPoints.push(i);
+      }
+      newPoly.insertNextCell(polyPoints);
+      output.setPolys(newPoly);
+    }
+
+    // Make sure the polygon normal is a unit vector
+    const n = [...model.normal];
+    const nLength = vtkMath.normalize(n);
+    if (nLength === 0.0) {
+      n[0] = 0.0;
+      n[1] = 0.0;
+      n[2] = 1.0;
+    }
+
+    // Find a vector in the polygon plane (perpendicular to normal)
+    const px = [0, 0, 0];
+    const py = [0, 0, 0];
+    let foundPlaneVector = false;
+
+    // Cross with unit axis vectors and eventually find vector in the polygon plane
+    const axis = [1.0, 0.0, 0.0];
+    vtkMath.cross(n, axis, px);
+    const pxLength = vtkMath.normalize(px);
+    if (pxLength > 1.0e-3) {
+      foundPlaneVector = true;
+    }
+    if (!foundPlaneVector) {
+      axis[0] = 0.0;
+      axis[1] = 1.0;
+      axis[2] = 0.0;
+      vtkMath.cross(n, axis, px);
+      const pxLength2 = vtkMath.normalize(px);
+      if (pxLength2 > 1.0e-3) {
+        foundPlaneVector = true;
+      }
+    }
+    if (!foundPlaneVector) {
+      axis[0] = 0.0;
+      axis[1] = 0.0;
+      axis[2] = 1.0;
+      vtkMath.cross(n, axis, px);
+      vtkMath.normalize(px);
+    }
+
+    // Create second orthogonal axis in polygon plane
+    vtkMath.cross(px, n, py);
+
+    // Generate polygon points
+    const theta = 2.0 * Math.PI / numPts;
+    const points = [];
+    const r = [0, 0, 0];
+    const x = [0, 0, 0];
+    for (let j = 0; j < numPts; j++) {
+      const cosTheta = Math.cos(j * theta);
+      const sinTheta = Math.sin(j * theta);
+      r[0] = px[0] * cosTheta + py[0] * sinTheta;
+      r[1] = px[1] * cosTheta + py[1] * sinTheta;
+      r[2] = px[2] * cosTheta + py[2] * sinTheta;
+      x[0] = model.center[0] + model.radius * r[0];
+      x[1] = model.center[1] + model.radius * r[1];
+      x[2] = model.center[2] + model.radius * r[2];
+      points.push(x[0], x[1], x[2]);
+    }
+    newPoints.setData(points);
+    output.setPoints(newPoints);
+    outData[0] = output;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  numberOfSides: 6,
+  center: [0.0, 0.0, 0.0],
+  normal: [0.0, 0.0, 1.0],
+  radius: 0.5,
+  generatePolygon: true,
+  generatePolyline: true,
+  outputPointsPrecision: DesiredOutputPrecision.FLOAT
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Build VTK API
+  macro.obj(publicAPI, model);
+  macro.algo(publicAPI, model, 0, 1);
+
+  // Build VTK API
+  macro.setGet(publicAPI, model, ['numberOfSides', 'radius', 'generatePolygon', 'generatePolyline', 'outputPointsPrecision']);
+  macro.setGetArray(publicAPI, model, ['center', 'normal'], 3);
+  vtkRegularPolygonSource(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkRegularPolygonSource');
+
+// ----------------------------------------------------------------------------
+
+var vtkRegularPolygonSource$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkRegularPolygonSource$1 as default, extend, newInstance };

package/Filters/Sources.js

@@ -13,6 +13,7 @@ import vtkLineSource from './Sources/LineSource.js';
 import vtkPlaneSource from './Sources/PlaneSource.js';
 import vtkPlatonicSolidSource from './Sources/PlatonicSolidSource.js';
 import vtkPointSource from './Sources/PointSource.js';
+import vtkRegularPolygonSource from './Sources/RegularPolygonSource.js';
 import vtkRTAnalyticSource from './Sources/RTAnalyticSource.js';
 import vtkSLICSource from './Sources/SLICSource.js';
 import vtkSphereSource from './Sources/SphereSource.js';
@@ -34,6 +35,7 @@ var Sources = {
   vtkPlaneSource,
   vtkPlatonicSolidSource,
   vtkPointSource,
+  vtkRegularPolygonSource,
   vtkRTAnalyticSource,
   vtkSLICSource,
   vtkSphereSource,

package/Proxy/Representations/GlyphRepresentationProxy.js

@@ -22,6 +22,7 @@ import '../../Filters/Sources/LineSource.js';
 import '../../Filters/Sources/PlaneSource.js';
 import '../../Filters/Sources/PlatonicSolidSource.js';
 import '../../Filters/Sources/PointSource.js';
+import '../../Filters/Sources/RegularPolygonSource.js';
 import '../../Filters/Sources/RTAnalyticSource.js';
 import '../../Filters/Sources/SLICSource.js';
 import '../../Filters/Sources/SphereSource.js';

package/index.d.ts

@@ -75,6 +75,7 @@
 /// <reference path="./Filters/General/TransformPolyDataFilter.d.ts" />
 /// <reference path="./Filters/General/TriangleFilter.d.ts" />
 /// <reference path="./Filters/General/TubeFilter.d.ts" />
+/// <reference path="./Filters/Modeling/RibbonFilter.d.ts" />
 /// <reference path="./Filters/Sources/ArcSource.d.ts" />
 /// <reference path="./Filters/Sources/Arrow2DSource.d.ts" />
 /// <reference path="./Filters/Sources/ArrowSource.d.ts" />
@@ -91,6 +92,7 @@
 /// <reference path="./Filters/Sources/PlatonicSolidSource/Constants.d.ts" />
 /// <reference path="./Filters/Sources/PlatonicSolidSource.d.ts" />
 /// <reference path="./Filters/Sources/PointSource.d.ts" />
+/// <reference path="./Filters/Sources/RegularPolygonSource.d.ts" />
 /// <reference path="./Filters/Sources/SphereSource.d.ts" />
 /// <reference path="./Filters/Texture/TextureMapToPlane.d.ts" />
 /// <reference path="./Filters/Texture/TextureMapToSphere.d.ts" />

package/package.json

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