synaps/topology/point_graph.h

/*********************************************************************
*      This file is part of the source code of SYNAPS library          *
*   Author(s): G. Gatellier                                          *
*              B. Mourrain, GALAAD, INRIA                            *
**********************************************************************/
#ifndef synaps_topology_point_graph_H
#define synaps_topology_point_graph_H
/*********************************************************************/
#include <vector>
#include <map>
#include <synaps/base/Seq.h>
#include <synaps/topology/point.h>
#include <synaps/base/io/axel.h>
#include <synaps/base/io/geomview.h>
/*********************************************************************/
__BEGIN_NAMESPACE_SYNAPS
//--------------------------------------------------------------------
namespace topology
{


  template<class Pt>
  struct ltpts
  {
    inline bool operator()(const Pt & Pi, const Pt & Pj) 
      {return (ptcmp(Pi,Pj) < 0);}
  };


  template<class C, 
           class R = Seq<topology::point<C> >, 
           class S = Seq<std::vector<int> >
          >
  struct point_graph  {
    typedef S Vect;

    typedef R VectPt;

    typedef typename R::value_type point_t;

    typedef C coeff_t;

    std::map<point_t, int, ltpts<point_t> > Pts_Map;

    R Vertices;

    S Edges;

    int nb_edges;

    point_graph():Vertices(),Edges(),nb_edges() {}

    point_graph(const point_graph<C,R,S> & Graph)
      :Pts_Map(Graph.Pts_Map), Vertices(Graph.Vertices), Edges(Graph.Edges) {}

    int access(const point_t & Point) const
      {
        bool exist = false;
        int i;
        for( i = 0; i < Vertices.size(); ++i)
          {
            if ( ptcmp(Point,Vertices[i]) == 0)
              {
                exist = true;
                break;
              }
          }
        
        if ( exist )
          return i;
        else
          return -1;
      }

    int access(point_t * Point) const
      {
        bool exist = false;
        int i;
        for( i = 0; i < Vertices.size(); ++i)
          {
            if ( ptcmp((*Point),Vertices[i]) == 0)
              {
                exist = true;
                break;
              }
          }
        
        if ( exist )
          return i;
        else
          return -1;
      }


    point_graph(R & V,S & E): 
      Vertices(V),Edges(E),nb_edges(E.size()) {}

    inline void insertVertex(const point_t & Point)
      {
        Vertices.push_back(Point);
      }

    inline void createInEdge()
      {
        typedef typename Vect::value_type type;
        type V;
        Edges.push_back(V);
      }

    int insert(const point_t & Point)
      {
        int size = Vertices.size();
        if (size == 0)
          return push_back(Point);
        bool exist = false;
        int i;
        for( i = 0; i < size; ++i)
          {
            if (ptcmp(Point,Vertices[i]) == 0)
              {
                exist = true;
                break;
              }
          }
        if ( exist )
            return i;
        else
          return push_back(Point);
      }

    int push_back(const point_t & Point)
      {
        int indice = Vertices.size();
        Pts_Map[(Point)]=indice;
        insertVertex(Point);
        return indice;
      }

    void insert(int  nb_point_begin, 
                int  nb_point_end)
      {
        int max = std::max(nb_point_end,nb_point_begin);
        if (max >= (int)(Edges.size()))
          {
            for(int i =(int)((Edges.size())-1); i < max; ++i)
              createInEdge();
          }

        if ( nb_point_begin < nb_point_end )
          {
            bool isAlready =false;
            for(int i = 0; i < (int)Edges[nb_point_begin].size(); ++i)
              if (Edges[nb_point_begin][i] == nb_point_end)
                {
                  isAlready=true;
                  break;
                }
            if ( !(isAlready) )
              {
                Edges[nb_point_begin].push_back(nb_point_end);
                ++nb_edges;
              }
          }
        else if ( nb_point_begin > nb_point_end )
          {
            bool isAlready =false;
            for(int i = 0; i < (int)Edges[nb_point_end].size(); ++i)
              if (Edges[nb_point_end][i] == nb_point_begin)
                {
                  isAlready=true;
                  break;
                }
            if ( !(isAlready) )
              {
                Edges[nb_point_end].push_back(nb_point_begin);
                ++nb_edges;
              }
          }
      }

    //----------------------------------------------------------------
    // Functions will be useful for the topology of one surface ??
    // (For the next developper)
    //----------------------------------------------------------------

    void graphAddCoord(const coeff_t & value, const int & ind)
      {
        std::map<point_t, int, ltpts<point_t> > auxiliar_map;
        if (Vertices.size() != 0)
          {
            int size = Vertices[0].size();
            assert( ind<(size+1) );
            int indice = Vertices.size();
            
            for(int i = 0; i < indice; ++i)
              {
                if (size == ind)
                  {
                    Vertices[i].resize(size+1);
                    Vertices[i][size] = value;
                    auxiliar_map[(Vertices[i])] = i;
                  }
                else
                  {
                    Vertices[i][ind] = value;
                    auxiliar_map[(Vertices[i])] = i;
                  }
              }
            Pts_Map.clear();
            Pts_Map = auxiliar_map;
          }
      }

    void graphSwap(const int & ind_i, const int & ind_j)
      {
        std::map<point_t, int, ltpts<point_t> > auxiliar_map;
        int indice = Vertices.size();
        for(int i = 0; i < indice; ++i)
          {
            coeff_t aux = Vertices[i][ind_i];
            Vertices[i][ind_i] = Vertices[i][ind_j];
            Vertices[i][ind_j] = aux;
            auxiliar_map[(Vertices[i])] = i;
          }
        Pts_Map.clear();
        Pts_Map = auxiliar_map;
      }


