コード例 #1
0
ファイル: test.py プロジェクト: kms70847/Animation
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")
コード例 #2
0
ファイル: test.py プロジェクト: kms70847/Animation
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")
コード例 #3
0
ファイル: main.py プロジェクト: kms70847/Animation
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
コード例 #4
0
ファイル: path.py プロジェクト: kms70847/Animation
    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)
コード例 #5
0
ファイル: test.py プロジェクト: kms70847/Animation
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))
コード例 #6
0
    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
コード例 #7
0
    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
コード例 #8
0
ファイル: sierpinsky.py プロジェクト: kms70847/Animation
 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))
コード例 #9
0
    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
コード例 #10
0
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))
コード例 #11
0
    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
コード例 #12
0
ファイル: main.py プロジェクト: kms70847/Animation
 def shift(point):
     dest = normalized(point, center, 1)
     return midpoint(point, dest, amtMutated)
コード例 #13
0
ファイル: path.py プロジェクト: kms70847/Animation
 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)
コード例 #14
0
ファイル: test.py プロジェクト: kms70847/Animation
def bezier_step(points, f):
    return [midpoint(points[i], points[i+1], f) for i in range(len(points)-1)]
コード例 #15
0
ファイル: logo.py プロジェクト: christian-oudard/logo
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