libMesh
postscript_io.C
Go to the documentation of this file.
1 // The libMesh Finite Element Library.
2 // Copyright (C) 2002-2017 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
3 
4 // This library is free software; you can redistribute it and/or
5 // modify it under the terms of the GNU Lesser General Public
6 // License as published by the Free Software Foundation; either
7 // version 2.1 of the License, or (at your option) any later version.
8 
9 // This library is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 // Lesser General Public License for more details.
13 
14 // You should have received a copy of the GNU Lesser General Public
15 // License along with this library; if not, write to the Free Software
16 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 
18 // C++ includes
19 #include <ctime>
20 #include <iomanip>
21 #include <iostream>
22 #include <sstream>
23 
24 // Local includes
25 #include "libmesh/postscript_io.h"
26 #include "libmesh/mesh_tools.h"
27 #include "libmesh/elem.h"
28 
29 namespace libMesh
30 {
31 
32 
33 // Transformation map between monomial (physical space) and Bezier bases.
34 const float PostscriptIO::_bezier_transform[3][3] =
35  {
36  {-1.f/6.f, 1.f/6.f, 1.},
37  {-1.f/6.f, 0.5, 1.f/6.f},
38  {0., 1., 0.}
39  };
40 
41 
43  MeshOutput<MeshBase> (mesh_in),
44  shade_value(0.0),
45  line_width(0.5),
46  //_M(3,3),
47  _offset(0., 0.),
48  _scale(1.0),
49  _current_point(0., 0.)
50 {
51  // This code is still undergoing some development.
52  libmesh_experimental();
53 
54  // Entries of transformation matrix from physical to Bezier coords.
55  // _M(0,0) = -1./6.; _M(0,1) = 1./6.; _M(0,2) = 1.;
56  // _M(1,0) = -1./6.; _M(1,1) = 0.5 ; _M(1,2) = 1./6.;
57  // _M(2,0) = 0. ; _M(2,1) = 1. ; _M(2,2) = 0.;
58 
59  // Make sure there is enough room to store Bezier coefficients.
60  _bezier_coeffs.resize(3);
61 }
62 
63 
64 
66 {
67 }
68 
69 
70 
71 void PostscriptIO::write (const std::string & fname)
72 {
73  // We may need to gather a DistributedMesh to output it, making that
74  // const qualifier in our constructor a dirty lie
75  MeshSerializer serialize(const_cast<MeshBase &>(this->mesh()), !_is_parallel_format);
76 
77  if (this->mesh().processor_id() == 0)
78  {
79  // Get a constant reference to the mesh.
80  const MeshBase & the_mesh = MeshOutput<MeshBase>::mesh();
81 
82  // Only works in 2D
83  libmesh_assert_equal_to (the_mesh.mesh_dimension(), 2);
84 
85  // Create output file stream.
86  // _out is now a private member of the class.
87  _out.open(fname.c_str());
88 
89  // Make sure it opened correctly
90  if (!_out.good())
91  libmesh_file_error(fname.c_str());
92 
93  // The mesh bounding box gives us info about what the
94  // Postscript bounding box should be.
96 
97  // Add a little extra padding to the "true" bounding box so
98  // that we can still see the boundary
99  const Real percent_padding = 0.01;
100  const Real dx=bbox.second(0)-bbox.first(0); libmesh_assert_greater (dx, 0.0);
101  const Real dy=bbox.second(1)-bbox.first(1); libmesh_assert_greater (dy, 0.0);
102 
103  const Real x_min = bbox.first(0) - percent_padding*dx;
104  const Real y_min = bbox.first(1) - percent_padding*dy;
105  const Real x_max = bbox.second(0) + percent_padding*dx;
106  const Real y_max = bbox.second(1) + percent_padding*dy;
107 
108  // Width of the output as given in postscript units.
109  // This usually is given by the strange unit 1/72 inch.
110  // A width of 300 represents a size of roughly 10 cm.
111  const Real width = 300;
112  _scale = width / (x_max-x_min);
113  _offset(0) = x_min;
114  _offset(1) = y_min;
115 
116  // Header writing stuff stolen from Deal.II
117  std::time_t time1= std::time (0);
118  std::tm * time = std::localtime(&time1);
119  _out << "%!PS-Adobe-2.0 EPSF-1.2" << '\n'
120  //<< "%!PS-Adobe-1.0" << '\n' // Lars' PS version
121  << "%%Filename: " << fname << '\n'
122  << "%%Title: LibMesh Output" << '\n'
123  << "%%Creator: LibMesh: A C++ finite element library" << '\n'
124  << "%%Creation Date: "
125  << time->tm_year+1900 << "/"
126  << time->tm_mon+1 << "/"
127  << time->tm_mday << " - "
128  << time->tm_hour << ":"
129  << std::setw(2) << time->tm_min << ":"
130  << std::setw(2) << time->tm_sec << '\n'
131  << "%%BoundingBox: "
132  // lower left corner
133  << "0 0 "
134  // upper right corner
135  << static_cast<unsigned int>( rint((x_max-x_min) * _scale ))
136  << ' '
137  << static_cast<unsigned int>( rint((y_max-y_min) * _scale ))
138  << '\n';
139 
140  // define some abbreviations to keep
141  // the output small:
142  // m=move turtle to
143  // l=define a line
144  // s=set rgb color
145  // sg=set gray value
146  // lx=close the line and plot the line
147  // lf=close the line and fill the interior
148  _out << "/m {moveto} bind def" << '\n'
149  << "/l {lineto} bind def" << '\n'
150  << "/s {setrgbcolor} bind def" << '\n'
151  << "/sg {setgray} bind def" << '\n'
152  << "/cs {curveto stroke} bind def" << '\n'
153  << "/lx {lineto closepath stroke} bind def" << '\n'
154  << "/lf {lineto closepath fill} bind def" << '\n';
155 
156  _out << "%%EndProlog" << '\n';
157  // << '\n';
158 
159  // Set line width in the postscript file.
160  _out << line_width << " setlinewidth" << '\n';
161 
162  // Set line cap and join options
163  _out << "1 setlinecap" << '\n';
164  _out << "1 setlinejoin" << '\n';
165 
166  // allow only five digits for output (instead of the default
167  // six); this should suffice even for fine grids, but reduces
168  // the file size significantly
169  _out << std::setprecision (5);
170 
171  // Loop over the active elements, draw lines for the edges. We
172  // draw even quadratic elements with straight sides, i.e. a straight
173  // line sits between each pair of vertices. Also we draw every edge
174  // for an element regardless of the fact that it may overlap with
175  // another. This would probably be a useful optimization...
176  for (const auto & elem : the_mesh.active_element_ptr_range())
177  this->plot_linear_elem(elem);
178 
179  // Issue the showpage command, and we're done.
180  _out << "showpage" << std::endl;
181 
182  } // end if (this->mesh().processor_id() == 0)
183 }
184 
185 
186 
187 
188 
189 
191 {
192  // Clear the string contents. Yes, this really is how you do that...
193  _cell_string.str("");
194 
195  // The general strategy is:
196  // 1.) Use m := {moveto} to go to vertex 0.
197  // 2.) Use l := {lineto} commands to draw lines to vertex 1, 2, ... N-1.
198  // 3a.) Use lx := {lineto closepath stroke} command at vertex N to draw the last line.
199  // 3b.) lf := {lineto closepath fill} command to shade the cell just drawn
200  // All of our 2D elements' vertices are numbered in counterclockwise order,
201  // so we can just draw them in the same order.
202 
203  // 1.)
204  _current_point = (elem->point(0) - _offset) * _scale;
205  _cell_string << _current_point(0) << " " << _current_point(1) << " "; // write x y
206  _cell_string << "m ";
207 
208  // 2.)
209  const unsigned int nv=elem->n_vertices();
210  for (unsigned int v=1; v<nv-1; ++v)
211  {
212  _current_point = (elem->point(v) - _offset) * _scale;
213  _cell_string << _current_point(0) << " " << _current_point(1) << " "; // write x y
214  _cell_string << "l ";
215  }
216 
217  // 3.)
218  _current_point = (elem->point(nv-1) - _offset) * _scale;
219  _cell_string << _current_point(0) << " " << _current_point(1) << " "; // write x y
220 
221  // We draw the shaded (interior) parts first, if applicable.
222  if (shade_value > 0.0)
223  _out << shade_value << " sg " << _cell_string.str() << "lf\n";
224 
225  // Draw the black lines (I guess we will always do this)
226  _out << "0 sg " << _cell_string.str() << "lx\n";
227 }
228 
229 
230 
231 
233 {
234  for (auto ns : elem->side_index_range())
235  {
236  // Build the quadratic side
238 
239  // Be sure it's quadratic (Edge2). Eventually we could
240  // handle cubic elements as well...
241  libmesh_assert_equal_to ( side->type(), EDGE3 );
242 
243  _out << "0 sg ";
244 
245  // Move to the first point on this side.
246  _current_point = (side->point(0) - _offset) * _scale;
247  _out << _current_point(0) << " " << _current_point(1) << " "; // write x y
248  _out << "m ";
249 
250  // Compute _bezier_coeffs for this edge. This fills up
251  // the _bezier_coeffs vector.
252  this->_compute_edge_bezier_coeffs(side.get());
253 
254  // Print curveto path to file
255  for (std::size_t i=0; i<_bezier_coeffs.size(); ++i)
256  _out << _bezier_coeffs[i](0) << " " << _bezier_coeffs[i](1) << " ";
257  _out << " cs\n";
258  }
259 }
260 
261 
262 
263 
265 {
266  // I only know how to do this for an Edge3!
267  libmesh_assert_equal_to (elem->type(), EDGE3);
268 
269  // Get x-coordinates into an array, transform them,
270  // and repeat for y.
271  float phys_coords[3] = {0., 0., 0.};
272  float bez_coords[3] = {0., 0., 0.};
273 
274  for (unsigned int i=0; i<2; ++i)
275  {
276  // Initialize vectors. Physical coordinates are initialized
277  // by their postscript-scaled values.
278  for (unsigned int j=0; j<3; ++j)
279  {
280  phys_coords[j] = static_cast<float>
281  ((elem->point(j)(i) - _offset(i)) * _scale);
282  bez_coords[j] = 0.; // zero out result vector
283  }
284 
285  // Multiply matrix times vector
286  for (unsigned int j=0; j<3; ++j)
287  for (unsigned int k=0; k<3; ++k)
288  bez_coords[j] += _bezier_transform[j][k]*phys_coords[k];
289 
290  // Store result in _bezier_coeffs
291  for (unsigned int j=0; j<3; ++j)
292  _bezier_coeffs[j](i) = phys_coords[j];
293  }
294 }
295 
296 } // namespace libMesh
void plot_linear_elem(const Elem *elem)
Draws an element with straight lines.
virtual UniquePtr< Elem > build_side_ptr(const unsigned int i, bool proxy=true)=0
virtual ~PostscriptIO()
Destructor.
Definition: postscript_io.C:65
std::ofstream _out
Output file stream which will be opened when the file name is known.
Point _offset
Amount to add to every (x,y) point to place it in Postscript coordinates.
virtual ElemType type() const =0
void _compute_edge_bezier_coeffs(const Elem *elem)
Given a quadratic edge Elem which lies in the x-y plane, computes the Bezier coefficients.
libMesh::BoundingBox create_bounding_box(const MeshBase &mesh)
The same functionality as the deprecated MeshTools::bounding_box().
Definition: mesh_tools.C:329
const bool _is_parallel_format
Flag specifying whether this format is parallel-capable.
Definition: mesh_output.h:141
IntRange< unsigned short > side_index_range() const
Definition: elem.h:2083
unsigned short int side
Definition: xdr_io.C:49
This is the base class from which all geometric element types are derived.
Definition: elem.h:89
virtual SimpleRange< element_iterator > active_element_ptr_range()=0
const MeshBase & mesh() const
This class defines an abstract interface for Mesh output.
Definition: mesh_output.h:53
The libMesh namespace provides an interface to certain functionality in the library.
Point _current_point
A point object used for temporary calculations.
static const float _bezier_transform[3][3]
Coefficients of the transformation from physical-space edge coordinates to Bezier basis coefficients...
This is the MeshBase class.
Definition: mesh_base.h:68
std::unique_ptr< T > UniquePtr
Definition: auto_ptr.h:46
Real shade_value
Controls greyscale shading of cells.
Definition: postscript_io.h:80
virtual void write(const std::string &) libmesh_override
This method implements writing a mesh to a specified file.
Definition: postscript_io.C:71
PostscriptIO(const MeshBase &mesh)
Constructor.
Definition: postscript_io.C:42
Real line_width
Control the thickness of the lines used.
Definition: postscript_io.h:88
Real _scale
Amount by which to stretch each point to place it in Postscript coordinates.
std::vector< Point > _bezier_coeffs
Vector containing 3 points corresponding to Bezier coefficients, as computed by _compute_edge_bezier_...
std::ostringstream _cell_string
Drawing style-independent data for a single cell.
Defines a Cartesian bounding box by the two corner extremum.
Definition: bounding_box.h:40
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
const Point & point(const unsigned int i) const
Definition: elem.h:1809
Temporarily serialize a DistributedMesh for output; a distributed mesh is allgathered by the MeshSeri...
unsigned int mesh_dimension() const
Definition: mesh_base.C:148
void plot_quadratic_elem(const Elem *elem)
Draws an element with Bezier curves.
virtual unsigned int n_vertices() const =0
processor_id_type processor_id()
Definition: libmesh_base.h:96