multipers 2.3.3b6__cp310-cp310-macosx_11_0_arm64.whl

multipers/gudhi/gudhi/Multi_persistence/Box.h

@@ -0,0 +1,174 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    Author(s):       David Loiseaux
+ *
+ *    Copyright (C) 2023 Inria
+ *
+ *    Modification(s):
+ *      - 2024/08 Hannah Schreiber: doc
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+/**
+ * @file Box.h
+ * @author David Loiseaux
+ * @brief Contains the @ref Gudhi::multi_persistence::Box class.
+ */
+
+#ifndef BOX_H_INCLUDED
+#define BOX_H_INCLUDED
+
+#include <ostream>  //std::ostream
+
+#include <gudhi/Debug_utils.h>
+#include <gudhi/One_critical_filtration.h>
+
+namespace Gudhi{
+namespace multi_persistence {
+
+/**
+ * @class Box Box.h gudhi/Multi_persistence/Box.h
+ * @ingroup multi_persistence
+ *
+ * @brief Simple box in \f$\mathbb R^n\f$ defined by two diametrically opposite corners.
+ *
+ * @tparam T Type of the coordinates of the Box. Has to follow the conditions of the template parameter of
+ * @ref One_critical_filtration "".
+ */
+template <typename T>
+class Box {
+ public:
+  using Point = Gudhi::multi_filtration::One_critical_filtration<T>; /**< Type of a point in \f$\mathbb R^n\f$. */
+
+  /**
+   * @brief Default constructor. Constructs a trivial box with corners at minus infinity.
+   */
+  Box() {}
+
+  /**
+   * @brief Constructs a box from the two given corners. Assumes that \f$ lowerCorner \le @p upperCorner \f$ and
+   * if both are finite values, they have the same dimension.
+   *
+   * @param lowerCorner First corner of the box. Has to be smaller than `upperCorner`.
+   * @param upperCorner Second corner of the box. Has to be greater than `lowerCorner`.
+   */
+  Box(const Point &lowerCorner, const Point &upperCorner) : lowerCorner_(lowerCorner), upperCorner_(upperCorner) {
+    GUDHI_CHECK(lowerCorner.size() == upperCorner.size() || !lowerCorner.is_finite() || !upperCorner.is_finite(),
+                "The two corners of the box don't have the same dimension.");
+  }
+
+  /**
+   * @brief Constructs a box from the two given corners. Assumes that \f$ box.first \le @p box.second \f$ and
+   * if both are finite values, they have the same dimension.
+   *
+   * @param box Pair of corners defining the wished box.
+   */
+  Box(const std::pair<Point, Point> &box) : Box(box.first, box.second) {}
+
+  /**
+   * @brief Returns the lowest of both defining corners.
+   */
+  const Point &get_lower_corner() const { return lowerCorner_; }
+
+  /**
+   * @brief Returns the lowest of both defining corners.
+   */
+  Point &get_lower_corner() { return lowerCorner_; }
+
+  /**
+   * @brief Returns the greatest of both defining corners.
+   */
+  Point &get_upper_corner() { return upperCorner_; }
+
+  /**
+   * @brief Returns the greatest of both defining corners.
+   */
+  const Point &get_upper_corner() const { return upperCorner_; }
+
+  /**
+   * @brief Returns a pair of const references to both defining corners.
+   */
+  std::pair<const Point &, const Point &> get_bounding_corners() const { return {lowerCorner_, upperCorner_}; }
+
+  /**
+   * @brief Returns a pair of references to both defining corners.
+   */
+  std::pair<Point &, Point &> get_bounding_corners() { return {lowerCorner_, upperCorner_}; }
+
+  /**
+   * @brief Returns true if and only if one of the following is true:
+   * - one of the corners is empty
+   * - one of the corners has value NaN
+   * - both corners have value infinity
+   * - both corners have value minus infinity
+   * - both corners are finite but don't have the same dimension.
+   */
+  bool is_trivial() const {
+    return lowerCorner_.empty() || upperCorner_.empty() || lowerCorner_.is_nan() || upperCorner_.is_nan() ||
+           (lowerCorner_.is_plus_inf() && upperCorner_.is_plus_inf()) ||
+           (lowerCorner_.is_minus_inf() && upperCorner_.is_minus_inf()) ||
+           (lowerCorner_.is_finite() && upperCorner_.is_finite() &&
+            lowerCorner_.num_parameters() != upperCorner_.num_parameters());
+  }
+
+  /**
+   * @brief Returns true if and only if the given point is inside the box.
+   * If the box is not {-infinity, infinity} and the given point is finite, but has not the same dimension
+   * than the box, the point is considered outside.
+   */
+  bool contains(const Point &point) const {
+    if (point.is_nan() || is_trivial()) return false;
+    if (point.is_plus_inf()) return upperCorner_.is_plus_inf();
+    if (point.is_minus_inf()) return lowerCorner_.is_minus_inf();
+
+    if ((lowerCorner_.is_finite() && point.size() != lowerCorner_.size()) ||
+        (upperCorner_.is_finite() && point.size() != upperCorner_.size())) {
+      // TODO: make it a warning, with future GUDHI_CHECK version?
+      // std::cerr << "Box and point are not of the same dimension." << std::endl;
+      return false;
+    }
+
+    return lowerCorner_ <= point && point <= upperCorner_;
+  }
+
+  /**
+   * @brief Returns the dimension of the box. If the box is trivial or both corners are infinite, the dimension is 0.
+   */
+  std::size_t dimension() const {
+    if (is_trivial()) return 0;
+    if (lowerCorner_.is_minus_inf() && upperCorner_.is_plus_inf()) return 0;  // not so sure what we want to do here
+    return lowerCorner_.is_finite() ? lowerCorner_.size() : upperCorner_.size();
+  }
+
+  /**
+   * @brief Inflates the box by delta.
+   *
+   * @param delta Inflation coefficient.
+   */
+  void inflate(T delta) {
+    lowerCorner_ -= delta;
+    upperCorner_ += delta;
+  }
+  friend bool operator==(const Box& a, const Box&b){
+    return a.upperCorner_ == b.upperCorner_ && a.lowerCorner_ == b.lowerCorner_;
+  }
+
+  /**
+   * @brief Outstream operator.
+   */
+  friend std::ostream &operator<<(std::ostream &os, const Box<T> &box) {
+    os << "Box -- Bottom corner : ";
+    os << box.get_lower_corner();
+    os << ", Top corner : ";
+    os << box.get_upper_corner();
+    return os;
+  }
+
+ private:
+  Point lowerCorner_; /**< Lowest of defining corners. */
+  Point upperCorner_; /**< Greatest of defining corners. */
+};
+
+}}  // namespace Gudhi::multi_persistence
+
+#endif  // BOX_H_INCLUDED

