2 # -*- coding: ISO-8859-1 -*-
5 # Copyright (C) 2003-2004 Michael Schindler <m-schindler@users.sourceforge.net>
7 # This file is part of PyX (http://pyx.sourceforge.net/).
9 # PyX is free software; you can redistribute it and/or modify
10 # it under the terms of the GNU General Public License as published by
11 # the Free Software Foundation; either version 2 of the License, or
12 # (at your option) any later version.
14 # PyX is distributed in the hope that it will be useful,
15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 # GNU General Public License for more details.
19 # You should have received a copy of the GNU General Public License
20 # along with PyX; if not, write to the Free Software
21 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 from math
import pi
, sin
, cos
, atan2
, tan
, hypot
, acos
, sqrt
26 import path
, trafo
, unit
, helper
28 from math
import radians
, degrees
30 # fallback implementation for Python 2.1 and below
31 def radians(x
): return x
*pi
/180
32 def degrees(x
): return x
*180/pi
35 #########################
37 #########################
39 def _topt(length
, default_type
=None):
40 if length
is None: return None
41 if default_type
is not None:
42 return unit
.topt(unit
.length(length
, default_type
=default_type
))
44 return unit
.topt(unit
.length(length
))
46 class connector_pt(path
.normpath
):
48 def omitends(self
, box1
, box2
):
49 """intersect a path with the boxes' paths"""
51 # cut off the start of self
52 # XXX how can decoration of this box1.path() be handled?
53 sp
= self
.intersect(box1
.path())[0]
55 self
.subpaths
= self
.split(sp
[-1:])[1].subpaths
57 # cut off the end of self
58 sp
= self
.intersect(box2
.path())[0]
60 self
.subpaths
= self
.split(sp
[:1])[0].subpaths
62 def shortenpath(self
, dists
):
63 """shorten a path by the given distances"""
65 # cut off the start of self
66 # XXX should path.lentopar used here?
67 center
= (unit
.topt(self
.begin()[0]), unit
.topt(self
.begin()[1]))
68 sp
= self
.intersect(path
.circle_pt(center
[0], center
[1], dists
[0]))[0]
71 self
.subpaths
= self
.split(sp
[-1:])[1].subpaths
73 # cut off the end of self
74 center
= (unit
.topt(self
.end()[0]), unit
.topt(self
.end()[1]))
75 sp
= self
.intersect(path
.circle_pt(center
[0], center
[1], dists
[1]))[0]
78 self
.subpaths
= self
.split(sp
[:1])[0].subpaths
86 class line_pt(connector_pt
):
88 def __init__(self
, box1
, box2
, boxdists
=[0,0]):
93 connector_pt
.__init
__(self
,
94 [path
.normsubpath([path
.normline(*(self
.box1
.center
+self
.box2
.center
))], 0)])
96 self
.omitends(box1
, box2
)
97 self
.shortenpath(boxdists
)
100 class arc_pt(connector_pt
):
102 def __init__(self
, box1
, box2
, relangle
=45,
103 absbulge
=None, relbulge
=None, boxdists
=[0,0]):
105 # the deviation of arc from the straight line can be specified:
106 # 1. By an angle between a straight line and the arc
107 # This angle is measured at the centers of the box.
108 # 2. By the largest normal distance between line and arc: absbulge
109 # or, equivalently, by the bulge relative to the length of the
110 # straight line from center to center.
111 # Only one can be used.
116 rel
= (self
.box2
.center
[0] - self
.box1
.center
[0],
117 self
.box2
.center
[1] - self
.box1
.center
[1])
118 distance
= hypot(*rel
)
120 # usage of bulge overrides the relangle parameter
121 if relbulge
is not None or absbulge
is not None:
124 try: bulge
+= absbulge
126 try: bulge
+= relbulge
*distance
129 try: radius
= abs(0.5 * (bulge
+ 0.25 * distance
**2 / bulge
))
130 except: radius
= 10 * distance
# default value for too straight arcs
131 radius
= min(radius
, 10 * distance
)
132 center
= 2.0*(radius
-abs(bulge
))/distance
133 center
*= 2*(bulge
>0.0)-1
134 # otherwise use relangle
137 try: radius
= 0.5 * distance
/ abs(cos(0.5*math
.pi
- radians(relangle
)))
138 except: radius
= 10 * distance
139 try: center
= tan(0.5*math
.pi
- radians(relangle
))
142 # up to here center is only the distance from the middle of the
143 # straight connection
144 center
= (0.5 * (self
.box1
.center
[0] + self
.box2
.center
[0] - rel
[1]*center
),
145 0.5 * (self
.box1
.center
[1] + self
.box2
.center
[1] + rel
[0]*center
))
146 angle1
= atan2(self
.box1
.center
[1] - center
[1], self
.box1
.center
[0] - center
[0])
147 angle2
= atan2(self
.box2
.center
[1] - center
[1], self
.box2
.center
[0] - center
[0])
149 # draw the arc in positive direction by default
150 # negative direction if relangle<0 or bulge<0
151 if (relangle
is not None and relangle
< 0) or (bulge
is not None and bulge
< 0):
152 connector_pt
.__init
__(self
,
153 path
.path(path
.moveto_pt(*self
.box1
.center
),
154 path
.arcn_pt(center
[0], center
[1], radius
, degrees(angle1
), degrees(angle2
))))
156 connector_pt
.__init
__(self
,
157 path
.path(path
.moveto_pt(*self
.box1
.center
),
158 path
.arc_pt(center
[0], center
[1], radius
, degrees(angle1
), degrees(angle2
))))
160 self
.omitends(box1
, box2
)
161 self
.shortenpath(boxdists
)
164 class curve_pt(connector_pt
):
166 def __init__(self
, box1
, box2
,
167 relangle1
=45, relangle2
=45,
168 absangle1
=None, absangle2
=None,
169 absbulge
=0, relbulge
=0.39, boxdists
=[0,0]):
171 # The deviation of the curve from a straight line can be specified:
172 # A. By an angle at each center
173 # These angles are either absolute angles with origin at the positive x-axis
174 # or the relative angle with origin at the straight connection line
175 # B. By the (expected) largest normal distance between line and arc: absbulge
176 # and/or by the (expected) bulge relative to the length of the
177 # straight line from center to center.
178 # Here, we need both informations.
180 # a curve with relbulge=0.39 and relangle1,2=45 leads
181 # approximately to the arc with angle=45
186 rel
= (self
.box2
.center
[0] - self
.box1
.center
[0],
187 self
.box2
.center
[1] - self
.box1
.center
[1])
188 distance
= hypot(*rel
)
189 # absolute angle of the straight connection
190 dangle
= atan2(rel
[1], rel
[0])
192 # calculate the armlength and absolute angles for the control points:
193 # absolute and relative bulges are added
194 bulge
= abs(distance
*relbulge
+ absbulge
)
196 if absangle1
is not None:
197 angle1
= radians(absangle1
)
199 angle1
= dangle
- radians(relangle1
)
200 if absangle2
is not None:
201 angle2
= radians(absangle2
)
203 angle2
= dangle
+ radians(relangle2
)
205 # get the control points
206 control1
= (cos(angle1
), sin(angle1
))
207 control2
= (cos(angle2
), sin(angle2
))
208 control1
= (self
.box1
.center
[0] + control1
[0] * bulge
, self
.box1
.center
[1] + control1
[1] * bulge
)
209 control2
= (self
.box2
.center
[0] - control2
[0] * bulge
, self
.box2
.center
[1] - control2
[1] * bulge
)
211 connector_pt
.__init
__(self
,
212 [path
.normsubpath([path
.normcurve(*(self
.box1
.center
+
214 control2
+ self
.box2
.center
))], 0)])
216 self
.omitends(box1
, box2
)
217 self
.shortenpath(boxdists
)
220 class twolines_pt(connector_pt
):
222 def __init__(self
, box1
, box2
,
223 absangle1
=None, absangle2
=None,
224 relangle1
=None, relangle2
=None, relangleM
=None,
225 length1
=None, length2
=None,
226 bezierradius
=None, beziersoftness
=1,
230 # The connection with two lines can be done in the following ways:
231 # 1. an angle at each box-center
232 # 2. two armlengths (if they are long enough)
233 # 3. angle and armlength at the same box
234 # 4. angle and armlength at different boxes
235 # 5. one armlength and the angle between the arms
237 # Angles at the box-centers can be relative or absolute
238 # The angle in the middle is always relative
239 # lengths are always absolute
244 begin
= self
.box1
.center
245 end
= self
.box2
.center
246 rel
= (self
.box2
.center
[0] - self
.box1
.center
[0],
247 self
.box2
.center
[1] - self
.box1
.center
[1])
248 distance
= hypot(*rel
)
249 dangle
= atan2(rel
[1], rel
[0])
251 # find out what arguments are given:
252 if relangle1
is not None: relangle1
= radians(relangle1
)
253 if relangle2
is not None: relangle2
= radians(relangle2
)
254 if relangleM
is not None: relangleM
= radians(relangleM
)
255 # absangle has priority over relangle:
256 if absangle1
is not None: relangle1
= dangle
- radians(absangle1
)
257 if absangle2
is not None: relangle2
= math
.pi
- dangle
+ radians(absangle2
)
259 # check integrity of arguments
260 no_angles
, no_lengths
=0,0
261 for anangle
in (relangle1
, relangle2
, relangleM
):
262 if anangle
is not None: no_angles
+= 1
263 for alength
in (length1
, length2
):
264 if alength
is not None: no_lengths
+= 1
266 if no_angles
+ no_lengths
!= 2:
267 raise NotImplementedError, "Please specify exactly two angles or lengths"
269 # calculate necessary angles and armlengths
270 # always length1 and relangle1
272 # the case with two given angles
273 # use the "sine-theorem" for calculating length1
275 if relangle1
is None: relangle1
= math
.pi
- relangle2
- relangleM
276 elif relangle2
is None: relangle2
= math
.pi
- relangle1
- relangleM
277 elif relangleM
is None: relangleM
= math
.pi
- relangle1
- relangle2
278 length1
= distance
* abs(sin(relangle2
)/sin(relangleM
))
279 middle
= self
._middle
_a
(begin
, dangle
, length1
, relangle1
)
280 # the case with two given lengths
281 # uses the "cosine-theorem" for calculating length1
282 elif no_lengths
== 2:
283 relangle1
= acos((distance
**2 + length1
**2 - length2
**2) / (2.0*distance
*length1
))
284 middle
= self
._middle
_a
(begin
, dangle
, length1
, relangle1
)
285 # the case with one length and one angle
287 if relangle1
is not None:
288 if length1
is not None:
289 middle
= self
._middle
_a
(begin
, dangle
, length1
, relangle1
)
290 elif length2
is not None:
291 length1
= self
._missinglength
(length2
, distance
, relangle1
)
292 middle
= self
._middle
_a
(begin
, dangle
, length1
, relangle1
)
293 elif relangle2
is not None:
294 if length1
is not None:
295 length2
= self
._missinglength
(length1
, distance
, relangle2
)
296 middle
= self
._middle
_b
(end
, dangle
, length2
, relangle2
)
297 elif length2
is not None:
298 middle
= self
._middle
_b
(end
, dangle
, length2
, relangle2
)
299 elif relangleM
is not None:
300 if length1
is not None:
301 length2
= self
._missinglength
(distance
, length1
, relangleM
)
302 relangle1
= acos((distance
**2 + length1
**2 - length2
**2) / (2.0*distance
*length1
))
303 middle
= self
._middle
_a
(begin
, dangle
, length1
, relangle1
)
304 elif length2
is not None:
305 length1
= self
._missinglength
(distance
, length2
, relangleM
)
306 relangle1
= acos((distance
**2 + length1
**2 - length2
**2) / (2.0*distance
*length1
))
307 middle
= self
._middle
_a
(begin
, dangle
, length1
, relangle1
)
309 raise NotImplementedError, "I found a strange combination of arguments"
311 connector_pt
.__init
__(self
,
312 path
.path(path
.moveto_pt(*self
.box1
.center
),
313 path
.lineto_pt(*middle
),
314 path
.lineto_pt(*self
.box2
.center
)))
316 self
.omitends(box1
, box2
)
317 self
.shortenpath(boxdists
)
319 def _middle_a(self
, begin
, dangle
, length1
, angle1
):
322 return begin
[0] + length1
*dir[0], begin
[1] + length1
*dir[1]
324 def _middle_b(self
, end
, dangle
, length2
, angle2
):
325 # a = -math.pi + dangle + angle2
326 return self
._middle
_a
(end
, -math
.pi
+dangle
, length2
, -angle2
)
328 def _missinglength(self
, lenA
, lenB
, angleA
):
329 # calculate lenC, where side A and angleA are opposite
330 tmp1
= lenB
* cos(angleA
)
331 tmp2
= sqrt(tmp1
**2 - lenB
**2 + lenA
**2)
332 if tmp1
> tmp2
: return tmp1
- tmp2
339 """a line is the straight connector between the centers of two boxes"""
341 def __init__(self
, box1
, box2
, boxdists
=[0,0]):
343 boxdists_pt
= (_topt(helper
.getitemno(boxdists
, 0), default_type
="v"),
344 _topt(helper
.getitemno(boxdists
, 1), default_type
="v"))
346 line_pt
.__init
__(self
, box1
, box2
, boxdists
=boxdists_pt
)
349 class curve(curve_pt
):
351 """a curve is the curved connector between the centers of two boxes.
352 The constructor needs both angle and bulge"""
355 def __init__(self
, box1
, box2
,
356 relangle1
=45, relangle2
=45,
357 absangle1
=None, absangle2
=None,
358 absbulge
=0, relbulge
=0.39,
361 boxdists_pt
= (_topt(helper
.getitemno(boxdists
, 0), default_type
="v"),
362 _topt(helper
.getitemno(boxdists
, 1), default_type
="v"))
364 curve_pt
.__init
__(self
, box1
, box2
,
365 relangle1
=relangle1
, relangle2
=relangle2
,
366 absangle1
=absangle1
, absangle2
=absangle2
,
367 absbulge
=_topt(absbulge
), relbulge
=relbulge
,
368 boxdists
=boxdists_pt
)
372 """an arc is a round connector between the centers of two boxes.
374 either an angle in (-pi,pi)
375 or a bulge parameter in (-distance, distance)
376 (relbulge and absbulge are added)"""
378 def __init__(self
, box1
, box2
, relangle
=45,
379 absbulge
=None, relbulge
=None, boxdists
=[0,0]):
381 boxdists_pt
= (_topt(helper
.getitemno(boxdists
, 0), default_type
="v"),
382 _topt(helper
.getitemno(boxdists
, 1), default_type
="v"))
384 arc_pt
.__init
__(self
, box1
, box2
,
386 absbulge
=_topt(absbulge
), relbulge
=relbulge
,
387 boxdists
=boxdists_pt
)
390 class twolines(twolines_pt
):
392 """a twolines is a connector consisting of two straight lines.
393 The construcor takes a combination of angles and lengths:
394 either two angles (relative or absolute)
396 or one length and one angle"""
398 def __init__(self
, box1
, box2
,
399 absangle1
=None, absangle2
=None,
400 relangle1
=None, relangle2
=None, relangleM
=None,
401 length1
=None, length2
=None,
402 bezierradius
=None, beziersoftness
=1,
406 boxdists_pt
= (_topt(helper
.getitemno(boxdists
, 0), default_type
="v"),
407 _topt(helper
.getitemno(boxdists
, 1), default_type
="v"))
409 twolines_pt
.__init
__(self
, box1
, box2
,
410 absangle1
=absangle1
, absangle2
=absangle2
,
411 relangle1
=relangle1
, relangle2
=relangle2
,
413 length1
=_topt(length1
), length2
=_topt(length2
),
414 bezierradius
=_topt(bezierradius
), beziersoftness
=1,
415 arcradius
=_topt(arcradius
),
416 boxdists
=boxdists_pt
)