/Users/mourrain/Devel/mmx/shape/include/shape/viewer_axel.hpp

Go to the documentation of this file.

/*********************************************************************
*      This file is part of the source code of AXEL library          *
*   Author(s): G. Gatellier                                          *
*              B. Mourrain, GALAAD, INRIA                            *
**********************************************************************/
# ifndef shape_axel_ostream_hpp
# define shape_axel_ostream_hpp
/********************************************************************/
# include <stdlib.h>
# include <string.h>
# include <sstream>
# include <fstream>
# include <shape/color.hpp>
# include <shape/width.hpp>
# include <shape/bounding_box.hpp>
# include <shape/graphic.hpp>

# define TMPL template<class V>
# define SELF viewer<axel,V>
# define BoundingBox bounding_box<double,V>
/*********************************************************************/
namespace mmx {
  namespace shape {
//====================================================================
struct axel {};

template<class O, class V=default_env> struct viewer;


template<class V> 
struct viewer<axel,V> : public BoundingBox 
{
    typedef mmx::shape::color< REF_OF(V) > Color;

    char *file;
    std::stringstream vw;

    Color color;
    Width width;

    viewer(): file((char*)"tmp.axl"), vw(std::ofstream::out | std::ofstream::app), color(0.75,0.75,0.75) {}

    viewer(char *fic) : file(fic), vw(std::ofstream::out | std::ofstream::app), color(0.75,0.75,0.75) {}

  
    viewer(const SELF& axl)
      :BoundingBox(axl.xmin(),axl.xmax(),axl.ymin(),axl.ymax(), axl.zmin(), axl.zmax()),  
       file(axl.file), vw(axl.vw.str(), std::ofstream::out | std::ofstream::app),
       color(axl.color) {}
    

    ~viewer() {}

    SELF& set_color(double r, double g, double b)
    {
      color=Color(r,g,b); return *this;
    }

    SELF& set_width(const shape::Width & w)
    {
      width=w; return *this;
    }

    SELF& operator=(const SELF & axl)
    {
      this->BoundingBox::operator=(axl);
      file=axl.file; vw<<axl.vw.str(); 
      color=axl.color;
      return *this;
    }


    void init() {
      //        std::ofstream f(file,std::ios::out);
    }

    int view() const
      {
        std::ofstream f(file, std::ofstream::out);
        if( !f )
          {
            std::cerr << "Creation refused" << std::endl;
            return (0);
          }
        f << "<axl>"<<std::endl;
        f << vw.str();
        f << "</axl>"<<std::endl;
        f.close();

        char cmd[1000];
        strcpy(cmd,"axel \0");
        strcat(cmd,file);                       \
        strcat(cmd," &");
        return system(cmd);
      }

    void view(char* opt) const
      {
        std::ofstream f(file, std::ofstream::out | std::ofstream::app);
        f << "</axl>\n";
        f.close();

        char cmd[1000];
        strcpy(cmd,"axel \0");
        strcat(cmd,file);
        strcat(cmd," ");        \
        strcat(cmd,opt);
        strcat(cmd," &");
        system(cmd);
      }
  };

  TMPL inline std::ostream& operator<<(std::ostream& os, const SELF & g)
  {
    os <<"Axel("<<g.file<<")"; return os;
  }

  TMPL inline SELF& operator<<(SELF & os, char s)
  {
    os.vw.put(s); return os;
  }

  TMPL inline SELF& operator<<(SELF & os, const char* s)
  {
    os.vw<<s; return os;
  }

  TMPL inline SELF& operator<<(SELF & os, const std::string& s)
  {
    os.vw<<s; return os;
  }

  TMPL inline SELF& operator<<(SELF& os, unsigned s)
  {
    os.vw<<s;return os;
  }

  TMPL inline SELF& operator<<(SELF& os, int s)
  {
    os.vw<<s;return os;
  }

  TMPL inline SELF& operator<<(SELF & os, double s)
  {
    os.vw<<s;return os;
  }

  TMPL SELF& 
  operator<<(SELF& os, const BoundingBox& bx) {
    for(unsigned i=0;i<3;i++)
      for(unsigned j=0;j<2;j++)
        os(i,j)=bx(i,j);
    return os;
  }

  TMPL inline SELF& 
  operator<<(SELF& os, const typename SELF::Color& c) {
    os.color.r=c.r;
    os.color.g=c.g;
    os.color.b=c.b;
    return os;
  }

  template<class V, class C, class W>
  SELF& operator<<(SELF& os, const graphic<C,W>& s)
  {
    if (s.type == 0) {
      os <<"<pointset  size=\""<<s.nbv<<"\" color=\"rgb\">\n";
      for(unsigned i =0;i<s.nbv;i++)
        os<<s.vertices[3*i]<<" "<<s.vertices[3*i+1]<<" "<<s.vertices[3*i+2]
          <<" 255 75 75\n";
      os <<"</pointset>\n";
    } else if (s.type == 1) {
      typedef fxv<double,3> point;
      point * P = (point*)(s.vertices);
      int   * Vs = (s.indices);
      os <<"<curve type=\"mesh\">\n<vect>\n";
      os <<"VECT\n";
      os <<s.nbi/2 << " " << s.nbi <<" "<<s.nbi/2<<"\n";
      for(unsigned i =0;i<s.nbi/2;i++)
        os<<"2 "; os<<"\n";
      for(unsigned i =0;i<s.nbi/2;i++)
        os<<"1 "; os<<"\n";
      
      for(unsigned i=0;i<s.nbi/2 ;i++) {
        os << P[Vs[2*i]][0]   <<" "<< P[Vs[2*i]][1] <<" "<< P[Vs[2*i]][2] <<" ";
        os << P[Vs[2*i+1]][0] <<" "<< P[Vs[2*i+1]][1] <<" "<< P[Vs[2*i+1]][2];
        os << "\n";
      }
      for(unsigned i =0;i<s.nbi/2;i++)
        os<<os.color.r<<" "<<os.color.g<<" "<<os.color.b<<" "<<"1\n";
      os <<"</vect>\n</curve>\n";
    } else if (s.type == 2) {
      std::cout<<"Surface"<<std::endl;
      typedef fxv<double,3> point;
      int   * Vs = (s.indices);
      os <<"<surface type=\"mesh\">\n<off>\n";
      os <<s.nbv<<" "<<s.nbi/3<<" 0\n";
      for(unsigned i=0;i<s.nbv;i++)
        os<<s.vertices[3*i]<<" "<<s.vertices[3*i+1]<<" "<<s.vertices[3*i+2] <<"\n";
      
      for(unsigned i=0;i<s.nbi/3;i++)
        os <<"3 "<< Vs[3*i]   <<" "<< Vs[3*i+1] <<" "<< Vs[3*i+2] <<"\n";
      os <<"</off>\n</surface>\n";
    }
    return os;
}



//====================================================================
} //namespace shape
} //namespace mmx 

# undef TMPL
# undef SELF
# undef BoundingBox
# endif // shape_axel_hpp