Connectivity.h

Go to the documentation of this file.

/*
**    Mesh Converter
**    Copyright (C) 2008 Damien Rohmer
**
**    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/>.
*/




/*
** Connectivity.h
** 
** Made by damien
** Login   <damien@ortie>
** 
** Started on  Tue May  6 21:17:55 2008 damien
** Last update Tue May  6 21:17:55 2008 damien
*/

#ifndef         CONNECTIVITY_H_
# define        CONNECTIVITY_H_

#include <stdlib.h>
#include <iostream>
#include <cmath>
#include <string>
#include <errno.h>
#include <stdio.h>
#include <int_vector.h>

#include <tinyXml/tinyxml.h>
#include <tinyXml/tinystr.h>

#include <vector>

#include <Point_set.h>
#include <Edge.h>



class Connectivity
{
 public:
  
  //************************************************//
  //************************************************//
  //CONSTRUCTORS
  //************************************************//
  //************************************************//

  Connectivity();
  Connectivity(const Connectivity& );
  ~Connectivity();
  int destroy();





  //************************************************//
  //************************************************//
  //Access/Size
  //************************************************//
  //************************************************//

  int get_index(int k_index) const;
  int& get_index(int k_index);
  int get_index(int k_polygon,int k_index) const;
  int& get_index(int k_polygon,int k_index);
  std::vector <int> get_index_of_polygon(int k_polygon) const;
  const int* get_index() const;


  int size_index() const;
  int polygon_number() const;
  int polygon_size(int k_polygon) const;
  int vertex_number() const;


  int get_index_triangulated(int k_index) const;
  int& get_index_triangulated(int k_index);
  int get_index_triangulated(int k_triangle,int k_index) const;
  int& get_index_triangulated(int k_triangle,int k_index);
  const int* get_index_triangulated() const;
  int get_triangle_number() const;


  int triangulate();

  int find_polygon(const std::vector <int>& polygon) const;



  int get_polygon_access(int k_polygon) const;


  //************************************************//
  //************************************************//
  //Build access
  //************************************************//
  //************************************************//

  int build_size_and_polygon_access();

  int build_triangulated_index();
  int find_max_index();

  int build_all_index();
  








  //************************************************//
  //************************************************//
  //Add/Delete polygon
  //************************************************//
  //************************************************//

  int add_polygon(const std::vector <int>& polygon);
  int add_polygon(int index_0,int index_1,int index_2,int index_3);
  int add_polygon(int index_0,int index_1,int index_2);

  int add_index(int index);

  int set_polygon(int k_polygon,const std::vector <int>& polygon);

  int set_index(int k_polygon,int k_index,int index);

  int delete_polygon(int k_polygon);
  int delete_given_polygon(const std::vector <int> polygon);

  

  int flip_polygon(int k_polygon);
  int flip_polygon();

  //************************************************//
  //************************************************//
  //Edges
  //************************************************//
  //************************************************//

  Edge  get_edge(int k_index) const;
  int set_edge(int k_index,const Edge& e);
  Edge  get_edge(int k_polygon,int k_edge) const;
  int  set_edge(int k_polygon,int k_edge,const Edge& e);
  Edge get_edge_segment(int index_vertex_0,int index_vertex_1) const;

  int edge_number() const;
  

  int build_edges();


  int build_manifold();


  //************************************************//
  //************************************************//
  //One Ring
  //************************************************//
  //************************************************//


  int build_one_ring();

  int_vector get_one_ring(int k_polygon,int k_edge) const;
  int_vector get_one_ring(int k_vertex) const;

  int_vector get_polygon_ring(int k_polygon,int k_edge) const;
  int_vector get_polygon_ring(int k_vertex) const;



  //************************************************//
  //************************************************//
  //INPUT/OUTPUT
  //************************************************//
  //************************************************//


  int load_off_file(const char* filename);
  int load_off_file(const std::string& filename);
  int load_obj_file(const char* filename);
  int load_obj_file(const std::string& filename);


  int load_collada_file(const std::string& filename);

  int load_collada_file(const char* filename);

  int load_collada_file(const std::string& filename,const std::string& name);

  int load_collada_file(const char* filename,const char* name);
  
  int load_g_file(const char* filename);
  int load_g_file(const std::string& filename);
  int write_g_type(const char* filename) const;
  int write_g_type(const std::string& filename) const;



  int write_off_type(const char* filename) const;
  int write_off_type(const std::string& filename) const;
  int write_obj_type(const char* filename) const;
  int write_obj_type(const std::string& filename) const;



  int export_visible_off(const char* filename,const Point_set& set) const;
  int export_visible_off(const std::string& filename,const Point_set& set) const;




  //************************************************//
  //************************************************//
  //OPERATORS
  //************************************************//
  //************************************************//

  int operator()(int k_index) const;
  int operator[](int k_index) const;
  int& operator()(int k_index);
  int& operator[](int k_index);
  int operator()(int k_polygon,int k_index) const;
  int& operator()(int k_polygon,int k_index);

  //affectation operator
  const Connectivity& operator=(const Connectivity&);


  friend Connectivity operator+(const Connectivity&,const Connectivity&);
  friend Connectivity operator+(const Connectivity&,const std::vector<int> &);
  friend Connectivity operator+(const std::vector<int> &,const Connectivity&);
  friend Connectivity operator-(const Connectivity&,const Connectivity&);
  friend Connectivity operator-(const Connectivity&,const std::vector<int>&);
  friend bool operator==(const Connectivity&,const Connectivity&);
  friend bool operator!=(const Connectivity&,const Connectivity&);
  friend ostream& operator << (ostream& flux,const Connectivity& );





 private:



  int find_current_edge_slow(int vertex_index_0,int vertex_index_1);

  std::vector <int> find_all_current_edge_slow(int vertex_index_0,int vertex_index_1);


  int reccursive_connect_manifold_polygons(int current_polygon,std::vector <int>* correct_polygon);



  int load_collada_mesh_connectivity(TiXmlNode* geometry_node,const std::string& filename);

  int load_triangles_connectivity(TiXmlNode* triangles,const std::string& filename);

  int load_polylist_connectivity(TiXmlNode* polylist,const std::string& filename);

  std::vector <int> load_collada_int_entry(TiXmlNode* node);



  std::vector <int> index_polygon;

  /*** could be better using an indirection. Just give the max index
       through all the index*/
  int max_index;

  std::vector <int> size_polygon;

  std::vector <int> polygon_access;

  std::vector <int> triangulated_index;

  std::vector <int_vector> one_ring;

  std::vector <int_vector> polygon_ring;

  std::vector <Edge> edges;
  
  std::vector <int> index_edges;

  std::vector <int_vector> edges_access;

};

#endif      /* !CONNECTIVITY_H_ */