Re: tool to calculate color combination

[Max M]

Astan Chee skrev:

Hi,
I was just wondering if there is a tool/script in python that allows me
to do color calculations; specifically, when I add them.

There is the colorsys module which I have used in this class:


from colorsys import rgb_to_hls, hls_to_rgb
import binascii
from types import StringType, TupleType, ListType, IntType, FloatType
from math import modf

class RGB:
""" Makes it easier to work with rgb colors """

def __init__(self, color):
# set color value
self.color = self.any2color(color)

def any2color(self, color):
"""
Takes a number of color formats and returns a sequence of 3
floats:
(r,g,b)
Some legal formats for pure blue are:
'0x0000FF','#0000FF','0000FF',
[0.0, 0.0, 1.0], [0, 0, 255], (0, 0.0, 'FF') and ('0', '0', 'f').
Mixed types are allowed in sequences.
"""
# it must be a hex, so convert to sequence of hex values
if isinstance(color, StringType):
# handle hex value
if color[:2].lower() == '0x': color = color[2:]
elif color[0] == '#': color = color[1:]
color = (color[:2], color[2:4], color[4:])
# convert sequence to floats
color_result = []
a = color_result.append
for part in color:
# what type is the part?
if isinstance(part, StringType): # hex part
if len(part) == 1:
part = '0%s' % part
b = binascii.a2b_hex(part)
a(ord(b[0])/255.0)
elif isinstance(part, IntType): # int part
a(part/255.0)
elif isinstance(part, FloatType): # float part
a(part)
return color_result
def __str__(self):
"Returns string representation of color (same as html_hex)"
return self.html_hex()
def r(self):
return self.color[0]

def g(self):
return self.color[1]

def b(self):
return self.color[2]
def bytes(self):
"""
Takes a sequence of colors in floats, and returns a sequence of
int in
the range 0-255
"""
return map(lambda x: int(x*255), self.color)
def html_hex(self):
"""
Returns the color in a hex string representation of the form
'#0000FF'
"""
r,g,b = self.color
return '#%02X%02X%02X' % (int(r*255),int(g*255),int(b*255))
def _cAdd(self, x, y):
"Private method! Cirkular add x+y so value allways in 0.0-1.0
range"
fractional, integer = modf(x + y)
if not fractional and integer: # special case 1.0
return 1.0
return abs(fractional)
# wrong result for negative values!
def hls_delta(self, dh, dl, ds):
"""
Returns a Color object same as self, but adjusted by delta hls
values
"""
h,l,s = rgb_to_hls(*self.color)
nh = self._cAdd(h, dh)
nl = l + dl
if nl 1.0: nl = 1.0
if nl < 0.0: nl = 0.0
ns = s + ds
if ns 1.0: ns = 1.0
if ns < 0.0: ns = 0.0
return RGB(hls_to_rgb(nh, nl, ns))
def change_ls(self, new_l=None, new_s=None):
"""
Returns a Color object same as self, but with new lightness and
saturation levels
"""
h,l,s = rgb_to_hls(*self.color)
if new_l == None:
new_l = l
if new_s == None:
new_s = s
return RGB(hls_to_rgb(h, new_l, new_s))
def spacer(self, transparent=None):
"""
Creates a 1x1 GIF89a of color. If no color it returns a
transparent gif
Should probably not be in this module?
"""
template = [71, 73, 70, 56, 57, 97, 1, 0, 1, 0, 128, 0, 0, 255,
255,
255, 0, 0, 0, 33, 249, 4, 1, 0, 0, 0, 0, 44, 0, 0, 0, 0, 1, 0,
1, 0,
0, 2, 2, 68, 1, 0, 59]
if not transparent:
template[13:16] = self.bytes() # set rgb values
template[22] = 0 # remove transparency
return ''.join(map(chr, template))

if __name__=='__main__':

red = (255, 0, 0)
green = (0.0, 1.0, 0.0)
blue = (0.0, 0.0, 1.0)
yellow = '#ffff00'

col = RGB(blue)
print col.color
print col.bytes()
print col

brighter = col.change_ls(0.0, 0.0)
print 'brighter:',brighter

# complementary = col.hls_delta(0.50, 0.0, 0.0)
# print complementary
--

hilsen/regards Max M, Denmark

http://www.mxm.dk/
IT's Mad Science