diff options
Diffstat (limited to 'include/gudhi/Skeleton_blocker/iterators')
6 files changed, 0 insertions, 1111 deletions
diff --git a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_blockers_iterators.h b/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_blockers_iterators.h deleted file mode 100644 index 95c5f7ef..00000000 --- a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_blockers_iterators.h +++ /dev/null @@ -1,134 +0,0 @@ -/* 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): David Salinas - * - * Copyright (C) 2014 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 SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_BLOCKERS_ITERATORS_H_ -#define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_BLOCKERS_ITERATORS_H_ - -#include <boost/iterator/iterator_facade.hpp> - -namespace Gudhi { - -namespace skeleton_blocker { - -/** - * @brief Iterator through the blockers of a vertex. - */ -// ReturnType = const Simplex* or Simplex* -// MapIteratorType = BlockerMapConstIterator or BlockerMapIterator - -template<typename MapIteratorType, typename ReturnType> -class Blocker_iterator_internal : public boost::iterator_facade< -Blocker_iterator_internal<MapIteratorType, ReturnType>, -ReturnType, -boost::forward_traversal_tag, -ReturnType -> { - private: - MapIteratorType current_position; - MapIteratorType end_of_map; - - public: - Blocker_iterator_internal() : current_position() { } - - Blocker_iterator_internal(MapIteratorType position, MapIteratorType end_of_map_) : - current_position(position), end_of_map(end_of_map_) { } - - bool equal(const Blocker_iterator_internal& other) const { - return current_position == other.current_position; - } - - void increment() { - goto_next_blocker(); - } - - ReturnType dereference() const { - return (current_position->second); - } - - private: - /** - * Let the current pair be (v,sigma) where v is a vertex and sigma is a blocker. - * If v is not the first vertex of sigma then we already have seen sigma as a blocker - * and we look for the next one. - */ - void goto_next_blocker() { - do { - ++current_position; - } while (!(current_position == end_of_map) && !first_time_blocker_is_seen()); - } - - bool first_time_blocker_is_seen() const { - return current_position->first == current_position->second->first_vertex(); - } -}; - -/** - * @brief Iterator through the blockers of a vertex - */ -// ReturnType = const Simplex* or Simplex* -// MapIteratorType = BlockerMapConstIterator or BlockerMapIterator - -template<typename MapIteratorType, typename ReturnType> -class Blocker_iterator_around_vertex_internal : public boost::iterator_facade< -Blocker_iterator_around_vertex_internal<MapIteratorType, ReturnType>, -ReturnType, -boost::forward_traversal_tag, -ReturnType -> { - private: - MapIteratorType current_position_; - - public: - Blocker_iterator_around_vertex_internal() : current_position_() { } - - Blocker_iterator_around_vertex_internal(MapIteratorType position) : - current_position_(position) { } - - Blocker_iterator_around_vertex_internal& operator=(Blocker_iterator_around_vertex_internal other) { - this->current_position_ = other.current_position_; - return *this; - } - - bool equal(const Blocker_iterator_around_vertex_internal& other) const { - return current_position_ == other.current_position_; - } - - void increment() { - current_position_++; - } - - ReturnType dereference() const { - return (current_position_->second); - } - - MapIteratorType current_position() { - return this->current_position_; - } -}; - -} // namespace skeleton_blocker - -namespace skbl = skeleton_blocker; - -} // namespace Gudhi - -#endif // SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_BLOCKERS_ITERATORS_H_ diff --git a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_edges_iterators.h b/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_edges_iterators.h deleted file mode 100644 index 5c725aae..00000000 --- a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_edges_iterators.h +++ /dev/null @@ -1,147 +0,0 @@ -/* 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): David Salinas - * - * Copyright (C) 2014 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 SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_EDGES_ITERATORS_H_ -#define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_EDGES_ITERATORS_H_ - -#include <boost/iterator/iterator_facade.hpp> -#include <boost/graph/adjacency_list.hpp> - -#include <utility> // for pair<> - -namespace Gudhi { - -namespace skeleton_blocker { - -template<typename SkeletonBlockerComplex> -class Edge_around_vertex_iterator : public boost::iterator_facade <Edge_around_vertex_iterator<SkeletonBlockerComplex> -, typename SkeletonBlockerComplex::Edge_handle const, boost::forward_traversal_tag -, typename SkeletonBlockerComplex::Edge_handle const> { - friend class boost::iterator_core_access; - - typedef SkeletonBlockerComplex Complex; - typedef typename Complex::boost_adjacency_iterator boost_adjacency_iterator; - typedef typename Complex::Vertex_handle Vertex_handle; - typedef typename Complex::Edge_handle Edge_handle; - - private: - const Complex* complex; - Vertex_handle v; - - boost_adjacency_iterator current_; - boost_adjacency_iterator end_; - - public: - Edge_around_vertex_iterator() : complex(NULL) { } - - Edge_around_vertex_iterator(const Complex* complex_, Vertex_handle v_) : - complex(complex_), - v(v_) { - tie(current_, end_) = adjacent_vertices(v.vertex, complex->skeleton); - } - - /** - * returns an iterator to the end - */ - Edge_around_vertex_iterator(const Complex* complex_, Vertex_handle v_, int end) : - complex(complex_), - v(v_) { - tie(current_, end_) = adjacent_vertices(v.vertex, complex->skeleton); - set_end(); - } - - bool equal(const Edge_around_vertex_iterator& other) const { - return (complex == other.complex) && (v == other.v) && (current_ == other.current_) && (end_ == other.end_); - } - - void increment() { - if (current_ != end_) - ++current_; - } - - Edge_handle dereference() const { - return *(*complex)[std::make_pair(v, static_cast<Vertex_handle> (*current_))]; - } - - private: - // remove this ugly hack - void set_end() { - current_ = end_; - } -}; - -/** - *@brief Iterator on the edges of a simplicial complex. - * - */ -template<typename SkeletonBlockerComplex> -class Edge_iterator : public boost::iterator_facade <Edge_iterator<SkeletonBlockerComplex> -, typename SkeletonBlockerComplex::Edge_handle const -, boost::forward_traversal_tag -, typename SkeletonBlockerComplex::Edge_handle const> { - friend class boost::iterator_core_access; - - public: - typedef SkeletonBlockerComplex Complex; - typedef typename Complex::boost_edge_iterator boost_edge_iterator; - typedef typename Complex::Edge_handle Edge_handle; - - const Complex* complex; - std::pair<boost_edge_iterator, boost_edge_iterator> edge_iterator; - - Edge_iterator() : complex(NULL) { } - - Edge_iterator(const SkeletonBlockerComplex* complex_) : - complex(complex_), - edge_iterator(boost::edges(complex_->skeleton)) { } - - /** - * return an iterator to the end - */ - Edge_iterator(const SkeletonBlockerComplex* complex_, int end) : - complex(complex_), - edge_iterator(boost::edges(complex_->skeleton)) { - edge_iterator.first = edge_iterator.second; - } - - bool equal(const Edge_iterator& other) const { - return (complex == other.complex) && (edge_iterator == other.edge_iterator); - } - - void increment() { - if (edge_iterator.first != edge_iterator.second) { - ++(edge_iterator.first); - } - } - - Edge_handle dereference() const { - return (*(edge_iterator.first)); - } -}; - -} // namespace skeleton_blocker - -namespace skbl = skeleton_blocker; - -} // namespace Gudhi - -#endif // SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_EDGES_ITERATORS_H_ diff --git a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_iterators.h b/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_iterators.h deleted file mode 100644 index 8054e64f..00000000 --- a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_iterators.h +++ /dev/null @@ -1,32 +0,0 @@ - /* 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): David Salinas - * - * Copyright (C) 2014 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 SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_ITERATORS_H_ -#define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_ITERATORS_H_ - -#include <gudhi/Skeleton_blocker/iterators/Skeleton_blockers_vertices_iterators.h> -#include <gudhi/Skeleton_blocker/iterators/Skeleton_blockers_edges_iterators.h> -#include <gudhi/Skeleton_blocker/iterators/Skeleton_blockers_blockers_iterators.h> -#include <gudhi/Skeleton_blocker/iterators/Skeleton_blockers_triangles_iterators.h> -#include <gudhi/Skeleton_blocker/iterators/Skeleton_blockers_simplices_iterators.h> - -#endif // SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_ITERATORS_H_ diff --git a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_simplices_iterators.h b/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_simplices_iterators.h deleted file mode 100644 index e2024652..00000000 --- a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_simplices_iterators.h +++ /dev/null @@ -1,402 +0,0 @@ -/* 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): David Salinas - * - * Copyright (C) 2014 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 SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_SIMPLICES_ITERATORS_H_ -#define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_SIMPLICES_ITERATORS_H_ - -#include <gudhi/Skeleton_blocker_link_complex.h> -#include <gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h> -#include <gudhi/Skeleton_blocker/internal/Trie.h> -#include <gudhi/Debug_utils.h> - -#include <boost/iterator/iterator_facade.hpp> - -#include <memory> -#include <list> -#include <iostream> - -namespace Gudhi { - -namespace skeleton_blocker { - -/** - * Link may be Skeleton_blocker_link_complex<SkeletonBlockerComplex> to iterate over all - * simplices around a vertex OR - * Skeleton_blocker_superior_link_complex<SkeletonBlockerComplex> to iterate over all - * superior vertices around a vertex. - * The iteration is done by computing a trie with the link and doing a breadth-first traversal - * of the trie. - */ -template<typename SkeletonBlockerComplex, typename Link> -class Simplex_around_vertex_iterator : -public boost::iterator_facade < Simplex_around_vertex_iterator<SkeletonBlockerComplex, Link> -, typename SkeletonBlockerComplex::Simplex -, boost::forward_traversal_tag -, typename SkeletonBlockerComplex::Simplex -> { - friend class boost::iterator_core_access; - typedef SkeletonBlockerComplex Complex; - typedef typename Complex::Vertex_handle Vertex_handle; - typedef typename Complex::Edge_handle Edge_handle; - typedef typename Complex::Simplex Simplex; - - // Link_vertex_handle == Complex_Vertex_handle but this renaming helps avoiding confusion - typedef typename Link::Vertex_handle Link_vertex_handle; - - typedef typename Gudhi::skeleton_blocker::Trie<Simplex> Trie; - - private: - const Complex* complex; - Vertex_handle v; - std::shared_ptr<Link> link_v; - std::shared_ptr<Trie> trie; - // TODO(DS): use a deque instead - std::list<Trie*> nodes_to_be_seen; - - public: - Simplex_around_vertex_iterator() : complex(0) { } - - Simplex_around_vertex_iterator(const Complex* complex_, Vertex_handle v_) : - complex(complex_), - v(v_), - link_v(new Link(*complex_, v_)), - trie(new Trie(v_)) { - compute_trie_and_nodes_to_be_seen(); - } - - // TODO(DS): avoid useless copy - // TODO(DS): currently just work if copy begin iterator - Simplex_around_vertex_iterator(const Simplex_around_vertex_iterator& other) : - complex(other.complex), - v(other.v), - link_v(other.link_v), - trie(other.trie), - nodes_to_be_seen(other.nodes_to_be_seen) { - if (!other.is_end()) { - } - } - - /** - * returns an iterator to the end - */ - Simplex_around_vertex_iterator(const Complex* complex_, Vertex_handle v_, bool end) : - complex(complex_), - v(v_) { - set_end(); - } - - private: - void compute_trie_and_nodes_to_be_seen() { - // once we go through every simplices passing through v0 - // we remove v0. That way, it prevents from passing a lot of times - // though edges leaving v0. - // another solution would have been to provides an adjacency iterator - // to superior vertices that avoids lower ones. - while (!link_v->empty()) { - auto v0 = *(link_v->vertex_range().begin()); - trie->add_child(build_trie(v0, trie.get())); - link_v->remove_vertex(v0); - } - nodes_to_be_seen.push_back(trie.get()); - } - - Trie* build_trie(Link_vertex_handle link_vh, Trie* parent) { - Trie* res = new Trie(parent_vertex(link_vh), parent); - for (Link_vertex_handle nv : link_v->vertex_range(link_vh)) { - if (link_vh < nv) { - Simplex simplex_node_plus_nv(res->simplex()); - simplex_node_plus_nv.add_vertex(parent_vertex(nv)); - if (complex->contains(simplex_node_plus_nv)) { - res->add_child(build_trie(nv, res)); - } - } - } - return res; - } - - bool is_node_in_complex(Trie* trie) { - return true; - } - - Vertex_handle parent_vertex(Link_vertex_handle link_vh) const { - return complex->convert_handle_from_another_complex(*link_v, link_vh); - } - - public: - friend std::ostream& operator<<(std::ostream& stream, const Simplex_around_vertex_iterator& savi) { - stream << savi.trie << std::endl; - stream << "(" << savi.nodes_to_be_seen.size() << ") nodes to see\n"; - return stream; - } - - bool equal(const Simplex_around_vertex_iterator& other) const { - bool same_complex = (complex == other.complex); - if (!same_complex) - return false; - - if (!(v == other.v)) - return false; - - bool both_empty = nodes_to_be_seen.empty() && other.nodes_to_be_seen.empty(); - if (both_empty) - return true; - - bool both_non_empty = !nodes_to_be_seen.empty() && !other.nodes_to_be_seen.empty(); - - // one is empty the other is not - if (!both_non_empty) return false; - - bool same_node = (**(nodes_to_be_seen.begin()) == **(other.nodes_to_be_seen.begin())); - return same_node; - } - - void increment() { - assert(!is_end()); - Trie* first_node = nodes_to_be_seen.front(); - - nodes_to_be_seen.pop_front(); - - for (auto childs : first_node->childs) { - nodes_to_be_seen.push_back(childs.get()); - } - } - - Simplex dereference() const { - assert(!nodes_to_be_seen.empty()); - Trie* first_node = nodes_to_be_seen.front(); - return first_node->simplex(); - } - - Simplex get_trie_address() const { - assert(!nodes_to_be_seen.empty()); - return nodes_to_be_seen.front(); - } - - private: - void set_end() { - nodes_to_be_seen.clear(); - } - - bool is_end() const { - return nodes_to_be_seen.empty(); - } -}; - -template<typename SkeletonBlockerComplex> -class Simplex_iterator : -public boost::iterator_facade < Simplex_iterator<SkeletonBlockerComplex> -, typename SkeletonBlockerComplex::Simplex -, boost::forward_traversal_tag -, typename SkeletonBlockerComplex::Simplex -> { - typedef Skeleton_blocker_link_superior<SkeletonBlockerComplex> Link; - - friend class boost::iterator_core_access; - - template<class SkBlDS> friend class Skeleton_blocker_complex; - - typedef SkeletonBlockerComplex Complex; - typedef typename Complex::Vertex_handle Vertex_handle; - typedef typename Complex::Edge_handle Edge_handle; - typedef typename Complex::Simplex Simplex; - typedef typename Complex::Complex_vertex_iterator Complex_vertex_iterator; - typedef typename Link::Vertex_handle Link_vertex_handle; - - private: - const Complex* complex_; - Complex_vertex_iterator current_vertex_; - - typedef Simplex_around_vertex_iterator<SkeletonBlockerComplex, Link> SAVI; - SAVI current_simplex_around_current_vertex_; - SAVI simplices_around_current_vertex_end_; - - public: - Simplex_iterator() : complex_(0) { } - - Simplex_iterator(const Complex* complex) : - complex_(complex), - current_vertex_(complex->vertex_range().begin()), - current_simplex_around_current_vertex_(complex, *current_vertex_), - simplices_around_current_vertex_end_(complex, *current_vertex_, true) { - // should not be called if the complex is empty - assert(!complex->empty()); - } - - private: - Simplex_iterator(const Complex* complex, bool end) : - complex_(complex) { - set_end(); - } - - public: - Simplex_iterator(const Simplex_iterator& other) - : - complex_(other.complex_), - current_vertex_(other.current_vertex_), - current_simplex_around_current_vertex_(other.current_simplex_around_current_vertex_), - simplices_around_current_vertex_end_(other.simplices_around_current_vertex_end_) { } - - friend Simplex_iterator make_begin_iterator(const Complex* complex) { - if (complex->empty()) - return make_end_simplex_iterator(complex); - else - return Simplex_iterator(complex); - } - - friend Simplex_iterator make_end_simplex_iterator(const Complex* complex) { - return Simplex_iterator(complex, true); - } - - bool equal(const Simplex_iterator& other) const { - if (complex_ != other.complex_) return false; - if (current_vertex_ != other.current_vertex_) return false; - if (is_end() && other.is_end()) return true; - if (current_simplex_around_current_vertex_ != other.current_simplex_around_current_vertex_) - return false; - return true; - } - - void increment() { - if (current_simplex_around_current_vertex_ != simplices_around_current_vertex_end_) { - current_simplex_around_current_vertex_.increment(); - if (current_simplex_around_current_vertex_ == simplices_around_current_vertex_end_) - goto_next_vertex(); - } else { - goto_next_vertex(); - } - } - - void goto_next_vertex() { - current_vertex_.increment(); - if (!is_end()) { - current_simplex_around_current_vertex_ = SAVI(complex_, *current_vertex_); - simplices_around_current_vertex_end_ = SAVI(complex_, *current_vertex_, true); - } - } - - Simplex dereference() const { - return current_simplex_around_current_vertex_.dereference(); - } - - private: - void set_end() { - current_vertex_ = complex_->vertex_range().end(); - } - - bool is_end() const { - return (current_vertex_ == complex_->vertex_range().end()); - } -}; - -/** - * Iterator through the maximal faces of the coboundary of a simplex. - */ -template<typename SkeletonBlockerComplex, typename Link> -class Simplex_coboundary_iterator : -public boost::iterator_facade < Simplex_coboundary_iterator<SkeletonBlockerComplex, Link> -, typename SkeletonBlockerComplex::Simplex, boost::forward_traversal_tag, typename SkeletonBlockerComplex::Simplex> { - friend class boost::iterator_core_access; - typedef SkeletonBlockerComplex Complex; - typedef typename Complex::Vertex_handle Vertex_handle; - typedef typename Complex::Edge_handle Edge_handle; - typedef typename Complex::Simplex Simplex; - typedef typename Complex::Complex_vertex_iterator Complex_vertex_iterator; - - // Link_vertex_handle == Complex_Vertex_handle but this renaming helps avoiding confusion - typedef typename Link::Vertex_handle Link_vertex_handle; - - private: - const Complex* complex; - const Simplex& sigma; - std::shared_ptr<Link> link; - Complex_vertex_iterator current_vertex; - Complex_vertex_iterator link_vertex_end; - - public: - Simplex_coboundary_iterator() : complex(0) { } - - Simplex_coboundary_iterator(const Complex* complex_, const Simplex& sigma_) : - complex(complex_), - sigma(sigma_), - // need only vertices of the link hence the true flag - link(new Link(*complex_, sigma_, false, true)) { - auto link_vertex_range = link->vertex_range(); - current_vertex = link_vertex_range.begin(); - link_vertex_end = link_vertex_range.end(); - } - - Simplex_coboundary_iterator(const Simplex_coboundary_iterator& other) : - complex(other.complex), - sigma(other.sigma), - link(other.link), - current_vertex(other.current_vertex), - link_vertex_end(other.link_vertex_end) { } - - // returns an iterator to the end - Simplex_coboundary_iterator(const Complex* complex_, const Simplex& sigma_, bool end) : - complex(complex_), - sigma(sigma_) { - // to represent an end iterator without having to build a useless link, we use - // the convection that link is not initialized. - } - - private: - Vertex_handle parent_vertex(Link_vertex_handle link_vh) const { - return complex->convert_handle_from_another_complex(*link, link_vh); - } - - public: - friend std::ostream& operator<<(std::ostream& stream, const Simplex_coboundary_iterator& sci) { - return stream; - } - - // assume that iterator points to the same complex and comes from the same simplex - bool equal(const Simplex_coboundary_iterator& other) const { - assert(complex == other.complex && sigma == other.sigma); - if (is_end()) return other.is_end(); - if (other.is_end()) return is_end(); - return *current_vertex == *(other.current_vertex); - } - - void increment() { - ++current_vertex; - } - - Simplex dereference() const { - Simplex res(sigma); - res.add_vertex(parent_vertex(*current_vertex)); - return res; - } - - private: - bool is_end() const { - return !link || current_vertex == link_vertex_end; - } -}; - -} // namespace skeleton_blocker - -namespace skbl = skeleton_blocker; - -} // namespace Gudhi - -#endif // SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_SIMPLICES_ITERATORS_H_ diff --git a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_triangles_iterators.h b/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_triangles_iterators.h deleted file mode 100644 index a834fe1d..00000000 --- a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_triangles_iterators.h +++ /dev/null @@ -1,226 +0,0 @@ -/* 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): David Salinas - * - * Copyright (C) 2014 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 SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_TRIANGLES_ITERATORS_H_ -#define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_TRIANGLES_ITERATORS_H_ - -#include <boost/iterator/iterator_facade.hpp> -#include <memory> - -namespace Gudhi { - -namespace skeleton_blocker { - -/** - * \brief Iterator over the triangles that are - * adjacent to a vertex of the simplicial complex. - * \remark Will be removed soon -> dont look - */ -template<typename Complex, typename LinkType> -class Triangle_around_vertex_iterator : public boost::iterator_facade -< Triangle_around_vertex_iterator <Complex, LinkType> -, typename Complex::Simplex const -, boost::forward_traversal_tag -, typename Complex::Simplex const> { - friend class boost::iterator_core_access; - template<typename T> friend class Triangle_iterator; - private: - typedef typename LinkType::Vertex_handle Vertex_handle; - typedef typename LinkType::Root_vertex_handle Root_vertex_handle; - typedef typename LinkType::Simplex Simplex; - typedef typename Complex::Complex_edge_iterator Complex_edge_iterator_; - - const Complex* complex_; - Vertex_handle v_; - std::shared_ptr<LinkType> link_; - Complex_edge_iterator_ current_edge_; - bool is_end_; - - public: - Triangle_around_vertex_iterator(const Complex* complex, Vertex_handle v) : - complex_(complex), v_(v), link_(new LinkType(*complex, v_)), - current_edge_(link_->edge_range().begin()), - is_end_(current_edge_ == link_->edge_range().end()) { } - - /** - * @brief ugly hack to get an iterator to the end - */ - Triangle_around_vertex_iterator(const Complex* complex, Vertex_handle v, bool is_end) : - complex_(complex), v_(v), link_(0), is_end_(true) { } - - /** - * @brief ugly hack to get an iterator to the end - */ - Triangle_around_vertex_iterator() : - complex_(0), v_(-1), link_(0), is_end_(true) { } - - Triangle_around_vertex_iterator(const Triangle_around_vertex_iterator& other) { - v_ = other.v_; - complex_ = other.complex_; - is_end_ = other.is_end_; - - if (!is_end_) { - link_ = other.link_; - current_edge_ = other.current_edge_; - } - } - - bool equal(const Triangle_around_vertex_iterator& other) const { - return (complex_ == other.complex_) && ((finished() && other.finished()) || current_edge_ == other.current_edge_); - } - - Simplex dereference() const { - Root_vertex_handle v1 = (*link_)[*current_edge_].first(); - Root_vertex_handle v2 = (*link_)[*current_edge_].second(); - return Simplex(v_, *(complex_->get_address(v1)), *(complex_->get_address(v2))); - } - - void increment() { - ++current_edge_; - } - - private: - bool finished() const { - return is_end_ || (current_edge_ == link_->edge_range().end()); - } -}; - -/** - * \brief Iterator over the triangles of the - * simplicial complex. - * \remark Will be removed soon -> dont look - * - */ -template<typename SkeletonBlockerComplex> -class Triangle_iterator : public boost::iterator_facade< -Triangle_iterator <SkeletonBlockerComplex>, -typename SkeletonBlockerComplex::Simplex const -, boost::forward_traversal_tag -, typename SkeletonBlockerComplex::Simplex const> { - friend class boost::iterator_core_access; - private: - typedef typename SkeletonBlockerComplex::Vertex_handle Vertex_handle; - typedef typename SkeletonBlockerComplex::Root_vertex_handle Root_vertex_handle; - typedef typename SkeletonBlockerComplex::Simplex Simplex; - typedef typename SkeletonBlockerComplex::Superior_triangle_around_vertex_iterator STAVI; - typedef typename SkeletonBlockerComplex::Complex_vertex_iterator Complex_vertex_iterator; - - const SkeletonBlockerComplex* complex_; - Complex_vertex_iterator current_vertex_; - STAVI current_triangle_; - bool is_end_; - - public: - /* - * @remark assume that the complex is non-empty - */ - Triangle_iterator(const SkeletonBlockerComplex* complex) : - complex_(complex), - current_vertex_(complex->vertex_range().begin()), - current_triangle_(complex, *current_vertex_), // this line is problematic is the complex is empty - is_end_(false) { - assert(!complex->empty()); - gotoFirstTriangle(); - } - - private: - // goto to the first triangle or to the end if none - void gotoFirstTriangle() { - if (!is_finished() && current_triangle_.finished()) { - goto_next_vertex(); - } - } - - public: - /** - * @brief ugly hack to get an iterator to the end - * @remark assume that the complex is non-empty - */ - Triangle_iterator(const SkeletonBlockerComplex* complex, bool is_end) : - complex_(complex), - current_vertex_(complex->vertex_range().end()), - current_triangle_(), // xxx this line is problematic is the complex is empty - is_end_(true) { } - - Triangle_iterator& operator=(const Triangle_iterator & other) { - complex_ = other.complex_; - Complex_vertex_iterator current_vertex_; - STAVI current_triangle_; - return *this; - } - - bool equal(const Triangle_iterator& other) const { - bool both_are_finished = is_finished() && other.is_finished(); - bool both_arent_finished = !is_finished() && !other.is_finished(); - // if the two iterators are not finished, they must have the same state - return (complex_ == other.complex_) && (both_are_finished || ((both_arent_finished) && - current_vertex_ == other.current_vertex_ && - current_triangle_ == other.current_triangle_)); - } - - Simplex dereference() const { - return *current_triangle_; - } - - private: - // goto the next vertex that has a triangle pending or the - // end vertex iterator if none exists - void goto_next_vertex() { - // we must have consume all triangles passing through the vertex - assert(current_triangle_.finished()); - // we must not be done - assert(!is_finished()); - - ++current_vertex_; - - if (!is_finished()) { - current_triangle_ = STAVI(complex_, *current_vertex_); - if (current_triangle_.finished()) - goto_next_vertex(); - } - } - - public: - void increment() { - if (!current_triangle_.finished()) { - ++current_triangle_; // problem here - if (current_triangle_.finished()) - goto_next_vertex(); - } else { - assert(!is_finished()); - goto_next_vertex(); - } - } - - private: - bool is_finished() const { - return is_end_ || current_vertex_ == complex_->vertex_range().end(); - } -}; - -} // namespace skeleton_blocker - -namespace skbl = skeleton_blocker; - -} // namespace Gudhi - -#endif // SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_TRIANGLES_ITERATORS_H_ diff --git a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_vertices_iterators.h b/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_vertices_iterators.h deleted file mode 100644 index 3a638ae6..00000000 --- a/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_vertices_iterators.h +++ /dev/null @@ -1,170 +0,0 @@ -/* 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): David Salinas - * - * Copyright (C) 2014 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 SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_VERTICES_ITERATORS_H_ -#define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_VERTICES_ITERATORS_H_ - -#include <boost/iterator/iterator_facade.hpp> - -#include <utility> // for pair<> - -namespace Gudhi { - -namespace skeleton_blocker { - -/** - *@brief Iterator on the vertices of a simplicial complex - *@remark The increment operator go to the next active vertex. - *@remark Incrementation increases Vertex_handle. - */ -template<typename SkeletonBlockerComplex> -class Vertex_iterator : public boost::iterator_facade< Vertex_iterator <SkeletonBlockerComplex> -, typename SkeletonBlockerComplex::Vertex_handle const -, boost::forward_traversal_tag -, typename SkeletonBlockerComplex::Vertex_handle const> { - friend class boost::iterator_core_access; - - typedef typename SkeletonBlockerComplex::boost_vertex_iterator boost_vertex_iterator; - typedef typename SkeletonBlockerComplex::Vertex_handle Vertex_handle; - private: - const SkeletonBlockerComplex* complex; - std::pair<boost_vertex_iterator, boost_vertex_iterator> vertexIterator; - - - public: - Vertex_iterator() : complex(NULL) { } - - Vertex_iterator(const SkeletonBlockerComplex* complex_) : - complex(complex_), - vertexIterator(vertices(complex_->skeleton)) { - if (!finished() && !is_active()) { - goto_next_valid(); - } - } - - /** - * return an iterator to the end. - */ - Vertex_iterator(const SkeletonBlockerComplex* complex_, int end) : - complex(complex_), vertexIterator(vertices(complex_->skeleton)) { - vertexIterator.first = vertexIterator.second; - } - - public: - void increment() { - goto_next_valid(); - } - - Vertex_handle dereference() const { - return (Vertex_handle(*(vertexIterator.first))); - } - - bool equal(const Vertex_iterator& other) const { - return vertexIterator == other.vertexIterator && complex == other.complex; - } - - bool operator<(const Vertex_iterator& other) const { - return dereference() < other.dereference(); - } - - private: - bool finished() const { - return vertexIterator.first == vertexIterator.second; - } - - void goto_next_valid() { - ++vertexIterator.first; - if (!finished() && !is_active()) { - goto_next_valid(); - } - } - - bool is_active() const { - return ((*complex)[Vertex_handle(*vertexIterator.first)]).is_active(); - } -}; - -template<typename SkeletonBlockerComplex> -class Neighbors_vertices_iterator : public boost::iterator_facade < Neighbors_vertices_iterator<SkeletonBlockerComplex> -, typename SkeletonBlockerComplex::Vertex_handle const -, boost::forward_traversal_tag -, typename SkeletonBlockerComplex::Vertex_handle const> { - friend class boost::iterator_core_access; - - typedef SkeletonBlockerComplex Complex; - typedef typename Complex::boost_adjacency_iterator boost_adjacency_iterator; - typedef typename Complex::Vertex_handle Vertex_handle; - typedef typename Complex::Edge_handle Edge_handle; - - private: - const Complex* complex; - Vertex_handle v; - - boost_adjacency_iterator current_; - boost_adjacency_iterator end_; - - public: - Neighbors_vertices_iterator() : complex(NULL) { } - - Neighbors_vertices_iterator(const Complex* complex_, Vertex_handle v_) : - complex(complex_), - v(v_) { - tie(current_, end_) = adjacent_vertices(v.vertex, complex->skeleton); - } - - /** - * returns an iterator to the end - */ - Neighbors_vertices_iterator(const Complex* complex_, Vertex_handle v_, int end) : - complex(complex_), - v(v_) { - tie(current_, end_) = adjacent_vertices(v.vertex, complex->skeleton); - set_end(); - } - - void increment() { - if (current_ != end_) - ++current_; - } - - Vertex_handle dereference() const { - return (Vertex_handle(*current_)); - } - - bool equal(const Neighbors_vertices_iterator& other) const { - return (complex == other.complex) && (v == other.v) && (current_ == other.current_) && (end_ == other.end_); - } - - private: - // TODO(DS): remove this ugly hack - void set_end() { - current_ = end_; - } -}; - -} // namespace skeleton_blocker - -namespace skbl = skeleton_blocker; - -} // namespace Gudhi - -#endif // SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_VERTICES_ITERATORS_H_ |