├── img
    └── .EMPTY
├── profile
    └── .EMPTY
├── speedup
    └── __init__.py
├── .gitignore
├── Makefile
├── setup.py
├── README.md
├── LICENSE
├── main_ani.py
├── orbitals.py
├── main_ani_detail.py
├── main.py
├── src
    └── speedup.pyx
└── render.py


/img/.EMPTY:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/profile/.EMPTY:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/speedup/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.png
 2 | *.*~
 3 | *.swp
 4 | run*/*
 5 | *.pyc
 6 | .ropeproject
 7 | build
 8 | profile
 9 | *.so
10 | *.c
11 | *.html
12 | 
13 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | all:
 4 | 	python setup.py build_ext --inplace
 5 | 	cython -a src/*.pyx
 6 | 	mv *.so speedup
 7 | 
 8 | html:
 9 | 	cython -a src/*.pyx
10 | 
11 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/python
 2 | 
 3 | from distutils.core import setup
 4 | from distutils.extension import Extension
 5 | from Cython.Build import cythonize
 6 | from Cython.Distutils import build_ext
 7 | import numpy
 8 | 
 9 | _extra = ['-O3', '-ffast-math']
10 | 
11 | extensions = [
12 |   Extension('speedup',
13 |             sources = ['./src/speedup.pyx'],
14 |             extra_compile_args = _extra
15 |   )
16 | ]
17 | 
18 | setup(
19 |   name = "speedup",
20 |   cmdclass={'build_ext' : build_ext},
21 |   include_dirs = [numpy.get_include()],
22 |   ext_modules = cythonize(extensions,include_path = [numpy.get_include()])
23 | )
24 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Orbitals
 2 | =============
 3 | 
 4 | Orbitals is based on the naive optimization process that Jared Tarbell has
 5 | implemented in his "[Happy
 6 | Place](http://www.complexification.net/gallery/machines/happyPlace/index.php)"
 7 | algorithm. Nodes are created in some, more or less structured arangement,
 8 | before they start to make friends with their neighbors. Gradually the nodes
 9 | make an effort to get closer to their friends, whilst at the same time keeping
10 | a comfortable distance from the nodes they have not befriended.  The
11 | visualization is made by drawing lines betweeen pairs of friends as they walk
12 | around the canvas. Thus the final image is a history of all the friendships.
13 | 
14 | This is the fastest version. Probably.
15 | 
16 | ![orbitals](https://inconvergent.net/img/orbitals_ba.jpg "orbitals")
17 | 
18 | -----------
19 | https://inconvergent.net
20 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 Anders Hoff
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/main_ani.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/python
 2 | # -*- coding: utf-8 -*-
 3 | 
 4 | import gtk
 5 | 
 6 | #np.random.seed(1)
 7 | 
 8 | COLOR_PATH = '../colors/dark_cyan_white_black.gif'
 9 | #COLOR_PATH = '../colors/shimmering.gif'
10 | 
11 | SIZE = 1080 # size of png image
12 | NUM = 200 # number of nodes
13 | MAXFS = 10 # max friendships pr node
14 | 
15 | BACK = [1,1,1,1] # background color
16 | GRAINS = 10
17 | ALPHA = 0.05 # opacity of drawn points
18 | 
19 | STP = 0.0001
20 | 
21 | RAD = 0.26 # radius of starting circle
22 | FARL  = 0.13 # ignore "enemies" beyond this radius
23 | NEARL = 0.02 # do not attempt to approach friends close than this
24 | 
25 | UPDATE_NUM = 35
26 | 
27 | FRIENDSHIP_RATIO = 0.1 # probability of friendship dens
28 | FRIENDSHIP_INITIATE_PROB = 0.1 # probability of friendship initation attempt
29 | 
30 | print
31 | print 'SIZE', SIZE
32 | print 'NUM', NUM
33 | print 'STP', STP
34 | print
35 | print 'MAXFS', MAXFS
36 | print 'GRAINS', GRAINS
37 | print 'COLOR_PATH', COLOR_PATH
38 | print 'RAD', RAD
39 | print 'FRIENDSHIP_RATIO', FRIENDSHIP_RATIO
40 | print 'FRIENDSHIP_INITIATE_PROB', FRIENDSHIP_INITIATE_PROB
41 | print
42 | 
43 | 
44 | def main():
45 | 
46 |   #from time import time
47 |   from render import Animate
48 |   from orbitals import Orbitals
49 |   from time import time
50 | 
51 | 
52 |   orbitals = Orbitals(NUM,STP,FARL,NEARL,FRIENDSHIP_RATIO,
53 |                       FRIENDSHIP_INITIATE_PROB,MAXFS)
54 |   orbitals.init(RAD)
55 | 
56 |   def step_wrap(render):
57 | 
58 |     t1 = time()
59 |     for i in xrange(UPDATE_NUM):
60 |       orbitals.step()
61 |       render.connections(*orbitals.get_render_data())
62 |     t2 = time()
63 | 
64 |     print render.steps, t2-t1
65 | 
66 |     return True
67 | 
68 |   render = Animate(COLOR_PATH,BACK,ALPHA,GRAINS,SIZE, step_wrap)
69 | 
70 |   gtk.main()
71 | 
72 | 
73 | if __name__ == '__main__' :
74 | 
75 |   if False:
76 | 
77 |     import pyximport
78 |     pyximport.install()
79 |     import pstats, cProfile
80 | 
81 |     fn = './profile/profile'
82 |     cProfile.runctx("main()", globals(), locals(), fn)
83 |     p = pstats.Stats(fn)
84 |     p.strip_dirs().sort_stats('cumulative').print_stats()
85 | 
86 |   else:
87 | 
88 |     main()
89 | 
90 | 


--------------------------------------------------------------------------------
/orbitals.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/python
 2 | # -*- coding: utf-8 -*-
 3 | 
 4 | from numpy.random import random, randint
 5 | from numpy import zeros, sin, cos
 6 | 
 7 | class Orbitals(object):
 8 | 
 9 |   def __init__(self,num,stp,farl,nearl,friendship_ratio,
10 |                friendship_initiate_prob,maxfs):
11 | 
12 |     self.num = num
13 |     self.stp = stp
14 |     self.farl = farl
15 |     self.nearl = nearl
16 |     self.friendship_ratio = friendship_ratio
17 |     self.friendship_initiate_prob = friendship_initiate_prob
18 |     self.maxfs = maxfs
19 | 
20 |     self.X = zeros(num,'float')
21 |     self.Y = zeros(num,'float')
22 |     self.R = zeros((num,num),'float')
23 |     self.A = zeros((num,num),'float')
24 |     self.F = zeros((num,num),'int')
25 | 
26 |   def make_friends(self,i):
27 | 
28 |     cand_num = self.F.sum(axis=1)
29 | 
30 |     maxfs = self.maxfs
31 |     F = self.F
32 | 
33 |     if cand_num[i]>=maxfs:
34 |       return
35 | 
36 |     cand_mask = cand_num<maxfs
37 |     cand_mask[i] = 0
38 |     cand_ind = cand_mask.nonzero()[0]
39 | 
40 |     cand_dist = self.R[i,cand_ind].flatten()
41 |     cand_sorted_dist = cand_dist.argsort()
42 |     cand_ind = cand_ind[cand_sorted_dist]
43 | 
44 |     cand_n = len(cand_ind)
45 | 
46 |     if cand_n<1:
47 |       return
48 | 
49 |     for k in xrange(cand_n):
50 | 
51 |       if random()<self.friendship_ratio:
52 | 
53 |         j = cand_ind[k]
54 |         F[[i,j],[j,i]] = 1
55 |         return
56 | 
57 |   def init(self, rad):
58 | 
59 |     from numpy import pi
60 | 
61 |     for i in xrange(self.num):
62 |       the = random()*pi*2
63 |       phi = random()*pi*2
64 |       x = rad * sin(the)
65 |       y = rad * cos(the)
66 |       self.X[i] = 0.5+x + cos(phi)*rad*0.05
67 |       self.Y[i] = 0.5+y + sin(phi)*rad*0.05
68 | 
69 |   def step(self):
70 | 
71 |     from speedup.speedup import pyx_set_distances
72 |     from speedup.speedup import pyx_iteration
73 | 
74 |     pyx_set_distances(self.X,self.Y,self.A,self.R,self.num)
75 |     pyx_iteration(self.X,self.Y,self.A,self.R,self.F,self.num,
76 |                   self.stp,self.farl,self.nearl)
77 | 
78 |     if random()<self.friendship_initiate_prob:
79 | 
80 |       k = randint(self.num)
81 |       self.make_friends(k)
82 | 
83 |   def get_render_data(self):
84 |     return self.X,self.Y,self.F,self.A,self.R
85 | 
86 | 
87 | 


--------------------------------------------------------------------------------
/main_ani_detail.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/python
  2 | # -*- coding: utf-8 -*-
  3 | 
  4 | import gtk
  5 | 
  6 | #np.random.seed(1)
  7 | 
  8 | COLOR_PATH = '../colors/dark_cyan_white_black.gif'
  9 | 
 10 | SIZE = 1080 # size of png image
 11 | NUM = 200 # number of nodes
 12 | MAXFS = 100 # max friendships pr node
 13 | 
 14 | BACK = [1,1,1,1] # background color
 15 | GRAINS = 5
 16 | ALPHA = 0.05 # opacity of drawn points
 17 | 
 18 | STP = 0.0001
 19 | 
 20 | RAD = 0.26 # radius of starting circle
 21 | FARL  = 0.13 # ignore "enemies" beyond this radius
 22 | NEARL = 0.02 # do not attempt to approach friends close than this
 23 | 
 24 | UPDATE_NUM = 15
 25 | 
 26 | FRIENDSHIP_RATIO = 0.1 # probability of friendship dens
 27 | FRIENDSHIP_INITIATE_PROB = 0.1 # probability of friendship initation attempt
 28 | 
 29 | CONTRAST = [0,0.3,0.3,0.4]
 30 | FRONT = [0,0,0,1]
 31 | 
 32 | print
 33 | print 'SIZE', SIZE
 34 | print 'NUM', NUM
 35 | print 'STP', STP
 36 | print
 37 | print 'MAXFS', MAXFS
 38 | print 'GRAINS', GRAINS
 39 | print 'COLOR_PATH', COLOR_PATH
 40 | print 'RAD', RAD
 41 | print 'FRIENDSHIP_RATIO', FRIENDSHIP_RATIO
 42 | print 'FRIENDSHIP_INITIATE_PROB', FRIENDSHIP_INITIATE_PROB
 43 | print
 44 | 
 45 | 
 46 | def main():
 47 | 
 48 |   #from time import time
 49 |   from render import Animate
 50 |   from orbitals import Orbitals
 51 |   from time import time
 52 | 
 53 | 
 54 |   orbitals = Orbitals(NUM,STP,FARL,NEARL,FRIENDSHIP_RATIO,
 55 |                       FRIENDSHIP_INITIATE_PROB,MAXFS)
 56 |   orbitals.init(RAD)
 57 | 
 58 |   def step_wrap(render):
 59 | 
 60 |     render.ctx.set_line_width(render.one*2.)
 61 | 
 62 |     t1 = time()
 63 | 
 64 |     for i in xrange(UPDATE_NUM):
 65 |       orbitals.step()
 66 |       render.clear_canvas()
 67 | 
 68 |       render.ctx.set_source_rgba(*CONTRAST)
 69 |       render.circles(*orbitals.get_render_data(),r=render.one*10.)
 70 | 
 71 |       render.ctx.set_source_rgba(*FRONT)
 72 |       render.connections_lines(*orbitals.get_render_data())
 73 | 
 74 |     t2 = time()
 75 | 
 76 |     print render.steps, t2-t1
 77 | 
 78 |     return True
 79 | 
 80 |   render = Animate(COLOR_PATH,BACK,ALPHA,GRAINS,SIZE, step_wrap)
 81 | 
 82 |   gtk.main()
 83 | 
 84 | 
 85 | if __name__ == '__main__' :
 86 | 
 87 |   if False:
 88 | 
 89 |     import pyximport
 90 |     pyximport.install()
 91 |     import pstats, cProfile
 92 | 
 93 |     fn = './profile/profile'
 94 |     cProfile.runctx("main()", globals(), locals(), fn)
 95 |     p = pstats.Stats(fn)
 96 |     p.strip_dirs().sort_stats('cumulative').print_stats()
 97 | 
 98 |   else:
 99 | 
100 |     main()
101 | 
102 | 


--------------------------------------------------------------------------------
/main.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/python
  2 | # -*- coding: utf-8 -*-
  3 | 
  4 | #np.random.seed(1)
  5 | 
  6 | COLOR_PATH = '../colors/dark_cyan_white_black.gif'
  7 | #COLOR_PATH = '../colors/shimmering.gif'
  8 | 
  9 | SIZE = 1080 # size of png image
 10 | NUM = 200 # number of nodes
 11 | MAXFS = 10 # max friendships pr node
 12 | 
 13 | BACK = [1,1,1,1] # background color
 14 | GRAINS = 5
 15 | ALPHA = 0.05 # opacity of drawn points
 16 | 
 17 | ONE = 1./SIZE
 18 | STP = ONE/15.
 19 | 
 20 | RAD = 0.26 # radius of starting circle
 21 | FARL  = 0.13 # ignore "enemies" beyond this radius
 22 | NEARL = 0.02 # do not attempt to approach friends close than this
 23 | 
 24 | UPDATE_NUM = 1000
 25 | 
 26 | FRIENDSHIP_RATIO = 0.1 # probability of friendship dens
 27 | FRIENDSHIP_INITIATE_PROB = 0.1 # probability of friendship initation attempt
 28 | 
 29 | FILENAME = './img/ff_c_num{:d}_fs{:d}_near{:2.4f}_far{:2.4f}_pa{:2.4f}_pb{:2.4f}'\
 30 |            .format(NUM,MAXFS,NEARL,FARL,
 31 |                    FRIENDSHIP_RATIO,FRIENDSHIP_INITIATE_PROB)
 32 | FILENAME = FILENAME + '_itt{:05d}.png'
 33 | 
 34 | print
 35 | print 'SIZE', SIZE
 36 | print 'NUM', NUM
 37 | print 'STP', STP
 38 | print 'ONE', ONE
 39 | print
 40 | print 'MAXFS', MAXFS
 41 | print 'GRAINS', GRAINS
 42 | print 'COLOR_PATH', COLOR_PATH
 43 | print 'RAD', RAD
 44 | print 'FRIENDSHIP_RATIO', FRIENDSHIP_RATIO
 45 | print 'FRIENDSHIP_INITIATE_PROB', FRIENDSHIP_INITIATE_PROB
 46 | print
 47 | 
 48 | 
 49 | def main():
 50 | 
 51 |   from time import time
 52 |   from itertools import count
 53 | 
 54 |   from render import Render
 55 |   from orbitals import Orbitals
 56 | 
 57 |   render = Render(COLOR_PATH,BACK,ALPHA,GRAINS,SIZE)
 58 | 
 59 |   orbitals = Orbitals(NUM,STP,FARL,NEARL,FRIENDSHIP_RATIO,
 60 |                       FRIENDSHIP_INITIATE_PROB,MAXFS)
 61 |   orbitals.init(RAD)
 62 | 
 63 |   render_connections = render.connections
 64 | 
 65 |   tcum = 0
 66 | 
 67 |   for itt in count():
 68 | 
 69 |     t1 = time()
 70 | 
 71 |     orbitals.step()
 72 |     render_connections(*orbitals.get_render_data())
 73 | 
 74 |     t2 = time()
 75 | 
 76 |     tcum += t2-t1
 77 | 
 78 |     if not (itt+1)%100:
 79 | 
 80 |       print itt, tcum
 81 |       tcum = 0
 82 | 
 83 |     if not (itt+1)%UPDATE_NUM:
 84 | 
 85 |       fn = FILENAME.format(itt+1)
 86 |       print fn
 87 |       render.sur.write_to_png(fn)
 88 | 
 89 | 
 90 | if __name__ == '__main__' :
 91 | 
 92 |   if True:
 93 | 
 94 |     import pstats, cProfile
 95 |     fn = './profile/profile'
 96 |     cProfile.run('main()',fn)
 97 |     p = pstats.Stats(fn)
 98 |     p.strip_dirs().sort_stats('cumulative').print_stats()
 99 | 
100 |   else:
101 | 
102 |     main()
103 | 
104 | 


--------------------------------------------------------------------------------
/src/speedup.pyx:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | # cython: profile=True
  3 | 
  4 | from __future__ import division
  5 | 
  6 | import numpy as np
  7 | cimport numpy as np
  8 | cimport cython
  9 | 
 10 | cdef float PI = np.pi
 11 | 
 12 | #from libc.stdlib cimport malloc, free
 13 | from libc.math cimport sqrt
 14 | from libc.math cimport cos
 15 | from libc.math cimport sin
 16 | from libc.math cimport atan2
 17 | 
 18 | 
 19 | # hack ahead ...
 20 | 
 21 | @cython.wraparound(False)
 22 | @cython.boundscheck(False)
 23 | @cython.nonecheck(False)
 24 | def pyx_connections(np.ndarray[double, mode="c",ndim=1] X,
 25 |                     np.ndarray[double, mode="c",ndim=1] Y,
 26 |                     np.ndarray[long, mode="c",ndim=2] F,
 27 |                     np.ndarray[double, mode="c",ndim=2] A,
 28 |                     np.ndarray[double, mode="c",ndim=2] R,
 29 |                     long num,
 30 |                     double one,
 31 |                     tuple colors,
 32 |                     long n_colors,
 33 |                     double alpha,
 34 |                     long grains,
 35 |                     fill,
 36 |                     rectangle,
 37 |                     set_source_rgba,
 38 |                     random):
 39 |   cdef int i
 40 |   cdef int j
 41 |   cdef int k
 42 |   cdef float a
 43 |   cdef float d
 44 |   cdef float s
 45 |   cdef float x
 46 |   cdef float y
 47 |   cdef tuple rgb
 48 | 
 49 | 
 50 |   cdef np.ndarray[double, mode="c",ndim=1] rnd
 51 | 
 52 |   for i in xrange(num):
 53 |     for j in xrange(i+1,num):
 54 | 
 55 |       if F[i,j]<1:
 56 |         continue
 57 | 
 58 |       a = A[i,j]
 59 |       d = R[i,j]
 60 | 
 61 |       rnd = random(grains)
 62 | 
 63 |       rgb = colors[ (i*num+j) % n_colors ]
 64 |       set_source_rgba(rgb[0],rgb[1],rgb[2],alpha)
 65 | 
 66 |       for k in xrange(grains):
 67 |         s = rnd[k]
 68 |         x = X[i] - d*s*cos(a)
 69 |         y = Y[i] - d*s*sin(a)
 70 |         rectangle(x,y,one,one)
 71 |         fill()
 72 | 
 73 | @cython.wraparound(False)
 74 | @cython.boundscheck(False)
 75 | @cython.nonecheck(False)
 76 | @cython.cdivision(True)
 77 | def pyx_set_distances(np.ndarray[double, mode="c",ndim=1] X,
 78 |                       np.ndarray[double, mode="c",ndim=1] Y,
 79 |                       np.ndarray[double, mode="c",ndim=2] A,
 80 |                       np.ndarray[double, mode="c",ndim=2] R,
 81 |                       int num):
 82 | 
 83 |   cdef int i
 84 |   cdef int j
 85 |   cdef float dx
 86 |   cdef float dy
 87 |   cdef float x
 88 |   cdef float y
 89 |   cdef float a
 90 | 
 91 |   for i in xrange(num):
 92 |     x = X[i]
 93 |     y = Y[i]
 94 |     for j in xrange(i,num):
 95 |       if i==j:
 96 |         A[i,j] = 0.
 97 |         R[i,j] = 0.
 98 |         continue
 99 | 
100 |       dx = x-X[j]
101 |       dy = y-Y[j]
102 |       d = sqrt(dx*dx + dy*dy)
103 | 
104 |       A[i,j] = atan2(dy,dx)
105 |       A[j,i] = atan2(-dy,-dx)
106 | 
107 |       R[i,j] = d
108 |       R[j,i] = d
109 | 
110 |   return
111 | 
112 | @cython.wraparound(False)
113 | @cython.boundscheck(False)
114 | @cython.nonecheck(False)
115 | @cython.cdivision(True)
116 | def pyx_iteration(np.ndarray[double, mode="c",ndim=1] X,
117 |                   np.ndarray[double, mode="c",ndim=1] Y,
118 |                   np.ndarray[double, mode="c",ndim=2] A,
119 |                   np.ndarray[double, mode="c",ndim=2] R,
120 |                   np.ndarray[long, mode="c",ndim=2] F,
121 |                   long num,
122 |                   float stp,
123 |                   float farl,
124 |                   float nearl):
125 |   cdef float d
126 |   cdef float a
127 |   cdef float dx
128 |   cdef float dy
129 |   cdef float sx
130 |   cdef float sy
131 |   cdef float speed
132 |   cdef int i
133 |   cdef int j
134 | 
135 |   for i in xrange(num):
136 |     sx = 0.
137 |     sy = 0.
138 |     for j in xrange(num):
139 | 
140 |       if i == j:
141 |         continue
142 | 
143 |       d = R[i,j]
144 |       a = A[i,j]
145 |       dx = cos(a)
146 |       dy = sin(a)
147 | 
148 |       if F[i,j]>0:
149 |         if d<nearl:
150 |           speed = farl-d
151 |           sx += dx*speed
152 |           sy += dy*speed
153 |         else:
154 |           sx -= dx
155 |           sy -= dy
156 |       else:
157 |         if d<farl:
158 |           speed = farl-d
159 |           sx += dx*speed
160 |           sy += dy*speed
161 | 
162 |     X[i] += sx*stp
163 |     Y[i] += sy*stp
164 | 
165 |   return
166 | 
167 | 


--------------------------------------------------------------------------------
/render.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/python
  2 | # -*- coding: utf-8 -*-
  3 | 
  4 | import cairo
  5 | import gtk, gobject
  6 | from speedup.speedup import pyx_connections
  7 | 
  8 | 
  9 | class Render(object):
 10 | 
 11 |   def __init__(self,color_path,back,alpha,grains,size):
 12 | 
 13 |     self.color_path = color_path
 14 |     self.size = size
 15 |     self.back = back
 16 |     self.grains = grains
 17 |     self.one = 1./size
 18 |     self.alpha = alpha
 19 | 
 20 |     self.__init_cairo()
 21 |     self.__get_colors(color_path)
 22 | 
 23 |   def __init_cairo(self):
 24 | 
 25 |     sur = cairo.ImageSurface(cairo.FORMAT_ARGB32,self.size,self.size)
 26 |     ctx = cairo.Context(sur)
 27 |     ctx.scale(self.size,self.size)
 28 |     self.sur = sur
 29 |     self.ctx = ctx
 30 | 
 31 |     self.clear_canvas()
 32 | 
 33 |   def clear_canvas(self):
 34 | 
 35 |     self.ctx.set_source_rgba(*self.back)
 36 |     self.ctx.rectangle(0,0,1,1)
 37 |     self.ctx.fill()
 38 | 
 39 |   def __get_colors(self,f):
 40 | 
 41 |     import Image
 42 |     from numpy.random import shuffle
 43 | 
 44 |     scale = 1./255.
 45 |     im = Image.open(f)
 46 |     w,h = im.size
 47 |     rgbim = im.convert('RGB')
 48 |     res = []
 49 |     for i in xrange(0,w):
 50 |       for j in xrange(0,h):
 51 |         r,g,b = rgbim.getpixel((i,j))
 52 |         res.append((r*scale,g*scale,b*scale))
 53 | 
 54 |     shuffle(res)
 55 |     self.colors = tuple(res)
 56 |     self.n_colors = len(res)
 57 | 
 58 |   def connections_pyx(self,X,Y,F,A,R):
 59 | 
 60 |     # this is rather hacky. connections is better code, but this is
 61 |     # about twice as fast (on the configurations i tested), which is useful
 62 |     # for animations
 63 | 
 64 |     rectangle = self.ctx.rectangle
 65 |     fill = self.ctx.fill
 66 |     set_source_rgba = self.ctx.set_source_rgba
 67 |     from numpy.random import random
 68 | 
 69 |     num = len(X)
 70 | 
 71 |     pyx_connections(X,Y,F,A,R,num,self.one,self.colors,self.n_colors,self.alpha,
 72 |                     self.grains,fill,rectangle,set_source_rgba,random)
 73 | 
 74 |   def circles(self,X,Y,F,A,R,r):
 75 | 
 76 |     from numpy import pi
 77 | 
 78 |     #r = self.one*7.
 79 | 
 80 |     arc = self.ctx.arc
 81 |     fill = self.ctx.fill
 82 | 
 83 |     fnum = F.sum(axis=0)
 84 | 
 85 |     for x,y,f in zip(X,Y,fnum):
 86 |       arc(x,y,r,0,pi*2.)
 87 |       fill()
 88 | 
 89 |   def connections_lines(self,X,Y,F,A,R):
 90 | 
 91 |     move_to = self.ctx.move_to
 92 |     line_to = self.ctx.line_to
 93 |     stroke = self.ctx.stroke
 94 | 
 95 |     indsx,indsy = F.nonzero()
 96 |     mask = indsx >= indsy
 97 | 
 98 |     for i,j in zip(indsx[mask],indsy[mask]):
 99 |       move_to(X[i],Y[i])
100 |       line_to(X[j],Y[j])
101 |       stroke()
102 | 
103 |   def connections(self,X,Y,F,A,R):
104 | 
105 |     from numpy.random import random
106 |     from numpy import sin, cos
107 | 
108 |     num = len(X)
109 |     one = self.one
110 | 
111 |     rectangle = self.ctx.rectangle
112 |     fill = self.ctx.fill
113 |     set_source_rgba = self.ctx.set_source_rgba
114 | 
115 |     colors = self.colors
116 |     n_colors = self.n_colors
117 |     alpha = self.alpha
118 |     grains = self.grains
119 | 
120 |     indsx,indsy = F.nonzero()
121 |     mask = indsx >= indsy
122 | 
123 |     for i,j in zip(indsx[mask],indsy[mask]):
124 |       a = A[i,j]
125 |       d = R[i,j]
126 |       scales = random(grains)*d
127 |       xp = X[i] - scales*cos(a)
128 |       yp = Y[i] - scales*sin(a)
129 | 
130 |       r,g,b = colors[ (i*num+j) % n_colors ]
131 |       set_source_rgba(r,g,b,alpha)
132 | 
133 |       for x,y in zip(xp,yp):
134 |         rectangle(x,y,one,one)
135 |         fill()
136 | 
137 | class Animate(Render):
138 | 
139 |   def __init__(self,color_path,back,alpha,grains,size, step):
140 | 
141 |     Render.__init__(self, color_path, back,alpha, grains, size)
142 | 
143 |     window = gtk.Window()
144 |     window.resize(self.size, self.size)
145 | 
146 |     self.step = step
147 | 
148 |     window.connect("destroy", self.__destroy)
149 |     darea = gtk.DrawingArea()
150 |     darea.connect("expose-event", self.expose)
151 |     window.add(darea)
152 |     window.show_all()
153 | 
154 |     self.darea = darea
155 |     self.steps = 0
156 | 
157 |     gobject.idle_add(self.step_wrap)
158 | 
159 |   def __destroy(self,*args):
160 | 
161 |     gtk.main_quit(*args)
162 | 
163 |   def expose(self,*args):
164 | 
165 |     cr = self.darea.window.cairo_create()
166 |     cr.set_source_surface(self.sur,0,0)
167 |     cr.paint()
168 | 
169 |   def step_wrap(self):
170 | 
171 |     res = self.step(self)
172 |     self.steps += 1
173 |     self.expose()
174 | 
175 |     return res
176 | 
177 | 


--------------------------------------------------------------------------------