epswrite.C

Go to the documentation of this file.

#ifdef HAVE_CONFIG_H
#include <tumble-conf.h>
#endif /* HAVE_CONFIG_H */

#include "epswrite.h"

#include "beziermesh.h"
#include "boundarymesh.h"

#include <cstdio>
#include <cstdlib>
#include <iostream>

using namespace std;

#define INCH_TO_PT( inch ) (unsigned)(inch * 72.0 + 0.5)


EPSWrite::EPSWrite(BezierMesh *_bezier_mesh, BoundaryMesh *_bdry_mesh )
{
    if(!_bezier_mesh || !_bdry_mesh){
        cout<<"EPSWrite --- given bad mesh!"<<endl;
        return;
    }

    /* copy over mesh pointers */
    bdry_mesh = _bdry_mesh;
    bezier_mesh = _bezier_mesh;

    /* initialize color mapping */
    default_eps_rgb_map(rgb_map);
    default_eps_grayscale_map(grayscale_map);


    /* get world dimensions */
    Point2D top, bot;
    double height, width;
    bdry_mesh->bbox(top, bot);
    height = top.y() - bot.y();
    width = top.x() - bot.x();

    top.coords[0] += width * 0.01;
    bot.coords[0] -= width * 0.01;
    top.coords[1] += height * 0.01;
    bot.coords[1] -= height * 0.01;

    set_world_view(bot, top);

    /* set defualt drawing */
    set_page_dim(0,0,790,610,5);
    set_border_ink(1, 1.0);
    set_edge_ink(1, 1.0);
    set_bdry_draw(DRAW_OFF);
    set_face_draw(DRAW_OFF);
}

/*
int EPSWrite::load_rgb_map(char *filename)
{
    if( !filename ) return -1;
    char buf[MAX_FILENAME];
    if( add_filename_extension(filename,"tcm",buf, MAX_FILENAME) ) return -1;
    return load_map(rgb_map);
}
*/
/*
int EPSWrite::load_grayscale_map(char *filename)
{
    if( !filename ) return -1;
    char buf[MAX_FILENAME];
    if( add_filename_extension(filename,"tgm",buf, MAX_FILENAME) ) return -1;
    return load_map(grayscale_map);
}
*/

int EPSWrite::map_rgbcolor(int idx, const Color &color)
{
    if( !color.is_valid() ) return -1;
    rgb_map[idx] = color;
    return 0;
}

int EPSWrite::map_grayscale(int idx, float scale)
{
    if( scale < 0.0 || scale > 1.0 ) return -1;
    grayscale_map[idx] = scale;
    return 0;
}

int EPSWrite::set_border_draw(int mode)
{
    if( (mode != DRAW_OFF) &&
         (mode != DRAW_GRAYSCALE) &&
         (mode != DRAW_RGB) ) return -1;
    border.mode = mode;
    return 0;
}

int EPSWrite::set_border_ink(unsigned linewidth, float shade)
{
    if(( shade < 0.0 ) || ( shade > 1.0)) return -1;
    border.mode = DRAW_GRAYSCALE;
    border.linewidth = linewidth;
    border.grayscale = shade;
    return 0;
}

int EPSWrite::set_border_ink(unsigned linewidth, const Color &rgbcolor)
{
    if( !rgbcolor.is_valid() ) return -1;
    border.mode = DRAW_RGB;
    border.linewidth = linewidth;
    border.rgbcolor = rgbcolor;
    return 0;
}

int EPSWrite::set_bdry_draw(int mode)
{
    if( (mode != DRAW_OFF) &&
         (mode != DRAW_GRAYSCALE) &&
         (mode != DRAW_RGB) ) return -1;
    bdry.mode = mode;
    return 0;
}

int EPSWrite::set_bdry_ink(unsigned linewidth, float shade)
{
    if(( shade < 0.0 ) || ( shade > 1.0)) return -1;
    bdry.mode = DRAW_GRAYSCALE;
    bdry.linewidth = linewidth;
    bdry.grayscale = shade;
    return 0;
}

int EPSWrite::set_bdry_ink(unsigned linewidth, const Color &rgbcolor)
{
    if( !rgbcolor.is_valid() ) return -1;
    bdry.mode = DRAW_RGB;
    bdry.linewidth = linewidth;
    bdry.rgbcolor = rgbcolor;
    return 0;
}

int EPSWrite::set_edge_draw(int mode)
{
    if( (mode != DRAW_OFF) &&
         (mode != DRAW_GRAYSCALE) &&
         (mode != DRAW_RGB) ) return -1;
    edges.mode = mode;
    return 0;
}

int EPSWrite::set_edge_ink(unsigned linewidth, float shade)
{
    if(( shade < 0.0 ) || ( shade > 1.0)) return -1;
    edges.mode = DRAW_GRAYSCALE;
    edges.linewidth = linewidth;
    edges.grayscale = shade;
    return 0;
}

int EPSWrite::set_edge_ink(unsigned linewidth, const Color &rgbcolor)
{
    if( !rgbcolor.is_valid() ) return -1;
    edges.mode = DRAW_RGB;
    edges.linewidth = linewidth;
    edges.rgbcolor = rgbcolor;
    return 0;
}

int EPSWrite::set_face_draw(int mode)
{
    if( (mode != DRAW_OFF) &&
         (mode != DRAW_GRAYSCALE) &&
         (mode != DRAW_RGB) ) return -1;
    shade_face_mode = mode;
    return 0;
}

int EPSWrite::set_page_dim(unsigned xmin, unsigned ymin, unsigned xmax, unsigned ymax, unsigned margin)
{
    if( ( xmin >= xmax ) || ( ymin >= ymax ) ) return -1;
    if( (2*margin >= xmax - xmin) || (2*margin >= ymax - ymin) ) return -1;

    page_bot.x = xmin;
    page_bot.y = ymin;
    page_top.x = xmax;
    page_top.y = ymax;
    page_width = xmax - xmin;
    page_height = ymax - ymin;
    margin_width = margin;

    canvas_bot.x = xmin + margin;
    canvas_bot.y = ymin + margin;
    canvas_top.x = xmax - margin;
    canvas_top.y = ymax - margin;
    canvas_width = canvas_top.x - canvas_bot.x;
    canvas_height = canvas_top.y - canvas_bot.y;
    project_to_canvas();
    return 0;
}

int EPSWrite::set_page_dim_inch(float xmin, float ymin, float xmax, float ymax, float margin)
{
    if( (xmin < 0.0) || (ymin < 0.0) ||(xmax < 0.0) || (ymax < 0.0) || (margin < 0.0) ) return -1;
    return set_page_dim(INCH_TO_PT(xmin), INCH_TO_PT(ymin), INCH_TO_PT(xmax), INCH_TO_PT(ymax), INCH_TO_PT(margin));
}

int EPSWrite::set_world_view(const Point2D &bot, const Point2D &top)
{
    if((bot.x() >= top.x()) || (bot.y() >= top.y())) return -1;
    world_bot = bot;
    world_top = top;
    world_width  = world_top.x() - world_bot.x();
    world_height = world_top.y() - world_bot.y();
    project_to_canvas();
    return 0;
}

void EPSWrite::project_to_canvas()
{
    Point2D world_center;
    double world_ratio = world_width / world_height;
    double canvas_ratio = (double)canvas_width / (double)canvas_height;
    double ny, nx;
    world_center.coords[0] = world_bot.x() + world_width * 0.5;
    world_center.coords[1] = world_bot.y() + world_height * 0.5;
    //cout<<"world ratio: "<<world_ratio<<"  canvas_ratio: "<<canvas_ratio<<endl;
    //cout<<"world center: "<<world_center<<endl;

    if(world_ratio > canvas_ratio){
        ny = world_width * (1.0 / canvas_ratio) * 0.5;
        view_top.assign(world_top.x(), world_center.y() + ny);
        view_bot.assign(world_bot.x(), world_center.y() - ny);
    }
    else{
        nx = world_height * canvas_ratio * 0.5;
        view_top.assign(world_center.x() + nx, world_top.y());
        view_bot.assign(world_center.x() - nx, world_bot.y());
    }
    view_width = view_top.x() - view_bot.x();
    view_height = view_top.y() - view_bot.y();
    //cout<<"view top: "<<view_top<<"   view bot: "<<view_bot<<endl;
}

int EPSWrite::write(char *epsfilename)
{
    if(!bdry_mesh || !bezier_mesh) return -1;
    if(!epsfilename) return -1;

    epsfile = fopen( epsfilename, "w" );
    if(!epsfile) return -1;

    /* initialize eps */
    print_header();
    set_options();
    set_clip();

    cout<<"World Top:"<<world_top<<" World Bot:"<<world_bot<<endl;
    cout<<"World Width:"<<world_width<<" World Height:"<<world_height<<endl;
    cout<<"Page Width:"<<page_width<< " Page Height:"<<page_height<<endl;
    cout<<"Canvas Width:"<<canvas_width<<" Canvas Height:"<<canvas_height<<endl;

    /* draw objects */
    if(shade_face_mode != DRAW_OFF) draw_faces();
    if(edges.mode != DRAW_OFF)      draw_edges();
    if(bdry.mode != DRAW_OFF)       draw_bdry();
    if(border.mode != DRAW_OFF)     draw_border();

    /* close up file */
    if( !fclose( epsfile ) ) return -1;
    return 0;
}

void EPSWrite::draw_bdry()
{
    set_ink(bdry);
    BezierMesh::Bezier_Edge_Hash_T::const_iterator i;
    for(i = bezier_mesh->get_edges_begin(); 
        i != bezier_mesh->get_edges_end(); ++i) {
        if( (*i)->is_boundary() ) draw_edge(*i);
    }
}

void EPSWrite::draw_faces()
{
    BezierMesh::Bezier_Face_Hash_T::const_iterator i;
    for(i = bezier_mesh->get_faces_begin(); 
        i != bezier_mesh->get_faces_end(); ++i) {
        shade_triangle(*i);
    }
}

void EPSWrite::draw_edges()
{
    set_ink(edges);
    BezierMesh::Bezier_Edge_Hash_T::const_iterator i;
    for(i = bezier_mesh->get_edges_begin(); 
        i != bezier_mesh->get_edges_end(); ++i) {
        draw_edge(*i);
    }
}

PSCoord EPSWrite::convert_coords(const Point2D &p)
{
    PSCoord q;
    q.x = canvas_bot.x + (unsigned)( ( (double)canvas_width  * (p.x() - view_bot.x()) / view_width  ) + 0.5);
    q.y = canvas_bot.y + (unsigned)( ( (double)canvas_height * (p.y() - view_bot.y()) / view_height ) + 0.5);
    return q;
}

void EPSWrite::print_header()
{

    fprintf(epsfile,"%%!PS-Adobe-3.0 EPSF-3.0\n");
    fprintf(epsfile,"%%%%Pages: 0\n");
    fprintf(epsfile,"%%%%BoundingBox: %u %u %u %u\n", page_bot.x, page_bot.y, page_top.x, page_top.y);
    fprintf(epsfile,"%%%%Creator: TUMBLE\n");
    fprintf(epsfile,"%%%%EndComments\n");
}

void EPSWrite::set_options()
{
    fprintf(epsfile,"%% setting global options\n");
    fprintf(epsfile,"1 setlinecap\n");
    fprintf(epsfile,"1 setlinejoin\n\n");
}

void EPSWrite::set_clip()
{
    fprintf(epsfile,"%%clip the bounding box\n");
    fprintf(epsfile,"newpath\n");
    fprintf(epsfile,"%u %u moveto\n", canvas_bot.x, canvas_bot.y);
    fprintf(epsfile,"%u %u lineto\n", canvas_top.x, canvas_bot.y);
    fprintf(epsfile,"%u %u lineto\n", canvas_top.x, canvas_top.y);
    fprintf(epsfile,"%u %u lineto\n", canvas_bot.x, canvas_top.y);
    fprintf(epsfile,"closepath\n");
    fprintf(epsfile,"clip\n\n");
}


void EPSWrite::set_ink(const PSDrawMode &mode)
{
    fprintf(epsfile,"%%set ink style\n");
    fprintf(epsfile,"%u setlinewidth\n",mode.linewidth);
    if(mode.mode == DRAW_GRAYSCALE) {
        fprintf(epsfile,"/DeviceGray setcolorspace\n");
        fprintf(epsfile,"%f setgray\n", mode.grayscale);
    }
    else if(mode.mode == DRAW_RGB) {
        fprintf(epsfile,"/DeviceRGB setcolorspace\n");
        fprintf(epsfile,"%f %f %f setrgbcolor\n", mode.rgbcolor.R(), mode.rgbcolor.G(), mode.rgbcolor.B());
    }
}

void EPSWrite::draw_border()
{
    unsigned a = (unsigned) ((double)border.linewidth / 2.0);
    set_ink(border);
    fprintf(epsfile,"%%draw the border\n");
    fprintf(epsfile,"newpath\n");
    fprintf(epsfile,"%u %u moveto\n", canvas_bot.x + a, canvas_bot.y + a);
    fprintf(epsfile,"%u %u lineto\n", canvas_top.x - a, canvas_bot.y + a);
    fprintf(epsfile,"%u %u lineto\n", canvas_top.x - a, canvas_top.y - a);
    fprintf(epsfile,"%u %u lineto\n", canvas_bot.x + a, canvas_top.y - a);
    fprintf(epsfile,"closepath\n");
    fprintf(epsfile,"stroke\n\n");
}

void EPSWrite::draw_edge(BezierEdge *e)
{
    PSCoord p0, p1, p2, p3;

    p0 = convert_coords( e->get_cp(0) );
    p1 = convert_coords( e->get_cp(0) * 1.0/3.0 + e->get_cp(1) * 2.0/3.0);
    p2 = convert_coords( e->get_cp(2) * 1.0/3.0 + e->get_cp(1) * 2.0/3.0);
    p3 = convert_coords( e->get_cp(2) );

    fprintf(epsfile,"%%draw edge\n");
    fprintf(epsfile,"newpath\n");
    fprintf(epsfile,"%u %u moveto\n",p0.x, p0.y);
    fprintf(epsfile,"%u %u %u %u %u %u curveto\n",p1.x, p1.y, p2.x, p2.y, p3.x, p3.y);
    fprintf(epsfile,"closepath\n");
    fprintf(epsfile,"stroke\n\n");
}

void EPSWrite::shade_triangle(BezierTriangle *t)
{
    PSDrawMode mode;
    PSCoord p0, p1, p2, p3;
    BezierEdge *e;
    BezierVertex *v, *vold;
    BezierTuple tup = bezier_mesh->get_tuple(t);

    mode.mode = shade_face_mode;
    mode.linewidth = 1;
    mode.grayscale = grayscale_map[ t->get_color() ];
    mode.rgbcolor  = rgb_map[ t->get_color() ];
    set_ink( mode );

    fprintf(epsfile,"%%shade triangle\n");
    fprintf(epsfile,"newpath\n");
    p0 = convert_coords( tup.e->get_cp(0) );
    fprintf(epsfile,"%u %u moveto\n",p0.x, p0.y);

    for(int i =0; i < 3; i++){
        e = tup.e;
        vold = tup.v;
        tup = bezier_mesh->Switch(0, tup);
        v = tup.v;
        p1 = convert_coords( vold->get_cp() * 1.0/3.0 + e->get_cp(1) * 2.0/3.0 );
        p2 = convert_coords( v->get_cp() * 1.0/3.0 + e->get_cp(1) * 2.0/3.0 );
        p3 = convert_coords( v->get_cp() );

        fprintf(epsfile,"%u %u %u %u %u %u curveto\n", p1.x, p1.y, p2.x, p2.y, p3.x, p3.y);
        tup = bezier_mesh->Switch( 1, tup );
    }
    fprintf(epsfile,"closepath\n");

    /* incase no edges are displayed make sure to fill in any gaps with a perimiter stroke command */
    if( edges.mode == DRAW_OFF ){
        fprintf(epsfile,"gsave\n");
        fprintf(epsfile,"stroke\n");
        fprintf(epsfile,"grestore\n");
    }
    fprintf(epsfile,"fill\n\n");
}

---