pyx/epsfile.py

   1 # -*- coding: ISO-8859-1 -*-
   2 #
   3 #
   4 # Copyright (C) 2002-2006 Jörg Lehmann <joergl@users.sourceforge.net>
   5 # Copyright (C) 2002-2006 André Wobst <wobsta@users.sourceforge.net>
   6 #
   7 # This file is part of PyX (http://pyx.sourceforge.net/).
   8 #
   9 # PyX is free software; you can redistribute it and/or modify
  10 # it under the terms of the GNU General Public License as published by
  11 # the Free Software Foundation; either version 2 of the License, or
  12 # (at your option) any later version.
  13 #
  14 # PyX is distributed in the hope that it will be useful,
  15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 # GNU General Public License for more details.
  18 #
  19 # You should have received a copy of the GNU General Public License
  20 # along with PyX; if not, write to the Free Software
  21 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  22
  23 import string
  24 import canvas, bbox, pykpathsea, unit, trafo, pswriter
  25
  26 # PostScript-procedure definitions (cf. 5002.EPSF_Spec_v3.0.pdf)
  27 # with important correction in EndEPSF:
  28 #   end operator is missing in the spec!
  29
  30 _BeginEPSF = pswriter.PSdefinition("BeginEPSF", """{
  31   /b4_Inc_state save def
  32   /dict_count countdictstack def
  33   /op_count count 1 sub def
  34   userdict begin
  35   /showpage { } def
  36   0 setgray 0 setlinecap
  37   1 setlinewidth 0 setlinejoin
  38   10 setmiterlimit [ ] 0 setdash newpath
  39   /languagelevel where
  40   {pop languagelevel
  41   1 ne
  42     {false setstrokeadjust false setoverprint
  43     } if
  44   } if
  45 } bind""")
  46
  47 _EndEPSF = pswriter.PSdefinition("EndEPSF", """{
  48   end
  49   count op_count sub {pop} repeat
  50   countdictstack dict_count sub {end} repeat
  51   b4_Inc_state restore
  52 } bind""")
  53
  54
  55 class linefilereader:
  56     """a line by line file reader
  57
  58     This line by line file reader allows for '\n', '\r' and
  59     '\r\n' as line separation characters. Line separation
  60     characters are not modified (binary mode). It implements
  61     a readline, a read and a close method similar to a regular
  62     file object."""
  63
  64     # note: '\n\r' is not considered to be a linebreak as its documented
  65     #       in the DSC spec #5001, while '\n\r' *is* a *single* linebreak
  66     #       according to the EPSF spec #5002
  67
  68     def __init__(self, filename, typicallinelen=257):
  69         """Opens the file filename for reading.
  70
  71         typicallinelen defines the default buffer increase
  72         to find the next linebreak."""
  73
  74         # note: The maximal line size in an EPS is 255 plus the
  75         #       linebreak characters. However, we also handle
  76         #       lines longer than that.
  77
  78         self.file = open(filename, "rb")
  79         self.buffer = ""
  80         self.typicallinelen = typicallinelen
  81
  82     def read(self, count=None, EOFmsg="unexpected end of file"):
  83         """read bytes from the file
  84
  85         count is the number of bytes to be read when set. Then count
  86         is unset, the rest of the file is returned. EOFmsg is used
  87         to raise a IOError, when the end of the file is reached while
  88         reading count bytes or when the rest of the file is empty when
  89         count is unset. When EOFmsg is set to None, less than the
  90         requested number of bytes might be returned."""
  91         if count is not None:
  92             if count > len(self.buffer):
  93                 self.buffer += self.file.read(count - len(self.buffer))
  94             if EOFmsg is not None and len(self.buffer) < count:
  95                 raise IOError(EOFmsg)
  96             result = self.buffer[:count]
  97             self.buffer = self.buffer[count:]
  98             return result
  99         else:
 100             self.buffer += self.file.read()
 101             if EOFmsg is not None and not len(self.buffer):
 102                 raise IOError(EOFmsg)
 103             result = self.buffer
 104             self.buffer = ""
 105             return result
 106
 107     def readline(self, EOFmsg="unexpected end of file"):
 108         """reads a line from the file
 109
 110         Lines are separated by '\n', '\r' or '\r\n'. The line separation
 111         strings are included in the return value. The last line might not
 112         end with an line separation string. Reading beyond the file generates
 113         an IOError with the EOFmsg message. When EOFmsg is None, an empty
 114         string is returned when reading beyond the end of the file."""
 115         EOF = 0
 116         while 1:
 117             crpos = self.buffer.find("\r")
 118             nlpos = self.buffer.find("\n")
 119             if nlpos == -1 and (crpos == -1 or crpos == len(self.buffer) - 1) and not EOF:
 120                 newbuffer = self.file.read(self.typicallinelen)
 121                 if not len(newbuffer):
 122                     EOF = 1
 123                 self.buffer += newbuffer
 124             else:
 125                 eol = len(self.buffer)
 126                 if not eol and EOFmsg is not None:
 127                     raise IOError(EOFmsg)
 128                 if nlpos != -1:
 129                     eol = nlpos + 1
 130                 if crpos != -1 and (nlpos == -1 or crpos < nlpos - 1):
 131                     eol = crpos + 1
 132                 result = self.buffer[:eol]
 133                 self.buffer = self.buffer[eol:]
 134                 return result
 135
 136     def close(self):
 137         "closes the file"
 138         self.file.close()
 139
 140
 141 def _readbbox(filename):
 142     """returns bounding box of EPS file filename"""
 143
 144     file = linefilereader(filename)
 145
 146     # check the %! header comment
 147     if not file.readline().startswith("%!"):
 148         raise IOError("file doesn't start with a '%!' header comment")
 149
 150     bboxatend = 0
 151     # parse the header (use the first BoundingBox)
 152     while 1:
 153         line = file.readline()
 154         if not line:
 155             break
 156         if line.startswith("%%BoundingBox:") and not bboxatend:
 157             values = line.split(":", 1)[1].split()
 158             if values == ["(atend)"]:
 159                 bboxatend = 1
 160             else:
 161                 if len(values) != 4:
 162                     raise IOError("invalid number of bounding box values")
 163                 return bbox.bbox_pt(*map(int, values))
 164         elif (line.rstrip() == "%%EndComments" or
 165               (len(line) >= 2 and line[0] != "%" and line[1] not in string.whitespace)):
 166             # implicit end of comments section
 167             break
 168     if not bboxatend:
 169         raise IOError("no bounding box information found")
 170
 171     # parse the body
 172     nesting = 0 # allow for nested documents
 173     while 1:
 174         line = file.readline()
 175         if line.startswith("%%BeginData:"):
 176             values = line.split(":", 1)[1].split()
 177             if len(values) > 3:
 178                 raise IOError("invalid number of arguments")
 179             if len(values) == 3:
 180                 if values[2] == "Lines":
 181                     for i in xrange(int(values[0])):
 182                         file.readline()
 183                 elif values[2] != "Bytes":
 184                     raise IOError("invalid bytesorlines-value")
 185                 else:
 186                     file.read(int(values[0]))
 187             else:
 188                 file.read(int(values[0]))
 189             line = file.readline()
 190             # ignore tailing whitespace/newline for binary data
 191             if (len(values) < 3 or values[2] != "Lines") and not len(line.strip()):
 192                 line = file.readline()
 193             if line.rstrip() != "%%EndData":
 194                 raise IOError("missing EndData")
 195         elif line.startswith("%%BeginBinary:"):
 196             file.read(int(line.split(":", 1)[1]))
 197             line = file.readline()
 198             # ignore tailing whitespace/newline
 199             if not len(line.strip()):
 200                 line = file.readline()
 201             if line.rstrip() != "%%EndBinary":
 202                 raise IOError("missing EndBinary")
 203         elif line.startswith("%%BeginDocument:"):
 204             nesting += 1
 205         elif line.rstrip() == "%%EndDocument":
 206             if nesting < 1:
 207                 raise IOError("unmatched EndDocument")
 208             nesting -= 1
 209         elif not nesting and line.rstrip() == "%%Trailer":
 210             break
 211
 212     usebbox = None
 213     # parse the trailer (use the last BoundingBox)
 214     line = True
 215     while line:
 216         line = file.readline(EOFmsg=None)
 217         if line.startswith("%%BoundingBox:"):
 218             values = line.split(":", 1)[1].split()
 219             if len(values) != 4:
 220                 raise IOError("invalid number of bounding box values")
 221             usebbox = bbox.bbox_pt(*map(int, values))
 222     if not usebbox:
 223         raise IOError("missing bounding box information in document trailer")
 224     return usebbox
 225
 226
 227 class epsfile(canvas.canvasitem):
 228
 229     """class for epsfiles"""
 230
 231     def __init__(self,
 232                  x, y, filename,
 233                  width=None, height=None, scale=None, align="bl",
 234                  clip=1, translatebbox=1, bbox=None,
 235                  kpsearch=0):
 236         """inserts epsfile
 237
 238         Object for an EPS file named filename at position (x,y). Width, height,
 239         scale and aligment can be adjusted by the corresponding parameters. If
 240         clip is set, the result gets clipped to the bbox of the EPS file. If
 241         translatebbox is not set, the EPS graphics is not translated to the
 242         corresponding origin. If bbox is not None, it overrides the bounding
 243         box in the epsfile itself. If kpsearch is set then filename is searched
 244         using the kpathsea library.
 245         """
 246
 247         self.x_pt = unit.topt(x)
 248         self.y_pt = unit.topt(y)
 249         if kpsearch:
 250             self.filename = pykpathsea.find_file(filename, pykpathsea.kpse_pict_format)
 251         else:
 252             self.filename = filename
 253         self.mybbox = bbox or _readbbox(self.filename)
 254
 255         # determine scaling in x and y direction
 256         self.scalex = self.scaley = scale
 257
 258         if width is not None or height is not None:
 259             if scale is not None:
 260                 raise ValueError("cannot set both width and/or height and scale simultaneously")
 261             if height is not None:
 262                 self.scaley = unit.topt(height)/(self.mybbox.ury_pt-self.mybbox.lly_pt)
 263             if width is not None:
 264                 self.scalex = unit.topt(width)/(self.mybbox.urx_pt-self.mybbox.llx_pt)
 265
 266             if self.scalex is None:
 267                 self.scalex = self.scaley
 268             if self.scaley is None:
 269                 self.scaley = self.scalex
 270
 271         # set the actual width and height of the eps file (after a
 272         # possible scaling)
 273         self.width_pt  = self.mybbox.urx_pt-self.mybbox.llx_pt
 274         if self.scalex:
 275             self.width_pt *= self.scalex
 276
 277         self.height_pt = self.mybbox.ury_pt-self.mybbox.lly_pt
 278         if self.scaley:
 279             self.height_pt *= self.scaley
 280
 281         # take alignment into account
 282         self.align       = align
 283         if self.align[0]=="b":
 284             pass
 285         elif self.align[0]=="c":
 286             self.y_pt -= self.height_pt/2.0
 287         elif self.align[0]=="t":
 288             self.y_pt -= self.height_pt
 289         else:
 290             raise ValueError("vertical alignment can only be b (bottom), c (center), or t (top)")
 291
 292         if self.align[1]=="l":
 293             pass
 294         elif self.align[1]=="c":
 295             self.x_pt -= self.width_pt/2.0
 296         elif self.align[1]=="r":
 297             self.x_pt -= self.width_pt
 298         else:
 299             raise ValueError("horizontal alignment can only be l (left), c (center), or r (right)")
 300
 301         self.clip = clip
 302         self.translatebbox = translatebbox
 303
 304         self.trafo = trafo.translate_pt(self.x_pt, self.y_pt)
 305
 306         if self.scalex is not None:
 307             self.trafo = self.trafo * trafo.scale_pt(self.scalex, self.scaley)
 308
 309         if translatebbox:
 310             self.trafo = self.trafo * trafo.translate_pt(-self.mybbox.llx_pt, -self.mybbox.lly_pt)
 311
 312     def bbox(self):
 313         return self.mybbox.transformed(self.trafo)
 314
 315     def processPS(self, file, writer, context, registry, bbox):
 316         registry.add(_BeginEPSF)
 317         registry.add(_EndEPSF)
 318         bbox += self.bbox()
 319         try:
 320             epsfile=open(self.filename,"rb")
 321         except:
 322             raise IOError, "cannot open EPS file '%s'" % self.filename
 323
 324         file.write("BeginEPSF\n")
 325
 326         if self.clip:
 327             llx_pt, lly_pt, urx_pt, ury_pt = self.mybbox.transformed(self.trafo).highrestuple_pt()
 328             file.write("%g %g %g %g rectclip\n" % (llx_pt, lly_pt, urx_pt-llx_pt, ury_pt-lly_pt))
 329
 330         self.trafo.processPS(file, writer, context, registry, bbox)
 331
 332         file.write("%%%%BeginDocument: %s\n" % self.filename)
 333         file.write(epsfile.read())
 334         file.write("%%EndDocument\n")
 335         file.write("EndEPSF\n")
 336
 337     def processPDF(self, file, writer, context, registry, bbox):
 338         raise RuntimeError("Including EPS files in PDF files not supported")