DimensionReductionMetrics.h

Go to the documentation of this file.

 
#pragma once
 
// ttk common includes
#include <Debug.h>
 
namespace ttk {
 
  class DimensionReductionMetrics : virtual public Debug {
 
  public:
    DimensionReductionMetrics();

    void execute(std::vector<std::vector<double>> const &input,
                 std::vector<std::vector<double>> const &latent);
 
    struct Metrics {
      double w0, w1, ta, lc, rmse, trust, cont, lcmc, mrreh, mrrel;
    };
    Metrics get() const {
      return {w0_, w1_, ta_, lc_, rmse_, trust_, cont_, lcmc_, mrreh_, mrrel_};
    }
 
  protected:
    double Wasserstein{2.};

    int SampleSize{-1};

    unsigned NeighborhoodSize{10};

    double w0_{0.};

    double w1_{0.};

    double ta_{0.};

    double lc_{0.};

    double rmse_{0.};

    double trust_{0.};

    double cont_{0.};

    double lcmc_{0.};

    double mrreh_{0.};

    double mrrel_{0.};
 
  private:
    unsigned n_;
    unsigned dimHigh_;
    unsigned dimLow_;
    std::vector<double> inputCompressedDistanceMatrix_;
    std::vector<double> latentCompressedDistanceMatrix_;
 
    inline double inputDM(unsigned i, unsigned j) const {
      if(i == j)
        return 0.;
      else
        return inputCompressedDistanceMatrix_[std::max(i, j)
                                                * (std::max(i, j) - 1) / 2
                                              + std::min(i, j)];
    }
 
    inline double latentDM(unsigned i, unsigned j) const {
      if(i == j)
        return 0.;
      else
        return latentCompressedDistanceMatrix_[std::max(i, j)
                                                 * (std::max(i, j) - 1) / 2
                                               + std::min(i, j)];
    }
 
    void computeTopologicalMetrics();
    void computeTripletAccuracy();
    void computePairwiseDistanceBasedMetrics();
    void computeRankBasedMetrics();
 
    bool tripletOrderPreserved(int i, int j, int k) const;
 
  }; // DimensionReductionMetrics class
 
} // namespace ttk