fix(BFSConnectivityFilter): rename filter; add. ts; add screenshot; bfs use 'polyData.buildLinks'

Author: qianlishun

Documentation/public/gallery/BFSConnectivityFilter.png

@@ -0,0 +1,10 @@
+export const ExtractionMode = {
+  ExtractionMode_ALL: 0,
+  ExtractionMode_LARGEST: 1,
+  ExtractionMode_SMALLEST: 2,
+  ExtractionMode_CUSTOM: 3,
+};
+
+export default {
+  ExtractionMode,
+};

Sources/Filters/General/BFSConnectivityFilter/Constants.js

@@ -5,12 +5,15 @@ import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
 import vtkFullScreenRenderWindow from '@kitware/vtk.js/Rendering/Misc/FullScreenRenderWindow';
 import vtkImageMarchingCubes from '@kitware/vtk.js/Filters/General/ImageMarchingCubes';
 import vtkMapper from '@kitware/vtk.js/Rendering/Core/Mapper';
-import vtkConnectivityFilter from '@kitware/vtk.js/Filters/General/ConnectivityFilter';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import vtkBFSConnectivityFilter from '@kitware/vtk.js/Filters/General/BFSConnectivityFilter';
+import Constants from '@kitware/vtk.js/Filters/General/BFSConnectivityFilter/Constants';
 
 import GUI from 'lil-gui';
 
