pyx/deco.py

   1 # -*- coding: ISO-8859-1 -*-
   2 #
   3 #
   4 # Copyright (C) 2002-2006 Jörg Lehmann <joergl@users.sourceforge.net>
   5 # Copyright (C) 2003-2004 Michael Schindler <m-schindler@users.sourceforge.net>
   6 # Copyright (C) 2002-2006 André Wobst <wobsta@users.sourceforge.net>
   7 #
   8 # This file is part of PyX (http://pyx.sourceforge.net/).
   9 #
  10 # PyX is free software; you can redistribute it and/or modify
  11 # it under the terms of the GNU General Public License as published by
  12 # the Free Software Foundation; either version 2 of the License, or
  13 # (at your option) any later version.
  14 #
  15 # PyX is distributed in the hope that it will be useful,
  16 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 # GNU General Public License for more details.
  19 #
  20 # You should have received a copy of the GNU General Public License
  21 # along with PyX; if not, write to the Free Software
  22 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  23
  24 # TODO:
  25 # - should we improve on the arc length -> arg parametrization routine or
  26 #   should we at least factor it out?
  27
  28 import sys, math
  29 import attr, canvas, canvasitem, color, path, normpath, style, trafo, unit
  30
  31 _marker = object()
  32
  33 #
  34 # Decorated path
  35 #
  36
  37 class decoratedpath(canvasitem.canvasitem):
  38     """Decorated path
  39
  40     The main purpose of this class is during the drawing
  41     (stroking/filling) of a path. It collects attributes for the
  42     stroke and/or fill operations.
  43     """
  44
  45     def __init__(self, path, strokepath=None, fillpath=None,
  46                  styles=None, strokestyles=None, fillstyles=None,
  47                  ornaments=None, fillrule=style.fillrule.nonzero_winding):
  48
  49         self.path = path
  50
  51         # global style for stroking and filling and subdps
  52         self.styles = styles
  53
  54         # styles which apply only for stroking and filling
  55         self.strokestyles = strokestyles
  56         self.fillstyles = fillstyles
  57
  58         # the decoratedpath can contain additional elements of the
  59         # path (ornaments), e.g., arrowheads.
  60         if ornaments is None:
  61             self.ornaments = canvas.canvas()
  62         else:
  63             self.ornaments = ornaments
  64
  65         # the fillrule is either fillrule.nonzero_winding or fillrule.even_odd
  66         self.fillrule = fillrule
  67
  68         self.nostrokeranges = None
  69
  70     def ensurenormpath(self):
  71         """convert self.path into a normpath"""
  72         assert self.nostrokeranges is None or isinstance(self.path, path.normpath), "you don't understand what you are doing"
  73         self.path = self.path.normpath()
  74
  75     def excluderange(self, begin, end):
  76         assert isinstance(self.path, path.normpath), "you don't understand what this is about"
  77         if self.nostrokeranges is None:
  78             self.nostrokeranges = [(begin, end)]
  79         else:
  80             ibegin = 0
  81             while ibegin < len(self.nostrokeranges) and self.nostrokeranges[ibegin][1] < begin:
  82                 ibegin += 1
  83
  84             if ibegin == len(self.nostrokeranges):
  85                 self.nostrokeranges.append((begin, end))
  86                 return
  87
  88             iend = len(self.nostrokeranges) - 1
  89             while 0 <= iend and end < self.nostrokeranges[iend][0]:
  90                 iend -= 1
  91
  92             if iend == -1:
  93                 self.nostrokeranges.insert(0, (begin, end))
  94                 return
  95
  96             if self.nostrokeranges[ibegin][0] < begin:
  97                 begin = self.nostrokeranges[ibegin][0]
  98             if end < self.nostrokeranges[iend][1]:
  99                 end = self.nostrokeranges[iend][1]
 100
 101             self.nostrokeranges[ibegin:iend+1] = [(begin, end)]
 102
 103     def bbox(self):
 104         pathbbox = self.path.bbox()
 105         ornamentsbbox = self.ornaments.bbox()
 106         if ornamentsbbox is not None:
 107             return ornamentsbbox + pathbbox
 108         else:
 109             return pathbbox
 110
 111     def strokepath(self):
 112         if self.nostrokeranges:
 113             splitlist = []
 114             for begin, end in self.nostrokeranges:
 115                 splitlist.append(begin)
 116                 splitlist.append(end)
 117             split = self.path.split(splitlist)
 118             # XXX properly handle closed paths?
 119             result = split[0]
 120             for i in range(2, len(split), 2):
 121                 result += split[i]
 122             return result
 123         else:
 124             return self.path
 125
 126     def processPS(self, file, writer, context, registry, bbox):
 127         # draw (stroke and/or fill) the decoratedpath on the canvas
 128         # while trying to produce an efficient output, e.g., by
 129         # not writing one path two times
 130
 131         # small helper
 132         def _writestyles(styles, context, registry, bbox):
 133             for style in styles:
 134                 style.processPS(file, writer, context, registry, bbox)
 135
 136         if self.strokestyles is None and self.fillstyles is None:
 137             if not len(self.ornaments):
 138                 raise RuntimeError("Path neither to be stroked nor filled nor decorated in another way")
 139             # just draw additional elements of decoratedpath
 140             self.ornaments.processPS(file, writer, context, registry, bbox)
 141             return
 142
 143         strokepath = self.strokepath()
 144         fillpath = self.path
 145
 146         # apply global styles
 147         if self.styles:
 148             file.write("gsave\n")
 149             context = context()
 150             _writestyles(self.styles, context, registry, bbox)
 151
 152         if self.fillstyles is not None:
 153             file.write("newpath\n")
 154             fillpath.outputPS(file, writer)
 155
 156             if self.strokestyles is not None and strokepath is fillpath:
 157                 # do efficient stroking + filling if respective paths are identical
 158                 file.write("gsave\n")
 159
 160                 if self.fillstyles:
 161                     _writestyles(self.fillstyles, context(), registry, bbox)
 162
 163                 if self.fillrule.even_odd:
 164                     file.write("eofill\n")
 165                 else:
 166                     file.write("fill\n")
 167                 file.write("grestore\n")
 168
 169                 acontext = context()
 170                 if self.strokestyles:
 171                     file.write("gsave\n")
 172                     _writestyles(self.strokestyles, acontext, registry, bbox)
 173
 174                 file.write("stroke\n")
 175                 # take linewidth into account for bbox when stroking a path
 176                 bbox += strokepath.bbox().enlarged_pt(0.5*acontext.linewidth_pt)
 177
 178                 if self.strokestyles:
 179                     file.write("grestore\n")
 180             else:
 181                 # only fill fillpath - for the moment
 182                 if self.fillstyles:
 183                     file.write("gsave\n")
 184                     _writestyles(self.fillstyles, context(), registry, bbox)
 185
 186                 if self.fillrule.even_odd:
 187                     file.write("eofill\n")
 188                 else:
 189                     file.write("fill\n")
 190                 bbox += fillpath.bbox()
 191
 192                 if self.fillstyles:
 193                     file.write("grestore\n")
 194
 195         if self.strokestyles is not None and (strokepath is not fillpath or self.fillstyles is None):
 196             # this is the only relevant case still left
 197             # Note that a possible stroking has already been done.
 198             acontext = context()
 199             if self.strokestyles:
 200                 file.write("gsave\n")
 201                 _writestyles(self.strokestyles, acontext, registry, bbox)
 202
 203             file.write("newpath\n")
 204             strokepath.outputPS(file, writer)
 205             file.write("stroke\n")
 206             # take linewidth into account for bbox when stroking a path
 207             bbox += strokepath.bbox().enlarged_pt(0.5*acontext.linewidth_pt)
 208
 209             if self.strokestyles:
 210                 file.write("grestore\n")
 211
 212         # now, draw additional elements of decoratedpath
 213         self.ornaments.processPS(file, writer, context, registry, bbox)
 214
 215         # restore global styles
 216         if self.styles:
 217             file.write("grestore\n")
 218
 219     def processPDF(self, file, writer, context, registry, bbox):
 220         # draw (stroke and/or fill) the decoratedpath on the canvas
 221
 222         def _writestyles(styles, context, registry, bbox):
 223             for style in styles:
 224                 style.processPDF(file, writer, context, registry, bbox)
 225
 226         def _writestrokestyles(strokestyles, context, registry, bbox):
 227             context.fillattr = 0
 228             for style in strokestyles:
 229                 style.processPDF(file, writer, context, registry, bbox)
 230             context.fillattr = 1
 231
 232         def _writefillstyles(fillstyles, context, registry, bbox):
 233             context.strokeattr = 0
 234             for style in fillstyles:
 235                 style.processPDF(file, writer, context, registry, bbox)
 236             context.strokeattr = 1
 237
 238         if self.strokestyles is None and self.fillstyles is None:
 239             if not len(self.ornaments):
 240                 raise RuntimeError("Path neither to be stroked nor filled nor decorated in another way")
 241             # just draw additional elements of decoratedpath
 242             self.ornaments.processPDF(file, writer, context, registry, bbox)
 243             return
 244
 245         strokepath = self.strokepath()
 246         fillpath = self.path
 247
 248         # apply global styles
 249         if self.styles:
 250             file.write("q\n") # gsave
 251             context = context()
 252             _writestyles(self.styles, context, registry, bbox)
 253
 254         if self.fillstyles is not None:
 255             fillpath.outputPDF(file, writer)
 256
 257             if self.strokestyles is not None and strokepath is fillpath:
 258                 # do efficient stroking + filling
 259                 file.write("q\n") # gsave
 260                 acontext = context()
 261
 262                 if self.fillstyles:
 263                     _writefillstyles(self.fillstyles, acontext, registry, bbox)
 264                 if self.strokestyles:
 265                     _writestrokestyles(self.strokestyles, acontext, registry, bbox)
 266
 267                 if self.fillrule.even_odd:
 268                     file.write("B*\n")
 269                 else:
 270                     file.write("B\n") # both stroke and fill
 271                 # take linewidth into account for bbox when stroking a path
 272                 bbox += strokepath.bbox().enlarged_pt(0.5*acontext.linewidth_pt)
 273
 274                 file.write("Q\n") # grestore
 275             else:
 276                 # only fill fillpath - for the moment
 277                 if self.fillstyles:
 278                     file.write("q\n") # gsave
 279                     _writefillstyles(self.fillstyles, context(), registry, bbox)
 280
 281                 if self.fillrule.even_odd:
 282                     file.write("f*\n")
 283                 else:
 284                     file.write("f\n") # fill
 285                 bbox += fillpath.bbox()
 286
 287                 if self.fillstyles:
 288                     file.write("Q\n") # grestore
 289
 290         if self.strokestyles is not None and (strokepath is not fillpath or self.fillstyles is None):
 291             # this is the only relevant case still left
 292             # Note that a possible stroking has already been done.
 293             acontext = context()
 294
 295             if self.strokestyles:
 296                 file.write("q\n") # gsave
 297                 _writestrokestyles(self.strokestyles, acontext, registry, bbox)
 298
 299             strokepath.outputPDF(file, writer)
 300             file.write("S\n") # stroke
 301             # take linewidth into account for bbox when stroking a path
 302             bbox += strokepath.bbox().enlarged_pt(0.5*acontext.linewidth_pt)
 303
 304             if self.strokestyles:
 305                 file.write("Q\n") # grestore
 306
 307         # now, draw additional elements of decoratedpath
 308         self.ornaments.processPDF(file, writer, context, registry, bbox)
 309
 310         # restore global styles
 311         if self.styles:
 312             file.write("Q\n") # grestore
 313
 314 #
 315 # Path decorators
 316 #
 317
 318 class deco:
 319
 320     """decorators
 321
 322     In contrast to path styles, path decorators depend on the concrete
 323     path to which they are applied. In particular, they don't make
 324     sense without any path and can thus not be used in canvas.set!
 325
 326     """
 327
 328     def decorate(self, dp, texrunner):
 329         """apply a style to a given decoratedpath object dp
 330
 331         decorate accepts a decoratedpath object dp, applies PathStyle
 332         by modifying dp in place.
 333         """
 334
 335         pass
 336
 337 #
 338 # stroked and filled: basic decos which stroked and fill,
 339 # respectively the path
 340 #
 341
 342 class _stroked(deco, attr.exclusiveattr):
 343
 344     """stroked is a decorator, which draws the outline of the path"""
 345
 346     def __init__(self, styles=[]):
 347         attr.exclusiveattr.__init__(self, _stroked)
 348         self.styles = attr.mergeattrs(styles)
 349         attr.checkattrs(self.styles, [style.strokestyle])
 350
 351     def __call__(self, styles=[]):
 352         # XXX or should we also merge self.styles
 353         return _stroked(styles)
 354
 355     def decorate(self, dp, texrunner):
 356         if dp.strokestyles is not None:
 357             raise RuntimeError("Cannot stroke an already stroked path")
 358         dp.strokestyles = self.styles
 359
 360 stroked = _stroked()
 361 stroked.clear = attr.clearclass(_stroked)
 362
 363
 364 class _filled(deco, attr.exclusiveattr):
 365
 366     """filled is a decorator, which fills the interior of the path"""
 367
 368     def __init__(self, styles=[]):
 369         attr.exclusiveattr.__init__(self, _filled)
 370         self.styles = attr.mergeattrs(styles)
 371         attr.checkattrs(self.styles, [style.fillstyle])
 372
 373     def __call__(self, styles=[]):
 374         # XXX or should we also merge self.styles
 375         return _filled(styles)
 376
 377     def decorate(self, dp, texrunner):
 378         if dp.fillstyles is not None:
 379             raise RuntimeError("Cannot fill an already filled path")
 380         dp.fillstyles = self.styles
 381
 382 filled = _filled()
 383 filled.clear = attr.clearclass(_filled)
 384
 385 #
 386 # Arrows
 387 #
 388
 389 # helper function which constructs the arrowhead
 390
 391 def _arrowhead(anormpath, arclenfrombegin, direction, size, angle, constrictionlen):
 392
 393     """helper routine, which returns an arrowhead from a given anormpath
 394
 395     - arclenfrombegin: position of arrow in arc length from the start of the path
 396     - direction: +1 for an arrow pointing along the direction of anormpath or
 397                  -1 for an arrow pointing opposite to the direction of normpath
 398     - size: size of the arrow as arc length
 399     - angle. opening angle
 400     - constrictionlen: None (no constriction) or arc length of constriction.
 401     """
 402
 403     # arc length and coordinates of tip
 404     tx, ty = anormpath.at(arclenfrombegin)
 405
 406     # construct the template for the arrow by cutting the path at the
 407     # corresponding length
 408     arrowtemplate = anormpath.split([arclenfrombegin, arclenfrombegin - direction * size])[1]
 409
 410     # from this template, we construct the two outer curves of the arrow
 411     arrowl = arrowtemplate.transformed(trafo.rotate(-angle/2.0, tx, ty))
 412     arrowr = arrowtemplate.transformed(trafo.rotate( angle/2.0, tx, ty))
 413
 414     # now come the joining backward parts
 415     if constrictionlen is not None:
 416         # constriction point (cx, cy) lies on path
 417         cx, cy = anormpath.at(arclenfrombegin - direction * constrictionlen)
 418         arrowcr= path.line(*(arrowr.atend() + (cx,cy)))
 419         arrow = arrowl.reversed() << arrowr << arrowcr
 420     else:
 421         arrow = arrowl.reversed() << arrowr
 422
 423     arrow[-1].close()
 424
 425     return arrow
 426
 427
 428 _base = 6 * unit.v_pt
 429
 430 class arrow(deco, attr.attr):
 431
 432     """arrow is a decorator which adds an arrow to either side of the path"""
 433
 434     def __init__(self, attrs=[], pos=1, reversed=0, size=_base, angle=45, constriction=0.8):
 435         self.attrs = attr.mergeattrs([style.linestyle.solid, filled] + attrs)
 436         attr.checkattrs(self.attrs, [deco, style.fillstyle, style.strokestyle])
 437         self.pos = pos
 438         self.reversed = reversed
 439         self.size = size
 440         self.angle = angle
 441         self.constriction = constriction
 442
 443     def __call__(self, attrs=None, pos=None, reversed=None, size=None, angle=None, constriction=_marker):
 444         if attrs is None:
 445             attrs = self.attrs
 446         if pos is None:
 447             pos = self.pos
 448         if reversed is None:
 449             reversed = self.reversed
 450         if size is None:
 451             size = self.size
 452         if angle is None:
 453             angle = self.angle
 454         if constriction is _marker:
 455             constriction = self.constriction
 456         return arrow(attrs=attrs, pos=pos, reversed=reversed, size=size, angle=angle, constriction=constriction)
 457
 458     def decorate(self, dp, texrunner):
 459         dp.ensurenormpath()
 460         anormpath = dp.path
 461
 462         # calculate absolute arc length of constricition
 463         # Note that we have to correct this length because the arrowtemplates are rotated
 464         # by self.angle/2 to the left and right. Hence, if we want no constriction, i.e., for
 465         # self.constriction = 1, we actually have a length which is approximately shorter
 466         # by the given geometrical factor.
 467         if self.constriction is not None:
 468             constrictionlen = arrowheadconstrictionlen = self.size * self.constriction * math.cos(math.radians(self.angle/2.0))
 469         else:
 470             # if we do not want a constriction, i.e. constriction is None, we still
 471             # need constrictionlen for cutting the path
 472             constrictionlen = self.size * 1 * math.cos(math.radians(self.angle/2.0))
 473             arrowheadconstrictionlen = None
 474
 475         arclenfrombegin = self.pos * anormpath.arclen()
 476         direction = self.reversed and -1 or 1
 477         arrowhead = _arrowhead(anormpath, arclenfrombegin, direction, self.size, self.angle, arrowheadconstrictionlen)
 478
 479         # add arrowhead to decoratedpath
 480         dp.ornaments.draw(arrowhead, self.attrs)
 481
 482         # exlude part of the path from stroking when the arrow is strictly at the begin or the end
 483         if self.pos == 0 and self.reversed:
 484             dp.excluderange(0, min(self.size, constrictionlen))
 485         elif self.pos == 1 and not self.reversed:
 486             dp.excluderange(anormpath.end() - min(self.size, constrictionlen), anormpath.end())
 487
 488 arrow.clear = attr.clearclass(arrow)
 489
 490 # arrows at begin of path
 491 barrow = arrow(pos=0, reversed=1)
 492 barrow.SMALL = barrow(size=_base/math.sqrt(64))
 493 barrow.SMALl = barrow(size=_base/math.sqrt(32))
 494 barrow.SMAll = barrow(size=_base/math.sqrt(16))
 495 barrow.SMall = barrow(size=_base/math.sqrt(8))
 496 barrow.Small = barrow(size=_base/math.sqrt(4))
 497 barrow.small = barrow(size=_base/math.sqrt(2))
 498 barrow.normal = barrow(size=_base)
 499 barrow.large = barrow(size=_base*math.sqrt(2))
 500 barrow.Large = barrow(size=_base*math.sqrt(4))
 501 barrow.LArge = barrow(size=_base*math.sqrt(8))
 502 barrow.LARge = barrow(size=_base*math.sqrt(16))
 503 barrow.LARGe = barrow(size=_base*math.sqrt(32))
 504 barrow.LARGE = barrow(size=_base*math.sqrt(64))
 505
 506 # arrows at end of path
 507 earrow = arrow()
 508 earrow.SMALL = earrow(size=_base/math.sqrt(64))
 509 earrow.SMALl = earrow(size=_base/math.sqrt(32))
 510 earrow.SMAll = earrow(size=_base/math.sqrt(16))
 511 earrow.SMall = earrow(size=_base/math.sqrt(8))
 512 earrow.Small = earrow(size=_base/math.sqrt(4))
 513 earrow.small = earrow(size=_base/math.sqrt(2))
 514 earrow.normal = earrow(size=_base)
 515 earrow.large = earrow(size=_base*math.sqrt(2))
 516 earrow.Large = earrow(size=_base*math.sqrt(4))
 517 earrow.LArge = earrow(size=_base*math.sqrt(8))
 518 earrow.LARge = earrow(size=_base*math.sqrt(16))
 519 earrow.LARGe = earrow(size=_base*math.sqrt(32))
 520 earrow.LARGE = earrow(size=_base*math.sqrt(64))
 521
 522
 523 class text(deco, attr.attr):
 524     """a simple text decorator"""
 525
 526     def __init__(self, text, textattrs=[], angle=0, relangle=None, textdist=0.2,
 527                        relarclenpos=0.5, arclenfrombegin=None, arclenfromend=None,
 528                        texrunner=None):
 529         if arclenfrombegin is not None and arclenfromend is not None:
 530             raise ValueError("either set arclenfrombegin or arclenfromend")
 531         self.text = text
 532         self.textattrs = textattrs
 533         self.angle = angle
 534         self.relangle = relangle
 535         self.textdist = textdist
 536         self.relarclenpos = relarclenpos
 537         self.arclenfrombegin = arclenfrombegin
 538         self.arclenfromend = arclenfromend
 539         self.texrunner = texrunner
 540
 541     def decorate(self, dp, texrunner):
 542         if self.texrunner:
 543             texrunner = self.texrunner
 544         import text as textmodule
 545         textattrs = attr.mergeattrs([textmodule.halign.center, textmodule.vshift.mathaxis] + self.textattrs)
 546
 547         dp.ensurenormpath()
 548         if self.arclenfrombegin is not None:
 549             param = dp.path.begin() + self.arclenfrombegin
 550         elif self.arclenfromend is not None:
 551             param = dp.path.end() - self.arclenfromend
 552         else:
 553             # relarcpos is used, when neither arcfrombegin nor arcfromend is given
 554             param = self.relarclenpos * dp.path.arclen()
 555         x, y = dp.path.at(param)
 556
 557         if self.relangle is not None:
 558             a = dp.path.trafo(param).apply_pt(math.cos(self.relangle*math.pi/180), math.sin(self.relangle*math.pi/180))
 559             b = dp.path.trafo(param).apply_pt(0, 0)
 560             angle = math.atan2(a[1] - b[1], a[0] - b[0])
 561         else:
 562             angle = self.angle*math.pi/180
 563         t = texrunner.text(x, y, self.text, textattrs)
 564         t.linealign(self.textdist, math.cos(angle), math.sin(angle))
 565         dp.ornaments.insert(t)
 566
 567
 568 class shownormpath(deco, attr.attr):
 569
 570     def decorate(self, dp, texrunner):
 571         r_pt = 2
 572         dp.ensurenormpath()
 573         for normsubpath in dp.path.normsubpaths:
 574             for i, normsubpathitem in enumerate(normsubpath.normsubpathitems):
 575                 if isinstance(normsubpathitem, normpath.normcurve_pt):
 576                     dp.ornaments.stroke(normpath.normpath([normpath.normsubpath([normsubpathitem])]), [color.rgb.green])
 577                 else:
 578                     dp.ornaments.stroke(normpath.normpath([normpath.normsubpath([normsubpathitem])]), [color.rgb.blue])
 579         for normsubpath in dp.path.normsubpaths:
 580             for i, normsubpathitem in enumerate(normsubpath.normsubpathitems):
 581                 if isinstance(normsubpathitem, normpath.normcurve_pt):
 582                     dp.ornaments.stroke(path.line_pt(normsubpathitem.x0_pt, normsubpathitem.y0_pt, normsubpathitem.x1_pt, normsubpathitem.y1_pt), [style.linestyle.dashed, color.rgb.red])
 583                     dp.ornaments.stroke(path.line_pt(normsubpathitem.x2_pt, normsubpathitem.y2_pt, normsubpathitem.x3_pt, normsubpathitem.y3_pt), [style.linestyle.dashed, color.rgb.red])
 584                     dp.ornaments.draw(path.circle_pt(normsubpathitem.x1_pt, normsubpathitem.y1_pt, r_pt), [filled([color.rgb.red])])
 585                     dp.ornaments.draw(path.circle_pt(normsubpathitem.x2_pt, normsubpathitem.y2_pt, r_pt), [filled([color.rgb.red])])
 586         for normsubpath in dp.path.normsubpaths:
 587             for i, normsubpathitem in enumerate(normsubpath.normsubpathitems):
 588                 if not i:
 589                     x_pt, y_pt = normsubpathitem.atbegin_pt()
 590                     dp.ornaments.draw(path.circle_pt(x_pt, y_pt, r_pt), [filled])
 591                 x_pt, y_pt = normsubpathitem.atend_pt()
 592                 dp.ornaments.draw(path.circle_pt(x_pt, y_pt, r_pt), [filled])