Quelques adaptations pour que ça compile avec Py2Exe.
[minwii.git] / src / minwii / gradients.py
1 #Copyright 2006 DR0ID <dr0id@bluewin.ch> http://mypage.bluewin.ch/DR0ID
2 #
3 #
4 #
5 """
6 Allow to draw some gradients relatively easy.
7 """
8
9 __author__ = "$Author: DR0ID $"
10 __version__= "$Revision: 109 $"
11 __date__ = "$Date: 2007-08-09 20:33:32 +0200 (Do, 09 Aug 2007) $"
12
13 import pygame
14 import math
15
16 BLEND_MODES_AVAILABLE = False
17 vernum = pygame.vernum
18 if vernum[0]>=1 and vernum[1]>=8:
19 BLEND_MODES_AVAILABLE = True
20
21
22 class ColorInterpolator(object):
23 '''
24 ColorInterpolator(distance, color1, color2, rfunc, gfunc, bfunc, afunc)
25
26 interpolates a color over the distance using different functions for r,g,b,a
27 separately (a= alpha).
28 '''
29 def __init__(self, distance, color1, color2, rfunc, gfunc, bfunc, afunc):
30 object.__init__(self)
31
32 self.rInterpolator = FunctionInterpolator(color1[0], color2[0], distance, rfunc)
33 self.gInterpolator = FunctionInterpolator(color1[1], color2[1], distance, gfunc)
34 self.bInterpolator = FunctionInterpolator(color1[2], color2[2], distance, bfunc)
35 if len(color1)==4 and len(color2)==4:
36 self.aInterpolator = FunctionInterpolator(color1[3], color2[3], distance, afunc)
37 else:
38 self.aInterpolator = FunctionInterpolator(255, 255, distance, afunc)
39
40 def eval(self, x):
41 '''
42 eval(x) -> color
43
44 returns the color at the position 0<=x<=d (actually not bound to this interval).
45 '''
46 ## print "colorInterp x", x, self.rInterpolator.eval(x), self.gInterpolator.eval(x), self.bInterpolator.eval(x)
47 return [self.rInterpolator.eval(x),
48 self.gInterpolator.eval(x),
49 self.bInterpolator.eval(x),
50 self.aInterpolator.eval(x)]
51
52
53
54 class FunctionInterpolator(object):
55 '''
56 FunctionINterpolator(startvalue, endvalue, trange, func)
57
58 interpolates a function y=f(x) in the range trange with
59 startvalue = f(0)
60 endvalue = f(trange)
61 using the function func
62 '''
63 def __init__(self, startvalue, endvalue, trange, func):
64 object.__init__(self)
65 # function
66 self.func = func
67 # y-scaling
68 self.a = endvalue-startvalue
69 if self.a == 0:
70 self.a = 1.
71 # x-scaling
72 if trange!=0:
73 self.b = 1./abs(trange)
74 else:
75 self.b = 1.
76 # x-displacement
77 self.c = 0
78 # y-displacement
79 self.d = min(max(startvalue,0),255)
80
81 def eval(self, x):
82 '''
83 eval(x)->float
84
85 return value at position x
86 '''
87 # make sure that the returned value is in [0,255]
88 ## return int(round(min(max(self.a*self.func(self.b*(x+self.c))+self.d, 0), 255)))
89 return int(min(max(self.a*self.func(self.b*(x+self.c))+self.d, 0), 255))
90
91
92
93 ##def gradient(surface,
94 ## startpoint,
95 ## endpoint,
96 ## startcolor,
97 ## endcolor,
98 ## Rfunc = (lambda x:x),
99 ## Gfunc = (lambda x:x),
100 ## Bfunc = (lambda x:x),
101 ## Afunc = (lambda x:1),
102 ## type = "line",
103 ## mode = None ):
104 ## '''
105 ## surface : surface to draw on
106 ## startpoint: (x,y) point on surface
107 ## endpoint : (x,y) point on surface
108 ## startcolor: (r,g,b,a) color at startpoint
109 ## endcolor : (r,g,b,a) color at endpoint
110 ## Rfunc : function y = f(x) with startcolor =f(0) and endcolor = f(1) where 0 is at startpoint and 1 at endpoint
111 ## Gfunc : --- " ---
112 ## Bfunc : --- " ---
113 ## Afunc : --- " ---
114 ## these functions are evaluated in the range 0 <= x <= 1 and 0<= y=f(x) <= 1
115 ## type : "line", "circle" or "rect"
116 ## mode : "+", "-", "*", None (how the pixels are drawen)
117 ##
118 ## returns : surface with the color characteristics w,h = (d, 256) and d = length of endpoint-startpoint
119 ##
120 ## '''
121 ## dx = endpoint[0]-startpoint[0]
122 ## dy = endpoint[1]-startpoint[1]
123 ## d = int(round(math.hypot(dx, dy)))
124 ## angle = math.degrees( math.atan2(dy, dx) )
125 ##
126 ## color = ColorInterpolator(d, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc)
127 ##
128 ## if type=="line":
129 ## h = int(2.*math.hypot(*surface.get_size()))
130 ### bigSurf = pygame.Surface((d, h)).convert_alpha()
131 ## bigSurf = pygame.Surface((d, h), pygame.SRCALPHA)#.convert_alpha()
132 ### bigSurf = pygame.Surface((d, 1), pygame.SRCALPHA)#.convert_alpha()
133 ## bigSurf.lock()
134 ## bigSurf.fill((0,0,0,0))
135 ## bigSurf.set_colorkey((0,0,0,0))
136 ## for x in range(d):
137 ## pygame.draw.line(bigSurf, color.eval(x), (x,0), (x,h), 1)
138 ### for x in range(d):
139 ### bigSurf.set_at((x, 0), color.eval(x))
140 ### bigSurf = pygame.transform.scale(bigSurf, (d, h))
141 ##
142 ## bigSurf = pygame.transform.rotate(bigSurf, -angle) #rotozoom(bigSurf, -angle, 1)
143 ## bigSurf.set_colorkey((0,0,0, 0))
144 ## rect = bigSurf.get_rect()
145 ## srect = pygame.Rect(rect)
146 ## dx = d/2. * math.cos(math.radians(angle))
147 ## dy = d/2. * math.sin(math.radians(angle))
148 ## rect.center = startpoint
149 ## rect.move_ip(dx, dy)
150 ## bigSurf.unlock()
151 ##
152 ## elif type=="circle":
153 ## bigSurf = pygame.Surface((2*d, 2*d)).convert_alpha()
154 ## bigSurf.fill((0,0,0,0))
155 ## bigSurf.lock()
156 ## for x in range(d, 0, -1):
157 ## pygame.draw.circle(bigSurf, color.eval(x), (d,d), x)
158 ## bigSurf.unlock()
159 ## rect = bigSurf.get_rect()
160 ## srect = pygame.Rect(rect)
161 ## rect.center = (startpoint[0], startpoint[1])
162 ##
163 ## elif type=="rect":
164 ## bigSurf = pygame.Surface((2*d, 2*d)).convert_alpha()
165 ## bigSurf.fill((0,0,0,0))
166 ## c = bigSurf.get_rect().center
167 ## bigSurf.lock()
168 ## for x in range(d,-1,-1):
169 ## r = pygame.Rect(0,0,2*x,2*x)
170 ## r.center = c
171 ## pygame.draw.rect(bigSurf, color.eval(x), r)
172 ## bigSurf.unlock()
173 ## bigSurf = pygame.transform.rotozoom(bigSurf, -angle, 1)
174 ## bigSurf.set_colorkey((0,0,0, 0))
175 ##
176 ## rect = bigSurf.get_rect()
177 ## srect = pygame.Rect(rect)
178 ## rect.center = startpoint
179 ## else:
180 ## raise NameError("type must be one of \"line\",\"circle\" or \"rect\"")
181 ##
182 ## if mode is None:
183 ## surface.blit(bigSurf, rect, srect)
184 ## else:
185 ## if mode=="+":
186 ## cf = pygame.color.add
187 ## elif mode=="*":
188 ## cf = pygame.color.multiply
189 ## elif mode=="-":
190 ## cf = pygame.color.subtract
191 ## else:
192 ## raise NameError("type must be one of \"+\", \"*\", \"-\" or None")
193 ## irect = surface.get_clip().clip(rect)
194 ## surface.lock()
195 ## for x in range(irect.left, irect.left+irect.width):
196 ## for y in range(irect.top, irect.top+irect.height):
197 ## surface.set_at((x,y), cf(surface.get_at((x,y)), bigSurf.get_at((x-rect.left, y-rect.top)) ) )
198 ## surface.unlock()
199 ##
200 ## del bigSurf
201 ## char = pygame.Surface((d+1, 257))
202 ### char.fill((0,0,0))
203 ### ox = 0
204 ### oldcol = color.eval(0)
205 ### for x in range(d):
206 ### col = color.eval(x)
207 ### pygame.draw.line(char, (255,0,0), (x, 256-col[0]), (ox, 256-oldcol[0]))
208 ### pygame.draw.line(char, (0,255,0), (x, 256-col[1]), (ox, 256-oldcol[1]))
209 ### pygame.draw.line(char, (0,0,255), (x, 256-col[2]), (ox, 256-oldcol[2]))
210 ### pygame.draw.line(char, (255,255,255), (x, 256-col[3]), (ox, 256-oldcol[3]))
211 ### ox = x
212 ### oldcol = col
213 ###
214 ## return char
215
216
217
218
219 def vertical(size, startcolor, endcolor):
220 """
221 Draws a vertical linear gradient filling the entire surface. Returns a
222 surface filled with the gradient (numeric is only 2-3 times faster).
223 """
224 height = size[1]
225 bigSurf = pygame.Surface((1,height)).convert_alpha()
226 dd = 1.0/height
227 sr, sg, sb, sa = startcolor
228 er, eg, eb, ea = endcolor
229 rm = (er-sr)*dd
230 gm = (eg-sg)*dd
231 bm = (eb-sb)*dd
232 am = (ea-sa)*dd
233 for y in range(height):
234 bigSurf.set_at((0,y),
235 (int(sr + rm*y),
236 int(sg + gm*y),
237 int(sb + bm*y),
238 int(sa + am*y))
239 )
240 return pygame.transform.scale(bigSurf, size)
241
242
243 def horizontal(size, startcolor, endcolor):
244 """
245 Draws a horizontal linear gradient filling the entire surface. Returns a
246 surface filled with the gradient (numeric is only 2-3 times faster).
247 """
248 width = size[0]
249 bigSurf = pygame.Surface((width, 1)).convert_alpha()
250 dd = 1.0/width
251 sr, sg, sb, sa = startcolor
252 er, eg, eb, ea = endcolor
253 rm = (er-sr)*dd
254 gm = (eg-sg)*dd
255 bm = (eb-sb)*dd
256 am = (ea-sa)*dd
257 for y in range(width):
258 bigSurf.set_at((y,0),
259 (int(sr + rm*y),
260 int(sg + gm*y),
261 int(sb + bm*y),
262 int(sa + am*y))
263 )
264 return pygame.transform.scale(bigSurf, size)
265
266
267 def radial(radius, startcolor, endcolor):
268 """
269 Draws a linear raidal gradient on a square sized surface and returns
270 that surface.
271 """
272 bigSurf = pygame.Surface((2*radius, 2*radius)).convert_alpha()
273 bigSurf.fill((0,0,0,0))
274 dd = -1.0/radius
275 sr, sg, sb, sa = endcolor
276 er, eg, eb, ea = startcolor
277 rm = (er-sr)*dd
278 gm = (eg-sg)*dd
279 bm = (eb-sb)*dd
280 am = (ea-sa)*dd
281
282 draw_circle = pygame.draw.circle
283 for rad in range(radius, 0, -1):
284 draw_circle(bigSurf, (er + int(rm*rad),
285 eg + int(gm*rad),
286 eb + int(bm*rad),
287 ea + int(am*rad)), (radius, radius), rad)
288 return bigSurf
289
290 def squared(width, startcolor, endcolor):
291 """
292 Draws a linear sqared gradient on a square sized surface and returns
293 that surface.
294 """
295 bigSurf = pygame.Surface((width, width)).convert_alpha()
296 bigSurf.fill((0,0,0,0))
297 dd = -1.0/(width/2)
298 sr, sg, sb, sa = endcolor
299 er, eg, eb, ea = startcolor
300 rm = (er-sr)*dd
301 gm = (eg-sg)*dd
302 bm = (eb-sb)*dd
303 am = (ea-sa)*dd
304
305 draw_rect = pygame.draw.rect
306 for currentw in range((width/2), 0, -1):
307 pos = (width/2)-currentw
308 draw_rect(bigSurf, (er + int(rm*currentw),
309 eg + int(gm*currentw),
310 eb + int(bm*currentw),
311 ea + int(am*currentw)), pygame.Rect(pos, pos, 2*currentw, 2*currentw ))
312 return bigSurf
313
314
315 def vertical_func(size, startcolor, endcolor, Rfunc = (lambda x:x), Gfunc = (lambda x:x), Bfunc = (lambda x:x), Afunc = (lambda x:1)):
316 """
317 Draws a vertical linear gradient filling the entire surface. Returns a
318 surface filled with the gradient (numeric is only 2x faster).
319 Rfunc, Gfunc, Bfunc and Afunc are function like y = f(x). They define
320 how the color changes.
321 """
322 height = size[1]
323 bigSurf = pygame.Surface((1,height)).convert_alpha()
324 color = ColorInterpolator(height, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc)
325 for y in range(0, height):
326 bigSurf.set_at((0,y), color.eval(y+0.1))
327 return pygame.transform.scale(bigSurf, size)
328
329
330 def horizontal_func(size, startcolor, endcolor, Rfunc = (lambda x:x), Gfunc = (lambda x:x), Bfunc = (lambda x:x), Afunc = (lambda x:1)):
331 """
332 Draws a horizontal linear gradient filling the entire surface. Returns a
333 surface filled with the gradient (numeric is only 2x faster).
334 Rfunc, Gfunc, Bfunc and Afunc are function like y = f(x). They define
335 how the color changes.
336 """
337 width = size[0]
338 bigSurf = pygame.Surface((width, 1)).convert_alpha()
339 color = ColorInterpolator(width, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc)
340 for y in range(0, width):
341 bigSurf.set_at((y, 0), color.eval(y+0.1))
342 return pygame.transform.scale(bigSurf, size)
343
344 def radial_func(radius, startcolor, endcolor, Rfunc = (lambda x:x), Gfunc = (lambda x:x), Bfunc = (lambda x:x), Afunc = (lambda x:1), colorkey=(0,0,0,0)):
345 """
346 Draws a linear raidal gradient on a square sized surface and returns
347 that surface.
348 """
349 bigSurf = pygame.Surface((2*radius, 2*radius)).convert_alpha()
350 if len(colorkey)==3:
351 colorkey += (0,)
352 bigSurf.fill(colorkey)
353 color = ColorInterpolator(radius, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc)
354 draw_circle = pygame.draw.circle
355 for rad in range(radius, 0, -1):
356 draw_circle(bigSurf, color.eval(rad), (radius, radius), rad)
357 return bigSurf
358
359 def radial_func_offset(radius, startcolor, endcolor, Rfunc = (lambda x:x), Gfunc = (lambda x:x), Bfunc = (lambda x:x), Afunc = (lambda x:1), colorkey=(0,0,0,0), offset=(0,0)):
360 """
361 Draws a linear raidal gradient on a square sized surface and returns
362 that surface.
363 offset is the amount the center of the gradient is displaced of the center of the image.
364 Unfotunately this function ignores alpha.
365 """
366 bigSurf = pygame.Surface((2*radius, 2*radius))#.convert_alpha()
367
368 mask = pygame.Surface((2*radius, 2*radius), pygame.SRCALPHA)#.convert_alpha()
369 mask.fill(colorkey)
370 mask.set_colorkey((255,0,255))
371 pygame.draw.circle(mask, (255,0,255), (radius, radius), radius)
372
373 if len(colorkey)==3:
374 colorkey += (0,)
375 bigSurf.fill(colorkey)
376
377 color = ColorInterpolator(radius, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc)
378 draw_circle = pygame.draw.circle
379 radi = radius + int(math.hypot(offset[0], offset[1])+1)
380 for rad in range(radi, 0, -1):
381 draw_circle(bigSurf, color.eval(rad), (radius+offset[0], radius+offset[1]), rad)
382
383 bigSurf.blit(mask, (0,0))
384 bigSurf.set_colorkey(colorkey)
385 return bigSurf
386
387
388 def squared_func(width, startcolor, endcolor, Rfunc = (lambda x:x), Gfunc = (lambda x:x), Bfunc = (lambda x:x), Afunc = (lambda x:1), offset=(0,0)):
389 """
390 Draws a linear sqared gradient on a square sized surface and returns
391 that surface.
392 """
393 bigSurf = pygame.Surface((width, width)).convert_alpha()
394 bigSurf.fill((0,0,0,0))
395 color = ColorInterpolator(width/2, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc)
396 draw_rect = pygame.draw.rect
397 widthh = width+2*int(max(abs(offset[0]),abs(offset[1])))
398 for currentw in range((widthh/2), 0, -1):
399 ## pos = (width/2)-currentw
400 rect = pygame.Rect(0, 0, 2*currentw, 2*currentw )
401 rect.center = (width/2+offset[0], width/2+offset[1])
402 draw_rect(bigSurf, color.eval(currentw), rect)
403 return bigSurf
404
405 def draw_gradient(surface, startpoint, endpoint, startcolor, endcolor, Rfunc = (lambda x:x), Gfunc = (lambda x:x), Bfunc = (lambda x:x), Afunc = (lambda x:1), mode=0):
406 """
407 Instead of returning an Surface, this function draw it directy onto the
408 given Surface and returns the rect.
409 """
410 dx = endpoint[0]-startpoint[0]
411 dy = endpoint[1]-startpoint[1]
412 d = int(round(math.hypot(dx, dy)))
413 angle = math.degrees( math.atan2(dy, dx) )
414
415 h = int(2.*math.hypot(*surface.get_size()))
416
417 bigSurf = horizontal_func((d,h), startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc)
418
419 ## bigSurf = pygame.transform.rotate(bigSurf, -angle) #rotozoom(bigSurf, -angle, 1)
420 bigSurf = pygame.transform.rotozoom(bigSurf, -angle, 1)
421 ## bigSurf.set_colorkey((0,0,0, 0))
422 rect = bigSurf.get_rect()
423 srect = pygame.Rect(rect)
424 dx = d/2. * math.cos(math.radians(angle))
425 dy = d/2. * math.sin(math.radians(angle))
426 rect.center = startpoint
427 rect.move_ip(dx, dy)
428 if BLEND_MODES_AVAILABLE:
429 return surface.blit(bigSurf, rect, None, mode)
430 else:
431 return surface.blit(bigSurf, rect)
432
433
434 def draw_circle(surface, startpoint, endpoint, startcolor, endcolor, Rfunc = (lambda x:x), Gfunc = (lambda x:x), Bfunc = (lambda x:x), Afunc = (lambda x:1), mode=0):
435 """
436 Instead of returning an Surface, this function draw it directy onto the
437 given Surface and returns the rect.
438 """
439 dx = endpoint[0]-startpoint[0]
440 dy = endpoint[1]-startpoint[1]
441 radius = int(round(math.hypot(dx, dy)))
442 pos = (startpoint[0]-radius, startpoint[1]-radius)
443 if BLEND_MODES_AVAILABLE:
444 return surface.blit(radial_func(radius, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc), pos, None, mode)
445 else:
446 return surface.blit(radial_func(radius, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc), pos)
447
448 def draw_squared(surface, startpoint, endpoint, startcolor, endcolor, Rfunc = (lambda x:x), Gfunc = (lambda x:x), Bfunc = (lambda x:x), Afunc = (lambda x:1), mode=0):
449 """
450 Instead of returning an Surface, this function draw it directy onto the
451 given Surface and returns the rect.
452 """
453 dx = endpoint[0]-startpoint[0]
454 dy = endpoint[1]-startpoint[1]
455 angle = math.degrees( math.atan2(dy, dx) )
456 width = 2*int(round(math.hypot(dx, dy)))
457
458 bigSurf = squared_func(width, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc)
459
460 bigSurf = pygame.transform.rotozoom(bigSurf, -angle, 1)
461 ## bigSurf.set_colorkey((0,0,0, 0))
462 rect = bigSurf.get_rect()
463 rect.center = startpoint
464 if BLEND_MODES_AVAILABLE:
465 return surface.blit(bigSurf, rect, None, mode)
466 else:
467 return surface.blit(bigSurf, rect)
468
469
470 def chart(startpoint, endpoint, startcolor, endcolor, Rfunc = (lambda x:x), Gfunc = (lambda x:x), Bfunc = (lambda x:x), Afunc = (lambda x:1), scale=None):
471 """
472 This returns a Surface where the change of the colors over the distance
473 (the width of the image) is showen as a line.
474 scale: a float, 1 is not scaling
475 """
476 dx = endpoint[0]-startpoint[0]
477 dy = endpoint[1]-startpoint[1]
478 distance = int(round(math.hypot(dx, dy)))
479 color = ColorInterpolator(distance, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc)
480 bigSurf = pygame.Surface((distance, 256))
481 bigSurf.fill((0,)*3)
482 oldcol = color.eval(0)
483 for x in range(distance):
484 r, g, b, a = color.eval(x)
485 pygame.draw.line(bigSurf, (255, 0, 0, 128), (x-1, oldcol[0]), (x, r))
486 pygame.draw.line(bigSurf, (0, 255, 0, 128), (x-1, oldcol[1]), (x, g))
487 pygame.draw.line(bigSurf, (0, 0, 255, 128), (x-1, oldcol[2]), (x, b))
488 pygame.draw.line(bigSurf, (255, 255, 255, 128), (x-1, oldcol[3]), (x, a))
489 oldcol = (r,g,b,a)
490 if scale:
491 ## return pygame.transform.scale(bigSurf, size)
492 return pygame.transform.rotozoom(bigSurf, 0, scale)
493 return pygame.transform.flip(bigSurf, 0, 1)
494 #------------------------------------------------------------------------------
495
496
497
498
499 def genericFxyGradient(surf, clip, color1, color2, func, intx, yint, zint=None):
500 """
501 genericFxyGradient(size, color1, color2,func, intx, yint, zint=None)
502
503 some sort of highfield drawer :-)
504
505 surf : surface to draw
506 clip : rect on surf to draw in
507 color1 : start color
508 color2 : end color
509 func : function z = func(x,y)
510 xint : interval in x direction where the function is evaluated
511 yint : interval in y direction where the function is evaluated
512 zint : if not none same as yint or xint, if None then the max and min value
513 of func is taken as z-interval
514
515 color = a*func(b*(x+c), d*(y+e))+f
516 """
517 # make shure that x1<x2 and y1<y2 and z1<z2
518 w,h = clip.size
519 x1 = min(intx)
520 x2 = max(intx)
521 y1 = min(yint)
522 y2 = max(yint)
523 if zint: # if user give us z intervall, then use it
524 z1 = min(zint)
525 z2 = max(zint)
526 else: # look for extrema of function (not best algorithme)
527 z1 = func(x1,y1)
528 z2 = z1
529 for i in range(w):
530 for j in range(h):
531 r = func(i,j)
532 z1 = min(z1, r)
533 z2 = max(z2, r)
534
535 x1 = float(x1)
536 x2 = float(x2)
537 y1 = float(y1)
538 y2 = float(y2)
539 z1 = float(z1)
540 z2 = float(z2)
541 if len(color1)==3:
542 color1 = list(color1)
543 color1.append(255)
544 if len(color2)==3:
545 color2 = list(color2)
546 color2.append(255)
547
548 # calculate streching and displacement variables
549 a = ((color2[0]-color1[0])/(z2-z1), \
550 (color2[1]-color1[1])/(z2-z1), \
551 (color2[2]-color1[2])/(z2-z1), \
552 (color2[3]-color1[3])/(z2-z1) ) # streching in z direction
553 b = (x2-x1)/float(w) # streching in x direction
554 d = (y2-y1)/float(h) # streching in y direction
555 f = ( color1[0]-a[0]*z1, \
556 color1[1]-a[1]*z1, \
557 color1[2]-a[2]*z1, \
558 color1[3]-a[3]*z1 )# z displacement
559 c = x1/b
560 e = y1/d
561
562 surff = pygame.surface.Surface((w,h)).convert_alpha()
563 # generate values
564 for i in range(h):
565 for j in range(w):
566 val = func(b*(j+c), d*(i+e))
567 #clip color
568 color = ( max(min(a[0]*val+f[0],255),0), \
569 max(min(a[1]*val+f[1],255),0), \
570 max(min(a[2]*val+f[2],255),0), \
571 max(min(a[3]*val+f[3],255),0) )
572 surff.set_at( (j,i), color )
573 surf.blit(surff, clip)
574
575
576