+const { ExtractionMode } = Constants;
+
 function createVTKImageData(typedArray, dims, dataType, spacing) {
   const data = vtkImageData.newInstance();
   const [width, height, depth] = dims;
@@ -83,10 +86,15 @@ function generateTestVolumeData(size) {
 // Standard rendering code setup
 // ----------------------------------------------------------------------------
 
-const connectivityOptions = ['All Regions', 'Largest', 'Smallest', 'Custom'];
+const extractionModeOptions = [
+  'ExtractionMode_ALL',
+  'ExtractionMode_LARGEST',
+  'ExtractionMode_SMALLEST',
+  'ExtractionMode_CUSTOM',
+];
 const params = {
   IsoValue: 100.0,
-  ExtractionMode: connectivityOptions[0],
+  ExtractionMode: extractionModeOptions[0],
   CustomRegionIndex: 0,
 };
 
@@ -120,16 +128,16 @@ const mCubes = vtkImageMarchingCubes.newInstance({
 });
 mCubes.setInputData(imageData);
 
-const connectivityFilter = vtkConnectivityFilter.newInstance();
-connectivityFilter.setInputConnection(mCubes.getOutputPort());
-connectivityFilter.setExtractionModeToAll();
+const bfsFilter = vtkBFSConnectivityFilter.newInstance();
+bfsFilter.setInputConnection(mCubes.getOutputPort());
+bfsFilter.setExtractionModeToAll();
 
-mapper.setInputConnection(connectivityFilter.getOutputPort());
+mapper.setInputConnection(bfsFilter.getOutputPort());
 
 // ----------------------------------------------------------------------------
 // UI control handling
 // ----------------------------------------------------------------------------
-const gui = new GUI();
+const gui = new GUI({ width: 300 });
 
 gui
   .add(params, 'IsoValue', 0, 255, 1)
@@ -142,14 +150,14 @@ gui
 let customIndexController;
 
 gui
-  .add(params, 'ExtractionMode', connectivityOptions)
-  .name('Connectivity Extraction Mode')
-  .onChange((v) => {
-    const index = connectivityOptions.indexOf(v);
-    if (connectivityFilter) {
-      connectivityFilter.setExtractionMode(index);
-      if (index === 3) {
-        const count = connectivityFilter.getRegionsCount();
+  .add(params, 'ExtractionMode', extractionModeOptions)
+  .name('Mode')
+  .onChange((value) => {
+    if (bfsFilter) {
+      const mode = ExtractionMode[value];
+      bfsFilter.set({ extractionMode: mode });
+      if (mode === ExtractionMode.ExtractionMode_CUSTOM) {
+        const count = bfsFilter.getRegionsCount();
         console.log(`Total regions count: ${count}`);
         customIndexController.max(count - 1);
         customIndexController.show(true);
@@ -164,8 +172,8 @@ customIndexController = gui
   .add(params, 'CustomRegionIndex', 0, 1, 1)
   .name('Custom Region Index')
   .onChange((v) => {
-    if (connectivityFilter) {
-      connectivityFilter.setExtractionIndex(Number(v));
+    if (bfsFilter) {
+      bfsFilter.setExtractionIndex(Number(v));
       renderWindow.render();
     }
   });
@@ -185,6 +193,6 @@ renderWindow.render();
 // modify objects in your browser's developer console:
 // -----------------------------------------------------------
 
-global.filter = connectivityFilter;
+global.filter = bfsFilter;
 global.mapper = mapper;
 global.actor = actor;

…eral/ConnectivityFilter/example/index.js …l/BFSConnectivityFilter/example/index.jsSources/Filters/General/ConnectivityFilter/example/index.js renamed to Sources/Filters/General/BFSConnectivityFilter/example/index.js Sources/Filters/General/ConnectivityFilter/example/index.js renamed to Sources/Filters/General/BFSConnectivityFilter/example/index.js

@@ -0,0 +1,95 @@
+import { vtkAlgorithm, vtkObject } from '../../../interfaces';
+
+export enum ExtractionMode {
+  ExtractionMode_ALL,
+  ExtractionMode_LARGEST,
+  ExtractionMode_SMALLEST,
+  ExtractionMode_CUSTOM,
+}
+
+/**
+ *
+ */
+export interface IBFSConnectivityFilterInitialValues {
+  extractionMode?: ExtractionMode;
+  extractionIndex?: number;
+  regionsCount?: number;
+}
+
+type vtkBFSConnectivityFilterBase = vtkObject & vtkAlgorithm;
+
+export interface vtkBFSConnectivityFilter extends vtkBFSConnectivityFilterBase {
+  
+  /**
+   * Get the ExtractionMode.
+   */
+  getExtractionMode(): ExtractionMode;
+
+  /**
+   * Get the extractionIndex.
+   */
+  getExtractionIndex(): number;
+
+  /**
+   * Get the count of regions.
+   */
+  getRegionsCount(): number;
+
+  /**
+   *
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   * Set the extractionMode to extract the required connected regions
+   * @param {ExtractionMode} extractionMode
+   */
+  setExtractionMode(extractionMode: ExtractionMode): boolean;
+
+  /**
+   * Set the index to extract regions. should be 0 ~ regionsCount-1.
+   * @param {Number} extractionIndex
+   */
+  setExtractionIndex(extractionIndex: number): boolean;
+
+  /**
+   * @param {Number} regionsCount
+   */
+  setRegionsCount(regionsCount: number): boolean;
+
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkBFSConnectivityFilter characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IBFSConnectivityFilterInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IBFSConnectivityFilterInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkBFSConnectivityFilter
+ * @param {IBFSConnectivityFilterInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IBFSConnectivityFilterInitialValues
+): vtkBFSConnectivityFilter;
+
+/**
+ * vtkBFSConnectivityFilter - Use BFS to find connected regions and extract regions
+ * After searching for connected regions, set extractionMode(All, Largest, smallest) 
+ * or (Custom) and extractionIndex to extract the required connected regions.
+ * The input output of the filter is polygonal data.
+ */
+export declare const vtkBFSConnectivityFilter: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkBFSConnectivityFilter;

Sources/Filters/General/BFSConnectivityFilter/index.d.ts

@@ -2,32 +2,25 @@ import macro from 'vtk.js/Sources/macros';
 import vtkPoints from 'vtk.js/Sources/Common/Core/Points';
 import vtkCellArray from 'vtk.js/Sources/Common/Core/CellArray';
 import vtkPolyData from 'vtk.js/Sources/Common/DataModel/PolyData';
+import Constants from './Constants';
+
+const { ExtractionMode } = Constants;
 
 function runBFS(polyData) {
+  if (!polyData.getLinks()) {
+    polyData.buildLinks();
+  }
   const polys = polyData.getPolys().getData();
   const numCells = polyData.getNumberOfCells();
-  const numPoints = polyData.getNumberOfPoints();
 
-  // CellToPoints mapping
-  const cellToPoints = new Array(numCells);
   const cellOffsets = new Uint32Array(numCells);
   let offset = 0;
   for (let i = 0; i < numCells; i++) {
     cellOffsets[i] = offset;
     const n = polys[offset];
-    cellToPoints[i] = polys.subarray(offset + 1, offset + 1 + n);
     offset += n + 1;
   }
 
-  // PointToCells mapping
-  const pointToCells = Array.from({ length: numPoints }, () => []);
-  for (let i = 0; i < numCells; i++) {
-    const pts = cellToPoints[i];
-    for (let j = 0; j < pts.length; j++) {
-      pointToCells[pts[j]].push(i);
-    }
-  }
-
   const visited = new Uint8Array(numCells);
   const regions = [];
 
@@ -40,9 +33,9 @@ function runBFS(polyData) {
       while (head < queue.length) {
         const cellId = queue[head++];
         component.push(cellId);
-        const pts = cellToPoints[cellId];
+        const pts = polyData.getCellPoints(cellId).cellPointIds;
         for (let j = 0; j < pts.length; j++) {
-          const neighborCells = pointToCells[pts[j]];
+          const neighborCells = polyData.getPointCells(pts[j]);
           for (let k = 0; k < neighborCells.length; k++) {
             const neighborId = neighborCells[k];
             if (!visited[neighborId]) {
@@ -58,15 +51,8 @@ function runBFS(polyData) {
   return { regions, cellOffsets };
 }
 
-const ExtractionMode = {
-  All: 0,
-  Largest: 1,
-  Smallest: 2,
-  Custom: 3,
-};
-
-function vtkConnectivityFilter(publicAPI, model) {
-  model.classHierarchy.push('vtkConnectivityFilter');
+function vtkBFSConnectivityFilter(publicAPI, model) {
+  model.classHierarchy.push('vtkBFSConnectivityFilter');
 
   publicAPI.requestData = (inData, outData) => {
     const input = inData[0];
@@ -75,7 +61,7 @@ function vtkConnectivityFilter(publicAPI, model) {
       return;
     }
 
-    console.time(`ConnectivityFilter`);
+    console.time(`BFSConnectivityFilter`);
 
     const output = outData[0] || vtkPolyData.newInstance();
 
@@ -89,11 +75,13 @@ function vtkConnectivityFilter(publicAPI, model) {
 
     // 3. select region
     let cells = null;
-    if (model.extractionMode === ExtractionMode.All) {
+    if (model.extractionMode === ExtractionMode.ExtractionMode_ALL) {
       cells = sortRegions.flatMap((arr) => Array.from(arr));
-    } else if (model.extractionMode === ExtractionMode.Smallest) {
+    } else if (
+      model.extractionMode === ExtractionMode.ExtractionMode_SMALLEST
+    ) {
       cells = sortRegions[sortRegions.length - 1];
-    } else if (model.extractionMode === ExtractionMode.Custom) {
+    } else if (model.extractionMode === ExtractionMode.ExtractionMode_CUSTOM) {
       if (
         model.extractionIndex >= 0 &&
         model.extractionIndex < model.regionsCount
@@ -153,30 +141,34 @@ function vtkConnectivityFilter(publicAPI, model) {
 
     outData[0] = output;
 
-    console.timeEnd(`ConnectivityFilter`);
+    console.timeEnd(`BFSConnectivityFilter`);
   };
 
   publicAPI.setExtractionModeToAll = () => {
-    publicAPI.setExtractionMode(ExtractionMode.All);
+    publicAPI.setExtractionMode(ExtractionMode.ExtractionMode_ALL);
   };
 
   publicAPI.setExtractionModeToLargest = () => {
-    publicAPI.setExtractionMode(ExtractionMode.Largest);
+    publicAPI.setExtractionMode(ExtractionMode.ExtractionMode_LARGEST);
   };
 
   publicAPI.setExtractionModeToSmallest = () => {
-    publicAPI.setExtractionMode(ExtractionMode.Smallest);
+    publicAPI.setExtractionMode(ExtractionMode.ExtractionMode_SMALLEST);
   };
 
   publicAPI.setExtractionModeToCustom = () => {
-    publicAPI.setExtractionMode(ExtractionMode.Custom);
+    publicAPI.setExtractionMode(ExtractionMode.ExtractionMode_CUSTOM);
   };
 
   publicAPI.getRegionsCount = () => model.regionsCount;
+
+  publicAPI.setRegionsCount = () => {
+    console.log('can not set RegionsCount');
+  };
 }
 
 const DEFAULT_VALUES = {
-  extractionMode: ExtractionMode.All,
+  extractionMode: ExtractionMode.ExtractionMode_ALL,
   extractionIndex: 0,
   regionsCount: 0,
 };
@@ -193,9 +185,12 @@ export function extend(publicAPI, model, initialValues = {}) {
     'regionsCount',
   ]);
 
-  vtkConnectivityFilter(publicAPI, model);
+  vtkBFSConnectivityFilter(publicAPI, model);
 }
 
-export const newInstance = macro.newInstance(extend, 'vtkConnectivityFilter');
+export const newInstance = macro.newInstance(
+  extend,
+  'vtkBFSConnectivityFilter'
+);
 
 export default { newInstance, extend };

…ters/General/ConnectivityFilter/index.js …s/General/BFSConnectivityFilter/index.jsSources/Filters/General/ConnectivityFilter/index.js renamed to Sources/Filters/General/BFSConnectivityFilter/index.js Sources/Filters/General/ConnectivityFilter/index.js renamed to Sources/Filters/General/BFSConnectivityFilter/index.js

@@ -1,4 +1,5 @@
 import vtkAppendPolyData from './AppendPolyData';
+import vtkBFSConnectivityFilter from './BFSConnectivityFilter';
 import vtkCalculator from './Calculator';
 import vtkClipClosedSurface from './ClipClosedSurface';
 import vtkClosedPolyLineToSurfaceFilter from './ClosedPolyLineToSurfaceFilter';
@@ -21,10 +22,10 @@ import vtkTriangleFilter from './TriangleFilter';
 import vtkTubeFilter from './TubeFilter';
 import vtkWarpScalar from './WarpScalar';
 import vtkWindowedSincPolyDataFilter from './WindowedSincPolyDataFilter';
-import vtkConnectivityFilter from './ConnectivityFilter';
 
 export default {
   vtkAppendPolyData,
+  vtkBFSConnectivityFilter,
   vtkCalculator,
   vtkClipClosedSurface,
   vtkClosedPolyLineToSurfaceFilter,
@@ -47,5 +48,4 @@ export default {
   vtkTubeFilter,
   vtkWarpScalar,
   vtkWindowedSincPolyDataFilter,
-  vtkConnectivityFilter,
 };