multipers/gudhi/gudhi/Multi_persistence/Line.h

@@ -0,0 +1,282 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    Author(s):       David Loiseaux
+ *
+ *    Copyright (C) 2023 Inria
+ *
+ *    Modification(s):
+ *      - 2024/08 Hannah Schreiber: doc
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+/**
+ * @file Line.h
+ * @author David Loiseaux
+ * @brief Contains the @ref Gudhi::multi_persistence::Line class.
+ */
+
+#ifndef LINE_FILTRATION_TRANSLATION_H_INCLUDED
+#define LINE_FILTRATION_TRANSLATION_H_INCLUDED
+
+#include <cmath>
+#include <cstddef>
+#include <stdexcept>
+#include <limits>
+
+#include <gudhi/Debug_utils.h>
+#include <gudhi/One_critical_filtration.h>
+#include <gudhi/Multi_critical_filtration.h>
+#include <gudhi/Multi_persistence/Box.h>
+
+namespace Gudhi{
+namespace multi_persistence {
+
+/**
+ * @class Line Line.h gudhi/Multi_persistence/Line.h
+ * @ingroup multi_persistence
+ *
+ * @brief A line in \f$\mathbb R^n\f$, with some helpers to project points on it.
+ *
+ * @tparam T Type of the coordinate values. Has to follow the conditions of the template parameter of
+ * @ref One_critical_filtration "".
+ */
+template <typename T>
+class Line {
+ public:
+  /**
+   * @brief Coordinates in \f$\mathbb R^n\f$.
+   */
+  using Point = Gudhi::multi_filtration::One_critical_filtration<T>;
+  /**
+   * @brief Set of coordinates in \f$\mathbb R^n\f$.
+   */
+  using K_critical_point = Gudhi::multi_filtration::Multi_critical_filtration<T>;
+
+  /**
+   * @brief Default constructor. Sets the number of coordinates to 0.
+   */
+  Line() : basePoint_(0), direction_(0) {}  // has to be explicitly set to 0, otherwise becomes -inf
+  /**
+   * @brief Constructs a line going through the given point with slope 1.
+   *
+   * @param x A point of the line.
+   */
+  Line(const Point &x) : basePoint_(x), direction_(0) {}  // default direction
+  /**
+   * @brief Constructs a line going through the given point with slope 1.
+   *
+   * @param x A point of the line. Will be moved.
+   */
+  Line(Point &&x) : basePoint_(std::move(x)), direction_(0) {}  // default direction
+  /**
+   * @brief Constructs a line going through the given point in the direction of the given vector.
+   * If the vector has no coordinates, the slope is assumed to be 1.
+   * Otherwise, the vector has to be non trivial and all its coordinates have to be positive.
+   *
+   * @param x A point of the line.
+   * @param vector Direction of the line. Positive and non trivial.
+   */
+  Line(const Point &x, const Point &vector) : basePoint_(x), direction_(vector) { check_direction_(); }
+
+  /**
+   * @brief Returns the coordinates of the point on the line with "time" parameter `t`. That is, the point \f$ x \f$
+   * such that \f$ x[i] = base\_point[i] + t \times direction[i] \f$ for all \f$ i \in [0, n - 1] \f$ with \f$ n \f$
+   * the number of coordinates.
+   */
+  Point operator[](T t) const {
+    GUDHI_CHECK(direction_.empty() || direction_.size() == basePoint_.size(),
+                "Direction and base point do not have the same dimension.");
+
+    if constexpr (std::numeric_limits<T>::has_quiet_NaN){   //to avoid windows error
+      if (std::isnan(t)) return Point::nan();
+    }
+    if (t == Point::T_inf) return Point::inf();
+    if (t == -Point::T_inf) return Point::minus_inf();
+
+    Point x(basePoint_.size());
+
+    if (direction_.size() > 0) {
+      for (std::size_t i = 0; i < x.size(); i++) x[i] = basePoint_[i] + t * direction_[i];
+    } else
+      for (std::size_t i = 0; i < x.size(); i++) x[i] = basePoint_[i] + t;
+
+    return x;
+  }
+
+  /**
+   * @brief Translates the given line in the given direction.
+   */
+  friend Line &operator+=(Line &to_translate, const Point &v) {
+    to_translate.basePoint_ += v;
+    return to_translate;
+  }
+
+  /**
+   * @brief Returns a reference to the current base point of the line.
+   */
+  Point &base_point() { return basePoint_; }
+  /**
+   * @brief Returns a const reference to the current base point of the line.
+   */
+  const Point &base_point() const { return basePoint_; }
+
+  /**
+   * @brief Returns a reference to the direction vector of the line.
+   */
+  Point &direction() { return direction_; }
+  /**
+   * @brief Returns a const reference to the direction vector of the line.
+   */
+  const Point &direction() const { return direction_; }
+
+  // TODO: factorize forward and backward version by adding a `co` to One_critical_filtration?
+  // Could make problems with One_critical_filtration being the type of basePoint_ and direction_
+
+  /**
+   * @brief Computes the "time" parameter \f$ t \f$ of the starting point \f$ p = base\_point + t \times direction \f$
+   * of the intersection between the line and the closed positive cone originating at `x`.
+   *
+   * @tparam U Type of the time parameter.
+   * @param x Origin of the closed positive cone.
+   */
+  template <typename U = T>
+  U compute_forward_intersection(const Point &x) const {
+    GUDHI_CHECK(direction_.empty() || direction_.size() == x.size(), "x has not as many parameters as the line.");
+
+    constexpr const U inf =
+        std::numeric_limits<U>::has_infinity ? std::numeric_limits<U>::infinity() : std::numeric_limits<U>::max();
+    if (x.is_plus_inf() || x.is_nan()) return inf;
+    if (x.is_minus_inf()) return -inf;
+    U t = -inf;
+    if (direction_.size()) {
+      for (std::size_t i = 0; i < x.size(); i++) {
+        if (direction_[i] == 0) {
+          if (x[i] > basePoint_[i]) return inf;
+        } else {
+          t = std::max(t, (static_cast<U>(x[i]) - static_cast<U>(basePoint_[i])) / static_cast<U>((direction_[i])));
+        }
+      }
+    } else {
+      for (std::size_t i = 0; i < x.size(); i++) t = std::max(t, static_cast<U>(x[i]) - static_cast<U>(basePoint_[i]));
+    }
+
+    return t;
+  }
+
+  /**
+   * @brief Computes the "time" parameter \f$ t \f$ of the starting point \f$ p = base\_point + t \times direction \f$
+   * of the intersection between the line and the union of closed positive cones originating at the points in `x`.
+   *
+   * @tparam U Type of the time parameter.
+   * @param x Set of origins for the closed positive cones.
+   */
+  template <typename U = T>
+  U compute_forward_intersection(const K_critical_point &x) const {
+    constexpr const U inf =
+        std::numeric_limits<U>::has_infinity ? std::numeric_limits<U>::infinity() : std::numeric_limits<U>::max();
+    if (x.is_plus_inf() || x.is_nan()) return inf;
+    if (x.is_minus_inf()) return -inf;
+    U t = inf;
+    for (const auto &y : x) {
+      t = std::min(t, compute_forward_intersection<U>(y));
+    }
+    return t;
+  }
+
+  /**
+   * @brief Computes the "time" parameter \f$ t \f$ of the starting point \f$ p = base\_point + t \times direction \f$
+   * of the intersection between the line and the open negative cone originating at `x`.
+   *
+   * @tparam U Type of the time parameter.
+   * @param x Origin of the open negative cone.
+   */
+  template <typename U = T>
+  U compute_backward_intersection(const Point &x) const {
+    constexpr const U inf =
+        std::numeric_limits<U>::has_infinity ? std::numeric_limits<U>::infinity() : std::numeric_limits<U>::max();
+    if (x.is_plus_inf()) return inf;
+    if (x.is_minus_inf() || x.is_nan()) return -inf;
+    U t = inf;
+
+    if (direction_.size()) {
+      for (std::size_t i = 0; i < x.size(); i++) {
+        if (direction_[i] == 0) {
+          if (x[i] <= basePoint_[i]) return -inf;
+        } else {
+          t = std::min(t, (static_cast<U>(x[i]) - static_cast<U>(basePoint_[i])) / static_cast<U>(direction_[i]));
+        }
+      }
+    } else {
+      for (std::size_t i = 0; i < x.size(); i++) t = std::min(t, static_cast<U>(x[i] - basePoint_[i]));
+    }
+    return t;
+  }
+
+  /**
+   * @brief Computes the "time" parameter \f$ t \f$ of the starting point \f$ p = base\_point + t \times direction \f$
+   * of the intersection between the line and the union of open negative cones originating at the points in `x`.
+   *
+   * @tparam U Type of the time parameter.
+   * @param x Set of origins for the open negative cones.
+   */
+  template <typename U = T>
+  U compute_backward_intersection(const K_critical_point &x) const {
+    constexpr const U inf =
+        std::numeric_limits<U>::has_infinity ? std::numeric_limits<U>::infinity() : std::numeric_limits<U>::max();
+    if (x.is_plus_inf()) return inf;
+    if (x.is_minus_inf() || x.is_nan()) return -inf;
+    U t = -inf;
+    for (const auto &y : x) {
+      t = std::max(t, compute_backward_intersection<U>(y));
+    }
+    return t;
+  }
+
+  /**
+   * @brief Given a box, returns "time" parameter of the intersection of this box and the line.
+   *
+   * @param box Box to intersect.
+   * @return A pair representing the two bounding points of the intersection, such that the first element is the
+   * smallest of the two. If the box and the line do not intersect or the box is trivial, returns the pair {inf, -inf}.
+   */
+  std::pair<T, T> get_bounds(const Box<T> &box) const {
+    if (box.is_trivial()) return {Point::T_inf, -Point::T_inf};
+
+    T bottom = compute_forward_intersection(box.get_lower_corner());
+    T top = compute_backward_intersection(box.get_upper_corner());
+
+    if (bottom > top) return {Point::T_inf, -Point::T_inf};  // no intersection
+
+    return {bottom, top};
+  }
+
+ private:
+  Point basePoint_; /**< Any point on the line. */
+  Point direction_; /**< Direction of the line. */
+
+  /**
+   * @brief Checks that the arguments define a correct and positively slopped line.
+   */
+  void check_direction_() const {
+    if (direction_.size() == 0) return;  // default slope
+
+    bool is_trivial = true;
+    for (T v : direction_) {
+      if (v) {
+        is_trivial = false;
+      }
+      if (v < 0) {
+        throw std::invalid_argument("Direction should have positive entries.");
+      }
+    }
+    if (is_trivial) {
+      throw std::invalid_argument("Direction should have at least one non-trivial entry.");
+    }
+    if (direction_.size() != basePoint_.size())
+      throw std::invalid_argument("The dimensions of base point and direction are not equal.");
+  }
+};
+
+}}  // namespace Gudhi::multi_persistence
+
+#endif  // LINE_FILTRATION_TRANSLATION_H_INCLUDED

