vtkVectorFieldTopology.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 vtkVectorFieldTopology_h
#define vtkVectorFieldTopology_h
 
#include "vtkFiltersFlowPathsModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h"
#include "vtkStreamTracer.h" // for vtkStreamSurface::CELL_LENGTH_UNIT
 
VTK_ABI_NAMESPACE_BEGIN
class vtkGradientFilter;
class vtkImageData;
class vtkPolyData;
class vtkStreamSurface;
class vtkUnstructuredGrid;
 
class VTKFILTERSFLOWPATHS_EXPORT vtkVectorFieldTopology : public vtkPolyDataAlgorithm
{
public:
  static vtkVectorFieldTopology* New();
  vtkTypeMacro(vtkVectorFieldTopology, vtkPolyDataAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkSetMacro(IntegrationStepUnit, int);
  vtkGetMacro(IntegrationStepUnit, int);
 
 
  vtkSetMacro(MaxNumSteps, int);
  vtkGetMacro(MaxNumSteps, int);
 
 
  vtkSetMacro(IntegrationStepSize, double);
  vtkGetMacro(IntegrationStepSize, double);
 
 
  vtkSetMacro(SeparatrixDistance, double);
  vtkGetMacro(SeparatrixDistance, double);
 
 
  vtkSetMacro(UseIterativeSeeding, bool);
  vtkGetMacro(UseIterativeSeeding, bool);
 
 
  vtkSetMacro(ComputeSurfaces, bool);
  vtkGetMacro(ComputeSurfaces, bool);
 
 
  vtkSetMacro(ExcludeBoundary, bool);
  vtkGetMacro(ExcludeBoundary, bool);
 
 
  vtkSetMacro(UseBoundarySwitchPoints, bool);
  vtkGetMacro(UseBoundarySwitchPoints, bool);
 
 
  vtkSetMacro(VectorAngleThreshold, double);
  vtkGetMacro(VectorAngleThreshold, double);
 
 
  vtkSetMacro(OffsetAwayFromBoundary, double);
  vtkGetMacro(OffsetAwayFromBoundary, double);
 
 
  vtkSetMacro(EpsilonCriticalPoint, double);
  vtkGetMacro(EpsilonCriticalPoint, double);
 
  void SetInterpolatorType(int interpType);
 
  void SetInterpolatorTypeToCellLocator();
 
  void SetInterpolatorTypeToDataSetPointLocator();
 
protected:
  vtkVectorFieldTopology();
  ~vtkVectorFieldTopology() override;
 
  int FillInputPortInformation(int port, vtkInformation* info) override;
  int FillOutputPortInformation(int port, vtkInformation* info) override;
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
private:
  vtkVectorFieldTopology(const vtkVectorFieldTopology&) = delete;
  void operator=(const vtkVectorFieldTopology&) = delete;
 
  int Validate();
 
  int ImageDataPrepare(vtkDataSet* dataSetInput, vtkUnstructuredGrid* tridataset);
 
  int UnstructuredGridPrepare(vtkDataSet* dataSetInput, vtkUnstructuredGrid* tridataset);
 
  int RemoveBoundary(vtkSmartPointer<vtkUnstructuredGrid> tridataset);
 
  int ComputeCriticalPoints2D(
    vtkSmartPointer<vtkPolyData> criticalPoints, vtkSmartPointer<vtkUnstructuredGrid> tridataset);
 
  int ComputeCriticalPoints3D(
    vtkSmartPointer<vtkPolyData> criticalPoints, vtkSmartPointer<vtkUnstructuredGrid> tridataset);
 
  static void InterpolateVector(
    double x0, double x1, double x, const double v0[3], const double v1[3], double v[3]);
 
  int ComputeBoundarySwitchPoints(
    vtkPolyData* boundarySwitchPoints, vtkUnstructuredGrid* tridataset);
 
  int ComputeSeparatricesBoundarySwitchPoints(vtkPolyData* boundarySwitchPoints,
    vtkPolyData* separatrices, vtkDataSet* dataset, vtkPoints* interestPoints,
    int integrationStepUnit, double dist, int maxNumSteps);
 
  int ComputeSeparatricesBoundarySwitchLines(vtkPolyData* boundarySwitchLines,
    vtkPolyData* separatrices, vtkDataSet* dataset, int integrationStepUnit, double dist,
    int maxNumSteps, bool computeSurfaces, bool useIterativeSeeding);
 
  int ComputeSeparatrices(vtkPolyData* criticalPoints, vtkPolyData* separatrices,
    vtkPolyData* surfaces, vtkDataSet* dataset, vtkPoints* interestPoints, int integrationStepUnit,
    double dist, double stepSize, int maxNumSteps, bool computeSurfaces, bool useIterativeSeeding);
 
  int ComputeSurface(int numberOfSeparatingSurfaces, bool isBackward, double normal[3],
    double zeroPos[3], vtkPolyData* streamSurfaces, vtkDataSet* dataset, int integrationStepUnit,
    double dist, double stepSize, int maxNumSteps, bool useIterativeSeeding);
 
  enum CriticalType2D
  {
    DEGENERATE_2D = -1,
    SINK_2D = 0,
    SADDLE_2D = 1,
    SOURCE_2D = 2,
    CENTER_2D = 3
  };
 
  enum CriticalTypeDetailed2D
  {
    //    DEGENERATE2D = -1,
    ATTRACTING_NODE_2D = 0,
    ATTRACTING_FOCUS_2D = 1,
    NODE_SADDLE_2D = 2,
    REPELLING_NODE_2D = 3,
    REPELLING_FOCUS_2D = 4,
    CENTER_DETAILED_2D = 5
  };
 
  enum CriticalType3D
  {
    DEGENERATE_3D = -1,
    SINK_3D = 0,
    SADDLE_1_3D = 1,
    SADDLE_2_3D = 2,
    SOURCE_3D = 3,
    CENTER_3D = 4
  };
 
  enum CriticalTypeDetailed3D
  {
    ATTRACTING_NODE_3D = 0,
    ATTRACTING_FOCUS_3D = 1,
    NODE_SADDLE_1_3D = 2,
    FOCUS_SADDLE_1_3D = 3,
    NODE_SADDLE_2_3D = 4,
    FOCUS_SADDLE_2_3D = 5,
    REPELLING_NODE_3D = 6,
    REPELLING_FOCUS_3D = 7,
    CENTER_DETAILED_3D = 8
  };
 
  static int Classify2D(int countComplex, int countPos, int countNeg);
 
  static int ClassifyDetailed2D(int countComplex, int countPos, int countNeg);
 
  static int Classify3D(int countComplex, int countPos, int countNeg);
 
  static int ClassifyDetailed3D(int countComplex, int countPos, int countNeg);
 
  int MaxNumSteps = 100;
 
  double IntegrationStepSize = 1;
 
  double SeparatrixDistance = 1;
 
  bool UseIterativeSeeding = false;
 
  bool ComputeSurfaces = false;
 
  const char* NameOfVectorArray;
 
  bool ExcludeBoundary = false;
 
  int Dimension = 2;
 
  int IntegrationStepUnit = vtkStreamTracer::CELL_LENGTH_UNIT;
 
  bool UseBoundarySwitchPoints = false;
 
  int InterpolatorType = vtkStreamTracer::INTERPOLATOR_WITH_DATASET_POINT_LOCATOR;
 
  double VectorAngleThreshold = 1;
 
  double OffsetAwayFromBoundary = 1e-3;
 
  double EpsilonCriticalPoint = 1e-10;
 
  vtkNew<vtkStreamSurface> StreamSurface;
};
VTK_ABI_NAMESPACE_END
#endif