def get_lab(self):
""" returns the current point in L*a*b* """
if not hasattr(self, '_lab'):
c = RGBColor()
c.set_from_rgb_hex(self.sRGB)
self._lab = c.convert_to('lab').get_value_tuple()
return self._lab
def get_rgb(self):
""" return the color as a list """
if not hasattr(self, '_rgb'):
c = RGBColor()
c.set_from_rgb_hex(self.sRGB)
self._rgb = (c.rgb_r / 255.0, c.rgb_g / 255.0, c.rgb_b / 255.0)
return self._rgb
def closest_delta_e(self, hex):
"""
Calculates the Delta E difference between a hex value and others in
the specified palette and returns the closest match (CMC method)
http://en.wikipedia.org/wiki/Color_difference#CMC_l:c_.281984.29
"""
incumbent = RGBColor(*webcolors.hex_to_rgb(hex))
shortest_dist = None
nearest_colour = None
for key, details in self.colours().items():
candidate = RGBColor(*webcolors.hex_to_rgb(key))
cdist = incumbent.delta_e(candidate, method="cmc")
if nearest_colour is None:
nearest_colour = (candidate, key, details)
shortest_dist = cdist
elif cdist < shortest_dist:
shortest_dist = cdist
nearest_colour = (candidate, key, details)
details = nearest_colour[2]
name = details['name']
hex = self.hex(name)
return hex, name
def rgbColorPickerUpdated(self, valuesDict, typeId, devId):
try:
self.debugLog(u"Starting rgbColorPickerUpdated.")
self.debugLog(u"typeId: " + typeId + "\ndevId: " + unicode(devId) + "\nvaluesDict: " + unicode(valuesDict))
# Get the raw 3 byte, space-separated hex string from the color picker.
rgbHexList = valuesDict['rgbColor'].split()
# Assign the RGB values.
red = int(rgbHexList[0], 16)
green = int(rgbHexList[1], 16)
blue = int(rgbHexList[2], 16)
# Convert the RGB values to HSL/HSV for use in the HSB actions.
rgb = RGBColor(red, green, blue, rgb_type='wide_gamut_rgb')
hsb = rgb.convert_to('hsv')
hue = int(round(hsb.hsv_h * 1.0))
saturation = int(round(hsb.hsv_s * 100.0))
brightness = int(round(hsb.hsv_v * 100.0))
# Assign the values to the appropriate valuesDict items.
valuesDict['red'] = red
valuesDict['green'] = green
valuesDict['blue'] = blue
valuesDict['hue'] = hue
valuesDict['saturation'] = saturation
valuesDict['brightness'] = brightness
# Can send a live update to the hardware here:
# self.sendSetRGBWCommand(valuesDict, typeId, devId)
del valuesDict['rgbColor']
return (valuesDict)
except Exception:
t, v, tb = sys.exc_info()
self.handle_exception(t,v,tb)
def get_rgb(self):
""" return the color as a list """
if not hasattr(self, '_rgb'):
c = RGBColor()
c.set_from_rgb_hex(self.sRGB)
self._rgb = (c.rgb_r / 255.0, c.rgb_g / 255.0, c.rgb_b / 255.0)
return self._rgb
def get_lab(self):
""" returns the current point in L*a*b* """
if not hasattr(self, '_lab'):
c = RGBColor()
c.set_from_rgb_hex(self.sRGB)
self._lab = c.convert_to('lab').get_value_tuple()
return self._lab
def process_item(channel):
import time
import random
import StringIO
import Image
import numpy
import itertools
from colormath.color_objects import LabColor, RGBColor
channel.send("ready")
for x in channel:
if x is None:
break
level, meshdir, filedata1, filedata2 = x
file1 = StringIO.StringIO(filedata1)
file2 = StringIO.StringIO(filedata2)
base_image = Image.open(file1)
compared_image = Image.open(file2)
delta_Es = [RGBColor(rgb_base[0], rgb_base[1], rgb_base[2]).convert_to('lab').delta_e(
RGBColor(rgb_cur[0], rgb_cur[1], rgb_cur[2]).convert_to('lab'))
for rgb_base, rgb_cur
in itertools.izip(base_image.getdata(), compared_image.getdata())
if not(len(rgb_base) > 3 and len(rgb_cur) > 3 and rgb_base[3] == 0 and rgb_cur[3] == 0)]
channel.send((level, meshdir, delta_Es))
def db_insert(filename, url, palette, rssid):
if db[COLLECTION].find({'opedid':filename}).count() > 0:
return
doc = {}
doc['opedid'] = filename
doc['url'] = url
# rgbs = []
labs = []
prominences = []
for color in palette.colors:
# rgbs.append(list(color.value))
prominences.append(color.prominence)
lab_color = RGBColor(*color.value).convert_to('lab')
labs.append(list(lab_color.get_value_tuple()))
# Rotate arrays
# rgbs = zip(*rgbs)
labs = zip(*labs)
#doc['r'] = rgbs[0]
#doc['g'] = rgbs[1]
#doc['b'] = rgbs[2]
doc['l'] = labs[0]
doc['a'] = labs[1]
doc['b'] = labs[2]
doc['prominence'] = prominences
doc['rssid'] = rssid
db[COLLECTION].insert(doc, safe=True)
def db_insert(filename, url, palette, rssid):
if db[COLLECTION].find({'opedid': filename}).count() > 0:
return
doc = {}
doc['opedid'] = filename
doc['url'] = url
# rgbs = []
labs = []
prominences = []
for color in palette.colors:
# rgbs.append(list(color.value))
prominences.append(color.prominence)
lab_color = RGBColor(*color.value).convert_to('lab')
labs.append(list(lab_color.get_value_tuple()))
# Rotate arrays
# rgbs = zip(*rgbs)
labs = zip(*labs)
#doc['r'] = rgbs[0]
#doc['g'] = rgbs[1]
#doc['b'] = rgbs[2]
doc['l'] = labs[0]
doc['a'] = labs[1]
doc['b'] = labs[2]
doc['prominence'] = prominences
doc['rssid'] = rssid
db[COLLECTION].insert(doc, safe=True)
def extract_bsdf(wd):
color=RGBColor()
color.set_from_rgb_hex(wd.color)
lab=color.convert_to('lab')
c=wd.contrast
d=wd.d()
return lab,(c,d)
def closest_delta_e(self, hex):
"""
Calculates the Delta E difference between a hex value and others in
the specified palette and returns the closest match (CMC method)
http://en.wikipedia.org/wiki/Color_difference#CMC_l:c_.281984.29
"""
incumbent = RGBColor(*webcolors.hex_to_rgb(hex))
shortest_dist = None
nearest_colour = None
for key, details in self.colours().items():
candidate = RGBColor(*webcolors.hex_to_rgb(key))
cdist = incumbent.delta_e(candidate, method="cmc")
if nearest_colour is None:
nearest_colour = (candidate, key, details)
shortest_dist = cdist
elif cdist < shortest_dist:
shortest_dist = cdist
nearest_colour = (candidate, key, details)
details = nearest_colour[2]
name = details['name']
hex = self.hex(name)
return hex, name
def extract_bsdf(wd):
color = RGBColor()
color.set_from_rgb_hex(wd.color)
lab = color.convert_to('lab')
c = wd.contrast
d = wd.d()
return lab, (c, d)
def hex_me_up(self):
self.hex_value = webcolors.rgb_to_hex(self.rgb)
snapped, colour_name = swatchbook.closest_delta_e('css3', self.hex_value)
snapped_rgb = webcolors.hex_to_rgb(snapped)
hsv = self.rgb_to_hsv(*snapped_rgb)
target = RGBColor(*snapped_rgb)
original = RGBColor(*self.rgb)
cdist = target.delta_e(original, method="cmc")
prom = Decimal(self.prominence).quantize(TWOPLACES)
dist = Decimal(cdist).quantize(TWOPLACES)
ELITE = False
self.css = {
'r': self.rgb[0],
'g': self.rgb[1],
'b': self.rgb[2],
'hue': hsv[0],
'hex': snapped,
'name': colour_name,
'distance': float(dist),
'prominence': float(prom),
'elite': ELITE,
}
return self.css
def contrast_text(self):
"""Returns hex code of a color that contrasts with this one, for
overlaying text. Includes the #."""
# get rgb and hsv values
rgbcolor = RGBColor()
rgbcolor.set_from_rgb_hex(self.color_hex)
hsvcolor = rgbcolor.convert_to('hsv')
new_v = hsvcolor.hsv_v;
if new_v <= .55:
new_v = 1.0;
elif new_v > .55:
new_v = 0.0;
new_h = hsvcolor.hsv_h
new_s = 0
contrast = HSVColor(hsv_h = new_h, hsv_s = new_s, hsv_v = new_v)
contrast_rgb = contrast.convert_to('rgb')
return contrast_rgb.get_rgb_hex()
def color_distance(color_a, color_b):
from colormath.color_objects import RGBColor
colora = RGBColor(rgb_r = color_a.rR, rgb_g = color_a.rG, rgb_b = color_a.rB)
colorb = RGBColor(rgb_r = color_b.rR, rgb_g = color_b.rG, rgb_b = color_b.rB)
return colora.delta_e(colorb, mode='cmc', pl=1, pc=1)
def find_related_pixel(self):
self.is_parse = True
try:
fileimage = cStringIO.StringIO(urllib.urlopen(self.picture_url_high).read())
img = Image.open(fileimage)
imgResze = img.resize((1, 1), Image.ANTIALIAS)
pixels = list(imgResze.getdata())
except:
print 'error color pixel'
self.delete()
return True
color_insta = RGBColor(pixels[0][0],pixels[0][1],pixels[0][2])
color_hex = color_insta.get_rgb_hex()
color_hex = color_hex.replace("#", "")
self.color = color_hex
self.r_color = pixels[0][0]
self.g_color = pixels[0][1]
self.b_color = pixels[0][2]
pixel_asso = None
for subscription in self.subscriptions.all():
print 'Subscription => %s' % subscription
for mosaic in subscription.mosaics.all():
print 'Mosaic : %s' % mosaic.name
try:
img = img.resize((mosaic.pixel_size, mosaic.pixel_size), Image.ANTIALIAS)
filepath = settings.MEDIA_ROOT + '/pics/%s_%s.png' % (mosaic.pixel_size,self.id)
img.save(filepath, 'PNG')
except:
print 'error save pixel min'
return True
color_insta = RGBColor(pixels[0][0],pixels[0][1],pixels[0][2])
color_hex = color_insta.get_rgb_hex()
color_hex = color_hex.replace("#", "")
delta_e = 100
for pixel in mosaic.pixels.filter(pic__isnull=True):
pixel_color = RGBColor(pixel.r_color,pixel.g_color,pixel.b_color)
delta_e_new = color_insta.delta_e(pixel_color)
#print '#'+pixel.color
#print color_insta.get_rgb_hex()
#print delta_e_new
if delta_e_new < delta_e:
delta_e = delta_e_new
pixel_asso = pixel
print 'minimum delta_e %s' % delta_e
if pixel_asso:
if delta_e < 25:
print 'set pixel %s with delta %s' % (pixel_asso.id,delta_e)
pixel_asso.pic = self
pixel_asso.save()
self.add_to_fake_mosaic(mosaic, pixel_asso)
self.save()
def scaled_rgb(hex_color, component=None, factor=1.0):
rgb_color = RGBColor()
rgb_color.set_from_rgb_hex(hex_color)
values = list(map(lambda x: factor * (x / 255), rgb_color.get_value_tuple()))
if component is None:
return '{} {} {}'.format(*rgb_color.get_value_tuple())
else:
comp_idx = ('R', 'G', 'B').index(component)
return '{}'.format(values[comp_idx])
def find_color_opeds(rgb_hex):
'Returns matching opeds for a given color'
color = RGBColor()
color.set_from_rgb_hex('#' + rgb_hex)
cursor = db_find(color)
colors = mongo_to_colors(cursor)
results = find_closest(color, colors)[:MAX_COLOR_RESULTS]
opeds = [result[0] for result in results]
return opeds
def save(self, *args, **kwargs):
if (self.color_L is None) or (self.color_a is None) or (self.color_b is None):
c = RGBColor()
c.set_from_rgb_hex(self.color)
c = c.convert_to('lab')
self.color_L = c.lab_l
self.color_a = c.lab_a
self.color_b = c.lab_b
super(ShapeBsdfLabel_wd, self).save(*args, **kwargs)
def difference(a, b): # HLS
print(a, b)
#c1 = HSLColor(hsl_h = a[0], hsl_s = a[2]/100.0, hsl_l = a[1]/100.0)
#c2 = HSLColor(hsl_h = b[0], hsl_s = a[2]/100.0, hsl_l = a[1]/100.0)
c1 = RGBColor(a[0], a[1], a[2])
c2 = RGBColor(b[0], b[1], b[2])
#c1.convert_to('lab')
#c2.convert_to('lab')
print(c1.delta_e(c2))
return c1.delta_e(c2)
def alter_lch(hex_color, value, component='L', relative=True):
rgb_color = RGBColor()
rgb_color.set_from_rgb_hex(hex_color)
lch_color = rgb_color.convert_to('lchab')
lch_lst = list(lch_color.get_value_tuple())
comp_idx = ('L', 'C', 'H').index(component)
lch_lst[comp_idx] = lch_lst[comp_idx] + value if relative else value
L, C, H = lch_lst
lch_res = LCHabColor(L, C, H)
return lch_to_hex(lch_res)
def difference(a, b): # HLS
print(a, b)
#c1 = HSLColor(hsl_h = a[0], hsl_s = a[2]/100.0, hsl_l = a[1]/100.0)
#c2 = HSLColor(hsl_h = b[0], hsl_s = a[2]/100.0, hsl_l = a[1]/100.0)
c1 = RGBColor(a[0], a[1], a[2])
c2 = RGBColor(b[0], b[1], b[2])
#c1.convert_to('lab')
#c2.convert_to('lab')
print(c1.delta_e(c2))
return c1.delta_e(c2)
def alter_lch(hex_color, value, component='L', relative=True):
rgb_color = RGBColor()
rgb_color.set_from_rgb_hex(hex_color)
lch_color = rgb_color.convert_to('lchab')
lch_lst = list(lch_color.get_value_tuple())
comp_idx = ('L', 'C', 'H').index(component)
lch_lst[comp_idx] = lch_lst[comp_idx] + value if relative else value
L, C, H = lch_lst
lch_res = LCHabColor(L, C, H)
return lch_to_hex(lch_res)
def set_rgb(self, rgb):
'''
Pass an RGB value to the classifier
'''
rgb = RGBColor(*rgb)
logger.debug(rgb.get_rgb_hex())
self.lab = rgb.convert_to('lab')
logger.debug('Saved lab: {lab} from rgb: {rgb}'.format(
lab=self._lab_to_tuple(self.lab), rgb=rgb))
self._update_lab_colors()
def save(self, *args, **kwargs):
if (self.color_L is None) or (self.color_a is None) or (self.color_b is
None):
c = RGBColor()
c.set_from_rgb_hex(self.color)
c = c.convert_to('lab')
self.color_L = c.lab_l
self.color_a = c.lab_a
self.color_b = c.lab_b
super(ShapeBsdfLabel_wd, self).save(*args, **kwargs)
def fromRGBAHex(self, rgba_hex, background_hex):
self.fromRGBHex(rgba_hex[:7])
if len(rgba_hex) > 7:
opacity = int(100 * (int(rgba_hex[7:], 16) / 255))
background = RGBColor()
if len(background_hex) > 7:
background_hex = "#ffffff"
background.set_from_rgb_hex(background_hex)
self.mix(background, opacity)
class Color(object):
@classmethod
def from_string(cls, string):
if not string.startswith('#'):
raise ValueError(string)
if len(string) == 4:
args = [int(x * 2, 16) for x in string[1:]]
elif len(string) == 7:
args = [int(string[i:i + 2], 16) for i in xrange(1, 7, 2)]
else:
raise ValueError(string)
return cls(*args)
@classmethod
def from_index(cls, index):
return cls(*INDEX_TO_COLOR[index])
def __init__(self, red, green, blue):
self.color = RGBColor(red, green, blue)
@property
def red(self):
return self.color.rgb_r
@property
def green(self):
return self.color.rgb_g
@property
def blue(self):
return self.color.rgb_b
def __eq__(self, other):
return self.to_int() == other.to_int()
def __ne__(self, other):
return not self.__eq__(other)
def __hash__(self):
return self.to_int()
def to_string(self):
return self.color.get_rgb_hex()
def to_int(self):
return COLOR_TO_INDEX[self.red, self.green, self.blue]
def difference_to(self, color):
return self.color.delta_e(color.color)
def closest(self, colors):
rv = {}
for color in colors:
rv[color.difference_to(self)] = color
return rv[min(rv)]
def mix(self, mask, opacity):
opacity /= 100.0
rgbcolor = self.convert_to("RGB")
rgbmask = mask.convert_to("RGB")
mixed = RGBColor()
mixed.rgb_r = (rgbcolor.rgb_r * opacity) + (rgbmask.rgb_r * (1 - opacity))
mixed.rgb_g = (rgbcolor.rgb_g * opacity) + (rgbmask.rgb_g * (1 - opacity))
mixed.rgb_b = (rgbcolor.rgb_b * opacity) + (rgbmask.rgb_b * (1 - opacity))
self._fromRGBColor(mixed)
def set_rgb(self, rgb):
'''
Pass an RGB value to the classifier
'''
rgb = RGBColor(*rgb)
logger.debug(rgb.get_rgb_hex())
self.lab = rgb.convert_to('lab')
logger.debug('Saved lab: {lab} from rgb: {rgb}'.format(
lab=self._lab_to_tuple(self.lab),
rgb=rgb))
self._update_lab_colors()
def get_distance(pix1, pix2): '''Computes distance beween two colors. based on colormath if available, or computes a simple euclidian distance on RGB values ''' if HasColormath: col1 = RGBColor(pix1[0], pix1[1], pix1[2]) col2 = RGBColor(pix2[0], pix2[1], pix2[2]) #dist = col1.delta_e(col2, mode='cmc', pl=1, pc=1) dist = col1.delta_e(col2) else: dist = sqrt ( pow(pix1[0]-pix2[0],2)+pow(pix1[1]-pix2[1],2)+pow(pix1[2]-pix2[2],2) ) return dist
def closest_colour(requested_colour):
"""Find the colour in kelly_colours that is closest to this one.
requested_colour is an RGB tuple."""
rlab = RGBColor(*requested_colour).convert_to("lab")
if (30 < rlab.lab_l < 70) and abs(rlab.lab_a) + abs(rlab.lab_b) == 0:
# This is a greyscale colour
return "#817066"
better_colours = {}
for key, bits in kelly_colours.items():
lab_diff = rlab.delta_e(bits[1])
better_colours[lab_diff] = key
return better_colours[min(better_colours.keys())]
def example_rgb_to_xyz():
"""
The reverse is similar.
"""
print "=== RGB Example: RGB->XYZ ==="
# Instantiate an Lab color object with the given values.
rgb = RGBColor(120, 130, 140, rgb_type='sRGB')
# Show a string representation.
print rgb
# Convert RGB to XYZ using a D50 illuminant.
xyz = rgb.convert_to('xyz', target_illuminant='D50')
print xyz
print "=== End Example ===\n"
def example_rgb_to_xyz():
"""
The reverse is similar.
"""
print "=== RGB Example: RGB->XYZ ==="
# Instantiate an Lab color object with the given values.
rgb = RGBColor(120, 130, 140, rgb_type='sRGB')
# Show a string representation.
print rgb
# Convert RGB to XYZ using a D50 illuminant.
xyz = rgb.convert_to('xyz', target_illuminant='D50')
print xyz
print "=== End Example ===\n"
def compare_colors(self, color0, color1):
"""
see https://de.wikipedia.org/wiki/Delta_E
0,0 … 0,5 kein bis fast kein Unterschied
0,5 … 1,0 Unterschied kann für das geübte Auge bemerkbar sein
1,0 … 2,0 merklicher Farbunterschied
2,0 … 4,0 wahrgenommener Farbunterschied
4,0 … 5,0 wesentlicher Farbunterschied, der selten toleriert wird
oberhalb 5,0 die Differenz wird als andere Farbe bewertet
"""
c0 = RGBColor(color0[0], color0[1], color0[2])
c1 = RGBColor(color1[0], color1[1], color1[2])
return c0.delta_e(c1, mode='cie1976')
def convert_platter(self):
self.lab_colors = []
self.rgb_color_keys = []
for rgb_color in DColor.Platter.keys():
hex = self.hex_to_rgb(rgb_color)
self.rgb_color_keys.append(rgb_color)
self.lab_colors.append(RGBColor(hex[0],hex[1],hex[2]).convert_to('lab'))
return self
def update_shape_dominant_delta(shape, save=True):
""" Update shape dominant_delta """
if not shape.dominant_rgb0 or not shape.dominant_rgb1:
return
c0 = RGBColor()
c1 = RGBColor()
c0.set_from_rgb_hex(shape.dominant_rgb0)
c1.set_from_rgb_hex(shape.dominant_rgb1)
shape.dominant_delta = c0.delta_e(c1)
if save:
shape.save()
def handle(self, *args, **options):
comparisons = []
comparisons += IntrinsicPointComparison.objects.all() \
.filter(point1_image_darker__isnull=True) \
.values_list('id', 'point1__sRGB', 'point2__sRGB')
comparisons += IntrinsicPointComparisonResponse.objects.all() \
.filter(reflectance_eq=False, reflectance_dd__isnull=True) \
.order_by().distinct('comparison') \
.values_list('comparison__id', 'comparison__point1__sRGB', 'comparison__point2__sRGB')
comparisons = list(set(comparisons))
for (id, sRGB1, sRGB2) in progress_bar(comparisons):
c1 = RGBColor()
c1.set_from_rgb_hex(sRGB1)
l1 = c1.convert_to('lab').lab_l
c2 = RGBColor()
c2.set_from_rgb_hex(sRGB2)
l2 = c2.convert_to('lab').lab_l
if l1 < l2:
IntrinsicPointComparison.objects \
.filter(id=id).update(point1_image_darker=True)
IntrinsicPointComparisonResponse.objects \
.filter(comparison_id=id, darker="1") \
.update(reflectance_eq=False, reflectance_dd=True)
IntrinsicPointComparisonResponse.objects \
.filter(comparison_id=id, darker="2") \
.update(reflectance_eq=False, reflectance_dd=False)
else:
IntrinsicPointComparison.objects \
.filter(id=id).update(point1_image_darker=False)
IntrinsicPointComparisonResponse.objects \
.filter(comparison_id=id, darker="1") \
.update(reflectance_eq=False, reflectance_dd=False)
IntrinsicPointComparisonResponse.objects \
.filter(comparison_id=id, darker="2") \
.update(reflectance_eq=False, reflectance_dd=True)
IntrinsicPointComparisonResponse.objects \
.filter(comparison_id=id, darker="E") \
.update(reflectance_eq=True, reflectance_dd=None)
def platter_colors(self):
self.main_colors_in_platter = []
for p in self.main_colors_in_rbg:
p_lab = RGBColor(p[0],p[1],p[2])
distances = []
for c in self.lab_colors:
distances.append((p_lab).convert_to('lab').delta_e(c))
self.main_colors_in_platter.append(DColor.Platter[self.rgb_color_keys[distances.index(min(distances))]])
return self
def _get_color(self):
self.nearest = None
self.shortest_distance = 100
chosen_name = None
for color_dict in (COLOURS, GREYSCALE):
for name, color in color_dict.iteritems():
desired_rgb = color[0]
target = RGBColor(*desired_rgb)
cdist = target.delta_e(RGBColor(*self.rgb), method='cmc')
if self.nearest is None or cdist < self.shortest_distance:
self.nearest = name
self.nearest_rgb = desired_rgb
self.shortest_distance = cdist
self.distance = cdist
# print 'Checking', name
(hue_lo, hue_hi) = color[1]
if hue_lo > hue_hi:
h = self.spin(self.hue)
hue_lo = self.spin(hue_lo)
hue_hi = self.spin(hue_hi)
else:
h = self.hue
sat_range = color[2] or DEFAULT_SAT
val_range = color[3] or DEFAUL_VAL
if h in range(hue_lo, hue_hi + 1) and \
self.sat in range(sat_range[0], sat_range[1] + 1) and \
self.val in range(val_range[0], val_range[1] + 1):
# TODO set up desirable hues, sat and b per named colour
target = RGBColor(*desired_rgb)
self.distance = cdist
chosen_name = name
self.nearest_hex = webcolors.rgb_to_hex(self.nearest_rgb)
return chosen_name
return None
def color(v, echelle, tohex=True):
""" Retourne la couleur d'une valeur intermediaire. """
# Utilisation d'un régression linéaire des valeurs HSV (hue, saturation, value)
# de 2 couleurs (même méthode que l'algorithme Lab-LCH d'ArcGIS).
keys = echelle.keys()
keys.sort()
if v < min(keys): v = min(keys)
if v > max(keys): v = max(keys)
if v in keys:
rgb = RGBColor(*echelle[v])
if tohex: return rgb.get_rgb_hex()
else: return rgb.get_value_tuple()
kmin, kmax = None, None
vmin, vmax = None, None
for i in range(len(keys) - 1):
if v > keys[i] and v < keys[i + 1]:
kmin, kmax = i, i + 1
vmin, vmax = keys[i], keys[i + 1]
break
if kmin is None or kmax is None or vmin is None or vmax is None:
return None
rgb_a = RGBColor(*echelle[vmin])
hsv_a = rgb_a.convert_to('hsv')
rgb_b = RGBColor(*echelle[vmax])
hsv_b = rgb_b.convert_to('hsv')
xa = keys[kmin]
xb = keys[kmax]
xi = v
hi = eq(xi, xa, xb, hsv_a.hsv_h, hsv_b.hsv_h)
si = eq(xi, xa, xb, hsv_a.hsv_s, hsv_b.hsv_s)
vi = eq(xi, xa, xb, hsv_a.hsv_v, hsv_b.hsv_v)
hsv_i = HSVColor(hi, si, vi)
rgb_i = hsv_i.convert_to('rgb')
if tohex: return rgb_i.get_rgb_hex()
else: return rgb_i.get_value_tuple()
def get_rbg_color(p):
distances = []
p_lab = RGBColor(p[0], p[1], p[2])
print len(lab_colors)
for c in lab_colors:
distances.append((p_lab).convert_to('lab').delta_e(c))
print len(distances)
print min(distances)
print distances.index(min(distances))
return hex_to_rgb(rgb_color_keys[distances.index(min(distances))])
def closest_ansi_color(color):
# Look up the closest ANSI color
color = RGBColor(*color[:3])
closest_dist = INFINITY
closest_color_index = 0
for i, c in enumerate(ANSI_COLORS):
d = color_distance(c, color)
if d < closest_dist:
closest_dist = d
closest_color_index = i
return ANSI_CODES[closest_color_index]
def fade_colors_rgb(self,rgbcolor1,rgbcolor2,speed=0.1):
"""
Values for color conversion: Best result for me:
target_illuminant=d50
target_rgb=sRGB
target_illuminant=
'a' 'b' 'c' 'd50' 'd55' 'd65' 'd75' 'e' 'f2' 'f7' 'f11'
target_rgb=
'adobe_rgb' 'apple_rgb' 'best_rgb' 'bruce_rgb' 'cie_rgb' 'colormatch_rgb' 'don_rgb_4' 'eci_rgb' 'ekta_space_ps5' 'ntsc_rgb' 'pal_secam_rgb' 'prophoto_rgb' 'smpte_c_rgb' 'srgb' 'wide_gamut_rgb'
"""
rgb1 = RGBColor(rgbcolor1[0],rgbcolor1[1],rgbcolor1[2])
rgb2 = RGBColor(rgbcolor2[0],rgbcolor2[1],rgbcolor2[2])
l1 = rgb1.convert_to('lab',target_illuminant='d50')
l2 = rgb2.convert_to('lab',target_illuminant='d50')
lab1 =[l1.lab_l,l1.lab_a,l1.lab_b]
lab2 =[l2.lab_l,l2.lab_a,l2.lab_b]
for i in range(0,self.fade_steps+1):
l=self.transition3(i,self.fade_steps,lab1,lab2)
lab=LabColor(l[0],l[1],l[2])
r=lab.convert_to('rgb')
rgb=[r.rgb_r,r.rgb_g,r.rgb_b]
self.set_color_rgb(rgb)
sleep(speed)
def set_light(self, light, hex, brightness=0, on=True):
rgb = RGBColor()
rgb.set_from_rgb_hex(hex)
color = rgb.convert_to('hsv')
bri = int(color.hsv_v * 254)
hue = int(color.hsv_h * 200)
sat = int(color.hsv_s * 254)
if brightness > 0:
bri = brightness
params = {
"on": on,
"bri": bri,
"hue": hue,
"sat": sat,
}
params = json.dumps(params)
self.send_data(light, params)
def scaled_rgb(hex_color, component=None, factor=1.0):
rgb_color = RGBColor()
rgb_color.set_from_rgb_hex(hex_color)
values = list(
map(lambda x: factor * (x / 255), rgb_color.get_value_tuple()))
if component is None:
return '{} {} {}'.format(*rgb_color.get_value_tuple())
else:
comp_idx = ('R', 'G', 'B').index(component)
return '{}'.format(values[comp_idx])
def update_shape_dominant_delta(shape, save=True):
""" Update shape dominant_delta """
if not shape.dominant_rgb0 or not shape.dominant_rgb1:
return
c0 = RGBColor()
c1 = RGBColor()
c0.set_from_rgb_hex(shape.dominant_rgb0)
c1.set_from_rgb_hex(shape.dominant_rgb1)
shape.dominant_delta = c0.delta_e(c1)
if save:
shape.save()
def blend(color1, color2, percentColor1=0.5):
percentColor2 = 1.0-percentColor1
# Convert from QColor to lab
c1Alpha = color1.alpha()
color1 = RGBColor(color1.red(),color1.green(),color1.blue()).convert_to('lab')
c2Alpha = color2.alpha()
color2 = RGBColor(color2.red(),color2.green(),color2.blue()).convert_to('lab')
# Interpolate the colors in lab space
result = LabColor(color1.lab_l*percentColor1+color2.lab_l*percentColor2,
color1.lab_a*percentColor1+color2.lab_a*percentColor2,
color1.lab_b*percentColor1+color2.lab_b*percentColor2)
resultAlpha = c1Alpha*percentColor1 + c2Alpha*percentColor2
# Convert back to QColor
result = result.convert_to('rgb')
return QColor.fromRgba(result.rgb_r,result.rgb_g,result.rgb_b,resultAlpha)
def assignColorNames(data, names):
from colormath.color_objects import RGBColor
result = {}
for key in data:
rgb = data[key]
#print "=== RGB Example: RGB->LAB ==="
# Instantiate an Lab color object with the given values.
rgb = RGBColor(rgb[0], rgb[1], rgb[2], rgb_type='sRGB')
# Show a string representation.
#print rgb
# Convert RGB to LAB using a D50 illuminant.
lab = rgb.convert_to('lab', target_illuminant='D65')
#print lab
#print "=== End Example ===\n"
# Reference color.
#color1 = LabColor(lab_l=0.9, lab_a=16.3, lab_b=-2.22)
# Color to be compared to the reference.
#color2 = LabColor(lab_l=0.7, lab_a=14.2, lab_b=-1.80)
color2 = lab
res = (1.E100, '')
for c in names:
rgb = data[c]
rgb = RGBColor(rgb[0], rgb[1], rgb[2], rgb_type='sRGB')
color1 = rgb.convert_to('lab', target_illuminant='D65')
#print "== Delta E Colors =="
#print " COLOR1: %s" % color1
#print " COLOR2: %s" % color2
#print "== Results =="
#print " CIE2000: %.3f" % color1.delta_e(color2, mode='cie2000')
## Typically used for acceptability.
#print " CMC: %.3f (2:1)" % color1.delta_e(color2, mode='cmc', pl=2, pc=1)
## Typically used to more closely model human percetion.
#print " CMC: %.3f (1:1)" % color1.delta_e(color2, mode='cmc', pl=1, pc=1)
r = color1.delta_e(color2, mode='cmc', pl=2, pc=1)
if (r < res[0]):
res = (r, c, data[c])
# data[key]['Color'] = res[1]
# data[key]['Delta_E'] = res[0]
# data[key]['RGBref'] = res[2]
result['%s (%s)' % (key, res[1])] = data[key]
return result
def updateStatus(self, device):
#self.debugLog(u"Updating device: " + device.name)
try:
keyValueList = []
bulb = WifiLedBulb(device.address)
keyValueList.append({'key':"online", 'value':True})
currentRGBW = bulb.getRgbw()
device.pluginProps["supportsWhite"] = bulb.rgbwcapable
device.pluginProps["supportsWhiteTemperature"] = False
#self.debugLog(str(currentRGBW))
channelKeys = []
if bulb.rgbwcapable:
channelKeys.extend(['whiteLevel'])
brightness= int(round(RGBColor(currentRGBW[0],currentRGBW[1],currentRGBW[2]).convert_to('hsv').hsv_v*100))
keyValueList.append({'key':"onOffState", 'value':bulb.isOn()})
keyValueList.append({'key':"redLevel", 'value':currentRGBW[0]})
keyValueList.append({'key':"greenLevel", 'value':currentRGBW[1]})
keyValueList.append({'key':"blueLevel", 'value':currentRGBW[2]})
keyValueList.append({'key':'brightnessLevel','value':brightness})
if bulb.rgbwcapable:
keyValueList.append({'key':"whiteLevel", 'value':currentRGBW[3]})
device.updateStatesOnServer(keyValueList)
except Exception,e:
self.errorLog("Error updating device: " + device.name +". Is the IP address correct?")
t, v, tb = sys.exc_info()
self.handle_exception(t,v,tb)
def refresh_values(self):
if not self.color_hex.islower():
self.color_hex = self.color_hex.lower()
# get rgb and hsv values
rgbcolor = RGBColor()
rgbcolor.set_from_rgb_hex(self.color_hex)
hsvcolor = rgbcolor.convert_to('hsv')
self.R = rgbcolor.rgb_r
self.G = rgbcolor.rgb_g
self.B = rgbcolor.rgb_b
self.H = round(hsvcolor.hsv_h)
# need to multiply by 100 to get the percent
self.S = round(hsvcolor.hsv_s * 100.0)
self.V = round(hsvcolor.hsv_v * 100.0)
# make rounded values
self.rR = round_rgb_colorvalue(self.R)
self.rG = round_rgb_colorvalue(self.G)
self.rB = round_rgb_colorvalue(self.B)
round_rgb = RGBColor(rgb_r = self.rR, rgb_g = self.rG, rgb_b = self.rB)
round_hsv = round_rgb.convert_to('hsv')
self.rounded_hex = round_rgb.get_rgb_hex()[1:7]
self.rH = round_hsv.hsv_h
self.rS = round_hsv.hsv_s
self.rV = round_hsv.hsv_v
# check to see if this is a round color
if self.R == self.rR and self.G == self.rG and self.B == self.rB:
self.is_round = True
else:
self.is_round = False
import sys
import os
from colormath.color_objects import LabColor, RGBColor
from PIL import Image
dir = sys.argv[1]
files = os.listdir(dir)
files.sort()
base_file = os.path.join(dir, files[-1])
compared_file = os.path.join(dir, files[int(sys.argv[2])])
base_image = Image.open(base_file)
compared_image = Image.open(compared_file)
print \
sum( \
RGBColor(rgb_base[0], rgb_base[1], rgb_base[2]) \
.convert_to('lab') \
.delta_e( \
RGBColor(rgb_cur[0], rgb_cur[1], rgb_cur[2]) \
.convert_to('lab') \
) \
for (rgb_base, rgb_cur) \
in zip(base_image.getdata(), compared_image.getdata())\
)
def E2(shape):
if shape.substance_entropy > 2.0:
yield 10000.0
yield 10000.0
yield 10000.0
yield 10000.0
return
color = RGBColor()
color.set_from_rgb_hex(shape.dominant_rgb0)
lab2 = color.convert_to('lab')
yield lab.delta_e(lab2) # cie2000 delta e
color.set_from_rgb_hex(shape.dominant_rgb1)
lab2 = color.convert_to('lab')
yield lab.delta_e(lab2) # cie2000 delta e
color.set_from_rgb_hex(shape.dominant_rgb2)
lab2 = color.convert_to('lab')
yield lab.delta_e(lab2) # cie2000 delta e
color.set_from_rgb_hex(shape.dominant_rgb3)
lab2 = color.convert_to('lab')
yield lab.delta_e(lab2) # cie2000 delta e
def to_lchab(v):
return RGBColor(v.r, v.g, v.b).convert_to('LCHab').get_value_tuple()
def hex_to_lch(hex_color):
rgb_color = RGBColor()
rgb_color.set_from_rgb_hex(hex_color)
return rgb_color.convert_to('lchab')
def raw_rgb(hex_color):
rgb_color = RGBColor()
rgb_color.set_from_rgb_hex(hex_color)
return '{} {} {}'.format(*rgb_color.get_value_tuple())
def __distance(self, c1, c2):
"Calculate the visual distance between the two colors."
return RGBColor(*c1).delta_e(RGBColor(*c2), method='cmc')
