| blob | ada27c0e02b3ba476621f7dbc7e9058f966cde9f |
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__ = ()
230 pass
233 return None
247 """Set current point to (x_pt, y_pt) (coordinates in pts)"""
263 return None
277 """Append straight line to (x_pt, y_pt) (coordinates in pts)"""
307 """Append curveto (coordinates in pts)"""
348 """Perform relative moveto (coordinates in pts)"""
364 return None
375 """Perform relative lineto (coordinates in pts)"""
408 """Append rcurveto (coordinates in pts)"""
455 """Append counterclockwise arc (coordinates in pts)"""
471 """return starting point of arc segment"""
476 """return end point of arc segment"""
487 # starting end end point of arc segment
491 # Now, we have to determine the corners of the bbox for the
492 # arc segment, i.e. global maxima/mimima of cos(phi) and sin(phi)
493 # in the interval [phi1, phi2]. These can either be located
494 # on the borders of this interval or in the interior.
497 # guarantee that phi2>phi1
500 # next minimum of cos(phi) looking from phi1 in counterclockwise
501 # direction: 2*pi*floor((phi1-pi)/(2*pi)) + 3*pi
508 # next minimum of sin(phi) looking from phi1 in counterclockwise
509 # direction: 2*pi*floor((phi1-3*pi/2)/(2*pi)) + 7/2*pi
516 # next maximum of cos(phi) looking from phi1 in counterclockwise
517 # direction: 2*pi*floor((phi1)/(2*pi))+2*pi
524 # next maximum of sin(phi) looking from phi1 in counterclockwise
525 # direction: 2*pi*floor((phi1-pi/2)/(2*pi)) + 1/2*pi
532 # Finally, we are able to construct the bbox for the arc segment.
533 # Note that if a current point is defined, we also
534 # have to include the straight line from this point
535 # to the first point of the arc segment.
547 # get starting and end point of arc segment and bpath corresponding to arc
552 # convert to list of curvetos omitting movetos
553 nbarc = []
561 # Note that if a current point is defined, we also
562 # have to include the straight line from this point
563 # to the first point of the arc segment.
564 # Otherwise, we have to add a moveto at the beginning.
580 """Append clockwise arc (coordinates in pts)"""
596 """return starting point of arc segment"""
601 """return end point of arc segment"""
609 # in principle, we obtain bbox of an arcn element from
610 # the bounding box of the corrsponding arc element with
611 # angle1 and angle2 interchanged. Though, we have to be carefull
612 # with the straight line segment, which is added if a current point
613 # is defined.
615 # Hence, we first compute the bbox of the arc without this line:
624 # Then, we repeat the logic from arc.bbox, but with interchanged
625 # start and end points of the arc
626 # XXX: I found the code to be equal! (AW, 31.1.2005)
634 return arcbb
637 # get starting and end point of arc segment and bpath corresponding to arc
643 # convert to list of curvetos omitting movetos
644 nbarc = []
652 # Note that if a current point is defined, we also
653 # have to include the straight line from this point
654 # to the first point of the arc segment.
655 # Otherwise, we have to add a moveto at the beginning.
672 """Append tangent arc (coordinates in pts)"""
689 """return pathitem which corresponds to arct with the given currentpoint.
691 The return value is either a arc_pt, a arcn_pt or a line_pt instance.
693 This is a helper routine for _updatecurrentpoint, _bbox and _normalized,
694 which will all delegate the work to the constructed pathitem.
695 """
697 # direction of tangent 1
702 # direction of tangent 2
707 # intersection angle between two tangents in the range (-pi, pi).
708 # We take the orientation from the sign of the vector product.
709 # Negative (positive) angles alpha corresponds to a turn to the right (left)
710 # as seen from currentpoint.
717 # two tangent points
723 # direction point 1 -> center of arc
729 # center of arc
733 # angle around which arc is centered
736 # half angular width of arc
745 # in the degenerate case, we just return a line as specified by the PS
746 # language reference
763 #
764 # now the pathitems that convert from user coordinates to pts
765 #
769 """Set current point to (x, y)"""
779 """Append straight line to (x, y)"""
789 """Append curveto"""
801 """Perform relative moveto"""
811 """Perform relative lineto"""
821 """Append rcurveto"""
834 """Append clockwise arc"""
844 """Append counterclockwise arc"""
854 """Append tangent arc"""
862 #
863 # "combined" pathitems provided for performance reasons
864 #
868 """Perform multiple linetos (coordinates in pts)"""
876 result = []
893 result = []
899 return result
908 """Perform multiple curvetos (coordinates in pts)"""
916 result = []
937 result = []
943 return result
950 ################################################################################
951 # path: PS style path
952 ################################################################################
956 """PS style path"""
961 """construct a path from pathitems *args"""
967 # normpath cache
971 """create new path out of self and other"""
975 """add other inplace
977 If other is a normpath instance, it is converted to a path before
978 being added.
979 """
982 return self
985 """return path item i"""
989 """return the number of path items"""
997 """append a path item"""
1003 """return arc length in pts"""
1007 """return arc length"""
1011 """return the param(s) matching the given length(s)_pt in pts"""
1015 """return the param(s) matching the given length(s)"""
1019 """return coordinates of path in pts at param(s) or arc length(s) in pts"""
1023 """return coordinates of path at param(s) or arc length(s)"""
1027 """return coordinates of the beginning of first subpath in path in pts"""
1031 """return coordinates of the beginning of first subpath in path"""
1035 """return coordinates of the end of last subpath in path in pts"""
1039 """return coordinates of the end of last subpath in path"""
1043 """return bbox of path"""
1051 abbox = nbbox
1053 abbox += nbbox
1055 return abbox
1058 """return param corresponding of the beginning of the path"""
1062 """return the curvature radius in pts at param(s) or arc length(s) in pts
1064 The curvature radius is the inverse of the curvature. When the
1065 curvature is 0, None is returned. Note that this radius can be negative
1066 or positive, depending on the sign of the curvature."""
1070 """return the curvature radius at param(s) or arc length(s)
1072 The curvature radius is the inverse of the curvature. When the
1073 curvature is 0, None is returned. Note that this radius can be negative
1074 or positive, depending on the sign of the curvature."""
1078 """return param corresponding of the end of the path"""
1082 """extend path by pathitems"""
1089 """intersect self with other path
1091 Returns a tuple of lists consisting of the parameter values
1092 of the intersection points of the corresponding normpath.
1093 """
1097 """join other path/normpath inplace
1099 If other is a normpath instance, it is converted to a path before
1100 being joined.
1101 """
1104 return self
1107 """return path consisting of self and other joined together"""
1110 # << operator also designates joining
1111 __lshift__ = joined
1114 """convert the path into a normpath"""
1115 # use cached value if existent
1118 # split path in sub paths
1119 subpaths = []
1120 currentsubpathitems = []
1126 # append open sub path
1128 # start new sub path
1129 currentsubpathitems = []
1132 # append closed sub path
1136 currentsubpathitems = []
1142 # append open sub path
1148 """return arc lenght(s) in pts matching the given param(s)"""
1152 """return arc lenght(s) matching the given param(s)"""
1156 """return corresponding path, i.e., self"""
1157 return self
1160 """return reversed normpath"""
1161 # TODO: couldn't we try to return a path instead of converting it
1162 # to a normpath (but this might not be worth the trouble)
1166 """split normpath at param(s) or arc length(s) in pts and return list of normpaths"""
1170 """split normpath at param(s) or arc length(s) and return list of normpaths"""
1174 """return tangent vector of path at param(s) or arc length(s) in pts
1176 If length in pts is not None, the tangent vector will be scaled to
1177 the desired length.
1178 """
1182 """return tangent vector of path at param(s) or arc length(s)
1184 If length is not None, the tangent vector will be scaled to
1185 the desired length.
1186 """
1190 """return transformation at param(s) or arc length(s) in pts"""
1194 """return transformation at param(s) or arc length(s)"""
1198 """return transformed path"""
1202 """write PS code to file"""
1207 """write PDF code to file"""
1208 # PDF only supports normsubpathitems but instead of
1209 # converting to a normpath, which will fail for short
1210 # closed paths, we use outputPDF of the normalized paths
1218 #
1219 # some special kinds of path, again in two variants
1220 #
1224 """straight line from (x1_pt, y1_pt) to (x2_pt, y2_pt) in pts"""
1232 """bezier curve with control points (x0_pt, y1_pt),..., (x3_pt, y3_pt) in pts"""
1242 """rectangle at position (x, y) with width and height in pts"""
1254 """circle with center (x, y) and radius in pts"""
1257 path.__init__(self, moveto_pt(x+radius,y), arc_pt(x, y, radius, arcepsilon, 360-arcepsilon), closepath())
1262 """straight line from (x1, y1) to (x2, y2)"""
1271 """bezier curve with control points (x0, y1),..., (x3, y3)"""
1282 """rectangle at position (x,y) with width and height"""
1291 """circle with center (x,y) and radius"""
1297 ################################################################################
1298 # normsubpathitems
1299 ################################################################################
1303 """element of a normalized sub path
1305 Various operations on normsubpathitems might be subject of
1306 approximitions. Those methods get the finite precision epsilon,
1307 which is the accuracy needed expressed as a length in pts.
1309 normsubpathitems should never be modified inplace, since references
1310 might be shared betweeen several normsubpaths.
1311 """
1314 """return arc length in pts"""
1315 pass
1318 """return a tuple of params and the total length arc length in pts"""
1319 pass
1322 """return coordinates at params in pts"""
1323 pass
1326 """return coordinates of first point in pts"""
1327 pass
1330 """return coordinates of last point in pts"""
1331 pass
1334 """return bounding box of normsubpathitem"""
1335 pass
1338 """return the curvature radius at params in pts
1340 The curvature radius is the inverse of the curvature. When the
1341 curvature is 0, None is returned. Note that this radius can be negative
1342 or positive, depending on the sign of the curvature."""
1343 pass
1346 """intersect self with other normsubpathitem"""
1347 pass
1350 """return a normsubpathitem with a modified beginning point"""
1351 pass
1354 """return a normsubpathitem with a modified end point"""
1355 pass
1358 """return a tuple of arc lengths and the total arc length in pts"""
1359 pass
1362 """return pathitem corresponding to normsubpathitem"""
1365 """return reversed normsubpathitem"""
1366 pass
1369 """return segments of the normsubpathitem
1371 The returned list of normsubpathitems for the segments between
1372 the params. params needs to contain at least two values.
1373 """
1374 pass
1377 """return transformations at params"""
1380 """return transformed normsubpathitem according to trafo"""
1381 pass
1384 """write PS code corresponding to normsubpathitem to file"""
1385 pass
1388 """write PDF code corresponding to normsubpathitem to file"""
1389 pass
1394 """Straight line from (x0_pt, y0_pt) to (x1_pt, y1_pt) (coordinates in pts)"""
1408 # do self.arclen_pt inplace for performance reasons
1450 # check for intersections out of bound
1451 # TODO: we might allow for a small out of bound errors.
1455 # return parameters of intersection
1480 result = []
1487 xl_pt = xr_pt
1488 yl_pt = yr_pt
1489 return result
1497 return normline_pt(*(trafo._apply(self.x0_pt, self.y0_pt) + trafo._apply(self.x1_pt, self.y1_pt)))
1508 """Bezier curve with control points x0_pt, y0_pt, x1_pt, y1_pt, x2_pt, y2_pt, x3_pt, y3_pt (coordinates in pts)"""
1523 return "normcurve_pt(%g, %g, %g, %g, %g, %g, %g, %g)" % (self.x0_pt, self.y0_pt, self.x1_pt, self.y1_pt,
1527 """split curve into two parts
1529 Helper method to reduce the complexity of a problem by turning
1530 a normcurve_pt into several normline_pt segments. This method
1531 returns normcurve_pt instances only, when they are not yet straight
1532 enough to be replaceable by normcurve_pt instances. Thus a recursive
1533 midpointsplitting will turn a curve into line segments with the
1534 given precision epsilon.
1535 """
1537 # first, we have to calculate the midpoints between adjacent
1538 # control points
1546 # In the next iterative step, we need the midpoints between 01 and 12
1547 # and between 12 and 23
1553 # Finally the midpoint is given by
1557 # Before returning the normcurves we check whether we can
1558 # replace them by normlines within an error of epsilon pts.
1559 # The maximal error value is given by the modulus of the
1560 # difference between the length of the control polygon
1561 # (i.e. |P1-P0|+|P2-P1|+|P3-P2|), which consitutes an upper
1562 # bound for the length, and the length of the straight line
1563 # between start and end point of the normcurve (i.e. |P3-P1|),
1564 # which represents a lower bound.
1594 params_b, arclen_b = b._arclentoparam_pt([length_pt - arclen_a for length_pt in lengths_pt], epsilon)
1595 params = []
1631 result = []
1651 return result
1654 # we can immediately quit when the bboxes are not overlapping
1658 # To improve the performance in the general case we alternate the
1659 # splitting process between the two normsubpathitems
1676 arclens_pt = [segment.arclen_pt(epsilon) for segment in self.segments([0] + list(params) + [1])]
1685 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)
1691 # first, we calculate the coefficients corresponding to our
1692 # original bezier curve. These represent a useful starting
1693 # point for the following change of the polynomial parameter
1703 result = []
1709 # [t1,t2] part
1710 #
1711 # the new coefficients of the [t1,t1+dt] part of the bezier curve
1712 # are then given by expanding
1713 # a0 + a1*(t1+dt*u) + a2*(t1+dt*u)**2 +
1714 # a3*(t1+dt*u)**3 in u, yielding
1715 #
1716 # a0 + a1*t1 + a2*t1**2 + a3*t1**3 +
1717 # ( a1 + 2*a2 + 3*a3*t1**2 )*dt * u +
1718 # ( a2 + 3*a3*t1 )*dt**2 * u**2 +
1719 # a3*dt**3 * u**3
1720 #
1721 # from this values we obtain the new control points by inversion
1722 #
1723 # TODO: we could do this more efficiently by reusing for
1724 # (x0_pt, y0_pt) the control point (x3_pt, y3_pt) from the previous
1725 # Bezier curve
1738 return result
1741 result = []
1750 return result
1760 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))
1763 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))
1766 ################################################################################
1767 # normsubpath
1768 ################################################################################
1772 """sub path of a normalized path
1774 A subpath consists of a list of normsubpathitems, i.e., normlines_pt and
1775 normcurves_pt and can either be closed or not.
1777 Some invariants, which have to be obeyed:
1778 - All normsubpathitems have to be longer than epsilon pts.
1779 - At the end there may be a normline (stored in self.skippedline) whose
1780 length is shorter than epsilon -- it has to be taken into account
1781 when adding further normsubpathitems
1782 - The last point of a normsubpathitem and the first point of the next
1783 element have to be equal.
1784 - When the path is closed, the last point of last normsubpathitem has
1785 to be equal to the first point of the first normsubpathitem.
1786 """
1791 """construct a normsubpath"""
1793 epsilon = _epsilon
1795 # If one or more items appended to the normsubpath have been
1796 # skipped (because their total length was shorter than epsilon),
1797 # we remember this fact by a line because we have to take it
1798 # properly into account when appending further normsubpathitems
1804 # a test (might be temporary)
1806 assert isinstance(anormsubpathitem, normsubpathitem), "only list of normsubpathitem instances allowed"
1814 """return normsubpathitem i"""
1818 """return number of normsubpathitems"""
1829 """return a dictionary mapping normsubpathitemindices to a tuple
1830 of a paramindices and normsubpathitemparams.
1832 normsubpathitemindex specifies a normsubpathitem containing
1833 one or several positions. paramindex specify the index of the
1834 param in the original list and normsubpathitemparam is the
1835 parameter value in the normsubpathitem.
1836 """
1838 result = {}
1849 return result
1852 """append normsubpathitem
1854 Fails on closed normsubpath.
1855 """
1856 # consitency tests (might be temporary)
1859 assert math.hypot(*[x-y for x, y in zip(self.skippedline.atend_pt(), anormsubpathitem.atbegin_pt())]) < self.epsilon, "normsubpathitems do not match"
1861 assert math.hypot(*[x-y for x, y in zip(self.normsubpathitems[-1].atend_pt(), anormsubpathitem.atbegin_pt())]) < self.epsilon, "normsubpathitems do not match"
1882 """return arc length in pts"""
1886 """return a tuple of params and the total length arc length in pts"""
1887 # work on a copy which is counted down to negative values
1898 # overwrite the results until the length has become negative
1900 totalarclen += arclen
1905 """return coordinates at params in pts"""
1908 for index, point_pt in zip(indices, self.normsubpathitems[normsubpathitemindex].at_pt(params)):
1910 return result
1913 """return coordinates of first point in pts"""
1919 """return coordinates of last point in pts"""
1925 """return bounding box of normsubpath"""
1930 return abbox
1932 return None
1935 """close subnormpath
1937 Fails on closed normsubpath.
1938 """
1951 # the append might have left a skippedline, which we have to remove
1952 # from the end of the closed path
1954 self.normsubpathitems[-1] = self.normsubpathitems[-1].modifiedend_pt(*self.skippedline.atend_pt())
1960 """return copy of normsubpath"""
1961 # Since normsubpathitems are never modified inplace, we just
1962 # need to copy the normsubpathitems list. We do not pass the
1963 # normsubpathitems to the constructor to not repeat the checks
1964 # for minimal length of each normsubpathitem.
1969 # We can share the reference to skippedline, since it is a
1970 # normsubpathitem as well and thus not modified in place either.
1973 return result
1976 """return the curvature radius at params in pts
1978 The curvature radius is the inverse of the curvature. When the
1979 curvature is 0, None is returned. Note that this radius can be negative
1980 or positive, depending on the sign of the curvature."""
1983 for index, radius_pt in zip(indices, self.normsubpathitems[normsubpathitemindex].curveradius_pt(params)):
1985 return result
1988 """extend path by normsubpathitems
1990 Fails on closed normsubpath.
1991 """
1996 """intersect self with other normsubpath
1998 Returns a tuple of lists consisting of the parameter values
1999 of the intersection points of the corresponding normsubpath.
2000 """
2001 intersections_a = []
2002 intersections_b = []
2004 # Intersect all subpaths of self with the subpaths of other, possibly including
2005 # one intersection point several times
2012 # although intersectipns_a are sorted for the different normsubpathitems,
2013 # within a normsubpathitem, the ordering has to be ensured separately:
2019 # for symmetry reasons we enumerate intersections_a as well, although
2020 # they are already sorted (note we do not need to sort intersections_a)
2025 # now we search for intersections points which are closer together than epsilon
2026 # This task is handled by the following function
2028 split = normsubpath.segments([0] + [intersection for intersection, index in intersections] + [len(normsubpath)])
2029 result = []
2031 # note that the number of segments of a closed path is off by one
2032 # compared to an open path
2036 j = i
2049 break
2055 j = i
2066 break
2068 return result
2073 # map intersection point to lowest point which is equivalent to the
2074 # point
2084 # determine the remaining intersection points
2085 intersectionpoints = {}
2089 # build result
2090 result = []
2096 result_a = intersection_a
2099 result_b = intersection_b
2101 # note that the result is sorted in a, since we sorted
2102 # intersections_a in the very beginning
2107 """join other normsubpath inplace
2109 Fails on closed normsubpath. Fails to join closed normsubpath.
2110 """
2114 # insert connection line
2119 # append other normsubpathitems
2125 """return joined self and other
2127 Fails on closed normsubpath. Fails to join closed normsubpath.
2128 """
2131 return result
2134 """return a tuple of arc lengths and the total arc length in pts"""
2141 arclens_pt, normsubpathitemarclen_pt = self.normsubpathitems[normsubpathitemindex]._paramtoarclen_pt(params, self.epsilon)
2144 totalarclen_pt += normsubpathitemarclen_pt
2150 """return list of pathitems"""
2154 # remove trailing normline_pt of closed subpaths
2165 return result
2168 """return reversed normsubpath"""
2169 nnormpathitems = []
2175 """return segments of the normsubpath
2177 The returned list of normsubpaths for the segments between
2178 the params. params need to contain at least two values.
2180 For a closed normsubpath the last segment result is joined to
2181 the first one when params starts with 0 and ends with len(self).
2182 or params starts with len(self) and ends with 0. Thus a segments
2183 operation on a closed normsubpath might properly join those the
2184 first and the last part to take into account the closed nature of
2185 the normsubpath. However, for intermediate parameters, closepath
2186 is not taken into account, i.e. when walking backwards you do not
2187 loop over the closepath forwardly. The special values 0 and
2188 len(self) for the first and the last parameter should be given as
2189 integers, i.e. no finite precision is used when checking for
2190 equality."""
2197 # instead of distribute the parameters, we need to keep their
2198 # order and collect parameters for the needed segments of
2199 # normsubpathitem with index collectindex
2200 collectparams = []
2203 # calculate index and parameter for corresponding normsubpathitem
2208 param -= index
2213 # append end point depening on the forthcoming index
2218 # get segments of the normsubpathitem and add them to the result
2222 # add normsubpathitems and first segment parameter to close the
2223 # gap to the forthcoming index
2232 collectindex = index
2234 # add remaining collectparams to the result
2240 # join last and first segment together if the normsubpath was
2241 # originally closed and first and the last parameters are the
2242 # beginning and end points of the normsubpath
2248 return result
2251 """return transformations at params"""
2256 return result
2259 """return transformed path"""
2267 return nnormsubpath
2270 # if the normsubpath is closed, we must not output a normline at
2271 # the end
2273 return
2275 assert len(self.normsubpathitems) > 1, "a closed normsubpath should contain more than a single normline_pt"
2286 # if the normsubpath is closed, we must not output a normline at
2287 # the end
2289 return
2291 assert len(self.normsubpathitems) > 1, "a closed normsubpath should contain more than a single normline_pt"
2302 ################################################################################
2303 # normpath
2304 ################################################################################
2308 """parameter of a certain point along a normpath"""
2319 return "normpathparam(%s, %s, %s)" % (self.normpath, self.normsubpathindex, self.normsubpathparam)
2329 __radd__ = __add__
2340 # other has to be a length in this case
2341 return self.normpath.arclentoparam_pt(-self.normpath.paramtoarclen_pt(self) + unit.topt(other))
2346 __rmul__ = __mul__
2357 return cmp((self.normsubpathindex, self.normsubpathparam), (other.normsubpathindex, other.normsubpathparam))
2362 """return arc length in pts corresponding to the normpathparam """
2366 """return arc length corresponding to the normpathparam """
2371 """Creates a method which takes a single argument or a list and
2372 returns a single value or a list out of method, which always
2373 works on lists."""
2378 break
2382 return wrappedmethod
2387 """normalized path
2389 A normalized path consists of a list of normsubpaths.
2390 """
2393 """construct a normpath from a list of normsubpaths"""
2403 """create new normpath out of self and other"""
2405 result += other
2406 return result
2409 """add other inplace"""
2412 return self
2415 """return normsubpath i"""
2419 """return the number of normsubpaths"""
2426 """return params with all non-normpathparam arguments converted by convertmethod
2428 usecases:
2429 - self._convertparams(params, self.arclentoparam_pt)
2430 - self._convertparams(params, self.arclentoparam)
2431 """
2433 converttoparams = []
2434 convertparamindices = []
2443 return params
2446 """return a dictionary mapping subpathindices to a tuple of a paramindices and subpathparams
2448 subpathindex specifies a subpath containing one or several positions.
2449 paramindex specify the index of the normpathparam in the original list and
2450 subpathparam is the parameter value in the subpath.
2451 """
2453 result = {}
2459 return result
2462 """append a normsubpath by a normsubpath or a pathitem"""
2464 # the normsubpaths list can be appended by a normsubpath only
2467 # ... but we are kind and allow for regular path items as well
2468 # in order to make a normpath to behave more like a regular path
2480 """return arc length in pts"""
2484 """return arc length"""
2488 """return the params matching the given lengths_pt"""
2489 # work on a copy which is counted down to negative values
2500 # overwrite the results until the length has become negative
2504 break
2506 return results
2509 """return the param(s) matching the given length(s)_pt in pts"""
2510 pass
2514 """return the param(s) matching the given length(s)"""
2519 """return coordinates of normpath in pts at params"""
2524 return result
2527 """return coordinates of normpath in pts at param(s) or lengths in pts"""
2532 """return coordinates of normpath at param(s) or arc lengths"""
2538 """return coordinates of the beginning of first subpath in normpath in pts"""
2545 """return coordinates of the beginning of first subpath in normpath"""
2550 """return coordinates of the end of last subpath in normpath in pts"""
2557 """return coordinates of the end of last subpath in normpath"""
2562 """return bbox of normpath"""
2567 abbox = nbbox
2569 abbox += nbbox
2570 return abbox
2573 """return param corresponding of the beginning of the normpath"""
2580 """return copy of normpath"""
2584 return result
2587 """return the curvature radius at params in pts
2589 The curvature radius is the inverse of the curvature. When the
2590 curvature is 0, None is returned. Note that this radius can be negative
2591 or positive, depending on the sign of the curvature."""
2595 for index, radius_pt in zip(indices, self.normsubpaths[normsubpathindex].curveradius_pt(params)):
2597 return result
2600 """return the curvature radius in pts at param(s) or arc length(s) in pts
2602 The curvature radius is the inverse of the curvature. When the
2603 curvature is 0, None is returned. Note that this radius can be negative
2604 or positive, depending on the sign of the curvature."""
2610 """return the curvature radius at param(s) or arc length(s)
2612 The curvature radius is the inverse of the curvature. When the
2613 curvature is 0, None is returned. Note that this radius can be negative
2614 or positive, depending on the sign of the curvature."""
2616 result = []
2622 return result
2626 """return param corresponding of the end of the path"""
2633 """extend path by normsubpaths or pathitems"""
2635 # use append to properly handle regular path items as well as normsubpaths
2639 """intersect self with other path
2641 Returns a tuple of lists consisting of the parameter values
2642 of the intersection points of the corresponding normpath.
2643 """
2646 # here we build up the result
2647 intersections = ([], [])
2649 # Intersect all normsubpaths of self with the normsubpaths of
2650 # other.
2656 return intersections
2659 """join other normsubpath inplace
2661 Both normpaths must contain at least one normsubpath.
2662 The last normsubpath of self will be joined to the first
2663 normsubpath of other.
2664 """
2673 """return joined self and other
2675 Both normpaths must contain at least one normsubpath.
2676 The last normsubpath of self will be joined to the first
2677 normsubpath of other.
2678 """
2681 return result
2683 # << operator also designates joining
2684 __lshift__ = joined
2687 """return a normpath, i.e. self"""
2688 return self
2691 """return arc lengths in pts matching the given params"""
2698 arclens_pt, normsubpatharclen_pt = self.normsubpaths[normsubpathindex]._paramtoarclen_pt(params)
2701 totalarclen_pt += normsubpatharclen_pt
2704 return result
2707 """return arc length(s) in pts matching the given param(s)"""
2711 """return arc length(s) matching the given param(s)"""
2716 """return path corresponding to normpath"""
2717 pathitems = []
2723 """return reversed path"""
2727 return nnormpath
2730 """split path at params and return list of normpaths"""
2732 # instead of distributing the parameters, we need to keep their
2733 # order and collect parameters for splitting of normsubpathitem
2734 # with index collectindex
2739 # append end point depening on the forthcoming index
2744 # get segments of the normsubpath and add them to the result
2748 # add normsubpathitems and first segment parameter to close the
2749 # gap to the forthcoming index
2763 # add remaining collectparams to the result
2769 return result
2772 """split path at param(s) or arc length(s) in pts and return list of normpaths"""
2775 break
2781 """split path at param(s) or arc length(s) and return list of normpaths"""
2784 break
2790 """return tangent vector of path at params
2792 If length is not None, the tangent vector will be scaled to
2793 the desired length.
2794 """
2803 tangentpath = tangentpath.transformed(trafo.scale_pt(sfactor, sfactor, *tangentpath.atbegin_pt()))
2805 return result
2808 """return tangent vector of path at param(s) or arc length(s) in pts
2810 If length in pts is not None, the tangent vector will be scaled to
2811 the desired length.
2812 """
2817 """return tangent vector of path at param(s) or arc length(s)
2819 If length is not None, the tangent vector will be scaled to
2820 the desired length.
2821 """
2826 """return transformation at params"""
2831 return result
2834 """return transformation at param(s) or arc length(s) in pts"""
2839 """return transformation at param(s) or arc length(s)"""
2844 """return transformed normpath"""