PersistentAlphaLaplacian.hpp

Go to the documentation of this file.

#ifndef PL_A_H
#define PL_A_H
 
#include "../core/PersistentLaplacian.hpp"
 
 
// #include <gudhi/Simplex_tree.h>
// #include <gudhi/Points_3D_off_io.h>
// #include <boost/variant.hpp>
// #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
// #include <CGAL/Delaunay_triangulation_3.h>
// #include <CGAL/Alpha_shape_3.h>
// #include <CGAL/Alpha_shape_vertex_base_3.h>
// #include <CGAL/Alpha_shape_cell_base_3.h>
// #include <CGAL/iterator.h>
 
// // Alpha_shape_3 templates type definitions
// typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
// typedef CGAL::Alpha_shape_vertex_base_3<Kernel> Vb;
// typedef CGAL::Alpha_shape_cell_base_3<Kernel> Fb;
// typedef CGAL::Triangulation_data_structure_3<Vb, Fb> Tds;
// typedef CGAL::Delaunay_triangulation_3<Kernel, Tds> Triangulation_3;
// typedef CGAL::Alpha_shape_3<Triangulation_3> Alpha_shape_3;
// // From file type definition
// typedef Kernel::Point_3 Point;
// // filtration with alpha values needed type definition
// typedef Alpha_shape_3::FT Alpha_value_type;
// typedef CGAL::Object Object;
// typedef CGAL::Dispatch_output_iterator<
//     CGAL::cpp11::tuple<Object, Alpha_value_type>,
//     CGAL::cpp11::tuple<std::back_insert_iterator<std::vector<Object>>,
//                        std::back_insert_iterator<std::vector<Alpha_value_type>>>>
//     Dispatch;
// typedef Alpha_shape_3::Cell_handle Cell_handle;
// typedef Alpha_shape_3::Facet Facet;
// typedef Alpha_shape_3::Edge Edge;
// typedef std::list<Alpha_shape_3::Vertex_handle> Vertex_list;
// // gudhi type definition
// typedef Gudhi::Simplex_tree<> Simplex_tree;
// typedef Simplex_tree::Vertex_handle Simplex_tree_vertex;
// typedef std::map<Alpha_shape_3::Vertex_handle, Simplex_tree_vertex> Alpha_shape_simplex_tree_map;
// typedef std::pair<Alpha_shape_3::Vertex_handle, Simplex_tree_vertex> Alpha_shape_simplex_tree_pair;
// typedef std::vector<Simplex_tree_vertex> Simplex_tree_vector_vertex;
 
 
 
namespace PersistentLaplacians{
    class PersistentAlphaLaplacian : public PersistentLaplacian {
        public:
            PersistentAlphaLaplacian(const char* filename, int max_dim); // .OFF file 
            PersistentAlphaLaplacian(std::vector<std::tuple<double,double,double>> points, int max_dim); // coordinantes
                                                                                                        // note that public API not using Gudhi type Point_3
                                                                                                        // so caller does not need knowledge of Gudhi
                                                                                                        // TODO: should pass points by reference, but pybind11 has problems
 
        private:
            // void alpha_points(std::vector<Point> &points, int dim_max, std::vector<std::vector<std::tuple<int,int,int>>>& boundaries_triples,std::vector<std::vector<filtration_type>>& filtrations);
            // void alpha_OFF(const char* filename, int dim_max, std::vector<std::vector<std::tuple<int,int,int>>>& boundaries_triples,std::vector<std::vector<filtration_type>>& filtrations);
            // // void boundary_triples_and_filtrations_to_reindexed(std::vector<std::vector<std::tuple<int,int,int>>> &boundaries_triples,
            //                                                 std::vector<std::vector<std::pair<int,filtration_type>>> &filtrations,
            //                                                 std::vector<SparseMatrixInt> &reindexed_boundaries,
            //                                                 std::vector<std::vector<filtration_type>> &filtrations_new);
            // void reindex_boundaries_triple(std::vector<std::vector<std::tuple<index_t,index_t,int>>>& boundaries_triples);
 
    };
}
 
#endif