pyx/deco.py

   1 #!/usr/bin/env python
   2 # -*- coding: ISO-8859-1 -*-
   3 #
   4 #
   5 # Copyright (C) 2002-2004 Jörg Lehmann <joergl@users.sourceforge.net>
   6 # Copyright (C) 2003-2004 Michael Schindler <m-schindler@users.sourceforge.net>
   7 # Copyright (C) 2002-2004 André Wobst <wobsta@users.sourceforge.net>
   8 #
   9 # This file is part of PyX (http://pyx.sourceforge.net/).
  10 #
  11 # PyX is free software; you can redistribute it and/or modify
  12 # it under the terms of the GNU General Public License as published by
  13 # the Free Software Foundation; either version 2 of the License, or
  14 # (at your option) any later version.
  15 #
  16 # PyX is distributed in the hope that it will be useful,
  17 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 # GNU General Public License for more details.
  20 #
  21 # You should have received a copy of the GNU General Public License
  22 # along with PyX; if not, write to the Free Software
  23 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24
  25 # TODO:
  26 # - should we improve on the arc length -> arg parametrization routine or
  27 #   should we at least factor it out?
  28
  29 import sys, math
  30 import attr, base, canvas, color, helper, path, style, trafo, unit
  31
  32 #
  33 # Decorated path
  34 #
  35
  36 class decoratedpath(base.canvasitem):
  37     """Decorated path
  38
  39     The main purpose of this class is during the drawing
  40     (stroking/filling) of a path. It collects attributes for the
  41     stroke and/or fill operations.
  42     """
  43
  44     def __init__(self, path, strokepath=None, fillpath=None,
  45                  styles=None, strokestyles=None, fillstyles=None,
  46                  subcanvas=None):
  47
  48         self.path = path
  49
  50         # path to be stroked or filled (or None)
  51         self.strokepath = strokepath
  52         self.fillpath = fillpath
  53
  54         # global style for stroking and filling and subdps
  55         self.styles = helper.ensurelist(styles)
  56
  57         # styles which apply only for stroking and filling
  58         self.strokestyles = helper.ensurelist(strokestyles)
  59         self.fillstyles = helper.ensurelist(fillstyles)
  60
  61         # the canvas can contain additional elements of the path, e.g.,
  62         # arrowheads,
  63         if subcanvas is None:
  64             self.subcanvas = canvas.canvas()
  65         else:
  66             self.subcanvas = subcanvas
  67
  68
  69     def bbox(self):
  70         scbbox = self.subcanvas.bbox()
  71         pbbox = self.path.bbox()
  72         if scbbox is not None:
  73             return scbbox+pbbox
  74         else:
  75             return pbbox
  76
  77     def prolog(self):
  78         result = []
  79         for style in list(self.styles) + list(self.fillstyles) + list(self.strokestyles):
  80             result.extend(style.prolog())
  81         result.extend(self.subcanvas.prolog())
  82         return result
  83
  84     def outputPS(self, file):
  85         # draw (stroke and/or fill) the decoratedpath on the canvas
  86         # while trying to produce an efficient output, e.g., by
  87         # not writing one path two times
  88
  89         # small helper
  90         def _writestyles(styles, file=file):
  91             for style in styles:
  92                 style.outputPS(file)
  93
  94         # apply global styles
  95         if self.styles:
  96             file.write("gsave\n")
  97             _writestyles(self.styles)
  98
  99         if self.fillpath is not None:
 100             file.write("newpath\n")
 101             self.fillpath.outputPS(file)
 102
 103             if self.strokepath==self.fillpath:
 104                 # do efficient stroking + filling
 105                 file.write("gsave\n")
 106
 107                 if self.fillstyles:
 108                     _writestyles(self.fillstyles)
 109
 110                 file.write("fill\n")
 111                 file.write("grestore\n")
 112
 113                 if self.strokestyles:
 114                     file.write("gsave\n")
 115                     _writestyles(self.strokestyles)
 116
 117                 file.write("stroke\n")
 118
 119                 if self.strokestyles:
 120                     file.write("grestore\n")
 121             else:
 122                 # only fill fillpath - for the moment
 123                 if self.fillstyles:
 124                     file.write("gsave\n")
 125                     _writestyles(self.fillstyles)
 126
 127                 file.write("fill\n")
 128
 129                 if self.fillstyles:
 130                     file.write("grestore\n")
 131
 132         if self.strokepath is not None and self.strokepath!=self.fillpath:
 133             # this is the only relevant case still left
 134             # Note that a possible stroking has already been done.
 135
 136             if self.strokestyles:
 137                 file.write("gsave\n")
 138                 _writestyles(self.strokestyles)
 139
 140             file.write("newpath\n")
 141             self.strokepath.outputPS(file)
 142             file.write("stroke\n")
 143
 144             if self.strokestyles:
 145                 file.write("grestore\n")
 146
 147         if self.strokepath is None and self.fillpath is None:
 148             raise RuntimeError("Path neither to be stroked nor filled")
 149
 150         # now, draw additional elements of decoratedpath
 151         self.subcanvas.outputPS(file)
 152
 153         # restore global styles
 154         if self.styles:
 155             file.write("grestore\n")
 156
 157     def outputPDF(self, file):
 158         # draw (stroke and/or fill) the decoratedpath on the canvas
 159
 160         def _writestyles(styles, file=file):
 161             for style in styles:
 162                 style.outputPDF(file)
 163
 164         def _writestrokestyles(strokestyles, file=file):
 165             for style in strokestyles:
 166                 if isinstance(style, color.color):
 167                     style.outputPDF(file, fillattr=0)
 168                 else:
 169                     style.outputPDF(file)
 170
 171         def _writefillstyles(fillstyles, file=file):
 172             for style in fillstyles:
 173                 if isinstance(style, color.color):
 174                     style.outputPDF(file, strokeattr=0)
 175                 else:
 176                     style.outputPDF(file)
 177
 178         # apply global styles
 179         if self.styles:
 180             file.write("q\n") # gsave
 181             _writestyles(self.styles)
 182
 183         if self.fillpath is not None:
 184             self.fillpath.outputPDF(file)
 185
 186             if self.strokepath==self.fillpath:
 187                 # do efficient stroking + filling
 188                 file.write("q\n") # gsave
 189
 190                 if self.fillstyles:
 191                     _writefillstyles(self.fillstyles)
 192                 if self.strokestyles:
 193                     _writestrokestyles(self.strokestyles)
 194
 195                 file.write("B\n") # both stroke and fill
 196                 file.write("Q\n") # grestore
 197             else:
 198                 # only fill fillpath - for the moment
 199                 if self.fillstyles:
 200                     file.write("q\n") # gsave
 201                     _writefillstyles(self.fillstyles)
 202
 203                 file.write("f\n") # fill
 204
 205                 if self.fillstyles:
 206                     file.write("Q\n") # grestore
 207
 208         if self.strokepath is not None and self.strokepath!=self.fillpath:
 209             # this is the only relevant case still left
 210             # Note that a possible stroking has already been done.
 211
 212             if self.strokestyles:
 213                 file.write("q\n") # gsave
 214                 _writestrokestyles(self.strokestyles)
 215
 216             self.strokepath.outputPDF(file)
 217             file.write("S\n") # stroke
 218
 219             if self.strokestyles:
 220                 file.write("Q\n") # grestore
 221
 222         if self.strokepath is None and self.fillpath is None:
 223             raise RuntimeError("Path neither to be stroked nor filled")
 224
 225         # now, draw additional elements of decoratedpath
 226         self.subcanvas.outputPDF(file)
 227
 228         # restore global styles
 229         if self.styles:
 230             file.write("Q\n") # grestore
 231
 232 #
 233 # Path decorators
 234 #
 235
 236 class deco:
 237
 238     """decorators
 239
 240     In contrast to path styles, path decorators depend on the concrete
 241     path to which they are applied. In particular, they don't make
 242     sense without any path and can thus not be used in canvas.set!
 243
 244     """
 245
 246     def decorate(self, dp):
 247         """apply a style to a given decoratedpath object dp
 248
 249         decorate accepts a decoratedpath object dp, applies PathStyle
 250         by modifying dp in place and returning the new dp.
 251         """
 252
 253         pass
 254
 255 #
 256 # stroked and filled: basic decos which stroked and fill,
 257 # respectively the path
 258 #
 259
 260 class _stroked(deco, attr.exclusiveattr):
 261
 262     """stroked is a decorator, which draws the outline of the path"""
 263
 264     def __init__(self, styles=[]):
 265         attr.exclusiveattr.__init__(self, _stroked)
 266         self.styles = attr.mergeattrs(styles)
 267         attr.checkattrs(self.styles, [style.strokestyle])
 268
 269     def __call__(self, styles=[]):
 270         # XXX or should we also merge self.styles
 271         return _stroked(styles)
 272
 273     def decorate(self, dp):
 274         dp.strokepath = dp.path
 275         dp.strokestyles = self.styles
 276         return dp
 277
 278 stroked = _stroked()
 279 stroked.clear = attr.clearclass(_stroked)
 280
 281
 282 class _filled(deco, attr.exclusiveattr):
 283
 284     """filled is a decorator, which fills the interior of the path"""
 285
 286     def __init__(self, styles=[]):
 287         attr.exclusiveattr.__init__(self, _filled)
 288         self.styles = attr.mergeattrs(styles)
 289         attr.checkattrs(self.styles, [style.fillstyle])
 290
 291     def __call__(self, styles=[]):
 292         # XXX or should we also merge self.styles
 293         return _filled(styles)
 294
 295     def decorate(self, dp):
 296         dp.fillpath = dp.path
 297         dp.fillstyles = self.styles
 298         return dp
 299
 300 filled = _filled()
 301 filled.clear = attr.clearclass(_filled)
 302
 303 #
 304 # Arrows
 305 #
 306
 307 # two helper functions which construct the arrowhead and return its size, respectively
 308
 309 def _arrowheadtemplatelength(anormpath, size):
 310     "returns length of arrowhead template (in parametrisation of anormpath)"
 311     # get tip (tx, ty)
 312     tx, ty = anormpath.begin()
 313
 314     # obtain arrow template by using path up to first intersection
 315     # with circle around tip (as suggested by Michael Schindler)
 316     ipar = anormpath.intersect(path.circle(tx, ty, size))[0]
 317     if ipar:
 318         return ipar[0]
 319     else:
 320         raise RuntimeError("arrow head too big for path")
 321
 322 def _arrowhead(anormpath, size, angle, constriction):
 323
 324     """helper routine, which returns an arrowhead for a normpath
 325
 326     returns arrowhead at begin of anormpath with size,
 327     opening angle and relative constriction
 328     """
 329
 330     alen = _arrowheadtemplatelength(anormpath, size)
 331     tx, ty = anormpath.begin()
 332
 333     # now we construct the template for our arrow but cutting
 334     # the path a the corresponding length
 335     arrowtemplate = anormpath.split([alen])[0]
 336
 337     # from this template, we construct the two outer curves
 338     # of the arrow
 339     arrowl = arrowtemplate.transformed(trafo.rotate(-angle/2.0, tx, ty))
 340     arrowr = arrowtemplate.transformed(trafo.rotate( angle/2.0, tx, ty))
 341
 342     # now come the joining backward parts
 343
 344     # constriction point (cx, cy) lies on path
 345     cx, cy = anormpath.at(_arrowheadtemplatelength(anormpath, constriction*size))
 346
 347     arrowcr= path.line(*(arrowr.end()+(cx,cy)))
 348
 349     arrow = arrowl.reversed() << arrowr << arrowcr
 350     arrow.append(path.closepath())
 351
 352     return arrow
 353
 354
 355 _base = 6 * unit.v_pt
 356
 357 class arrow(deco, attr.attr):
 358
 359     """arrow is a decorator which adds an arrow to either side of the path"""
 360
 361     def __init__(self, attrs=[], position=0, size=_base, angle=45, constriction=0.8):
 362         self.attrs = attr.mergeattrs([style.linestyle.solid, filled] + attrs)
 363         attr.checkattrs(self.attrs, [deco, style.fillstyle, style.strokestyle])
 364         self.position = position
 365         self.size = size
 366         self.angle = angle
 367         self.constriction = constriction
 368
 369     def __call__(self, attrs=None, position=None, size=None, angle=None, constriction=None):
 370         if attrs is None:
 371             attrs = self.attrs
 372         if position is None:
 373             position = self.position
 374         if size is None:
 375             size = self.size
 376         if angle is None:
 377             angle = self.angle
 378         if constriction is None:
 379             constriction = self.constriction
 380         return arrow(attrs=attrs, position=position, size=size, angle=angle, constriction=constriction)
 381
 382     def decorate(self, dp):
 383         # XXX raise exception error, when strokepath is not defined
 384
 385         # convert to normpath if necessary
 386         if isinstance(dp.strokepath, path.normpath):
 387             anormpath = dp.strokepath
 388         else:
 389             anormpath = path.normpath(dp.path)
 390         if self.position:
 391             anormpath = anormpath.reversed()
 392
 393         # add arrowhead to decoratedpath
 394         dp.subcanvas.draw(_arrowhead(anormpath, self.size, self.angle, self.constriction),
 395                           self.attrs)
 396
 397         # calculate new strokepath
 398         ilen = _arrowheadtemplatelength(anormpath, self.size*min(self.constriction, 1))
 399
 400         # this is the rest of the path, we have to draw
 401         anormpath = anormpath.split([ilen])[1]
 402
 403         # go back to original orientation, if necessary
 404         if self.position:
 405             anormpath.reverse()
 406
 407         # set the new (shortened) strokepath
 408         dp.strokepath = anormpath
 409
 410         return dp
 411
 412 arrow.clear = attr.clearclass(arrow)
 413
 414 # arrows at begin of path
 415 barrow = arrow(position=0)
 416 barrow.SMALL = barrow(size=_base/math.sqrt(64))
 417 barrow.SMALl = barrow(size=_base/math.sqrt(32))
 418 barrow.SMAll = barrow(size=_base/math.sqrt(16))
 419 barrow.SMall = barrow(size=_base/math.sqrt(8))
 420 barrow.Small = barrow(size=_base/math.sqrt(4))
 421 barrow.small = barrow(size=_base/math.sqrt(2))
 422 barrow.normal = barrow(size=_base)
 423 barrow.large = barrow(size=_base*math.sqrt(2))
 424 barrow.Large = barrow(size=_base*math.sqrt(4))
 425 barrow.LArge = barrow(size=_base*math.sqrt(8))
 426 barrow.LARge = barrow(size=_base*math.sqrt(16))
 427 barrow.LARGe = barrow(size=_base*math.sqrt(32))
 428 barrow.LARGE = barrow(size=_base*math.sqrt(64))
 429
 430 # arrows at end of path
 431 earrow = arrow(position=1)
 432 earrow.SMALL = earrow(size=_base/math.sqrt(64))
 433 earrow.SMALl = earrow(size=_base/math.sqrt(32))
 434 earrow.SMAll = earrow(size=_base/math.sqrt(16))
 435 earrow.SMall = earrow(size=_base/math.sqrt(8))
 436 earrow.Small = earrow(size=_base/math.sqrt(4))
 437 earrow.small = earrow(size=_base/math.sqrt(2))
 438 earrow.normal = earrow(size=_base)
 439 earrow.large = earrow(size=_base*math.sqrt(2))
 440 earrow.Large = earrow(size=_base*math.sqrt(4))
 441 earrow.LArge = earrow(size=_base*math.sqrt(8))
 442 earrow.LARge = earrow(size=_base*math.sqrt(16))
 443 earrow.LARGe = earrow(size=_base*math.sqrt(32))
 444 earrow.LARGE = earrow(size=_base*math.sqrt(64))
 445