ttkMergeTreePrincipalGeodesics.h

Go to the documentation of this file.

 
#pragma once
 
// VTK Module
#include <ttkMergeTreePrincipalGeodesicsModule.h>
 
// VTK Includes
#include <ttkAlgorithm.h>
#include <vtkMultiBlockDataSet.h>
#include <vtkUnstructuredGrid.h>
 
// TTK Base Includes
#include <FTMTree.h>
#include <MergeTreePrincipalGeodesics.h>
#include <ttkMergeTreeVisualization.h>
 
class TTKMERGETREEPRINCIPALGEODESICS_EXPORT ttkMergeTreePrincipalGeodesics
  : public ttkAlgorithm // we inherit from the generic ttkAlgorithm class
  ,
    protected ttk::MergeTreePrincipalGeodesics // and we inherit from the base
                                               // class
{
private:
  // Input options
  double oldEpsilonTree1;
  int DiagramPairTypes = 0;
  // Output options
 
  // ----------------------
  // Data for visualization
  // ----------------------
  // Trees
  std::vector<ttk::ftm::MergeTree<double>> intermediateDTrees;
  std::vector<vtkUnstructuredGrid *> treesNodes, treesNodes2;
  std::vector<vtkUnstructuredGrid *> treesArcs, treesArcs2;
  std::vector<vtkDataSet *> treesSegmentation, treesSegmentation2;
  // Output
  // -> base class
 
  void setDataVisualization(int ttkNotUsed(numInputs),
                            int ttkNotUsed(numInputs2)) {
  }
 
  void resetDataVisualization() {
    setDataVisualization(0, 0);
    if(not keepState_) {
      barycenter_ = ttk::ftm::MergeTree<double>();
      allTs_.clear();
    }
  }
 
  bool isDataVisualizationFilled() {
    return allTs_.size() != 0 and not keepState_;
  }
 
public:
  // Input Options
  void SetNormalizedWasserstein(bool nW) {
    normalizedWasserstein_ = nW;
    Modified();
    resetDataVisualization();
  }
  bool GetNormalizedWasserstein() {
    return normalizedWasserstein_;
  }
 
  void SetNumberOfGeodesics(unsigned int numberOfGeodesics) {
    numberOfAxes_ = numberOfGeodesics;
    Modified();
    resetDataVisualization();
  }
  unsigned int GetNumberOfGeodesics() {
    return numberOfAxes_;
  }
 
  void SetNumberOfProjectionIntervals(unsigned int intervals) {
    k_ = intervals;
    Modified();
    resetDataVisualization();
  }
  unsigned int GetNumberOfProjectionIntervals() {
    return k_;
  }
 
  void SetNumberOfProjectionSteps(unsigned int steps) {
    noProjectionStep_ = steps;
    Modified();
    resetDataVisualization();
  }
  unsigned int GetNumberOfProjectionSteps() {
    return noProjectionStep_;
  }
 
  void SetBarycenterSizeLimitPercent(double percent) {
    barycenterSizeLimitPercent_ = percent;
    Modified();
    resetDataVisualization();
  }
  double GetBarycenterSizeLimitPercent() {
    return barycenterSizeLimitPercent_;
  }
 
  void SetDeterministic(bool deterministic) {
    deterministic_ = deterministic;
    Modified();
    resetDataVisualization();
  }
  bool GetDeterministic() {
    return deterministic_;
  }
 
  void SetJoinSplitMixtureCoefficient(double joinSplitMixtureCoefficient) {
    mixtureCoefficient_ = joinSplitMixtureCoefficient;
    Modified();
    resetDataVisualization();
  }
  double GetJoinSplitMixtureCoefficient() {
    return mixtureCoefficient_;
  }
 
  void SetDiagramPairTypes(int diagramPairTypes) {
    DiagramPairTypes = diagramPairTypes;
    Modified();
    resetDataVisualization();
  }
  vtkGetMacro(DiagramPairTypes, int);
 
  void SetKeepState(bool keepState) {
    keepState_ = keepState;
    Modified();
    resetDataVisualization();
  }
  bool GetKeepState() {
    return keepState_;
  }
 
  void SetEpsilon1UseFarthestSaddle(bool epsilon1UseFarthestSaddle) {
    epsilon1UseFarthestSaddle_ = epsilon1UseFarthestSaddle;
    Modified();
    resetDataVisualization();
  }
  bool GetEpsilon1UseFarthestSaddle() {
    return epsilon1UseFarthestSaddle_;
  }
 
  void SetEpsilonTree1(double epsilonTree1) {
    epsilonTree1_ = epsilonTree1;
    oldEpsilonTree1 = epsilonTree1_;
    Modified();
    resetDataVisualization();
  }
  double GetEpsilonTree1() {
    return epsilonTree1_;
  }
 
  void SetEpsilon2Tree1(double epsilon2Tree1) {
    epsilon2Tree1_ = epsilon2Tree1;
    Modified();
    resetDataVisualization();
  }
  double GetEpsilon2Tree1() {
    return epsilon2Tree1_;
  }
 
  void SetEpsilon3Tree1(double epsilon3Tree1) {
    epsilon3Tree1_ = epsilon3Tree1;
    Modified();
    resetDataVisualization();
  }
  double GetEpsilon3Tree1() {
    return epsilon3Tree1_;
  }
 
  void SetPersistenceThreshold(double persistenceThreshold) {
    persistenceThreshold_ = persistenceThreshold;
    Modified();
    resetDataVisualization();
  }
  double GetPersistenceThreshold() {
    return persistenceThreshold_;
  }
 
  void SetDeleteMultiPersPairs(bool delMultiPersPairs) {
    deleteMultiPersPairs_ = delMultiPersPairs;
    Modified();
    resetDataVisualization();
  }
  bool GetDeleteMultiPersPairs() {
    return deleteMultiPersPairs_;
  }
 
  // Output options
  void SetComputeReconstructionError(bool b) {
    doComputeReconstructionError_ = b;
    Modified();
    resetDataVisualization();
  }
  bool GetComputeReconstructionError() {
    return doComputeReconstructionError_;
  }

  static ttkMergeTreePrincipalGeodesics *New();
  vtkTypeMacro(ttkMergeTreePrincipalGeodesics, ttkAlgorithm);
 
protected:
  ttkMergeTreePrincipalGeodesics();

  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<vtkSmartPointer<vtkMultiBlockDataSet>> &inputTrees2);
 
  template <class dataType>
  int runCompute(
    vtkInformationVector *outputVector,
    std::vector<vtkSmartPointer<vtkMultiBlockDataSet>> &inputTrees,
    std::vector<vtkSmartPointer<vtkMultiBlockDataSet>> &inputTrees2);
 
  template <class dataType>
  int runOutput(
    vtkInformationVector *outputVector,
    std::vector<vtkSmartPointer<vtkMultiBlockDataSet>> &inputTrees,
    std::vector<vtkSmartPointer<vtkMultiBlockDataSet>> &inputTrees2);
 
  template <class dataType>
  void makeBarycenterOutput(ttk::ftm::MergeTree<dataType> &barycenter,
                            int blockId,
                            vtkMultiBlockDataSet *output_barycenter);
};