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 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 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