path.py

   1 # -*- encoding: utf-8 -*-
   2 #
   3 #
   4 # Copyright (C) 2002-2006 Jörg Lehmann <joergl@users.sourceforge.net>
   5 # Copyright (C) 2003-2005 Michael Schindler <m-schindler@users.sourceforge.net>
   6 # Copyright (C) 2002-2011 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 import math
  25 from math import cos, sin, tan, acos, pi, radians, degrees
  26 from . import trafo, unit
  27 from .normpath import NormpathException, normpath, normsubpath, normline_pt, normcurve_pt
  28 from . import bbox as bboxmodule
  29
  30 # set is available as an external interface to the normpath.set method
  31 from .normpath import set
  32
  33
  34 class _marker: pass
  35
  36 ################################################################################
  37
  38 # specific exception for path-related problems
  39 class PathException(Exception): pass
  40
  41 ################################################################################
  42 # Bezier helper functions
  43 ################################################################################
  44
  45 def _bezierpolyrange(x0, x1, x2, x3):
  46     tc = [0, 1]
  47
  48     a = x3 - 3*x2 + 3*x1 - x0
  49     b = 2*x0 - 4*x1 + 2*x2
  50     c = x1 - x0
  51
  52     s = b*b - 4*a*c
  53     if s >= 0:
  54         if b >= 0:
  55             q = -0.5*(b+math.sqrt(s))
  56         else:
  57             q = -0.5*(b-math.sqrt(s))
  58
  59         try:
  60             t = q*1.0/a
  61         except ZeroDivisionError:
  62             pass
  63         else:
  64             if 0 < t < 1:
  65                 tc.append(t)
  66
  67         try:
  68             t = c*1.0/q
  69         except ZeroDivisionError:
  70             pass
  71         else:
  72             if 0 < t < 1:
  73                 tc.append(t)
  74
  75     p = [(((a*t + 1.5*b)*t + 3*c)*t + x0) for t in tc]
  76
  77     return min(*p), max(*p)
  78
  79
  80 def _arctobcurve(x_pt, y_pt, r_pt, phi1, phi2):
  81     """generate the best bezier curve corresponding to an arc segment"""
  82
  83     dphi = phi2-phi1
  84
  85     if dphi==0: return None
  86
  87     # the two endpoints should be clear
  88     x0_pt, y0_pt = x_pt+r_pt*cos(phi1), y_pt+r_pt*sin(phi1)
  89     x3_pt, y3_pt = x_pt+r_pt*cos(phi2), y_pt+r_pt*sin(phi2)
  90
  91     # optimal relative distance along tangent for second and third
  92     # control point
  93     l = r_pt*4*(1-cos(dphi/2))/(3*sin(dphi/2))
  94
  95     x1_pt, y1_pt = x0_pt-l*sin(phi1), y0_pt+l*cos(phi1)
  96     x2_pt, y2_pt = x3_pt+l*sin(phi2), y3_pt-l*cos(phi2)
  97
  98     return normcurve_pt(x0_pt, y0_pt, x1_pt, y1_pt, x2_pt, y2_pt, x3_pt, y3_pt)
  99
 100
 101 def _arctobezierpath(x_pt, y_pt, r_pt, phi1, phi2, dphimax=45):
 102     apath = []
 103
 104     phi1 = radians(phi1)
 105     phi2 = radians(phi2)
 106     dphimax = radians(dphimax)
 107
 108     if phi2<phi1:
 109         # guarantee that phi2>phi1 ...
 110         phi2 = phi2 + (math.floor((phi1-phi2)/(2*pi))+1)*2*pi
 111     elif phi2>phi1+2*pi:
 112         # ... or remove unnecessary multiples of 2*pi
 113         phi2 = phi2 - (math.floor((phi2-phi1)/(2*pi))-1)*2*pi
 114
 115     if r_pt == 0 or phi1-phi2 == 0: return []
 116
 117     subdivisions = int((phi2-phi1)/dphimax)+1
 118
 119     dphi = (phi2-phi1)/subdivisions
 120
 121     for i in range(subdivisions):
 122         apath.append(_arctobcurve(x_pt, y_pt, r_pt, phi1+i*dphi, phi1+(i+1)*dphi))
 123
 124     return apath
 125
 126 def _arcpoint(x_pt, y_pt, r_pt, angle):
 127     """return starting point of arc segment"""
 128     return x_pt+r_pt*cos(radians(angle)), y_pt+r_pt*sin(radians(angle))
 129
 130 def _arcbboxdata(x_pt, y_pt, r_pt, angle1, angle2):
 131     phi1 = radians(angle1)
 132     phi2 = radians(angle2)
 133
 134     # starting end end point of arc segment
 135     sarcx_pt, sarcy_pt = _arcpoint(x_pt, y_pt, r_pt, angle1)
 136     earcx_pt, earcy_pt = _arcpoint(x_pt, y_pt, r_pt, angle2)
 137
 138     # Now, we have to determine the corners of the bbox for the
 139     # arc segment, i.e. global maxima/mimima of cos(phi) and sin(phi)
 140     # in the interval [phi1, phi2]. These can either be located
 141     # on the borders of this interval or in the interior.
 142
 143     if phi2 < phi1:
 144         # guarantee that phi2>phi1
 145         phi2 = phi2 + (math.floor((phi1-phi2)/(2*pi))+1)*2*pi
 146
 147     # next minimum of cos(phi) looking from phi1 in counterclockwise
 148     # direction: 2*pi*floor((phi1-pi)/(2*pi)) + 3*pi
 149
 150     if phi2 < (2*math.floor((phi1-pi)/(2*pi))+3)*pi:
 151         minarcx_pt = min(sarcx_pt, earcx_pt)
 152     else:
 153         minarcx_pt = x_pt-r_pt
 154
 155     # next minimum of sin(phi) looking from phi1 in counterclockwise
 156     # direction: 2*pi*floor((phi1-3*pi/2)/(2*pi)) + 7/2*pi
 157
 158     if phi2 < (2*math.floor((phi1-3.0*pi/2)/(2*pi))+7.0/2)*pi:
 159         minarcy_pt = min(sarcy_pt, earcy_pt)
 160     else:
 161         minarcy_pt = y_pt-r_pt
 162
 163     # next maximum of cos(phi) looking from phi1 in counterclockwise
 164     # direction: 2*pi*floor((phi1)/(2*pi))+2*pi
 165
 166     if phi2 < (2*math.floor((phi1)/(2*pi))+2)*pi:
 167         maxarcx_pt = max(sarcx_pt, earcx_pt)
 168     else:
 169         maxarcx_pt = x_pt+r_pt
 170
 171     # next maximum of sin(phi) looking from phi1 in counterclockwise
 172     # direction: 2*pi*floor((phi1-pi/2)/(2*pi)) + 1/2*pi
 173
 174     if phi2 < (2*math.floor((phi1-pi/2)/(2*pi))+5.0/2)*pi:
 175         maxarcy_pt = max(sarcy_pt, earcy_pt)
 176     else:
 177         maxarcy_pt = y_pt+r_pt
 178
 179     return minarcx_pt, minarcy_pt, maxarcx_pt, maxarcy_pt
 180
 181
 182 ################################################################################
 183 # path context and pathitem base class
 184 ################################################################################
 185
 186 class context:
 187
 188     """context for pathitem"""
 189
 190     def __init__(self, x_pt, y_pt, subfirstx_pt, subfirsty_pt):
 191         """initializes a context for path items
 192
 193         x_pt, y_pt are the currentpoint. subfirstx_pt, subfirsty_pt
 194         are the starting point of the current subpath. There are no
 195         invalid contexts, i.e. all variables need to be set to integer
 196         or float numbers.
 197         """
 198         self.x_pt = x_pt
 199         self.y_pt = y_pt
 200         self.subfirstx_pt = subfirstx_pt
 201         self.subfirsty_pt = subfirsty_pt
 202
 203
 204 class pathitem:
 205
 206     """element of a PS style path"""
 207
 208     def __str__(self):
 209         raise NotImplementedError()
 210
 211     def createcontext(self):
 212         """creates a context from the current pathitem
 213
 214         Returns a context instance. Is called, when no context has yet
 215         been defined, i.e. for the very first pathitem. Most of the
 216         pathitems do not provide this method. Note, that you should pass
 217         the context created by createcontext to updatebbox and updatenormpath
 218         of successive pathitems only; use the context-free createbbox and
 219         createnormpath for the first pathitem instead.
 220         """
 221         raise PathException("path must start with moveto or the like (%r)" % self)
 222
 223     def createbbox(self):
 224         """creates a bbox from the current pathitem
 225
 226         Returns a bbox instance. Is called, when a bbox has to be
 227         created instead of updating it, i.e. for the very first
 228         pathitem. Most pathitems do not provide this method.
 229         updatebbox must not be called for the created instance and the
 230         same pathitem.
 231         """
 232         raise PathException("path must start with moveto or the like (%r)" % self)
 233
 234     def createnormpath(self, epsilon=_marker):
 235         """create a normpath from the current pathitem
 236
 237         Return a normpath instance. Is called, when a normpath has to
 238         be created instead of updating it, i.e. for the very first
 239         pathitem. Most pathitems do not provide this method.
 240         updatenormpath must not be called for the created instance and
 241         the same pathitem.
 242         """
 243         raise PathException("path must start with moveto or the like (%r)" % self)
 244
 245     def updatebbox(self, bbox, context):
 246         """updates the bbox to contain the pathitem for the given
 247         context
 248
 249         Is called for all subsequent pathitems in a path to complete
 250         the bbox information. Both, the bbox and context are updated
 251         inplace. Does not return anything.
 252         """
 253         raise NotImplementedError(self)
 254
 255     def updatenormpath(self, normpath, context):
 256         """update the normpath to contain the pathitem for the given
 257         context
 258
 259         Is called for all subsequent pathitems in a path to complete
 260         the normpath. Both the normpath and the context are updated
 261         inplace. Most pathitem implementations will use
 262         normpath.normsubpath[-1].append to add normsubpathitem(s).
 263         Does not return anything.
 264         """
 265         raise NotImplementedError(self)
 266
 267     def outputPS(self, file, writer):
 268         """write PS representation of pathitem to file"""
 269         raise NotImplementedError(self)
 270
 271     def returnSVGdata(self, inverse_y, first, context):
 272         """return SVG representation of pathitem
 273
 274         :param bool inverse_y: reverts y coordinate as SVG uses a
 275             different y direction, but when creating font paths no
 276             y inversion is needed.
 277         :param bool first: :class:`arc` and :class:`arcn` need to
 278             know whether it is first in the path to prepend a line
 279             or a move. Note that it can't tell from the context as
 280             it is not stored in the context whether it is first.
 281         :param context: :class:`arct` need the currentpoint and
 282             closepath needs the startingpoint of the last subpath
 283             to update the currentpoint
 284         :type context: :class:`context`
 285         :rtype: string
 286
 287         """
 288         raise NotImplementedError(self)
 289
 290
 291
 292 ################################################################################
 293 # various pathitems
 294 ################################################################################
 295 # Each one comes in two variants:
 296 #  - one with suffix _pt. This one requires the coordinates
 297 #    to be already in pts (mainly used for internal purposes)
 298 #  - another which accepts arbitrary units
 299
 300
 301 class closepath(pathitem):
 302
 303     """Connect subpath back to its starting point"""
 304
 305     __slots__ = ()
 306
 307     def __str__(self):
 308         return "closepath()"
 309
 310     def updatebbox(self, bbox, context):
 311         context.x_pt = context.subfirstx_pt
 312         context.y_pt = context.subfirsty_pt
 313
 314     def updatenormpath(self, normpath, context):
 315         normpath.normsubpaths[-1].close()
 316         context.x_pt = context.subfirstx_pt
 317         context.y_pt = context.subfirsty_pt
 318
 319     def outputPS(self, file, writer):
 320         file.write("closepath\n")
 321
 322     def returnSVGdata(self, inverse_y, first, context):
 323         return "Z"
 324
 325
 326 class pdfmoveto_pt(normline_pt):
 327
 328     def outputPDF(self, file, writer):
 329         pass
 330
 331
 332 class moveto_pt(pathitem):
 333
 334     """Start a new subpath and set current point to (x_pt, y_pt) (coordinates in pts)"""
 335
 336     __slots__ = "x_pt", "y_pt"
 337
 338     def __init__(self, x_pt, y_pt):
 339         self.x_pt = x_pt
 340         self.y_pt = y_pt
 341
 342     def __str__(self):
 343         return "moveto_pt(%g, %g)" % (self.x_pt, self.y_pt)
 344
 345     def createcontext(self):
 346         return context(self.x_pt, self.y_pt, self.x_pt, self.y_pt)
 347
 348     def createbbox(self):
 349         return bboxmodule.bbox_pt(self.x_pt, self.y_pt, self.x_pt, self.y_pt)
 350
 351     def createnormpath(self, epsilon=_marker):
 352         if epsilon is _marker:
 353             return normpath([normsubpath([normline_pt(self.x_pt, self.y_pt, self.x_pt, self.y_pt)])])
 354         elif epsilon is None:
 355             return normpath([normsubpath([pdfmoveto_pt(self.x_pt, self.y_pt, self.x_pt, self.y_pt)],
 356                                          epsilon=epsilon)])
 357         else:
 358             return normpath([normsubpath([normline_pt(self.x_pt, self.y_pt, self.x_pt, self.y_pt)],
 359                                          epsilon=epsilon)])
 360
 361     def updatebbox(self, bbox, context):
 362         bbox.includepoint_pt(self.x_pt, self.y_pt)
 363         context.x_pt = context.subfirstx_pt = self.x_pt
 364         context.y_pt = context.subfirsty_pt = self.y_pt
 365
 366     def updatenormpath(self, normpath, context):
 367         if normpath.normsubpaths[-1].epsilon is not None:
 368             normpath.append(normsubpath([normline_pt(self.x_pt, self.y_pt, self.x_pt, self.y_pt)],
 369                                         epsilon=normpath.normsubpaths[-1].epsilon))
 370         else:
 371             normpath.append(normsubpath(epsilon=normpath.normsubpaths[-1].epsilon))
 372         context.x_pt = context.subfirstx_pt = self.x_pt
 373         context.y_pt = context.subfirsty_pt = self.y_pt
 374
 375     def outputPS(self, file, writer):
 376         file.write("%g %g moveto\n" % (self.x_pt, self.y_pt) )
 377
 378     def returnSVGdata(self, inverse_y, first, context):
 379         context.x_pt = context.subfirstx_pt = self.x_pt
 380         context.y_pt = context.subfirsty_pt = self.y_pt
 381         if inverse_y:
 382             return "M%g %g" % (self.x_pt, -self.y_pt)
 383         return "M%g %g" % (self.x_pt, self.y_pt)
 384
 385
 386 class lineto_pt(pathitem):
 387
 388     """Append straight line to (x_pt, y_pt) (coordinates in pts)"""
 389
 390     __slots__ = "x_pt", "y_pt"
 391
 392     def __init__(self, x_pt, y_pt):
 393         self.x_pt = x_pt
 394         self.y_pt = y_pt
 395
 396     def __str__(self):
 397         return "lineto_pt(%g, %g)" % (self.x_pt, self.y_pt)
 398
 399     def updatebbox(self, bbox, context):
 400         bbox.includepoint_pt(self.x_pt, self.y_pt)
 401         context.x_pt = self.x_pt
 402         context.y_pt = self.y_pt
 403
 404     def updatenormpath(self, normpath, context):
 405         normpath.normsubpaths[-1].append(normline_pt(context.x_pt, context.y_pt,
 406                                                      self.x_pt, self.y_pt))
 407         context.x_pt = self.x_pt
 408         context.y_pt = self.y_pt
 409
 410     def outputPS(self, file, writer):
 411         file.write("%g %g lineto\n" % (self.x_pt, self.y_pt) )
 412
 413     def returnSVGdata(self, inverse_y, first, context):
 414         context.x_pt = self.x_pt
 415         context.y_pt = self.y_pt
 416         if inverse_y:
 417             return "L%g %g" % (self.x_pt, -self.y_pt)
 418         return "L%g %g" % (self.x_pt, self.y_pt)
 419
 420
 421 class curveto_pt(pathitem):
 422
 423     """Append curveto (coordinates in pts)"""
 424
 425     __slots__ = "x1_pt", "y1_pt", "x2_pt", "y2_pt", "x3_pt", "y3_pt"
 426
 427     def __init__(self, x1_pt, y1_pt, x2_pt, y2_pt, x3_pt, y3_pt):
 428         self.x1_pt = x1_pt
 429         self.y1_pt = y1_pt
 430         self.x2_pt = x2_pt
 431         self.y2_pt = y2_pt
 432         self.x3_pt = x3_pt
 433         self.y3_pt = y3_pt
 434
 435     def __str__(self):
 436         return "curveto_pt(%g, %g, %g, %g, %g, %g)" % (self.x1_pt, self.y1_pt,
 437                                                        self.x2_pt, self.y2_pt,
 438                                                        self.x3_pt, self.y3_pt)
 439
 440     def updatebbox(self, bbox, context):
 441         xmin_pt, xmax_pt = _bezierpolyrange(context.x_pt, self.x1_pt, self.x2_pt, self.x3_pt)
 442         ymin_pt, ymax_pt = _bezierpolyrange(context.y_pt, self.y1_pt, self.y2_pt, self.y3_pt)
 443         bbox.includepoint_pt(xmin_pt, ymin_pt)
 444         bbox.includepoint_pt(xmax_pt, ymax_pt)
 445         context.x_pt = self.x3_pt
 446         context.y_pt = self.y3_pt
 447
 448     def updatenormpath(self, normpath, context):
 449         normpath.normsubpaths[-1].append(normcurve_pt(context.x_pt, context.y_pt,
 450                                                       self.x1_pt, self.y1_pt,
 451                                                       self.x2_pt, self.y2_pt,
 452                                                       self.x3_pt, self.y3_pt))
 453         context.x_pt = self.x3_pt
 454         context.y_pt = self.y3_pt
 455
 456     def outputPS(self, file, writer):
 457         file.write("%g %g %g %g %g %g curveto\n" % (self.x1_pt, self.y1_pt,
 458                                                     self.x2_pt, self.y2_pt,
 459                                                     self.x3_pt, self.y3_pt))
 460
 461     def returnSVGdata(self, inverse_y, first, context):
 462         context.x_pt = self.x3_pt
 463         context.y_pt = self.y3_pt
 464         if inverse_y:
 465             return "C%g %g %g %g %g %g" % (self.x1_pt, -self.y1_pt, self.x2_pt, -self.y2_pt, self.x3_pt, -self.y3_pt)
 466         return "C%g %g %g %g %g %g" % (self.x1_pt, self.y1_pt, self.x2_pt, self.y2_pt, self.x3_pt, self.y3_pt)
 467
 468
 469 class rmoveto_pt(pathitem):
 470
 471     """Perform relative moveto (coordinates in pts)"""
 472
 473     __slots__ = "dx_pt", "dy_pt"
 474
 475     def __init__(self, dx_pt, dy_pt):
 476          self.dx_pt = dx_pt
 477          self.dy_pt = dy_pt
 478
 479     def __str__(self):
 480         return "rmoveto_pt(%g, %g)" % (self.dx_pt, self.dy_pt)
 481
 482     def updatebbox(self, bbox, context):
 483         bbox.includepoint_pt(context.x_pt + self.dx_pt, context.y_pt + self.dy_pt)
 484         context.x_pt += self.dx_pt
 485         context.y_pt += self.dy_pt
 486         context.subfirstx_pt = context.x_pt
 487         context.subfirsty_pt = context.y_pt
 488
 489     def updatenormpath(self, normpath, context):
 490         context.x_pt += self.dx_pt
 491         context.y_pt += self.dy_pt
 492         context.subfirstx_pt = context.x_pt
 493         context.subfirsty_pt = context.y_pt
 494         if normpath.normsubpaths[-1].epsilon is not None:
 495             normpath.append(normsubpath([normline_pt(context.x_pt, context.y_pt,
 496                                                      context.x_pt, context.y_pt)],
 497                                         epsilon=normpath.normsubpaths[-1].epsilon))
 498         else:
 499             normpath.append(normsubpath(epsilon=normpath.normsubpaths[-1].epsilon))
 500
 501     def outputPS(self, file, writer):
 502         file.write("%g %g rmoveto\n" % (self.dx_pt, self.dy_pt) )
 503
 504     def returnSVGdata(self, inverse_y, first, context):
 505         context.x_pt += self.dx_pt
 506         context.y_pt += self.dy_pt
 507         context.subfirstx_pt = context.x_pt
 508         context.subfirsty_pt = context.y_pt
 509         if inverse_y:
 510             return "m%g %g" % (self.dx_pt, -self.dy_pt)
 511         return "m%g %g" % (self.dx_pt, self.dy_pt)
 512
 513
 514 class rlineto_pt(pathitem):
 515
 516     """Perform relative lineto (coordinates in pts)"""
 517
 518     __slots__ = "dx_pt", "dy_pt"
 519
 520     def __init__(self, dx_pt, dy_pt):
 521         self.dx_pt = dx_pt
 522         self.dy_pt = dy_pt
 523
 524     def __str__(self):
 525         return "rlineto_pt(%g %g)" % (self.dx_pt, self.dy_pt)
 526
 527     def updatebbox(self, bbox, context):
 528         bbox.includepoint_pt(context.x_pt + self.dx_pt, context.y_pt + self.dy_pt)
 529         context.x_pt += self.dx_pt
 530         context.y_pt += self.dy_pt
 531
 532     def updatenormpath(self, normpath, context):
 533         normpath.normsubpaths[-1].append(normline_pt(context.x_pt, context.y_pt,
 534                                                      context.x_pt + self.dx_pt, context.y_pt + self.dy_pt))
 535         context.x_pt += self.dx_pt
 536         context.y_pt += self.dy_pt
 537
 538     def outputPS(self, file, writer):
 539         file.write("%g %g rlineto\n" % (self.dx_pt, self.dy_pt) )
 540
 541     def returnSVGdata(self, inverse_y, first, context):
 542         context.x_pt += self.dx_pt
 543         context.y_pt += self.dy_pt
 544         if inverse_y:
 545             return "l%g %g" % (self.dx_pt, -self.dy_pt)
 546         return "l%g %g" % (self.dx_pt, self.dy_pt)
 547
 548
 549 class rcurveto_pt(pathitem):
 550
 551     """Append rcurveto (coordinates in pts)"""
 552
 553     __slots__ = "dx1_pt", "dy1_pt", "dx2_pt", "dy2_pt", "dx3_pt", "dy3_pt"
 554
 555     def __init__(self, dx1_pt, dy1_pt, dx2_pt, dy2_pt, dx3_pt, dy3_pt):
 556         self.dx1_pt = dx1_pt
 557         self.dy1_pt = dy1_pt
 558         self.dx2_pt = dx2_pt
 559         self.dy2_pt = dy2_pt
 560         self.dx3_pt = dx3_pt
 561         self.dy3_pt = dy3_pt
 562
 563     def __str__(self):
 564         return "rcurveto_pt(%g, %g, %g, %g, %g, %g)" % (self.dx1_pt, self.dy1_pt,
 565                                                         self.dx2_pt, self.dy2_pt,
 566                                                         self.dx3_pt, self.dy3_pt)
 567
 568     def updatebbox(self, bbox, context):
 569         xmin_pt, xmax_pt = _bezierpolyrange(context.x_pt,
 570                                             context.x_pt+self.dx1_pt,
 571                                             context.x_pt+self.dx2_pt,
 572                                             context.x_pt+self.dx3_pt)
 573         ymin_pt, ymax_pt = _bezierpolyrange(context.y_pt,
 574                                             context.y_pt+self.dy1_pt,
 575                                             context.y_pt+self.dy2_pt,
 576                                             context.y_pt+self.dy3_pt)
 577         bbox.includepoint_pt(xmin_pt, ymin_pt)
 578         bbox.includepoint_pt(xmax_pt, ymax_pt)
 579         context.x_pt += self.dx3_pt
 580         context.y_pt += self.dy3_pt
 581
 582     def updatenormpath(self, normpath, context):
 583         normpath.normsubpaths[-1].append(normcurve_pt(context.x_pt, context.y_pt,
 584                                                       context.x_pt + self.dx1_pt, context.y_pt + self.dy1_pt,
 585                                                       context.x_pt + self.dx2_pt, context.y_pt + self.dy2_pt,
 586                                                       context.x_pt + self.dx3_pt, context.y_pt + self.dy3_pt))
 587         context.x_pt += self.dx3_pt
 588         context.y_pt += self.dy3_pt
 589
 590     def outputPS(self, file, writer):
 591         file.write("%g %g %g %g %g %g rcurveto\n" % (self.dx1_pt, self.dy1_pt,
 592                                                      self.dx2_pt, self.dy2_pt,
 593                                                      self.dx3_pt, self.dy3_pt))
 594
 595     def returnSVGdata(self, inverse_y, first, context):
 596         context.x_pt += self.dx3_pt
 597         context.y_pt += self.dy3_pt
 598         if inverse_y:
 599             return "c%g %g %g %g %g %g" % (self.dx1_pt, -self.dy1_pt, self.dx2_pt, -self.dy2_pt, self.dx3_pt, -self.dy3_pt)
 600         return "c%g %g %g %g %g %g" % (self.dx1_pt, self.dy1_pt, self.dx2_pt, self.dy2_pt, self.dx3_pt, self.dy3_pt)
 601
 602
 603 class arc_pt(pathitem):
 604
 605     """Append counterclockwise arc (coordinates in pts)"""
 606
 607     __slots__ = "x_pt", "y_pt", "r_pt", "angle1", "angle2"
 608
 609     sweep = 0
 610
 611     def __init__(self, x_pt, y_pt, r_pt, angle1, angle2):
 612         self.x_pt = x_pt
 613         self.y_pt = y_pt
 614         self.r_pt = r_pt
 615         self.angle1 = angle1
 616         self.angle2 = angle2
 617
 618     def __str__(self):
 619         return "arc_pt(%g, %g, %g, %g, %g)" % (self.x_pt, self.y_pt, self.r_pt,
 620                                                self.angle1, self.angle2)
 621
 622     def createcontext(self):
 623         x1_pt, y1_pt = _arcpoint(self.x_pt, self.y_pt, self.r_pt, self.angle1)
 624         x2_pt, y2_pt = _arcpoint(self.x_pt, self.y_pt, self.r_pt, self.angle2)
 625         return context(x2_pt, y2_pt, x1_pt, y1_pt)
 626
 627     def createbbox(self):
 628         return bboxmodule.bbox_pt(*_arcbboxdata(self.x_pt, self.y_pt, self.r_pt,
 629                                                 self.angle1, self.angle2))
 630
 631     def createnormpath(self, epsilon=_marker):
 632         if epsilon is _marker:
 633             return normpath([normsubpath(_arctobezierpath(self.x_pt, self.y_pt, self.r_pt, self.angle1, self.angle2))])
 634         else:
 635             return normpath([normsubpath(_arctobezierpath(self.x_pt, self.y_pt, self.r_pt, self.angle1, self.angle2),
 636                                          epsilon=epsilon)])
 637
 638     def updatebbox(self, bbox, context):
 639         minarcx_pt, minarcy_pt, maxarcx_pt, maxarcy_pt = _arcbboxdata(self.x_pt, self.y_pt, self.r_pt,
 640                                                                       self.angle1, self.angle2)
 641         bbox.includepoint_pt(minarcx_pt, minarcy_pt)
 642         bbox.includepoint_pt(maxarcx_pt, maxarcy_pt)
 643         context.x_pt, context.y_pt = _arcpoint(self.x_pt, self.y_pt, self.r_pt, self.angle2)
 644
 645     def updatenormpath(self, normpath, context):
 646         if normpath.normsubpaths[-1].closed:
 647             normpath.append(normsubpath([normline_pt(context.x_pt, context.y_pt,
 648                                                          *_arcpoint(self.x_pt, self.y_pt, self.r_pt, self.angle1))],
 649                                         epsilon=normpath.normsubpaths[-1].epsilon))
 650         else:
 651             normpath.normsubpaths[-1].append(normline_pt(context.x_pt, context.y_pt,
 652                                                          *_arcpoint(self.x_pt, self.y_pt, self.r_pt, self.angle1)))
 653         normpath.normsubpaths[-1].extend(_arctobezierpath(self.x_pt, self.y_pt, self.r_pt, self.angle1, self.angle2))
 654         context.x_pt, context.y_pt = _arcpoint(self.x_pt, self.y_pt, self.r_pt, self.angle2)
 655
 656     def outputPS(self, file, writer):
 657         file.write("%g %g %g %g %g arc\n" % (self.x_pt, self.y_pt,
 658                                              self.r_pt,
 659                                              self.angle1,
 660                                              self.angle2))
 661
 662     def returnSVGdata(self, inverse_y, first, context):
 663         # move or line to the start point
 664         x_pt, y_pt = _arcpoint(self.x_pt, self.y_pt, self.r_pt, self.angle1)
 665         if inverse_y:
 666             y_pt = -y_pt
 667         if first:
 668             data = ["M%g %g" % (x_pt, y_pt)]
 669         else:
 670             data = ["L%g %g" % (x_pt, y_pt)]
 671
 672         angle1 = self.angle1
 673         angle2 = self.angle2
 674
 675         # make 0 < angle2-angle1 < 2*360
 676         if angle2 < angle1:
 677             angle2 += (math.floor((angle1-angle2)/360)+1)*360
 678         elif angle2 > angle1 + 360:
 679             angle2 -= (math.floor((angle2-angle1)/360)-1)*360
 680         # svg arcs become unstable when close to 360 degree and cannot
 681         # express more than 360 degree at all, so we might need to split.
 682         subdivisions = int((angle2-angle1)/350)+1
 683
 684         # we equal split by subdivisions
 685         large = "1" if (angle2-angle1)/subdivisions > 180 else "0"
 686         for i in range(subdivisions):
 687             x_pt, y_pt = _arcpoint(self.x_pt, self.y_pt, self.r_pt, angle1 + (i+1)*(angle2-angle1)/subdivisions)
 688             if inverse_y:
 689                 y_pt = -y_pt
 690             data.append("A%g %g 0 %s 0 %g %g" % (self.r_pt, self.r_pt, large, x_pt, y_pt))
 691
 692         context.x_pt = x_pt
 693         context.y_pt = y_pt
 694         return "".join(data)
 695
 696
 697 class arcn_pt(pathitem):
 698
 699     """Append clockwise arc (coordinates in pts)"""
 700
 701     __slots__ = "x_pt", "y_pt", "r_pt", "angle1", "angle2"
 702
 703     sweep = 1
 704
 705     def __init__(self, x_pt, y_pt, r_pt, angle1, angle2):
 706         self.x_pt = x_pt
 707         self.y_pt = y_pt
 708         self.r_pt = r_pt
 709         self.angle1 = angle1
 710         self.angle2 = angle2
 711
 712     def __str__(self):
 713         return "arcn_pt(%g, %g, %g, %g, %g)" % (self.x_pt, self.y_pt, self.r_pt,
 714                                                 self.angle1, self.angle2)
 715
 716     def createcontext(self):
 717         x1_pt, y1_pt = _arcpoint(self.x_pt, self.y_pt, self.r_pt, self.angle1)
 718         x2_pt, y2_pt = _arcpoint(self.x_pt, self.y_pt, self.r_pt, self.angle2)
 719         return context(x2_pt, y2_pt, x1_pt, y1_pt)
 720
 721     def createbbox(self):
 722         return bboxmodule.bbox_pt(*_arcbboxdata(self.x_pt, self.y_pt, self.r_pt,
 723                                                 self.angle2, self.angle1))
 724
 725     def createnormpath(self, epsilon=_marker):
 726         if epsilon is _marker:
 727             return normpath([normsubpath(_arctobezierpath(self.x_pt, self.y_pt, self.r_pt, self.angle2, self.angle1))]).reversed()
 728         else:
 729             return normpath([normsubpath(_arctobezierpath(self.x_pt, self.y_pt, self.r_pt, self.angle2, self.angle1),
 730                                          epsilon=epsilon)]).reversed()
 731
 732     def updatebbox(self, bbox, context):
 733         minarcx_pt, minarcy_pt, maxarcx_pt, maxarcy_pt = _arcbboxdata(self.x_pt, self.y_pt, self.r_pt,
 734                                                                       self.angle2, self.angle1)
 735         bbox.includepoint_pt(minarcx_pt, minarcy_pt)
 736         bbox.includepoint_pt(maxarcx_pt, maxarcy_pt)
 737         context.x_pt, context.y_pt = _arcpoint(self.x_pt, self.y_pt, self.r_pt, self.angle2)
 738
 739     def updatenormpath(self, normpath, context):
 740         if normpath.normsubpaths[-1].closed:
 741             normpath.append(normsubpath([normline_pt(context.x_pt, context.y_pt,
 742                                                          *_arcpoint(self.x_pt, self.y_pt, self.r_pt, self.angle1))],
 743                                         epsilon=normpath.normsubpaths[-1].epsilon))
 744         else:
 745             normpath.normsubpaths[-1].append(normline_pt(context.x_pt, context.y_pt,
 746                                                          *_arcpoint(self.x_pt, self.y_pt, self.r_pt, self.angle1)))
 747         bpathitems = _arctobezierpath(self.x_pt, self.y_pt, self.r_pt, self.angle2, self.angle1)
 748         bpathitems.reverse()
 749         for bpathitem in bpathitems:
 750             normpath.normsubpaths[-1].append(bpathitem.reversed())
 751         context.x_pt, context.y_pt = _arcpoint(self.x_pt, self.y_pt, self.r_pt, self.angle2)
 752
 753     def outputPS(self, file, writer):
 754         file.write("%g %g %g %g %g arcn\n" % (self.x_pt, self.y_pt,
 755                                               self.r_pt,
 756                                               self.angle1,
 757                                               self.angle2))
 758
 759     def returnSVGdata(self, inverse_y, first, context):
 760         # move or line to the start point
 761         x_pt, y_pt = _arcpoint(self.x_pt, self.y_pt, self.r_pt, self.angle1)
 762         if inverse_y:
 763             y_pt = -y_pt
 764         if first:
 765             data = ["M%g %g" % (x_pt, y_pt)]
 766         else:
 767             data = ["L%g %g" % (x_pt, y_pt)]
 768
 769         angle1 = self.angle1
 770         angle2 = self.angle2
 771
 772         # make 0 < angle1-angle2 < 2*360
 773         if angle1 < angle2:
 774             angle1 += (math.floor((angle2-angle1)/360)+1)*360
 775         elif angle1 > angle2 + 360:
 776             angle1 -= (math.floor((angle1-angle2)/360)-1)*360
 777         # svg arcs become unstable when close to 360 degree and cannot
 778         # express more than 360 degree at all, so we might need to split.
 779         subdivisions = int((angle1-angle2)/350)+1
 780
 781         # we equal split by subdivisions
 782         large = "1" if (angle1-angle2)/subdivisions > 180 else "0"
 783         for i in range(subdivisions):
 784             x_pt, y_pt = _arcpoint(self.x_pt, self.y_pt, self.r_pt, angle1 + (i+1)*(angle2-angle1)/subdivisions)
 785             if inverse_y:
 786                 y_pt = -y_pt
 787             data.append("A%g %g 0 %s 1 %g %g" % (self.r_pt, self.r_pt, large, x_pt, y_pt))
 788
 789         context.x_pt = x_pt
 790         context.y_pt = y_pt
 791         return "".join(data)
 792
 793
 794 class arct_pt(pathitem):
 795
 796     """Append tangent arc (coordinates in pts)"""
 797
 798     __slots__ = "x1_pt", "y1_pt", "x2_pt", "y2_pt", "r_pt"
 799
 800     def __init__(self, x1_pt, y1_pt, x2_pt, y2_pt, r_pt):
 801         self.x1_pt = x1_pt
 802         self.y1_pt = y1_pt
 803         self.x2_pt = x2_pt
 804         self.y2_pt = y2_pt
 805         self.r_pt = r_pt
 806
 807     def __str__(self):
 808         return "arct_pt(%g, %g, %g, %g, %g)" % (self.x1_pt, self.y1_pt,
 809                                                 self.x2_pt, self.y2_pt,
 810                                                 self.r_pt)
 811
 812     def _pathitems(self, x_pt, y_pt):
 813         """return pathitems corresponding to arct for given currentpoint x_pt, y_pt.
 814
 815         The return is a list containing line_pt, arc_pt, a arcn_pt instances.
 816
 817         This is a helper routine for updatebbox and updatenormpath,
 818         which will delegate the work to the constructed pathitem.
 819         """
 820
 821         # direction of tangent 1
 822         dx1_pt, dy1_pt = self.x1_pt-x_pt, self.y1_pt-y_pt
 823         l1_pt = math.hypot(dx1_pt, dy1_pt)
 824         dx1, dy1 = dx1_pt/l1_pt, dy1_pt/l1_pt
 825
 826         # direction of tangent 2
 827         dx2_pt, dy2_pt = self.x2_pt-self.x1_pt, self.y2_pt-self.y1_pt
 828         l2_pt = math.hypot(dx2_pt, dy2_pt)
 829         dx2, dy2 = dx2_pt/l2_pt, dy2_pt/l2_pt
 830
 831         # intersection angle between two tangents in the range (-pi, pi).
 832         # We take the orientation from the sign of the vector product.
 833         # Negative (positive) angles alpha corresponds to a turn to the right (left)
 834         # as seen from currentpoint.
 835         if dx1*dy2-dy1*dx2 > 0:
 836             alpha = acos(dx1*dx2+dy1*dy2)
 837         else:
 838             alpha = -acos(dx1*dx2+dy1*dy2)
 839
 840         try:
 841             # two tangent points
 842             xt1_pt = self.x1_pt - dx1*self.r_pt*tan(abs(alpha)/2)
 843             yt1_pt = self.y1_pt - dy1*self.r_pt*tan(abs(alpha)/2)
 844             xt2_pt = self.x1_pt + dx2*self.r_pt*tan(abs(alpha)/2)
 845             yt2_pt = self.y1_pt + dy2*self.r_pt*tan(abs(alpha)/2)
 846
 847             # direction point 1 -> center of arc
 848             dmx_pt = 0.5*(xt1_pt+xt2_pt) - self.x1_pt
 849             dmy_pt = 0.5*(yt1_pt+yt2_pt) - self.y1_pt
 850             lm_pt = math.hypot(dmx_pt, dmy_pt)
 851             dmx, dmy = dmx_pt/lm_pt, dmy_pt/lm_pt
 852
 853             # center of arc
 854             mx_pt = self.x1_pt + dmx*self.r_pt/cos(alpha/2)
 855             my_pt = self.y1_pt + dmy*self.r_pt/cos(alpha/2)
 856
 857             # angle around which arc is centered
 858             phi = degrees(math.atan2(-dmy, -dmx))
 859
 860             # half angular width of arc
 861             deltaphi = degrees(alpha)/2
 862
 863             line = lineto_pt(*_arcpoint(mx_pt, my_pt, self.r_pt, phi-deltaphi))
 864             if alpha > 0:
 865                 return [line, arc_pt(mx_pt, my_pt, self.r_pt, phi-deltaphi, phi+deltaphi)]
 866             else:
 867                 return [line, arcn_pt(mx_pt, my_pt, self.r_pt, phi-deltaphi, phi+deltaphi)]
 868
 869         except ZeroDivisionError:
 870             # in the degenerate case, we just return a line as specified by the PS
 871             # language reference
 872             return [lineto_pt(self.x1_pt, self.y1_pt)]
 873
 874     def updatebbox(self, bbox, context):
 875         for pathitem in self._pathitems(context.x_pt, context.y_pt):
 876             pathitem.updatebbox(bbox, context)
 877
 878     def updatenormpath(self, normpath, context):
 879         for pathitem in self._pathitems(context.x_pt, context.y_pt):
 880             pathitem.updatenormpath(normpath, context)
 881
 882     def outputPS(self, file, writer):
 883         file.write("%g %g %g %g %g arct\n" % (self.x1_pt, self.y1_pt,
 884                                               self.x2_pt, self.y2_pt,
 885                                               self.r_pt))
 886
 887     def returnSVGdata(self, inverse_y, first, context):
 888         # first is always False as arct cannot be first, it has no createcontext method
 889         return "".join(pathitem.returnSVGdata(inverse_y, first, context) for pathitem in self._pathitems(context.x_pt, context.y_pt))
 890
 891 #
 892 # now the pathitems that convert from user coordinates to pts
 893 #
 894
 895 class moveto(moveto_pt):
 896
 897     """Set current point to (x, y)"""
 898
 899     __slots__ = "x_pt", "y_pt"
 900
 901     def __init__(self, x, y):
 902         moveto_pt.__init__(self, unit.topt(x), unit.topt(y))
 903
 904
 905 class lineto(lineto_pt):
 906
 907     """Append straight line to (x, y)"""
 908
 909     __slots__ = "x_pt", "y_pt"
 910
 911     def __init__(self, x, y):
 912         lineto_pt.__init__(self, unit.topt(x), unit.topt(y))
 913
 914
 915 class curveto(curveto_pt):
 916
 917     """Append curveto"""
 918
 919     __slots__ = "x1_pt", "y1_pt", "x2_pt", "y2_pt", "x3_pt", "y3_pt"
 920
 921     def __init__(self, x1, y1, x2, y2, x3, y3):
 922         curveto_pt.__init__(self,
 923                             unit.topt(x1), unit.topt(y1),
 924                             unit.topt(x2), unit.topt(y2),
 925                             unit.topt(x3), unit.topt(y3))
 926
 927 class rmoveto(rmoveto_pt):
 928
 929     """Perform relative moveto"""
 930
 931     __slots__ = "dx_pt", "dy_pt"
 932
 933     def __init__(self, dx, dy):
 934         rmoveto_pt.__init__(self, unit.topt(dx), unit.topt(dy))
 935
 936
 937 class rlineto(rlineto_pt):
 938
 939     """Perform relative lineto"""
 940
 941     __slots__ = "dx_pt", "dy_pt"
 942
 943     def __init__(self, dx, dy):
 944         rlineto_pt.__init__(self, unit.topt(dx), unit.topt(dy))
 945
 946
 947 class rcurveto(rcurveto_pt):
 948
 949     """Append rcurveto"""
 950
 951     __slots__ = "dx1_pt", "dy1_pt", "dx2_pt", "dy2_pt", "dx3_pt", "dy3_pt"
 952
 953     def __init__(self, dx1, dy1, dx2, dy2, dx3, dy3):
 954         rcurveto_pt.__init__(self,
 955                              unit.topt(dx1), unit.topt(dy1),
 956                              unit.topt(dx2), unit.topt(dy2),
 957                              unit.topt(dx3), unit.topt(dy3))
 958
 959
 960 class arcn(arcn_pt):
 961
 962     """Append clockwise arc"""
 963
 964     __slots__ = "x_pt", "y_pt", "r_pt", "angle1", "angle2"
 965
 966     def __init__(self, x, y, r, angle1, angle2):
 967         arcn_pt.__init__(self, unit.topt(x), unit.topt(y), unit.topt(r), angle1, angle2)
 968
 969
 970 class arc(arc_pt):
 971
 972     """Append counterclockwise arc"""
 973
 974     __slots__ = "x_pt", "y_pt", "r_pt", "angle1", "angle2"
 975
 976     def __init__(self, x, y, r, angle1, angle2):
 977         arc_pt.__init__(self, unit.topt(x), unit.topt(y), unit.topt(r), angle1, angle2)
 978
 979
 980 class arct(arct_pt):
 981
 982     """Append tangent arc"""
 983
 984     __slots__ = "x1_pt", "y1_pt", "x2_pt", "y2_pt", "r_pt"
 985
 986     def __init__(self, x1, y1, x2, y2, r):
 987         arct_pt.__init__(self, unit.topt(x1), unit.topt(y1),
 988                          unit.topt(x2), unit.topt(y2), unit.topt(r))
 989
 990 #
 991 # "combined" pathitems provided for performance reasons
 992 #
 993
 994 class multilineto_pt(pathitem):
 995
 996     """Perform multiple linetos (coordinates in pts)"""
 997
 998     __slots__ = "points_pt"
 999
