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, vtkDataObject* field, vtkDataSet* dataset, vtkPoints* interestPoints,
    int integrationStepUnit, double dist, int maxNumSteps, int& numberOfSeparatingLines);

  int ComputeSeparatricesBoundarySwitchLines(vtkPolyData* boundarySwitchLines,
    vtkPolyData* separatrices, vtkDataObject* field, vtkDataSet* dataset, int integrationStepUnit,
    double dist, int maxNumSteps, bool computeSurfaces, bool useIterativeSeeding);

  int ComputeSeparatrices(vtkPolyData* criticalPoints, vtkPolyData* separatrices,
    vtkPolyData* surfaces, vtkDataObject* field, vtkDataSet* dataset, vtkPoints* interestPoints,
    int integrationStepUnit, double dist, double stepSize, int maxNumSteps, bool computeSurfaces,
    bool useIterativeSeeding, int& numberOfSeparatingLines, int& numberOfSeparatingSurfaces);

  int ComputeSurface(int numberOfSeparatingSurfaces, bool isBackward, double normal[3],
    double zeroPos[3], vtkPolyData* streamSurfaces, vtkDataObject* field, 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);

  static void CopyBoundarySwitchLinesArray(vtkDataSet* source, vtkPolyData* target);

  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