00001
00002
00003
00004 from __future__ import division
00005
00006 from random import random
00007
00008 from PIL import Image
00009
00010 from enhanced_grid import *
00011
00012
00013 def int_sequence(seq):
00014 new_seq = []
00015
00016 for element in seq:
00017 new_seq.append(int(255 * element))
00018
00019 return tuple(new_seq)
00020
00021
00022 def float_sequence(seq):
00023 new_seq = []
00024
00025 for element in seq:
00026 new_seq.append(element / 255)
00027
00028 return tuple(new_seq)
00029
00030
00031
00032 def grid_to_rgb_image(grid, fname):
00033 image = Image.new('RGBA', grid.dims)
00034 pixels = image.load()
00035
00036 for index in grid.index_iter():
00037 pixels[index] = int_sequence(grid[index])
00038
00039 image.save(fname)
00040
00041
00042
00043 def rgb_image_to_image_grid_channels(fname):
00044 image = Image.open(fname)
00045 pix = image.load()
00046
00047 grids = (Grid2D(image.size, 0), Grid2D(image.size, 0), Grid2D(image.size, 0))
00048
00049 for index in grids[0].index_iter():
00050 grids[0][index] = pix[index][0] / 255
00051 grids[1][index] = pix[index][1] / 255
00052 grids[2][index] = pix[index][2] / 255
00053
00054 return grids
00055
00056
00057
00058
00059
00060
00061 def channels_to_rgb_grid(grids):
00062 red_grid, green_grid, blue_grid = grids
00063
00064 new_grid = Grid2D(red_grid.dims)
00065
00066 for index in new_grid.index_iter():
00067 new_grid[index] = (red_grid[index], green_grid[index], blue_grid[index], 1)
00068
00069 return new_grid
00070
00071
00072 def rgb_image_to_grid(fname):
00073 image = Image.open(fname)
00074 pix = image.load()
00075
00076 grid = Grid2D(image.size, 0)
00077
00078 for index in grid.index_iter():
00079 grid[index] = float_sequence(pix[index])
00080
00081 return grid
00082
00083
00084
00085
00086
00087 def index_grid_to_rgb_grid(grid, pallet):
00088 new_grid = Grid2D(grid.dims)
00089
00090 for index in new_grid.index_iter():
00091 new_grid[index] = pallet[grid[index]]
00092
00093 return new_grid
00094
00095 def transpose(grid):
00096 w, h = grid.dims
00097 new_grid = Grid2D((h, w))
00098
00099 for index in grid.index_iter():
00100 x, y = index
00101 new_grid[y, x] = grid[index]
00102
00103 return new_grid
00104
00105
00106
00107
00108 def greyscale_grid_to_rgb_grid(grid, color):
00109 red, green, blue, alpha = color
00110
00111 new_grid = Grid2D(grid.dims, None)
00112 for index in grid.index_iter():
00113 value = grid[index]
00114 new_grid[index] = (value * red, value * green, value * blue, alpha)
00115
00116 return new_grid
00117
00118 def rgb_grid_to_greyscale_grid(grid):
00119 new_grid = Grid2D(grid.dims, None)
00120
00121 for index in grid.index_iter():
00122 red, green, blue, alpha = grid[index]
00123 new_grid[index] = (red + green + blue) / 3
00124
00125 return new_grid
00126
00127
00128 def edge(grid):
00129 new_grid = Grid2D(grid.dims, (0, 0, 0, 1))
00130
00131 for i in range(1, grid.dims[0]):
00132 for j in range(1, grid.dims[1]):
00133 red, green, blue, alpha = grid[i, j]
00134 red1, green1, blue1, alpha1 = grid[i - 1, j]
00135 red2, green2, blue2, alpha2 = grid[i, j - 1]
00136 red3, green3, blue3, alpha3 = grid[i - 1, j - 1]
00137 redd = abs(red - red1) + abs(red - red2) + abs(red - red3)
00138 greend = abs(green - green1) + abs(green - green2) + abs(green - green3)
00139 blued = abs(blue - blue1) + abs(blue - blue2) + abs(blue - blue3)
00140
00141 avr = (redd + greend + blued)
00142
00143 new_grid[i, j] = (avr, avr, avr, 1)
00144
00145
00146 return new_grid
00147
00148
00149
00150
00151 def normalize(grid):
00152 max_lum = max(grid[0, 0])
00153 min_lum = min(grid[0, 0])
00154
00155 for cell in grid.cell_iter():
00156 red, green, blue, alpha = cell
00157 max_lum = max(red, green, blue, max_lum)
00158 min_lum = min(red, green, blue, min_lum)
00159
00160 if max_lum == min_lum:
00161 multiplier = 1
00162 min_lum = 0
00163 max_lum = 0
00164 else:
00165 multiplier = 1 / (max_lum - min_lum)
00166
00167 new_grid = Grid2D(grid.dims)
00168
00169 for index in grid.index_iter():
00170 red, green, blue, alpha = grid[index]
00171 red = (red - min_lum) * multiplier
00172 green = (green - min_lum) * multiplier
00173 blue = (blue - min_lum) * multiplier
00174
00175 new_grid[index] = (red, green, blue, alpha)
00176
00177 return new_grid
00178
00179
00180 def normalize_grey(grid):
00181 max_lum = grid[0, 0]
00182 min_lum = grid[0, 0]
00183
00184 for cell in grid.cell_iter():
00185 max_lum = max(cell, max_lum)
00186 min_lum = min(cell, min_lum)
00187
00188 if max_lum == min_lum:
00189 multiplier = 1
00190 min_lum = 0
00191 max_lum = 0
00192 else:
00193 multiplier = 1 / (max_lum - min_lum)
00194
00195 new_grid = Grid2D(grid.dims)
00196
00197 for index in grid.index_iter():
00198 new_grid[index] = (grid[index] - min_lum) * multiplier
00199
00200 return new_grid
00201
00202
00203 def saturate(grid):
00204 new_grid = Grid2D(grid.dims)
00205
00206 for index in grid.index_iter():
00207 new_grid[index] = max(min(grid[index], 1), 0)
00208
00209 return new_grid
00210
00211 def threshold(grid, value):
00212 new_grid = Grid2D(grid.dims)
00213
00214 for index in grid.index_iter():
00215 new_grid[index] = 1 if grid[index] >= value else 0
00216
00217 return new_grid
00218
00219
00220 def multiply_grid(grid, factor):
00221 new_grid = Grid2D(grid.dims)
00222
00223 for index in grid.index_iter():
00224 new_grid[index] = grid[index] * factor
00225
00226 return new_grid
00227
00228
00229 def add_grid(grid, summand):
00230 new_grid = Grid2D(grid.dims)
00231
00232 for index in grid.index_iter():
00233 new_grid[index] = grid[index] + summand
00234
00235 return new_grid
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245 def entropy(grid, n):
00246 new_grid = Grid2D(grid.dims, (0, 0, 0, 1))
00247
00248 for index in grid.index_iter():
00249 red, green, blue, alpha = grid[index]
00250 red_sum, green_sum, blue_sum = 0, 0, 0
00251
00252 for cell in grid.square_iter(index, n):
00253 red1, green1, blue1, alpha1 = cell
00254 red_sum += abs(red - red1)
00255 green_sum += abs(green - green1)
00256 blue_sum += abs(blue - blue1)
00257
00258 new_grid[index] = (red_sum, green_sum, blue_sum, alpha)
00259
00260 return new_grid
00261
00262
00263
00264
00265
00266
00267
00268
00269 def white_noise(dims, period=1):
00270 grid = Grid2D(dims)
00271 width, height = dims
00272
00273 for i in range(0, width, period):
00274 for j in range(0, height, period):
00275 r = random()
00276
00277 for index in grid.window_index_iter((i, j), (i + period, j+period)):
00278 grid[index] = r
00279
00280 return grid
00281
00282
00283
00284
00285
00286 def mix_grey(col1, col2, t):
00287 return col1 * (1 - t) + col2 * t
00288
00289
00290
00291
00292
00293 def mix_color(color0, color1, t):
00294 new_color = []
00295
00296 for channel0, channel1 in zip(color0, color1):
00297 new_color.append(channel0 * (1 - t) + channel1 * t)
00298
00299 return new_color
00300
00301
00302
00303 def tile(grid, m, n):
00304 width, height = grid.dims
00305 dims = width * m, height * n
00306
00307 new_grid = Grid2D(dims)
00308
00309 for index in new_grid.index_iter():
00310 x, y, = index
00311 new_grid[index] = grid[x % width, y % height]
00312
00313 return new_grid
00314
00315
00316 def add_grey_grids(grids, factors = None):
00317 new_grid = Grid2D(grids[0].dims, 0)
00318
00319 if factors == None:
00320 factors = [1] * len(grids)
00321
00322 for grid, factor in zip(grids, factors):
00323 for index in grid.index_iter():
00324 new_grid[index] += grid[index] * factor
00325
00326 return new_grid
00327
00328
00329 def integrate(grid):
00330 new_grid = Grid2D(grid.dims, 0)
00331
00332 new_grid[0, 0] = grid[0, 0]
00333
00334 for i in xrange(1, grid.width):
00335 new_grid[i, 0] = new_grid[i-1, 0] + grid[i, 0]
00336
00337 for j in xrange(1, grid.height):
00338 new_grid[0, j] = new_grid[i, j-1] + grid[0, j]
00339
00340 for i in xrange(1, grid.width):
00341 for j in xrange(1, grid.height):
00342 new_grid[i, j] = new_grid[i-1, j] + new_grid[i, j-1] - new_grid[i-1, j-1] + grid[i, j]
00343
00344 return new_grid
00345
00346 def integrate_vertically(grid):
00347 w, h = grid.dims
00348 new_grid = Grid2D((w, h), 0)
00349
00350 for i in range(w):
00351 new_grid[i, 0] = grid[i, 0]
00352
00353 for i in range(w):
00354 for j in range(1, h):
00355 new_grid[i, j] = grid[i, j] + new_grid[i, j - 1]
00356
00357 return new_grid
00358
00359 def blend(grid1, grid2, blend_image):
00360 dims = blend_image.dims
00361
00362 grid = Grid2D(dims)
00363
00364 for index in grid.index_iter():
00365 grid[index] = mix_color(grid1[index], grid2[index], blend_image[index])
00366
00367 return grid
00368
00369