I've made some headway implementing a primitive hypertoon using VPython. I came up with the hypertoon concept some years back, per this 1996 web page: http://www.grunch.net/synergetics/hypertoon.html The basic idea is you have this set of key frames, say A-F, and a set of cartoons or "scenarios" which always start and finish with one of the key frames. In between you have some transformation that takes you smoothly from the starting key frame to the ending one. A dictionary of scenarios might look like this: scenarios = {} # Scenario( function, starting frame, ending frame) scenarios['sc0'] = Scenario(trans0, 'A', 'B') scenarios['sc1'] = Scenario(trans1, 'A', 'C') scenarios['sc2'] = Scenario(trans2, 'A', 'D') scenarios['sc3'] = Scenario(trans3, 'B', 'C') scenarios['sc4'] = Scenario(trans4, 'C', 'D') scenarios['sc5'] = Scenario(trans5, 'D', 'B') ... So you get this spaghetti ball, or network, of interconnected nodes (the key frames), all interconnected by transformations (the scenarios). At each node, you may randomize the selection process, as to where to go next. def play(self, n): node = keyframes[0] lastthing = None for i in xrange(n): nodelist = self.nodes[node] # list of candidate toons nextsc = nodelist[randint(0,len(nodelist)-1)] # random pick lastthing = self.scenarios[nextsc].play(lastthing) # play it node = self.scenarios[nextsc].finish # here's where you end up The result is a continuous smooth motion visualization, with a lot of repetition, and with a lot of random sequencing. If the network is quite large, then you might keep seeing new stuff even after quite some time. Per my interest in geometry, my theme for my first VPython hypertoon is polyhedra and their interrelationships per what Bucky Fuller called the concentric hierarchy (or cosmic hierarchy when he was being cosmic). I started out with the following key frames: # A: rh dodeca all alone # B: octahedron all alone # C: cube all alone # D: tetra all alone Later I added: # E: cubocta all alone # F: Icosa all alone Not sure what's with this "all alone" -- emphasizing that we end up with nothing else on stage I guess. The first thing I did was script scenarios among the initial four key frames. I wrote a transformation in each direction, e.g. if there's a toon from A to B, there's also one from B to A. By transformation I don't mean anything very fancy. I basically just trace out edges (they progressively elongate, so each scenario takes a few seconds -- I adjust the frame rate). For example: def trans10(thing): print "trans10: tetra -> cube" tet = rbf.Tetra() # D: tetra all alone tet.draw() if thing is not None: thing.delete() invtet = rbf.Invtetra() invtet.draw(trace=True) cb = rbf.Cube() cb.draw(trace=True) tet.delete() invtet.delete() # C: cube all alone return cb Here we're going from the tetrahedron key frame to the cube key frame. I do this by drawing an inverted tetrahedron (black), intersecting the first one's mid edges, then connecting the resulting 8 points by tracing out a (green) cube. Then I delete the two tetrahedral, leaving only the cube. There's one subtlety here: each scenario returns the final polyhedron as an object, and this gets passed in to the next scenario as an argument. The next scenario then superimposes an identical shape, before deleting the one that got passed in. The purpose is to create overlap, so there's no point at which the stage is entirely empty. The fanciest I've gotten with the transformations so far is between E and F (the icosahedron and the cuboctahedron). For those of you familiar with Bucky's geometry (actually a philosophy), there's this thing called the jitterbug transformation that relates the two. I found this somewhat difficult to implement in VPython and ended up with a kind of double-buffering, where two polyhedra progressively draw and delete themselves as the vertices shift position. I'm posting the source code to my web site, in case you want to eyeball it in any detail (or even run it). I'll be changing it of course, as time permits. This version requires Python 2.4, meaning I'm using the VPython 2.4 experimental. However, it'd take only minor tweaks to make it run in 2.3 (I treat 'set' as a built-in and use 'sorted' is all). hypertoons.py -- the main module wherein all the scenarios are defined and from whence the hypertoon is launched rbf.py -- a library of concentric hierarchy shapes, repurposed from POV-Ray work to support VPython vectors instead. The repurposing is incomplete and fuzzy around the edges. coords.py -- where I've rolled my own vector classes, except now I hardly need 'em cuz I'm using VPython's native class. See: http://www.4dsolutions.net/ocn/python/hypertoons/ The only reason coords.py is still in the picture is I get the whole show rolling by defining a large set of vertices as globals within rbf.py. These are the key "points of interest" within the concentric hierarchy, out of which all the polyhedra are built. For historical reasons, these key points start out being defined in this weird coordinate system defined by four rays emanating from the center of a tetrahedron to its four corners, labeled (1,0,0,0), (0,1,0,0), (0,0,1,0), (0,0,0,1) -- a coordinate system that requires no negative numbers. It so happens that our points of interest are very easily expressed as vector sums (linear combinations) of these four. I immediately convert these weirdo vectors to traditional XYZ vectors in rbf.py, but I'm still using the old coords.py to start with with "Qvectors" (Q for Quadrays)[1]. Here's what that looks like in more detail (defining A-Z): ORIGIN = vector(0,0,0) A = vector(Qvector((1,0,0,0)).xyz) # center to corner of tetrahedron B = vector(Qvector((0,1,0,0)).xyz) # " C = vector(Qvector((0,0,1,0)).xyz) # " D = vector(Qvector((0,0,0,1)).xyz) # " # tetrahedron's dual (also a tetrahedron i.e. inverted tet) E,F,G,H = B+C+D,A+C+D,A+B+D,A+B+C # tetrahedron + dual (inverted tet) = duo-tet cube # octahedron vertices from pairs of tetrahedron radials I,J,K,L,M,N = A+B, A+C, A+D, B+C, B+D, C+D # octahedron + dual (cube) = rhombic dodecahedron # cuboctahedron vertices from pairs of octahedron radials O,P,Q,R,S,T = I+J, I+K, I+L, I+M, N+J, N+K U,V,W,X,Y,Z = N+L, N+M, J+L, L+M, M+K, K+J Kirby PS: Something I've discovered about VPython: apparently copy.deepcopy doesn't work reliably to copy vector objects. [1] http://www.grunch.net/synergetics/quadintro.html