00001
00002
00003
00004 from __future__ import with_statement
00005
00006 from time import clock
00007
00008 from PIL import Image
00009 from PIL import ImageDraw
00010 from Image import EXTENT
00011 from Image import BICUBIC
00012
00013 from random import shuffle
00014
00015 from poisson_disk import *
00016 from enhanced_grid import *
00017
00018 w = h = 256
00019 min_radius = 4
00020 max_radius = 20
00021
00022 def convert_enhanced_grid_to_png(grid, fname, ellipse=False):
00023 image = Image.new('RGBA', grid.dims)
00024
00025
00026 if ellipse:
00027 draw = ImageDraw.Draw(image)
00028 draw.rectangle(((0, 0), grid.dims), fill=(0, 0, 0, 255))
00029 else:
00030 pix = image.load()
00031
00032 for index in grid.index_iter():
00033 grey = int(255 * grid[index])
00034
00035 if ellipse:
00036 if grid[index] > 0:
00037 draw.ellipse((index, (index[0] + 3, index[1] + 3)), fill=(grey, grey, grey, 255))
00038 else:
00039 pix[index] = (grey, grey, grey, 255)
00040
00041 if ellipse:
00042 del draw
00043
00044 image.save(fname)
00045
00046 def make_image_grid_from_radius_grid(r_grid):
00047
00048 i_grid = Grid2D(r_grid.dims, 0)
00049
00050 for index in r_grid.index_iter():
00051 i_grid[index] = 1 if r_grid[index] > min_radius else 0
00052
00053 return i_grid
00054
00055 def make_image_grid_from_radius_grid_2(r_grid, min, max):
00056 d = max - min
00057 i_grid = Grid2D(r_grid.dims, 0)
00058
00059 for index in r_grid.index_iter():
00060 i_grid[index] = (r_grid[index] - min) / d
00061
00062 return i_grid
00063
00064
00065
00066 def paint_images_at_points(dims, points, image_names, fname):
00067 icon_width = icon_height = 64
00068
00069 def point_float_to_int(point):
00070 return int (point[0] - icon_width / 2), int(point[1] - icon_height / 2)
00071 images = []
00072
00073 image = Image.new('RGBA', dims)
00074
00075 for image_name in image_names:
00076 images.append(Image.open(image_name))
00077
00078 image_count = len(images)
00079
00080 shuffle(points)
00081
00082 for point in points:
00083 new_width = int(icon_width - 20 + random() * 20)
00084 new_height = new_width
00085 new_size = (new_width, new_height)
00086
00087 icon = images[rand(image_count)]
00088 icon = icon.transform(new_size, EXTENT, (0, 0, icon_width, icon_height), BICUBIC)
00089 icon = icon.rotate(random() * 360)
00090 image.paste(icon, point_float_to_int(point), icon)
00091
00092 image.save(fname)
00093
00094 def dist((x0, y0), (x1, y1)):
00095 u = (x1 - x0)
00096 v = (y1 - y0)
00097
00098 return sqrt(u*u + v*v)
00099
00100
00101 def poisson_demo():
00102 w = h = 512
00103 r_grid = Grid2D((w, h), max_radius)
00104 p = 128, 256
00105 q = 256, 128
00106 d = 12
00107 dd = -(64 - d)
00108 ddd = (64 + d/2)
00109
00110 for i, j in r_grid.index_iter():
00111 if ((((i + ddd) % 64) >= 32 + d) and \
00112 (((j + ddd) % 64) >= 32 + d)) or \
00113 (((((i + ddd) - dd) % 64) < 32 - d - 0) and \
00114 ((((j + ddd) - dd) % 64) < 32 - d - 0)):
00115 r_grid[i,j] = min_radius
00116 else:
00117 r_grid[i,j] = max_radius
00118
00119 p = sample_poisson(w, h, r_grid, 30)
00120
00121 g = points_to_grid(p, (w, h))
00122
00123 convert_enhanced_grid_to_png(g, 'poisson_image.png', True)
00124
00125 i_grid = make_image_grid_from_radius_grid(r_grid)
00126
00127 convert_enhanced_grid_to_png(i_grid, 'poisson_radius.png', False)
00128
00129 def poisson_circle_demo():
00130 w = h = 512
00131 r_grid = Grid2D((w, h))
00132 center = (w/2, h/2)
00133
00134 for index in r_grid.index_iter():
00135 r_grid[index] = (dist(index, center)) + 0.1
00136
00137 p = sample_poisson(w, h, r_grid, 30)
00138
00139 g = points_to_grid(p, (w, h))
00140
00141 convert_enhanced_grid_to_png(g, 'poisson_circle_image.png', True)
00142
00143 i_grid = make_image_grid_from_radius_grid_2(r_grid, 0.1, (sqrt(w*w/2)))
00144
00145 convert_enhanced_grid_to_png(i_grid, 'poisson_circle_radius.png', False)
00146
00147
00148 def poisson_texture_demo():
00149 images = ['daisy64.png']
00150
00151 w = h = 1024
00152 p = sample_poisson_uniform(w, h, 60, 40)
00153 paint_images_at_points((w, h), p, images, 'texture.png')
00154
00155 g = points_to_grid(p, (w, h))
00156 convert_enhanced_grid_to_png(g, 'uniform_poisson_for_texture.png', True)
00157
00158 def uniform_poisson_demo():
00159 p = sample_poisson_uniform(w, h, 13, 30)
00160 g = points_to_grid(p, (w, h))
00161 convert_enhanced_grid_to_png(g, 'uniform_poisson.png')
00162
00163 def uniform_demo():
00164 g = Grid2D((w, h), 0)
00165
00166 for i in range(256):
00167 x = rand(w)
00168 y = rand(h)
00169 g[x, y] = 1
00170
00171 convert_enhanced_grid_to_png(g, 'uniform_random.png')
00172
00173 def jittered_grid_demo():
00174 divisions = 16
00175 g = Grid2D((w, h), 0)
00176
00177 for i in range(w // divisions):
00178 for j in range(h // divisions):
00179 g[i * divisions + rand(divisions),
00180 j * divisions + rand(divisions)] = 1
00181
00182 convert_enhanced_grid_to_png(g, 'jittered_grid.png')
00183
00184 print "Demo 1/6..."
00185 poisson_demo()
00186
00187 print "Demo 2/6..."
00188 poisson_circle_demo()
00189
00190 print "Demo 3/6..."
00191 uniform_poisson_demo()
00192
00193 print "Demo 4/6..."
00194 uniform_demo()
00195
00196 print "Demo 5/6..."
00197 jittered_grid_demo()
00198
00199 print "Demo 6/6..."
00200 poisson_texture_demo()
00201
00202 print "Done."