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)
