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 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()
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 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 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 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
class RGBConversionTestCase(BaseColorConversionTest):
def setUp(self):
self.color = RGBColor(0.482, 0.784, 0.196, rgb_type='sRGB')
def test_to_xyz_and_back(self):
xyz = convert_color(self.color, XYZColor)
rgb = convert_color(xyz, RGBColor)
self.assertColorMatch(rgb, self.color)
def test_conversion_to_hsl_max_r(self):
color = RGBColor(255, 123, 50, rgb_type='sRGB', is_upscaled=True)
hsl = convert_color(color, HSLColor)
self.assertColorMatch(hsl, HSLColor(21.366, 1.000, 0.598))
def test_conversion_to_hsl_max_g(self):
color = RGBColor(123, 255, 50, rgb_type='sRGB', is_upscaled=True)
hsl = convert_color(color, HSLColor)
self.assertColorMatch(hsl, HSLColor(98.634, 1.000, 0.598))
def test_conversion_to_hsl_max_b(self):
color = RGBColor(0.482, 0.482, 1.0, rgb_type='sRGB')
hsl = convert_color(color, HSLColor)
self.assertColorMatch(hsl, HSLColor(240.000, 1.000, 0.741))
def test_conversion_to_hsl_gray(self):
color = RGBColor(0.482, 0.482, 0.482, rgb_type='sRGB')
hsl = convert_color(color, HSLColor)
self.assertColorMatch(hsl, HSLColor(0.000, 0.000, 0.482))
def test_conversion_to_hsv(self):
hsv = convert_color(self.color, HSVColor)
self.assertColorMatch(hsv, HSVColor(90.816, 0.750, 0.784))
def test_conversion_to_cmy(self):
cmy = convert_color(self.color, CMYColor)
self.assertColorMatch(cmy, CMYColor(0.518, 0.216, 0.804))
def test_srgb_conversion_to_xyz_d50(self):
"""
sRGB's native illuminant is D65. Test the XYZ adaptations by setting
a target illuminant to something other than D65.
"""
xyz = convert_color(self.color, XYZColor, target_illuminant='D50')
self.assertColorMatch(xyz, XYZColor(0.313, 0.460, 0.082))
def test_srgb_conversion_to_xyz_d65(self):
"""
sRGB's native illuminant is D65. This is a straightforward conversion.
"""
xyz = convert_color(self.color, XYZColor)
self.assertColorMatch(xyz, XYZColor(0.294, 0.457, 0.103))
def test_adobe_conversion_to_xyz_d65(self):
"""
Adobe RGB's native illuminant is D65, like sRGB's. However, sRGB uses
different conversion math that uses gamma, so test the alternate logic
route for non-sRGB RGB colors.
"""
adobe = RGBColor(0.482, 0.784, 0.196, rgb_type='adobe_rgb')
xyz = convert_color(adobe, XYZColor)
self.assertColorMatch(xyz, XYZColor(0.230, 0.429, 0.074))
def test_adobe_conversion_to_xyz_d50(self):
"""
Adobe RGB's native illuminant is D65, so an adaptation matrix is
involved here. However, the math for sRGB and all other RGB types is
different, so test all of the other types with an adaptation matrix
here.
"""
adobe = RGBColor(0.482, 0.784, 0.196, rgb_type='adobe_rgb')
xyz = convert_color(adobe, XYZColor, target_illuminant='D50')
self.assertColorMatch(xyz, XYZColor(0.247, 0.431, 0.060))
def test_convert_to_self(self):
same_color = convert_color(self.color, RGBColor)
self.assertEqual(self.color, same_color)
def test_get_rgb_hex(self):
hex_str = self.color.get_rgb_hex()
self.assertEqual(hex_str, "#7bc832", "sRGB to hex conversion failed")
def test_set_from_rgb_hex(self):
rgb = RGBColor.new_from_rgb_hex('#7bc832')
self.assertColorMatch(rgb, RGBColor(0.482, 0.784, 0.196))