multipers/gudhi/gudhi/Off_reader.h

@@ -0,0 +1,173 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    Author(s):       David Salinas
+ *
+ *    Copyright (C) 2014 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+
+#ifndef OFF_READER_H_
+#define OFF_READER_H_
+
+
+#include <sstream>
+#include <iostream>
+#include <iterator>
+#include <string>
+#include <vector>
+#include <fstream>
+
+namespace Gudhi {
+
+/** \brief OFF file reader top class visitor. 
+ * 
+ * OFF file must be conform to \ref FileFormatsOFF
+ */
+class Off_reader {
+ public:
+  Off_reader(std::ifstream& stream) : stream_(stream) { }
+
+  ~Off_reader() {
+    stream_.close();
+  }
+
+  /** \brief
+   * Read an OFF file and calls the following methods :
+   * 
+   * <CODE>void init(int dim,int num_vertices,int num_faces,int num_edges);  // from file header - num_edges may not be set
+   * 
+   * void point(const std::vector<double>& point);  // for each point read
+   * 
+   * void maximal_face(const std::list<int>& face);  // for each face read
+   * 
+   * void done();  // upon file read is finished</CODE>
+   * 
+   * of the visitor when reading a point or a maximal face. Edges are not taken into account.
+   */
+  template<typename OffVisitor>
+  bool read(OffVisitor& off_visitor) {
+    bool success_read_off_preamble = read_off_preamble(off_visitor);
+    if (!success_read_off_preamble) {
+      std::cerr << "could not read off preambule\n";
+      return false;
+    }
+
+    bool success_read_off_points = read_off_points(off_visitor);
+    if (!success_read_off_points) {
+      std::cerr << "could not read off points\n";
+      return false;
+    }
+
+    bool success_read_off_faces = read_off_faces(off_visitor);
+    if (!success_read_off_faces) {
+      std::cerr << "could not read off faces\n";
+      return false;
+    }
+
+    off_visitor.done();
+    return success_read_off_preamble && success_read_off_points && success_read_off_faces;
+  }
+
+ private:
+  std::ifstream& stream_;
+
+  struct Off_info {
+    int dim;
+    int num_vertices;
+    int num_edges;
+    int num_faces;
+  };
+
+  Off_info off_info_;
+
+  template<typename OffVisitor>
+  bool read_off_preamble(OffVisitor& off_visitor) {
+    std::string line;
+    if (!goto_next_uncomment_line(line)) return false;
+
+    bool is_off_file = (line.find("OFF") != std::string::npos);
+    bool is_noff_file = (line.find("nOFF") != std::string::npos);
+
+
+
+    if (!is_off_file && !is_noff_file) {
+      std::cerr << line << std::endl;
+      std::cerr << "missing off header\n";
+      return false;
+    }
+
+    if (is_noff_file) {
+      // Should be on a separate line, but we accept it on the same line as the number of vertices
+      stream_ >> off_info_.dim;
+    } else {
+      off_info_.dim = 3;
+    }
+
+    if (!goto_next_uncomment_line(line)) return false;
+    std::istringstream iss(line);
+    if (!(iss >> off_info_.num_vertices >> off_info_.num_faces >> off_info_.num_edges)) {
+      std::cerr << "incorrect number of vertices/faces/edges\n";
+      return false;
+    }
+    off_visitor.init(off_info_.dim, off_info_.num_vertices, off_info_.num_faces, off_info_.num_edges);
+
+    return true;
+  }
+
+  bool goto_next_uncomment_line(std::string& uncomment_line) {
+    do {
+      // skip whitespace, including empty lines
+      if (!std::ifstream::sentry(stream_)) return false;
+      std::getline(stream_, uncomment_line);
+    } while (uncomment_line[0] == '#');
+    return static_cast<bool>(stream_);
+  }
+
+  template<typename OffVisitor>
+  bool read_off_points(OffVisitor& visitor) {
+    int num_vertices_to_read = off_info_.num_vertices;
+    while (num_vertices_to_read--) {
+      std::string line;
+      if (!goto_next_uncomment_line(line)) return false;
+      std::vector<double> point;
+      std::istringstream iss(line);
+      point.assign(std::istream_iterator<double>(iss), std::istream_iterator<double>());
+      // if(point.size() != off_info_.dim) return false;
+      visitor.point(point);
+    }
+    return true;
+  }
+
+  template<typename OffVisitor>
+  bool read_off_faces(OffVisitor& visitor) {
+    std::string line;
+    while (goto_next_uncomment_line(line)) {
+      std::istringstream iss(line);
+      int num_face_vertices;
+      iss >> num_face_vertices;
+      std::vector<int> face;
+      face.assign(std::istream_iterator<int>(iss), std::istream_iterator<int>());
+      // if (face.size() != (off_info_.dim + 1)) return false;
+      visitor.maximal_face(face);
+    }
+    return true;
+  }
+};
+
+template<typename OFFVisitor>
+void read_off(const std::string& name_file_off, OFFVisitor& vis) {
+  std::ifstream stream(name_file_off);
+  if (!stream.is_open()) {
+    std::cerr << "could not open file \n";
+  } else {
+    Off_reader off_reader(stream);
+    off_reader.read(vis);
+  }
+}
+
+}  // namespace Gudhi
+
+#endif  // OFF_READER_H_