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 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 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 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 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 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 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 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_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 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 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 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 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 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 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 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 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 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 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 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 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)
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 __distance(self, c1, c2):
"Calculate the visual distance between the two colors."
return RGBColor(*c1).delta_e(RGBColor(*c2), method='cmc')
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())
