vtkVoronoiFlower2D.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 vtkVoronoiFlower2D_h
#define vtkVoronoiFlower2D_h
 
#include "vtkAbstractTransform.h"    // For transforming input points
#include "vtkFiltersMeshingModule.h" // For export macro
#include "vtkIdTypeArray.h"          // for PointsOfInterest
#include "vtkPolyDataAlgorithm.h"
#include "vtkSmartPointer.h"         // For self-destructing data members
#include "vtkSpheres.h"              // For Voronoi Flower
#include "vtkStaticPointLocator2D.h" // For point locator
#include "vtkWrappingHints.h"        // For VTK_MARSHALAUTO
 
VTK_ABI_NAMESPACE_BEGIN
class vtkStaticPointLocator2D;
class vtkAbstractTransform;
class vtkPointSet;
class vtkSpheres;
 
class VTKFILTERSMESHING_EXPORT VTK_MARSHALAUTO vtkVoronoiFlower2D : public vtkPolyDataAlgorithm
{
public:

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

  enum OutputTypeOptions
  {
    VORONOI = 0,
    DELAUNAY = 1,
    VORONOI_AND_DELAUNAY = 2,
    SURFACE_NET = 3,
    SPEED_TEST = 4,
  };


  vtkSetMacro(OutputType, int);
  vtkGetMacro(OutputType, int);
  void SetOutputTypeToVoronoi() { this->SetOutputType(VORONOI); }
  void SetOutputTypeToDelaunay() { this->SetOutputType(DELAUNAY); }
  void SetOutputTypeToVoronoiAndDelaunay() { this->SetOutputType(VORONOI_AND_DELAUNAY); }
  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 GeneratePointScalarsStrategy
  {
    NO_POINT_SCALARS = 0, // Don't produce any point scalars (default)
    FLOWER_RADII = 1      // Output cell scalars are the generating point id
  };
  vtkGetMacro(GeneratePointScalars, int);

  enum GenerateCellScalarsStrategy
  {
    NO_CELL_SCALARS = 0, // Don't produce any cell scalars
    POINT_IDS = 1,       // Output cell scalars are the generating point id / tile id (default)
    REGION_IDS = 2,      // The region the cell primitives originated from (if region ids available)
    NUMBER_SIDES = 3,    // The number of edges in the Voronoi tile
    PRIM_IDS = 4,        // The ids of derivative primitives (e.g., Delaunay triangles)
    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).
  };


  vtkSetClampMacro(GenerateCellScalars, int, NO_CELL_SCALARS, RANDOM);
  vtkGetMacro(GenerateCellScalars, int);
  void SetGenerateCellScalarsToNone() { this->SetGenerateCellScalars(NO_CELL_SCALARS); }
  void SetGenerateCellScalarsToPointIds() { this->SetGenerateCellScalars(POINT_IDS); }
  void SetGenerateCellScalarsToRegionIds() { this->SetGenerateCellScalars(REGION_IDS); }
  void SetGenerateCellScalarsToNumberOfSides() { this->SetGenerateCellScalars(NUMBER_SIDES); }
  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 FindTile(double x[3]);
  void GetTileData(vtkIdType tileId, vtkPolyData* tileData);


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


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


  vtkSetSmartPointerMacro(Transform, vtkAbstractTransform);
  vtkGetSmartPointerMacro(Transform, vtkAbstractTransform);
 
  enum ProjectionPlaneStrategy
  {
    XY_PLANE = 0,
    SPECIFIED_TRANSFORM_PLANE = 1,
    BEST_FITTING_PLANE = 2
  };


  vtkSetClampMacro(ProjectionPlaneMode, int, XY_PLANE, BEST_FITTING_PLANE);
  vtkGetMacro(ProjectionPlaneMode, int);
  void SetProjectionPlaneModeToXYPlane() { this->SetProjectionPlaneMode(XY_PLANE); }
  void SetProjectionPlaneModeToSpecifiedTransformPlane()
  {
    this->SetProjectionPlaneMode(SPECIFIED_TRANSFORM_PLANE);
  }
  void SetProjectionPlaneModeToBestFittingPlane()
  {
    this->SetProjectionPlaneMode(BEST_FITTING_PLANE);
  }



  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(MaximumNumberOfTileClips, vtkIdType, 1, VTK_ID_MAX);
  vtkGetMacro(MaximumNumberOfTileClips, vtkIdType);


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


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


  vtkGetObjectMacro(Spheres, vtkSpheres);


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


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

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

  vtkMTimeType GetMTime() override;

  template <typename T>
  void UpdateExecutionInformation(T* voro);
 
protected:
  vtkVoronoiFlower2D();
  ~vtkVoronoiFlower2D() override = default;
 
  // Satisfy pipeline-related API
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  // Specify that the input is of type vtkPointSet
  int FillInputPortInformation(int, vtkInformation*) override;
 
private:
  vtkVoronoiFlower2D(const vtkVoronoiFlower2D&) = delete;
  void operator=(const vtkVoronoiFlower2D&) = delete;
 
  int OutputType;
  vtkTypeBool Validate;
  double Padding;
  vtkTypeBool PassPointData;
  int GeneratePointScalars;
  int GenerateCellScalars;
  vtkTypeBool MergePoints; // merge near coincident points or not
  int ProjectionPlaneMode; // selects the plane in 3D where the tessellation will be computed
  vtkSmartPointer<vtkStaticPointLocator2D> Locator;
  vtkSmartPointer<vtkAbstractTransform> Transform;
  vtkIdType PointOfInterest;
  vtkSmartPointer<vtkIdTypeArray> PointsOfInterest; // list of points of interest
  vtkIdType MaximumNumberOfTileClips;
  vtkTypeBool GenerateVoronoiFlower;
  vtkSmartPointer<vtkSpheres> Spheres;
  double PruneTolerance;
  unsigned int BatchSize;
  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 NumberOfPrunes;        // If spoke prining is enabled, report number of pruning operations
};
 
//------------------------------------------------------------------------------
template <typename T>
void vtkVoronoiFlower2D::UpdateExecutionInformation(T* voro)
{
  this->NumberOfThreads = voro->GetNumberOfThreads();
  this->MaximumNumberOfPoints = voro->GetMaximumNumberOfPoints();
  this->NumberOfPrunes = voro->GetNumberOfPrunes();
}
 
VTK_ABI_NAMESPACE_END
#endif