feat(FillHolesFilter): add vtkFillHolesFilter

Author: daker

Data/stl/spherewithholes.stl

@@ -0,0 +1,162 @@
+import { vtkObject } from '../../../interfaces';
+import { Nullable } from '../../../types';
+
+export interface ICellLinksInitialValues {}
+
+/**
+ * Link record for a point: number of incident cells and their ids.
+ */
+export interface ICellLink {
+  /**
+   * Number of cells using the point.
+   */
+  ncells: number;
+  /**
+   * Cell ids that use the point.
+   */
+  cells: Nullable<number[]>;
+}
+
+export interface vtkCellLinks extends vtkObject {
+  /**
+   * Build the link list array from the input dataset.
+   * The resulting structure maps each point id to the cells that reference it.
+   */
+  buildLinks(data: any): void;
+
+  /**
+   * Allocate storage for a number of links (typically the number of points).
+   * @param {Number} numLinks Number of point links to allocate.
+   * @param {Number} [extSize=1000] Growth factor used for future extensions.
+   */
+  allocate(numLinks: number, extSize?: number): void;
+
+  /**
+   * Allocate per-point cell-id arrays based on precomputed link counts.
+   * @param {Number} n Number of links (points).
+   */
+  allocateLinks(n: number): void;
+
+  /**
+   * Clear out previously allocated link structures.
+   */
+  initialize(): void;
+
+  /**
+   * Get the full link structure for a point id.
+   * @param {Number} ptId Point id.
+   */
+  getLink(ptId: number): ICellLink;
+
+  /**
+   * Get the number of cells using the point.
+   * @param {Number} ptId Point id.
+   */
+  getNcells(ptId: number): number;
+
+  /**
+   * Return the list of cell ids that use the point.
+   * @param {Number} ptId Point id.
+   */
+  getCells(ptId: number): Nullable<number[]>;
+
+  /**
+   * Insert a new point entry into the links structure.
+   * @param {Number} numLinks Initial size of the point's cell-id list.
+   */
+  insertNextPoint(numLinks: number): void;
+
+  /**
+   * Append a cell id to the point's cell-id list.
+   * @param {Number} ptId Point id.
+   * @param {Number} cellId Cell id.
+   */
+  insertNextCellReference(ptId: number, cellId: number): void;
+
+  /**
+   * Delete a point by removing all links to using cells.
+   * @param {Number} ptId Point id.
+   */
+  deletePoint(ptId: number): void;
+
+  /**
+   * Remove the reference from a point to a cell.
+   * @param {Number} cellId Cell id.
+   * @param {Number} ptId Point id.
+   */
+  removeCellReference(cellId: number, ptId: number): void;
+
+  /**
+   * Add a reference from a point to a cell.
+   * @param {Number} cellId Cell id.
+   * @param {Number} ptId Point id.
+   */
+  addCellReference(cellId: number, ptId: number): void;
+
+  /**
+   * Resize a point's cell-id list.
+   * @param {Number} ptId Point id.
+   * @param {Number} size New list size.
+   */
+  resizeCellList(ptId: number, size: number): void;
+
+  /**
+   * Reclaim unused memory.
+   */
+  squeeze(): void;
+
+  /**
+   * Reset to an empty state without freeing memory.
+   */
+  reset(): void;
+
+  /**
+   * Deep-copy from another cell-links instance.
+   * @param src Source object.
+   */
+  deepCopy(src: any): void;
+
+  /**
+   * Increment the count of cells using a point.
+   * @param {Number} ptId Point id.
+   */
+  incrementLinkCount(ptId: number): void;
+
+  /**
+   * Insert a cell id into a point's cell-id list at a specific position.
+   * @param {Number} ptId Point id.
+   * @param {Number} pos Position inside the point's list.
+   * @param {Number} cellId Cell id.
+   */
+  insertCellReference(ptId: number, pos: number, cellId: number): void;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkCellLinks characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {ICellLinksInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: ICellLinksInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkCellLinks.
+ * @param {ICellLinksInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: ICellLinksInitialValues
+): vtkCellLinks;
+
+/**
+ * vtkCellLinks maps each point to the cells that reference it.
+ */
+export declare const vtkCellLinks: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkCellLinks;

Documentation/public/gallery/FillHolesFilter.jpg

@@ -1,4 +1,4 @@
-import { CellType, Vector3 } from '../../../types';
+import { CellType } from '../../../types';
 import vtkCellArray from '../../Core/CellArray';
 import vtkPointSet, { IPointSetInitialValues } from '../PointSet';
 
@@ -36,10 +36,15 @@ export interface vtkPolyData extends vtkPointSet {
   /**
    * Get the neighbors at an edge.
    * @param {Number} cellId The Id of the cell.
-   * @param {Vector3} point1 The first point coordinate.
-   * @param {Vector3} point2 The second point coordinate.
-   */
-  getCellEdgeNeighbors(cellId: number, point1: Vector3, point2: Vector3): void;
+   * @param {Number} point1 The first point id.
+   * @param {Number} point2 The second point id.
+   * @returns {Number[]} Neighbor cell ids.
+   */
+  getCellEdgeNeighbors(
+    cellId: number,
+    point1: number,
+    point2: number
+  ): number[];
 
   /**
    * Get a list of point ids that define a cell.

Sources/Common/DataModel/CellLinks/index.d.ts

@@ -0,0 +1,57 @@
+import '@kitware/vtk.js/favicon';
+
+// Load the rendering pieces we want to use (for both WebGL and WebGPU)
+import '@kitware/vtk.js/Rendering/Profiles/Geometry';
+import '@kitware/vtk.js/IO/Core/DataAccessHelper/HttpDataAccessHelper';
+
+import vtkFullScreenRenderWindow from '@kitware/vtk.js/Rendering/Misc/FullScreenRenderWindow';
+import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
+import vtkFillHolesFilter from '@kitware/vtk.js/Filters/Modeling/FillHolesFilter';
+import vtkMapper from '@kitware/vtk.js/Rendering/Core/Mapper';
+import vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
+import vtkSTLReader from '@kitware/vtk.js/IO/Geometry/STLReader';
+
+// ----------------------------------------------------------------------------
+// Example code
+// ----------------------------------------------------------------------------
+
+const fullScreenRenderer = vtkFullScreenRenderWindow.newInstance();
+const leftRenderer = fullScreenRenderer.getRenderer();
+const renderWindow = fullScreenRenderer.getRenderWindow();
+const rightRenderer = vtkRenderer.newInstance();
+renderWindow.addRenderer(rightRenderer);
+leftRenderer.setViewport(0, 0, 0.5, 1);
+rightRenderer.setViewport(0.5, 0, 1, 1);
+leftRenderer.setBackground(0.32, 0.34, 0.43);
+rightRenderer.setBackground(0.32, 0.34, 0.43);
+
+const reader = vtkSTLReader.newInstance({
+  removeDuplicateVertices: true,
+  merging: true,
+});
+const fillHolesFilter = vtkFillHolesFilter.newInstance();
+fillHolesFilter.setHoleSize(1000.0);
+fillHolesFilter.setInputConnection(reader.getOutputPort());
+
+const readerActor = vtkActor.newInstance();
+const readerMapper = vtkMapper.newInstance({ scalarVisibility: false });
+readerActor.setMapper(readerMapper);
+readerMapper.setInputConnection(reader.getOutputPort());
+leftRenderer.addActor(readerActor);
+
+const filledActor = vtkActor.newInstance();
+const filledMapper = vtkMapper.newInstance({ scalarVisibility: false });
+filledActor.setMapper(filledMapper);
+filledMapper.setInputConnection(fillHolesFilter.getOutputPort());
+rightRenderer.addActor(filledActor);
+
+reader.setUrl(`${__BASE_PATH__}/data/stl/spherewithholes.stl`).then(() => {
+  leftRenderer.resetCamera();
+  rightRenderer.setActiveCamera(leftRenderer.getActiveCamera());
+  rightRenderer.resetCamera();
+  renderWindow.render();
+});
+
+leftRenderer.resetCamera();
+rightRenderer.setActiveCamera(leftRenderer.getActiveCamera());
+renderWindow.render();

Sources/Common/DataModel/PolyData/index.d.ts

@@ -0,0 +1,65 @@
+import { vtkAlgorithm, vtkObject } from '../../../interfaces';
+
+/**
+ * Initial values for vtkFillHolesFilter.
+ */
+export interface IFillHolesFilterInitialValues {
+  holeSize?: number;
+}
+
+type vtkFillHolesFilterBase = vtkObject & vtkAlgorithm;
+
+export interface vtkFillHolesFilter extends vtkFillHolesFilterBase {
+  /**
+   * Expose methods.
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   * Get the maximum hole size to fill.
+   */
+  getHoleSize(): number;
+
+  /**
+   * Set the maximum hole size to fill.
+   * @param holeSize
+   */
+  setHoleSize(holeSize: number): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkFillHolesFilter characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IFillHolesFilterInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IFillHolesFilterInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkFillHolesFilter.
+ * @param {IFillHolesFilterInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IFillHolesFilterInitialValues
+): vtkFillHolesFilter;
+
+/**
+ * vtkFillHolesFilter is a filter that identifies and fills holes in input vtkPolyData meshes.
+ * Holes are identified by locating boundary edges, linking them together into loops,
+ * and then triangulating the resulting loops. Note that you can specify an approximate
+ * limit to the size of the hole that can be filled.
+ *
+ * The VTK.js implementation follows the same algorithmic approach as VTK C++.
+ */
+export declare const vtkFillHolesFilter: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkFillHolesFilter;