export_eps.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// includes, FEAT
#include <kernel/geometry/conformal_mesh.hpp>
#include <kernel/util/assertion.hpp>
#include <kernel/util/exception.hpp>
#include <kernel/util/math.hpp>
 
// includes, system
#include <iostream>
#include <fstream>
 
namespace FEAT
{
  namespace Geometry
  {
    class ExportEPS
    {
    public:
      template<typename Shape_, typename DataType_>
      static void write(
        std::ostream& os,
        const ConformalMesh<Shape_, 2, DataType_>& mesh,
        const double width = 100.0,
        const double height = 100.0,
        const double stroke = 0.1,
        const double extra = 0.0)
      {
        XASSERTM(width  >= 1.0, "invalid bounding box width");
        XASSERTM(height >= 1.0, "invalid bounding box height");
        XASSERTM(stroke > 0.01, "invalid stroke width");
        XASSERTM(extra >= 0.0, "invalid bounding box extra");
 
        // get vertices-at-edge
        const auto& vtx = mesh.get_vertex_set();
        const auto& idx = mesh.template get_index_set<1,0>();
 
        // compute minimal and maximal x/y coords
        DataType_ x_min, x_max, y_min, y_max;
        x_min = x_max = vtx[0][0];
        y_min = y_max = vtx[0][1];
        for(Index i(1); i < vtx.get_num_vertices(); ++i)
        {
          const auto& v = vtx[i];
          Math::minimax(v[0], x_min, x_max);
          Math::minimax(v[1], y_min, y_max);
        }
 
        // compute x/y scale:
        // Note: PostScript units are "points"
        // 1 inch = 25.4 millimeters
        // 1 inch = 72 points
        // ==> 1 millimeter = 72 / 25.4 points
        const double x_sc = (72.0 / 25.4) * width  / double(x_max - x_min);
        const double y_sc = (72.0 / 25.4) * height / double(y_max - y_min);
 
        // compute scaling factor
        const double scale = Math::min(x_sc, y_sc);
 
        // compute bounding box (rounding up)
        const int box_x = int(scale * double(x_max - x_min) + 2.0*extra) + 1;
        const int box_y = int(scale * double(y_max - y_min) + 2.0*extra) + 1;
 
        // compute offset from extra
        const double box_o = 72.0 * extra / 25.4;
 
        // write EPS header
        os << "%!!PS-Adobe-3.0 EPSF-3.0\n";
 
        // write bounding box
        os << "%%BoundingBox: 0 0 " << box_x << " " << box_y << '\n';
 
        // set stroke width
        os << (72.0 * stroke / 25.4) << " setlinewidth\n";
 
        // begin a new path
        os << "newpath\n";
 
        // write all edges
        for(Index i(0); i < idx.get_num_entities(); ++i)
        {
          // get the vertices
          const auto& v0 = vtx[idx[i][0]];
          const auto& v1 = vtx[idx[i][1]];
 
          // transform vertices
          double v0x = box_o + (double(v0[0]) - x_min) * scale;
          double v0y = box_o + (double(v0[1]) - y_min) * scale;
          double v1x = box_o + (double(v1[0]) - x_min) * scale;
          double v1y = box_o + (double(v1[1]) - y_min) * scale;
 
          // write vertices
          os << v0x << " " << v0y << " moveto\n";
          os << v1x << " " << v1y << " lineto\n";
        }
 
        // draw path and show page
        os << "stroke\n";
        os << "showpage\n";
      }
 
      template<typename Shape_, typename DataType_>
      static void write(
        const String& filename,
        const ConformalMesh<Shape_, 2, DataType_>& mesh,
        const double width = 100.0,
        const double height = 100.0,
        const double stroke = 0.1,
        const double extra = 0.0)
      {
        std::ofstream ofs(filename);
        if(!ofs.is_open() || !ofs.good())
          throw FileError(String("Failed to open output file: ") + filename);
        write(ofs, mesh, width, height, stroke, extra);
        ofs.close();
      }
    };
  } // namespace Geometry
} // namespace FEAT