Warning: session_start(): Session cannot be started after headers have already been sent in /home/tvrreohg/public_html/manga.php on line 13
3
2j @ s6 d Z ddlmZmZmZ ddlmZ ddlZddlm Z e dddd gZ
d
d d d
ddddddddddddddd d d d d d!d"gZ dhd$dZ d%d& Z
d'd( Zdid)dZd*Zd+Zd,d- Zd.d/ Zd0d Zd1d Zd2d Zd3d
Zd4d Zd5d
Zd6d Zd7d Zd8d Z d9d Z d:d Z d;d Z d Z!d?d@ Z"ddAlm#Z#m$Z$m%Z%m&Z& e#fdBdZ'dCd Z(dDdE Z)dFdG Z*dHdI Z+dJdK Z,dLd Z-dMd Z.dNd Z/dOd Z0dPdQ Z1dRdS Z2dTd Z3dUdV Z4dWdX Z5dYd Z6dZd[ Z7d\d] Z8djd_d`Z9dad! Z:dbd" Z;dcdd Zdgkr2ddl?Z?ddl@Z@e?jAe@jB jC dS )kzNfontTools.misc.bezierTools.py -- tools for working with Bezier path segments.
)
calcBoundssectRectrectArea)IdentityN)
namedtuple Intersectionptt1t2approximateCubicArcLengthapproximateCubicArcLengthC approximateQuadraticArcLength approximateQuadraticArcLengthCcalcCubicArcLengthcalcCubicArcLengthCcalcQuadraticArcLengthcalcQuadraticArcLengthCcalcCubicBoundscalcQuadraticBounds splitLinesplitQuadratic
splitCubicsplitQuadraticAtT
splitCubicAtTsolveQuadratic
solveCubicquadraticPointAtT
cubicPointAtT linePointAtTsegmentPointAtTlineLineIntersectionscurveLineIntersectionscurveCurveIntersectionssegmentSegmentIntersections{Gzt?c C s t t| t| t| t| |S )a Calculates the arc length for a cubic Bezier segment.
Whereas :func:`approximateCubicArcLength` approximates the length, this
function calculates it by "measuring", recursively dividing the curve
until the divided segments are shorter than ``tolerance``.
Args:
pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples.
tolerance: Controls the precision of the calcuation.
Returns:
Arc length value.
)r complex)pt1pt2pt3pt4 tolerance r+ ?/tmp/pip-build-_d5lkt3n/fonttools/fontTools/misc/bezierTools.pyr * s c C s\ | d|| | d }|| | | d }| | | d || |f||| || d |ffS )N g ?g ?r+ )p0p1p2p3ZmidZderiv3r+ r+ r, _split_cubic_into_two= s r2 c C sz t || }t || t || t || }|| |krH|| d S t||||\}}t| f| t| f| S d S )Ng ?)absr2 _calcCubicArcLengthCRecurse) multr. r/ r0 r1 archZboxZoneZtwor+ r+ r, r4 F s $ r4 c C s dd| }t || |||S )zCalculates the arc length for a cubic Bezier segment.
Args:
pt1,pt2,pt3,pt4: Control points of the Bezier as complex numbers.
tolerance: Controls the precision of the calcuation.
Returns:
Arc length value.
g ?g ?)r4 )r& r' r( r) r* r5 r+ r+ r, r R s
g|=c C s | |j jS )N) conjugatereal)v1v2r+ r+ r, _dotd s r< c C s( | t j| d d d t j| d S )N )mathsqrtasinh)xr+ r+ r, _intSecAtanh s rC c C s t t| t| t| S )a Calculates the arc length for a quadratic Bezier segment.
Args:
pt1: Start point of the Bezier as 2D tuple.
pt2: Handle point of the Bezier as 2D tuple.
pt3: End point of the Bezier as 2D tuple.
Returns:
Arc length value.
Example::
>>> calcQuadraticArcLength((0, 0), (0, 0), (0, 0)) # empty segment
0.0
>>> calcQuadraticArcLength((0, 0), (50, 0), (80, 0)) # collinear points
80.0
>>> calcQuadraticArcLength((0, 0), (0, 50), (0, 80)) # collinear points vertical
80.0
>>> calcQuadraticArcLength((0, 0), (50, 20), (100, 40)) # collinear points
107.70329614269008
>>> calcQuadraticArcLength((0, 0), (0, 100), (100, 0))
154.02976155645263
>>> calcQuadraticArcLength((0, 0), (0, 50), (100, 0))
120.21581243984076
>>> calcQuadraticArcLength((0, 0), (50, -10), (80, 50))
102.53273816445825
>>> calcQuadraticArcLength((0, 0), (40, 0), (-40, 0)) # collinear points, control point outside
66.66666666666667
>>> calcQuadraticArcLength((0, 0), (40, 0), (0, 0)) # collinear points, looping back
40.0
)r r% )r& r' r( r+ r+ r, r n s c C s || }|| }|| }|d }t |}|dkr>> calcQuadraticBounds((0, 0), (50, 100), (100, 0))
(0, 0, 100, 50.0)
>>> calcQuadraticBounds((0, 0), (100, 0), (100, 100))
(0.0, 0.0, 100, 100)
g @r c sT g | ]L}d | kodk n r | | | | | | fqS )r r> r+ ).0t)axaybxbycxcyr+ r,
s z'calcQuadraticBounds..)calcQuadraticParametersappendr )r& r' r( Zax2Zay2rootspointsr+ )rN rO rP rQ rR rS r, r s
c C s t t| t| t| t| S )a Approximates the arc length for a cubic Bezier segment.
Uses Gauss-Lobatto quadrature with n=5 points to approximate arc length.
See :func:`calcCubicArcLength` for a slower but more accurate result.
Args:
pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples.
Returns:
Arc length value.
Example::
>>> approximateCubicArcLength((0, 0), (25, 100), (75, 100), (100, 0))
190.04332968932817
>>> approximateCubicArcLength((0, 0), (50, 0), (100, 50), (100, 100))
154.8852074945903
>>> approximateCubicArcLength((0, 0), (50, 0), (100, 0), (150, 0)) # line; exact result should be 150.
149.99999999999991
>>> approximateCubicArcLength((0, 0), (50, 0), (100, 0), (-50, 0)) # cusp; exact result should be 150.
136.9267662156362
>>> approximateCubicArcLength((0, 0), (50, 0), (100, -50), (-50, 0)) # cusp
154.80848416537057
)r r% )r& r' r( r) r+ r+ r, r s c C s t || d }t d| d| d| d| }t || | | d }t d| d| d| d| }t || d }|| | | | S ) zApproximates the arc length for a cubic Bezier segment.
Args:
pt1,pt2,pt3,pt4: Control points of the Bezier as complex numbers.
Returns:
Arc length value.
g333333?gc1?g85$t?gu|Y?g#$?g?gc1g#$)r3 ) r& r' r( r) rK r: r; Zv3v4r+ r+ r, r # s ""c s t | |||\\ \\\ d }d }d }d }dd t||D }dd t||D } || }
fdd|
D | |g } t| S )aX Calculates the bounding rectangle for a quadratic Bezier segment.
Args:
pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples.
Returns:
A four-item tuple representing the bounding rectangle ``(xMin, yMin, xMax, yMax)``.
Example::
>>> calcCubicBounds((0, 0), (25, 100), (75, 100), (100, 0))
(0, 0, 100, 75.0)
>>> calcCubicBounds((0, 0), (50, 0), (100, 50), (100, 100))
(0.0, 0.0, 100, 100)
>>> print("%f %f %f %f" % calcCubicBounds((50, 0), (0, 100), (100, 100), (50, 0)))
35.566243 0.000000 64.433757 75.000000
g @g @c S s( g | ] }d | kodk n r|qS )r r> r+ )rL rM r+ r+ r, rT _ s z#calcCubicBounds..c S s( g | ] }d | kodk n r|qS )r r> r+ )rL rM r+ r+ r, rT ` s c s\ g | ]T} | | | | | | | | | | | | fqS r+ r+ )rL rM )rN rO rP rQ rR rS dxdyr+ r, rT d s )calcCubicParametersr r ) r& r' r( r) Zax3Zay3Zbx2Zby2ZxRootsZyRootsrW rX r+ )rN rO rP rQ rR rS rZ r[ r, r G s &
c C s | \}}|\}}|| }|| } |}
|} || f| } | dkrF| |fgS ||
| f| | }
d|
koldk n r||
|
| |
| f}| |f||fgS | |fgS dS )a
Split a line at a given coordinate.
Args:
pt1: Start point of line as 2D tuple.
pt2: End point of line as 2D tuple.
where: Position at which to split the line.
isHorizontal: Direction of the ray splitting the line. If true,
``where`` is interpreted as a Y coordinate; if false, then
``where`` is interpreted as an X coordinate.
Returns:
A list of two line segments (each line segment being two 2D tuples)
if the line was successfully split, or a list containing the original
line.
Example::
>>> printSegments(splitLine((0, 0), (100, 100), 50, True))
((0, 0), (50, 50))
((50, 50), (100, 100))
>>> printSegments(splitLine((0, 0), (100, 100), 100, True))
((0, 0), (100, 100))
>>> printSegments(splitLine((0, 0), (100, 100), 0, True))
((0, 0), (0, 0))
((0, 0), (100, 100))
>>> printSegments(splitLine((0, 0), (100, 100), 0, False))
((0, 0), (0, 0))
((0, 0), (100, 100))
>>> printSegments(splitLine((100, 0), (0, 0), 50, False))
((100, 0), (50, 0))
((50, 0), (0, 0))
>>> printSegments(splitLine((0, 100), (0, 0), 50, True))
((0, 100), (0, 50))
((0, 50), (0, 0))
r r> Nr+ )r& r' where isHorizontalZpt1xZpt1yZpt2xZpt2yrN rO rP rQ rG rM ZmidPtr+ r+ r, r m s $
c C sb t | ||\}}}t|| || || | }tdd |D }|sP| ||fgS t|||f| S )a Split a quadratic Bezier curve at a given coordinate.
Args:
pt1,pt2,pt3: Control points of the Bezier as 2D tuples.
where: Position at which to split the curve.
isHorizontal: Direction of the ray splitting the curve. If true,
``where`` is interpreted as a Y coordinate; if false, then
``where`` is interpreted as an X coordinate.
Returns:
A list of two curve segments (each curve segment being three 2D tuples)
if the curve was successfully split, or a list containing the original
curve.
Example::
>>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 150, False))
((0, 0), (50, 100), (100, 0))
>>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 50, False))
((0, 0), (25, 50), (50, 50))
((50, 50), (75, 50), (100, 0))
>>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 25, False))
((0, 0), (12.5, 25), (25, 37.5))
((25, 37.5), (62.5, 75), (100, 0))
>>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 25, True))
((0, 0), (7.32233, 14.6447), (14.6447, 25))
((14.6447, 25), (50, 75), (85.3553, 25))
((85.3553, 25), (92.6777, 14.6447), (100, -7.10543e-15))
>>> # XXX I'm not at all sure if the following behavior is desirable:
>>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 50, True))
((0, 0), (25, 50), (50, 50))
((50, 50), (50, 50), (50, 50))
((50, 50), (75, 50), (100, 0))
c s s* | ]"}d | kodk n r|V qdS )r r> Nr+ )rL rM r+ r+ r, s z!splitQuadratic..)rU r sorted_splitQuadraticAtT) r& r' r( r] r^ rG rH c solutionsr+ r+ r, r s # c C sp t | |||\}}}} t|| || || | | | }
tdd |
D }
|
s\| |||fgS t|||| f|
S )a Split a cubic Bezier curve at a given coordinate.
Args:
pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples.
where: Position at which to split the curve.
isHorizontal: Direction of the ray splitting the curve. If true,
``where`` is interpreted as a Y coordinate; if false, then
``where`` is interpreted as an X coordinate.
Returns:
A list of two curve segments (each curve segment being four 2D tuples)
if the curve was successfully split, or a list containing the original
curve.
Example::
>>> printSegments(splitCubic((0, 0), (25, 100), (75, 100), (100, 0), 150, False))
((0, 0), (25, 100), (75, 100), (100, 0))
>>> printSegments(splitCubic((0, 0), (25, 100), (75, 100), (100, 0), 50, False))
((0, 0), (12.5, 50), (31.25, 75), (50, 75))
((50, 75), (68.75, 75), (87.5, 50), (100, 0))
>>> printSegments(splitCubic((0, 0), (25, 100), (75, 100), (100, 0), 25, True))
((0, 0), (2.29379, 9.17517), (4.79804, 17.5085), (7.47414, 25))
((7.47414, 25), (31.2886, 91.6667), (68.7114, 91.6667), (92.5259, 25))
((92.5259, 25), (95.202, 17.5085), (97.7062, 9.17517), (100, 1.77636e-15))
c s s* | ]"}d | kodk n r|V qdS )r r> Nr+ )rL rM r+ r+ r, r_ s z splitCubic..)r\ r r` _splitCubicAtT) r& r' r( r) r] r^ rG rH rb rE rc r+ r+ r, r s c G s$ t | ||\}}}t|||f| S )a Split a quadratic Bezier curve at one or more values of t.
Args:
pt1,pt2,pt3: Control points of the Bezier as 2D tuples.
*ts: Positions at which to split the curve.
Returns:
A list of curve segments (each curve segment being three 2D tuples).
Examples::
>>> printSegments(splitQuadraticAtT((0, 0), (50, 100), (100, 0), 0.5))
((0, 0), (25, 50), (50, 50))
((50, 50), (75, 50), (100, 0))
>>> printSegments(splitQuadraticAtT((0, 0), (50, 100), (100, 0), 0.5, 0.75))
((0, 0), (25, 50), (50, 50))
((50, 50), (62.5, 50), (75, 37.5))
((75, 37.5), (87.5, 25), (100, 0))
)rU ra )r& r' r( tsrG rH rb r+ r+ r, r s c G s* t | |||\}}}}t||||f| S )a Split a cubic Bezier curve at one or more values of t.
Args:
pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples.
*ts: Positions at which to split the curve.
Returns:
A list of curve segments (each curve segment being four 2D tuples).
Examples::
>>> printSegments(splitCubicAtT((0, 0), (25, 100), (75, 100), (100, 0), 0.5))
((0, 0), (12.5, 50), (31.25, 75), (50, 75))
((50, 75), (68.75, 75), (87.5, 50), (100, 0))
>>> printSegments(splitCubicAtT((0, 0), (25, 100), (75, 100), (100, 0), 0.5, 0.75))
((0, 0), (12.5, 50), (31.25, 75), (50, 75))
((50, 75), (59.375, 75), (68.75, 68.75), (77.3438, 56.25))
((77.3438, 56.25), (85.9375, 43.75), (93.75, 25), (100, 0))
)r\ rd ) r& r' r( r) re rG rH rb rE r+ r+ r, r s c G s t |}g }|jdd |jd | \}}|\}}|\} }
xtt|d D ]} || } || d }
|
| }|| }|| }|| }d| | | | }d| | | | }| | }|| || | }|| || |
}t||f||f||f\}}}|j|||f qLW |S )Nr g g ?r> r= )listinsertrV rangelencalcQuadraticPoints)rG rH rb re segmentsrN rO rP rQ rR rS ir r
deltadelta_2a1xa1yb1xb1yt1_2c1xc1yr& r' r( r+ r+ r, ra ( s,
ra c " G s t |}|jdd |jd g }| \}}|\}} |\}
} |\} }
x>tt|d D ](}|| }||d }|| }|| }|| }|| }|| }|| }|| }d| | | | }d| | | | }d| | |
d| | | }d| | | d| | | }|| || |
| | } || | | | | |
} t||f||f||f| | f\} } } }!|j| | | |!f qVW |S )Nr g g ?r> r- r= )rf rg rV rh ri calcCubicPoints)"rG rH rb rE re rk rN rO rP rQ rR rS rZ r[ rl r r
rm rn Zdelta_3rs Zt1_3ro rp rq rr rt ru Zd1xZd1yr& r' r( r) r+ r+ r, rd C s8
$rd )r@ acoscospic C s~ t | tk r,t |tk r g }qz| | g}nN|| d| | }|dkrv||}| | d | | | d | g}ng }|S )uK Solve a quadratic equation.
Solves *a*x*x + b*x + c = 0* where a, b and c are real.
Args:
a: coefficient of *x²*
b: coefficient of *x*
c: constant term
Returns:
A list of roots. Note that the returned list is neither guaranteed to
be sorted nor to contain unique values!
g @g g @)r3 rD )rG rH rb r@ rW ZDDZrDDr+ r+ r, r m s &c C s t | tk rt|||S t| } || }|| }|| }|| d| d }d| | | d| | d| d }|| } || | }
| tk rdn| } t |
tk rdn|
}
| |
} | dkr|
dkrt| d t} | | | gS | td kr@ttt|t |
d d
}
dt | }|d }|t
|
d | }|t
|
dt d | }|t
|
d
t d | }t |||g\}}}|| tk r|| tk rt|| | d t } }}n~|| tk rt|| d t }}t|t}nN|| tk rt|t}t|| d t }}n t|t}t|t}t|t}|||gS t
t | t | d} | || } |dkrr| } t| |d t} | gS d S )ut Solve a cubic equation.
Solves *a*x*x*x + b*x*x + c*x + d = 0* where a, b, c and d are real.
Args:
a: coefficient of *x³*
b: coefficient of *x²*
c: coefficient of *x*
d: constant term
Returns:
A list of roots. Note that the returned list is neither guaranteed to
be sorted nor to contain unique values!
Examples::
>>> solveCubic(1, 1, -6, 0)
[-3.0, -0.0, 2.0]
>>> solveCubic(-10.0, -9.0, 48.0, -29.0)
[-2.9, 1.0, 1.0]
>>> solveCubic(-9.875, -9.0, 47.625, -28.75)
[-2.911392, 1.0, 1.0]
>>> solveCubic(1.0, -4.5, 6.75, -3.375)
[1.5, 1.5, 1.5]
>>> solveCubic(-12.0, 18.0, -9.0, 1.50023651123)
[0.5, 0.5, 0.5]
>>> solveCubic(
... 9.0, 0.0, 0.0, -7.62939453125e-05
... ) == [-0.0, -0.0, -0.0]
True
g @g "@g @g ;@g K@r g g ?g ?g @r> Ng g gUUUUUU?)r3 rD r floatround
epsilonDigitsrw maxminr@ rx ry r` pow)rG rH rb rE Za1Za2a3QRZR2ZQ3ZR2_Q3rB thetaZrQ2Za1_3rI rJ x2r+ r+ r, r sT & (
c
C s^ |\}}|\}}| \}}|| d } || d }
|| | } || |
} | | f| |
f||ffS )Ng @r+ )
r& r' r( r y2x3y3rR rS rP rQ rN rO r+ r+ r, rU s rU c C s |\}}|\}}|\}} | \}
} ||
d } || d }
|| d | }|| d |
}||
| | }| | |
| }||f||f| |
f|
| ffS )Ng @r+ )r& r' r( r) r r r r x4y4rZ r[ rR rS rP rQ rN rO r+ r+ r, r\ s r\ c C sf | \}}|\}}|\}}|} |}
|d | } |d | } || | }
|| | }| |
f| | f|
|ffS )Ng ?r+ )rG rH rb rN rO rP rQ rR rS rJ y1r r r r r+ r+ r, rj s rj c C s | \}}|\}}|\}} |\}
} |
} | }
|d |
}| d | }|| d | }|| d | }||
| | }|| | | }| |
f||f||f||ffS )Ng @r+ )rG rH rb rE rN rO rP rQ rR rS rZ r[ rJ r r r r r r r r+ r+ r, rv s rv c C s8 | d d| |d | | d d| |d | fS )zFinds the point at time `t` on a line.
Args:
pt1, pt2: Coordinates of the line as 2D tuples.
t: The time along the line.
Returns:
A 2D tuple with the coordinates of the point.
r r> r+ )r& r' rM r+ r+ r, r * s
c C s d| d| | d dd| | |d || |d }d| d| | d dd| | |d || |d }||fS )zFinds the point at time `t` on a quadratic curve.
Args:
pt1, pt2, pt3: Coordinates of the curve as 2D tuples.
t: The time along the curve.
Returns:
A 2D tuple with the coordinates of the point.
r> r r= r+ )r& r' r( rM rB yr+ r+ r, r 7 s
@@c C s d| d| d| | d dd| d| | |d dd| | | |d || | |d }d| d| d| | d dd| d| | |d dd| | | |d || | |d }||fS )zFinds the point at time `t` on a cubic curve.
Args:
pt1, pt2, pt3, pt4: Coordinates of the curve as 2D tuples.
t: The time along the curve.
Returns:
A 2D tuple with the coordinates of the point.
r> r r- r+ )r& r' r( r) rM rB r r+ r+ r, r F s ppc C sZ t | dkrt| |f S t | dkr4t| |f S t | dkrNt| |f S tdd S )Nr= r- zUnknown curve degree)ri r r r
ValueError)segrM r+ r+ r, r _ s c C sx | \}}|\}}|\}}t || tk r )r3 rD ) ser ZsxZsyexZeyZpxpyr+ r+ r,
_line_t_of_ptn s r c C sR | d |d |d |d }| d |d |d |d }|dkoN|dk S )Nr r> g r+ )rG rH originZxDiffZyDiffr+ r+ r, '_both_points_are_on_same_side_of_origin| s r c C s
| \}}|\}}|\}} |\}
} t j||
rJt j||rJt j|| rJg S t j| | rtt j||rtt j|| rtg S t j||
rt j| | rg S t j||rt j||rg S t j||r|} | | |
| }
|
| | | }| |f}t|t| ||t|||dgS t j||
r`|} || || }|| | | }| |f}t|t| ||t|||dgS || || }| | |
| }
t j||
rg S || | |
| | ||
} || | | }| |f}t||| rt|||rt|t| ||t|||dgS g S )a Finds intersections between two line segments.
Args:
s1, e1: Coordinates of the first line as 2D tuples.
s2, e2: Coordinates of the second line as 2D tuples.
Returns:
A list of ``Intersection`` objects, each object having ``pt``, ``t1``
and ``t2`` attributes containing the intersection point, time on first
segment and time on second segment respectively.
Examples::
>>> a = lineLineIntersections( (310,389), (453, 222), (289, 251), (447, 367))
>>> len(a)
1
>>> intersection = a[0]
>>> intersection.pt
(374.44882952482897, 313.73458370177315)
>>> (intersection.t1, intersection.t2)
(0.45069111555824465, 0.5408153767394238)
)r r r
)r? iscloser r r )s1Ze1s2e2Zs1xZs1yZe1xZe1yZs2xZs2yZe2xZe2yrB Zslope34r r Zslope12r+ r+ r, r sN && c C sT | d }| d }t j|d |d |d |d }tj| j|d |d S )Nr r> r )r? atan2r rotate translate)segmentstartendZangler+ r+ r, _alignment_transformation s $r c C s t |j| }t| dkrBt| \}}}t|d |d |d }nDt| dkr~t| \}}}}t|d |d |d |d }ntdtdd |D S )Nr- r> r zUnknown curve degreec s s* | ]"}d | kodkn r|V qdS )g r> Nr+ )rL rl r+ r+ r, r_ s z._curve_line_intersections_t..) r ZtransformPointsri rU r r\ r r r` )curvelineZ
aligned_curverG rH rb
intersectionsrE r+ r+ r, _curve_line_intersections_t s r c C s t | dkrt}nt | dkr$t}ntdg }xPt| |D ]B}|| |f }t||f }t||f }|jt|||d q>> curve = [ (100, 240), (30, 60), (210, 230), (160, 30) ]
>>> line = [ (25, 260), (230, 20) ]
>>> intersections = curveLineIntersections(curve, line)
>>> len(intersections)
3
>>> intersections[0].pt
(84.9000930760723, 189.87306176459828)
r- r zUnknown curve degree)r r r
) ri r r r r r r rV r )r r Z pointFinderr rM r Zline_tr+ r+ r, r! s c C s4 t | dkrt| S t | dkr(t| S tdd S )Nr- r zUnknown curve degree)ri r r r )rb r+ r+ r,
_curve_bounds
s
r c C sp t | dkr0| \}}t|||}||f||fgS t | dkrJt| |f S t | dkrdt| |f S tdd S )Nr= r- r zUnknown curve degree)ri r r r r )rb rM r r midpointr+ r+ r, _split_segment_at_t s r MbP?c s| t | }t |}|sd }|s d }t||\}}|s6g S dd } t| k rht| k rh| || |fgS t| d\}
} |d | |f} | ||d f}
t|d\}}|d | |f}| ||d f}g }|jt|
| | |d |jt| | |
|d |jt|
| | |d |jt| | |
|d fd d
}t }g }x8|D ]0}||}||kr^qD|j| |j| qDW |S )
N ?c S s d| d | d S )Ng ?r r> r+ )rr+ r+ r, r 1 s z._curve_curve_intersections_t..midpointg ?r r> )range1range2c s t | d t | d fS )Nr r> )int)re ) precisionr+ r, V s z._curve_curve_intersections_t..)r r )r r ) r r r r extend _curve_curve_intersections_tsetaddrV )curve1curve2r r r Zbounds1Zbounds2Z
intersects_r Zc11Zc12Z c11_rangeZ c12_rangeZc21Zc22Z c21_rangeZ c22_rangefoundZ
unique_keyseenZ
unique_valuesre keyr+ )r r, r ! sR
r c s t |} fdd|D S )a Finds intersections between a curve and a curve.
Args:
curve1: List of coordinates of the first curve segment as 2D tuples.
curve2: List of coordinates of the second curve segment as 2D tuples.
Returns:
A list of ``Intersection`` objects, each object having ``pt``, ``t1``
and ``t2`` attributes containing the intersection point, time on first
segment and time on second segment respectively.
Examples::
>>> curve1 = [ (10,100), (90,30), (40,140), (220,220) ]
>>> curve2 = [ (5,150), (180,20), (80,250), (210,190) ]
>>> intersections = curveCurveIntersections(curve1, curve2)
>>> len(intersections)
3
>>> intersections[0].pt
(81.7831487395506, 109.88904552375288)
c s, g | ]$}t t |d |d |d dqS )r r> )r r r
)r r )rL re )r r+ r, rT { s z+curveCurveIntersections..)r )r r Zintersection_tsr+ )r r, r" d s
c C s d}t |t | kr"| | }} d}t | dkrRt |dkrFt| |}qt| |}n.t | dkrxt |dkrxt| | }ntd|s|S dd |D S )a) Finds intersections between two segments.
Args:
seg1: List of coordinates of the first segment as 2D tuples.
seg2: List of coordinates of the second segment as 2D tuples.
Returns:
A list of ``Intersection`` objects, each object having ``pt``, ``t1``
and ``t2`` attributes containing the intersection point, time on first
segment and time on second segment respectively.
Examples::
>>> curve1 = [ (10,100), (90,30), (40,140), (220,220) ]
>>> curve2 = [ (5,150), (180,20), (80,250), (210,190) ]
>>> intersections = segmentSegmentIntersections(curve1, curve2)
>>> len(intersections)
3
>>> intersections[0].pt
(81.7831487395506, 109.88904552375288)
>>> curve3 = [ (100, 240), (30, 60), (210, 230), (160, 30) ]
>>> line = [ (25, 260), (230, 20) ]
>>> intersections = segmentSegmentIntersections(curve3, line)
>>> len(intersections)
3
>>> intersections[0].pt
(84.9000930760723, 189.87306176459828)
FTr= z4Couldn't work out which intersection function to usec S s g | ]}t |j|j|jd qS ))r r r
)r r r
r )rL rl r+ r+ r, rT s z/segmentSegmentIntersections..)ri r" r! r r )Zseg1Zseg2Zswappedr r+ r+ r, r# s
c C sB y t | }W n tk
r$ d| S X ddjdd |D S dS )zw
>>> _segmentrepr([1, [2, 3], [], [[2, [3, 4], [0.1, 2.2]]]])
'(1, (2, 3), (), ((2, (3, 4), (0.1, 2.2))))'
z%gz(%s)z, c s s | ]}t |V qd S )N) _segmentrepr)rL rB r+ r+ r, r_ s z _segmentrepr..N)iter TypeErrorjoin)objitr+ r+ r, r s
r c C s x| D ]}t t| qW dS )zlHelper for the doctests, displaying each segment in a list of
segments on a single line as a tuple.
N)printr )rk r r+ r+ r,
printSegments s
r __main__)r$ )r$ )r NN)D__doc__ZfontTools.misc.arrayToolsr r r ZfontTools.misc.transformr r? collectionsr r __all__r r2 r4 r r| rD r< rC r r r
r r r r r r r r r r ra rd r@ rw rx ry r r rU r\ rj rv r r r r r r r r r r! r r r r" r# r r __name__sysdoctestexittestmodfailedr+ r+ r+ r, s
# !" $&9-%' !a
N
&
B 0