def dart(d,e,f, depth, parent="d"):
if depth <= 1:
if parent == "d" or depth == 1:
draw.polygon(d.tuple()+e.tuple()+f.tuple(), outline=outline, fill=dartfill)
else:
fd = midpoint(f,d, depth)
fe = midpoint(f,e, depth)
draw.polygon(f.tuple() + fd.tuple() + fe.tuple(), outline=outline, fill=dartfill)
draw.polygon(d.tuple() + e.tuple() + fe.tuple() + fd.tuple(), outline=outline, fill=kitefill)
else:
p = midpoint(e,f, (phi-1)/phi)
dart(p,d,e, depth-1, "d")
kite(f,p,d, depth-1, "d")
def kite(a,b,c, depth, parent="k"):
if depth <= 1:
if parent == "k" or depth == 1:
draw.polygon(a.tuple()+b.tuple()+c.tuple(), outline=outline, fill=kitefill)
else:
ab = midpoint(a,b, depth)
ac = midpoint(a,c,depth)
draw.polygon(a.tuple()+ab.tuple()+ac.tuple(), outline=outline, fill=kitefill)
draw.polygon(b.tuple() + c.tuple() + ac.tuple() + ab.tuple(), outline=outline, fill=dartfill)
else:
p = midpoint(a,b, (phi-1)/phi)
q = midpoint(a,c, 1/phi)
dart(p,q,a, depth-1, "k")
kite(b,p,q, depth-1, "k")
kite(b,c,q, depth-1, "k")
def subDivide(polygon, depth):
if depth == 0:
return [polygon]
assert(len(polygon.points) == 3)
a,b,c = polygon.points
ab = midpoint(a,b)
bc = midpoint(b,c)
ca = midpoint(c,a)
subFaces = [
subDivide(Polygon(a, ab, ca), depth-1),
subDivide(Polygon(b, bc, ab), depth-1),
subDivide(Polygon(c, ca, bc), depth-1),
subDivide(Polygon(ab, bc, ca), depth-1)
]
faces = sum(subFaces, [])
return faces
def at(self, frac=None, **kargs):
if frac == None: frac = kargs.get("frac", kargs.get("dist", 0)/float(self.distance))
def midpoint(a,b, frac):
return a*(1-frac) + b*frac
theta = midpoint(self.start, self.end, frac)
x = self.center.x + self.radius * math.cos(theta)
y = self.center.y + self.radius * math.sin(theta)
return Point(x, y)
def line(draw, a,b, **kwargs):
style = kwargs.pop("style", "solid")
if style == "solid":
draw.line(a.tuple()+b.tuple(), **kwargs)
elif style == "dotted":
segment_size = 10
length = (b-a).magnitude()
if length == 0: return
points = [midpoint(a,b,f) for f in frange(0,1, float(segment_size)/length)]
for a,b in pairs(points):
line(draw, a,b, **kwargs)
else:
raise Exception("Unknown line style {}".format(style))
def setsize_fixed(self, start, end):
"""
Sizing mechanism for fixed size buildings like 3x3 workshops,
5x5 trade depots and 5x5 siege workshops. Here we just move to
the center of the building and deploy it. This allows for e.g.
a 3x3 grid of 'wc' cells indicating a single carpenter's workshop.
Returns keys, pos:
keys needed to make the currently-designating area the correct size
pos is where the cursor ends up after sizing the area
"""
# move cursor halfway to end from start
mid = midpoint(start, end)
keys = self.move(start, mid)
return keys, mid
def setsize_fixed(self, start, end):
"""
Sizing mechanism for fixed size buildings like 3x3 workshops,
5x5 trade depots and 5x5 siege workshops. Here we just move to
the center of the building and deploy it. This allows for e.g.
a 3x3 grid of 'wc' cells indicating a single carpenter's workshop.
Returns keys, pos:
keys needed to make the currently-designating area the correct size
pos is where the cursor ends up after sizing the area
"""
# move cursor halfway to end from start
mid = midpoint(start, end)
keys = self.move(start, mid)
return keys, mid
def sier(depth, a, b, c):
def tri(a,b,c):
def line(start, end):
im_draw.line([start.tuple(), end.tuple()], fill="black")
line(a,b); line(b,c); line(c,a)
if depth == 1:
tri(a,b,c)
else:
sier(depth-1, a, midpoint(a,b), midpoint(c,a))
sier(depth-1, b, midpoint(b,c), midpoint(a,b))
sier(depth-1, c, midpoint(c,a), midpoint(b,c))
def setsize_build(self, start, end):
"""
Standard sizing mechanism for the build buildtype.
Returns keys, pos:
keys needed to make the currently-designating area the correct size
pos is where the cursor ends up after sizing the area
"""
# move cursor halfway to end from start
mid = midpoint(start, end)
keys = self.move(start, mid)
# resize construction
area = Area(start, end)
keys += ['{widen}'] * (area.width() - 1)
keys += ['{heighten}'] * (area.height() - 1)
return keys, mid
def transform(
wheel1: Point,
wheel2: Point,
tail: Point,
scene_center: Point,
):
"""
:return: (
robot_position, # position against scene center;
angle, # angle against scene center;
distance, # distance to scene center;
)
"""
robot_center = midpoint(wheel1, wheel2)
# finds the tail point's prime and its projection line - the main one
tail_prime = two_points_90(wheel1, robot_center)
intersection_line = line(wheel1, wheel2)
if not pts_same_side(tail, tail_prime, intersection_line):
tail_prime = two_points_90(wheel2, robot_center)
main_projection_line = line(tail, tail_prime)
# finds center line's prime
center_line = line(scene_center, robot_center)
side_line = line(tail, wheel1)
side_intersection = intersection(center_line, side_line)
if side_intersection:
side_line_prime = line(tail_prime, wheel1)
else:
side_line = line(tail, wheel2)
side_intersection = intersection(center_line, side_line)
side_line_prime = line(tail_prime, wheel2)
# noinspection PyTypeChecker
side_intersection_projection_line = parallel_line(main_projection_line, side_intersection)
side_intersection_prime = intersection(side_line_prime, side_intersection_projection_line)
center_line_prime = line(robot_center, side_intersection_prime)
# computes position, angle and distance
center_line_projection = parallel_line(main_projection_line, scene_center)
center_prime = intersection(center_line_projection, center_line_prime)
dist = distance(center_prime, robot_center) / distance(robot_center, tail_prime)
robot_position = robot_center - center_prime
angle = math.degrees(normalize_angle(
three_pts_angle(tail_prime, robot_center, center_prime) - math.pi))
return Object(robot_position, angle, (dist * ROBOT_UNIT))
def setsize_build(self, start, end):
"""
Standard sizing mechanism for the build buildtype.
Returns keys, pos:
keys needed to make the currently-designating area the correct size
pos is where the cursor ends up after sizing the area
"""
# move cursor halfway to end from start
mid = midpoint(start, end)
keys = self.move(start, mid)
# resize construction
area = Area(start, end)
keys += ['{widen}'] * (area.width() - 1)
keys += ['{heighten}'] * (area.height() - 1)
return keys, mid
def shift(point):
dest = normalized(point, center, 1)
return midpoint(point, dest, amtMutated)
def at(self, frac=None, **kargs):
if frac == None: frac = kargs.get("frac", kargs.get("dist", 0)/float(self.distance))
return midpoint(self.start, self.end, frac)
def bezier_step(points, f):
return [midpoint(points[i], points[i+1], f) for i in range(len(points)-1)]
def logo_arcs(crossovers):
n = len(crossovers)
# Outer arcs.
outer_arcs = []
for i in range(0, n, 2):
inner = crossovers[i]
outer1 = crossovers[(i - 1) % n]
outer2 = crossovers[(i + 1) % n]
outer_arcs.append(arc_center_a_b(inner, outer1, outer2))
# Middle arcs.
middle_left_arcs = []
middle_right_arcs = []
middle_centers = {}
for i in range(0, n, 2):
outer = crossovers[(i + 1) % n]
inner1 = crossovers[i]
inner2 = crossovers[(i + 2) % n]
mid1 = midpoint(inner1, outer)
tangent1 = perp(outer - inner1)
center1 = intersect_lines(
outer,
inner2,
mid1,
mid1 + tangent1,
)
middle_left_arcs.append(arc_center_a_b(center1, inner1, outer))
mid2 = midpoint(inner2, outer)
tangent2 = perp(outer - inner2)
center2 = intersect_lines(
outer,
inner1,
mid2,
mid2 - tangent2,
)
middle_right_arcs.append(arc_center_a_b(center2, outer, inner2))
middle_centers[i] = center1
middle_centers[i + 1] = center2
# Inner arcs.
inner_arcs = []
for i in range(1, n, 2):
inner1 = crossovers[(i - 1) % n]
inner2 = crossovers[(i + 1) % n]
# Get the middle arc circle centers which are perpendicular to the ends of the
# inner arc, so the arcs will be cotangent.
middleCenter1 = middle_centers[(i - 2) % n]
middleCenter2 = middle_centers[(i + 1) % n]
# These lines intersect at the inner arc center.
center = intersect_lines(middleCenter1, inner1, middleCenter2, inner2)
inner_arcs.append(arc_center_a_b(center, inner2, inner1))
# Assemble arcs.
m = n // 2
arcs = []
for i in range(m):
j = i * 3 % m
arcs.append(outer_arcs[j])
arcs.append(middle_right_arcs[j])
arcs.append(inner_arcs[(j + 1) % m])
arcs.append(middle_left_arcs[(j + 2) % m])
return arcs
