Connectivity Class Reference

Connectivity of a mesh. More...

#include <Connectivity.h>

Collaboration diagram for Connectivity:

[legend]

List of all members.

Public Member Functions
	Connectivity ()
	classical constructor
	Connectivity (const Connectivity &)
	Copy constructor.
	~Connectivity ()
	classical destructor
int	destroy ()
	Set all size to 0.
int	get_index (int k_index) const
	get index from k_index
int &	get_index (int k_index)
	get index from k_index
int	get_index (int k_polygon, int k_index) const
	get index from k_index of k_polygon
int &	get_index (int k_polygon, int k_index)
	get index from k_index of k_polygon
std::vector< int >	get_index_of_polygon (int k_polygon) const
	get full_index of the given polygon
const int *	get_index () const
	get_pointer
int	size_index () const
	size of the vector
int	polygon_number () const
	number of polygons
int	polygon_size (int k_polygon) const
	get size of the given polygon
int	vertex_number () const
	get number of vertex by taking the max of every vertex index
int	get_index_triangulated (int k_index) const
	get index of the triangulated version
int &	get_index_triangulated (int k_index)
	get index of the triangulated version
int	get_index_triangulated (int k_triangle, int k_index) const
	get index of this triangle in the triangulated version
int &	get_index_triangulated (int k_triangle, int k_index)
	get index of this triangle in the triangulated version
const int *	get_index_triangulated () const
	get pointer of the triangulation
int	get_triangle_number () const
	get number of triangules in the triangulated version
int	triangulate ()
	triangulate the mesh
int	find_polygon (const std::vector< int > &polygon) const
	try to find a given polygon return polygon number or -1 if not found
int	get_polygon_access (int k_polygon) const
	get the polygon access (when polygons are given in the same order )
int	build_size_and_polygon_access ()
	fill the array of polygon size and the direct access polygon
int	build_triangulated_index ()
	build the triangulated version of the index
int	find_max_index ()
	find max_index to estimate the number of vertex
int	build_all_index ()
	build all starting from index_polygon only
int	add_polygon (const std::vector< int > &polygon)
	add a full polygon
int	add_polygon (int index_0, int index_1, int index_2, int index_3)
	add a full quad
int	add_polygon (int index_0, int index_1, int index_2)
	add a full triangle
int	add_index (int index)
	add index of polygon
int	set_polygon (int k_polygon, const std::vector< int > &polygon)
	set polygon number k
int	set_index (int k_polygon, int k_index, int index)
	set index
int	delete_polygon (int k_polygon)
	delete polygon
int	delete_given_polygon (const std::vector< int > polygon)
	delete polygon from a given polygon
int	flip_polygon (int k_polygon)
	Flip a given polygon.
int	flip_polygon ()
	Flip every polygons.
Edge	get_edge (int k_index) const
	direct access to edges number
int	set_edge (int k_index, const Edge &e)
	set edge from edges number
Edge	get_edge (int k_polygon, int k_edge) const
	access to edges from polygon number
int	set_edge (int k_polygon, int k_edge, const Edge &e)
	set edges from polygon number
Edge	get_edge_segment (int index_vertex_0, int index_vertex_1) const
	fast find given edge from the index of the two vertices
int	edge_number () const
	Number of edges.
int	build_edges ()
	build entire edges from polygons
int	build_manifold ()
	build manifold if there is triangle inversion
int	build_one_ring ()
	build one ring on a general mesh (not necessarily 2-manifold)
int_vector	get_one_ring (int k_polygon, int k_edge) const
	get one ring
int_vector	get_one_ring (int k_vertex) const
	get one ring directly from the vertex
int_vector	get_polygon_ring (int k_polygon, int k_edge) const
	get polygon ring (polygon that shares this vertex)
int_vector	get_polygon_ring (int k_vertex) const
	get polygon ring directly form the vertex (polygon that shares this vertex)
int	load_off_file (const char *filename)
	load off connectivity
int	load_off_file (const std::string &filename)
	load off connectivity
int	load_obj_file (const char *filename)
	load obj connectivity
int	load_obj_file (const std::string &filename)
	load obj connectivity
int	load_collada_file (const std::string &filename)
	load the collada connectivity
int	load_collada_file (const char *filename)
	load the collada connectivity
int	load_collada_file (const std::string &filename, const std::string &name)
	load the collada connectivity
int	load_collada_file (const char *filename, const char *name)
	load the collada connectivity
int	load_g_file (const char *filename)
	load g file connectivity
int	load_g_file (const std::string &filename)
	load g file connectivity
int	write_g_type (const char *filename) const
	write g type file connectivity
int	write_g_type (const std::string &filename) const
	write g type file connectivity
int	write_off_type (const char *filename) const
	Add connectivity description in a .off type.
int	write_off_type (const std::string &filename) const
	Add connectivity description in a .off type.
int	write_obj_type (const char *filename) const
	Add connectivity description in a .obj type.
int	write_obj_type (const std::string &filename) const
	Add connectivity description in a .obj type.
int	export_visible_off (const char *filename, const Point_set &set) const
	export into mesh in off file with the given Point_Set
int	export_visible_off (const std::string &filename, const Point_set &set) const
int	operator() (int k_index) const
	direct access to index_polygon
int	operator[] (int k_index) const
	direct access to index_polygon
int &	operator() (int k_index)
	direct access to index_polygon
int &	operator[] (int k_index)
	direct access to index_polygon
int	operator() (int k_polygon, int k_index) const
	access to k_index of polygon n. k_polygon
int &	operator() (int k_polygon, int k_index)
	access to k_index of polygon n. k_polygon
const Connectivity &	operator= (const Connectivity &)
Private Member Functions
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)
	Pass through all the edges to flip the polygon if needed.
int	load_collada_mesh_connectivity (TiXmlNode *geometry_node, const std::string &filename)
	Internal Collada Loader.
int	load_triangles_connectivity (TiXmlNode *triangles, const std::string &filename)
	Internal Collada Loader.
int	load_polylist_connectivity (TiXmlNode *polylist, const std::string &filename)
	Internal Collada Loader.
std::vector< int >	load_collada_int_entry (TiXmlNode *node)
	Internal Collada Loader.
Private Attributes
std::vector< int >	index_polygon
	every index are ordered in only one vector
int	max_index
	max_index estimate the number of vertex that are needed
std::vector< int >	size_polygon
	vertex of polygon size
std::vector< int >	polygon_access
	direct access of polygon n.k
std::vector< int >	triangulated_index
	triangulated version
std::vector< int_vector >	one_ring
	one_ring
std::vector< int_vector >	polygon_ring
	Polygon ring = polygons surrounding a given vertex.
std::vector< Edge >	edges
	Set of Edges of the mesh.
std::vector< int >	index_edges
	Pointer between polygon edges and index in Edge vector.
std::vector< int_vector >	edges_access
	Pointer between [index_0,index_1] and edge index for direct access.
Friends
Connectivity	operator+ (const Connectivity &, const Connectivity &)
	concatenation of two connectivity
Connectivity	operator+ (const Connectivity &, const std::vector< int > &)
	add polygon
Connectivity	operator+ (const std::vector< int > &, const Connectivity &)
	add polygon
Connectivity	operator- (const Connectivity &, const Connectivity &)
	delete a set of polygon
Connectivity	operator- (const Connectivity &, const std::vector< int > &)
	delete polygon
bool	operator== (const Connectivity &, const Connectivity &)
	test equality
bool	operator!= (const Connectivity &, const Connectivity &)
	test equality
ostream &	operator<< (ostream &flux, const Connectivity &)
	Stream output.

---

Detailed Description

Connectivity of a mesh.

Container class for the connectivity

Separate the general connectivity (any polygons), but also store a triangulated version for the openGl draw

Save general polygon in an array with separator=-1 (as in VRML): [k_1,k_2,k_3,k_4,-1,k_5,k_6,k_7,-1,...] also know polygon size: [4,3,...] and a direct access index: [0,5,...]

Also save a triangulated version for fast drawing.

Definition at line 69 of file Connectivity.h.

---

Constructor & Destructor Documentation

Connectivity::Connectivity

(

)

classical constructor

Definition at line 26 of file Connectivity.cpp.

{
}

Connectivity::Connectivity

(

const Connectivity &

c

)

Copy constructor.

Definition at line 30 of file Connectivity.cpp.

References edges, index_polygon, max_index, one_ring, polygon_access, polygon_ring, and size_polygon.

{
  index_polygon  = c.index_polygon;
  size_polygon   = c.size_polygon;
  polygon_access = c.polygon_access;
  edges          = c.edges;
  max_index      = c.max_index;
  one_ring       = c.one_ring;
  polygon_ring   = c.polygon_ring;
}

Connectivity::~Connectivity

(

)

classical destructor

Definition at line 41 of file Connectivity.cpp.

References destroy().

{destroy();}

Here is the call graph for this function:

---

Member Function Documentation

int Connectivity::destroy

(

)

Set all size to 0.

Definition at line 43 of file Connectivity.cpp.

References edges, index_polygon, max_index, one_ring, polygon_access, polygon_ring, and size_polygon.

Referenced by Mesh_object::destroy(), load_g_file(), load_obj_file(), load_off_file(), and ~Connectivity().

{
  index_polygon  . resize(0);
  size_polygon   . resize(0);
  polygon_access . resize(0);
  edges          . resize(0);
  one_ring       . resize(0);
  polygon_ring   . resize(0);
  max_index=-1;

  return 0;
}

Here is the caller graph for this function:

int Connectivity::get_index

(

int

k_index

)

const

get index from k_index

Definition at line 56 of file Connectivity.cpp.

References index_polygon, and size_index().

Referenced by Mesh_object::get_index().

{
  if(k_index<0 || k_index>=size_index())
    {printf("Error in get_index(%d) with size %d in Connectivity\n",k_index,size_index());exit(-1);}
  return index_polygon[k_index];
}

Here is the call graph for this function:

Here is the caller graph for this function:

int & Connectivity::get_index

(

int

k_index

)

get index from k_index

Definition at line 62 of file Connectivity.cpp.

References index_polygon, and size_index().

{
  if(k_index<0 || k_index>=size_index())
    {printf("Error in get_index(%d) with size %d in Connectivity\n",k_index,size_index());exit(-1);}
  return index_polygon[k_index];
}

Here is the call graph for this function:

int Connectivity::get_index	(	int	k_polygon,
		int	k_index
	)			const

get index from k_index of k_polygon

Definition at line 68 of file Connectivity.cpp.

References index_polygon, polygon_access, polygon_number(), and polygon_size().

{
  if(k_polygon<0 || k_polygon>=polygon_number())
    {printf("Error in get_index, k_polygon(%d) is not correct with size %d in Connectivity\n",k_polygon,polygon_number());exit(-1);}
  if(k_index<0 || k_index>=polygon_size(k_polygon))
    {printf("Error in get_index, k_index(%d) is not correct for polygon %d in Connectivity. This polygon has size=%d\n",k_index,k_polygon,polygon_size(k_polygon));exit(-1);}
  return index_polygon[polygon_access[k_polygon]+k_index];
}

Here is the call graph for this function:

int & Connectivity::get_index	(	int	k_polygon,
		int	k_index
	)

get index from k_index of k_polygon

Definition at line 76 of file Connectivity.cpp.

References index_polygon, polygon_access, polygon_number(), and polygon_size().

