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>

# include <realroot/polynomial.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);
    }

    int save() 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();

        return (1);
    }

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

    void precision(int p)
    {
        vw.precision(p);
    }

};

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 VARIANT> inline SELF&
operator<<(SELF& os, const polynomial<C, VARIANT>& mp ) {
    print(os.vw, mp.rep(), polynomial<C, VARIANT>::Ring::vars()); return os;
}


template<class V, class C, class W>
SELF& operator<<(SELF& os, const graphic<C,W>& s)
{
    os <<"<mesh type=\"off\">\n";
    os <<s.nbv() << " " << s.nbe() << " " << s.nbf() <<"\n";

    for(unsigned i =0;i<s.nbv();i++)
        os<<s.vertex_coord(3*i)<<" "<<s.vertex_coord(3*i+1)<<" "<<s.vertex_coord(3*i+2)<<"\n";

    for(unsigned i=0;i<s.nbe() ;i++)
        os << s.edge_index(2*i)  <<" " << s.edge_index(2*i+1) << "\n";

    for(unsigned i=0;i<s.nbf();i++)
        os <<"3 "<< s.face_index(3*i)   <<" "<< s.face_index(3*i+1) <<" "<< s.face_index(3*i+2) <<"\n";
    os <<"</mesh>\n";

    return os;
}



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

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

---