← Back to branch summary

~ubuntu-branches/ubuntu/trusty/pyx/trusty

« back to all changes in this revision

Viewing changes to pyx/box.py

  • Committer: Bazaar Package Importer
  • Author(s): Thomas Viehmann
  • Date: 2006-11-26 14:04:53 UTC
  • mfrom: (2.1.3 edgy)
  • Revision ID: james.westby@ubuntu.com-20061126140453-1dq3cycpspmlik2t
Tags: 0.9-3
http://bugs.debian.org/400087
http://bugs.debian.org/392634
* New maintainer. Thank you for more than three years of
  maintenance,  Graham! Closes: #400087
* Don't hard-code python 2.3 in manual/Makefile.
  Thanks to Matthias Klose for the bug report and patch.
  Closes: #392634
* Remove obsolete dh_python call from debian/rules.

Show diffs side-by-side

added added

removed removed

Lines of Context:
pyx/box.py
1
 
#!/usr/bin/env python
2
1
# -*- coding: ISO-8859-1 -*-
3
2
#
4
3
#
20
19
#
21
20
# You should have received a copy of the GNU General Public License
22
21
# along with PyX; if not, write to the Free Software
23
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
22
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
24
23
 
25
24
 
26
25
import types, math
27
 
import bbox, path, unit, trafo, helper
 
26
import bbox, path, unit, trafo
28
27
 
 
28
class _marker: pass
29
29
 
30
30
class BoxCrossError(Exception): pass
31
31
 
44
44
                self.center = self.center[0] + corn[0], self.center[1] + corn[1]
45
45
            self.center = self.center[0]/len(self.corners), self.center[1]/len(self.corners)
46
46
 
47
 
    def path(self, centerradius=None, bezierradius=None, beziersoftness=1):
 
47
    def path(self, centerradius=None, bezierradius=None, beziersoftness=None):
48
48
        pathitems = []
49
49
        if centerradius is not None and self.center is not None:
50
50
            r = unit.topt(centerradius)
51
51
            pathitems.append(path.arc_pt(self.center[0], self.center[1], r, 0, 360))
52
52
            pathitems.append(path.closepath())
53
 
        if bezierradius is None:
54
 
            pathitems.append(path.moveto_pt(self.corners[0][0], self.corners[0][1]))
55
 
            for x, y in self.corners[1:]:
56
 
                pathitems.append(path.lineto_pt(x, y))
57
 
            pathitems.append(path.closepath())
58
 
        else:
59
 
            # curved box plotting by Michael Schindler
60
 
            l = len(self.corners)
61
 
            # make beziersoftnes a list of length l
62
 
            if helper.issequence(beziersoftness):
63
 
                if not (len(beziersoftness) == l): raise ValueError
64
 
            else:
65
 
                beziersoftness = [float(beziersoftness)]*l
66
 
            # make bezierradius a list (lenght l) of 2-tuples
67
 
            if helper.issequence(bezierradius):
68
 
                r = list(bezierradius)
69
 
                if len(bezierradius) == l:
70
 
                    for oner, i in zip(r, range(l)):
71
 
                        if helper.issequence(oner):
72
 
                            if len(oner) == 2:
73
 
                                r[i] = [unit.topt(oner[0]), unit.topt(oner[1])]
74
 
                            else: raise ValueError
75
 
                        else:
76
 
                            r[i] = [unit.topt(oner)]*2
77
 
                else: raise ValueError
78
 
            else:
79
 
                r = [[unit.topt(bezierradius)]*2]*l
80
 
            for i in range(l):
81
 
                c = self.corners[i]
82
 
                def normed(*v):
83
 
                    n = math.hypot(*v)
84
 
                    return v[0] / n, v[1] / n
85
 
                d1 = normed(self.corners[(i - 1 + l) % l][0] - c[0],
86
 
                            self.corners[(i - 1 + l) % l][1] - c[1])
87
 
                d2 = normed(self.corners[(i + 1 + l) % l][0] - c[0],
88
 
                            self.corners[(i + 1 + l) % l][1] - c[1])
89
 
                dc = normed(d1[0] + d2[0], d1[1] + d2[1])
90
 
                f = 0.3192 * beziersoftness[i]
91
 
                g = (15.0 * f + math.sqrt(-15.0*f*f + 24.0*f))/12.0
92
 
                f1 = c[0] + f * d1[0] * r[i][0], c[1] + f * d1[1] * r[i][0]
93
 
                f2 = c[0] + f * d2[0] * r[i][1], c[1] + f * d2[1] * r[i][1]
94
 
                g1 = c[0] + g * d1[0] * r[i][0], c[1] + g * d1[1] * r[i][0]
95
 
                g2 = c[0] + g * d2[0] * r[i][1], c[1] + g * d2[1] * r[i][1]
96
 
                d1 = c[0] +     d1[0] * r[i][0], c[1] +     d1[1] * r[i][0]
97
 
                d2 = c[0] +     d2[0] * r[i][1], c[1] +     d2[1] * r[i][1]
98
 
                e  = 0.5 * (f1[0] + f2[0]), 0.5 * (f1[1] + f2[1])
99
 
                if i:
100
 
                    pathitems.append(path.lineto_pt(*d1))
101
 
                else:
102
 
                    pathitems.append(path.moveto_pt(*d1))
103
 
                pathitems.append(path.curveto_pt(*(g1 + f1 + e)))
104
 
                pathitems.append(path.curveto_pt(*(f2 + g2 + d2)))
105
 
            pathitems.append(path.closepath())
 
53
        if bezierradius is not None or beziersoftness is not None:
 
54
            raise ValueError("smooth functionality removed; apply smooth deformer on path")
 
55
        pathitems.append(path.moveto_pt(self.corners[0][0], self.corners[0][1]))
 
56
        for x, y in self.corners[1:]:
 
57
            pathitems.append(path.lineto_pt(x, y))
 
58
        pathitems.append(path.closepath())
106
59
        return path.path(*pathitems)
107
60
 
108
61
    def transform(self, *trafos):
109
62
        for trafo in trafos:
110
63
            if self.center is not None:
111
 
                self.center = trafo._apply(*self.center)
112
 
            self.corners = [trafo._apply(*point) for point in self.corners]
 
64
                self.center = trafo.apply_pt(*self.center)
 
65
            self.corners = [trafo.apply_pt(*point) for point in self.corners]
113
66
 
114
67
    def reltransform(self, *trafos):
115
68
        if self.center is not None:
223
176
        return self
224
177
 
225
178
    def circlealign(self, *args):
226
 
        self.reltransform(trafo.translate(*self.circlealignvector(*args)))
 
179
        self.transform(trafo.translate(*self.circlealignvector(*args)))
227
180
        return self
228
181
 
229
182
    def linealign(self, *args):
351
304
class rect_pt(polygon_pt):
352
305
 
353
306
    def __init__(self, x, y, width, height, relcenter=(0, 0), abscenter=(0, 0),
354
 
                       corners=helper.nodefault, center=helper.nodefault, **args):
355
 
        if corners != helper.nodefault or center != helper.nodefault:
 
307
                       corners=_marker, center=_marker, **args):
 
308
        if corners != _marker or center != _marker:
356
309
            raise ValueError
357
310
        polygon_pt.__init__(self, corners=((x, y),
358
311
                                         (x + width, y),