vtkVoronoiFlower3D.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkVoronoiFlower3D_h
#define vtkVoronoiFlower3D_h
 
#include "vtkDataSetAlgorithm.h"
#include "vtkFiltersMeshingModule.h" // For export macro
#include "vtkIdTypeArray.h"          // for PointsOfInterest
#include "vtkSmartPointer.h"         // For self-destructing data members
#include "vtkStaticPointLocator.h"   // For point locator
#include "vtkWrappingHints.h"        // For VTK_MARSHALAUTO
 
VTK_ABI_NAMESPACE_BEGIN
 
class VTKFILTERSMESHING_EXPORT VTK_MARSHALAUTO vtkVoronoiFlower3D : public vtkDataSetAlgorithm
{
public:

  static vtkVoronoiFlower3D* New();
  vtkTypeMacro(vtkVoronoiFlower3D, vtkDataSetAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  enum OutputTypeOptions
  {
    VORONOI = 0,         // 3D Voronoi tessellation; output cells are polyhedra (vtkPolyhedron)
    DELAUNAY = 1,        // 3D Delaunay tesselation; cells are tetraheda (vtkTetra)
    ADJACENCY_GRAPH = 2, // the graph edges connecting neighboring Voronoi hulls
    POLYGONAL_COMPLEX =
      3,          // all polygonal faces including interior. Duplicate faces are not produced.
    BOUNDARY = 4, // produce polygonal faces on the boundary of the Voronoi tessellation
    SURFACE_NET =
      5,            // faces forming the surface net (i.e., faces on the boundaries between regions)
    SPEED_TEST = 6, // no output, just compute Voronoi hulls (for performance testing)
  };

  vtkSetClampMacro(OutputType, int, VORONOI, SPEED_TEST);
  vtkGetMacro(OutputType, int);
  void SetOutputTypeToVoronoi() { this->SetOutputType(VORONOI); }
  void SetOutputTypeToDelaunay() { this->SetOutputType(DELAUNAY); }
  void SetOutputTypeToAdjacencyGraph() { this->SetOutputType(ADJACENCY_GRAPH); }
  void SetOutputTypeToPolygonalComplex() { this->SetOutputType(POLYGONAL_COMPLEX); }
  void SetOutputTypeToBoundary() { this->SetOutputType(BOUNDARY); }
  void SetOutputTypeToSurfaceNet() { this->SetOutputType(SURFACE_NET); }
  void SetOutputTypeToSpeedTest() { this->SetOutputType(SPEED_TEST); }


  vtkSetClampMacro(Padding, double, 0.0001, 0.25);
  vtkGetMacro(Padding, double);


  vtkSetMacro(PassPointData, vtkTypeBool);
  vtkGetMacro(PassPointData, vtkTypeBool);
  vtkBooleanMacro(PassPointData, vtkTypeBool);


  enum GenerateCellScalarsStrategy
  {
    NO_CELL_SCALARS = 0, // Don't produce any cell scalars
    POINT_IDS = 1,       // Output cell scalars are the generating point id (default)
    REGION_IDS = 2,      // The region the cell primitives originated from (if region ids available)
    NUMBER_FACES = 3,    // The number of faces in the Voronoi hull
    PRIM_IDS = 4,        // The ids of the hull face primitives
    THREAD_IDS =
      5,       // Scalars are the thread id used to produce output. This may change between runs.
    RANDOM = 6 // Scalars are pseudo random numbers between [0,64).
  };



  vtkSetMacro(GenerateCellScalars, int);
  vtkGetMacro(GenerateCellScalars, int);
  void SetGenerateCellScalarsToNone() { this->SetGenerateCellScalars(NO_CELL_SCALARS); }
  void SetGenerateCellScalarsToPointIds() { this->SetGenerateCellScalars(POINT_IDS); }
  void SetGenerateCellScalarsToRegionIds() { this->SetGenerateCellScalars(REGION_IDS); }
  void SetGenerateCellScalarsToNumberFaces() { this->SetGenerateCellScalars(NUMBER_FACES); }
  void SetGenerateCellScalarsToPrimIds() { this->SetGenerateCellScalars(PRIM_IDS); }
  void SetGenerateCellScalarsToThreadIds() { this->SetGenerateCellScalars(THREAD_IDS); }
  void SetGenerateCellScalarsToRandom() { this->SetGenerateCellScalars(RANDOM); }


  vtkGetMacro(MergePoints, vtkTypeBool);
  vtkSetMacro(MergePoints, vtkTypeBool);
  vtkBooleanMacro(MergePoints, vtkTypeBool);


  vtkIdType FindHull(double x[3]);


  vtkSetClampMacro(PruneTolerance, double, 0.0, 0.5);
  vtkGetMacro(PruneTolerance, double);


  vtkStaticPointLocator* GetLocator() { return this->Locator; }


  vtkSetMacro(Validate, vtkTypeBool);
  vtkGetMacro(Validate, vtkTypeBool);
  vtkBooleanMacro(Validate, vtkTypeBool);


  vtkSetClampMacro(BatchSize, unsigned int, 1, VTK_INT_MAX);
  vtkGetMacro(BatchSize, unsigned int);


  vtkGetMacro(BoundaryCapping, vtkTypeBool);
  vtkSetMacro(BoundaryCapping, vtkTypeBool);
  vtkBooleanMacro(BoundaryCapping, vtkTypeBool);


  vtkSetClampMacro(PointOfInterest, vtkIdType, -1, VTK_ID_MAX);
  vtkGetMacro(PointOfInterest, vtkIdType);
  vtkSetObjectMacro(PointsOfInterest, vtkIdTypeArray);
  vtkGetObjectMacro(PointsOfInterest, vtkIdTypeArray);
  vtkSetClampMacro(MaximumNumberOfHullClips, vtkIdType, 1, VTK_ID_MAX);
  vtkGetMacro(MaximumNumberOfHullClips, vtkIdType);


  enum GeneratePointScalarsStrategy
  {
    NO_POINT_SCALARS = 0, // Don't produce any point scalars (default)
    FLOWER_RADII = 1      // Output point scalars are the Voronoi flower radii
  };
  vtkGetMacro(GeneratePointScalars, int);

  int GetMaximumNumberOfPoints() { return this->MaximumNumberOfPoints; }

  int GetMaximumNumberOfFaces() { return this->MaximumNumberOfFaces; }

  int GetNumberOfThreads() { return this->NumberOfThreads; }

  int GetNumberOfPrunes() { return this->NumberOfPrunes; }

  vtkMTimeType GetMTime() override;

  template <typename T>
  void UpdateExecutionInformation(T* voro);
 
protected:
  vtkVoronoiFlower3D();
  ~vtkVoronoiFlower3D() override = default;
 
  // Satisfy pipeline-related API
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int FillInputPortInformation(int port, vtkInformation* info) override;
  int FillOutputPortInformation(int port, vtkInformation* info) override;
 
private:
  vtkVoronoiFlower3D(const vtkVoronoiFlower3D&) = delete;
  void operator=(const vtkVoronoiFlower3D&) = delete;
 
  int OutputType;            // specification of the filter output
  double Padding;            // amount to pad out input points bounding box
  vtkTypeBool Validate;      // Choose to validate and repair output
  vtkTypeBool PassPointData; // indicate whether to pass input point data to output
  int GeneratePointScalars;  // indicate whether point scalars are to be produced
  int GenerateCellScalars;   // indicate whether cell scalars are to be produced
  vtkTypeBool MergePoints;   // merge near coincident points or not
  vtkIdType PointOfInterest; // specify a single input point to process
  vtkSmartPointer<vtkIdTypeArray> PointsOfInterest; // list of points of interest
  vtkIdType MaximumNumberOfHullClips;               // limit the number of hull clips
  vtkSmartPointer<vtkStaticPointLocator> Locator;   // locator for finding proximal points
  double PruneTolerance;                            // the prune spokes tolerance
  unsigned int BatchSize;                           // process data in batches of specified size
  vtkTypeBool BoundaryCapping; // cap the domain boundary if OutputType is SURFACE_NET

  int NumberOfThreads;       // report on the number of threads used during processing
  int MaximumNumberOfPoints; // maximum number of points found in any hull
  int MaximumNumberOfFaces;  // maximum number of faces found in any hull
  int NumberOfPrunes;        // If spoke pruning is enabled, report number of pruning operations
};
 
//------------------------------------------------------------------------------
template <typename T>
void vtkVoronoiFlower3D::UpdateExecutionInformation(T* voro)
{
  this->NumberOfThreads = voro->GetNumberOfThreads();
  this->MaximumNumberOfPoints = voro->GetMaximumNumberOfPoints();
  this->MaximumNumberOfFaces = voro->GetMaximumNumberOfFaces();
  this->NumberOfPrunes = voro->GetNumberOfPrunes();
}
 
VTK_ABI_NAMESPACE_END
#endif