    void rotationGraph(const coeff_t & t)
      {
        std::map<point_t, int, ltpts<point_t> > auxiliar_map;
        if (Vertices.size() != 0)
          {
            int size = Vertices[0].size();
            int indice = Vertices.size();
            for(int i = 0; i < indice; ++i)
              {
                point_t newPoint(size);
                rotation3d(newPoint,Vertices[i],t);
                Vertices[i] = newPoint;
                auxiliar_map[(Vertices[i])] = i;
              }
            Pts_Map.clear();
            Pts_Map = auxiliar_map;
          }
      }

    void graphInsert(const point_graph<C,R,S> & Graph)
      {
        int indice = Graph.Edges.size();
        for(int i = 0; i < indice; ++i)
          {
            int begin = insert(Graph.Vertices[i]);
            for(int j = 0; j < (int)Graph.Edges[i].size(); ++j)
              {
                int end = insert(Graph.Vertices[Graph.Edges[i][j]]);
                push_back(begin,end);
              }
          }
      }

  };
  //--------------------------------------------------------------------
  template<class C, class R>
  std::ostream & operator<<(std::ostream& os, const point_graph<C,R>& g)
  {
    os <<"PointGraph("<<g.Vertices;
    for(unsigned i=0;i<g.Edges.size();i++)
      {
        if(g.Edges[i].size())
          {
            for(unsigned j=0; j<g.Edges[i].size();j++) 
              os <<"; ("<<i<<","<<g.Edges[i][j]<<")";
          }
      }
    os <<")";  return os;
  }
  
  template <class C, class R, class S>
  void print( char* file,
              const point_graph<C,R,S> & G,
              float r = 0.0, float g = 0.0,
              float b = 0.9, float a = 1.,
              float sz= 0.01)
  {
    typedef typename point_graph<C,R,S>::point_t point_t;

    std::vector< std::pair<int,int> > lines;
    for( unsigned  i = 0;  i <  G.Edges.size(); i++ )
      for( unsigned j = 0; j < G.Edges[i].size(); j++ )
        lines.push_back( std::pair<unsigned,unsigned>(i,G.Edges[i][j]) );

    point_t pt1, pt2;
    std::ofstream f;
    f.open (file, std::ofstream::out | std::ofstream::app);

    int size = (int)lines.size();

    // Number of Lines.
    f << size <<  " ";

    // Number of Points.
    f << (2*size) << " ";

    // For the colors.
    f << size <<  std::endl;

    for(int i = 1; i <= size; ++i)
      f<<"2 ";

    f<<std::endl;

    for(int i = 1; i <= size; ++i)
      f<<"1 ";

    f<<std::endl;

    for(int i = 0; i < size; ++i)
      {
        pt1=G.Vertices[lines[i].first];
        pt2=G.Vertices[lines[i].second];
        if(pt1.size()<3)
          f <<pt1[0]<<" "<<pt1[1]<<" "<<0<<" ";
        else
          f <<pt1[0]<<" "<<pt1[1]<<" "<<pt1[2]<<" ";

        if(pt2.size()<3)
          f <<pt2[0]<<" "<<pt2[1]<<" "<<0<<std::endl;
        else
          f <<pt2[0]<<" "<<pt2[1]<<" "<<pt2[2]<<std::endl;
      }
    f<<std::endl;
    for(int i = 0; i < size; ++i)
      f << r << " " << g << " " << b << " " << a  <<"\n";


    /*
    f << G.Vertices.size()  << " " << lines.size() << std::endl;
    for ( unsigned i = 0; i < G.Vertices.size(); i ++ )
      {
        unsigned m = std::min((unsigned)3,G.Vertices[i].size());
        for ( unsigned d = 0; d < m; d++ )
          f << G.Vertices[i][d] << " ";
        for ( unsigned d = m; d < 3; d++ )
          f << "0 ";
        f << std::endl;
      };
    
    f << 2 << " " << lines[0].first << " " << lines[0].second //<< std::endl;
      << " "<< r << " " << g << " " << b << " " << a << std::endl;
    for ( unsigned i = 1; i < lines.size(); i ++)
      f << 2 << " " << lines[i].first << " " << lines[i].second
        << " "<< r << " " << g << " " << b << " " << a << std::endl;
      for(unsigned i=0; i< G.Vertices.size(); i++) 
      { 
      print(f,G.Vertices[i],r,g,b,a,sz);
      }
    */
    f.close(); 
  }

  
  template <class C, class R, class S>
  geomview::ostream & operator<< (geomview::ostream & os, 
                                  const point_graph<C,R,S> & G)
  {

    os<<"{= VECT\n";
    print(os.file,G,os.color.r,os.color.g,os.color.b,1,os.width.sz); 
    os <<"}\n";
    return os;
  }

  template <class C, class R, class S>
  axel::ostream & operator<< (axel::ostream & os, 
                              const point_graph<C,R,S> & G)
  {
    os<<"<curve type=\"mesh\">\n<vect>\nVECT\n";
    print(os.file,G,os.color.r,os.color.g,os.color.b,1,os.width.sz); 
    os<<"</vect>\n</curve>\n";
    return os;
  }


}

//--------------------------------------------------------------------
__END_NAMESPACE_SYNAPS
/*********************************************************************/
#endif // synaps_topology_point_graph_H