def GetSnapPoints(self):
t = self.trafo
start_angle = self.start_angle
end_angle = self.end_angle
if self.start_angle == self.end_angle:
a = Point(t.m11, t.m21)
b = Point(t.m12, t.m22)
c = t.offset()
return [c, c + a, c - a, c + b, c - b]
else:
points = [t(Polar(start_angle)), t(Polar(end_angle)), t.offset()]
if end_angle < start_angle:
end_angle = end_angle + 2 * pi
pi2 = pi / 2
angle = pi2 * (floor(start_angle / pi2) + 1)
while angle < end_angle:
points.append(t(Polar(1, angle)))
angle = angle + pi2
return points
def Snap(self, p): try: x, y = self.trafo.inverse()(p) minx = self.radius1 maxx = 1 - self.radius1 miny = self.radius2 maxy = 1 - self.radius2 if minx < x < maxx: if miny < y < maxy: ratio = hypot(self.trafo.m11, self.trafo.m21) \ / hypot(self.trafo.m12, self.trafo.m22) if x < 0.5: dx = x else: dx = 1 - x if y < 0.5: dy = y else: dy = 1 - y if dy / dx > ratio: x = round(x) else: y = round(y) elif y > maxy: y = 1 else: y = 0 elif miny < y < maxy: if x > maxx: x = 1 else: x = 0 elif minx > 0 and miny > 0: # the round corners if x < 0.5: cx = minx else: cx = maxx if y < 0.5: cy = miny else: cy = maxy trafo = Trafo(minx, 0, 0, miny, cx, cy) r, phi = trafo.inverse()(x, y).polar() x, y = trafo(Polar(1, phi)) else: # normal corners x = round(min(max(x, 0), 1)) y = round(min(max(y, 0), 1)) p2 = self.trafo(x, y) return (abs(p - p2), p2) except SingularMatrix: return (1e200, p)
def Ellipse(self, ell):
trf = ell.trafo
if (trf.m12 == 0 and trf.m21 == 0) or (trf.m11 == 0 and trf.m22 == 0):
self.FillStyle(ell.Properties())
left, top, right, bottom = self.rect_to_ltrb(ell, Point(-1, -1))
if ell.start_angle == ell.end_angle:
self.packrec('<LHhhhh', 7, 0x0418, bottom, right, top, left)
else:
xe, ye = map(rndtoint,
self.trafo(ell.trafo(Polar(1, ell.start_angle))))
xs, ys = map(rndtoint,
self.trafo(ell.trafo(Polar(1, ell.end_angle))))
if ell.arc_type == const.ArcArc:
function = 0x0817
elif ell.arc_type == const.ArcPieSlice:
function = 0x081A
elif ell.arc_type == const.ArcChord:
function = 0x0830
self.packrec('<LHhhhhhhhh', 11, function, ye, xe, ys, xs,
bottom, right, top, left)
else:
self.PolyBezier(ell.Paths(), ell.Properties())
def update_rects(self):
trafo = self.trafo
start = trafo.offset()
# On some systems, atan2 can raise a ValueError if both
# parameters are 0. In that case, the actual value the of angle
# is not important since in the computation of p below, the
# coordinate depending on the angle will always be 0 because
# both trafo coefficients are 0. So set the angle to 0 in case
# of an exception.
try:
phi1 = atan2(trafo.m12, trafo.m11)
except ValueError:
phi1 = 0
try:
phi2 = atan2(trafo.m22, trafo.m21)
except ValueError:
phi2 = 0
p = Point(trafo.m11 * cos(phi1) + trafo.m12 * sin(phi1),
trafo.m21 * cos(phi2) + trafo.m22 * sin(phi2))
self.coord_rect = r = Rect(start + p, start - p)
if self.properties.HasLine():
width = self.properties.line_width
r = r.grown(width / 2 + 1)
# add the bounding boxes of arrows
if self.arc_type == ArcArc:
pi2 = pi / 2
arrow1 = self.properties.line_arrow1
if arrow1 is not None:
pos = trafo(Polar(1, self.start_angle))
dir = trafo.DTransform(Polar(1, self.start_angle - pi2))
r = UnionRects(r, arrow1.BoundingRect(pos, dir, width))
arrow2 = self.properties.line_arrow2
if arrow2 is not None:
pos = trafo(Polar(1, self.end_angle))
dir = trafo.DTransform(Polar(1, self.end_angle + pi2))
r = UnionRects(r, arrow2.BoundingRect(pos, dir, width))
self.bounding_rect = r
def create_star_path(corners, step, radius): # create a star-like polygon. center = Point(300, 400) radius = 100 angle = step * 2 * pi / corners # create an empty path and append the line segments path = CreatePath() for i in range(corners): p = Polar(radius, angle * i + pi / 2) path.AppendLine(p) # close the path. path.AppendLine(path.Node(0)) path.ClosePath() return path
def create_spiral_path(rotation, radius):
r = unit.convert(radius)
rate = r / (rotation * 2 * pi)
def tangent(phi, a=0.55197 * rate):
return a * Point(cos(phi) - phi * sin(phi), sin(phi) + phi * cos(phi))
pi2 = pi / 2.0
angle = 0
tang = tangent(0)
path = CreatePath()
p = Point(0, 0)
path.AppendLine(p)
for i in range(rotation * 4):
p1 = p + tang
angle = pi2 * (i + 1)
p = Polar(rate * angle, angle)
tang = tangent(angle)
p2 = p - tang
path.AppendBezier(p1, p2, p, ContSymmetrical)
return path
def apply_constraint(self, p, state):
if state & ConstraintMask:
try:
inverse = self.trafo.inverse()
p2 = inverse(p)
r, phi = p2.polar()
pi12 = pi / 12
angle = pi12 * floor(phi / pi12 + 0.5)
pi2 = 2 * pi
d1 = fmod(abs(phi - angle), pi2)
if self.selection == 1:
selected_angle = self.end_angle
else:
selected_angle = self.start_angle
d2 = fmod(abs(phi - selected_angle), pi2)
if d2 < d1:
phi = selected_angle
else:
phi = angle
p = self.trafo(Polar(r, phi))
except SingularMatrix:
pass
return p
def apply_constraint(self, p, state):
if state:
if self.selection in self.selAspect:
ref_x, ref_y = self.reference
aspect = self.aspect
if aspect is None:
# width is 0
p = Point(self.drag_start.x, p.y)
else:
w = p.x - ref_x
h = p.y - ref_y
if w == 0:
w = 0.00001
a = h / w
if a > 0:
sign = 1
else:
sign = -1
if abs(a) > aspect:
h = sign * w * aspect
else:
w = sign * h / aspect
p = Point(ref_x + w, ref_y + h)
# if state & const.AlternateMask:
# pi4 = math.pi / 4
# off = p - self.drag_start
# d = Polar(pi4 * round(math.atan2(off.y, off.x) / pi4))
# p = self.drag_start + (off * d) * d
# print 'ALT'
if state & const.ConstraintMask: # and self.selection == -1:
pi4 = math.pi / 4
off = p - self.drag_start
d = Polar(pi4 * round(math.atan2(off.y, off.x) / pi4))
p = self.drag_start + (off * d) * d
return p