Connectivity.cpp

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/>.
*/





#include <Connectivity.h>


Connectivity::Connectivity()
{
}

Connectivity::Connectivity(const Connectivity& c)
{
  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(){destroy();}

int Connectivity::destroy()
{
  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;
}

int Connectivity::get_index(int k_index) const
{
  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];
}
int& Connectivity::get_index(int k_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];
}
int Connectivity::get_index(int k_polygon,int k_index) const
{
  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];
}
int& Connectivity::get_index(int k_polygon,int k_index)
{
  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];
}
std::vector <int> Connectivity::get_index_of_polygon(int k_polygon) const
{
  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;
}
const int* Connectivity::get_index() const {return &index_polygon[0];}






int Connectivity::size_index() const {return index_polygon.size();}
int Connectivity::polygon_number() const {return size_polygon.size();}
int Connectivity::polygon_size(int k_polygon) const
{
  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::get_index_triangulated(int k_index) const
{
  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_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
{
  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)
{
 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
{return &triangulated_index[0];}
int Connectivity::get_triangle_number() const
{
  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;
}




int Connectivity::build_size_and_polygon_access()
{
  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;
}

int Connectivity::build_triangulated_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;
}

int Connectivity::find_max_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;
}

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


int Connectivity::add_polygon(int index_0,int index_1,int index_2)
{
  std::vector <int> polygon;
  polygon.push_back(index_0);
  polygon.push_back(index_1);
  polygon.push_back(index_2);
  return add_polygon(polygon);
}
int Connectivity::add_polygon(int index_0,int index_1,int index_2,int index_3)
{
  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);
}
int Connectivity::add_polygon(const std::vector <int>& polygon)
{
  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;
}

int Connectivity::add_index(int index)
{
  index_polygon.push_back(index);
  return 0;
}

int Connectivity::set_polygon(int k_polygon,const std::vector <int>& 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;
}


int Connectivity::set_index(int k_polygon,int k_index,int 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;
}


int Connectivity::delete_polygon(int k_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;
}

int Connectivity::delete_given_polygon(const std::vector <int> polygon)
{
  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;
}







int Connectivity::load_off_file(const char* filename)
{std::string file=filename;return load_off_file(file);}
int Connectivity::load_off_file(const std::string& filename)
{
  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;
}

int Connectivity::write_off_type(const char* filename) const
{std::string file=filename;return write_off_type(file);}

int Connectivity::write_off_type(const std::string& filename) const
{
  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;

}






int Connectivity::export_visible_off(const char* filename,const Point_set& set) const
{std::string file=filename;return export_visible_off(file,set);}
int Connectivity::export_visible_off(const std::string& filename,const Point_set& set) const
{

  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;
}





int Connectivity::operator()(int k_index) const
{
  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];
}
int Connectivity::operator[](int k_index) const
{
  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];
}
int& Connectivity::operator()(int k_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];
}
int& Connectivity::operator[](int k_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];
}
int Connectivity::operator()(int k_polygon,int k_index) const
{
  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];
}
int& Connectivity::operator()(int k_polygon,int k_index)
{
  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];
}


int Connectivity::find_polygon(const std::vector <int>& polygon) const
{
  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;
}


const Connectivity& Connectivity::operator=(const Connectivity& c)
{
  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);
}

Connectivity operator+(const Connectivity& c1,const Connectivity& c2)
{
  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)
{
  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)
{
  Connectivity c;
  c = _c+v;
  return c;
}


Connectivity operator-(const Connectivity& c1,const Connectivity& c2)
{
  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)
{
  Connectivity c=c1;
  c.delete_given_polygon(c2);
  return c;
}


bool operator==(const Connectivity& c1,const Connectivity& c2)
{

  //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){return !(c1==c2);}

ostream& operator << (ostream& flux,const Connectivity& c)
{
  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;
}


Edge Connectivity::get_edge(int k_index) const
{
  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];
}

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

  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];

}


int Connectivity::build_edges()
{

  //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;
}



int Connectivity::find_current_edge_slow(int vertex_index_0,int vertex_index_1)
{
  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;

}

std::vector <int> Connectivity::find_all_current_edge_slow(int vertex_index_0,int vertex_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;
}



Edge Connectivity::get_edge_segment(int index_vertex_0,int index_vertex_1) const
{
  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;
    
}

int Connectivity::edge_number() const{return edges.size();}

int Connectivity::vertex_number() const{return max_index+1;}


int Connectivity::set_edge(int k_index,const Edge& e)
{
  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;
}

int Connectivity::set_edge(int k_polygon,int k_edge,const Edge& e)
{
  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;
}


int Connectivity::build_one_ring()
{

  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;
}

int_vector Connectivity::get_one_ring(int k_polygon,int k_edge) const
{
  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];
}
int_vector Connectivity::get_one_ring(int k_vertex) const
{
  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
{
  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];
}
int_vector Connectivity::get_polygon_ring(int k_vertex) const
{
  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::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;
}


int Connectivity::reccursive_connect_manifold_polygons(int current_polygon,std::vector <int>* correct_polygon)
{
  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;
}


int Connectivity::flip_polygon(int k_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;
}

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



int Connectivity::load_obj_file(const char* filename)
{std::string file=filename;return load_obj_file(file);}
int Connectivity::load_obj_file(const std::string& filename)
{
  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;
}


int Connectivity::write_obj_type(const char* filename) const
{std::string file=filename;return write_obj_type(file);}
int Connectivity::write_obj_type(const std::string& filename) const
{
  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;
}

int Connectivity::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();
}


int Connectivity::load_collada_file(const std::string& filename,const std::string& name)
{
  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; 
}
int Connectivity::load_collada_file(const char* filename,const char* name)
{const std::string file=filename;const std::string geometry_name=name;return load_collada_file(file,geometry_name);}

int Connectivity::load_collada_mesh_connectivity(TiXmlNode* geometry_node,const std::string& filename)
{
  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;
}


int Connectivity::load_triangles_connectivity(TiXmlNode* triangles,const std::string& filename)
{
  //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;

}

int Connectivity::load_polylist_connectivity(TiXmlNode* polylist,const std::string& filename)
{
  //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;
  
}

std::vector <int> Connectivity::load_collada_int_entry(TiXmlNode* vcount_node)
{
  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;
} 


int Connectivity::load_collada_file(const std::string& filename)
{
  int ok=0;
  ok += load_collada_file(filename,"_ALL_");
  return ok;
}
int Connectivity::load_collada_file(const char* filename)
{std::string file=filename;return load_collada_file(file,"_ALL_");}

int Connectivity::get_polygon_access(int k_polygon) const
{
  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];
}

int Connectivity::load_g_file(const char* filename)
{return load_g_file(std::string(filename));}
int Connectivity::load_g_file(const std::string& filename)
{
    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;


}

int Connectivity::write_g_type(const char* filename) const
{return write_g_type(std::string(filename));}
int Connectivity::write_g_type(const std::string& filename) const
{
  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;
}