ttkReebSpace.h

Go to the documentation of this file.

 
 
#pragma once
 
// VTK Module
#include <ttkReebSpaceModule.h>
 
// ttk code includes
#include <ReebSpace.h>
#include <ttkAlgorithm.h>
 
// in this example, this wrapper takes a data-set on the input and produces a
// data-set on the output - to adapt.
// see the documentation of the vtkAlgorithm class to decide from which VTK
// class your wrapper should inherit.
class TTKREEBSPACE_EXPORT ttkReebSpace : public ttkAlgorithm,
                                         protected ttk::ReebSpace {
 
public:
  static ttkReebSpace *New();
  vtkTypeMacro(ttkReebSpace, ttkAlgorithm);
 
  vtkGetMacro(ForceInputOffsetScalarField, bool);
  vtkSetMacro(ForceInputOffsetScalarField, bool);
 
  vtkGetMacro(UseOctreeAcceleration, bool);
  vtkSetMacro(UseOctreeAcceleration, bool);
 
  // 0-sheet options
  vtkGetMacro(ZeroSheetId, bool);
  vtkSetMacro(ZeroSheetId, bool);
 
  vtkGetMacro(ZeroSheetType, bool);
  vtkSetMacro(ZeroSheetType, bool);
 
  vtkGetMacro(ZeroSheetValue, bool);
  vtkSetMacro(ZeroSheetValue, bool);
 
  vtkGetMacro(ZeroSheetVertexId, bool);
  vtkSetMacro(ZeroSheetVertexId, bool);
 
  // 1-sheet options
  vtkGetMacro(OneSheetId, bool);
  vtkSetMacro(OneSheetId, bool);
 
  vtkGetMacro(OneSheetType, bool);
  vtkSetMacro(OneSheetType, bool);
 
  vtkGetMacro(OneSheetValue, bool);
  vtkSetMacro(OneSheetValue, bool);
 
  vtkGetMacro(OneSheetVertexId, bool);
  vtkSetMacro(OneSheetVertexId, bool);
 
  vtkGetMacro(OneSheetEdgeId, bool);
  vtkSetMacro(OneSheetEdgeId, bool);
 
  // 2-sheet options
  vtkGetMacro(TwoSheets, bool);
  vtkSetMacro(TwoSheets, bool);
 
  vtkGetMacro(TwoSheetCaseId, bool);
  vtkSetMacro(TwoSheetCaseId, bool);
 
  vtkGetMacro(TwoSheetValue, bool);
  vtkSetMacro(TwoSheetValue, bool);
 
  vtkGetMacro(TwoSheetParameterization, bool);
  vtkSetMacro(TwoSheetParameterization, bool);
 
  vtkGetMacro(TwoSheetId, bool);
  vtkSetMacro(TwoSheetId, bool);
 
  vtkGetMacro(TwoSheetEdgeId, bool);
  vtkSetMacro(TwoSheetEdgeId, bool);
 
  vtkGetMacro(TwoSheetTetId, bool);
  vtkSetMacro(TwoSheetTetId, bool);
 
  vtkGetMacro(TwoSheetEdgeType, bool);
  vtkSetMacro(TwoSheetEdgeType, bool);
 
  vtkGetMacro(ThreeSheetTetNumber, bool);
  vtkSetMacro(ThreeSheetTetNumber, bool);
 
  vtkGetMacro(ThreeSheetVertexNumber, bool);
  vtkSetMacro(ThreeSheetVertexNumber, bool);
 
  vtkGetMacro(ThreeSheetExpansion, bool);
  vtkSetMacro(ThreeSheetExpansion, bool);
 
  vtkGetMacro(ThreeSheetDomainVolume, bool);
  vtkSetMacro(ThreeSheetDomainVolume, bool);
 
  vtkGetMacro(ThreeSheetRangeArea, bool);
  vtkSetMacro(ThreeSheetRangeArea, bool);
 
  vtkGetMacro(ThreeSheetHyperVolume, bool);
  vtkSetMacro(ThreeSheetHyperVolume, bool);
 
  vtkGetMacro(SimplificationThreshold, double);
  vtkSetMacro(SimplificationThreshold, double);
 
  vtkGetMacro(SimplificationCriterion, int);
  vtkSetMacro(SimplificationCriterion, int);
 
protected:
  ttkReebSpace();
 
  int FillInputPortInformation(int port, vtkInformation *info) override;
  int FillOutputPortInformation(int port, vtkInformation *info) override;
  int RequestData(vtkInformation *request,
                  vtkInformationVector **inputVector,
                  vtkInformationVector *outputVector) override;
 
  template <class dataTypeU, class dataTypeV>
  int dispatch(const dataTypeU *const uField,
               const dataTypeV *const vField,
               ttk::Triangulation *const triangulation);
 
private:
  bool ZeroSheetValue{true}, ZeroSheetVertexId{true}, ZeroSheetType{true},
    ZeroSheetId{true};
  bool OneSheetValue{true}, OneSheetVertexId{true}, OneSheetType{true},
    OneSheetId{true}, OneSheetEdgeId{true};
  bool TwoSheets{true}, TwoSheetCaseId{true}, TwoSheetValue{true},
    TwoSheetParameterization{true}, TwoSheetId{true}, TwoSheetEdgeId{true},
    TwoSheetTetId{true}, TwoSheetEdgeType{true};
  bool ThreeSheetVertexNumber{true}, ThreeSheetTetNumber{true},
    ThreeSheetExpansion{true}, ThreeSheetDomainVolume{true},
    ThreeSheetRangeArea{true}, ThreeSheetHyperVolume{true};
 
  bool ForceInputOffsetScalarField{false};
  bool UseOctreeAcceleration{true};
  int SimplificationCriterion{1};
  double SimplificationThreshold{0.0};
};