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 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 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 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 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 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 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 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')