def main(): glutInit(len(sys.argv), sys.argv) glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glutCreateWindow("wireframe tetrahedron"); glutReshapeWindow(200,200) glutDisplayFunc(display); glutTimerFunc(msPerFrame, timer, None) glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION) init(); glutMainLoop(); make_gif(screenshots) return 0;
def make_smooth_hanoi(size): if size > 6: raise Exception("ImageMagick cannot generate a gif of size {}".format(size)) def state_diff(prev, cur): """ identifies which ring has moved between the two states, and its source/dest. returns a (size, source, dest) tuple. """ size = None for i in range(3): if len(prev[i]) < len(cur[i]): dest = i elif len(prev[i]) > len(cur[i]): source = i size = prev[i][-1] if size == None: raise Exception("No difference detected between states {} and {}".format(prev, cur)) return (size, source, dest) imgs = [] prev = None for state in hanoi.iter_hanoi_state(0, 2, 1, size): if prev: # create transition between prev and state assert sum(len(tower) for tower in prev.values()) == size, "expected prev of size {}, got {}".format( size, prev ) free_ring, source, dest = state_diff(prev, state) prev[source].pop() for frac in frange(0, 1, 32): imgs.append(make_img(prev.values(), free_ring, source, dest, frac)) imgs.append(make_img(state.values())) prev = state for i in range(10): imgs.append(imgs[-1]) imgs = add_progress_bar(imgs) animation.make_gif(imgs, delay=2, name="smooth_hanoi_{}.gif".format(size))
def bounce(frames): return frames + [frames[-1]] * 12 + list(frames[::-1]) + [frames[0]]*12 draw = None def render(frac): global draw radius = 1000 center = Point(radius, radius) img = Image.new("RGB", (radius*2, radius*2), "white") draw = ImageDraw.Draw(img) spokes = [center + exp(radius, math.radians(theta)) for theta in range(0, 360, 36)] for i in range(10): b = spokes[i] c = spokes[(i+1)%len(spokes)] if i %2 == 1: b,c = c,b kite(center, b,c,frac) img = img.resize((radius/2, radius/2), Image.ANTIALIAS) return img import animation frames = [] for i in range(64): print i, frames.append(render(1 + (i / 8.))) animation.make_gif(bounce(frames), delay=8)
break yield cur def make_image(f): def trefoil(theta): r = math.sin(theta * 3) return Point(r*math.cos(theta), r*math.sin(theta)) theta = f * math.pi bands = [] offsets = (0, 120, 240) for offset in offsets: img = Image.new("L", (screen_width, screen_height), "black") draw = ImageDraw.Draw(img) p = trefoil(theta + math.radians(offset)) logical_dot(draw, p, math.cos(math.radians(30)), fill=0xFF, outline=0xFF) bands.append(img) return Image.merge("RGB", bands) seconds = 3 delay = 2 #in centiseconds frames = seconds * 100 / delay images = [] for f in frange(0, 1, 1.0/frames): print "{:03}%\r".format(int(f*100)), images.append(make_image(f)) animation.make_gif(images, delay=delay)
default = (255,0,255) if not neighbors: return default colors = [pix[p.x, p.y] for p in neighbors] return average(colors) def distort(src): src_pix = src.load() dst = Image.new("RGB", src.size) dst_pix = dst.load() for i in range(dst.size[0]): for j in range(dst.size[1]): p = f(Point(i,j)) dst_pix[i,j] = nice_get(src, src_pix, p) return dst src = Image.open("clock.png") imgs = [] frames = 16 for i in range(frames): print "Creating image {}...".format(i+1) t = (float(outer_radius)/inner_radius)**rebase(i, 0, frames, 0,1) print "time mult:", t dst = distort(src) imgs.append(dst) print "Created." print "Creating gif..." animation.make_gif(imgs, delay=4) print "Created."
for p in lattice.points_within(r.with_margin(lattice.u.magnitude())): corners = [p + delta for delta in corner_deltas] for a,b in iter_cycle(corners): draw.line(a.tuple()+b.tuple(), fill="black") return img def ease(f): return math.sin(f * math.pi / 2) frames = [] num_frames = 80 d = 80 origin = Point(window_size/2, window_size/2) lattice = Lattice(origin, Point(0,d), Point(d,0)) for s in range(2): for i in range(num_frames): print i, f = float(i)/num_frames q = float(num_frames*s + i) / (num_frames*2) z = 2**q frames.append(render(ease(f), lattice*z)) lattice.u = rotated(lattice.u, math.radians(45)) / math.sqrt(2) lattice.v = rotated(lattice.v, math.radians(45)) / math.sqrt(2) frames = [frame.resize((window_size/2, window_size/2), Image.ANTIALIAS) for frame in frames] animation.make_gif(frames)
def make_frame(f): size = 800 path_center = Point(size / 2, size / 2) path_radius = size / 4 path_p = path_center + exp(path_radius, f * 2 * math.pi) stars = [starburst(c, size, 30) for c in (Point(5 * size / 16, size / 2), path_p)] img = Image.new("RGB", (size, size), "white") draw = ImageDraw.Draw(img) for star in stars: for a, b in star: draw.line(a.tuple() + b.tuple(), fill="gray") for a, b in stars[0]: for c, d in stars[1]: p = intersection(a, b, c, d) if p is not None: dot(draw, p) return img.resize((size / 2, size / 2), Image.ANTIALIAS) frames = 240 images = [] for f in frange(0, 1, 1.0 / frames): print f images.append(make_frame(f)) animation.make_gif(images)
def make_hanoi(size): size = 5 imgs = [make_img(state.values()) for state in hanoi.iter_hanoi_state(0, 2, 1, size)] animation.make_gif(imgs, delay=15, name="hanoi_{}.gif".format(size))
drawBulgingLine(A,B, theta, surface) else: C = solveTriangle(A,B,maxAngle) drawLevyCurve(A,C,theta, level-1, surface) drawLevyCurve(C,B,theta, level-1, surface) def drawStuff(frame, surface): level = frame / framesPerLevel frame = frame % framesPerLevel theta = maxAngle * frame / framesPerLevel A = Point(windowSize.x/2, windowSize.y * 0.60) B = Point(windowSize.x/2, windowSize.y * 0.40) drawLevyCurve(A,B, theta, level, surface) frame = 0 levels = 13 screenshots = [] while frame < framesPerLevel * levels: for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() screen.fill(black) drawStuff(frame, screen) pygame.display.flip() screenshots.append(image_from_surface(screen)) time.sleep(1.0 / ticks_per_second) frame += 1 make_gif(screenshots)
from koch import Koch from gridFractal import GridFractal from sierpinsky import Sierpinsky def exists(filename): try: file = open(filename) file.close() return True except: return False fractals = { "koch": lambda: Koch(), "sierpinsky": lambda: Sierpinsky(), "grid_plus": lambda: GridFractal([[False, True, False],[True, True, True],[False, True, False]]), "grid_h": lambda: GridFractal([[True, False, True],[True, True, True],[True, False, True]]), "grid_t": lambda: GridFractal([[False, True, False],[False, True, False],[True, True, True]]), "grid_o": lambda: GridFractal([[False, True, True],[True, True, True],[True, True, False]]), } for key in sorted(fractals.keys()): filename = key + ".gif" if exists(filename): print "Already exists:\t{}".format(filename) else: fractal = fractals[key]() imgs = output.make_animation(fractal, 16) animation.make_gif(imgs, name=filename) print "created:\t{}.".format(filename)
else: print "frames does not divide rotational period; rendering full sequence" max_frame = frames for t in range(max_frame): f = float(t) / frames print t, theta = math.radians(360 * f) img = Image.new("RGB", (size, size), "white") draw = ImageDraw.Draw(img) for i,j, x, y in iter_circle_centers(f): circle(draw, (x, y), circle_radius, outline="gray") #we need two loops so the dots always render in front of the circles for i,j, x, y in iter_circle_centers(f): angle = angle_delta * (i-j) dot_x = int(x + math.cos(theta+angle) * circle_radius) dot_y = int(y + math.sin(theta+angle) * circle_radius) circle(draw, (dot_x, dot_y), dot_radius, outline="black", fill="black") #draw.rectangle((0,0, int(size*f), 5), fill="red") img = img.resize((size/2, size/2), Image.ANTIALIAS) images.append(img) animation.make_gif(images, delay=4, name="output.gif")
imgs = [] def frob(curve, curve_frac, forward_frac): points = render_curve(curve, curve_frac, forward_frac) width = max(p.x for p in points) points = [(p * 0.80 * size / width) + Point(size/10, size/10) for p in points] im = render_lines(points) imgs.append(im) def delay(n): imgs.append(imgs[-1]) max_depth = 6 for i in range(max_depth+1): print "generating curve depth {}".format(i) curve = space_filling_curve(i) for frac in [x * 0.10 for x in range(1, 11)]: frob(curve, frac, 0) if i == 0 or i == max_depth: continue delay(5) for frac in [x * 0.10 for x in range(1, 11)]: frob(curve, 1, frac) delay(5) #pause on the last frame delay(40) print "making gif..." make_gif(imgs, delay=4)