def bin_dataframe(self, radius):
"""
This function looks at the Set's dataframe and checks whether there are
columns that are closer together than _radius_ in colorspace. Such columns
are then merged.
The algorithm is similar to the DCB algorithm itself, which is heavily commented
in the ColorList class.
"""
cols = list(self.dataframe)
# Perform checking
for col in cols:
colbgr = literal_eval(col)
color = sRGBColor(colbgr[0], colbgr[1], colbgr[2], is_upscaled=True)
color_lab = convert_color(color, LabColor)
for compcol in cols[cols.index(col)+1:]:
compcolbgr = literal_eval(compcol)
compcolor = sRGBColor(compcolbgr[0], compcolbgr[1], compcolbgr[2], is_upscaled=True)
compcolor_lab = convert_color(compcolor, LabColor)
delta = delta_e_cie2000(color_lab, compcolor_lab)
if ( delta < radius ):
self.dataframe[col].fillna(self.dataframe[compcol], inplace=True)
del self.dataframe[compcol]
cols.remove(compcol)
# Clean up dataframe (sorting columns, setting NaN to 0)
#self.dataframe.sort_index(inplace=True)
self.dataframe.fillna(0, inplace=True)
self.dataframe = self.dataframe.reindex_axis(sorted(self.dataframe.columns, key=lambda x: self.dataframe[x].sum(), reverse=True), axis=1)
def colorCloseEnough(color1, color2):
rgb1 = sRGBColor(color1[0], color1[1], color1[2])
rgb2 = sRGBColor(color2[0], color2[1], color2[2])
lab1 = convert_color(rgb1, LabColor)
lab2 = convert_color(rgb2, LabColor)
return delta_e_cie1976(lab1, lab2) < 5000
def get_colors(infile, outfile, numcolors=256, swatchsize=10, resize=150):
image = Image.open(infile)
image = image.resize((resize, resize))
result = image.convert('P', palette=Image.ADAPTIVE, colors=numcolors)
result.putalpha(0)
colors = result.getcolors(resize*resize)
hslcolors = map(lambda x: convert_color(sRGBColor(x[1][0], x[1][1], x[1][2], is_upscaled=True), HSLColor), colors)
hslcolors = sorted(hslcolors, key=lambda c: c.hsl_s)
hslcolors = sorted(hslcolors, key=lambda c: c.hsl_h)
hslcolors = map(lambda c: HSLColor(c.hsl_h, 0.5 + 0.5 * c.hsl_s, 0.55 + 0.15 * c.hsl_l), hslcolors)
hslcolors = map(lambda x: convert_color(x, sRGBColor).get_upscaled_value_tuple(), hslcolors)
# Save colors to file
pal = Image.new('RGB', (swatchsize*numcolors, swatchsize * 20))
draw = ImageDraw.Draw(pal)
posx = 0
for col in hslcolors:
draw.rectangle([posx, 0, posx+swatchsize, swatchsize * 20], fill=col)
posx = posx + swatchsize
del draw
pal.save(outfile, "PNG")
print "palettes.append(%s)" % str(hslcolors)
def distance(c1, c2):
"""
Calculate the visual distance between the two colors.
"""
return delta_e_cmc(
convert_color(sRGBColor(*c1, is_upscaled=True), LabColor),
convert_color(sRGBColor(*c2, is_upscaled=True), LabColor)
)
def color_diff(color_1, color_2):
# Red Color 6
color1_rgb = sRGBColor(color_1[0], color_1[1], color_1[2])
# Blue Color 9
color2_rgb = sRGBColor(color_2[0], color_2[1], color_2[2])
# Convert from RGB to Lab Color Space 12
color1_lab = convert_color(color1_rgb, LabColor)
# Convert from RGB to Lab Color Space 15
color2_lab = convert_color(color2_rgb, LabColor)
# Find the color difference 18
delta_e = delta_e_cie2000(color1_lab, color2_lab)
return delta_e
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)
c1RGB = sRGBColor(a[0], a[1], a[2])
c2RGB = sRGBColor(b[0], b[1], b[2])
c1Lab = convert_color(c1RGB, LabColor)
c2Lab = convert_color(c2RGB, LabColor)
#c1.convert_to('lab')
#c2.convert_to('lab')
print(delta_e_cie2000(c1Lab, c2Lab))
return delta_e_cie2000(c1Lab, c2Lab)
def colordiff_lab(pixel1,pixel2): #convert rgb values to L*ab values rgb_pixel_1=sRGBColor(pixel1[0],pixel1[1],pixel1[2],True) lab_1= convert_color(rgb_pixel_1, LabColor) rgb_pixel_2=sRGBColor(pixel2[0],pixel2[1],pixel2[2],True) lab_2= convert_color(rgb_pixel_2, LabColor) #calculate delta e delta_e = delta_e_cie1976(lab_1, lab_2) return delta_e
def dynamic_binning(self, radius):
"""
This function applies the dynamic color binning algorithm to the
ColorList. This algorithm sorts the colors by pixel count. Selecting
the most prominent color, it searches the rest of the list for similar
(i.e. within a distance <radius> in Lab color space) colors and adds
the pixel counts of those colors to that of the prominent color, thus
binning together similar colors. In this way it goes down the list
until all colors present have been binned.
The function returns a new ColorList object, as well as a dictionary
that tells the user which colors have been binned together. This
dictionary is of the form {major_color: [list, of, minor, colors]}.
"""
colorlist = self.colorlist
clustered_colorlist = []
synonymous_colors = {}
for color in colorlist:
color_copy = color
synonymous_colors[tuple(color[0:2])] = []
# Store color as Lab-color
color_rgb = sRGBColor(color[0], color[1], color[2], is_upscaled=True)
color_lab = convert_color(color_rgb, LabColor)
# Loop through all the colors that are less prominent than the current color
for color_compare in colorlist[colorlist.index(color)+1:]:
# Store color as Lab-color
color_compare_rgb = sRGBColor(color_compare[0], color_compare[1], color_compare[2], is_upscaled=True)
color_compare_lab = convert_color(color_compare_rgb, LabColor)
# Calculate the distance in color space
delta = delta_e_cie2000(color_lab, color_compare_lab)
# If distance is smaller than threshold, label as similar
if ( delta < radius ):
# Add up pixel counts
color_copy[3] += color_compare[3]
# Remove color from the list we are looping over
colorlist.remove(color_compare)
synonymous_colors[tuple(color[0:2])].append(color_compare[0:2])
# Add color with updated pixel count to new list
clustered_colorlist.append(color_copy)
clustered_colorlist.sort(key=lambda tup: tup[3], reverse=True)
BinnedColorList = ColorList.from_list(clustered_colorlist)
return BinnedColorList, synonymous_colors
def colordiff_lab(pixel1,pixel2): #convert rgb values to L*ab values rgb_pixel_source=sRGBColor(pixel1[0],pixel1[1],pixel1[2],True) lab_source= convert_color(rgb_pixel_source, LabColor) rgb_pixel_palette=sRGBColor(pixel2[0],pixel2[1],pixel2[2],True) lab_palette= convert_color(rgb_pixel_palette, LabColor) #calculate delta e delta_e = delta_e_cie1976(lab_source, lab_palette) return delta_e
def colordiff_lab(source_pixel,palette_pixel): #convert rgb values to L*ab values rgb_pixel_source=sRGBColor(source_pixel[0],source_pixel[1],source_pixel[2],True) lab_source= convert_color(rgb_pixel_source, LabColor) rgb_pixel_palette=sRGBColor(palette_pixels[0],palette_pixels[1],palette_pixels[2],True) lab_palette= convert_color(rgb_pixel_palette, LabColor) #calculate delta e delta_e = delta_e_cie1976(lab_source, lab_palette) return delta_e
def test_conversion_through_rgb(self):
"""
Make sure our convenience RGB tracking feature is working. For example,
going from XYZ->HSL via Adobe RGB, then taking that HSL object and
converting back to XYZ should also use Adobe RGB (instead of the
default of sRGB).
"""
xyz = convert_color(self.color, XYZColor)
hsl = convert_color(xyz, HSLColor, through_rgb_type=AdobeRGBColor)
# Notice how we don't have to pass through_rgb_type explicitly.
xyz2 = convert_color(hsl, XYZColor)
self.assertColorMatch(xyz, xyz2)
def combinecolors(c1, c2, firstweight):
firstweight = random.uniform(0.25, 0.75)
# extra chance to make it lopsided
if random.random() < 0.5:
firstweight = firstweight / random.uniform(2, 4)
secondweight = 1-firstweight
c = sRGBColor(c1[0], c1[1], c1[2], is_upscaled = True)
c2 = sRGBColor(c2[0], c2[1], c2[2], is_upscaled = True)
hsl1 = color_conversions.convert_color(c, HSLColor)
hsl2 = color_conversions.convert_color(c2, HSLColor)
hue1 = hsl1.hsl_h
hue2 = hsl2.hsl_h
# jank recombination of hue
# make hue2 the greater one
if hue2 > hue1:
temp = hue1
hue1 = hue2
hue2 = temp
# shrink green region to make recombination work- green is from 75 to 150
recombinecount = 0
if hue1 > 75:
subtract = min((hue1-75), 25)
hue1 = hue1 - subtract
recombinecount += 1
if hue2 > 75:
subtract = min((hue2-75), 25)
hue2 = hue2 - subtract
recombinecount += 1
new_hue = circle_ave(hue1, hue2, circlerange = 360-25)
# add both if it was found on the greater side of the circle
if new_hue > hue2 and recombinecount > 0:
recombinecount = 2
# convert back with green
if new_hue > 75:
new_hue = new_hue + (min(new_hue-75, 25)/2) * recombinecount
new_hsl = HSLColor(new_hue,
hsl1.hsl_s*firstweight+hsl2.hsl_s*(1-firstweight),
hsl1.hsl_l*firstweight+hsl2.hsl_l*(1-firstweight))
rgb = color_conversions.convert_color(new_hsl, sRGBColor)
pygame_rgb = (int(rgb.rgb_r * 255), int(rgb.rgb_g * 255), int(rgb.rgb_b * 255))
return pygame_rgb
def recolor(self):
from_lab = convert_color(sRGBColor(*self.from_color), LabColor)
from_hsv = convert_color(sRGBColor(*self.from_color), HSVColor)
self._to_lab = convert_color(sRGBColor(*self.to_color), LabColor)
range_ = self.range
from_r, from_g, from_b = self.from_color
to_r, to_g, to_b = self.to_color
width, height = self.image.width, self.image.height
pixel_count = width * height
source_pixels = numpy.asarray(self.image)
result_image = PIL.Image.new('RGB', (width, height), "black")
target_pixels = result_image.load()
pixels_done = 0
for i in range(width):
for j in range(height):
r, g, b = source_pixels[j, i]
hsv_pixel = convert_color(sRGBColor(r, g, b), HSVColor)
distance = barkovsky_distance_3000(hsv_pixel, from_hsv)
#distance = delta_e_cie2000(lab_pixel, from_lab)
# distance = math.sqrt(
# (r - from_r) ** 2 +
# (g - from_g) ** 2 +
# (b - from_b) ** 2
# )
pixels_done += 1
if pixels_done % 10000 == 0:
print('%d%%' % (pixels_done / pixel_count * 100))
if distance > range_:
target_pixels[i, j] = (r, g, b)
continue
r_diff = r - from_r
g_diff = g - from_g
b_diff = b - from_b
r_new = cap_number(to_r + r_diff, 0, 255)
g_new = cap_number(to_g + g_diff, 0, 255)
b_new = cap_number(to_b + b_diff, 0, 255)
target_pixels[i, j] = (
int(r_new), int(g_new), int(b_new)
)
self.set_result_image(result_image)
def distinguishable_colors(n_colors):
import numpy as np
from colormath.color_objects import sRGBColor, LabColor
from colormath.color_conversions import convert_color
from matplotlib.colors import rgb2hex
bg = [1,1,1] #Assumes background is white
#Generate 30^3 RGB triples to choose from.
n_grid = 30
x = np.linspace(0,1,n_grid)
R = np.array([x]*900).flatten()
G = np.array([[i]*30 for i in x]*30).flatten()
B = np.array([[i]*900 for i in x]).flatten()
rgb = np.array([R,G,B]).T #27000 by 3 matrix
if n_colors > len(rgb)/3: #>27000
print "You can't distinguish that many colors, dingus"
return None
#Convert to Lab colorspace
lab = np.array([list(convert_color(sRGBColor(i[0], i[1], i[2]), LabColor).get_value_tuple()) for i in rgb])
bglab = list(convert_color(sRGBColor(bg[0], bg[1], bg[2]), LabColor).get_value_tuple())
#Compute the distance from background to candicate colors
arr_length = len(rgb)
mindist2 = np.empty(arr_length)
mindist2.fill(float('Inf'))
dX = lab - bglab
dist2 = np.sum(np.square(dX), axis=1)
mindist2 = np.minimum(dist2, mindist2)
#Pick the colors
colors = np.zeros((n_colors, 3))
lastlab = bglab
for i in range(n_colors):
dX = lab - lastlab #subtract last from all colors in the list
dist2 = np.sum(np.square(dX), axis=1)
mindist2 = np.minimum(dist2, mindist2)
index = np.argmax(mindist2)
colors[i] = rgb[index]
lastlab = lab[index]
hex_colors = [rgb2hex(item) for item in colors]
return hex_colors
def rgb2is(red, green, blue, colorsdb, nbest):
colors = json.loads(open(colorsdb, 'r').read())
color1_rgb = sRGBColor(red, green, blue, is_upscaled=True);
color1_lab = convert_color(color1_rgb, LabColor);
result = []
for name, value in colors.items():
color2_rgb = sRGBColor(*value, is_upscaled=True);
color2_lab = convert_color(color2_rgb, LabColor);
delta_e = delta_e_cie2000(color1_lab, color2_lab);
result.append((delta_e, name))
for res in sorted(result)[:nbest]:
print('{1}, delta = {0}'.format(*res))
def color_contrast(img):
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = img.reshape((img.shape[0] * img.shape[1], 3))
clt = KMeans(n_clusters = 3)
clt.fit(img)
color_centroids = [sRGBColor(r, g, b) for (r, g, b) in clt.cluster_centers_]
color_diff = 0.0
for (color_a, color_b) in combinations(color_centroids, 2):
color_a_lab = convert_color(color_a, LabColor);
color_b_lab = convert_color(color_b, LabColor);
delta_e = delta_e_cie2000(color_a_lab, color_b_lab)
color_diff += delta_e
return float(color_diff/3)
def avg_delta_e_2000(main1, tail1, main2, tail2):
rgb_main1 = sRGBColor(main1[0], main1[1], main1[2])
rgb_main2 = sRGBColor(main2[0], main2[1], main2[2])
rgb_tail1 = sRGBColor(tail1[0], tail1[1], tail1[2])
rgb_tail2 = sRGBColor(tail2[0], tail2[1], tail2[2])
lab_main1 = convert_color(rgb_main1, LabColor)
lab_main2 = convert_color(rgb_main2, LabColor)
lab_tail1 = convert_color(rgb_tail1, LabColor)
lab_tail2 = convert_color(rgb_tail2, LabColor)
main_deltae = delta_e_cie2000(lab_main1, lab_main2)
tail_deltae = delta_e_cie2000(lab_tail1, lab_tail2)
pair_deltae = numpy.array([main_deltae, tail_deltae])
return numpy.average(pair_deltae, weights=[main_weight, tail_weight])
def _kmeans_once(X, k, maxiter=1000, random_seed=None, verbose=False):
centroids = _init_centroids(X,k,random_seed)
labels, WCSS = _assign_cluster(X, centroids)
for iter in range(maxiter):
print "Iteration ", iter
new_centroids = _update_clusters(X, labels, k)
labels, WCSS = _assign_cluster(X, new_centroids)
if (verbose): print new_centroids
if (new_centroids[0].get_value_tuple() == centroids[0].get_value_tuple() and \
new_centroids[1].get_value_tuple() == centroids[1].get_value_tuple() and \
new_centroids[2].get_value_tuple() == centroids[2].get_value_tuple()):
break
centroids = new_centroids
if (verbose):
print "Converged in ", iter, "iterations"
print centroids
# Return centroids converted back to RGB
centroidsRGB = [convert_color(centroid, sRGBColor).get_value_tuple() for centroid in centroids]
return labels, centroidsRGB, WCSS
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 example_spectral_to_xyz():
"""
Instantiate an Lab color object with the given values. Note that the
spectral range can run from 340nm to 830nm. Any omitted values assume a
value of 0.0, which is more or less ignored. For the distribution below,
we are providing an example reading from an X-Rite i1 Pro, which only
measures between 380nm and 730nm.
"""
print("=== Example: Spectral->XYZ ===")
spc = SpectralColor(
observer='2', illuminant='d50',
spec_380nm=0.0600, spec_390nm=0.0600, spec_400nm=0.0641,
spec_410nm=0.0654, spec_420nm=0.0645, spec_430nm=0.0605,
spec_440nm=0.0562, spec_450nm=0.0543, spec_460nm=0.0537,
spec_470nm=0.0541, spec_480nm=0.0559, spec_490nm=0.0603,
spec_500nm=0.0651, spec_510nm=0.0680, spec_520nm=0.0705,
spec_530nm=0.0736, spec_540nm=0.0772, spec_550nm=0.0809,
spec_560nm=0.0870, spec_570nm=0.0990, spec_580nm=0.1128,
spec_590nm=0.1251, spec_600nm=0.1360, spec_610nm=0.1439,
spec_620nm=0.1511, spec_630nm=0.1590, spec_640nm=0.1688,
spec_650nm=0.1828, spec_660nm=0.1996, spec_670nm=0.2187,
spec_680nm=0.2397, spec_690nm=0.2618, spec_700nm=0.2852,
spec_710nm=0.2500, spec_720nm=0.2400, spec_730nm=0.2300)
xyz = convert_color(spc, XYZColor)
print(xyz)
print("=== End Example ===\n")
def print_color(color):
if type(color) is int:
colstr = '5;' + str(color)
else:
rgb = convert_color(color, sRGBColor)
colstr = '2;' + ';'.join((str(i) for i in get_upscaled_values(rgb)))
sys.stdout.write('\033[48;' + colstr + 'm ')
def named_colorset(colorfile):
"""From a file, generate a set of named color objects"""
colorset = json.load(open(colorfile))
for color in colorset['colors']:
cobj = convert_color(sRGBColor.new_from_rgb_hex(color['hex']), LabColor)
color['obj'] = cobj
return colorset['colors']
def get_lab(name, rgb): rgb = sRGBColor( int(rgb[:2], 16), int(rgb[2:4], 16), int(rgb[4:6], 16), is_upscaled=True ) lab = convert_color(rgb, LabColor) return name, lab
def to_Lab(color):
from colormath.color_objects import LabColor, sRGBColor
from colormath.color_conversions import convert_color
return convert_color(
sRGBColor(*color, is_upscaled=True),
LabColor
).get_value_tuple()
def _rgb_to_lab(rgb):
orgb = sRGBColor(rgb[0], rgb[1], rgb[2])
orgb.is_upscaled = False
r = convert_color(orgb, LabColor).get_value_tuple()
if not np.all(np.isfinite(r)):
raise ValueError('Found non finite values in input rgb tuple {} '.format(rgb))
return r
def createcolors(min_colors, max_colors):
"""Creates some random colors and saves them to the DB."""
from colorsearchtest.database import db
from colorsearchtest.models import Color
from colormath.color_conversions import convert_color
from colormath.color_objects import sRGBColor, LabColor
# Based on:
# https://github.com/kevinwuhoo/randomcolor-py/blob/master/test_randomcolor.py
import randomcolor
import random
rand_color = randomcolor.RandomColor()
rand = random.Random()
rand_int = lambda: rand.randint(min_colors, max_colors)
i = rand_int()
colors = rand_color.generate(count=i, format_='rgbArray')
for x in colors:
c_rgb = sRGBColor(rgb_r=x[0], rgb_g=x[1], rgb_b=x[2],
is_upscaled=True)
c_lab = convert_color(c_rgb, LabColor)
c = Color(rgb_r=x[0], rgb_g=x[1], rgb_b=x[2],
lab_l=c_lab.lab_l, lab_a=c_lab.lab_a, lab_b=c_lab.lab_b)
db.session.add(c)
db.session.commit()
return i
def __init__(self, palette: str="palette.bin", distinguishing: float=5.0):
""" Constructor.
:param palette:
:param distinguishing:
"""
self.distinguish = distinguishing
self.colorList = []
self.labColorList = []
self.lBound, self.uBound = 0.0, 0.0
persistence = shelve.open(palette)
_colorList = persistence['data']
for colorTuple in _colorList:
color = sRGBColor(colorTuple[0], colorTuple[1], colorTuple[2])
self.colorList.append(color)
self.labColorList.append(convert_color(color, LabColor))
persistence.close()
self.colorsCount = len(self.colorList)
for i in range(self.colorsCount):
for j in range(i, self.colorsCount):
distance = delta_e_cmc(self.labColorList[i], self.labColorList[j])
self.lBound = min(self.lBound, distance)
self.uBound = max(self.uBound, distance)
def find_color_code_by_color_distance(r, g, b, algorithm='delta_e_cie2000'):
"""
:param r:
:param g:
:param b:
:param algorithm:
:return: tuple(sRGBColor, color_code)
"""
color = sRGBColor(r, g, b)
lab_color = convert_color(color, LabColor)
distances = [algorithms[algorithm](lab_color, convert_color(x[0], LabColor)) for x in color_wheel]
np_distances = np.array(distances)
idx = np.argmin(np_distances)
ans_color = color_wheel[idx][0]
return convert_color(ans_color, sRGBColor).get_value_tuple(), (color_wheel[idx][1], color_wheel[idx][2])
def worker(gridwork):
ret = []
predefinedcolors = False
if len(gridwork.beadlist):
predefinedcolors = True
ravg, gavg, bavg = 0, 0, 0
blockpixels = gridwork.xgrid*gridwork.ygrid
offset=0
for y in range(0,gridwork.ygrid):
for x in range(0,gridwork.xgrid):
travg, tgavg, tbavg = gridwork.region[offset]
ravg+=travg
gavg+=tgavg
bavg+=tbavg
offset+=1
nr, ng, nb = (ravg/blockpixels), (gavg/blockpixels), (bavg/blockpixels)
if predefinedcolors:
index = gridwork.beadlist.keys()[0]
if gridwork.fastcolor:
closest = colordistance((nr, ng, nb), (gridwork.beadlist[index][0], gridwork.beadlist[index][1], gridwork.beadlist[index][2]))
else:
rgblab = convert_color(sRGBColor( nr, ng, nb), LabColor)
closest = delta_e_cie2000(rgblab, convert_color(sRGBColor( gridwork.beadlist[index][0], gridwork.beadlist[index][1], gridwork.beadlist[index][2] ), LabColor))
for key in gridwork.beadlist:
hr = gridwork.beadlist[key][0]
hg = gridwork.beadlist[key][1]
hb = gridwork.beadlist[key][2]
if fastcolor:
delta = colordistance((nr, ng, nb), (hr, hg, hb))
else:
beadlab = convert_color(sRGBColor( hr, hg, hb ), LabColor)
delta = delta_e_cie2000(rgblab, beadlab)
if delta < closest:
index = key
closest = delta
nr, ng, nb = gridwork.beadlist[index][0], gridwork.beadlist[index][1], gridwork.beadlist[index][2]
gridwork.color = (nr, ng, nb)
ret.append((gridwork.color,gridwork.box))
return ret
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 scaledRGBTupleToHSL(s):
rgb = sRGBColor(s[0], s[1], s[2], True)
return convert_color(rgb, HSLColor)
def matchValues(hash, R, B, G):
log("Attempting API request on /match/%s/%d/%d/%d" % (hash, R, G, B), True)
redisVidHashToImageHash = redis.Redis(host=redisHost,
db=1,
decode_responses=True)
redisImgHashToTimestamp = redis.Redis(host=redisHost,
db=2,
decode_responses=True)
redisImageHashToColorPalette = redis.Redis(host=redisHost,
db=3,
decode_responses=True)
imageList = sorted(list(redisVidHashToImageHash.smembers(hash)),
key=lambda item: int(redisImgHashToTimestamp.get(item)))
if len(imageList) == 0:
response = {
"message":
"No color palettes matched for the specified color and hash. Either hash does not exist or server is not done processing"
}
response_pickled = jsonpickle.encode(response)
log(
'POST /match/%s/%d/%d/%d HTTP/1.1 200 - No Images' %
(hash, R, G, B), True)
return Response(response=response_pickled,
status=200,
mimetype="application/json")
R /= 255.0
G /= 255.0
B /= 255.0
color1_rgb = sRGBColor(R, G, B)
# Convert from RGB to Lab Color Space
color1_lab = convert_color(color1_rgb, LabColor)
toPlot = [False] * len(imageList)
buf = io.BytesIO()
subplt = 0
for imageHash in imageList:
#Get color centers from redis db
centers = [
i.split(' ')
for i in redisImageHashToColorPalette.get(imageHash).split(',')
]
centers = np.array([np.array([float(n) for n in i]) for i in centers])
for RGB in centers:
color2_rgb = sRGBColor(RGB[0], RGB[1], RGB[2])
# Convert from RGB to Lab Color Space
color2_lab = convert_color(color2_rgb, LabColor)
# Find the color difference
delta_e = delta_e_cie2000(color1_lab, color2_lab)
print(delta_e)
if delta_e <= 10:
toPlot[subplt] = True
subplt += 1
numToPlot = np.sum(toPlot)
fig, axs = plt.subplots(numToPlot * 2,
figsize=(14,
14 if numToPlot == 0 else numToPlot * 14))
subplt = 0
n = 0
for imageHash in imageList:
if toPlot[n]:
centers = [
i.split(' ')
for i in redisImageHashToColorPalette.get(imageHash).split(',')
]
centers = np.array(
[np.array([float(n) for n in i]) for i in centers])
img = downloadFromGCS(imageHash,
'csci4253finalproject',
'%s/%s' % (hash, imageHash),
file_perms='w+b')
#Plot the image
axs[subplt].imshow(np.array(Image.open(img)))
axs[subplt].grid()
axs[subplt].set_title("Timestamp: %s ms" %
(redisImgHashToTimestamp.get(imageHash)),
fontsize=40)
axs[subplt].axis('off')
subplt += 1
# Plot the palette
axs[subplt].imshow(centers[np.concatenate(
[[i] * 100 for i in range(len(centers))]).reshape((-1, 10)).T])
axs[subplt].grid()
axs[subplt].axis('off')
subplt += 1
img.close()
os.remove(img.name)
n += 1
plt.savefig(buf, format='jpg')
buf.seek(0)
log('GET /match/%s/%d/%d/%d HTTP/1.1 200' % (hash, R, G, B), True)
return send_file(buf,
mimetype='image/jpg',
as_attachment=False,
attachment_filename='results_%s.jpg' % hash)
def staticGold(): gold = sRGBColor(255, 200, 0) gold = convert_color(gold, LabColor) return gold
print("Avg pixel intensity on right face : ", calcAvgPixel(right_face))
# Calculate the avg pixel of each half face
r1, g1, b1 = calcAvgPixel(left_face)
r2, g2, b2 = calcAvgPixel(right_face)
color1_rgb = sRGBColor(r1, g1, b1)
color2_rgb = sRGBColor(r2, g2, b2)
# Convert from RGB to Lab Color Space
color1_lab = convert_color(color1_rgb, LabColor)
color2_lab = convert_color(color2_rgb, LabColor)
# Find the color difference
delta_e = delta_e_cie2000(color1_lab, color2_lab)
print("The difference between the 2 color = ", delta_e)
# Impose a threshold either from user or hard-coded
# threshold = int(input("Enter a threshold: "))
threshold = 25
if delta_e > threshold:
print("Asymmetry exists!")
outputCl = outputBlockStart[1] + cl
if (outputRw < args.outputSize
and outputCl < args.outputSize):
nextVertOverlap[rw, cl] = output[outputRw, outputCl]
#convert vertical rgb color space to lab color space
if (cb > 0):
for rw in range(blockWidth):
for cl in range(args.overlap):
prevValues = prevVertOverlap[rw, cl]
nextValues = nextVertOverlap[rw, cl]
prevRGB = sRGBColor(prevValues[0], prevValues[1],
prevValues[2])
nextRGB = sRGBColor(nextValues[0], nextValues[1],
nextValues[2])
prevLab = convert_color(prevRGB, LabColor)
nextLab = convert_color(nextRGB, LabColor)
left = min(args.overlap - 1, cl + 1)
right = max(0, cl - 1)
if (rw == 0):
diffVertOverlap[rw, cl] = delta_e_cie1976(
prevLab, nextLab)
else:
diffVertOverlap[rw, cl] = delta_e_cie1976(
prevLab, nextLab) + min(
diffVertOverlap[rw - 1, right],
diffVertOverlap[rw - 1, cl],
diffVertOverlap[rw - 1, left])
#calculate vertical minimum boundary cut
if (cb > 0):
def staticred(): redbar = sRGBColor(148, 100, 116) redbar = convert_color(redbar, LabColor) return redbar
def getColor(id):
color = HSVColor(id * 60 % 360, 150, 200)
return np.array(
convert_color(color, sRGBColor).get_value_tuple()
) / 255.0 # FIXME: This is bgr color
def grab_vis_params(self, index, get_op_img=False):
with open(self.inputs_dir + self.input_files[index]) as input_file:
all_inputs = np.array([float(val.rstrip()) for val in input_file])
# setup view params
view_params = np.zeros(5)
view_params[0] = 2.0 * (
(all_inputs[0] - self.min_elevation) /
(self.max_elevation - self.min_elevation)) - 1.0
view_params[1] = np.cos(np.deg2rad(all_inputs[1]))
view_params[2] = np.sin(np.deg2rad(all_inputs[1]))
view_params[3] = all_inputs[2] / self.roll_range
view_params[4] = 2.0 * ((all_inputs[3] - self.min_zoom) /
(self.max_zoom - self.min_zoom)) - 1.0
# next, grab the opacity TF
verbose_op_func = np.reshape(all_inputs[4:(4 + 2 * self.tf_res)],
(self.tf_res, 2))
op_tf = 2.0 * verbose_op_func[:, 1:] - 1.0
op_tf = op_tf.T
# grab the color TF
verbose_color_func = np.reshape(all_inputs[(4 + 2 * self.tf_res):],
(self.tf_res, 4))
lab_color_tf = np.array([
convert_color(sRGBColor(rgb[0], rgb[1], rgb[2]),
LabColor).get_value_tuple()
for rgb in verbose_color_func[:, 1:]
])
color_tf = np.zeros((3, self.tf_res))
color_tf[0, :] = 2.0 * ((lab_color_tf[:, 0] - self.min_lab_l) /
(self.max_lab_l - self.min_lab_l)) - 1.0
color_tf[1, :] = 2.0 * ((lab_color_tf[:, 1] - self.min_lab_a) /
(self.max_lab_a - self.min_lab_a)) - 1.0
color_tf[2, :] = 2.0 * ((lab_color_tf[:, 2] - self.min_lab_b) /
(self.max_lab_b - self.min_lab_b)) - 1.0
if get_op_img:
# and the opacity image
pil_rgba_img = Image.open(self.imgs_dir +
self.img_files[index]).convert("RGBA")
np_rgba_img = np.array(pil_rgba_img).astype(np.uint8)
np_opacity_img = np.zeros(
(np_rgba_img.shape[0], np_rgba_img.shape[1],
3)).astype(np.uint8)
np_opacity_img[:, :, 0] = np_rgba_img[:, :, 3]
np_opacity_img[:, :, 1] = np_rgba_img[:, :, 3]
np_opacity_img[:, :, 2] = np_rgba_img[:, :, 3]
if self.target_opacity_res != pil_rgba_img.width:
pil_opacity_img = Image.fromarray(np_opacity_img).resize(
(self.target_opacity_res, self.target_opacity_res),
resample=PIL.Image.BICUBIC)
else:
pil_opacity_img = Image.fromarray(np_opacity_img)
target_opacity_img = np.array(pil_opacity_img,
dtype=np.float32) / 255.0
target_opacity_img = np.swapaxes(target_opacity_img[:, :, 0:1].T,
axis1=1,
axis2=2)
return view_params, op_tf, color_tf, target_opacity_img
else:
return view_params, op_tf, color_tf
def lab2rgb(pt):
return convert_color(LabColor(pt[0], pt[1], pt[2]),
sRGBColor).get_value_tuple()
def rgb_error(self):
return delta_e_cie2000(
convert_color(self.m_lch, LabColor),
convert_color(sRGBColor.new_from_rgb_hex(self.rgb()), LabColor))
def get_rgb_colors(self):
"""Return a dictionary of sRGB color objects (not just coordinates)."""
return {
name: Palette.clamp_rgb_color(convert_color(lab, sRGBColor))
for name, lab in self.get_lab_colors().items()
}
def rgb(self):
rgb = convert_color(self.m_lch, sRGBColor)
if (rgb.rgb_r != rgb.clamped_rgb_r or rgb.rgb_g != rgb.clamped_rgb_g
or rgb.rgb_b != rgb.clamped_rgb_b):
raise Exception("Colour {} is outside sRGB".format(self.lch()))
return rgb.get_rgb_hex()
def get_mask_contours(image, monsters_in_image, debug=False):
imgray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(imgray, 5, 255, 0)
contours, _ = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
monster_contours = {}
for i in range(len(contours)):
# Create a mask image that contains the contour filled in
cimg = np.zeros_like(imgray)
cv2.drawContours(cimg, contours, i, color=255, thickness=-1)
ret, thresh = cv2.threshold(cimg, 5, 255, 0)
# Access the image pixels and create a 1D numpy array then add to list
pts = np.where(cimg == 255)
if len(pts[0]) < 500:
continue
counts = defaultdict(lambda: 0)
for c in image[pts[0], pts[1]]:
counts[tuple(c)] += 1
unique_bgrs = [k for k in counts.keys() if counts[k] > 100]
colors_per_monster = defaultdict(lambda: [])
for bgr in unique_bgrs:
closest_color = ()
min_dist = 500000
# Compute the closest color using the delta E metric
# http://hanzratech.in/2015/01/16/color-difference-between-2-colors-using-python.html
for color in monster_colors.keys():
if monster_colors[color] not in monsters_in_image:
continue
pixel_color = sRGBColor(bgr[2]/255, bgr[1]/255, bgr[0]/255)
monster_color = sRGBColor(color[0]/100, color[1]/100, color[2]/100)
# Convert from RGB to Lab Color Space
pixel_color_lab = convert_color(pixel_color, LabColor)
monster_color_lab = convert_color(monster_color, LabColor)
delta_e = delta_e_cie2000(pixel_color_lab, monster_color_lab)
if delta_e < min_dist:
min_dist = delta_e
closest_color = color
# If the pixel is not black...
if closest_color != (0, 0, 0):
colors_per_monster[closest_color].append(bgr)
for key, colors in colors_per_monster.items():
colors = np.array(colors)
min_color = np.min(colors, axis=0)
max_color = np.max(colors, axis=0)
mask = cv2.inRange(image, min_color, max_color)
if cv2.countNonZero(mask) < 500:
continue
masked = cv2.bitwise_and(thresh, thresh, mask=mask)
blurred = cv2.GaussianBlur(masked, (7, 7), 0)
sub_contours, _ = cv2.findContours(blurred, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
monster_contours[key] = sorted(sub_contours, key=lambda x: -cv2.contourArea(x))[0]
if debug:
cv2.imshow(str(key), masked)
if debug:
cv2.waitKey(0)
cv2.destroyAllWindows()
return monster_contours
vector_list1 = []
vector_list2 = []
for t in test_pic:
#line_vector存放一行的向量，vector_test存放一张图片的向量，vector_list1存放所有test图片的向量
vector_test = []
img1 = cv2.imread(pic_tests_dir + t, cv2.IMREAD_COLOR)
#测试集图像不一定是400*400，所以要转换
img1 = cv2.resize(img1, (50, 50), interpolation=cv2.INTER_CUBIC)
print(t, 'is loading..........')
for i in range(img1.shape[0]):
line_vector = []
for j in range(img1.shape[1]):
#rgb转xyz转lab
rgb1 = sRGBColor(img1[i][j][0], img1[i][j][1], img1[i][j][2])
xyz1 = convert_color(rgb1, XYZColor)
lab1 = convert_color(xyz1, LabColor, target_illuminant=str)
line_vector.append(lab1)
vector_test.append(line_vector)
vector_list1.append(vector_test)
print('train_set loading complete!!!')
for c in colors:
vector = []
img2 = cv2.imread(pic_dir + c, cv2.IMREAD_COLOR)
img2 = cv2.resize(img2, (50, 50), interpolation=cv2.INTER_CUBIC)
print(c, 'is loading..........')
for i in range(img2.shape[0]):
line_vector_2 = []
for j in range(img2.shape[1]):
def _ipt_conversion():
return convert_color(xyz, IPTColor)
def test_conversion_to_xyz(self):
xyz = convert_color(self.color, XYZColor)
self.assertColorMatch(xyz, XYZColor(0.115, 0.099, 0.047))
def test_consistency(self):
xyz = convert_color(self.color, XYZColor)
same_color = convert_color(xyz, IPTColor)
self.assertColorMatch(self.color, same_color)
def test_convert_to_self(self):
same_color = convert_color(self.color, SpectralColor)
self.assertEqual(self.color, same_color)
def test_convert_to_XYZ(self):
xyz = convert_color(self.color, XYZColor)
self.assertColorMatch(
xyz,
XYZColor(0.4497, 0.2694, 0.0196, illuminant="d65", observer="2"))
def isWhite(pix): color = sRGBColor(*(pix)) color = convert_color(color, LabColor) similarity = delta_e_cie2000(color,statusWhite) return similarity
def test_convert_so_self(self):
same_color = convert_color(self.color, IPTColor)
self.assertEqual(self.color, same_color)
def isred(pix): color = sRGBColor(*(pix)) color = convert_color(color, LabColor) similarity = delta_e_cie2000(color, minigame_red) return similarity
def test_convert_to_self(self):
same_color = convert_color(self.color, CMYKColor)
self.assertEqual(self.color, same_color)
def staticWhite(): white = sRGBColor(255, 255, 255) white = convert_color(white, LabColor) return white
def get_difference(rgb1, rgb2):
lab1 = convert_color(rgb1, LabColor)
lab2 = convert_color(rgb2, LabColor)
delta = delta_e_cie2000(lab1, lab2)
return delta
def HSLToScaledRGBTuple(hsl):
return convert_color(hsl, sRGBColor).get_upscaled_value_tuple()
def distinguishable_colors(ncolors,
backgrounds=[[0, 0, 0], [1, 1, 1]],
save_csv=True,
plot_colormap=True,
verbose=True,
out_dir='.'):
"""
Create a colormap of perceptually distinguishable colors.
This program is a Python program based on Tim Holy's 2010-2011
BSD-licensed Matlab program "distinguishable_colors.m"
(https://www.mathworks.com/matlabcentral/fileexchange/
29702-generate-maximally-perceptually-distinct-colors):
"This function generates a set of colors which are distinguishable
by reference to the "Lab" color space, which more closely matches
human color perception than RGB. Given an initial large list of possible
RGB colors, it iteratively chooses the entry in the list that is farthest
(in Lab space) from all previously-chosen entries. While this "greedy"
algorithm does not yield a global maximum, it is simple and efficient.
Moreover, the sequence of colors is consistent no matter how many you
request, which facilitates the users' ability to learn the color order
and avoids major changes in the appearance of plots when adding or
removing lines."
Parameters
----------
ncolors : integer
number of colors for the colormap
backgrounds : list of list(s) of 3 elements between 0 and 1
rgb background colors to initialize and distinguish from
save_csv : Boolean
save colormap as csv file?
plot_colormap : Boolean
plot colormap as horizontal bar chart?
verbose : Boolean
print to stdout?
Returns
-------
colors : numpy ndarray of ndarrays of 3 floats between 0 and 1
rgb colormap
Examples
--------
>>> from mindboggle.mio.colors import distinguishable_colors
>>> ncolors = 31
>>> backgrounds = [[0,0,0],[1,1,1]]
>>> save_csv = False
>>> plot_colormap = False
>>> verbose = False
>>> colors = distinguishable_colors(ncolors, backgrounds,
... save_csv, plot_colormap, verbose)
>>> colors[0]
array([ 0.62068966, 0.06896552, 1. ])
>>> colors[1]
array([ 0. , 0.5862069, 0. ])
>>> colors[2]
array([ 0.75862069, 0.20689655, 0. ])
"""
import numpy as np
import matplotlib.pyplot as plt
from colormath.color_objects import LabColor, AdobeRGBColor
from colormath.color_conversions import convert_color
from colormath.color_diff import delta_e_cie2000
filename = "colormap_of_{0}_distinguishable_colors".format(ncolors)
filename = os.path.join(out_dir, filename)
# ------------------------------------------------------------------------
# Generate a sizable number of RGB triples. This represents our space of
# possible choices. By starting in RGB space, we ensure that all of the
# colors can be generated by the monitor:
# ------------------------------------------------------------------------
n_grid = 30 # number of grid divisions along each axis in RGB space
x = np.linspace(0, 1, num=n_grid, endpoint=True)
R, G, B = np.meshgrid(x, x, x)
ncolors_total = np.size(R)
RGB = np.vstack([np.ravel(R), np.ravel(G), np.ravel(B)])
RGB = [[RGB[0][icolor], RGB[1][icolor], RGB[2][icolor]]
for icolor in range(ncolors_total)]
if ncolors > ncolors_total:
raise IOError("You can't readily distinguish that many colors")
# ------------------------------------------------------------------------
# Convert to Lab color space which better represents human perception:
# ------------------------------------------------------------------------
# https://python-colormath.readthedocs.io/en/latest/illuminants.html
lab_colors = []
for rgb in RGB:
lab = convert_color(AdobeRGBColor(rgb[0], rgb[1], rgb[2]), LabColor)
lab_colors.append(lab)
bg_lab_colors = []
for bg_rgb in backgrounds:
bg_lab = convert_color(AdobeRGBColor(bg_rgb[0], bg_rgb[1], bg_rgb[2]),
LabColor)
bg_lab_colors.append(bg_lab)
# ------------------------------------------------------------------------
# If the user specified multiple background colors, compute differences
# between the candidate colors and the background colors:
# ------------------------------------------------------------------------
min_dx = np.inf * np.ones(ncolors_total)
if backgrounds:
for bg_lab_color in bg_lab_colors:
# Store difference from closest previously-chosen color:
for icolor_total, lab_color in enumerate(lab_colors):
dx = delta_e_cie2000(lab_color, bg_lab_color)
min_dx[icolor_total] = min(dx, min_dx[icolor_total])
# ------------------------------------------------------------------------
# Iteratively pick the color that maximizes the difference
# with the nearest already-picked color:
# ------------------------------------------------------------------------
# Initialize by making the "previous" color equal to the last background:
last_lab_color = bg_lab_colors[-1]
colors = np.zeros((ncolors, 3))
for icolor in range(ncolors):
# Find the difference of the last color from all colors on the list:
for icolor_total, lab_color in enumerate(lab_colors):
dx = delta_e_cie2000(lab_color, last_lab_color)
min_dx[icolor_total] = min(dx, min_dx[icolor_total])
# Find the entry farthest from all previously chosen colors:
imax_dx = np.argmax(min_dx)
# Store distant color:
colors[icolor] = RGB[imax_dx]
# Prepare for next iteration:
last_lab_color = lab_colors[imax_dx]
# ------------------------------------------------------------------------
# Plot the colormap as a horizontal bar chart:
# ------------------------------------------------------------------------
if plot_colormap:
if verbose:
print("RGB values:")
plt.figure(ncolors, figsize=(5, 10))
for icolor in range(ncolors):
ax = plt.subplot(ncolors, 1, icolor + 1)
plt.axis("off")
rgb = colors[icolor]
#rgb = [[rgb.rgb_r, rgb.rgb_g, rgb.rgb_b]]
if verbose:
print(rgb)
plt.barh(0, 50, 1, 0, color=rgb)
plt.savefig(filename + ".png")
if verbose:
print("Colormap image saved to {0}".format(filename + ".png"))
# ------------------------------------------------------------------------
# Save the colormap as a csv file:
# ------------------------------------------------------------------------
if save_csv:
np.savetxt(filename + ".csv",
colors,
fmt='%.18e',
delimiter=',',
newline='\n',
header='')
if verbose:
print("Colormap saved to {0}".format(filename + ".csv"))
return colors
def group_colors(colormap,
colormap_name,
description='',
adjacency_matrix=[],
IDs=[],
names=[],
groups=[],
save_text_files=True,
plot_colors=True,
plot_graphs=True,
out_dir='.',
verbose=True):
"""
This greedy algoritm reorders a colormap so that labels assigned to
the same group have more similar colors, but within a group (usually
of adjacent labels), the colors are reordered so that adjacent labels
have dissimilar colors:
1. Convert colormap to Lab color space
which better represents human perception.
2. Load a binary (or weighted) adjacency matrix, where each row or column
represents a label, and each value signifies whether (or the degree
to which) a given pair of labels are adjacent.
If a string (file) is provided instead of a numpy ndarray:
column 0 = label "ID" number
column 1 = label "name"
column 2 = "group" number (each label is assigned to a group)
columns 3... = label adjacency matrix
3. Sort labels by decreasing number of adjacent labels (adjacency sum).
4. Order label groups by decreasing maximum adjacency sum.
5. Create a similarity matrix for pairs of colors.
6. Sort colors by decreasing perceptual difference from all other colors.
7. For each label group:
7.1. Select unpicked colors for group that are similar to the first
unpicked color (unpicked colors were sorted above by decreasing
perceptual difference from all other colors).
7.2. Reorder subgraph colors according to label adjacency sum
(decreasing number of adjacent labels).
8. Assign new colors.
For plotting graphs and colormap:
1. Convert the matrix to a graph, where each node represents a label
and each edge represents the adjacency value between connected nodes.
2. Break up the graph into subgraphs, where each subgraph contains labels
assigned the same group number (which usually means they are adjacent).
3. Plot the colormap and colored sub/graphs.
NOTE: Requires pydotplus
Parameters
----------
colormap : string or numpy ndarray of ndarrays of 3 floats between 0 and 1
csv file containing rgb colormap, or colormap array
colormap_name : string
name of colormap
description : string
description of colormap
adjacency_matrix : string or NxN numpy ndarray (N = number of labels)
csv file containing label adjacency matrix or matrix itself
IDs : list of integers
label ID numbers
names : list of strings
label names
groups : list of integers
label group numbers (one per label)
save_text_files : Boolean
save colormap as csv and json files?
plot_colors : Boolean
plot colormap as horizontal bar chart?
plot_graphs : Boolean
plot colormap as graphs?
out_dir : string
output directory path
verbose : Boolean
print to stdout?
Returns
-------
colors : numpy ndarray of ndarrays of 3 floats between 0 and 1
rgb colormap
Examples
--------
>>> # Get colormap:
>>> from mindboggle.mio.colors import distinguishable_colors
>>> colormap = distinguishable_colors(ncolors=31,
... backgrounds=[[0,0,0],[1,1,1]],
... save_csv=False, plot_colormap=False, verbose=False)
>>> # Get adjacency matrix:
>>> from mindboggle.mio.colors import label_adjacency_matrix
>>> from mindboggle.mio.fetch_data import prep_tests
>>> urls, fetch_data = prep_tests()
>>> label_file = fetch_data(urls['left_manual_labels'], '', '.vtk')
>>> IDs, adjacency_matrix, output_table = label_adjacency_matrix(label_file,
... ignore_values=[-1, 0], add_value=0, save_table=False,
... output_format='', verbose=False)
>>> adjacency_matrix = adjacency_matrix.values
>>> adjacency_matrix = adjacency_matrix[:, 1::]
>>> # Reorganize colormap:
>>> from mindboggle.mio.colors import group_colors
>>> from mindboggle.mio.labels import DKTprotocol
>>> dkt = DKTprotocol()
>>> colormap_name = "DKT31colormap"
>>> description = "Colormap for DKT31 human brain cortical labels"
>>> save_text_files = True
>>> plot_colors = False
>>> plot_graphs = False
>>> out_dir = '.'
>>> verbose = False
>>> #IDs = dkt.DKT31_numbers
>>> names = dkt.DKT31_names #dkt.left_cerebrum_cortex_DKT31_names
>>> groups = dkt.DKT31_groups
>>> colors = group_colors(colormap, colormap_name, description,
... adjacency_matrix, IDs, names, groups,
... save_text_files, plot_colors, plot_graphs, out_dir, verbose)
>>> colors[0]
[0.7586206896551724, 0.20689655172413793, 0.0]
>>> colors[1]
[0.48275862068965514, 0.4482758620689655, 0.48275862068965514]
>>> colors[2]
[0.3448275862068966, 0.3103448275862069, 0.034482758620689655]
>>> colors[-1]
[0.7931034482758621, 0.9655172413793103, 0.7931034482758621]
No groups / subgraphs:
>>> groups = []
>>> colors = group_colors(colormap, colormap_name, description,
... adjacency_matrix, IDs, names, groups,
... save_text_files, plot_colors, plot_graphs, out_dir, verbose)
>>> colors[0]
[0.5172413793103449, 0.8275862068965517, 1.0]
>>> colors[1]
[0.13793103448275862, 0.0, 0.24137931034482757]
>>> colors[2]
[0.3793103448275862, 0.27586206896551724, 0.48275862068965514]
>>> colors[-1]
[0.6206896551724138, 0.48275862068965514, 0.3448275862068966]
"""
import os
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import networkx as nx
from colormath.color_diff import delta_e_cie2000
from colormath.color_objects import LabColor, AdobeRGBColor
from colormath.color_conversions import convert_color
import itertools
from mindboggle.mio.colors import write_json_colormap, write_xml_colormap
# ------------------------------------------------------------------------
# Set parameters for graph layout and output files:
# ------------------------------------------------------------------------
if plot_graphs:
graph_node_size = 1000
graph_edge_width = 2
graph_font_size = 10
subgraph_node_size = 3000
subgraph_edge_width = 5
subgraph_font_size = 18
axis_buffer = 10
graph_image_file = os.path.join(out_dir, "label_graph.png")
subgraph_image_file_pre = os.path.join(out_dir, "label_subgraph")
subgraph_image_file_post = ".png"
if plot_colors:
colormap_image_file = os.path.join(out_dir, 'label_colormap.png')
if save_text_files:
colormap_csv_file = os.path.join(out_dir, 'label_colormap.csv')
colormap_json_file = os.path.join(out_dir, 'label_colormap.json')
colormap_xml_file = os.path.join(out_dir, 'label_colormap.xml')
run_permutations = False
# ------------------------------------------------------------------------
# Load colormap:
# ------------------------------------------------------------------------
if verbose:
print("Load colormap and convert to CIELAB color space.")
if isinstance(colormap, np.ndarray):
colors = colormap
elif isinstance(colormap, str):
colors = pd.read_csv(colormap, sep=',', header=None)
colors = colors.values
else:
raise IOError("Please use correct format for colormap.")
nlabels = np.shape(colors)[0]
new_colors = np.copy(colors)
if len(IDs) == 0:
IDs = range(nlabels)
if len(names) == 0:
names = [str(x) for x in range(nlabels)]
if len(groups) == 0:
groups = [1 for x in range(nlabels)]
# ------------------------------------------------------------------------
# Convert to Lab color space which better represents human perception:
# ------------------------------------------------------------------------
# https://python-colormath.readthedocs.io/en/latest/illuminants.html
lab_colors = []
for rgb in colors:
lab_colors.append(
convert_color(AdobeRGBColor(rgb[0], rgb[1], rgb[2]), LabColor))
# ------------------------------------------------------------------------
# Load label adjacency matrix:
# ------------------------------------------------------------------------
if np.size(adjacency_matrix):
if verbose:
print("Load label adjacency matrix.")
if isinstance(adjacency_matrix, np.ndarray):
adjacency_values = adjacency_matrix
# If a string (file) is provided instead of a numpy ndarray:
# column 0 = label "ID" number
# column 1 = label "name"
# column 2 = "group" number (each label is assigned to a group)
# columns 3... = label adjacency matrix
elif isinstance(adjacency_matrix, str):
matrix = pd.read_csv(adjacency_matrix, sep=',', header=None)
matrix = matrix.values
IDs = matrix.ID
names = matrix.name
groups = matrix.group
adjacency_values = matrix[[str(x) for x in IDs]].values
else:
raise IOError("Please use correct format for adjacency matrix.")
if np.shape(adjacency_values)[0] != nlabels:
raise IOError("The colormap and label adjacency matrix don't "
"have the same number of labels.")
# Normalize adjacency values:
adjacency_values = adjacency_values / np.max(adjacency_values)
else:
plot_graphs = False
# ------------------------------------------------------------------------
# Sort labels by decreasing number of adjacent labels (adjacency sum):
# ------------------------------------------------------------------------
if np.size(adjacency_matrix):
adjacency_sums = np.sum(adjacency_values, axis=1) # sum rows
isort_labels = np.argsort(adjacency_sums)[::-1]
else:
isort_labels = range(nlabels)
# ------------------------------------------------------------------------
# Order label groups by decreasing maximum adjacency sum:
# ------------------------------------------------------------------------
label_groups = np.unique(groups)
if np.size(adjacency_matrix):
max_adjacency_sums = []
for label_group in label_groups:
igroup = [i for i, x in enumerate(groups) if x == label_group]
max_adjacency_sums.append(max(adjacency_sums[igroup]))
label_groups = label_groups[np.argsort(max_adjacency_sums)[::-1]]
# ------------------------------------------------------------------------
# Convert adjacency matrix to graph for plotting:
# ------------------------------------------------------------------------
if plot_graphs:
adjacency_graph = nx.from_numpy_matrix(adjacency_values)
for inode in range(nlabels):
adjacency_graph.node[inode]['ID'] = IDs[inode]
adjacency_graph.node[inode]['label'] = names[inode]
adjacency_graph.node[inode]['group'] = groups[inode]
# ------------------------------------------------------------------------
# Create a similarity matrix for pairs of colors:
# ------------------------------------------------------------------------
if verbose:
print("Create a similarity matrix for pairs of colors.")
dx_matrix = np.zeros((nlabels, nlabels))
for icolor1 in range(nlabels):
for icolor2 in range(nlabels):
dx_matrix[icolor1,
icolor2] = delta_e_cie2000(lab_colors[icolor1],
lab_colors[icolor2])
# ------------------------------------------------------------------------
# Sort colors by decreasing perceptual difference from all other colors:
# ------------------------------------------------------------------------
icolors_to_pick = list(np.argsort(np.sum(dx_matrix, axis=1))[::-1])
# ------------------------------------------------------------------------
# Loop through label groups:
# ------------------------------------------------------------------------
for label_group in label_groups:
if verbose:
print("Labels in group {0}...".format(label_group))
igroup = [i for i, x in enumerate(groups) if x == label_group]
N = len(igroup)
# --------------------------------------------------------------------
# Select unpicked colors for group that are similar to the first
# unpicked color (unpicked colors were sorted above by decreasing
# perceptual difference from all other colors):
# --------------------------------------------------------------------
isimilar = np.argsort(dx_matrix[icolors_to_pick[0],
icolors_to_pick])[0:N]
icolors_to_pick_copy = icolors_to_pick.copy()
group_colors = [list(colors[icolors_to_pick[i]]) for i in isimilar]
if run_permutations:
group_lab_colors = [
lab_colors[icolors_to_pick[i]] for i in isimilar
]
for iremove in isimilar:
icolors_to_pick.remove(icolors_to_pick_copy[iremove])
# --------------------------------------------------------------------
# Reorder group colors according to label adjacency sum
# (decreasing number of adjacent labels):
# --------------------------------------------------------------------
isort_group_labels = np.argsort(isort_labels[igroup])
group_colors = [group_colors[i] for i in isort_group_labels]
# --------------------------------------------------------------------
# Compute differences between every pair of colors within group:
# --------------------------------------------------------------------
weights = False
if run_permutations:
permutation_max = np.zeros(N)
NxN_matrix = np.zeros((N, N))
# ----------------------------------------------------------------
# Extract group adjacency submatrix:
# ----------------------------------------------------------------
neighbor_matrix = adjacency_values[igroup, :][:, igroup]
if not weights:
neighbor_matrix = (neighbor_matrix > 0).astype(np.uint8)
# ----------------------------------------------------------------
# Permute colors and color pair differences:
# ----------------------------------------------------------------
DEmax = 0
permutations = [
np.array(s) for s in itertools.permutations(range(0, N), N)
]
if verbose:
print(" ".join([
str(N), 'labels,',
str(len(permutations)), 'permutations:'
]))
for permutation in permutations:
delta_matrix = NxN_matrix.copy()
for i1 in range(N):
for i2 in range(N):
if (i2 > i1) and (neighbor_matrix[i1, i2] > 0):
delta_matrix[i1, i2] = delta_e_cie2000(
group_lab_colors[i1], group_lab_colors[i2])
if weights:
DE = np.sum((delta_matrix * neighbor_matrix))
else:
DE = np.sum(delta_matrix)
# ------------------------------------------------------------
# Store color permutation with maximum adjacency cost:
# ------------------------------------------------------------
if DE > DEmax:
DEmax = DE
permutation_max = permutation
# ------------------------------------------------------------
# Reorder group colors by the maximum adjacency cost:
# ------------------------------------------------------------
group_colors = [group_colors[x] for x in permutation_max]
new_colors[isimilar] = group_colors
# --------------------------------------------------------------------
# Assign new colors:
# --------------------------------------------------------------------
else:
new_colors[isimilar] = group_colors
# --------------------------------------------------------------------
# Draw a figure of the colored subgraph:
# --------------------------------------------------------------------
if plot_graphs:
plt.figure(label_group)
subgraph = adjacency_graph.subgraph(igroup)
# Layout:
pos = nx.nx_pydot.graphviz_layout(subgraph, prog="neato")
nx.draw(subgraph,
pos,
node_size=subgraph_node_size,
width=subgraph_edge_width,
alpha=0.5,
with_labels=False)
# Labels:
labels = {}
for iN in range(N):
labels[subgraph.nodes()[iN]] = \
subgraph.node[subgraph.nodes()[iN]]['label']
nx.draw_networkx_labels(subgraph,
pos,
labels,
font_size=subgraph_font_size,
font_color='black')
# Nodes:
nodelist = list(subgraph.node.keys())
for iN in range(N):
nx.draw_networkx_nodes(subgraph,
pos,
node_size=subgraph_node_size,
nodelist=[nodelist[iN]],
node_color=group_colors[iN])
# Figure:
ax = plt.gca().axis()
plt.gca().axis([
ax[0] - axis_buffer, ax[1] + axis_buffer, ax[2] - axis_buffer,
ax[3] + axis_buffer
])
plt.savefig(subgraph_image_file_pre + str(int(label_group)) +
subgraph_image_file_post)
#plt.show()
# ------------------------------------------------------------------------
# Plot the entire graph (without colors):
# ------------------------------------------------------------------------
if plot_graphs:
plt.figure(nlabels)
# Graph:
pos = nx.nx_pydot.graphviz_layout(adjacency_graph, prog="neato")
nx.draw(adjacency_graph,
pos,
node_color='yellow',
node_size=graph_node_size,
width=graph_edge_width,
with_labels=False)
# Labels:
labels = {}
for ilabel in range(nlabels):
labels[ilabel] = adjacency_graph.node[ilabel]['label']
nx.draw_networkx_labels(adjacency_graph,
pos,
labels,
font_size=graph_font_size,
font_color='black')
# # Nodes:
# nodelist = list(adjacency_graph.node.keys())
# for icolor, new_color in enumerate(new_colors):
# nx.draw_networkx_nodes(subgraph, pos,
# node_size=graph_node_size,
# nodelist=[nodelist[icolor]],
# node_color=new_color)
plt.savefig(graph_image_file)
plt.show()
# ------------------------------------------------------------------------
# Plot the subgraphs (colors):
# ------------------------------------------------------------------------
if plot_graphs:
for label_group in label_groups:
plt.figure(label_group)
plt.show()
# ------------------------------------------------------------------------
# Plot the colormap as a horizontal bar chart:
# ------------------------------------------------------------------------
if plot_colors:
plt.figure(nlabels, figsize=(5, 10))
for ilabel in range(nlabels):
ax = plt.subplot(nlabels, 1, ilabel + 1)
plt.axis("off")
rgb = new_colors[ilabel]
plt.barh(0, 50, 1, 0, color=rgb)
plt.savefig(colormap_image_file)
plt.show()
# ------------------------------------------------------------------------
# Save new colormap as text files:
# ------------------------------------------------------------------------
if save_text_files:
# ------------------------------------------------------------------------
# Save new colormap as a csv file:
# ------------------------------------------------------------------------
np.savetxt(colormap_csv_file,
new_colors,
fmt='%.18e',
delimiter=',',
newline='\n',
header='')
# ------------------------------------------------------------------------
# Save new colormap as a json file:
# ------------------------------------------------------------------------
write_json_colormap(colormap=new_colors,
label_numbers=IDs,
label_names=names,
colormap_file=colormap_json_file,
colormap_name=colormap_name,
description=description)
# ------------------------------------------------------------------------
# Save new colormap as an xml file:
# ------------------------------------------------------------------------
write_xml_colormap(colormap=new_colors,
label_numbers=IDs,
colormap_file=colormap_xml_file,
colormap_name=colormap_name)
# ------------------------------------------------------------------------
# Return new colors:
# ------------------------------------------------------------------------
colors = new_colors.tolist()
return colors
from colormath.color_objects import sRGBColor, XYZColor
from colormath.color_conversions import convert_color
from colormath.color_appearance_models import CIECAM02
from hyooze import xFF, DEPTH
from hyooze.mesh import EqualBrightnessMesh
REFERENCE_WHITE = convert_color(sRGBColor(1, 1, 1), XYZColor)
class Office:
"""Color perception models are environment dependent. This class encodes the
assumptions about viewing conditions."""
def __init__(self, ambient_lightness, background):
self.ambient_lightness = ambient_lightness
self.background = background
background_xyz = convert_color(background, XYZColor)
self.background_brightness = background_xyz.xyz_y
self._mesh_cache = {}
def rgb_to_cbh(self, r, g, b):
target_xyz = convert_color(sRGBColor(r, g, b, is_upscaled=True),
XYZColor)
perception = CIECAM02(
target_xyz.xyz_x,
target_xyz.xyz_y,
target_xyz.xyz_z,
REFERENCE_WHITE.xyz_x,
REFERENCE_WHITE.xyz_y,
REFERENCE_WHITE.xyz_z,
c=0.69,
def rgb2lab(pt):
return convert_color(sRGBColor(pt[0], pt[1], pt[2]),
LabColor).get_value_tuple()
