ttkTrackingFromFields.h

Go to the documentation of this file.

 
#pragma once
 
#include <vtkCellData.h>
#include <vtkDataSet.h>
#include <vtkUnstructuredGrid.h>
 
// VTK Module
#include <TrackingFromCriticalPoints.h>
#include <TrackingFromFields.h>
#include <TrackingPostProcessing.h>
#include <ttkAlgorithm.h>
#include <ttkTrackingFromFieldsModule.h>
 
#include <algorithm>
#include <string>
 
class TTKTRACKINGFROMFIELDS_EXPORT ttkTrackingFromFields
  : public ttkAlgorithm,
    protected ttk::TrackingFromFields {
 
public:
  static ttkTrackingFromFields *New();
 
  vtkTypeMacro(ttkTrackingFromFields, ttkAlgorithm);

  vtkSetMacro(Sampling, int);
  vtkGetMacro(Sampling, int);

  vtkSetMacro(StartTimestep, int);
  vtkGetMacro(StartTimestep, int);

  vtkSetMacro(EndTimestep, int);
  vtkGetMacro(EndTimestep, int);

  vtkSetMacro(Tolerance, double);
  vtkGetMacro(Tolerance, double);
 
  vtkSetMacro(RelativeDestructionCost, double);
  vtkGetMacro(RelativeDestructionCost, double);
 
  vtkSetMacro(AssignmentPrecision, double);
  vtkGetMacro(AssignmentPrecision, double);

  vtkSetMacro(PX, double);
  vtkGetMacro(PX, double);

  vtkSetMacro(PY, double);
  vtkGetMacro(PY, double);

  vtkSetMacro(PZ, double);
  vtkGetMacro(PZ, double);

  vtkSetMacro(PE, double);
  vtkGetMacro(PE, double);

  vtkSetMacro(PS, double);
  vtkGetMacro(PS, double);

  vtkSetMacro(PF, double);
  vtkGetMacro(PF, double);

  vtkSetMacro(WassersteinMetric, const std::string &);
  vtkGetMacro(WassersteinMetric, std::string);
 
  vtkSetMacro(DistanceAlgorithm, const std::string &);
  vtkGetMacro(DistanceAlgorithm, std::string);

  vtkSetMacro(PVAlgorithm, int);
  vtkGetMacro(PVAlgorithm, int);
 
  vtkSetMacro(AssignmentMethod, int);
  vtkGetMacro(AssignmentMethod, int);

  vtkSetMacro(UseGeometricSpacing, bool);
  vtkGetMacro(UseGeometricSpacing, bool);

  vtkSetMacro(Spacing, double);
  vtkGetMacro(Spacing, double);

  vtkSetMacro(DoPostProc, bool);
  vtkGetMacro(DoPostProc, bool);

  vtkSetMacro(PostProcThresh, double);
  vtkGetMacro(PostProcThresh, double);

  vtkSetMacro(EnablePostProc, bool);
  vtkGetMacro(EnablePostProc, bool);

  vtkSetMacro(DoLinearize, bool);
  vtkGetMacro(DoLinearize, bool);

  vtkSetMacro(DoFusion, bool);
  vtkGetMacro(DoFusion, bool);

  vtkSetMacro(LinearizeFuse, bool);
  vtkGetMacro(LinearizeFuse, bool);

  vtkSetMacro(DoStartFrame, bool);
  vtkGetMacro(DoStartFrame, bool);

  vtkSetMacro(StartFrame, int);
  vtkGetMacro(StartFrame, int);

  vtkSetMacro(DoMergeTree, bool);
  vtkGetMacro(DoMergeTree, bool);

  vtkSetMacro(UseSplitTree, int);
  vtkGetMacro(UseSplitTree, int);

  vtkSetMacro(UseOtsuSimplification, bool);
  vtkGetMacro(UseOtsuSimplification, bool);
 
  vtkSetMacro(OtsuBins, int);
  vtkGetMacro(OtsuBins, int);
 
  vtkSetMacro(MaxSurfSize, int);
  vtkGetMacro(MaxSurfSize, int);

  vtkSetMacro(CosColDegrees, double);
  vtkGetMacro(CosColDegrees, double);

  vtkSetMacro(MaxLinkRadius, double);
  vtkGetMacro(MaxLinkRadius, double);

  vtkSetMacro(MaxFrameDist, int);
  vtkGetMacro(MaxFrameDist, int);
 
protected:
  ttkTrackingFromFields();
 
  int FillInputPortInformation(int port, vtkInformation *info) override;
  int FillOutputPortInformation(int port, vtkInformation *info) override;
  int RequestDataObject(vtkInformation *request,
                        vtkInformationVector **inputVector,
                        vtkInformationVector *outputVector) override;
  int RequestData(vtkInformation *request,
                  vtkInformationVector **inputVector,
                  vtkInformationVector *outputVector) override;
 
private:
  // Sampling config.
  int StartTimestep{0};
  int EndTimestep{-1};
  int Sampling{1};
 
  // Filtering config.
  double Tolerance{1};
  double PX{1};
  double PY{1};
  double PZ{1};
  double PE{0};
  double PS{0};
  double PF{0};
 
  double RelativeDestructionCost{0.1};
  double AssignmentPrecision{0.01};
  int AssignmentMethod{0};
 
  // Bottleneck config.
  bool UseGeometricSpacing{false};
  bool DoPostProc{false};
  double PostProcThresh{0.0};
  double Spacing{1.0};
  std::string DistanceAlgorithm{"ttk"};
  int PVAlgorithm{2};
  std::string WassersteinMetric{"2"};
 
  // Post-processing config.
  bool EnablePostProc{false};
  bool DoLinearize{true};
  bool DoFusion{true};
  bool LinearizeFuse{true};
  bool DoStartFrame{false};
  int StartFrame{0};
  bool DoMergeTree{false};
  int UseSplitTree{2};
  bool UseOtsuSimplification{false};
  int OtsuBins{0};
  int MaxSurfSize{10000};
  double CosColDegrees{20.0};
  double MaxLinkRadius{225.0};
  int MaxFrameDist{30};
 
  template <class dataType, class triangulationType>
  int trackWithPersistenceMatching(vtkUnstructuredGrid *output,
                                   unsigned long fieldNumber,
                                   const triangulationType *triangulation);
 
  template <class dataType, class triangulationType>
  int trackWithCriticalPointMatching(vtkUnstructuredGrid *output,
                                     unsigned long fieldNumber,
                                     const triangulationType *triangulation);
 
  template <class dataType, class triangulationType>
  int applyPostProcessing(vtkUnstructuredGrid *output,
                          vtkDataSet *segOutput,
                          vtkDataSet *input,
                          const std::vector<vtkDataArray *> &inputScalarFields,
                          const triangulationType *triangulation);
 
  void writeSegmentationArrays(
    vtkDataSet *segOutput,
    const std::vector<std::vector<int>> &vertexTrajPerFrame);
};