+#Copyright 2006 DR0ID <dr0id@bluewin.ch> http://mypage.bluewin.ch/DR0ID
+#
+#
+#
+"""
+Allow to draw some gradients relatively easy.
+"""
+
+__author__ = "$Author: DR0ID $"
+__version__= "$Revision: 109 $"
+__date__ = "$Date: 2007-08-09 20:33:32 +0200 (Do, 09 Aug 2007) $"
+
+import pygame
+import math
+
+BLEND_MODES_AVAILABLE = False
+vernum = pygame.vernum
+if vernum[0]>=1 and vernum[1]>=8:
+ BLEND_MODES_AVAILABLE = True
+
+
+class ColorInterpolator(object):
+ '''
+ ColorInterpolator(distance, color1, color2, rfunc, gfunc, bfunc, afunc)
+
+ interpolates a color over the distance using different functions for r,g,b,a
+ separately (a= alpha).
+ '''
+ def __init__(self, distance, color1, color2, rfunc, gfunc, bfunc, afunc):
+ object.__init__(self)
+
+ self.rInterpolator = FunctionInterpolator(color1[0], color2[0], distance, rfunc)
+ self.gInterpolator = FunctionInterpolator(color1[1], color2[1], distance, gfunc)
+ self.bInterpolator = FunctionInterpolator(color1[2], color2[2], distance, bfunc)
+ if len(color1)==4 and len(color2)==4:
+ self.aInterpolator = FunctionInterpolator(color1[3], color2[3], distance, afunc)
+ else:
+ self.aInterpolator = FunctionInterpolator(255, 255, distance, afunc)
+
+ def eval(self, x):
+ '''
+ eval(x) -> color
+
+ returns the color at the position 0<=x<=d (actually not bound to this interval).
+ '''
+## print "colorInterp x", x, self.rInterpolator.eval(x), self.gInterpolator.eval(x), self.bInterpolator.eval(x)
+ return [self.rInterpolator.eval(x),
+ self.gInterpolator.eval(x),
+ self.bInterpolator.eval(x),
+ self.aInterpolator.eval(x)]
+
+
+
+class FunctionInterpolator(object):
+ '''
+ FunctionINterpolator(startvalue, endvalue, trange, func)
+
+ interpolates a function y=f(x) in the range trange with
+ startvalue = f(0)
+ endvalue = f(trange)
+ using the function func
+ '''
+ def __init__(self, startvalue, endvalue, trange, func):
+ object.__init__(self)
+ # function
+ self.func = func
+ # y-scaling
+ self.a = endvalue-startvalue
+ if self.a == 0:
+ self.a = 1.
+ # x-scaling
+ if trange!=0:
+ self.b = 1./abs(trange)
+ else:
+ self.b = 1.
+ # x-displacement
+ self.c = 0
+ # y-displacement
+ self.d = min(max(startvalue,0),255)
+
+ def eval(self, x):
+ '''
+ eval(x)->float
+
+ return value at position x
+ '''
+ # make sure that the returned value is in [0,255]
+## return int(round(min(max(self.a*self.func(self.b*(x+self.c))+self.d, 0), 255)))
+ return int(min(max(self.a*self.func(self.b*(x+self.c))+self.d, 0), 255))
+
+
+
+##def gradient(surface,
+## startpoint,
+## endpoint,
+## startcolor,
+## endcolor,
+## Rfunc = (lambda x:x),
+## Gfunc = (lambda x:x),
+## Bfunc = (lambda x:x),
+## Afunc = (lambda x:1),
+## type = "line",
+## mode = None ):
+## '''
+## surface : surface to draw on
+## startpoint: (x,y) point on surface
+## endpoint : (x,y) point on surface
+## startcolor: (r,g,b,a) color at startpoint
+## endcolor : (r,g,b,a) color at endpoint
+## Rfunc : function y = f(x) with startcolor =f(0) and endcolor = f(1) where 0 is at startpoint and 1 at endpoint
+## Gfunc : --- " ---
+## Bfunc : --- " ---
+## Afunc : --- " ---
+## these functions are evaluated in the range 0 <= x <= 1 and 0<= y=f(x) <= 1
+## type : "line", "circle" or "rect"
+## mode : "+", "-", "*", None (how the pixels are drawen)
+##
+## returns : surface with the color characteristics w,h = (d, 256) and d = length of endpoint-startpoint
+##
+## '''
+## dx = endpoint[0]-startpoint[0]
+## dy = endpoint[1]-startpoint[1]
+## d = int(round(math.hypot(dx, dy)))
+## angle = math.degrees( math.atan2(dy, dx) )
+##
+## color = ColorInterpolator(d, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc)
+##
+## if type=="line":
+## h = int(2.*math.hypot(*surface.get_size()))
+### bigSurf = pygame.Surface((d, h)).convert_alpha()
+## bigSurf = pygame.Surface((d, h), pygame.SRCALPHA)#.convert_alpha()
+### bigSurf = pygame.Surface((d, 1), pygame.SRCALPHA)#.convert_alpha()
+## bigSurf.lock()
+## bigSurf.fill((0,0,0,0))
+## bigSurf.set_colorkey((0,0,0,0))
+## for x in range(d):
+## pygame.draw.line(bigSurf, color.eval(x), (x,0), (x,h), 1)
+### for x in range(d):
+### bigSurf.set_at((x, 0), color.eval(x))
+### bigSurf = pygame.transform.scale(bigSurf, (d, h))
+##
+## bigSurf = pygame.transform.rotate(bigSurf, -angle) #rotozoom(bigSurf, -angle, 1)
+## bigSurf.set_colorkey((0,0,0, 0))
+## rect = bigSurf.get_rect()
+## srect = pygame.Rect(rect)
+## dx = d/2. * math.cos(math.radians(angle))
+## dy = d/2. * math.sin(math.radians(angle))
+## rect.center = startpoint
+## rect.move_ip(dx, dy)
+## bigSurf.unlock()
+##
+## elif type=="circle":
+## bigSurf = pygame.Surface((2*d, 2*d)).convert_alpha()
+## bigSurf.fill((0,0,0,0))
+## bigSurf.lock()
+## for x in range(d, 0, -1):
+## pygame.draw.circle(bigSurf, color.eval(x), (d,d), x)
+## bigSurf.unlock()
+## rect = bigSurf.get_rect()
+## srect = pygame.Rect(rect)
+## rect.center = (startpoint[0], startpoint[1])
+##
+## elif type=="rect":
+## bigSurf = pygame.Surface((2*d, 2*d)).convert_alpha()
+## bigSurf.fill((0,0,0,0))
+## c = bigSurf.get_rect().center
+## bigSurf.lock()
+## for x in range(d,-1,-1):
+## r = pygame.Rect(0,0,2*x,2*x)
+## r.center = c
+## pygame.draw.rect(bigSurf, color.eval(x), r)
+## bigSurf.unlock()
+## bigSurf = pygame.transform.rotozoom(bigSurf, -angle, 1)
+## bigSurf.set_colorkey((0,0,0, 0))
+##
+## rect = bigSurf.get_rect()
+## srect = pygame.Rect(rect)
+## rect.center = startpoint
+## else:
+## raise NameError("type must be one of \"line\",\"circle\" or \"rect\"")
+##
+## if mode is None:
+## surface.blit(bigSurf, rect, srect)
+## else:
+## if mode=="+":
+## cf = pygame.color.add
+## elif mode=="*":
+## cf = pygame.color.multiply
+## elif mode=="-":
+## cf = pygame.color.subtract
+## else:
+## raise NameError("type must be one of \"+\", \"*\", \"-\" or None")
+## irect = surface.get_clip().clip(rect)
+## surface.lock()
+## for x in range(irect.left, irect.left+irect.width):
+## for y in range(irect.top, irect.top+irect.height):
+## surface.set_at((x,y), cf(surface.get_at((x,y)), bigSurf.get_at((x-rect.left, y-rect.top)) ) )
+## surface.unlock()
+##
+## del bigSurf
+## char = pygame.Surface((d+1, 257))
+### char.fill((0,0,0))
+### ox = 0
+### oldcol = color.eval(0)
+### for x in range(d):
+### col = color.eval(x)
+### pygame.draw.line(char, (255,0,0), (x, 256-col[0]), (ox, 256-oldcol[0]))
+### pygame.draw.line(char, (0,255,0), (x, 256-col[1]), (ox, 256-oldcol[1]))
+### pygame.draw.line(char, (0,0,255), (x, 256-col[2]), (ox, 256-oldcol[2]))
+### pygame.draw.line(char, (255,255,255), (x, 256-col[3]), (ox, 256-oldcol[3]))
+### ox = x
+### oldcol = col
+###
+## return char
+
+
+
+
+def vertical(size, startcolor, endcolor):
+ """
+ Draws a vertical linear gradient filling the entire surface. Returns a
+ surface filled with the gradient (numeric is only 2-3 times faster).
+ """
+ height = size[1]
+ bigSurf = pygame.Surface((1,height)).convert_alpha()
+ dd = 1.0/height
+ sr, sg, sb, sa = startcolor
+ er, eg, eb, ea = endcolor
+ rm = (er-sr)*dd
+ gm = (eg-sg)*dd
+ bm = (eb-sb)*dd
+ am = (ea-sa)*dd
+ for y in range(height):
+ bigSurf.set_at((0,y),
+ (int(sr + rm*y),
+ int(sg + gm*y),
+ int(sb + bm*y),
+ int(sa + am*y))
+ )
+ return pygame.transform.scale(bigSurf, size)
+
+
+def horizontal(size, startcolor, endcolor):
+ """
+ Draws a horizontal linear gradient filling the entire surface. Returns a
+ surface filled with the gradient (numeric is only 2-3 times faster).
+ """
+ width = size[0]
+ bigSurf = pygame.Surface((width, 1)).convert_alpha()
+ dd = 1.0/width
+ sr, sg, sb, sa = startcolor
+ er, eg, eb, ea = endcolor
+ rm = (er-sr)*dd
+ gm = (eg-sg)*dd
+ bm = (eb-sb)*dd
+ am = (ea-sa)*dd
+ for y in range(width):
+ bigSurf.set_at((y,0),
+ (int(sr + rm*y),
+ int(sg + gm*y),
+ int(sb + bm*y),
+ int(sa + am*y))
+ )
+ return pygame.transform.scale(bigSurf, size)
+
+
+def radial(radius, startcolor, endcolor):
+ """
+ Draws a linear raidal gradient on a square sized surface and returns
+ that surface.
+ """
+ bigSurf = pygame.Surface((2*radius, 2*radius)).convert_alpha()
+ bigSurf.fill((0,0,0,0))
+ dd = -1.0/radius
+ sr, sg, sb, sa = endcolor
+ er, eg, eb, ea = startcolor
+ rm = (er-sr)*dd
+ gm = (eg-sg)*dd
+ bm = (eb-sb)*dd
+ am = (ea-sa)*dd
+
+ draw_circle = pygame.draw.circle
+ for rad in range(radius, 0, -1):
+ draw_circle(bigSurf, (er + int(rm*rad),
+ eg + int(gm*rad),
+ eb + int(bm*rad),
+ ea + int(am*rad)), (radius, radius), rad)
+ return bigSurf
+
+def squared(width, startcolor, endcolor):
+ """
+ Draws a linear sqared gradient on a square sized surface and returns
+ that surface.
+ """
+ bigSurf = pygame.Surface((width, width)).convert_alpha()
+ bigSurf.fill((0,0,0,0))
+ dd = -1.0/(width/2)
+ sr, sg, sb, sa = endcolor
+ er, eg, eb, ea = startcolor
+ rm = (er-sr)*dd
+ gm = (eg-sg)*dd
+ bm = (eb-sb)*dd
+ am = (ea-sa)*dd
+
+ draw_rect = pygame.draw.rect
+ for currentw in range((width/2), 0, -1):
+ pos = (width/2)-currentw
+ draw_rect(bigSurf, (er + int(rm*currentw),
+ eg + int(gm*currentw),
+ eb + int(bm*currentw),
+ ea + int(am*currentw)), pygame.Rect(pos, pos, 2*currentw, 2*currentw ))
+ return bigSurf
+
+
+def vertical_func(size, startcolor, endcolor, Rfunc = (lambda x:x), Gfunc = (lambda x:x), Bfunc = (lambda x:x), Afunc = (lambda x:1)):
+ """
+ Draws a vertical linear gradient filling the entire surface. Returns a
+ surface filled with the gradient (numeric is only 2x faster).
+ Rfunc, Gfunc, Bfunc and Afunc are function like y = f(x). They define
+ how the color changes.
+ """
+ height = size[1]
+ bigSurf = pygame.Surface((1,height)).convert_alpha()
+ color = ColorInterpolator(height, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc)
+ for y in range(0, height):
+ bigSurf.set_at((0,y), color.eval(y+0.1))
+ return pygame.transform.scale(bigSurf, size)
+
+
+def horizontal_func(size, startcolor, endcolor, Rfunc = (lambda x:x), Gfunc = (lambda x:x), Bfunc = (lambda x:x), Afunc = (lambda x:1)):
+ """
+ Draws a horizontal linear gradient filling the entire surface. Returns a
+ surface filled with the gradient (numeric is only 2x faster).
+ Rfunc, Gfunc, Bfunc and Afunc are function like y = f(x). They define
+ how the color changes.
+ """
+ width = size[0]
+ bigSurf = pygame.Surface((width, 1)).convert_alpha()
+ color = ColorInterpolator(width, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc)
+ for y in range(0, width):
+ bigSurf.set_at((y, 0), color.eval(y+0.1))
+ return pygame.transform.scale(bigSurf, size)
+
+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)):
+ """
+ Draws a linear raidal gradient on a square sized surface and returns
+ that surface.
+ """
+ bigSurf = pygame.Surface((2*radius, 2*radius)).convert_alpha()
+ if len(colorkey)==3:
+ colorkey += (0,)
+ bigSurf.fill(colorkey)
+ color = ColorInterpolator(radius, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc)
+ draw_circle = pygame.draw.circle
+ for rad in range(radius, 0, -1):
+ draw_circle(bigSurf, color.eval(rad), (radius, radius), rad)
+ return bigSurf
+
+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)):
+ """
+ Draws a linear raidal gradient on a square sized surface and returns
+ that surface.
+ offset is the amount the center of the gradient is displaced of the center of the image.
+ Unfotunately this function ignores alpha.
+ """
+ bigSurf = pygame.Surface((2*radius, 2*radius))#.convert_alpha()
+
+ mask = pygame.Surface((2*radius, 2*radius), pygame.SRCALPHA)#.convert_alpha()
+ mask.fill(colorkey)
+ mask.set_colorkey((255,0,255))
+ pygame.draw.circle(mask, (255,0,255), (radius, radius), radius)
+
+ if len(colorkey)==3:
+ colorkey += (0,)
+ bigSurf.fill(colorkey)
+
+ color = ColorInterpolator(radius, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc)
+ draw_circle = pygame.draw.circle
+ radi = radius + int(math.hypot(offset[0], offset[1])+1)
+ for rad in range(radi, 0, -1):
+ draw_circle(bigSurf, color.eval(rad), (radius+offset[0], radius+offset[1]), rad)
+
+ bigSurf.blit(mask, (0,0))
+ bigSurf.set_colorkey(colorkey)
+ return bigSurf
+
+
+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)):
+ """
+ Draws a linear sqared gradient on a square sized surface and returns
+ that surface.
+ """
+ bigSurf = pygame.Surface((width, width)).convert_alpha()
+ bigSurf.fill((0,0,0,0))
+ color = ColorInterpolator(width/2, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc)
+ draw_rect = pygame.draw.rect
+ widthh = width+2*int(max(abs(offset[0]),abs(offset[1])))
+ for currentw in range((widthh/2), 0, -1):
+## pos = (width/2)-currentw
+ rect = pygame.Rect(0, 0, 2*currentw, 2*currentw )
+ rect.center = (width/2+offset[0], width/2+offset[1])
+ draw_rect(bigSurf, color.eval(currentw), rect)
+ return bigSurf
+
+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):
+ """
+ Instead of returning an Surface, this function draw it directy onto the
+ given Surface and returns the rect.
+ """
+ dx = endpoint[0]-startpoint[0]
+ dy = endpoint[1]-startpoint[1]
+ d = int(round(math.hypot(dx, dy)))
+ angle = math.degrees( math.atan2(dy, dx) )
+
+ h = int(2.*math.hypot(*surface.get_size()))
+
+ bigSurf = horizontal_func((d,h), startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc)
+
+## bigSurf = pygame.transform.rotate(bigSurf, -angle) #rotozoom(bigSurf, -angle, 1)
+ bigSurf = pygame.transform.rotozoom(bigSurf, -angle, 1)
+## bigSurf.set_colorkey((0,0,0, 0))
+ rect = bigSurf.get_rect()
+ srect = pygame.Rect(rect)
+ dx = d/2. * math.cos(math.radians(angle))
+ dy = d/2. * math.sin(math.radians(angle))
+ rect.center = startpoint
+ rect.move_ip(dx, dy)
+ if BLEND_MODES_AVAILABLE:
+ return surface.blit(bigSurf, rect, None, mode)
+ else:
+ return surface.blit(bigSurf, rect)
+
+
+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):
+ """
+ Instead of returning an Surface, this function draw it directy onto the
+ given Surface and returns the rect.
+ """
+ dx = endpoint[0]-startpoint[0]
+ dy = endpoint[1]-startpoint[1]
+ radius = int(round(math.hypot(dx, dy)))
+ pos = (startpoint[0]-radius, startpoint[1]-radius)
+ if BLEND_MODES_AVAILABLE:
+ return surface.blit(radial_func(radius, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc), pos, None, mode)
+ else:
+ return surface.blit(radial_func(radius, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc), pos)
+
+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):
+ """
+ Instead of returning an Surface, this function draw it directy onto the
+ given Surface and returns the rect.
+ """
+ dx = endpoint[0]-startpoint[0]
+ dy = endpoint[1]-startpoint[1]
+ angle = math.degrees( math.atan2(dy, dx) )
+ width = 2*int(round(math.hypot(dx, dy)))
+
+ bigSurf = squared_func(width, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc)
+
+ bigSurf = pygame.transform.rotozoom(bigSurf, -angle, 1)
+## bigSurf.set_colorkey((0,0,0, 0))
+ rect = bigSurf.get_rect()
+ rect.center = startpoint
+ if BLEND_MODES_AVAILABLE:
+ return surface.blit(bigSurf, rect, None, mode)
+ else:
+ return surface.blit(bigSurf, rect)
+
+
+def chart(startpoint, endpoint, startcolor, endcolor, Rfunc = (lambda x:x), Gfunc = (lambda x:x), Bfunc = (lambda x:x), Afunc = (lambda x:1), scale=None):
+ """
+ This returns a Surface where the change of the colors over the distance
+ (the width of the image) is showen as a line.
+ scale: a float, 1 is not scaling
+ """
+ dx = endpoint[0]-startpoint[0]
+ dy = endpoint[1]-startpoint[1]
+ distance = int(round(math.hypot(dx, dy)))
+ color = ColorInterpolator(distance, startcolor, endcolor, Rfunc, Gfunc, Bfunc, Afunc)
+ bigSurf = pygame.Surface((distance, 256))
+ bigSurf.fill((0,)*3)
+ oldcol = color.eval(0)
+ for x in range(distance):
+ r, g, b, a = color.eval(x)
+ pygame.draw.line(bigSurf, (255, 0, 0, 128), (x-1, oldcol[0]), (x, r))
+ pygame.draw.line(bigSurf, (0, 255, 0, 128), (x-1, oldcol[1]), (x, g))
+ pygame.draw.line(bigSurf, (0, 0, 255, 128), (x-1, oldcol[2]), (x, b))
+ pygame.draw.line(bigSurf, (255, 255, 255, 128), (x-1, oldcol[3]), (x, a))
+ oldcol = (r,g,b,a)
+ if scale:
+## return pygame.transform.scale(bigSurf, size)
+ return pygame.transform.rotozoom(bigSurf, 0, scale)
+ return pygame.transform.flip(bigSurf, 0, 1)
+#------------------------------------------------------------------------------
+
+
+
+
+def genericFxyGradient(surf, clip, color1, color2, func, intx, yint, zint=None):
+ """
+ genericFxyGradient(size, color1, color2,func, intx, yint, zint=None)
+
+ some sort of highfield drawer :-)
+
+ surf : surface to draw
+ clip : rect on surf to draw in
+ color1 : start color
+ color2 : end color
+ func : function z = func(x,y)
+ xint : interval in x direction where the function is evaluated
+ yint : interval in y direction where the function is evaluated
+ zint : if not none same as yint or xint, if None then the max and min value
+ of func is taken as z-interval
+
+ color = a*func(b*(x+c), d*(y+e))+f
+ """
+ # make shure that x1<x2 and y1<y2 and z1<z2
+ w,h = clip.size
+ x1 = min(intx)
+ x2 = max(intx)
+ y1 = min(yint)
+ y2 = max(yint)
+ if zint: # if user give us z intervall, then use it
+ z1 = min(zint)
+ z2 = max(zint)
+ else: # look for extrema of function (not best algorithme)
+ z1 = func(x1,y1)
+ z2 = z1
+ for i in range(w):
+ for j in range(h):
+ r = func(i,j)
+ z1 = min(z1, r)
+ z2 = max(z2, r)
+
+ x1 = float(x1)
+ x2 = float(x2)
+ y1 = float(y1)
+ y2 = float(y2)
+ z1 = float(z1)
+ z2 = float(z2)
+ if len(color1)==3:
+ color1 = list(color1)
+ color1.append(255)
+ if len(color2)==3:
+ color2 = list(color2)
+ color2.append(255)
+
+ # calculate streching and displacement variables
+ a = ((color2[0]-color1[0])/(z2-z1), \
+ (color2[1]-color1[1])/(z2-z1), \
+ (color2[2]-color1[2])/(z2-z1), \
+ (color2[3]-color1[3])/(z2-z1) ) # streching in z direction
+ b = (x2-x1)/float(w) # streching in x direction
+ d = (y2-y1)/float(h) # streching in y direction
+ f = ( color1[0]-a[0]*z1, \
+ color1[1]-a[1]*z1, \
+ color1[2]-a[2]*z1, \
+ color1[3]-a[3]*z1 )# z displacement
+ c = x1/b
+ e = y1/d
+
+ surff = pygame.surface.Surface((w,h)).convert_alpha()
+ # generate values
+ for i in range(h):
+ for j in range(w):
+ val = func(b*(j+c), d*(i+e))
+ #clip color
+ color = ( max(min(a[0]*val+f[0],255),0), \
+ max(min(a[1]*val+f[1],255),0), \
+ max(min(a[2]*val+f[2],255),0), \
+ max(min(a[3]*val+f[3],255),0) )
+ surff.set_at( (j,i), color )
+ surf.blit(surff, clip)
+
+
+
projects / minwii.git / commitdiff