| blob | a5b5314078fc25f48857a39c6a7339c02af35b7a |
1 #!/usr/bin/env python
2 # -*- coding: ISO-8859-1 -*-
3 #
4 #
5 # Copyright (C) 2002-2005 Jörg Lehmann <joergl@users.sourceforge.net>
6 # Copyright (C) 2003-2004 Michael Schindler <m-schindler@users.sourceforge.net>
7 # Copyright (C) 2002-2005 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
25 # - correct bbox for curveto and normcurve
26 # (maybe we still need the current bbox implementation (then maybe called
27 # cbox = control box) for normcurve for the use during the
28 # intersection of bpaths)
32 import math
37 # fallback implementation for Python 2.1
45 # fallback implementation for Python 2.2 and below
52 # fallback implementation for Python 2.2 and below
56 # use new style classes when possible
59 ################################################################################
61 # global epsilon (default precision of normsubpaths)
65 global _epsilon
67 _epsilon = epsilon
69 ################################################################################
70 # Bezier helper functions
71 ################################################################################
74 """generate the best bezier curve corresponding to an arc segment"""
80 # the two endpoints should be clear
84 # optimal relative distance along tangent for second and third
85 # control point
95 apath = []
102 # guarantee that phi2>phi1 ...
105 # ... or remove unnecessary multiples of 2*pi
117 return apath
119 #
120 # we define one exception
121 #
125 ################################################################################
126 # _currentpoint: current point during walk along path
127 ################################################################################
137 __cmp__ = __add__ = __iadd__ = __sub__ = __isub__ = __mul__ = __imul__ = __div__ = __idiv__ = invalid2
144 """current point during walk along path"""
149 """initialize current point
151 By default the current point is marked invalid.
152 """
157 """mark current point invalid"""
161 """checks whether the current point is invalid"""
165 ################################################################################
166 # pathitem: element of a PS style path
167 ################################################################################
171 """element of a PS style path"""
174 """update current point of during walk along pathitem
176 changes currentpoint in place
177 """
182 """return bounding box of pathitem
184 currentpoint: current point along path
185 """
189 """return list of normalized version of pathitem
191 currentpoint: current point along path
193 Returns the path converted into a list of normline or normcurve
194 instances. Additionally instances of moveto_pt and closepath are
195 contained, which act as markers.
196 """
200 """write PS code corresponding to pathitem to file, using writer and context"""
204 """write PDF code corresponding to pathitem to file
206 Since PDF is limited to lines and curves, _normalized is used to
207 generate PDF outout. Thus only moveto_pt and closepath need to
208 implement the outputPDF method."""
212 # various pathitems
213 #
214 # Each one comes in two variants:
215 # - one with suffix _pt. This one requires the coordinates
216 # to be already in pts (mainly used for internal purposes)
217 # - another which accepts arbitrary units
222 """Connect subpath back to its starting point"""
224 __slots__ = ()
235 return None
249 """Set current point to (x_pt, y_pt) (coordinates in pts)"""
265 return None
279 """Append straight line to (x_pt, y_pt) (coordinates in pts)"""
309 """Append curveto (coordinates in pts)"""
350 """Perform relative moveto (coordinates in pts)"""
366 return None
377 """Perform relative lineto (coordinates in pts)"""
410 """Append rcurveto (coordinates in pts)"""
457 """Append counterclockwise arc (coordinates in pts)"""
473 """return starting point of arc segment"""
478 """return end point of arc segment"""
489 # starting end end point of arc segment
493 # Now, we have to determine the corners of the bbox for the
494 # arc segment, i.e. global maxima/mimima of cos(phi) and sin(phi)
495 # in the interval [phi1, phi2]. These can either be located
496 # on the borders of this interval or in the interior.
499 # guarantee that phi2>phi1
502 # next minimum of cos(phi) looking from phi1 in counterclockwise
503 # direction: 2*pi*floor((phi1-pi)/(2*pi)) + 3*pi
510 # next minimum of sin(phi) looking from phi1 in counterclockwise
511 # direction: 2*pi*floor((phi1-3*pi/2)/(2*pi)) + 7/2*pi
518 # next maximum of cos(phi) looking from phi1 in counterclockwise
519 # direction: 2*pi*floor((phi1)/(2*pi))+2*pi
526 # next maximum of sin(phi) looking from phi1 in counterclockwise
527 # direction: 2*pi*floor((phi1-pi/2)/(2*pi)) + 1/2*pi
534 # Finally, we are able to construct the bbox for the arc segment.
535 # Note that if a current point is defined, we also
536 # have to include the straight line from this point
537 # to the first point of the arc segment.
549 # get starting and end point of arc segment and bpath corresponding to arc
554 # convert to list of curvetos omitting movetos
555 nbarc = []
563 # Note that if a current point is defined, we also
564 # have to include the straight line from this point
565 # to the first point of the arc segment.
566 # Otherwise, we have to add a moveto at the beginning.
582 """Append clockwise arc (coordinates in pts)"""
598 """return starting point of arc segment"""
603 """return end point of arc segment"""
611 # in principle, we obtain bbox of an arcn element from
612 # the bounding box of the corrsponding arc element with
613 # angle1 and angle2 interchanged. Though, we have to be carefull
614 # with the straight line segment, which is added if a current point
615 # is defined.
617 # Hence, we first compute the bbox of the arc without this line:
626 # Then, we repeat the logic from arc.bbox, but with interchanged
627 # start and end points of the arc
628 # XXX: I found the code to be equal! (AW, 31.1.2005)
636 return arcbb
639 # get starting and end point of arc segment and bpath corresponding to arc
645 # convert to list of curvetos omitting movetos
646 nbarc = []
654 # Note that if a current point is defined, we also
655 # have to include the straight line from this point
656 # to the first point of the arc segment.
657 # Otherwise, we have to add a moveto at the beginning.
674 """Append tangent arc (coordinates in pts)"""
691 """return pathitem which corresponds to arct with the given currentpoint.
693 The return value is either a arc_pt, a arcn_pt or a line_pt instance.
695 This is a helper routine for _updatecurrentpoint, _bbox and _normalized,
696 which will all delegate the work to the constructed pathitem.
697 """
699 # direction of tangent 1
704 # direction of tangent 2
709 # intersection angle between two tangents in the range (-pi, pi).
710 # We take the orientation from the sign of the vector product.
711 # Negative (positive) angles alpha corresponds to a turn to the right (left)
712 # as seen from currentpoint.
719 # two tangent points
725 # direction point 1 -> center of arc
731 # center of arc
735 # angle around which arc is centered
738 # half angular width of arc
747 # in the degenerate case, we just return a line as specified by the PS
748 # language reference
765 #
766 # now the pathitems that convert from user coordinates to pts
767 #
771 """Set current point to (x, y)"""
781 """Append straight line to (x, y)"""
791 """Append curveto"""
803 """Perform relative moveto"""
813 """Perform relative lineto"""
823 """Append rcurveto"""
836 """Append clockwise arc"""
846 """Append counterclockwise arc"""
856 """Append tangent arc"""
864 #
865 # "combined" pathitems provided for performance reasons
866 #
870 """Perform multiple linetos (coordinates in pts)"""
878 result = []
895 result = []
901 return result
910 """Perform multiple curvetos (coordinates in pts)"""
918 result = []
939 result = []
945 return result
952 ################################################################################
953 # path: PS style path
954 ################################################################################
958 """PS style path"""
963 """construct a path from pathitems *args"""
969 # normpath cache
973 """create new path out of self and other"""
977 """add other inplace
979 If other is a normpath instance, it is converted to a path before
980 being added.
981 """
984 return self
987 """return path item i"""
991 """return the number of path items"""
999 """append a path item"""
1005 """return arc length in pts"""
1009 """return arc length"""
1013 """return the param(s) matching the given length(s)_pt in pts"""
1017 """return the param(s) matching the given length(s)"""
1021 """return coordinates of path in pts at param(s) or arc length(s) in pts"""
1025 """return coordinates of path at param(s) or arc length(s)"""
1029 """return coordinates of the beginning of first subpath in path in pts"""
1033 """return coordinates of the beginning of first subpath in path"""
1037 """return coordinates of the end of last subpath in path in pts"""
1041 """return coordinates of the end of last subpath in path"""
1045 """return bbox of path"""
1053 abbox = nbbox
1055 abbox += nbbox
1057 return abbox
1060 """return param corresponding of the beginning of the path"""
1064 """return the curvature radius in pts at param(s) or arc length(s) in pts
1066 The curvature radius is the inverse of the curvature. When the
1067 curvature is 0, None is returned. Note that this radius can be negative
1068 or positive, depending on the sign of the curvature."""
1072 """return the curvature radius at param(s) or arc length(s)
1074 The curvature radius is the inverse of the curvature. When the
1075 curvature is 0, None is returned. Note that this radius can be negative
1076 or positive, depending on the sign of the curvature."""
1080 """return param corresponding of the end of the path"""
1084 """extend path by pathitems"""
1091 """intersect self with other path
1093 Returns a tuple of lists consisting of the parameter values
1094 of the intersection points of the corresponding normpath.
1095 """
1099 """join other path/normpath inplace
1101 If other is a normpath instance, it is converted to a path before
1102 being joined.
1103 """
1106 return self
1109 """return path consisting of self and other joined together"""
1112 # << operator also designates joining
1113 __lshift__ = joined
1116 """convert the path into a normpath"""
1117 # use cached value if existent
1120 # split path in sub paths
1121 subpaths = []
1122 currentsubpathitems = []
1128 # append open sub path
1130 # start new sub path
1131 currentsubpathitems = []
1134 # append closed sub path
1138 currentsubpathitems = []
1144 # append open sub path
1150 """return arc lenght(s) in pts matching the given param(s)"""
1154 """return arc lenght(s) matching the given param(s)"""
1158 """return corresponding path, i.e., self"""
1159 return self
1162 """return reversed normpath"""
1163 # TODO: couldn't we try to return a path instead of converting it
1164 # to a normpath (but this might not be worth the trouble)
1168 """split normpath at param(s) or arc length(s) in pts and return list of normpaths"""
1172 """split normpath at param(s) or arc length(s) and return list of normpaths"""
1176 """return tangent vector of path at param(s) or arc length(s) in pts
1178 If length in pts is not None, the tangent vector will be scaled to
1179 the desired length.
1180 """
1184 """return tangent vector of path at param(s) or arc length(s)
1186 If length is not None, the tangent vector will be scaled to
1187 the desired length.
1188 """
1192 """return transformation at param(s) or arc length(s) in pts"""
1196 """return transformation at param(s) or arc length(s)"""
1200 """return transformed path"""
1204 """write PS code to file"""
1209 """write PDF code to file"""
1210 # PDF only supports normsubpathitems but instead of
1211 # converting to a normpath, which will fail for short
1212 # closed paths, we use outputPDF of the normalized paths
1220 #
1221 # some special kinds of path, again in two variants
1222 #
1226 """straight line from (x1_pt, y1_pt) to (x2_pt, y2_pt) in pts"""
1234 """bezier curve with control points (x0_pt, y1_pt),..., (x3_pt, y3_pt) in pts"""
1244 """rectangle at position (x, y) with width and height in pts"""
1256 """circle with center (x, y) and radius in pts"""
1259 path.__init__(self, moveto_pt(x+radius,y), arc_pt(x, y, radius, arcepsilon, 360-arcepsilon), closepath())
1264 """straight line from (x1, y1) to (x2, y2)"""
1273 """bezier curve with control points (x0, y1),..., (x3, y3)"""
1284 """rectangle at position (x,y) with width and height"""
1293 """circle with center (x,y) and radius"""
1299 ################################################################################
1300 # normsubpathitems
1301 ################################################################################
1305 """element of a normalized sub path
1307 Various operations on normsubpathitems might be subject of
1308 approximitions. Those methods get the finite precision epsilon,
1309 which is the accuracy needed expressed as a length in pts.
1311 normsubpathitems should never be modified inplace, since references
1312 might be shared betweeen several normsubpaths.
1313 """
1316 """return arc length in pts"""
1317 pass
1320 """return a tuple of params and the total length arc length in pts"""
1321 pass
1324 """return coordinates at params in pts"""
1325 pass
1328 """return coordinates of first point in pts"""
1329 pass
1332 """return coordinates of last point in pts"""
1333 pass
1336 """return bounding box of normsubpathitem"""
1337 pass
1340 """return the curvature radius at params in pts
1342 The curvature radius is the inverse of the curvature. When the
1343 curvature is 0, None is returned. Note that this radius can be negative
1344 or positive, depending on the sign of the curvature."""
1345 pass
1348 """intersect self with other normsubpathitem"""
1349 pass
1352 """return a normsubpathitem with a modified beginning point"""
1353 pass
1356 """return a normsubpathitem with a modified end point"""
1357 pass
1360 """return a tuple of arc lengths and the total arc length in pts"""
1361 pass
1364 """return pathitem corresponding to normsubpathitem"""
1367 """return reversed normsubpathitem"""
1368 pass
1371 """return segments of the normsubpathitem
1373 The returned list of normsubpathitems for the segments between
1374 the params. params needs to contain at least two values.
1375 """
1376 pass
1379 """return transformations at params"""
1382 """return transformed normsubpathitem according to trafo"""
1383 pass
1386 """write PS code corresponding to normsubpathitem to file"""
1387 pass
1390 """write PDF code corresponding to normsubpathitem to file"""
1391 pass
1396 """Straight line from (x0_pt, y0_pt) to (x1_pt, y1_pt) (coordinates in pts)"""
1410 # do self.arclen_pt inplace for performance reasons
1452 # check for intersections out of bound
1453 # TODO: we might allow for a small out of bound errors.
1457 # return parameters of intersection
1482 result = []
1489 xl_pt = xr_pt
1490 yl_pt = yr_pt
1491 return result
1499 return normline_pt(*(trafo._apply(self.x0_pt, self.y0_pt) + trafo._apply(self.x1_pt, self.y1_pt)))
1510 """Bezier curve with control points x0_pt, y0_pt, x1_pt, y1_pt, x2_pt, y2_pt, x3_pt, y3_pt (coordinates in pts)"""
1525 return "normcurve_pt(%g, %g, %g, %g, %g, %g, %g, %g)" % (self.x0_pt, self.y0_pt, self.x1_pt, self.y1_pt,
1529 """split curve into two parts
1531 Helper method to reduce the complexity of a problem by turning
1532 a normcurve_pt into several normline_pt segments. This method
1533 returns normcurve_pt instances only, when they are not yet straight
1534 enough to be replaceable by normcurve_pt instances. Thus a recursive
1535 midpointsplitting will turn a curve into line segments with the
1536 given precision epsilon.
1537 """
1539 # first, we have to calculate the midpoints between adjacent
1540 # control points
1548 # In the next iterative step, we need the midpoints between 01 and 12
1549 # and between 12 and 23
1555 # Finally the midpoint is given by
1559 # Before returning the normcurves we check whether we can
1560 # replace them by normlines within an error of epsilon pts.
1561 # The maximal error value is given by the modulus of the
1562 # difference between the length of the control polygon
1563 # (i.e. |P1-P0|+|P2-P1|+|P3-P2|), which consitutes an upper
1564 # bound for the length, and the length of the straight line
1565 # between start and end point of the normcurve (i.e. |P3-P1|),
1566 # which represents a lower bound.
1596 params_b, arclen_b = b._arclentoparam_pt([length_pt - arclen_a for length_pt in lengths_pt], epsilon)
1597 params = []
1633 result = []
1653 return result
1656 # we can immediately quit when the bboxes are not overlapping
1660 # To improve the performance in the general case we alternate the
1661 # splitting process between the two normsubpathitems
1678 arclens_pt = [segment.arclen_pt(epsilon) for segment in self.segments([0] + list(params) + [1])]
1687 return normcurve_pt(self.x3_pt, self.y3_pt, self.x2_pt, self.y2_pt, self.x1_pt, self.y1_pt, self.x0_pt, self.y0_pt)
1693 # first, we calculate the coefficients corresponding to our
1694 # original bezier curve. These represent a useful starting
1695 # point for the following change of the polynomial parameter
1705 result = []
1711 # [t1,t2] part
1712 #
1713 # the new coefficients of the [t1,t1+dt] part of the bezier curve
1714 # are then given by expanding
1715 # a0 + a1*(t1+dt*u) + a2*(t1+dt*u)**2 +
1716 # a3*(t1+dt*u)**3 in u, yielding
1717 #
1718 # a0 + a1*t1 + a2*t1**2 + a3*t1**3 +
1719 # ( a1 + 2*a2 + 3*a3*t1**2 )*dt * u +
1720 # ( a2 + 3*a3*t1 )*dt**2 * u**2 +
1721 # a3*dt**3 * u**3
1722 #
1723 # from this values we obtain the new control points by inversion
1724 #
1725 # TODO: we could do this more efficiently by reusing for
1726 # (x0_pt, y0_pt) the control point (x3_pt, y3_pt) from the previous
1727 # Bezier curve
1740 return result
1743 result = []
1752 return result
1762 file.write("%g %g %g %g %g %g curveto\n" % (self.x1_pt, self.y1_pt, self.x2_pt, self.y2_pt, self.x3_pt, self.y3_pt))
1765 file.write("%f %f %f %f %f %f c\n" % (self.x1_pt, self.y1_pt, self.x2_pt, self.y2_pt, self.x3_pt, self.y3_pt))
1768 ################################################################################
1769 # normsubpath
1770 ################################################################################
1774 """sub path of a normalized path
1776 A subpath consists of a list of normsubpathitems, i.e., normlines_pt and
1777 normcurves_pt and can either be closed or not.
1779 Some invariants, which have to be obeyed:
1780 - All normsubpathitems have to be longer than epsilon pts.
1781 - At the end there may be a normline (stored in self.skippedline) whose
1782 length is shorter than epsilon -- it has to be taken into account
1783 when adding further normsubpathitems
1784 - The last point of a normsubpathitem and the first point of the next
1785 element have to be equal.
1786 - When the path is closed, the last point of last normsubpathitem has
1787 to be equal to the first point of the first normsubpathitem.
1788 """
1793 """construct a normsubpath"""
1795 epsilon = _epsilon
1797 # If one or more items appended to the normsubpath have been
1798 # skipped (because their total length was shorter than epsilon),
1799 # we remember this fact by a line because we have to take it
1800 # properly into account when appending further normsubpathitems
1806 # a test (might be temporary)
1808 assert isinstance(anormsubpathitem, normsubpathitem), "only list of normsubpathitem instances allowed"
1816 """return normsubpathitem i"""
1820 """return number of normsubpathitems"""
1831 """return a dictionary mapping normsubpathitemindices to a tuple
1832 of a paramindices and normsubpathitemparams.
1834 normsubpathitemindex specifies a normsubpathitem containing
1835 one or several positions. paramindex specify the index of the
1836 param in the original list and normsubpathitemparam is the
1837 parameter value in the normsubpathitem.
1838 """
1840 result = {}
1851 return result
1854 """append normsubpathitem
1856 Fails on closed normsubpath.
1857 """
1858 # consitency tests (might be temporary)
1861 assert math.hypot(*[x-y for x, y in zip(self.skippedline.atend_pt(), anormsubpathitem.atbegin_pt())]) < self.epsilon, "normsubpathitems do not match"
1863 assert math.hypot(*[x-y for x, y in zip(self.normsubpathitems[-1].atend_pt(), anormsubpathitem.atbegin_pt())]) < self.epsilon, "normsubpathitems do not match"
1884 """return arc length in pts"""
1888 """return a tuple of params and the total length arc length in pts"""
1889 # work on a copy which is counted down to negative values
1900 # overwrite the results until the length has become negative
1902 totalarclen += arclen
1907 """return coordinates at params in pts"""
1910 for index, point_pt in zip(indices, self.normsubpathitems[normsubpathitemindex].at_pt(params)):
1912 return result
1915 """return coordinates of first point in pts"""
1921 """return coordinates of last point in pts"""
1927 """return bounding box of normsubpath"""
1932 return abbox
1934 return None
1937 """close subnormpath
1939 Fails on closed normsubpath.
1940 """
1953 # the append might have left a skippedline, which we have to remove
1954 # from the end of the closed path
1956 self.normsubpathitems[-1] = self.normsubpathitems[-1].modifiedend_pt(*self.skippedline.atend_pt())
1962 """return copy of normsubpath"""
1963 # Since normsubpathitems are never modified inplace, we just
1964 # need to copy the normsubpathitems list. We do not pass the
1965 # normsubpathitems to the constructor to not repeat the checks
1966 # for minimal length of each normsubpathitem.
1971 # We can share the reference to skippedline, since it is a
1972 # normsubpathitem as well and thus not modified in place either.
1975 return result
1978 """return the curvature radius at params in pts
1980 The curvature radius is the inverse of the curvature. When the
1981 curvature is 0, None is returned. Note that this radius can be negative
1982 or positive, depending on the sign of the curvature."""
1985 for index, radius_pt in zip(indices, self.normsubpathitems[normsubpathitemindex].curveradius_pt(params)):
1987 return result
1990 """extend path by normsubpathitems
1992 Fails on closed normsubpath.
1993 """
1998 """intersect self with other normsubpath
2000 Returns a tuple of lists consisting of the parameter values
2001 of the intersection points of the corresponding normsubpath.
2002 """
2003 intersections_a = []
2004 intersections_b = []
2006 # Intersect all subpaths of self with the subpaths of other, possibly including
2007 # one intersection point several times
2014 # although intersectipns_a are sorted for the different normsubpathitems,
2015 # within a normsubpathitem, the ordering has to be ensured separately:
2021 # for symmetry reasons we enumerate intersections_a as well, although
2022 # they are already sorted (note we do not need to sort intersections_a)
2027 # now we search for intersections points which are closer together than epsilon
2028 # This task is handled by the following function
2030 split = normsubpath.segments([0] + [intersection for intersection, index in intersections] + [len(normsubpath)])
2031 result = []
2033 # note that the number of segments of a closed path is off by one
2034 # compared to an open path
2038 j = i
2051 break
2057 j = i
2068 break
2070 return result
2075 # map intersection point to lowest point which is equivalent to the
2076 # point
2086 # determine the remaining intersection points
2087 intersectionpoints = {}
2091 # build result
2092 result = []
2098 result_a = intersection_a
2101 result_b = intersection_b
2103 # note that the result is sorted in a, since we sorted
2104 # intersections_a in the very beginning
2109 """join other normsubpath inplace
2111 Fails on closed normsubpath. Fails to join closed normsubpath.
2112 """
2116 # insert connection line
2121 # append other normsubpathitems
2127 """return joined self and other
2129 Fails on closed normsubpath. Fails to join closed normsubpath.
2130 """
2133 return result
2136 """return a tuple of arc lengths and the total arc length in pts"""
2143 arclens_pt, normsubpathitemarclen_pt = self.normsubpathitems[normsubpathitemindex]._paramtoarclen_pt(params, self.epsilon)
2146 totalarclen_pt += normsubpathitemarclen_pt
2152 """return list of pathitems"""
2156 # remove trailing normline_pt of closed subpaths
2167 return result
2170 """return reversed normsubpath"""
2171 nnormpathitems = []
2177 """return segments of the normsubpath
2179 The returned list of normsubpaths for the segments between
2180 the params. params need to contain at least two values.
2182 For a closed normsubpath the last segment result is joined to
2183 the first one when params starts with 0 and ends with len(self).
2184 or params starts with len(self) and ends with 0. Thus a segments
2185 operation on a closed normsubpath might properly join those the
2186 first and the last part to take into account the closed nature of
2187 the normsubpath. However, for intermediate parameters, closepath
2188 is not taken into account, i.e. when walking backwards you do not
2189 loop over the closepath forwardly. The special values 0 and
2190 len(self) for the first and the last parameter should be given as
2191 integers, i.e. no finite precision is used when checking for
2192 equality."""
2199 # instead of distribute the parameters, we need to keep their
2200 # order and collect parameters for the needed segments of
2201 # normsubpathitem with index collectindex
2202 collectparams = []
2205 # calculate index and parameter for corresponding normsubpathitem
2210 param -= index
2215 # append end point depening on the forthcoming index
2220 # get segments of the normsubpathitem and add them to the result
2224 # add normsubpathitems and first segment parameter to close the
2225 # gap to the forthcoming index
2234 collectindex = index
2236 # add remaining collectparams to the result
2242 # join last and first segment together if the normsubpath was
2243 # originally closed and first and the last parameters are the
2244 # beginning and end points of the normsubpath
2250 return result
2253 """return transformations at params"""
2258 return result
2261 """return transformed path"""
2269 return nnormsubpath
2272 # if the normsubpath is closed, we must not output a normline at
2273 # the end
2275 return
2277 assert len(self.normsubpathitems) > 1, "a closed normsubpath should contain more than a single normline_pt"
2288 # if the normsubpath is closed, we must not output a normline at
2289 # the end
2291 return
2293 assert len(self.normsubpathitems) > 1, "a closed normsubpath should contain more than a single normline_pt"
2304 ################################################################################
2305 # normpath
2306 ################################################################################
2310 """parameter of a certain point along a normpath"""
2321 return "normpathparam(%s, %s, %s)" % (self.normpath, self.normsubpathindex, self.normsubpathparam)
2331 __radd__ = __add__
2342 # other has to be a length in this case
2343 return self.normpath.arclentoparam_pt(-self.normpath.paramtoarclen_pt(self) + unit.topt(other))
2348 __rmul__ = __mul__
2359 return cmp((self.normsubpathindex, self.normsubpathparam), (other.normsubpathindex, other.normsubpathparam))
2364 """return arc length in pts corresponding to the normpathparam """
2368 """return arc length corresponding to the normpathparam """
2373 """Creates a method which takes a single argument or a list and
2374 returns a single value or a list out of method, which always
2375 works on lists."""
2380 break
2384 return wrappedmethod
2389 """normalized path
2391 A normalized path consists of a list of normsubpaths.
2392 """
2395 """construct a normpath from a list of normsubpaths"""
2405 """create new normpath out of self and other"""
2407 result += other
2408 return result
2411 """add other inplace"""
2414 return self
2417 """return normsubpath i"""
2421 """return the number of normsubpaths"""
2428 """return params with all non-normpathparam arguments converted by convertmethod
2430 usecases:
2431 - self._convertparams(params, self.arclentoparam_pt)
2432 - self._convertparams(params, self.arclentoparam)
2433 """
2435 converttoparams = []
2436 convertparamindices = []
2445 return params
2448 """return a dictionary mapping subpathindices to a tuple of a paramindices and subpathparams
2450 subpathindex specifies a subpath containing one or several positions.
2451 paramindex specify the index of the normpathparam in the original list and
2452 subpathparam is the parameter value in the subpath.
2453 """
2455 result = {}
2461 return result
2464 """append a normsubpath by a normsubpath or a pathitem"""
2466 # the normsubpaths list can be appended by a normsubpath only
2469 # ... but we are kind and allow for regular path items as well
2470 # in order to make a normpath to behave more like a regular path
2482 """return arc length in pts"""
2486 """return arc length"""
2490 """return the params matching the given lengths_pt"""
2491 # work on a copy which is counted down to negative values
2502 # overwrite the results until the length has become negative
2506 break
2508 return results
2511 """return the param(s) matching the given length(s)_pt in pts"""
2512 pass
2516 """return the param(s) matching the given length(s)"""
2521 """return coordinates of normpath in pts at params"""
2526 return result
2529 """return coordinates of normpath in pts at param(s) or lengths in pts"""
2534 """return coordinates of normpath at param(s) or arc lengths"""
2540 """return coordinates of the beginning of first subpath in normpath in pts"""
2547 """return coordinates of the beginning of first subpath in normpath"""
2552 """return coordinates of the end of last subpath in normpath in pts"""
2559 """return coordinates of the end of last subpath in normpath"""
2564 """return bbox of normpath"""
2569 abbox = nbbox
2571 abbox += nbbox
2572 return abbox
2575 """return param corresponding of the beginning of the normpath"""
2582 """return copy of normpath"""
2586 return result
2589 """return the curvature radius at params in pts
2591 The curvature radius is the inverse of the curvature. When the
2592 curvature is 0, None is returned. Note that this radius can be negative
2593 or positive, depending on the sign of the curvature."""
2597 for index, radius_pt in zip(indices, self.normsubpaths[normsubpathindex].curveradius_pt(params)):
2599 return result
2602 """return the curvature radius in pts at param(s) or arc length(s) in pts
2604 The curvature radius is the inverse of the curvature. When the
2605 curvature is 0, None is returned. Note that this radius can be negative
2606 or positive, depending on the sign of the curvature."""
2612 """return the curvature radius at param(s) or arc length(s)
2614 The curvature radius is the inverse of the curvature. When the
2615 curvature is 0, None is returned. Note that this radius can be negative
2616 or positive, depending on the sign of the curvature."""
2618 result = []
2624 return result
2628 """return param corresponding of the end of the path"""
2635 """extend path by normsubpaths or pathitems"""
2637 # use append to properly handle regular path items as well as normsubpaths
2641 """intersect self with other path
2643 Returns a tuple of lists consisting of the parameter values
2644 of the intersection points of the corresponding normpath.
2645 """
2648 # here we build up the result
2649 intersections = ([], [])
2651 # Intersect all normsubpaths of self with the normsubpaths of
2652 # other.
2658 return intersections
2661 """join other normsubpath inplace
2663 Both normpaths must contain at least one normsubpath.
2664 The last normsubpath of self will be joined to the first
2665 normsubpath of other.
2666 """
2675 """return joined self and other
2677 Both normpaths must contain at least one normsubpath.
2678 The last normsubpath of self will be joined to the first
2679 normsubpath of other.
2680 """
2683 return result
2685 # << operator also designates joining
2686 __lshift__ = joined
2689 """return a normpath, i.e. self"""
2690 return self
2693 """return arc lengths in pts matching the given params"""
2700 arclens_pt, normsubpatharclen_pt = self.normsubpaths[normsubpathindex]._paramtoarclen_pt(params)
2703 totalarclen_pt += normsubpatharclen_pt
2706 return result
2709 """return arc length(s) in pts matching the given param(s)"""
2713 """return arc length(s) matching the given param(s)"""
2718 """return path corresponding to normpath"""
2719 pathitems = []
2725 """return reversed path"""
2729 return nnormpath
2732 """split path at params and return list of normpaths"""
2734 # instead of distributing the parameters, we need to keep their
2735 # order and collect parameters for splitting of normsubpathitem
2736 # with index collectindex
2741 # append end point depening on the forthcoming index
2746 # get segments of the normsubpath and add them to the result
2750 # add normsubpathitems and first segment parameter to close the
2751 # gap to the forthcoming index
2765 # add remaining collectparams to the result
2771 return result
2774 """split path at param(s) or arc length(s) in pts and return list of normpaths"""
2777 break
2783 """split path at param(s) or arc length(s) and return list of normpaths"""
2786 break
2792 """return tangent vector of path at params
2794 If length is not None, the tangent vector will be scaled to
2795 the desired length.
2796 """
2805 tangentpath = tangentpath.transformed(trafo.scale_pt(sfactor, sfactor, *tangentpath.atbegin_pt()))
2807 return result
2810 """return tangent vector of path at param(s) or arc length(s) in pts
2812 If length in pts is not None, the tangent vector will be scaled to
2813 the desired length.
2814 """
2819 """return tangent vector of path at param(s) or arc length(s)
2821 If length is not None, the tangent vector will be scaled to
2822 the desired length.
2823 """
2828 """return transformation at params"""
2833 return result
2836 """return transformation at param(s) or arc length(s) in pts"""
2841 """return transformation at param(s) or arc length(s)"""
2846 """return transformed normpath"""