ttkPlanarGraphLayout.h

Go to the documentation of this file.

 
 
#pragma once
 
// Module
#include <ttkPlanarGraphLayoutModule.h>
 
// VTK includes
#include <ttkAlgorithm.h>
#include <vtkUnstructuredGrid.h>
 
// TTK includes
#include <PlanarGraphLayout.h>
#include <vtkUnstructuredGrid.h>
 
class TTKPLANARGRAPHLAYOUT_EXPORT ttkPlanarGraphLayout
  : public ttkAlgorithm,
    protected ttk::PlanarGraphLayout {
 
private:
  // --- Graph Planar Layout
  // optional field data
  bool UseSequences{false};
  bool UseSizes{false};
  bool UseBranches{false};
  bool UseLevels{false};
 
  // output field name
  std::string OutputArrayName{"Layout"};
 
  // --- Merge Tree Planar Layout
  bool InputIsAMergeTree = false;
  bool BranchDecompositionPlanarLayout = false;
  double BranchSpacing = 1.;
  double ImportantPairs = 10.; // important pairs threshold
  int MaximumImportantPairs = 0;
  int MinimumImportantPairs = 0;
  double ImportantPairsSpacing = 1.;
  double NonImportantPairsSpacing = 0.1;
  double NonImportantPairsProximity = 0.05;
  std::string ExcludeImportantPairsLower = "";
  std::string ExcludeImportantPairsHigher = "";
 
public:
  // --- Graph Planar Layout
  // getters and setters for optional arrays
  vtkSetMacro(UseSequences, bool);
  vtkGetMacro(UseSequences, bool);
 
  vtkSetMacro(UseSizes, bool);
  vtkGetMacro(UseSizes, bool);
 
  vtkSetMacro(UseBranches, bool);
  vtkGetMacro(UseBranches, bool);
 
  vtkSetMacro(UseLevels, bool);
  vtkGetMacro(UseLevels, bool);
 
  // getters and setters for output array name
  vtkSetMacro(OutputArrayName, const std::string &);
  vtkGetMacro(OutputArrayName, std::string);
 
  // --- Merge Tree Planar Layout
  vtkSetMacro(InputIsAMergeTree, bool);
  vtkGetMacro(InputIsAMergeTree, bool);
 
  vtkSetMacro(BranchDecompositionPlanarLayout, bool);
  vtkGetMacro(BranchDecompositionPlanarLayout, bool);
 
  vtkSetMacro(BranchSpacing, double);
  vtkGetMacro(BranchSpacing, double);
 
  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 ttkPlanarGraphLayout *New();
  vtkTypeMacro(ttkPlanarGraphLayout, ttkAlgorithm);
 
protected:
  ttkPlanarGraphLayout();
  ~ttkPlanarGraphLayout() override;
 
  int FillInputPortInformation(int port, vtkInformation *info) override;
  int FillOutputPortInformation(int port, vtkInformation *info) override;
  int RequestData(vtkInformation *request,
                  vtkInformationVector **inputVector,
                  vtkInformationVector *outputVector) override;
 
  int planarGraphLayoutCall(vtkInformation *request,
                            vtkInformationVector **inputVector,
                            vtkInformationVector *outputVector);
  int mergeTreePlanarLayoutCall(vtkInformation *request,
                                vtkInformationVector **inputVector,
                                vtkInformationVector *outputVector);
 
  template <class dataType>
  int mergeTreePlanarLayoutCallTemplate(vtkUnstructuredGrid *treeNodes,
                                        vtkUnstructuredGrid *treeArcs,
                                        vtkUnstructuredGrid *output);
};