Cech_complex.h

/*    This file is part of the Gudhi Library. The Gudhi library
 *    (Geometric Understanding in Higher Dimensions) is a generic C++
 *    library for computational topology.
 *
 *    Author(s):       Vincent Rouvreau
 *
 *    Copyright (C) 2018 Inria
 *
 *    This program is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation, either version 3 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef CECH_COMPLEX_H_
#define CECH_COMPLEX_H_

#include <gudhi/distance_functions.h>        // for Gudhi::Minimal_enclosing_ball_radius
#include <gudhi/graph_simplicial_complex.h>  // for Gudhi::Proximity_graph
#include <gudhi/Debug_utils.h>               // for GUDHI_CHECK
#include <gudhi/Cech_complex_blocker.h>      // for Gudhi::cech_complex::Cech_blocker

#include <iostream>
#include <stdexcept>  // for exception management
#include <vector>

namespace Gudhi {

namespace cech_complex {

template <typename SimplicialComplexForProximityGraph, typename ForwardPointRange>
class Cech_complex {
 private:
  // Required by compute_proximity_graph
  using Vertex_handle = typename SimplicialComplexForProximityGraph::Vertex_handle;
  using Filtration_value = typename SimplicialComplexForProximityGraph::Filtration_value;
  using Proximity_graph = Gudhi::Proximity_graph<SimplicialComplexForProximityGraph>;

  // Retrieve Coordinate type from ForwardPointRange
  using Point_from_range_iterator = typename boost::range_const_iterator<ForwardPointRange>::type;
  using Point_from_range = typename std::iterator_traits<Point_from_range_iterator>::value_type;
  using Coordinate_iterator = typename boost::range_const_iterator<Point_from_range>::type;
  using Coordinate = typename std::iterator_traits<Coordinate_iterator>::value_type;

 public:
  // Point and Point_cloud type definition
  using Point = std::vector<Coordinate>;
  using Point_cloud = std::vector<Point>;

 public:
  Cech_complex(const ForwardPointRange& points, Filtration_value max_radius) : max_radius_(max_radius) {
    // Point cloud deep copy
    point_cloud_.reserve(boost::size(points));
    for (auto&& point : points) point_cloud_.emplace_back(std::begin(point), std::end(point));

    cech_skeleton_graph_ = Gudhi::compute_proximity_graph<SimplicialComplexForProximityGraph>(
        point_cloud_, max_radius_, Gudhi::Minimal_enclosing_ball_radius());
  }

  template <typename SimplicialComplexForCechComplex>
  void create_complex(SimplicialComplexForCechComplex& complex, int dim_max) {
    GUDHI_CHECK(complex.num_vertices() == 0,
                std::invalid_argument("Cech_complex::create_complex - simplicial complex is not empty"));

    // insert the proximity graph in the simplicial complex
    complex.insert_graph(cech_skeleton_graph_);
    // expand the graph until dimension dim_max
    complex.expansion_with_blockers(dim_max,
                                    Cech_blocker<SimplicialComplexForCechComplex, Cech_complex>(&complex, this));
  }

  Filtration_value max_radius() const { return max_radius_; }

  const Point& get_point(Vertex_handle vertex) const { return point_cloud_[vertex]; }

 private:
  Proximity_graph cech_skeleton_graph_;
  Filtration_value max_radius_;
  Point_cloud point_cloud_;
};

}  // namespace cech_complex

}  // namespace Gudhi

#endif  // CECH_COMPLEX_H_