ttkMergeTreeTemporalReductionDecoding.h

Go to the documentation of this file.

 
#pragma once
 
// VTK Module
#include <ttkMergeTreeTemporalReductionDecodingModule.h>
 
// VTK Includes
#include <ttkAlgorithm.h>
#include <vtkSmartPointer.h>
 
/* Note on including VTK modules
 *
 * Each VTK module that you include a header from needs to be specified in this
 * module's vtk.module file, either in the DEPENDS or PRIVATE_DEPENDS (if the
 * header is included in the cpp file only) sections.
 *
 * In order to find the corresponding module, check its location within the VTK
 * source code. The VTK module name is composed of the path to the header. You
 * can also find the module name within the vtk.module file located in the same
 * directory as the header file.
 *
 * For example, vtkSphereSource.h is located in directory VTK/Filters/Sources/,
 * so its corresponding VTK module is called VTK::FiltersSources. In this case,
 * the vtk.module file would need to be extended to
 *
 * NAME
 *   ttkMergeTreeTemporalReductionDecoding
 * DEPENDS
 *   ttkAlgorithm
 *   VTK::FiltersSources
 */
 
// TTK Base Includes
#include <MergeTreeTemporalReductionDecoding.h>
 
// VTK Includes
#include <vtkMultiBlockDataSet.h>
#include <vtkUnstructuredGrid.h>
 
class TTKMERGETREETEMPORALREDUCTIONDECODING_EXPORT
  ttkMergeTreeTemporalReductionDecoding
  : public ttkAlgorithm // we inherit from the generic ttkAlgorithm class
  ,
    protected ttk::MergeTreeTemporalReductionDecoding // and we inherit from the
                                                      // base class
{
private:
  using idNode = ttk::ftm::idNode;
 
  // Output options
  bool OutputTrees = true;
  bool PlanarLayout = false;
  bool BranchDecompositionPlanarLayout = false;
  bool PathPlanarLayout = false;
  double BranchSpacing = 1.;
  bool RescaleTreesIndividually = false;
  double DimensionSpacing = 1.;
  int DimensionToShift = 0;
  double ImportantPairs = 50.;
  int MaximumImportantPairs = 0;
  int MinimumImportantPairs = 0;
  double ImportantPairsSpacing = 1.;
  double NonImportantPairsSpacing = 1.;
  double NonImportantPairsProximity = 0.05;
  std::string ExcludeImportantPairsLower = "";
  std::string ExcludeImportantPairsHigher = "";
 
  // ----------------------
  // Data for visualization
  // ----------------------
  // Trees
  std::vector<vtkUnstructuredGrid *> treesNodes;
  std::vector<vtkUnstructuredGrid *> treesArcs;
  std::vector<vtkDataSet *> treesSegmentation;
  // Output
  std::vector<std::vector<int>> treesNodeCorrMesh;
  std::vector<ttk::ftm::MergeTree<double>> intermediateSTrees;
  std::vector<std::vector<std::tuple<idNode, idNode, double>>> allMatching;
 
  void setDataVisualization(int numInputs) {
    // Trees
    treesNodes = std::vector<vtkUnstructuredGrid *>(numInputs);
    treesArcs = std::vector<vtkUnstructuredGrid *>(numInputs);
    treesSegmentation = std::vector<vtkDataSet *>(numInputs);
  }
 
  void resetDataVisualization() {
    setDataVisualization(0);
    treesNodeCorrMesh = std::vector<std::vector<int>>();
    intermediateSTrees = std::vector<ttk::ftm::MergeTree<double>>();
    allMatching
      = std::vector<std::vector<std::tuple<idNode, idNode, double>>>();
  }
 
  bool isDataVisualizationFilled() {
    return treesNodeCorrMesh.size() != 0 and intermediateSTrees.size() != 0
           and allMatching.size() != 0;
  }
 
public:
  // Input Options
  void SetAssignmentSolver(int assignmentSolver) {
    assignmentSolverID_ = assignmentSolver;
    Modified();
    resetDataVisualization();
  }
  int GetAssignmentSolver() {
    return assignmentSolverID_;
  }
 
  void SetUsePathMappings(double usePM) {
    usePathMappings_ = usePM;
    Modified();
    resetDataVisualization();
  }
  double GetPathMappings() {
    return usePathMappings_;
  }
 
  // Output Options
  vtkSetMacro(OutputTrees, bool);
  vtkGetMacro(OutputTrees, bool);
 
  vtkSetMacro(PlanarLayout, bool);
  vtkGetMacro(PlanarLayout, bool);
 
  vtkSetMacro(BranchDecompositionPlanarLayout, bool);
  vtkGetMacro(BranchDecompositionPlanarLayout, bool);
 
  vtkSetMacro(PathPlanarLayout, bool);
  vtkGetMacro(PathPlanarLayout, bool);
 
  vtkSetMacro(BranchSpacing, double);
  vtkGetMacro(BranchSpacing, double);
 
  vtkSetMacro(RescaleTreesIndividually, bool);
  vtkGetMacro(RescaleTreesIndividually, bool);
 
  vtkSetMacro(DimensionSpacing, double);
  vtkGetMacro(DimensionSpacing, double);
 
  vtkSetMacro(DimensionToShift, int);
  vtkGetMacro(DimensionToShift, int);
 
  vtkSetMacro(ImportantPairs, double);
  vtkGetMacro(ImportantPairs, double);
 
  vtkSetMacro(MaximumImportantPairs, int);
  vtkGetMacro(MaximumImportantPairs, int);
 
  vtkSetMacro(MinimumImportantPairs, int);
  vtkGetMacro(MinimumImportantPairs, int);
 
  vtkSetMacro(ImportantPairsSpacing, double);
  vtkGetMacro(ImportantPairsSpacing, double);
 
  vtkSetMacro(NonImportantPairsSpacing, double);
  vtkGetMacro(NonImportantPairsSpacing, double);
 
  vtkSetMacro(NonImportantPairsProximity, double);
  vtkGetMacro(NonImportantPairsProximity, double);
 
  vtkSetMacro(ExcludeImportantPairsLower, const std::string &);
  vtkGetMacro(ExcludeImportantPairsLower, std::string);
 
  vtkSetMacro(ExcludeImportantPairsHigher, const std::string &);
  vtkGetMacro(ExcludeImportantPairsHigher, std::string);

  static ttkMergeTreeTemporalReductionDecoding *New();
  vtkTypeMacro(ttkMergeTreeTemporalReductionDecoding, ttkAlgorithm);
 
protected:
  ttkMergeTreeTemporalReductionDecoding();
  ~ttkMergeTreeTemporalReductionDecoding() override;

  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 dataType>
  int run(vtkInformationVector *outputVector,
          std::vector<vtkSmartPointer<vtkMultiBlockDataSet>> &inputTrees,
          std::vector<std::tuple<double, int, int, int, int>> &coefs,
          std::vector<bool> &interpolatedTrees);
 
  template <class dataType>
  int runCompute(std::vector<vtkSmartPointer<vtkMultiBlockDataSet>> &inputTrees,
                 std::vector<std::tuple<double, int, int, int, int>> &coefs);
 
  template <class dataType>
  int runOutput(vtkInformationVector *outputVector,
                std::vector<vtkSmartPointer<vtkMultiBlockDataSet>> &inputTrees,
                std::vector<std::tuple<double, int, int, int, int>> &coefs,
                std::vector<bool> &interpolatedTrees);
};