{
  if(k_polygon<0 || k_polygon>=polygon_number())
    {printf("Error in get_index, k_polygon(%d) is not correct with size %d in Connectivity\n",k_polygon,polygon_number());exit(-1);}
  if(k_index<0 || k_index>=polygon_size(k_polygon))
    {printf("Error in get_index, k_index(%d) is not correct for polygon %d in Connectivity. This polygon has size=%d\n",k_index,k_polygon,polygon_size(k_polygon));exit(-1);}
  return index_polygon[polygon_access[k_polygon]+k_index];
}

Here is the call graph for this function:

std::vector< int > Connectivity::get_index_of_polygon

(

int

k_polygon

)

const

get full_index of the given polygon

Definition at line 84 of file Connectivity.cpp.

References get_index(), polygon_number(), and polygon_size().

Referenced by find_polygon(), flip_polygon(), Mesh_object::get_index_of_polygon(), operator+(), and operator-().

{
  if(k_polygon<0 || k_polygon>=polygon_number())
    {printf("Error in get_index, k_polygon(%d) is not correct with size %d in Connectivity\n",k_polygon,polygon_number());exit(-1);}
  std::vector <int> ind;
  int k_index=0,N_index=polygon_size(k_polygon);
  for(k_index=0;k_index<N_index;k_index++)
    ind.push_back(get_index(k_polygon,k_index));
  return ind;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const int * Connectivity::get_index

(

)

const

get_pointer

Definition at line 94 of file Connectivity.cpp.

References index_polygon.

Referenced by build_edges(), build_one_ring(), build_triangulated_index(), find_max_index(), get_index_of_polygon(), get_one_ring(), get_polygon_ring(), reccursive_connect_manifold_polygons(), write_g_type(), write_obj_type(), and write_off_type().

{return &index_polygon[0];}

int Connectivity::size_index

(

)

const

size of the vector

Definition at line 101 of file Connectivity.cpp.

References index_polygon.

Referenced by build_size_and_polygon_access(), find_max_index(), get_index(), operator()(), operator[](), and Mesh_object::size_index().

{return index_polygon.size();}

Here is the caller graph for this function:

int Connectivity::polygon_number

(

)

const

number of polygons

Definition at line 102 of file Connectivity.cpp.

References size_polygon.

Referenced by build_edges(), build_manifold(), build_one_ring(), build_triangulated_index(), export_visible_off(), find_polygon(), flip_polygon(), get_edge(), get_index(), get_index_of_polygon(), get_polygon_access(), operator()(), operator+(), operator-(), operator<<(), operator==(), Mesh_object::polygon_number(), reccursive_connect_manifold_polygons(), Mesh_object::save_g_file(), Mesh_object::save_obj_file(), Mesh_object::save_off_file(), set_edge(), write_g_type(), write_obj_type(), and write_off_type().

{return size_polygon.size();}

int Connectivity::polygon_size

(

int

k_polygon

)

const

get size of the given polygon

Definition at line 103 of file Connectivity.cpp.

References size_polygon.

Referenced by build_edges(), build_one_ring(), build_triangulated_index(), get_edge(), get_index(), get_index_of_polygon(), operator()(), operator<<(), operator==(), Mesh_object::polygon_size(), reccursive_connect_manifold_polygons(), set_edge(), set_index(), write_g_type(), write_obj_type(), and write_off_type().

{
  if(k_polygon<0 || k_polygon>=int(size_polygon.size()))
    {printf("Error in polygon_size in Connectivity, k_polygon[%d] with size[%d]\n",k_polygon,size_polygon.size());exit(-1);}
  return size_polygon[k_polygon];
}

int Connectivity::vertex_number

(

)

const

get number of vertex by taking the max of every vertex index

Definition at line 1016 of file Connectivity.cpp.

References max_index.

Referenced by build_edges().

{return max_index+1;}

Here is the caller graph for this function:

int Connectivity::get_index_triangulated

(

int

k_index

)

const

get index of the triangulated version

Definition at line 113 of file Connectivity.cpp.

References triangulated_index.

Referenced by Mesh_object::get_index_triangulated().

{
  if(k_index<0 || k_index>=int(triangulated_index.size()))
    {printf("Error in get_index_triangulated in Connectivity, k_index[%d] with size[%d]\n",k_index,triangulated_index.size());exit(-1);}
  return triangulated_index[k_index];
}

Here is the caller graph for this function:

int & Connectivity::get_index_triangulated

(

int

k_index

)

get index of the triangulated version

Definition at line 119 of file Connectivity.cpp.

References triangulated_index.

{
  if(k_index<0 || k_index>=int(triangulated_index.size()))
    {printf("Error in get_index_triangulated in Connectivity, k_index[%d] with size[%d]\n",k_index,triangulated_index.size());exit(-1);}
  return triangulated_index[k_index];
}

int Connectivity::get_index_triangulated	(	int	k_triangle,
		int	k_index
	)			const

get index of this triangle in the triangulated version

Definition at line 125 of file Connectivity.cpp.

References triangulated_index.

{
  if(k_triangle<0 || 3*k_triangle+2>=int(triangulated_index.size()))
    {printf("Error in get_index_triangulated in Connectivity, k_triangle[%d] with size[%d]\n",k_triangle,k_index);exit(-1);}
  if(k_index<0 || k_index>=3)
    {printf("Error in get_index_triangulated in Connectivity, k_index[%d] should be between 0 and 2\n",k_index);exit(-1);}
  return triangulated_index[3*k_triangle+k_index];
}

int & Connectivity::get_index_triangulated	(	int	k_triangle,
		int	k_index
	)

get index of this triangle in the triangulated version

Definition at line 133 of file Connectivity.cpp.

References triangulated_index.

{
 if(k_triangle<0 || 3*k_triangle+2>=int(triangulated_index.size()))
    {printf("Error in get_index_triangulated in Connectivity, k_triangle[%d] with size[%d]\n",k_triangle,k_index);exit(-1);}
  if(k_index<0 || k_index>=3)
    {printf("Error in get_index_triangulated in Connectivity, k_index[%d] should be between 0 and 2\n",k_index);exit(-1);}
  return triangulated_index[3*k_triangle+k_index];
}

const int * Connectivity::get_index_triangulated

(

)

const

get pointer of the triangulation

Definition at line 141 of file Connectivity.cpp.

References triangulated_index.

{return &triangulated_index[0];}

int Connectivity::get_triangle_number

(

)

const

get number of triangules in the triangulated version

Definition at line 143 of file Connectivity.cpp.

References triangulated_index.

Referenced by Mesh_object::get_triangle_number().

{
  if(triangulated_index.size()%3!=0)
    {printf("Error size of triangulated_index [%d] is not multiple of 3\n",triangulated_index.size());exit(-1);}
  return triangulated_index.size()/3;
}

Here is the caller graph for this function:

int Connectivity::triangulate

(

)

triangulate the mesh

Suppose that the triangulated part is computed

Definition at line 1450 of file Connectivity.cpp.

References add_polygon(), build_all_index(), index_polygon, and triangulated_index.

Referenced by Mesh_object::triangulate().

{
  if(triangulated_index.size()%3!=0)
    {printf("Error in triangulate() in Connectivity, size of triangulated_index is not multiple of 3 (%d)\n",triangulated_index.size());exit(-1);}

  int k_vertex=0,N_vertex=triangulated_index.size()/3;
  index_polygon.resize(0);
  for(k_vertex=0;k_vertex<N_vertex;k_vertex++)
    add_polygon(triangulated_index[3*k_vertex+0],triangulated_index[3*k_vertex+1],triangulated_index[3*k_vertex+2]);
  return build_all_index();
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Connectivity::find_polygon

(

const std::vector< int > &

polygon

)

const

try to find a given polygon return polygon number or -1 if not found

Definition at line 599 of file Connectivity.cpp.

References get_index_of_polygon(), and polygon_number().

Referenced by delete_given_polygon(), and Mesh_object::find_polygon().

{
  int N_poly=polygon.size();
  
  //test if the given polygon is correct
  std::vector <int> sorted_poly=polygon;
  std::sort(sorted_poly.begin(),sorted_poly.end());
  for(int k=0;k<N_poly-1;k++)
    if(sorted_poly[k]==sorted_poly[k+1])
      {printf("Error polygon given in find_polygon in Connectivity is not correct, two index are the same=degenerated polygon [%d]\n",sorted_poly[k]);exit(-1);}
  
  int N_polygon=polygon_number();
  std::vector <int> compared_polygon;
  int k_polygon=0;
  int count=0,k_poly=0,k_to_compare=0;

  //loop on every polygon of the mesh
  for(k_polygon=0;k_polygon<N_polygon;k_polygon++)
    {
      //get polygon to compare
      compared_polygon=get_index_of_polygon(k_polygon);


      count=0;
      //test if size are equal
      if(N_poly==int(compared_polygon.size()))
        {
          //test for every index of the given polygon
          for(k_poly=0;k_poly<N_poly;k_poly++)
            //test for every index of the current compared polygon
            for(k_to_compare=0;k_to_compare<int(compared_polygon.size());k_to_compare++)
              //if one index is the same
              if(polygon[k_poly]==compared_polygon[k_to_compare])
                count++;
        }
      if(count==N_poly)//find the polygon
        return k_polygon;
    }
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Connectivity::get_polygon_access

(

int

k_polygon

)

const

get the polygon access (when polygons are given in the same order )

index0,index1,index2,-1,index3,index4,...

Definition at line 1752 of file Connectivity.cpp.

References polygon_access, and polygon_number().

Referenced by Mesh_object::get_polygon_access().

{
  if(k_polygon<0 || k_polygon>polygon_number())
    {printf("Error in Connectivity in get_polygon_access(%d), polygon_number()=%d\n",k_polygon,polygon_number());exit(-1);}
  return polygon_access[k_polygon];
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Connectivity::build_size_and_polygon_access

(

)

fill the array of polygon size and the direct access polygon

Definition at line 153 of file Connectivity.cpp.

References index_polygon, polygon_access, size_index(), and size_polygon.

Referenced by build_all_index().

{
  int k_index=0,N_index=size_index();
  int current_size=0,k_polygon=0;

  size_polygon.resize(0);
  polygon_access.resize(0);

  //the first polygon start at index 0
  polygon_access.push_back(0);
  for(k_index=0;k_index<N_index;k_index++)
    {
      if(index_polygon[k_index]==-1)
        {
          if(current_size<2)
            {printf("Error in build_size_and_polygon_access in Connectivity, polygon_size[%d] is less than 2 at index[%d]\n",current_size,k_index);exit(-1);}
          size_polygon.push_back(current_size);
          current_size=0;
          k_polygon++;
        }
      else
        current_size++;
      if(k_index>0 && index_polygon[k_index-1]==-1)
        polygon_access.push_back(k_index);

    }
  if(index_polygon[N_index-1]!=-1)
    {printf("Error index_polygon of size(%d) does not end with -1 [%d]\n",index_polygon.size(),index_polygon[N_index-1]);exit(-1);}
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Connectivity::build_triangulated_index

(

)

build the triangulated version of the index

Perform a triangle strip build for each polygon

Definition at line 184 of file Connectivity.cpp.

References get_index(), polygon_number(), polygon_size(), and triangulated_index.

Referenced by build_all_index().

{
  triangulated_index.resize(0);
  int k_index=0,N_index;
  int k_polygon=0,N_polygon=polygon_number();

  int index0,index1,index2;
  for(k_polygon=0;k_polygon<N_polygon;k_polygon++)
    {
      N_index=polygon_size(k_polygon);
      index0=get_index(k_polygon,0);
      index1=get_index(k_polygon,1);
      for(k_index=2;k_index<N_index;k_index++)
        {
          index2=get_index(k_polygon,k_index);
          
          //add the current triangle
          triangulated_index.push_back(index0);
          triangulated_index.push_back(index1);
          triangulated_index.push_back(index2);

          //reorganize the current triangle
          //do triangle strip
          index1=index2;
        }
      
    }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Connectivity::find_max_index

(

)

find max_index to estimate the number of vertex

Definition at line 214 of file Connectivity.cpp.

References get_index(), max_index, and size_index().

Referenced by build_all_index().

{
  max_index=-2;
  int k_index=0,N_index=size_index();
  for(k_index=0;k_index<N_index;k_index++)
    if(max_index<get_index(k_index))
      max_index=get_index(k_index);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Connectivity::build_all_index

(

)

build all starting from index_polygon only

actually call build_size_and_polygon_access() and build_triangulated_index() functions

Definition at line 224 of file Connectivity.cpp.

References build_one_ring(), build_size_and_polygon_access(), build_triangulated_index(), and find_max_index().

Referenced by Mesh_object::build_connectivity_index(), delete_polygon(), load_collada_file(), load_g_file(), load_obj_file(), load_off_file(), operator+(), set_polygon(), and triangulate().

{
  int ok=0;
  ok += build_size_and_polygon_access();
  ok += build_triangulated_index();
  ok += find_max_index();
  ok += build_one_ring();
  return ok;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Connectivity::add_polygon

(

const std::vector< int > &

polygon

)

add a full polygon

Definition at line 252 of file Connectivity.cpp.

References index_polygon.

Referenced by Mesh_object::add_polygon(), add_polygon(), load_g_file(), load_obj_file(), load_off_file(), load_polylist_connectivity(), load_triangles_connectivity(), operator+(), and triangulate().

{
  int current_size=polygon.size();
  if(current_size<3)
    {printf("Error polygon size [%d] in add_polygon<3\n",current_size);exit(-1);}


  //test if the given polygon is correct
  int N_poly=polygon.size();
  std::vector <int> sorted_poly=polygon;
  std::sort(sorted_poly.begin(),sorted_poly.end());
  for(int k=0;k<N_poly-1;k++)
    if(sorted_poly[k]==sorted_poly[k+1])
      {printf("Error polygon given in add_polygon in Connectivity is not correct, two index are the same=degenerated polygon [%d]\n",sorted_poly[k]);}




  int k=0;
  for(k=0;k<current_size;k++)
    index_polygon.push_back(polygon[k]);

  //add the final -1
  index_polygon.push_back(-1);
  
  return 0;
}

Here is the caller graph for this function:

int Connectivity::add_polygon	(	int	index_0,
		int	index_1,
		int	index_2,
		int	index_3
	)

add a full quad

Definition at line 243 of file Connectivity.cpp.

References add_polygon().

{
  std::vector <int> polygon;
  polygon.push_back(index_0);
  polygon.push_back(index_1);
  polygon.push_back(index_2);
  polygon.push_back(index_3);
  return add_polygon(polygon);
}

Here is the call graph for this function:

int Connectivity::add_polygon	(	int	index_0,
		int	index_1,
		int	index_2
	)

add a full triangle

Definition at line 235 of file Connectivity.cpp.

References add_polygon().

{
  std::vector <int> polygon;
  polygon.push_back(index_0);
  polygon.push_back(index_1);
  polygon.push_back(index_2);
  return add_polygon(polygon);
}

Here is the call graph for this function:

int Connectivity::add_index

(

int

index

)

add index of polygon

does not ensure that the polygon end by -1 (should be manually included)

Definition at line 280 of file Connectivity.cpp.

References index_polygon.

Referenced by Mesh_object::add_index().

{
  index_polygon.push_back(index);
  return 0;
}

Here is the caller graph for this function:

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

set polygon number k

slow, needs the re-calculation of the index Also assume that the access is already set-up

Definition at line 286 of file Connectivity.cpp.

References build_all_index(), index_polygon, and polygon_access.

Referenced by Mesh_object::set_polygon().

{

  if(k_polygon<0 || k_polygon>=int(polygon_access.size()))
    {printf("Error k_polygon[%d] is not correct in set_polygon in Connectivity (number of polygon: %d)\n",k_polygon,polygon_access.size());exit(-1);}


  std::vector <int> index_polygon_2;
  int k_access0=0;k_access0=polygon_access[k_polygon];
  int k_access1=-1;if(k_polygon<int(polygon_access.size())-1){k_access1=polygon_access[k_polygon+1];}
  int k_index=0;

  //copy of the first part of the polygon
  for(k_index=0;k_index<k_access0;k_index++)
    index_polygon_2.push_back(index_polygon[k_index]);

  //then replace the polygon
  int N_polygon=0;N_polygon=polygon.size();
  if(N_polygon<3){printf("Error polygon size [%d] is <3 in set_polygon(%d) in Connectivity\n",N_polygon,k_polygon);exit(-1);}
  for(k_index=0;k_index<N_polygon;k_index++)
    index_polygon_2.push_back(polygon[k_index]);
  //add the final -1
  index_polygon_2.push_back(-1);

  //finally add the other one
  if(k_access1!=-1)
    {
      for(k_index=k_access1;k_index<int(index_polygon.size());k_index++)
        index_polygon_2.push_back(index_polygon[k_index]);
    }

  //then copy
  index_polygon=index_polygon_2;

  //recalculate everything
  build_all_index();

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Connectivity::set_index	(	int	k_polygon,
		int	k_index,
		int	index
	)

set index

should not be use, direct access to the index, does not ensure its correct with size

Definition at line 327 of file Connectivity.cpp.

References index_polygon, polygon_access, and polygon_size().

Referenced by Mesh_object::set_index().

{

  if(k_polygon<0 || k_polygon>=int(polygon_access.size()))
    {printf("Error k_polygon[%d] is not correct in set_index in Connectivity (number of polygon: %d)\n",k_polygon,polygon_access.size());exit(-1);}

  if(k_index<0 || k_index>=polygon_size(k_polygon))
    {printf("Error k_index[%d] is not correct with size[%d] of polygon[%d]\n",k_index,polygon_size(k_polygon),k_polygon);exit(-1);}

  int current_index=polygon_access[k_polygon]+k_index;
  index_polygon[current_index]=index;
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Connectivity::delete_polygon

(

int

k_polygon

)

delete polygon

assume that all the index are already calculated. Slow, will recalculate everything at each time

Definition at line 342 of file Connectivity.cpp.

References build_all_index(), index_polygon, and polygon_access.

Referenced by delete_given_polygon(), and Mesh_object::delete_polygon().

{
  if(k_polygon<0 || k_polygon>=int(polygon_access.size()))
    {printf("Error k_polygon[%d] is not correct in set_index in Connectivity (number of polygon: %d)\n",k_polygon,polygon_access.size());exit(-1);}

  int k_access0=polygon_access[k_polygon];
  int k_access1=-1;if(k_polygon<int(polygon_access.size())-1){k_access1=polygon_access[k_polygon+1];}
  int k_index=0;

  //copy until reach the polygon
  std::vector <int> index_polygon_2;
  for(k_index=0;k_index<k_access0;k_index++)
    index_polygon_2.push_back(index_polygon[k_index]);
  
  //copy the last part
  if(k_access1!=-1)
    {
      for(k_index=k_access1;k_index<int(index_polygon.size());k_index++)
        index_polygon_2.push_back(index_polygon[k_index]);
    }
  
  //copy
  index_polygon=index_polygon_2;

  //rebuild_index
  build_all_index();

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Connectivity::delete_given_polygon

(

const std::vector< int >

polygon

)

delete polygon from a given polygon

Definition at line 372 of file Connectivity.cpp.

References delete_polygon(), and find_polygon().

Referenced by Mesh_object::delete_given_polygon(), and operator-().

{
  int k_poly_to_delete=find_polygon(polygon);
  if(k_poly_to_delete!=-1)
    return delete_polygon(k_poly_to_delete);

  //did not find the polygon
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Connectivity::flip_polygon

(

int

k_polygon

)

Flip a given polygon.

Inverse the sens of the polygon

Definition at line 1309 of file Connectivity.cpp.

References get_index_of_polygon(), index_polygon, polygon_access, polygon_number(), and size_polygon.

Referenced by Mesh_object::flip_polygon().

{

  if(k_polygon<0 || k_polygon>=polygon_number())
    {printf("Error in flip_polygon(%d), N_polygon=%d\n",k_polygon,polygon_number());exit(-1);}
  
  int index=polygon_access[k_polygon];
  int size_current_polygon=size_polygon[k_polygon];
  const std::vector <int> current_polygon=get_index_of_polygon(k_polygon);
  if(int(current_polygon.size())!=size_current_polygon)
    {printf("Error in flip_polygon, size are not correct\n");exit(-1);}

  index_polygon[index]=current_polygon[0];
  int k_size_polygon=0;

  for(k_size_polygon=1;k_size_polygon<size_current_polygon;k_size_polygon++)
    index_polygon[index+k_size_polygon]=current_polygon[size_current_polygon-k_size_polygon];//in the other direction


  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Connectivity::flip_polygon

(

)

Flip every polygons.

Definition at line 1331 of file Connectivity.cpp.

References polygon_number().

Referenced by reccursive_connect_manifold_polygons().

{
  int k=0;
  for(k=0;k<polygon_number();k++)
    flip_polygon(k);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Edge Connectivity::get_edge

(

int

k_index

)

const

direct access to edges number

Definition at line 762 of file Connectivity.cpp.

References edges.

Referenced by build_edges(), find_all_current_edge_slow(), find_current_edge_slow(), and get_edge_segment().

{
  if(k_index<0 || k_index>=int(edges.size()))
    {printf("Error in get_edge[%d] in Connectivity, size=[%d]\n",k_index,edges.size());exit(-1);}
  return edges[k_index];
}

Here is the caller graph for this function:

int Connectivity::set_edge	(	int	k_index,
		const Edge &	e
	)

set edge from edges number

Definition at line 1019 of file Connectivity.cpp.

References edges.

Referenced by build_edges().

{
  if(k_index<0 || k_index>=int(edges.size()))
    {printf("Error in set_edge[%d] in Connectivity, size=[%d]\n",k_index,edges.size());exit(-1);}
  edges[k_index]=e;
  return 0;
}

Here is the caller graph for this function:

Edge Connectivity::get_edge	(	int	k_polygon,
		int	k_edge
	)			const

access to edges from polygon number

Definition at line 769 of file Connectivity.cpp.

References edges, index_edges, polygon_access, polygon_number(), and polygon_size().

{

  if(k_polygon<0 || k_polygon>=polygon_number())
    {printf("Error get_edges[%d,%d] in Connectivity, polygon_number=[%d]\n",k_polygon,k_edge,polygon_number());exit(-1);}
  if(k_edge<0 || k_edge>=polygon_size(k_polygon))
    {printf("Error get_edges[%d,%d] in Connectivity, polygon_size(%d)=%d\n",k_polygon,k_edge,polygon_number(),polygon_size(k_polygon));exit(-1);}
  
  int k_access = polygon_access[k_polygon];
  if(k_access<0 || k_access+k_edge>=int(index_edges.size()))
    {printf("k_access+k_edge %d+%d is not correct in get_edges(%d,%d) in Connectivity, index_edges.size()=%d, might not be initialized\n",k_access,k_edge,k_polygon,k_edge,index_edges.size());exit(-1);}
  

  int k_index_edge = index_edges[k_access+k_edge];
  if(k_index_edge<0 || k_index_edge>=int(edges.size()))
    {printf("index_edge[%d]=%d is not correct with edges.size()=%d in get_edges(%d,%d) in Connectivity \n",k_access,k_index_edge,edges.size(),k_polygon,k_edge);exit(-1);}



  //return edges[index_edges[polygon_access[k_polygon]+k_edge]];
  return edges[k_index_edge];

}

Here is the call graph for this function:

int Connectivity::set_edge	(	int	k_polygon,
		int	k_edge,
		const Edge &	e
	)

set edges from polygon number

Definition at line 1027 of file Connectivity.cpp.

References edges, index_edges, polygon_access, polygon_number(), and polygon_size().

{
  if(k_polygon<0 || k_polygon>=polygon_number())
    {printf("Error set_edges[%d,%d] in Connectivity, polygon_number=[%d]\n",k_polygon,k_edge,polygon_number());exit(-1);}
  if(k_edge<0 || k_edge>=polygon_size(k_polygon))
    {printf("Error set_edges[%d,%d] in Connectivity, polygon_size(%d)=%d\n",k_polygon,k_edge,polygon_number(),polygon_size(k_polygon));exit(-1);}
  
  int k_access = polygon_access[k_polygon];
  if(k_access<0 || k_access+k_edge>=int(index_edges.size()))
    {printf("k_access+k_edge %d+%d is not correct in set_edges(%d,%d) in Connectivity, index_edges.size()=%d, might not be initialized\n",k_access,k_edge,k_polygon,k_edge,index_edges.size());exit(-1);}
  
  int k_index_edge = index_edges[k_access+k_edge];
  if(k_index_edge<0 || k_index_edge>=int(edges.size()))
    {printf("index_edge[%d]=%d is not correct with edges.size()=%d in set_edges(%d,%d) in Connectivity \n",k_access,k_index_edge,edges.size(),k_polygon,k_edge);exit(-1);}

  //edges[index_edges[polygon_access[k_polygon]+k_edge]];
  edges[k_index_edge]=e;
  return 0;
}

Here is the call graph for this function:

Edge Connectivity::get_edge_segment	(	int	index_vertex_0,
		int	index_vertex_1
	)			const

fast find given edge from the index of the two vertices

Definition at line 975 of file Connectivity.cpp.

References edges_access, get_edge(), Edge::get_index_0(), and Edge::get_index_1().

Referenced by write_g_type().

{
  int N_vertex=edges_access.size();
  if(index_vertex_0<0 || index_vertex_0>=N_vertex || index_vertex_1<0 || index_vertex_1>=N_vertex)
    {printf("Error in get_edge_segment(%d,%d) in Connectivity edges_access.size()=%d\n",index_vertex_0,index_vertex_1,N_vertex);exit(-1);}
  
  int N_one_ring = edges_access[index_vertex_0].size();
  int k_one_ring=0;



  //look for index_vertex_2 in the one ring of the index_vertex_0
  Edge e;
  for(k_one_ring=0;k_one_ring<N_one_ring;k_one_ring++)
    {
      e = get_edge(edges_access[index_vertex_0][k_one_ring]);

      //edge is in the right order
      if(e.get_index_1()==index_vertex_1)
        {
          if(e.get_index_0()!=index_vertex_0){printf("Error in edge access in get_edge_segment in Connectivity\n");exit(-1);}
          return e;
        }

      //edge is in the opposite order
      else if(e.get_index_0()==index_vertex_1)
        {
          if(e.get_index_1()!=index_vertex_0){printf("Error in edge access in get_edge_segment in Connectivity\n");exit(-1);}
          return e;
        }
      
    }
  
  //if not found
  Edge o;
  return o;
    
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Connectivity::edge_number

(

)

const

Number of edges.

Definition at line 1014 of file Connectivity.cpp.

References edges.

Referenced by build_edges(), Mesh_object::save_obj_file(), and Mesh_object::save_off_file().

{return edges.size();}

Here is the caller graph for this function:

int Connectivity::build_edges

(

)

build entire edges from polygons

Works on 2-manifold

Definition at line 794 of file Connectivity.cpp.

References edge_number(), edges, edges_access, find_current_edge_slow(), get_edge(), get_index(), Edge::get_index_0(), Edge::get_index_1(), index_edges, polygon_number(), polygon_size(), set_edge(), Edge::set_face_0(), Edge::set_index(), Edge::set_next_edge(), Edge::set_previous_edge(), and vertex_number().

Referenced by Mesh_object::build_edges(), and build_manifold().

{

  //destroy edges;
  edges        . resize(0);
  index_edges  . resize(0);
  edges_access . resize(0);

  int k_polygon=0;
  int N_polygon=polygon_number();
  int k_vertex=0;
  int N_vertex=0;

  int edge_index=0;

  int ind[2];

  //******************************//
  //Fill the vertex index of the edges
  //******************************//
  for(k_polygon=0;k_polygon<N_polygon;k_polygon++)
    {
      N_vertex=polygon_size(k_polygon);
      for(k_vertex=0;k_vertex<N_vertex;k_vertex++)
        {


          //get index line
          ind[0]=get_index(k_polygon,k_vertex);
          ind[1]=get_index(k_polygon,(k_vertex+1)%N_vertex);

          

          //try to find if [ind[1]-ind[2]] has already been declared
          if(find_current_edge_slow(ind[0],ind[1])!=-1)//not a manifold mesh
            {printf("Warning, edge [%d,%d] is duplicated, not a manifold mesh\n",ind[0],ind[1]);return -1;}

          //****************//    
          //add the edge
          //****************//
          
          //add the index_edges pointer
          index_edges.push_back(edges.size());
          
          //set the vertex index and the first face
          Edge e;
          e.set_index(ind[0],ind[1]);
          e.set_face_0(k_polygon);
          edges.push_back(e);

          edge_index = find_current_edge_slow(ind[1],ind[0]);
          if(edge_index!=-1)//the first face is already set-up
            {
              if(edge_index<0 || edge_index>=int(edges.size()))
                {printf("Error in build index, something wrong in polygon %d\n",k_polygon);exit(-1);}

              //set the opposite face
              edges[edge_index]     . set_face_1(k_polygon);
              edges[edges.size()-1] . set_face_1(edges[edge_index].get_face_0());

              //set the half edge
              edges[edges.size()-1].set_half_edge(edge_index);
              edges[edge_index].set_half_edge(edges.size()-1);
            }


        }
      //add separator in index_edges
      index_edges.push_back(-1);
    }


  //******************************//
  // now set the edges link
  //******************************//
  int ind_next[2]={0,0};
  int ind_previous[2]={0,0};
  Edge current_e;
  int index_next_e=0,index_previous_e=0;
  for(k_polygon=0;k_polygon<N_polygon;k_polygon++)
    {
      N_vertex=polygon_size(k_polygon);
      for(k_vertex=0;k_vertex<N_vertex;k_vertex++)
        {

          //current index
          ind[0] = get_index(k_polygon,k_vertex);
          ind[1] = get_index(k_polygon,(k_vertex+1)%N_vertex);

          //next index
          ind_next[0] = get_index(k_polygon,(k_vertex+1)%N_vertex);
          ind_next[1] = get_index(k_polygon,(k_vertex+2)%N_vertex);

          //previous index
          ind_previous[0] = get_index(k_polygon,(k_vertex-1<0?N_vertex-1:k_vertex-1));
          ind_previous[1] = get_index(k_polygon,k_vertex);

          //current edge
          current_e  = get_edge(k_polygon,k_vertex);
          //get and set next and previous edges
          index_next_e     = find_current_edge_slow(ind_next[0],ind_next[1]);
          index_previous_e = find_current_edge_slow(ind_previous[0],ind_previous[1]);


          if(index_next_e==-1 || index_previous_e==-1){printf("Error in build_edge part 2, index are = -1\n");exit(-1);}
          if(index_next_e==-1 || index_previous_e==-1){printf("Error in build_edge part 2\n");exit(-1);}




          current_e.set_next_edge(index_next_e);
          current_e.set_previous_edge(index_previous_e);
          set_edge(k_polygon,k_vertex,current_e);

          //printf("(%d,%d)->%d,(%d,%d)->%d,(%d,%d)->%d (h%d)\n",ind[0],ind[1],index_edges[polygon_access[k_polygon]+k_vertex],ind_previous[0],ind_previous[1],index_previous_e,ind_next[0],ind_next[1],index_next_e,current_e.get_half_edge());
          //cout<<current_e<<endl;

        }
    }
  


  //******************************//
  // now build direct access to edges
  //******************************//

  N_vertex=vertex_number();
  edges_access.resize(N_vertex);
  int k_edge=0,N_edge=edge_number();
  Edge e;
  for(k_edge=0;k_edge<N_edge;k_edge++)
    {
      e = get_edge(k_edge);
      if(e.get_index_0()<0 || e.get_index_0()>=N_vertex || e.get_index_1()<0|| e.get_index_1()>=N_vertex)
        {printf("Error in build direct access in build_edge()\n");}
      edges_access[e.get_index_0()].add(k_edge);
    }



  return 0;
}

Here is the caller graph for this function:

int Connectivity::build_manifold

(

)

build manifold if there is triangle inversion

Only works if there is repeted index between two triangles (not in the correct turning sense

Definition at line 1121 of file Connectivity.cpp.

References build_edges(), polygon_number(), and reccursive_connect_manifold_polygons().

Referenced by Mesh_object::build_manifold().

{

  int N_polygon=polygon_number();
  std::vector <int> correct_polygon(N_polygon);

  int end_loop=0;
  int k=0;
  int first_polygon_not_correct=0;

  //redo the entire loop in the case where there is connected parts
  do
    {

      //find the find index not correct (should be runed as much as there is non-connected parts
      first_polygon_not_correct=-1;
      k=0;
      do
        {
          if(correct_polygon[k]==0)
            first_polygon_not_correct=k;
          k++;
        }while((k<N_polygon) && (correct_polygon[k-1]==1));

      if(first_polygon_not_correct!=-1)
        {
          //suppose this first_polygon is true and go ahead
          correct_polygon[first_polygon_not_correct]=1;
          reccursive_connect_manifold_polygons(first_polygon_not_correct,&correct_polygon);
        }

      //every polygons have been passed
      else if((first_polygon_not_correct==-1) && (k==N_polygon))
        end_loop=1;
    }while(end_loop==0);



  build_edges();
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Connectivity::build_one_ring

(

)

build one ring on a general mesh (not necessarily 2-manifold)

Also build the polygon ring

Definition at line 1048 of file Connectivity.cpp.

References get_index(), max_index, one_ring, polygon_number(), polygon_ring, and polygon_size().

Referenced by build_all_index().

{

  int k_polygon=0,k_vertex=0,N_vertex=0;
  int k_index=0,k_index_2=0;
  int N_polygon=0;

  if(max_index<=0)
    {printf("Error in build_one_ring, max_index=0\n");exit(-1);}

  one_ring.resize(max_index+1);
  polygon_ring.resize(max_index+1);


  //loop over every vertices
  N_polygon=polygon_number();
  for(k_polygon=0;k_polygon<N_polygon;k_polygon++)
    {
      N_vertex=polygon_size(k_polygon);
      for(k_vertex=0;k_vertex<N_vertex;k_vertex++)
        {
          k_index = get_index(k_polygon,k_vertex);

          //add the following vertex
          k_index_2 = get_index(k_polygon,(k_vertex+1)%N_vertex);
          one_ring[k_index]   . add_unique(k_index_2);
          one_ring[k_index_2] . add_unique(k_index);

          //add the previous vertex       
          k_index_2 = get_index(k_polygon,(k_vertex-1)<0?N_vertex-1:k_vertex-1);
          one_ring[k_index]   . add_unique(k_index_2);
          one_ring[k_index_2] . add_unique(k_index);

          // add the polygon_ring
          polygon_ring[k_index].add_unique(k_polygon);
        }


    }    

  
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int_vector Connectivity::get_one_ring	(	int	k_polygon,
		int	k_edge
	)			const

get one ring

Definition at line 1092 of file Connectivity.cpp.

References get_index(), and one_ring.

Referenced by Mesh_object::get_one_ring().

{
  int k_index = get_index(k_polygon,k_edge);
  if(k_index<0 || k_index>=int(one_ring.size()))
    {printf("Error in get_one_ring(%d,%d), size of one_ring=%d\n",k_polygon,k_edge,one_ring.size());exit(-1);}
  return one_ring[k_index];
}

Here is the call graph for this function:

Here is the caller graph for this function:

int_vector Connectivity::get_one_ring

(

int

k_vertex

)

const

get one ring directly from the vertex

Definition at line 1099 of file Connectivity.cpp.

References one_ring.

{
  if(k_vertex<0 || k_vertex>=int(one_ring.size()))
    {printf("Error in get_one_ring(%d), size of one_ring=%d\n",k_vertex,one_ring.size());exit(-1);}
  return one_ring[k_vertex];
}

int_vector Connectivity::get_polygon_ring	(	int	k_polygon,
		int	k_edge
	)			const

get polygon ring (polygon that shares this vertex)

Definition at line 1106 of file Connectivity.cpp.

References get_index(), and polygon_ring.

Referenced by Mesh_object::get_polygon_ring().

{
  int k_index = get_index(k_polygon,k_edge);
  if(k_index<0 || k_index>=int(polygon_ring.size()))
    {printf("Error in get_polygon_ring(%d,%d), size of polygon_ring=%d\n",k_polygon,k_edge,polygon_ring.size());exit(-1);}
  return polygon_ring[k_index];
}

Here is the call graph for this function:

Here is the caller graph for this function:

int_vector Connectivity::get_polygon_ring

(

int

k_vertex

)

const

get polygon ring directly form the vertex (polygon that shares this vertex)

Definition at line 1113 of file Connectivity.cpp.

References polygon_ring.

{
  if(k_vertex<0 || k_vertex>=int(polygon_ring.size()))
    {printf("Error in get_polygon_ring(%d), size of polygon_ring=%d\n",k_vertex,polygon_ring.size());exit(-1);}
  return polygon_ring[k_vertex];
}

int Connectivity::load_off_file

(

const char *

filename

)

load off connectivity

Definition at line 388 of file Connectivity.cpp.

Referenced by Mesh_object::load_off_file().

{std::string file=filename;return load_off_file(file);}

Here is the caller graph for this function:

int Connectivity::load_off_file

(

const std::string &

filename

)

load off connectivity

Definition at line 390 of file Connectivity.cpp.

References add_polygon(), build_all_index(), destroy(), and SIZE_BUFFER.

{
  destroy();

  #define SIZE_BUFFER 2048
  char buffer[SIZE_BUFFER]={'\0'};

  FILE *fid=NULL;
  fid=fopen(filename.data(),"r");
  if(fid==NULL)
    {printf("ERROR loading %s in load_off_file in Connectivity\n",filename.data());exit(-1);}


  //find OFF or NOFF
  while(strcmp(buffer,"OFF")!=0 && strcmp(buffer,"NOFF")!=0)
    {
      if(fscanf(fid,"%s",buffer)==EOF)
        {printf("ERROR file %s is not off file\n",filename.data());exit(-1);}
      if(buffer[0]=='#')//comments
        fgets(buffer,sizeof(buffer),fid);
    }

  //pass comments
  fscanf(fid,"%s",buffer);
  while(buffer[0]=='#')//comments
    {
      fgets(buffer,sizeof(buffer),fid);
      fscanf(fid,"%s",buffer);
    }

  //read Number of polygon
  int N_vertex=0,N_polygon=0;
  N_vertex=atoi(buffer);//N_vertex
  fscanf(fid,"%d",&N_polygon);//N_polygon
  fgets(buffer,sizeof(buffer),fid);//read line

  //read vertices
  int k_vertex=0;
  for(k_vertex=0;k_vertex<N_vertex;k_vertex++)
    {
      fgets(buffer,sizeof(buffer),fid);//read line
      if(buffer[0]=='#')//comments does not count in vertices number
        k_vertex--;
    }

  //read polygon
  int size_poly=0;
  int k_polygon=0;
  int k_current_polygon=0;
  int temp=0;
  std::vector <int> v_poly;
  for(k_polygon=0;k_polygon<N_polygon;k_polygon++)
    {
       if(fscanf(fid,"%d",&size_poly)!=1)
        {
          fscanf(fid,"%s",buffer);
          if(buffer[0]!='#')
            {printf("ERROR loading polygons in load_off_file %s in Connectivity\n",filename.data());exit(-1);}
          else//read line
            {
              fgets(buffer,sizeof(buffer),fid);
              k_polygon--;
            }
        }
      else
        {
          v_poly.resize(0);
          for(k_current_polygon=0;k_current_polygon<size_poly;k_current_polygon++)
            {
              fscanf(fid,"%d",&temp);
              v_poly.push_back(temp);
            }
          add_polygon(v_poly);
        }
    }
    
  if(fclose(fid)!=0)
    {printf("ERROR closing %s in load_off_file in Connectivity\n",filename.data());exit(-1);}


  //build the index
  build_all_index();

  return 0;
}

Here is the call graph for this function:

int Connectivity::load_obj_file

(

const char *

filename

)

load obj connectivity

Definition at line 1341 of file Connectivity.cpp.

Referenced by Mesh_object::load_obj_file().

{std::string file=filename;return load_obj_file(file);}

Here is the caller graph for this function:

int Connectivity::load_obj_file

(

const std::string &

filename

)

load obj connectivity

Definition at line 1343 of file Connectivity.cpp.

References add_polygon(), build_all_index(), destroy(), and SIZE_BUFFER.

{
  destroy();

#define SIZE_BUFFER 2048
  char buffer[SIZE_BUFFER]={'\0'};
  char buffer2[SIZE_BUFFER]={'\0'};

  FILE *fid=NULL;
  fid=fopen(filename.data(),"r");
  if(fid==NULL)
    {printf("ERROR loading %s in load_obj_file in Connectivity\n",filename.data());exit(-1);}


  std::vector <int> poly;
  int cv=0;
  int one=-1;
  while(fscanf(fid,"%s",buffer)!=EOF)
    {
      switch(buffer[0])
        {
        case 'f': //polygon faces
          poly.resize(0);
          strcpy(buffer2,"\0");
          fscanf(fid,"%s",buffer2);

          if(strstr(buffer2,"//")!=NULL)
            {
              if(sscanf(buffer2,"%d//%*d",&cv)!=1)
                {printf("Error reading connectivity in %s\n",filename.data());exit(-1);}
              poly.push_back(cv+one);
              while(fscanf(fid,"%d//%*d",&cv)==1)
                poly.push_back(cv+one);
              add_polygon(poly);
            }
          else if(sscanf(buffer2,"%d/%*d/%*d",&cv)==1)//warning %d/%d passes through it
            {
              poly.push_back(cv+one);
              while(fscanf(fid,"%d/%*d/%*d",&cv)==1)
                poly.push_back(cv+one);
              add_polygon(poly);
            }
          else if(sscanf(buffer2,"%d/%*d",&cv)==1)
            {
              poly.push_back(cv+one);
              while(fscanf(fid,"%d/%*d",&cv)==1)
                poly.push_back(cv+one);
              add_polygon(poly);
            }
          else if(sscanf(buffer2,"%d",&cv)==1)
            {
              poly.push_back(cv+one);
              while(fscanf(fid,"%d",&cv)==1)
                poly.push_back(cv+one);
              add_polygon(poly);
            }
          else //read the whole line
            {
              fgets(buffer,sizeof(buffer),fid);
              //printf("Something wrong reading obj file [%s] at part:
              //%s %s\n",filename.data(),buffer,buffer2);exit(-1);}
            }
          break;
        }
    }


  //build the index
  build_all_index();

  return 0;
}

Here is the call graph for this function:

int Connectivity::load_collada_file

(

const std::string &

filename

)

load the collada connectivity

Load every polygon of the file

Definition at line 1743 of file Connectivity.cpp.

Referenced by Mesh_object::load_collada_file(), and load_collada_file().

{
  int ok=0;
  ok += load_collada_file(filename,"_ALL_");
  return ok;
}

Here is the caller graph for this function:

int Connectivity::load_collada_file

(

const char *

filename

)

load the collada connectivity

The every polygon of the file

Definition at line 1749 of file Connectivity.cpp.

References load_collada_file().

{std::string file=filename;return load_collada_file(file,"_ALL_");}

Here is the call graph for this function:

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

load the collada connectivity

The required name if the id of the geometry node

Definition at line 1463 of file Connectivity.cpp.

References build_all_index(), and load_collada_mesh_connectivity().

{
  TiXmlDocument doc(filename);
  if(!doc.LoadFile())
    {
      printf("ERROR opening %s\n",filename.data());
      cerr << "error #" << doc.ErrorId() << " : " << doc.ErrorDesc() << endl;
      exit(-1);
    }


  //find library_geometries
  TiXmlHandle root(doc.RootElement());
  TiXmlNode *lib_geometry=NULL;lib_geometry=root.ToNode();
  if(lib_geometry==NULL)
    {printf("Error reading file %s in load_collada_file in Connectivity\n",filename.data());exit(-1);}


  //go to library_geometries entry
  lib_geometry = lib_geometry->FirstChild("library_geometries");

  if(lib_geometry==NULL)
    {printf("Error in file %s, cannot find library_geometries in load_collada_file in Connectivity\n",filename.data());exit(-1);}
  
  
  //load all geometries
  TiXmlNode *geometry=NULL;
  geometry=lib_geometry->FirstChild("geometry");
  if(geometry==NULL)
    {printf("Error cannot find geometry in file %s in load_collada_file in Connectivity\n",filename.data());exit(-1);}
  

  std::string geometry_id;
  int is_find=0;
  do
    {
      if(geometry->ToElement()->Attribute("id")==NULL)
        {printf("Error in file %s, geometry does not have id \n",filename.data());exit(-1);}
      geometry_id = geometry->ToElement()->Attribute("id");
      if(geometry_id==name || name=="_ALL_")
        {
          load_collada_mesh_connectivity(geometry,filename);
          if(name!="_ALL_")
            is_find=1;
        }
      geometry=geometry->NextSiblingElement("geometry");
    }while(geometry!=NULL && is_find==0);

  if(is_find==0 && name!="_ALL_")
    {printf("Error in file %s, no geometry found to load Connectivity with id=\"%s\"\n",filename.data(),name.data());exit(-1);}

  
  //rebuild the index
  build_all_index();

  return 0; 
}

Here is the call graph for this function:

int Connectivity::load_collada_file	(	const char *	filename,
		const char *	name
	)

load the collada connectivity

The required name if the id of the geometry node

Definition at line 1520 of file Connectivity.cpp.

References load_collada_file().

{const std::string file=filename;const std::string geometry_name=name;return load_collada_file(file,geometry_name);}

Here is the call graph for this function:

int Connectivity::load_g_file

(

const char *

filename

)

load g file connectivity

Definition at line 1759 of file Connectivity.cpp.

Referenced by Mesh_object::load_g_file().

{return load_g_file(std::string(filename));}

Here is the caller graph for this function:

int Connectivity::load_g_file

(

const std::string &

filename

)

load g file connectivity

Definition at line 1761 of file Connectivity.cpp.

References add_polygon(), build_all_index(), destroy(), and SIZE_BUFFER.

{
    destroy();

  #define SIZE_BUFFER 2048
  char buffer[SIZE_BUFFER]={'\0'};

  FILE *fid=NULL;
  fid=fopen(filename.data(),"r");
  if(fid==NULL)
    {printf("ERROR loading %s in load_g_file in Connectivity\n",filename.data());exit(-1);}


  //pass comments
  fscanf(fid,"%s",buffer);
  while(buffer[0]=='#')//comments
    {
      fgets(buffer,sizeof(buffer),fid);
      fscanf(fid,"%s",buffer);
    }

  //read Number of polygon
  int N_vertex=0,N_polygon=0;
  N_vertex=atoi(buffer);//N_vertex
  fscanf(fid,"%d",&N_polygon);//N_polygon
  fgets(buffer,sizeof(buffer),fid);//read line

  //read vertices
  int k_vertex=0;
  for(k_vertex=0;k_vertex<N_vertex;k_vertex++)
    {
      fgets(buffer,sizeof(buffer),fid);//read line
      if(buffer[0]=='#')//comments does not count in vertices number
        k_vertex--;
    }

  //read polygons

  int size_poly=0;
  int k_polygon=0;
  int k_current_polygon=0;
  int temp=0;
  std::vector <int> v_poly;
  for(k_polygon=0;k_polygon<N_polygon;k_polygon++)
    {
       if(fscanf(fid,"%d",&size_poly)!=1)
        {
          fscanf(fid,"%s",buffer);
          if(buffer[0]!='#')
            {printf("ERROR loading polygons in load_g_file %s in Connectivity\n",filename.data());exit(-1);}
          else//read line
            {
              fgets(buffer,sizeof(buffer),fid);
              k_polygon--;
            }
        }
      else
        {
          v_poly.resize(0);
          for(k_current_polygon=0;k_current_polygon<size_poly;k_current_polygon++)
            {
              fscanf(fid,"%d",&temp);
              v_poly.push_back(temp);
            }
          add_polygon(v_poly);
          //read rest of the line
          fgets(buffer,sizeof(buffer),fid);
        }
    }

  if(fclose(fid)!=0)
    {printf("ERROR closing %s in load_g_file in Connectivity\n",filename.data());exit(-1);}

  //build the index
  build_all_index();

  return 0;


}

Here is the call graph for this function:

int Connectivity::write_g_type

(

const char *

filename

)

const

write g type file connectivity

Definition at line 1842 of file Connectivity.cpp.

Referenced by Mesh_object::save_g_file().

{return write_g_type(std::string(filename));}

Here is the caller graph for this function:

int Connectivity::write_g_type

(

const std::string &

filename

)

const

write g type file connectivity

Definition at line 1844 of file Connectivity.cpp.

References get_edge_segment(), Edge::get_face_1(), get_index(), polygon_number(), and polygon_size().

{
  FILE *fid=NULL;
  fid=fopen(filename.data(),"a");
  if(fid==NULL)
    {printf("ERROR loading %s in write_g_type in Connectivity\n",filename.data());exit(-1);}

  int k_polygon=0,N_polygon=polygon_number();
  int current_size=0,k_index;
  Edge e;
  for(k_polygon=0;k_polygon<N_polygon;k_polygon++)
    {
      current_size=polygon_size(k_polygon);

      //write the size of the polygon
      fprintf(fid,"%d ",current_size);
      //read the polygon
      for(k_index=0;k_index<current_size;k_index++)
        fprintf(fid,"%d ",get_index(k_polygon,k_index));
      //get edge
      for(k_index=0;k_index<current_size;k_index++)
        {
          e = get_edge_segment(get_index(k_polygon,k_index),get_index(k_polygon,(k_index+1)%current_size));
          fprintf(fid,"%d ",e.get_face_1());
        }

      fprintf(fid,"\n");
    }

  if(fclose(fid)!=0)
    {printf("ERROR closing %s in write_g_type in Connectivity\n",filename.data());exit(-1);}

  return 0;
}

Here is the call graph for this function:

int Connectivity::write_off_type

(

const char *

filename

)

const

Add connectivity description in a .off type.

Definition at line 476 of file Connectivity.cpp.

Referenced by export_visible_off(), and Mesh_object::save_off_file().

{std::string file=filename;return write_off_type(file);}

Here is the caller graph for this function:

int Connectivity::write_off_type

(

const std::string &

filename

)

const

Add connectivity description in a .off type.

Definition at line 479 of file Connectivity.cpp.

References get_index(), polygon_number(), and polygon_size().

{
  FILE *fid=NULL;
  fid=fopen(filename.data(),"a");
  if(fid==NULL)
    {printf("ERROR loading %s in write_off_type in Connectivity\n",filename.data());exit(-1);}

  int k_polygon=0,N_polygon=polygon_number();
  int current_size=0,k_index;
  for(k_polygon=0;k_polygon<N_polygon;k_polygon++)
    {
      current_size=polygon_size(k_polygon);

      //write the size of the polygon
      fprintf(fid,"%d ",current_size);
      //read the polygon
      for(k_index=0;k_index<current_size;k_index++)
        fprintf(fid,"%d ",get_index(k_polygon,k_index));
      fprintf(fid,"\n");
    }

  if(fclose(fid)!=0)
    {printf("ERROR closing %s in write_off_type in Connectivity\n",filename.data());exit(-1);}

  return 0;

}

Here is the call graph for this function:

int Connectivity::write_obj_type

(

const char *

filename

)

const

Add connectivity description in a .obj type.

Definition at line 1417 of file Connectivity.cpp.

Referenced by Mesh_object::save_obj_file().

{std::string file=filename;return write_obj_type(file);}

Here is the caller graph for this function:

int Connectivity::write_obj_type

(

const std::string &

filename

)

const

Add connectivity description in a .obj type.

Definition at line 1419 of file Connectivity.cpp.

References get_index(), polygon_number(), and polygon_size().

{
  FILE *fid=NULL;
  fid=fopen(filename.data(),"a");
  if(fid==NULL)
    {printf("ERROR loading %s in write_obj_type in Connectivity\n",filename.data());exit(-1);}
  
  int k_polygon=0,N_polygon=polygon_number();
  int current_size=0,k_index;
  int one=+1;
  for(k_polygon=0;k_polygon<N_polygon;k_polygon++)
    {
      current_size=polygon_size(k_polygon);

      //write the type of face
      fprintf(fid,"f ");

      //read the polygon
      for(k_index=0;k_index<current_size;k_index++)
        fprintf(fid,"%d ",get_index(k_polygon,k_index)+one);

      fprintf(fid,"\n");
    }

  if(fclose(fid)!=0)
    {printf("ERROR closing %s in write_obj_type in Connectivity\n",filename.data());exit(-1);}


  return 0;
}

Here is the call graph for this function:

int Connectivity::export_visible_off	(	const char *	filename,
		const Point_set &	set
	)			const

export into mesh in off file with the given Point_Set

Definition at line 512 of file Connectivity.cpp.

{std::string file=filename;return export_visible_off(file,set);}

int Connectivity::export_visible_off	(	const std::string &	filename,
		const Point_set &	set
	)			const

Definition at line 514 of file Connectivity.cpp.

References polygon_number(), and write_off_type().

{

  FILE *fid=NULL;
  fid=fopen(filename.data(),"w");
  if(fid==NULL)
    {printf("ERROR loading %s in export_visible_off in Connectivity\n",filename.data());exit(-1);}



  // HEADER
  fprintf(fid,"# VISIBLE OFF SCENE CONNECTIVITY\n");
  fprintf(fid,"OFF\n");
  fprintf(fid,"%d %d 0\n",set.size(),polygon_number());

  if(fclose(fid)!=0)
    {printf("ERROR closing %s in export_visible_off in Connectivity\n",filename.data());exit(-1);}
  fid=NULL;


  // export vertex
  set.write_off_type(filename);

  // export connectivity
  write_off_type(filename);


  //write EOF
  fid=fopen(filename.data(),"a");
  if(fid==NULL)
    {printf("ERROR loading %s in export_visible_off in Connectivity\n",filename.data());exit(-1);}
  fprintf(fid,"#EOF [OK] %s\n",filename.data());
  if(fclose(fid)!=0)
    {printf("ERROR closing %s in export_visible_off in Connectivity\n",filename.data());exit(-1);}
  fid=NULL;

  return 0;
}

Here is the call graph for this function:

int Connectivity::operator()

(

int

k_index

)

const

direct access to index_polygon

Definition at line 557 of file Connectivity.cpp.

References index_polygon, and size_index().

{
  if(k_index<0 || k_index>=size_index())
    {printf("Error in operator()(%d) with size %d in Connectivity\n",k_index,size_index());exit(-1);}
  return index_polygon[k_index];
}

Here is the call graph for this function:

int Connectivity::operator[]

(

int

k_index

)

const

direct access to index_polygon

Definition at line 563 of file Connectivity.cpp.

References index_polygon, and size_index().

{
  if(k_index<0 || k_index>=size_index())
    {printf("Error in operator[](%d) with size %d in Connectivity\n",k_index,size_index());exit(-1);}
  return index_polygon[k_index];
}

Here is the call graph for this function:

int & Connectivity::operator()

(

int

k_index

)

direct access to index_polygon

Definition at line 569 of file Connectivity.cpp.

References index_polygon, and size_index().

{
  if(k_index<0 || k_index>=size_index())
    {printf("Error in operator()(%d) with size %d in Connectivity\n",k_index,size_index());exit(-1);}
  return index_polygon[k_index];
}

Here is the call graph for this function:

int & Connectivity::operator[]

(

int

k_index

)

direct access to index_polygon

Definition at line 575 of file Connectivity.cpp.

References index_polygon, and size_index().

{
  if(k_index<0 || k_index>=size_index())
    {printf("Error in operator[](%d) with size %d in Connectivity\n",k_index,size_index());exit(-1);}
  return index_polygon[k_index];
}

Here is the call graph for this function:

int Connectivity::operator()	(	int	k_polygon,
		int	k_index
	)			const

access to k_index of polygon n. k_polygon

Definition at line 581 of file Connectivity.cpp.

References index_polygon, polygon_access, polygon_number(), and polygon_size().

{
  if(k_polygon<0 || k_polygon>=polygon_number())
    {printf("Error in operator(), k_polygon(%d) is not correct with size %d in Connectivity\n",k_polygon,polygon_number());exit(-1);}
  if(k_index<0 || k_index>=polygon_size(k_polygon))
    {printf("Error in operator(), k_index(%d) is not correct for polygon %d in Connectivity. This polygon has size=%d\n",k_index,k_polygon,polygon_size(k_polygon));exit(-1);}
    return index_polygon[polygon_access[k_polygon]+k_index];
}

Here is the call graph for this function:

int & Connectivity::operator()	(	int	k_polygon,
		int	k_index
	)

access to k_index of polygon n. k_polygon

Definition at line 589 of file Connectivity.cpp.

References index_polygon, polygon_access, polygon_number(), and polygon_size().

{
  if(k_polygon<0 || k_polygon>=polygon_number())
    {printf("Error in operator(), k_polygon(%d) is not correct with size %d in Connectivity\n",k_polygon,polygon_number());exit(-1);}
  if(k_index<0 || k_index>=polygon_size(k_polygon))
    {printf("Error in operator(), k_index(%d) is not correct for polygon %d in Connectivity. This polygon has size=%d\n",k_index,k_polygon,polygon_size(k_polygon));exit(-1);}
    return index_polygon[polygon_access[k_polygon]+k_index];
}

Here is the call graph for this function:

const Connectivity & Connectivity::operator=

(

const Connectivity &

c

)

Definition at line 641 of file Connectivity.cpp.

References edges, index_polygon, one_ring, polygon_access, polygon_ring, size_polygon, and triangulated_index.

{
  index_polygon      = c.index_polygon;
  size_polygon       = c.size_polygon;
  polygon_access     = c.polygon_access;
  triangulated_index = c.triangulated_index;
  edges              = c.edges;
  one_ring           = c.one_ring;
  polygon_ring       = c.polygon_ring;

  return (*this);
}

int Connectivity::find_current_edge_slow	(	int	vertex_index_0,
		int	vertex_index_1
	)			[private]

look to find the edge corresponding to [vertex_0,vertex_1], return -1 if not Full research, slow. Only use, when access table is not build

Definition at line 939 of file Connectivity.cpp.

References edges, get_edge(), Edge::get_index_0(), and Edge::get_index_1().

Referenced by build_edges().

{
  int N_edge=edges.size();
  int k_edge=0;
  Edge e;
  for(k_edge=0;k_edge<N_edge;k_edge++)
    {
      e=get_edge(k_edge);
      //find vertex (in the right order)
      if(vertex_index_0==e.get_index_0() && vertex_index_1==e.get_index_1())
        return k_edge;
    }
  //did not find
  return -1;

}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< int > Connectivity::find_all_current_edge_slow	(	int	vertex_index_0,
		int	vertex_index_1
	)			[private]

look to find all the edge corresponding to [vertex_0,vertex_1] return empty vector if not found Full research, slow.

Definition at line 956 of file Connectivity.cpp.

References edges, get_edge(), Edge::get_index_0(), and Edge::get_index_1().

{
  std::vector <int> found_edges;
  int N_edge=edges.size();
  int k_edge=0;
  Edge e;
  for(k_edge=0;k_edge<N_edge;k_edge++)
    {
      e=get_edge(k_edge);
      //find vertex (in the right order)
      if(vertex_index_0==e.get_index_0() && vertex_index_1==e.get_index_1())
        found_edges.push_back(k_edge);
    }
  //did not find
  return found_edges;
}

Here is the call graph for this function:

int Connectivity::reccursive_connect_manifold_polygons	(	int	current_polygon,
		std::vector< int > *	correct_polygon
	)			[private]

Pass through all the edges to flip the polygon if needed.

Reccursive construction

Definition at line 1164 of file Connectivity.cpp.

References flip_polygon(), get_index(), polygon_number(), and polygon_size().

Referenced by build_manifold().

{
  int k_vertex_current=0;
  int N_vertex_current=polygon_size(current_polygon);

  int k_polygon=0;
  int N_polygon=polygon_number();
  int N_vertex=0;
  int k_vertex=0;

  //printf("%d/%d\n",current_polygon,N_polygon);


  for(k_vertex_current=0;k_vertex_current<N_vertex_current;k_vertex_current++)
    {


      //get the edge
      int u0=get_index(current_polygon,k_vertex_current);
      int u1=get_index(current_polygon,(k_vertex_current+1)%N_vertex_current);
      
      
      //try to find the same edge
      for(k_polygon=0;k_polygon<N_polygon;k_polygon++)
        {
          if((*correct_polygon)[k_polygon]==0)
            {
              N_vertex=polygon_size(k_polygon);
              for(k_vertex=0;k_vertex<N_vertex;k_vertex++)
                {
                  
                  //if find the same edge, need to flip the polygon
                  if(
                     (u0==get_index(k_polygon,0) && u1==get_index(k_polygon,1))
                     ||
                     (u0==get_index(k_polygon,1) && u1==get_index(k_polygon,2))
                     ||
                     (u0==get_index(k_polygon,2) && u1==get_index(k_polygon,0)) )
                    {
                      flip_polygon(k_polygon);
                      //printf("flip [%d,%d]-[%d,%d]\n",u0,u1,current_polygon,k_polygon);
                      (*correct_polygon)[k_polygon]=1;
                      
                      reccursive_connect_manifold_polygons(k_polygon,correct_polygon); 
                    }
                  //if find a correct polygon already good
                  else if(
                          (u0==get_index(k_polygon,1) && u1==get_index(k_polygon,0))
                          ||
                          (u0==get_index(k_polygon,2) && u1==get_index(k_polygon,1))
                          ||
                          (u0==get_index(k_polygon,0) && u1==get_index(k_polygon,2)) )
                    {
                      //confirm it is good
                      (*correct_polygon)[k_polygon]=1;
                      reccursive_connect_manifold_polygons(k_polygon,correct_polygon);
                    }
                }
            }
        }
      
    }



//   std::vector <int> already_flipped(N_polygon);

//   //******************************//
//   //Loop on every edges
//   //******************************//
//   for(k_polygon=0;k_polygon<N_polygon;k_polygon++)
//     {
//       N_vertex=polygon_size(k_polygon);
//       for(k_vertex=0;k_vertex<N_vertex;k_vertex++)
//      {
//        //get index line
//        ind[0]=get_index(k_polygon,k_vertex);
//        ind[1]=get_index(k_polygon,(k_vertex+1)%N_vertex);

//        for(k_polygon2=k_polygon+1;k_polygon2<N_polygon;k_polygon2++)
//          {
//            N_vertex2=polygon_size(k_polygon2);
//            for(k_vertex2=0;k_vertex2<N_vertex2;k_vertex2++)
//              {
//                ind2[0]=get_index(k_polygon2,k_vertex2);
//                ind2[1]=get_index(k_polygon2,(k_vertex2+1)%N_vertex2);

//                if(ind[0]==ind2[0] && ind[1]==ind2[1])
//                  {
//                    printf("[%d,%d] - flipped [%d/%d]\n",ind[0],ind[1],k_polygon,k_polygon2);

//                    if(already_flipped[k_polygon2]==0)
//                      {
//                        flip_polygon(k_polygon2);
//                        already_flipped[k_polygon2]=1;
//                      }

//                  }
//              }
//          }













//        //try to find if [ind[1]-ind[2]] has already been declared
//        other_polygon=find_all_current_edge_slow(ind[0],ind[1]);
//        if(other_polygon.size()>1)//not a manifold mesh
//          {
//            printf("Find non manifold mesh [%d,%d]\n",ind[0],ind[1]);

//            //printf("%d,%d,%d\n",get_index(other_polygon,0),get_index(other_polygon,1),get_index(other_polygon,2));
//            if(other_polygon[0]!=k_polygon)
//              flip_polygon(other_polygon[0]);
//            else if(flip_polygon(other_polygon[1]!=k_polygon))
//              flip_polygon(other_polygon[1]);
//            //printf("%d,%d,%d\n",get_index(other_polygon,0),get_index(other_polygon,1),get_index(other_polygon,2));
//            //printf("%d,%d,%d\n",get_index(k_polygon,0),get_index(k_polygon,1),get_index(k_polygon,2));

//            //restart from zero
//            k_vertex=N_vertex;
//            k_polygon=-1;
//            build_edges();


//          }




  //rebuild the edges
  //build_edges();

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Connectivity::load_collada_mesh_connectivity	(	TiXmlNode *	geometry_node,
		const std::string &	filename
	)			[private]

Internal Collada Loader.

Load mesh connectivity (polylist+triangles)

Definition at line 1523 of file Connectivity.cpp.

References load_polylist_connectivity(), and load_triangles_connectivity().

Referenced by load_collada_file().

{
  TiXmlNode* mesh_node=NULL;
  mesh_node=geometry_node->FirstChild("mesh");
  //need to find mesh
  if(mesh_node==NULL)
    {printf("Error in Connectivity in load_collada_mesh_connectivity for file %s\n",filename.data());exit(-1);}


  //*************************************//
  //try to load every polylist  
  //*************************************//
  TiXmlNode* polylist_node=NULL;
  polylist_node=mesh_node->FirstChild("polylist");
  while(polylist_node!=NULL)
    {
      //there is polylist
      load_polylist_connectivity(polylist_node,filename);
      
      polylist_node=polylist_node->NextSiblingElement("polylist");
    };
    

  //*************************************//
  //try to load every triangles
  //*************************************//
  TiXmlNode* triangles_node=NULL;
  triangles_node=mesh_node->FirstChild("triangles");
  while(triangles_node!=NULL)
    {
      //there is triangles
      load_triangles_connectivity(triangles_node,filename);
      
      triangles_node=triangles_node->NextSiblingElement("triangles");
    };
    


  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int Connectivity::load_triangles_connectivity	(	TiXmlNode *	triangles,
		const std::string &	filename
	)			[private]

Internal Collada Loader.

Load Triangles connectivity

load the

only take the offseted vertices

check integrity

Definition at line 1565 of file Connectivity.cpp.

References add_polygon(), and load_collada_int_entry().

Referenced by load_collada_mesh_connectivity().

{
  //first load every input and check where entry "vertex" to get its offset
  TiXmlNode* input_node=NULL;
  input_node=triangles->FirstChild("input");
  if(input_node==NULL)
    {printf("Error in load_triangle_connectivity of file %s, no input entry in the triangles source\n",filename.data());exit(-1);}
  
  int total_offset=0,vertex_offset=-1;
  std::string semantic_string;
  while(input_node!=NULL)
    {  
      if(input_node->ToElement()->Attribute("semantic")==NULL)
        {printf("Error in load_triangles_connectivity for file %s, no semantic entry in input of triangles\n",filename.data());exit(-1);}
      semantic_string=input_node->ToElement()->Attribute("semantic");
      if(semantic_string=="VERTEX" || semantic_string=="vertex" || semantic_string=="Vertex")
        {
          //get the offset of the input
          if(input_node->ToElement()->QueryIntAttribute("offset",&vertex_offset)!=TIXML_SUCCESS)
            {printf("Error in load_triangles_connectivity, offset vertex is wrong for file %s in Connectivity\n",filename.data());exit(-1);}
        }
      total_offset++;
      input_node = input_node->NextSiblingElement("input");
    };


  

  TiXmlNode* p_node=NULL;
  p_node=triangles->FirstChild("p");
  if(p_node==NULL)
    {printf("Error, no <p> found in triangles in file %s in Connectivity\n",filename.data());exit(-1);}
  std::vector <int> p_entry=load_collada_int_entry(p_node);

  int triangle_count=0;
  if(triangles->ToElement()->QueryIntAttribute("count",&triangle_count)!=TIXML_SUCCESS)
    {printf("Error in triangles in Connectivity for file %s, no count in triangles\n",filename.data());exit(-1);}


  std::vector <int> connectivity_array;
  int count=0;
  for(int k_poly=0;k_poly<triangle_count;k_poly++)
    for(int k_vertex=0;k_vertex<3;k_vertex++)
      for(int k_offset=0;k_offset<total_offset;k_offset++)
        {
          if(k_offset==vertex_offset)
            connectivity_array.push_back(p_entry[count]);
          count++;
        }



  if(3*triangle_count!=int(connectivity_array.size()))
    {printf("Error in file %s in Connectivity, in loading triangle: size(connectivity_array)=%d and given size=3x%d=%d\n",filename.data(),connectivity_array.size(),triangle_count,3*triangle_count);exit(-1);}

  
  //add the polygon
  std::vector <int> current_polygon;
  int k_polygon=0,k_index=0;
  count=0;
  for(k_polygon=0;k_polygon<triangle_count;k_polygon++)
    {
      current_polygon.resize(0);
      for(k_index=0;k_index<3;k_index++,count++)
        current_polygon.push_back(connectivity_array[count]);
      add_polygon(current_polygon);
    }
    

  return 0;

}

Here is the call graph for this function:

Here is the caller graph for this function:

int Connectivity::load_polylist_connectivity	(	TiXmlNode *	polylist,
		const std::string &	filename
	)			[private]

Internal Collada Loader.

Load polylist connectivity

load the <vcount>

load the

only take the offseted vertices

Definition at line 1641 of file Connectivity.cpp.

References add_polygon(), and load_collada_int_entry().

Referenced by load_collada_mesh_connectivity().

{
  //first load every input and check where entry "vertex" to get its offset
  TiXmlNode* input_node=NULL;
  input_node=polylist->FirstChild("input");
  if(input_node==NULL)
    {printf("Error in load_polylist_connectivity of file %s, no input entry in the polylist source\n",filename.data());exit(-1);}
  
  int total_offset=0,vertex_offset=-1;
  std::string semantic_string;
  while(input_node!=NULL)
    {
      if(input_node->ToElement()->Attribute("semantic")==NULL)
        {printf("Error in load_polylist_connectivity for file %s, no semantic entry in input of polylist\n",filename.data());exit(-1);}
      semantic_string=input_node->ToElement()->Attribute("semantic");
      if(semantic_string=="VERTEX" || semantic_string=="vertex" || semantic_string=="Vertex")
        {
          //get the offset of the input
          if(input_node->ToElement()->QueryIntAttribute("offset",&vertex_offset)!=TIXML_SUCCESS)
            {printf("Error in load_polylist_connectivity, offset vertex is wrong for file %s in Connectivity\n",filename.data());exit(-1);}
        }
      total_offset++;
      input_node = input_node->NextSiblingElement("input");
    };


  TiXmlNode* vcount_node=NULL;
  vcount_node=polylist->FirstChild("vcount");
  if(vcount_node==NULL)
    {printf("Error, no vcount found in polylist in file %s in Connectivity\n",filename.data());exit(-1);}
  std::vector <int> vcount_entry=load_collada_int_entry(vcount_node);

  //check polylist count
  int polylist_count=0;
  if(polylist->ToElement()->QueryIntAttribute("count",&polylist_count)!=TIXML_SUCCESS)
    {printf("Error in polylist in Connectivity for file %s, no count in polylist\n",filename.data());exit(-1);}
  if(polylist_count!=int(vcount_entry.size()))
    {printf("Error in file %s in Connectivity, in loading polylist: size(vcount)=%d and given size=%d\n",filename.data(),vcount_entry.size(),polylist_count);exit(-1);}


  TiXmlNode* p_node=NULL;
  p_node=polylist->FirstChild("p");
  if(p_node==NULL)
    {printf("Error, no <p> found in polylist in file %s in Connectivity\n",filename.data());exit(-1);}
  std::vector <int> p_entry=load_collada_int_entry(p_node);

  std::vector <int> connectivity_array;
  int count=0;
  for(int k_poly=0;k_poly<polylist_count;k_poly++)
    for(int k_vertex=0;k_vertex<vcount_entry[k_poly];k_vertex++)
      for(int k_offset=0;k_offset<total_offset;k_offset++)
        {
          if(k_offset==vertex_offset)
            connectivity_array.push_back(p_entry[count]);
          count++;
        }
  
  //add the polygon
  std::vector <int> current_polygon;
  int k_polygon=0,k_index=0;
  count=0;
  for(k_polygon=0;k_polygon<polylist_count;k_polygon++)
    {
      current_polygon.resize(0);
      for(k_index=0;k_index<vcount_entry[k_polygon];k_index++,count++)
        current_polygon.push_back(connectivity_array[count]);
      add_polygon(current_polygon);
    }
    

  return 0;
  
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< int > Connectivity::load_collada_int_entry

(

TiXmlNode *

node

)

[private]

Internal Collada Loader.

Load vcount entry

Definition at line 1718 of file Connectivity.cpp.

Referenced by load_polylist_connectivity(), and load_triangles_connectivity().

{
  std::vector <int> vcount_entry;
  if(vcount_node==NULL)
    {printf("Error in load_collada_vcount_entry in Connectivity, pointer is null\n");exit(-1);}
  if(vcount_node->FirstChild()==NULL)
    {printf("Error no child in load_collada_vcount_entry in Connectivity\n");exit(-1);}
  //convert entry to text
  std::string full_string = vcount_node->FirstChild()->ToText()->ValueStr();

  //fill the entry
  int k1=0,k0=0;
  string X;
  do
    {
      k1= full_string.find(" ",k1+1);
      X = full_string.substr(k0,k1-k0);
      vcount_entry.push_back(atoi(X.data())); //add index
      k0=k1+1;
    }while(k1>0);

  return vcount_entry;
} 

Here is the caller graph for this function:

---

Friends And Related Function Documentation

Connectivity operator+	(	const Connectivity &	c1,
		const Connectivity &	c2
	)			[friend]

concatenation of two connectivity

Just add, assume there is no duplicate

Definition at line 654 of file Connectivity.cpp.

{
  Connectivity c;
  int N_polygon=0;
  int k_polygon=0;

  N_polygon=c1.polygon_number();
  for(k_polygon=0;k_polygon<N_polygon;k_polygon++)
    c.add_polygon(c1.get_index_of_polygon(k_polygon));

  N_polygon=c2.polygon_number();
  for(k_polygon=0;k_polygon<N_polygon;k_polygon++)
    c.add_polygon(c2.get_index_of_polygon(k_polygon));

  c.build_all_index();

  return c;
}

Connectivity operator+	(	const Connectivity &	_c,
		const std::vector< int > &	v
	)			[friend]

add polygon

Definition at line 673 of file Connectivity.cpp.

{
  Connectivity c;

  int N_polygon=0;
  int k_polygon=0;

  N_polygon=_c.polygon_number();
  for(k_polygon=0;k_polygon<N_polygon;k_polygon++)
    c.add_polygon(_c.get_index_of_polygon(k_polygon));

  c.add_polygon(v);
  c.build_all_index();

  return c;
}

Connectivity operator+	(	const std::vector< int > &	v,
		const Connectivity &	_c
	)			[friend]

add polygon

Definition at line 691 of file Connectivity.cpp.

{
  Connectivity c;
  c = _c+v;
  return c;
}

Connectivity operator-	(	const Connectivity &	c1,
		const Connectivity &	c2
	)			[friend]

delete a set of polygon

Definition at line 699 of file Connectivity.cpp.

{
  Connectivity c;
  c=c1;

  int k=0;
  int N_polygon=c2.polygon_number();
  for(k=0;k<N_polygon;k++)
    c.delete_given_polygon(c2.get_index_of_polygon(k));
  
  return c;
}

Connectivity operator-	(	const Connectivity &	c1,
		const std::vector< int > &	c2
	)			[friend]

delete polygon

Definition at line 712 of file Connectivity.cpp.

{
  Connectivity c=c1;
  c.delete_given_polygon(c2);
  return c;
}

bool operator==	(	const Connectivity &	c1,
		const Connectivity &	c2
	)			[friend]

test equality

Definition at line 720 of file Connectivity.cpp.

{

  //must have same dimension first
  if(c1.polygon_number()!=c2.polygon_number())
    return 0;

  int k_polygon=0;
  int N_polygon=c1.polygon_number();
  int k_vertex=0,N_vertex=0;
  for(k_polygon=0;k_polygon<N_polygon;k_polygon++)
    {
      if(c1.polygon_size(k_polygon)!=c2.polygon_size(k_polygon))
        return 0;

      N_vertex=c1.polygon_size(k_polygon);
      for(k_vertex=0;k_vertex<N_vertex;k_vertex++)
        if(c1(k_polygon,k_vertex)!=c2(k_polygon,k_vertex))
          return 0;
    }
  return 1;
}

bool operator!=	(	const Connectivity &	c1,
		const Connectivity &	c2
	)			[friend]

test equality

Definition at line 743 of file Connectivity.cpp.

{return !(c1==c2);}

ostream& operator<<	(	ostream &	flux,
		const Connectivity &	c
	)			[friend]

Stream output.

Definition at line 745 of file Connectivity.cpp.

{
  int k_polygon=0,N_polygon=c.polygon_number();
  int k_vertex=0,N_vertex=0;
  for(k_polygon=0;k_polygon<N_polygon;k_polygon++)
    {
      N_vertex=c.polygon_size(k_polygon);
      flux<<N_vertex<<" [";
      for(k_vertex=0;k_vertex<N_vertex-1;k_vertex++)
        cout<<c(k_polygon,k_vertex)<<",";
      cout<<c(k_polygon,N_vertex-1)<<"]"<<endl;
    }

  return flux;
}

---

Member Data Documentation

std::vector<int> Connectivity::index_polygon [private]

every index are ordered in only one vector

vector of type [index_1,index_2,index_3,-1,index_4,...]. Here -1 is used as a separator.

Definition at line 401 of file Connectivity.h.

Referenced by add_index(), add_polygon(), build_size_and_polygon_access(), Connectivity(), delete_polygon(), destroy(), flip_polygon(), get_index(), operator()(), operator=(), operator[](), set_index(), set_polygon(), size_index(), and triangulate().

int Connectivity::max_index [private]

max_index estimate the number of vertex that are needed

Definition at line 406 of file Connectivity.h.

Referenced by build_one_ring(), Connectivity(), destroy(), find_max_index(), and vertex_number().

std::vector<int> Connectivity::size_polygon [private]

vertex of polygon size

Definition at line 409 of file Connectivity.h.

Referenced by build_size_and_polygon_access(), Connectivity(), destroy(), flip_polygon(), operator=(), polygon_number(), and polygon_size().

std::vector<int> Connectivity::polygon_access [private]

direct access of polygon n.k

Definition at line 412 of file Connectivity.h.

Referenced by build_size_and_polygon_access(), Connectivity(), delete_polygon(), destroy(), flip_polygon(), get_edge(), get_index(), get_polygon_access(), operator()(), operator=(), set_edge(), set_index(), and set_polygon().

std::vector<int> Connectivity::triangulated_index [private]

triangulated version

Definition at line 415 of file Connectivity.h.

Referenced by build_triangulated_index(), get_index_triangulated(), get_triangle_number(), operator=(), and triangulate().

std::vector<int_vector> Connectivity::one_ring [private]

one_ring

Definition at line 418 of file Connectivity.h.

Referenced by build_one_ring(), Connectivity(), destroy(), get_one_ring(), and operator=().

std::vector<int_vector> Connectivity::polygon_ring [private]

Polygon ring = polygons surrounding a given vertex.

Definition at line 421 of file Connectivity.h.

Referenced by build_one_ring(), Connectivity(), destroy(), get_polygon_ring(), and operator=().

std::vector<Edge> Connectivity::edges [private]

Set of Edges of the mesh.

Definition at line 424 of file Connectivity.h.

Referenced by build_edges(), Connectivity(), destroy(), edge_number(), find_all_current_edge_slow(), find_current_edge_slow(), get_edge(), operator=(), and set_edge().

std::vector<int> Connectivity::index_edges [private]

Pointer between polygon edges and index in Edge vector.

Definition at line 427 of file Connectivity.h.

Referenced by build_edges(), get_edge(), and set_edge().

std::vector<int_vector> Connectivity::edges_access [private]

Pointer between [index_0,index_1] and edge index for direct access.

Definition at line 430 of file Connectivity.h.

Referenced by build_edges(), and get_edge_segment().

---

The documentation for this class was generated from the following files:

• header/Connectivity.h
• src/Connectivity.cpp