1000     def __init__(self, points_pt):
1001         self.points_pt = points_pt
1002
1003     def __str__(self):
1004         result = []
1005         for point_pt in self.points_pt:
1006             result.append("(%g, %g)" % point_pt )
1007         return "multilineto_pt([%s])" % (", ".join(result))
1008
1009     def updatebbox(self, bbox, context):
1010         for point_pt in self.points_pt:
1011             bbox.includepoint_pt(*point_pt)
1012         if self.points_pt:
1013             context.x_pt, context.y_pt = self.points_pt[-1]
1014
1015     def updatenormpath(self, normpath, context):
1016         x0_pt, y0_pt = context.x_pt, context.y_pt
1017         for point_pt in self.points_pt:
1018             normpath.normsubpaths[-1].append(normline_pt(x0_pt, y0_pt, *point_pt))
1019             x0_pt, y0_pt = point_pt
1020         context.x_pt, context.y_pt = x0_pt, y0_pt
1021
1022     def outputPS(self, file, writer):
1023         for point_pt in self.points_pt:
1024             file.write("%g %g lineto\n" % point_pt )
1025
1026     def returnSVGdata(self, inverse_y, first, context):
1027         if self.points_pt:
1028             context.x_pt, context.y_pt = self.points_pt[-1]
1029         if inverse_y:
1030             return "".join("L%g %g" % (x_pt, -y_pt) for x_pt, y_pt in self.points_pt)
1031         return "".join("L%g %g" % point_pt for point_pt in self.points_pt)
1032
1033
1034 class multicurveto_pt(pathitem):
1035
1036     """Perform multiple curvetos (coordinates in pts)"""
1037
1038     __slots__ = "points_pt"
1039
1040     def __init__(self, points_pt):
1041         self.points_pt = points_pt
1042
1043     def __str__(self):
1044         result = []
1045         for point_pt in self.points_pt:
1046             result.append("(%g, %g, %g, %g, %g, %g)" % point_pt )
1047         return "multicurveto_pt([%s])" % (", ".join(result))
1048
1049     def updatebbox(self, bbox, context):
1050         for point_pt in self.points_pt:
1051             xmin_pt, xmax_pt = _bezierpolyrange(context.x_pt, point_pt[0], point_pt[2], point_pt[4])
1052             ymin_pt, ymax_pt = _bezierpolyrange(context.y_pt, point_pt[1], point_pt[3], point_pt[5])
1053             bbox.includepoint_pt(xmin_pt, ymin_pt)
1054             bbox.includepoint_pt(xmax_pt, ymax_pt)
1055             context.x_pt, context.y_pt = point_pt[4:]
1056
1057     def updatenormpath(self, normpath, context):
1058         x0_pt, y0_pt = context.x_pt, context.y_pt
1059         for point_pt in self.points_pt:
1060             normpath.normsubpaths[-1].append(normcurve_pt(x0_pt, y0_pt, *point_pt))
1061             x0_pt, y0_pt = point_pt[4:]
1062         context.x_pt, context.y_pt = x0_pt, y0_pt
1063
1064     def outputPS(self, file, writer):
1065         for point_pt in self.points_pt:
1066             file.write("%g %g %g %g %g %g curveto\n" % point_pt)
1067
1068     def returnSVGdata(self, inverse_y, first, context):
1069         if self.points_pt:
1070             context.x_pt, context.y_pt = self.points_pt[-1][4:]
1071         if inverse_y:
1072             return "".join("C%g %g %g %g %g %g" % (x1_pt, -y1_pt, x2_pt, -y2_pt, x3_pt, -y3_pt)
1073                            for x1_pt, y1_pt, x2_pt, y2_pt, x3_pt, y3_pt in self.points_pt)
1074         return "".join("C%g %g %g %g %g %g" % point_pt for point_pt in self.points_pt)
1075
1076
1077 ################################################################################
1078 # path: PS style path
1079 ################################################################################
1080
1081 class path:
1082
1083     """PS style path"""
1084
1085     __slots__ = "pathitems", "_normpath"
1086
1087     def __init__(self, *pathitems):
1088         """construct a path from pathitems *args"""
1089
1090         for apathitem in pathitems:
1091             assert isinstance(apathitem, pathitem), "only pathitem instances allowed"
1092
1093         self.pathitems = list(pathitems)
1094         # normpath cache (when no epsilon is set)
1095         self._normpath = None
1096
1097     def __add__(self, other):
1098         """create new path out of self and other"""
1099         return path(*(self.pathitems + other.path().pathitems))
1100
1101     def __iadd__(self, other):
1102         """add other inplace
1103
1104         If other is a normpath instance, it is converted to a path before
1105         being added.
1106         """
1107         self.pathitems += other.path().pathitems
1108         self._normpath = None
1109         return self
1110
1111     def __getitem__(self, i):
1112         """return path item i"""
1113         return self.pathitems[i]
1114
1115     def __len__(self):
1116         """return the number of path items"""
1117         return len(self.pathitems)
1118
1119     def __str__(self):
1120         l = ", ".join(map(str, self.pathitems))
1121         return "path(%s)" % l
1122
1123     def append(self, apathitem):
1124         """append a path item"""
1125         assert isinstance(apathitem, pathitem), "only pathitem instance allowed"
1126         self.pathitems.append(apathitem)
1127         self._normpath = None
1128
1129     def arclen_pt(self):
1130         """return arc length in pts"""
1131         return self.normpath().arclen_pt()
1132
1133     def arclen(self):
1134         """return arc length"""
1135         return self.normpath().arclen()
1136
1137     def arclentoparam_pt(self, lengths_pt):
1138         """return the param(s) matching the given length(s)_pt in pts"""
1139         return self.normpath().arclentoparam_pt(lengths_pt)
1140
1141     def arclentoparam(self, lengths):
1142         """return the param(s) matching the given length(s)"""
1143         return self.normpath().arclentoparam(lengths)
1144
1145     def at_pt(self, params):
1146         """return coordinates of path in pts at param(s) or arc length(s) in pts"""
1147         return self.normpath().at_pt(params)
1148
1149     def at(self, params):
1150         """return coordinates of path at param(s) or arc length(s)"""
1151         return self.normpath().at(params)
1152
1153     def atbegin_pt(self):
1154         """return coordinates of the beginning of first subpath in path in pts"""
1155         return self.normpath().atbegin_pt()
1156
1157     def atbegin(self):
1158         """return coordinates of the beginning of first subpath in path"""
1159         return self.normpath().atbegin()
1160
1161     def atend_pt(self):
1162         """return coordinates of the end of last subpath in path in pts"""
1163         return self.normpath().atend_pt()
1164
1165     def atend(self):
1166         """return coordinates of the end of last subpath in path"""
1167         return self.normpath().atend()
1168
1169     def bbox(self):
1170         """return bbox of path"""
1171         if self.pathitems:
1172             bbox = self.pathitems[0].createbbox()
1173             context = self.pathitems[0].createcontext()
1174             for pathitem in self.pathitems[1:]:
1175                 pathitem.updatebbox(bbox, context)
1176             return bbox
1177         else:
1178             return bboxmodule.empty()
1179
1180     def begin(self):
1181         """return param corresponding of the beginning of the path"""
1182         return self.normpath().begin()
1183
1184     def curvature_pt(self, params):
1185         """return the curvature in 1/pts at param(s) or arc length(s) in pts"""
1186         return self.normpath().curvature_pt(params)
1187
1188     def end(self):
1189         """return param corresponding of the end of the path"""
1190         return self.normpath().end()
1191
1192     def extend(self, pathitems):
1193         """extend path by pathitems"""
1194         for apathitem in pathitems:
1195             assert isinstance(apathitem, pathitem), "only pathitem instance allowed"
1196         self.pathitems.extend(pathitems)
1197         self._normpath = None
1198
1199     def intersect(self, other):
1200         """intersect self with other path
1201
1202         Returns a tuple of lists consisting of the parameter values
1203         of the intersection points of the corresponding normpath.
1204         """
1205         return self.normpath().intersect(other)
1206
1207     def join(self, other):
1208         """join other path/normpath inplace
1209
1210         If other is a normpath instance, it is converted to a path before
1211         being joined.
1212         """
1213         self.pathitems = self.joined(other).path().pathitems
1214         self._normpath = None
1215         return self
1216
1217     def joined(self, other):
1218         """return path consisting of self and other joined together"""
1219         return self.normpath().joined(other).path()
1220
1221     # << operator also designates joining
1222     __lshift__ = joined
1223
1224     def normpath(self, epsilon=_marker):
1225         """convert the path into a normpath"""
1226         # use cached value if existent and epsilon is _marker
1227         if self._normpath is not None and epsilon is _marker:
1228             return self._normpath
1229         if self.pathitems:
1230             if epsilon is _marker:
1231                 np = self.pathitems[0].createnormpath()
1232             else:
1233                 np = self.pathitems[0].createnormpath(epsilon)
1234             context = self.pathitems[0].createcontext()
1235             for pathitem in self.pathitems[1:]:
1236                 pathitem.updatenormpath(np, context)
1237         else:
1238             np = normpath()
1239         if epsilon is _marker:
1240             self._normpath = np
1241         return np
1242
1243     def paramtoarclen_pt(self, params):
1244         """return arc lenght(s) in pts matching the given param(s)"""
1245         return self.normpath().paramtoarclen_pt(params)
1246
1247     def paramtoarclen(self, params):
1248         """return arc lenght(s) matching the given param(s)"""
1249         return self.normpath().paramtoarclen(params)
1250
1251     def path(self):
1252         """return corresponding path, i.e., self"""
1253         return self
1254
1255     def reversed(self):
1256         """return reversed normpath"""
1257         # TODO: couldn't we try to return a path instead of converting it
1258         #       to a normpath (but this might not be worth the trouble)
1259         return self.normpath().reversed()
1260
1261     def rotation_pt(self, params):
1262         """return rotation at param(s) or arc length(s) in pts"""
1263         return self.normpath().rotation(params)
1264
1265     def rotation(self, params):
1266         """return rotation at param(s) or arc length(s)"""
1267         return self.normpath().rotation(params)
1268
1269     def split_pt(self, params):
1270         """split normpath at param(s) or arc length(s) in pts and return list of normpaths"""
1271         return self.normpath().split(params)
1272
1273     def split(self, params):
1274         """split normpath at param(s) or arc length(s) and return list of normpaths"""
1275         return self.normpath().split(params)
1276
1277     def tangent_pt(self, params, length):
1278         """return tangent vector of path at param(s) or arc length(s) in pts
1279
1280         If length in pts is not None, the tangent vector will be scaled to
1281         the desired length.
1282         """
1283         return self.normpath().tangent_pt(params, length)
1284
1285     def tangent(self, params, length=1):
1286         """return tangent vector of path at param(s) or arc length(s)
1287
1288         If length is not None, the tangent vector will be scaled to
1289         the desired length.
1290         """
1291         return self.normpath().tangent(params, length)
1292
1293     def trafo_pt(self, params):
1294         """return transformation at param(s) or arc length(s) in pts"""
1295         return self.normpath().trafo(params)
1296
1297     def trafo(self, params):
1298         """return transformation at param(s) or arc length(s)"""
1299         return self.normpath().trafo(params)
1300
1301     def transformed(self, trafo):
1302         """return transformed path"""
1303         return self.normpath().transformed(trafo)
1304
1305     def outputPS(self, file, writer):
1306         """write PS code to file"""
1307         for pitem in self.pathitems:
1308             pitem.outputPS(file, writer)
1309
1310     def outputPDF(self, file, writer):
1311         """write PDF code to file"""
1312         # PDF only supports normsubpathitems; we need to use a normpath
1313         # with epsilon equals None to prevent failure for paths shorter
1314         # than epsilon
1315         self.normpath(epsilon=None).outputPDF(file, writer)
1316
1317     def returnSVGdata(self, inverse_y=True):
1318         """return SVG code"""
1319         if not self.pathitems:
1320             return ""
1321         context = self.pathitems[0].createcontext()
1322         return "".join(pitem.returnSVGdata(inverse_y, not i, context) for i, pitem in enumerate(self.pathitems))
1323
1324
1325 #
1326 # some special kinds of path, again in two variants
1327 #
1328
1329 class line_pt(path):
1330
1331     """straight line from (x1_pt, y1_pt) to (x2_pt, y2_pt) in pts"""
1332
1333     def __init__(self, x1_pt, y1_pt, x2_pt, y2_pt):
1334         path.__init__(self, moveto_pt(x1_pt, y1_pt), lineto_pt(x2_pt, y2_pt))
1335
1336
1337 class curve_pt(path):
1338
1339     """bezier curve with control points (x0_pt, y1_pt),..., (x3_pt, y3_pt) in pts"""
1340
1341     def __init__(self, x0_pt, y0_pt, x1_pt, y1_pt, x2_pt, y2_pt, x3_pt, y3_pt):
1342         path.__init__(self,
1343                       moveto_pt(x0_pt, y0_pt),
1344                       curveto_pt(x1_pt, y1_pt, x2_pt, y2_pt, x3_pt, y3_pt))
1345
1346
1347 class rect_pt(path):
1348
1349     """rectangle at position (x_pt, y_pt) with width_pt and height_pt in pts"""
1350
1351     def __init__(self, x_pt, y_pt, width_pt, height_pt):
1352         path.__init__(self, moveto_pt(x_pt, y_pt),
1353                             lineto_pt(x_pt+width_pt, y_pt),
1354                             lineto_pt(x_pt+width_pt, y_pt+height_pt),
1355                             lineto_pt(x_pt, y_pt+height_pt),
1356                             closepath())
1357
1358
1359 class circle_pt(path):
1360
1361     """circle with center (x_pt, y_pt) and radius_pt in pts"""
1362
1363     def __init__(self, x_pt, y_pt, radius_pt, arcepsilon=0.1):
1364         path.__init__(self, moveto_pt(x_pt+radius_pt, y_pt),
1365                             arc_pt(x_pt, y_pt, radius_pt, arcepsilon, 360-arcepsilon),
1366                             closepath())
1367
1368
1369 class ellipse_pt(path):
1370
1371     """ellipse with center (x_pt, y_pt) in pts,
1372     the two axes (a_pt, b_pt) in pts,
1373     and the angle angle of the first axis"""
1374
1375     def __init__(self, x_pt, y_pt, a_pt, b_pt, angle, **kwargs):
1376         t = trafo.scale(a_pt, b_pt).rotated(angle).translated_pt(x_pt, y_pt)
1377         p = circle_pt(0, 0, 1, **kwargs).normpath(epsilon=None).transformed(t).path()
1378         path.__init__(self, *p.pathitems)
1379
1380
1381 class line(line_pt):
1382
1383     """straight line from (x1, y1) to (x2, y2)"""
1384
1385     def __init__(self, x1, y1, x2, y2):
1386         line_pt.__init__(self, unit.topt(x1), unit.topt(y1),
1387                                unit.topt(x2), unit.topt(y2))
1388
1389
1390 class curve(curve_pt):
1391
1392     """bezier curve with control points (x0, y1),..., (x3, y3)"""
1393
1394     def __init__(self, x0, y0, x1, y1, x2, y2, x3, y3):
1395         curve_pt.__init__(self, unit.topt(x0), unit.topt(y0),
1396                                 unit.topt(x1), unit.topt(y1),
1397                                 unit.topt(x2), unit.topt(y2),
1398                                 unit.topt(x3), unit.topt(y3))
1399
1400
1401 class rect(rect_pt):
1402
1403     """rectangle at position (x,y) with width and height"""
1404
1405     def __init__(self, x, y, width, height):
1406         rect_pt.__init__(self, unit.topt(x), unit.topt(y),
1407                                unit.topt(width), unit.topt(height))
1408
1409
1410 class circle(circle_pt):
1411
1412     """circle with center (x,y) and radius"""
1413
1414     def __init__(self, x, y, radius, **kwargs):
1415         circle_pt.__init__(self, unit.topt(x), unit.topt(y), unit.topt(radius), **kwargs)
1416
1417
1418 class ellipse(ellipse_pt):
1419
1420     """ellipse with center (x, y), the two axes (a, b),
1421     and the angle angle of the first axis"""
1422
1423     def __init__(self, x, y, a, b, angle, **kwargs):
1424         ellipse_pt.__init__(self, unit.topt(x), unit.topt(y), unit.topt(a), unit.topt(b), angle, **kwargs)