TopologicalSimplification.h

Go to the documentation of this file.

 
 
#pragma once
 
// base code includes
#include <Debug.h>
#include <LegacyTopologicalSimplification.h>
#include <LocalizedTopologicalSimplification.h>
#include <Triangulation.h>
 
#include <cmath>
#include <set>
#include <tuple>
#include <type_traits>
 
namespace ttk {
 
  class TopologicalSimplification : virtual public Debug {
  public:
    TopologicalSimplification();
 
    enum class BACKEND { LEGACY, LTS };
    /*
     * Either execute this file "legacy" algorithm, or the
     * lts algorithm. The choice depends on the value of the variable backend_.
     * Default is lts (localized).
     */
    template <typename dataType, typename triangulationType>
    int execute(const dataType *const inputScalars,
                dataType *const outputScalars,
                const SimplexId *const identifiers,
                const SimplexId *const inputOffsets,
                SimplexId *const offsets,
                const SimplexId constraintNumber,
                const bool addPerturbation,
                const triangulationType &triangulation);
 
    inline void setBackend(const BACKEND arg) {
      backend_ = arg;
    }
 
    inline int preconditionTriangulation(AbstractTriangulation *triangulation) {
      switch(backend_) {
        case BACKEND::LEGACY:
          legacyObject_.setDebugLevel(debugLevel_);
          legacyObject_.setThreadNumber(threadNumber_);
          legacyObject_.preconditionTriangulation(triangulation);
          break;
 
        case BACKEND::LTS:
          ltsObject_.setDebugLevel(debugLevel_);
          ltsObject_.setThreadNumber(threadNumber_);
          ltsObject_.preconditionTriangulation(triangulation);
          break;
 
        default:
          this->printErr(
            "Error, the backend for topological simplification is invalid");
          return -1;
      }
      return 0;
    }
 
  protected:
    BACKEND backend_{BACKEND::LTS};
    LegacyTopologicalSimplification legacyObject_;
    lts::LocalizedTopologicalSimplification ltsObject_;
  };
} // namespace ttk
 
template <typename dataType, typename triangulationType>
int ttk::TopologicalSimplification::execute(
  const dataType *const inputScalars,
  dataType *const outputScalars,
  const SimplexId *const identifiers,
  const SimplexId *const inputOffsets,
  SimplexId *const offsets,
  const SimplexId constraintNumber,
  const bool addPerturbation,
  const triangulationType &triangulation) {
  switch(backend_) {
    case BACKEND::LTS:
      return ltsObject_
        .removeUnauthorizedExtrema<dataType, SimplexId, triangulationType>(
          outputScalars, offsets, &triangulation, identifiers, constraintNumber,
          addPerturbation);
    case BACKEND::LEGACY:
      return legacyObject_.execute(inputScalars, outputScalars, identifiers,
                                   inputOffsets, offsets, constraintNumber,
                                   triangulation);
 
    default:
      this->printErr(
        "Error, the backend for topological simplification is invalid");
      return -1;
  }
}