def findMaxDeltaEColor(labColor, iter=500): """ :param labColor: lab color in standard range [(0 ~ 100), (-128 ~ 127), (-128 ~ 127)] :param iter: random number of iteration, the result will be more precise with larger number :return: the approximate color with maximum deltaE regard to labColor """ maxDelta_E = 0 maxL = None maxa = None maxb = None for i in range(iter): L = np.random.randint(0, 100) a = np.random.randint(-128, 127) b = np.random.randint(-128, 127) delta_E = colour.delta_E(labColor, [L, a, b], method=deltaE_method) if delta_E > maxDelta_E: maxDelta_E = delta_E maxL = L maxa = a maxb = b assert maxL is not None assert maxa is not None assert maxb is not None maxStandardLabColor = np.array([L, a, b]) print("color with maximum delta E found : {}".format(maxDelta_E)) print(maxStandardLabColor) maxOpencvLabColor = standardLAB2opencvLAB(maxStandardLabColor)[np.newaxis, np.newaxis, :] \ .astype(np.uint8) maxRGBColor = cv.cvtColor(maxOpencvLabColor, cv.COLOR_LAB2RGB).reshape( (1, 1, 3)) plt.imshow(maxRGBColor / 255.0) plt.show()
def delta_E_range(): XYZ = colour.volume.XYZ_outer_surface() # print(XYZ, XYZ.shape) combinations = colour.XYZ_to_Lab( np.array(list(itertools.combinations(XYZ, 2)))) # print(combinations) delta_E = colour.delta_E(combinations[:, 0, :], combinations[:, 1, :]) return np.amax(delta_E), np.amin(delta_E)
def visualize_color_bin(rgb): lab = cv2.cvtColor(rgb.astype(np.float32) / 255, cv2.COLOR_RGB2Lab) lab_delta = np.asarray([colour.delta_E(lc, lab) for lc in lab_colors]) lab_delta = np.argmin(lab_delta, axis=0) for i in range(lab.shape[0]): for j in range(lab.shape[1]): rgb[i, j, :] = rgb_colors[lab_delta[i, j]] return rgb
def evaluate_fitness(self, individuals): for individual in individuals: fitness_value = 1 / (1 + np.sum( delta_E( self.target_image_np_lab, self.preprocess_pil_image(individual.phenotype), ))) individual.set_fitness(fitness_value)
def is_close(self, x1, y1): color_vec = np.array(self.lab_image[self.x0, self.y0, :]) color_mat = np.array([(self.lab_image[x1, y1, 0], self.lab_image[x1, y1, 1], self.lab_image[x1, y1, 2])]) # dist = np.asscalar(delta_e_cie2000(color_vec, color_mat)[0]) dist = np.asscalar(colour.delta_E(color_vec, color_mat)[0]) # print(dist) if dist < self.thresh: return True return False
def evaluate_fitness(self, individuals): for individual in individuals: preprocessed_genotype = self.preprocess_pil_image(individual.genotype) fitness_value = 1 / ( 1 + np.mean(delta_E(self.target_image_np_lab, preprocessed_genotype)) ) + 0.5 * compare_ssim( self.target_image_np_lab, preprocessed_genotype, multichannel=True ) individual.set_fitness(fitness_value)
def getTransLoss(colors): l = len(colors) tcolors = [opencvLAB2standardLAB(color) for color in colors] temp = [ colour.delta_E(tcolors, np.tile(color, (l, 1)), method=deltaE_method) for color in tcolors ] Temp = [t.argsort()[:30] for t in temp] res = np.stack(temp) res2 = np.stack(Temp) return res, res2
def findMaxDeltaEColorInArray(color_array_a, color_b): """ find the color in color_array_a with max deltaE w.r.t. color_b :param color: shape (1) in standard LAB space :param color_array: shape (N, 3) in standard LAB space :return: """ delta_E = colour.delta_E(color_array_a, color_b, method=deltaE_method) index = np.argmax(delta_E) max_color = color_array_a[index] return index, max_color
def calc_delta_e(src_rgb, dst_rgb, method='cie2000'): """ RGB値からdelta_eを計算。 rgb値はガンマ補正がかかった8bit整数型の値とする。 """ src_linear = (src_rgb / 0xFF)**2.4 dst_linear = (dst_rgb / 0xFF)**2.4 src_lab = linear_rgb_to_cielab(src_linear, BT709) dst_lab = linear_rgb_to_cielab(dst_linear, BT709) delta = delta_E(src_lab, dst_lab, method) return delta
def d_textRegion2textColor(bboxs, textColor): """ :param bboxs: text region of all characters, LAB color space :param textColor: color we try to put on text, LAB color space :return: minimum textRegion2textColor distance: min(d(bbox, textColor)), where d is a distance function """ l = len(bboxs) bboxs = [opencvLAB2standardLAB(box) for box in bboxs] p = opencvLAB2standardLAB(textColor) d = colour.delta_E(bboxs, np.tile(p, (l, 1)), method=deltaE_method) t = np.argsort(d)[0] return d[t], t
def colorPicker(event, x, y, flags, param): global clickedColorLAB if event == cv2.EVENT_LBUTTONDOWN: colorsBGR = first[y:y + 1, x:x + 1] labim = cv2.cvtColor(colorsBGR, cv2.COLOR_BGR2LAB) clickedColorLAB = labim[0, 0] print("New base {} Lab".format(clickedColorLAB)) if event == cv2.EVENT_RBUTTONDOWN: colorsBGR2 = first[y:y + 1, x:x + 1] labim2 = cv2.cvtColor(colorsBGR2, cv2.COLOR_BGR2LAB) toval = labim2[0, 0] print("To compare {} Lab".format(toval)) dlt = delta_E(clickedColorLAB, toval) print("Delta E = {}".format(dlt))
def getMaskOfAColor(median_color, image, visited_map): """ :param median_color: lab color :return: A mask; 0 areas refer to areas not this color; 1 areas refer to areas with this color """ compared_color_template = getColoredTemplateForCompared( height, width, median_color) distance = colour.delta_E(image, compared_color_template) mask = np.where( visited_map == 1, 0, np.where(distance < PERCEPTUAL_DIS_FOR_DISTINCT_BG, 1, 0)) return mask
def deltaE00(img1, img2): """ Calculate deltaE 2000 over two images and returns average deltaE 2000 :param img1: numpy :param img2: numpy :return: float """ from skimage import color import colour img1 = color.rgb2lab(img1) img2 = color.rgb2lab(img2) img1 = np.reshape(img1, [-1, 3]).astype(np.float32) img2 = np.reshape(img2, [-1, 3]).astype(np.float32) delta_e = colour.delta_E(img1, img2, method='CIE 2000') return np.mean(delta_e)
def getCurrentColorForMask(ind, image): """ :param ind: the index of the seed color :return: avg color around the seed color """ mid_color = image[ind[0], ind[1]] kernel_size = 5 margin = int(kernel_size / 2) u_i, b_i = max(ind[0] - margin, 0), min(ind[0] + margin + 1, height) l_j, r_j = max(ind[1] - margin, 0), min(ind[1] + margin + 1, width) neighbours = image[u_i:b_i, l_j:r_j] B = getColoredTemplateForCompared(neighbours.shape[0], neighbours.shape[1], mid_color) dists = colour.delta_E(neighbours, B) colors = neighbours[dists < PERCEPTUAL_DIS_FOR_DISTINCT_BG] if len(colors) < int(kernel_size * kernel_size / 2): return False, [] return True, np.average(colors, axis=0).astype('uint8')
def deltaE(trueVals, estVals, MINLAT, MAXLAT, cmap=cm.viridis_r): norm = Normalize(vmin=MINLAT, vmax=MAXLAT) m = cm.ScalarMappable(norm=norm, cmap=cmap) trueVals = list(np.array(trueVals).flatten()) estVals = list(np.array(estVals).flatten()) trueColors = m.to_rgba(trueVals)[:, :3] # multiply by 255 for RGB trueColors = np.array([trueColors]) # cvtColor req 2-dim array trueColors = cv2.cvtColor(trueColors.astype("float32"), cv2.COLOR_RGB2LAB) estColors = m.to_rgba(estVals)[:, :3] estColors = np.array([estColors]) estColors = cv2.cvtColor(estColors.astype("float32"), cv2.COLOR_RGB2LAB) dE = np.mean(colour.delta_E(trueColors, estColors, method='CIE 2000')) return dE
def color_bin(rgb): rgb_img = visualize_color_bin(rgb) edges = cv2.Laplacian(cv2.cvtColor(rgb_img, cv2.COLOR_RGB2GRAY), cv2.CV_64F) hsv_obs = cv2.cvtColor(rgb_img, cv2.COLOR_RGB2HSV) edges = np.where(edges != 0, 1, 0) edges = np.uint8(edges) edges = np.expand_dims(edges, axis=-1) hsv_obs[:, :, 1:3] = hsv_obs[:, :, 1:3] * edges rgb = cv2.cvtColor(hsv_obs, cv2.COLOR_HSV2RGB) rgb = np.uint8(rgb) lab = cv2.cvtColor(rgb.astype(np.float32) / 255, cv2.COLOR_RGB2Lab) lab_delta = np.asarray([colour.delta_E(lc, lab) for lc in lab_colors]) lab_delta = np.argmin(lab_delta, axis=0) one_hot_rgb = np.eye(N_RGBS)[lab_delta] return one_hot_rgb
def visualize_edged_color_bin(rgb): rgb_img = visualize_color_bin(rgb) edges = cv2.Laplacian(cv2.cvtColor(rgb_img, cv2.COLOR_RGB2GRAY), cv2.CV_64F) hsv_obs = cv2.cvtColor(rgb_img, cv2.COLOR_RGB2HSV) edges = np.where(edges != 0, 1, 0) edges = np.uint8(edges) edges = np.expand_dims(edges, axis=-1) hsv_obs[:, :, 1:3] = hsv_obs[:, :, 1:3] * edges rgb = cv2.cvtColor(hsv_obs, cv2.COLOR_HSV2RGB) rgb = np.uint8(rgb) lab = cv2.cvtColor(rgb.astype(np.float32) / 255, cv2.COLOR_RGB2Lab) lab_delta = np.asarray([colour.delta_E(lc, lab) for lc in lab_colors]) lab_delta = np.argmin(lab_delta, axis=0) for i in range(lab.shape[0]): for j in range(lab.shape[1]): rgb[i, j, :] = rgb_colors[lab_delta[i, j]] return rgb
def scan (self, x, y): if self.img is None: raise ValueError ("No image was loaded!") base_color = self.img[y, x] pixels = list() pixels.append((x, y)) imgcopy = self.img.copy() start = time.time() while len(pixels) > 0: cur = pixels.pop(-1) if not self.pixelInBound (*cur): continue if self.pixelVisited(*cur): continue self.setPixelVisited(*cur) x, y = cur # if delta larger than tolerance add to outline and continue color_diff = colour.delta_E(base_color, self.img[y, x], method="CIE 1994") if color_diff > self.color_diff_tolerance: self._outline.append (cur) imgcopy[y, x] = [68, 72, 30] imgcopy[y if y + 1 >= self.imgheight else y + 1, x] = [68, 72, 30] imgcopy[y if y - 1 < 0 else y - 1, x] = [68, 72, 30] imgcopy[y, x if x + 1 >= self.imgwidth else x + 1] = [68, 72, 30] imgcopy[y, x if x - 1 < 0 else x - 1] = [68, 72, 30] continue # expand pixel search and add pixel color self._distinctColors[tuple(self.img[y, x])] = color_diff pixels.extend (((x, y + 1), (x, y - 1), (x + 1, y), (x - 1, y))) self.last_scantime = time.time() - start self.img = imgcopy
def match_image_by_colour(images, training_images): """ Loops through each test category comparing each square extracted from the dipstick with all possible test outcomes, in order to find the two closest matching colours for each test. To make the colour comparison RGB colours are converted to LAB colours and the LAB DELTA E 2000 formula is computed. A list is returned containing the indices corresponding to which colours for each test had the closet match. """ minimum_indices = [] minimum = 0 for index, test_category in enumerate(training_images): minimum_delta_e = 101 for minimum_index, test in enumerate(test_category): square_colour = rgb2lab(np.uint8([[images[index]]])) test_colour = rgb2lab(np.uint8([[test]])) delta_e = colour.delta_E(square_colour, test_colour) if delta_e < minimum_delta_e: minimum_delta_e = delta_e minimum = minimum_index minimum_indices.append(minimum) return minimum_indices
useblit=True, button=[1, 3], # don't use middle button minspanx=5, minspany=5, spancoords='pixels', interactive=True) plt.connect('key_press_event', toggle_selector) input("Choose ROI") roi = toggle_selector.RS.extents #xmin,xmax,ymin,ymax roi = [int(r) for r in roi] color = np.array( [i[roi[2]:roi[3], roi[0]:roi[1]].mean((0, 1)) / 255 for i in images]) ##now, convert this into the XYZ domain cXYZ = [colour.sRGB_to_XYZ(col) for col in color] delE = np.array([[colour.delta_E(c1 * 100, c2) for c2 in XYZ] for c1 in cXYZ]) bif = np.array([retL[i.argmin()] / 5 for i in delE]) #Now, extract the voltage from the data files #first, pull the appropriate columsn nameRegex = re.compile('[wW](\d{3}).*') compound = nameRegex.search(name)[1] cmpGex = re.compile('^W' + compound + '.*') col1 = [i for i, el in enumerate(voltData.columns) if cmpGex.search(el)][0] col2 = col1 + 1 bif = pd.Series(bif, dtype='float')
output_bps=16, output_color=rp.ColorSpace.XYZ, gamma=(1, 1)).astype(float) / (2.0**16 - 1) # rgb = raw.postprocess(user_wb = user_wb) # plt.imshow(rgb) # plt.show() fig, axs = plt.subplots() dEs = np.zeros((4, 6), dtype=np.float) for i in range(0, 24): sample = im_xyz[box[i][1]:box[i][3], box[i][0]:box[i][2]] mean_xyz = [np.mean(sample[:, :, x]) for x in range(0, 3)] dE = colour.delta_E( colour.XYZ_to_Lab( mean_xyz, illuminant=colour. ILLUMINANTS['CIE 1931 2 Degree Standard Observer']['D65']), colour.XYZ_to_Lab( cc[i], illuminant=colour. ILLUMINANTS['CIE 1931 2 Degree Standard Observer']['D65'])) #print(dE) dEs[int(i / 6)][i % 6] = dE # vis = np.tile(mean_xyz, [120, 120, 1]) # vis2 = np.tile(cc[i], [120, 120, 1]) # fig, (ax1, ax2, ax3) = plt.subplots(1, 3) # ax1.imshow(sample) # ax2.imshow(vis) # ax3.imshow(vis2) # plt.show() axs.imshow(dEs)
def Distance(xyz, lab): lab1 = colour.XYZ_to_Lab( xyz, colour.ILLUMINANTS['CIE 1931 2 Degree Standard Observer']['D65']) return colour.delta_E(lab, lab1)
import numpy as np import colour from colour.utilities import message_box message_box('"Delta E" Computations') Lab_1 = np.array([100.00000000, 21.57210357, 272.22819350]) Lab_2 = np.array([100.00000000, 426.67945353, 72.39590835]) message_box( f'Computing "Delta E" with "CIE 1976" method from given "CIE L*a*b*" ' f"colourspace matrices:\n\n" f"\t{Lab_1}\n" f"\t{Lab_2}") print(colour.delta_E(Lab_1, Lab_2, method="CIE 1976")) print(colour.difference.delta_E_CIE1976(Lab_1, Lab_2)) print("\n") message_box( f'Computing "Delta E" with "CIE 1994" method from given "CIE L*a*b*" ' f"colourspace matrices:\n\n" f"\t{Lab_1}\n" f"\t{Lab_2}") print(colour.delta_E(Lab_1, Lab_2, method="CIE 1994")) print(colour.difference.delta_E_CIE1994(Lab_1, Lab_2)) print("\n") message_box(
""" Showcases *Delta E* colour difference computations. """ import colour from colour.utilities.verbose import message_box message_box('"Delta E" Computations') Lab1 = [100, 21.57210357, 272.2281935] Lab2 = [100, 426.67945353, 72.39590835] message_box(('Computing "Delta E" with CIE 1976 method from given *CIE Lab* ' 'colourspace matrices:\n' '\n\t{0}\n\t{1}'.format(Lab1, Lab2))) print(colour.delta_E_CIE1976(Lab1, Lab2)) print(colour.delta_E(Lab1, Lab2, method='CIE 1976')) print('\n') message_box(('Computing "Delta E" with CIE 1994 method from given *CIE Lab* ' 'colourspace matrices:\n' '\n\t{0}\n\t{1}'.format(Lab1, Lab2))) print(colour.delta_E_CIE1994(Lab1, Lab2)) print(colour.delta_E(Lab1, Lab2, method='CIE 1994')) print('\n') message_box(('Computing "Delta E" with CIE 1994 method from given *CIE Lab* ' 'colourspace matrices for "graphics arts" applications:\n' '\n\t{0}\n\t{1}'.format(Lab1, Lab2))) print(colour.delta_E_CIE1994(Lab1, Lab2, textiles=False))
import cv2 import numpy as np import colour import os out = open("./deltaE_output/output.txt", 'w+') for i in range(int(len([name for name in os.listdir('./deltaE_input')])/5)): image1_rgb = cv2.imread("./deltaE_input/" + str(i + 1)+".jpg") image2_rgb = cv2.imread("./deltaE_input/cnn" + str(i + 1)+"-1.png") image3_rgb = cv2.imread("./deltaE_input/cnn" + str(i + 1)+"-2.png") image1_lab = cv2.cvtColor(image1_rgb.astype(np.float32) / 255, cv2.COLOR_RGB2Lab) image2_lab = cv2.cvtColor(image2_rgb.astype(np.float32) / 255, cv2.COLOR_RGB2Lab) image3_lab = cv2.cvtColor(image3_rgb.astype(np.float32) / 255, cv2.COLOR_RGB2Lab) delta_E_1 = colour.delta_E(image1_lab, image2_lab) delta_E_2 = colour.delta_E(image1_lab, image3_lab) cnn1 = str(i + 1) + " - " + str(np.mean(delta_E_1)) cnn2 = str(np.mean(delta_E_2)) out.write(cnn1 + " " + cnn2 + "\n")
def computeContours(frame): colorsLAB = { "Red": ([ cv2.getTrackbarPos('Red L', 'Color Values'), cv2.getTrackbarPos('Red A', 'Color Values'), cv2.getTrackbarPos('Red B', 'Color Values') ]), "Orange": ([ cv2.getTrackbarPos('Orange L', 'Color Values'), cv2.getTrackbarPos('Orange A', 'Color Values'), cv2.getTrackbarPos('Orange B', 'Color Values') ]), "Yellow": ([ cv2.getTrackbarPos('Yellow L', 'Color Values'), cv2.getTrackbarPos('Yellow A', 'Color Values'), cv2.getTrackbarPos('Yellow B', 'Color Values') ]), "Green": ([ cv2.getTrackbarPos('Green L', 'Color Values'), cv2.getTrackbarPos('Green A', 'Color Values'), cv2.getTrackbarPos('Green B', 'Color Values') ]), "Blue": ([ cv2.getTrackbarPos('Blue L', 'Color Values'), cv2.getTrackbarPos('Blue A', 'Color Values'), cv2.getTrackbarPos('Blue B', 'Color Values') ]), "White": ([ cv2.getTrackbarPos('White L', 'Color Values'), cv2.getTrackbarPos('White A', 'Color Values'), cv2.getTrackbarPos('White B', 'Color Values') ]) } frame2 = frame.copy() gausBlur = keepOdd('Blur kSize', 'Settings') gaus = cv2.getTrackbarPos('Block Size', 'Settings') if gaus < 3: gaus = 3 else: count = gaus % 2 if (count == 0): gaus += 1 # blur = cv2.bilateralFilter(cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY), gausBlur, cv2.getTrackbarPos('Blur Sigma X', 'Settings'), cv2.getTrackbarPos('Blur Sigma X', 'Settings')) # blur = cv2.cvtColor(blur, cv2.COLOR_BGR2GRAY) # blur = cv2.GaussianBlur(frame2, (gausBlur, gausBlur), cv2.getTrackbarPos('Blur Sigma X', 'Settings')) # blur = cv2.cvtColor(blur, cv2.COLOR_BGR2GRAY) frame2 = cv2.adaptiveThreshold(cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY), cv2.getTrackbarPos('Max Value', 'Settings'), cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, gaus, cv2.getTrackbarPos('C', 'Settings')) # frame2 = cv2.adaptiveThreshold(blur, # cv2.getTrackbarPos('Max Value', 'Settings'), # cv2.ADAPTIVE_THRESH_GAUSSIAN_C, # cv2.THRESH_BINARY_INV, # gaus, # cv2.getTrackbarPos('C', 'Settings')) se1Size = keepOdd('Closing', 'Settings') # se2Size = keepOdd('Opening', 'Settings') se1 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (se1Size, se1Size)) # se2 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (se2Size,se2Size)) frame2 = cv2.morphologyEx(frame2, cv2.MORPH_CLOSE, se1) # frame2 = cv2.morphologyEx(frame2, cv2.MORPH_OPEN, se2) (contours, hierarchy) = cv2.findContours(frame2.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) # Index is used to remove nested squares. index = 0 for cnt in contours: if (hierarchy[0, index, 3] != -1): epsilon = (cv2.getTrackbarPos('Epsilon Percent', 'Settings') / 100) * cv2.arcLength(cnt, True) approx = cv2.approxPolyDP(cnt, epsilon, True) area = cv2.contourArea(approx, False) # arch = cv2.arcLength(approx, True) # squareness = 4 * math.pi * area / (arch * arch) if (len(approx) == 4 and area > cv2.getTrackbarPos('Blob Area', 'Settings')): # Square detected. Draw square on original image in green. M = cv2.moments(cnt) if (M["m00"] != 0): cX = int(M["m10"] / M["m00"]) cY = int(M["m01"] / M["m00"]) # cv2.drawContours(frame, [approx], 0, (cv2.getTrackbarPos('Contour B', 'Settings'), cv2.getTrackbarPos('Contour G', 'Settings'), cv2.getTrackbarPos('Contour R', 'Settings')), 3) mask = np.zeros(frame2.shape, np.uint8) cv2.drawContours(mask, [cnt], 0, 255, -1) # pixelpoints = np.transpose(np.nonzero(mask)) # hsvFrame = cv2.cvtColor(frame.copy(), cv2.COLOR_BGR2HSV) # labFrame = cv2.cvtColor(frame.astype(np.float32) / 255, cv2.COLOR_BGR2Lab) labFrame = cv2.cvtColor(frame, cv2.COLOR_BGR2Lab) meanVal = cv2.mean(labFrame, mask=mask) # color = np.array((int(meanVal[0]), 255, 255), np.uint8) color = np.array((128, int(meanVal[1]), int(meanVal[2])), np.uint8) resultColor = {} for (k, v) in colorsLAB.items(): resultColor[k] = colorSci.delta_E(v, color) #THIS WILL WORK FOR EVEN GREY # print(resultColor) finalColor = min(resultColor, key=resultColor.get) # print(finalColor) # print(color) cv2.circle(frame, (cX, cY), 9, (0, 0, 0), -1) cv2.circle( frame, (cX, cY), 5, (colorsRGB[finalColor][2], colorsRGB[finalColor][1], colorsRGB[finalColor][0]), -1) else: # Square NOT detected. Draw square on original image in red. cv2.drawContours(frame, [approx], 0, (255, 0, 0), 3) index += 1 return frame2
readCSVs = csv.DictReader(csvfile, delimiter=',') lab2_list = [] l2 = [] a2 = [] b2 = [] for row in readCSVs: l2 = row['LAB_L'] a2 = row['LAB_A'] b2 = row['LAB_B'] if l2 or a2 or b2.isdigit(): l2_n = float(l2) a2_n = float(a2) b2_n = float(b2) lab2_data = np.array([l2_n, a2_n, b2_n]) lab2_list.append(lab2_data) # Calculate delta_E CIE_1976 = colour.delta_E(lab_list, lab2_list, method='CIE 1976') CIE_1994 = colour.delta_E(lab_list, lab2_list, method='CIE 1994') CIE_2000 = colour.delta_E(lab_list, lab2_list, method='CIE 2000') # Create & write CSV file serial_num = range(1, row_count) np.savetxt(save_path + '/' + 'delta_E.csv', np.column_stack((serial_num, CIE_1976, CIE_1994, CIE_2000)), delimiter=',', fmt='%s', header='Sample_ID, CIE_1976, CIE1994, CIE2000') root.destroy()
import colour from colour.utilities.verbose import message_box message_box('"Delta E" Computations') Lab1 = (100.00000000, 21.57210357, 272.22819350) Lab2 = (100.00000000, 426.67945353, 72.39590835) message_box( ( 'Computing "Delta E" with CIE 1976 method from given *CIE Lab* ' "colourspace matrices:\n" "\n\t{0}\n\t{1}".format(Lab1, Lab2) ) ) print(colour.delta_E_CIE1976(Lab1, Lab2)) print(colour.delta_E(Lab1, Lab2, method="CIE 1976")) print("\n") message_box( ( 'Computing "Delta E" with CIE 1994 method from given *CIE Lab* ' "colourspace matrices:\n" "\n\t{0}\n\t{1}".format(Lab1, Lab2) ) ) print(colour.delta_E_CIE1994(Lab1, Lab2)) print(colour.delta_E(Lab1, Lab2, method="CIE 1994")) print("\n")
import colour import numpy as np a = np.array([18, -13, 20]) b = np.array([18, -13, 122]) delta_E = colour.delta_E(a, b, method="CIE 2000") print(delta_E)
def test_color(path_im, color_name, ppg_data, wb_roi, patch_roi, path_jpeg = None): #Full DNG detail # with exiftool.ExifTool() as et: # metadata = et.get_metadata(path_im) # for key in metadata.keys(): # print(key, ' ', metadata[key]) with rp.imread(path_im) as raw: h, w = np.shape(raw.raw_image) print(h, ' ', w) #print(raw.raw_colors) m_raw_rgb = np.array([0.0, 0.0, 0.0, 0.0]) m_raw_cnt = np.array([0, 0, 0, 0]) for i in range(wb_roi[1], wb_roi[3]): for j in range(wb_roi[0], wb_roi[2]): m_raw_rgb[raw.raw_color(i, j)] += raw.raw_value(i, j) m_raw_cnt[raw.raw_color(i, j)] += 1 m_raw_rgb /= m_raw_cnt # print(m_raw_rgb) wp = np.array([m_raw_rgb[0], m_raw_rgb[1], m_raw_rgb[2]]) wp /= wp[1] print('white point: ' + str(wp)) user_whitebalance = (1.0 / wp).tolist() + [0] print('user white balance: ' + str(user_whitebalance)) print('camera white balance: ' + str(raw.camera_whitebalance)) print('Custom processing:') custom_xyz = raw.postprocess(user_wb=user_whitebalance, output_bps=16, output_color=rp.ColorSpace.XYZ, gamma = (1, 1)).astype(float) / (2.0**16 - 1) sample = custom_xyz[patch_roi[1]:patch_roi[3], patch_roi[0]:patch_roi[2]] c_xyz = [np.mean(sample[:, :, x]) for x in range(0, 3)] c_rgb = cam2xyz.XYZ2sRGB(c_xyz) print('Default processing:') default_xyz = raw.postprocess(use_camera_wb=True, output_bps=16, output_color=rp.ColorSpace.XYZ, gamma = (1, 1)).astype(float) / (2.0**16 - 1) sample = default_xyz[patch_roi[1]:patch_roi[3], patch_roi[0]:patch_roi[2]] d_xyz = [np.mean(sample[:, :, x]) for x in range(0, 3)] d_rgb = cam2xyz.XYZ2sRGB(d_xyz) j_rgb = [0, 0, 0] if path_jpeg: jpeg_rgb = cv2.cvtColor(cv2.imread(path_jpeg), cv2.COLOR_BGR2RGB) sample = jpeg_rgb[patch_roi[1]:patch_roi[3], patch_roi[0]:patch_roi[2]] j_rgb = [np.mean(sample[:, :, x]) for x in range(0, 3)] c_lab = cam2xyz.XYZ2LAB(c_xyz) d_lab = cam2xyz.XYZ2LAB(d_xyz) if path_jpeg: j_lab = cam2xyz.RGB2LAB(j_rgb) print('RGB after eliminate illuminant: ' + str(c_rgb)) print('PPG RGB: ' + str(ppg_data[color_name]['RGB'])) print('Lab after eliminate illuminant: ' + str(c_lab)) print('PPG Lab: ' + str(ppg_data[color_name]['LAB'])) # dE_c = deltaE(c_lab, np.array(ppg_data[color_name]['LAB'])) # dE_d = deltaE(d_lab, np.array(ppg_data[color_name]['LAB'])) dE_c = colour.delta_E(c_lab, np.array(ppg_data[color_name]['LAB'])) dE_d = colour.delta_E(d_lab, np.array(ppg_data[color_name]['LAB'])) # print('Custom wb dE: ', deltaE(c_lab, np.array(ppg_data[color_name]['LAB']))) # print('Default wb dE: ', deltaE(d_lab, np.array(ppg_data[color_name]['LAB']))) print('Custom wb dE: ', dE_c) print('Default wb dE: ', dE_d) dE_j = -1.0 if path_jpeg: dE_j = colour.delta_E(j_lab, np.array(ppg_data[color_name]['LAB'])) print('JPEG dE: ', dE_j) # vis_s = np.tile(c_rgb, [300, 300, 1]) # vis_d = np.tile(d_rgb, [300, 300, 1]) # vis_ppg = np.tile(ppg_data[color_name]['RGB'], [300, 300, 1]) # if path_jpeg: # vis_j = np.tile(j_rgb, [300, 300, 1]) # if path_jpeg: # fig, (ax1, ax2, ax3, ax4) = plt.subplots(1, 4) # ax1.imshow(vis_s) # ax1.set_title('Custom wb') # ax2.imshow(vis_ppg) # ax2.set_title('Gt') # ax3.imshow(vis_d) # ax3.set_title('Default wb') # ax4.imshow(vis_j) # ax4.set_title('jpeg') # plt.show() return dE_d, dE_c, dE_j, d_rgb, c_rgb, j_rgb, d_xyz, c_xyz
def calculateLoss(boxes, palette, log_statistics, search_index, key_frame, frame_mean_delta, config): transloss_beta = config["transloss_beta"] transloss_gamma = config["transloss_gamma"] transloss_theta = config["transloss_theta"] distance_gamma = config["distance_gamma"] distance_standard = config["distance_standard"] tolerance_index = config["tolerance_index"] boxes = getBoxMean(boxes) boxes_standardLAB = opencvLAB2standardLAB(boxes) # shape: (box_num x 3) palette_standardLAB = palette.standardLAB[search_index] distance = colour.delta_E( boxes_standardLAB[None, :, :], palette_standardLAB[:, None, :], method=deltaE_method) # shape: (palette_color_num x box_num) # relative_L = (palette_standardLAB[:, None, 0] + 5) / (boxes_standardLAB[None, :, 0]+5) # relative_L[relative_L < 1] = 1/relative_L[relative_L < 1] # distance *= relative_L # min_distance_each_color = distance.min(axis=1) # shape: (palette_color_num) min_distance_each_color = np.partition( distance, kth=tolerance_index, axis=1)[:, tolerance_index] # shape: (palette_color_num) # if key_frame: # previous_color_loss_table = palette.DP_loss[palette.nearby_indexes[search_index[:]]] # else: # previous_color_loss_table = palette.DP_loss[palette.nearby_indexes[search_index[:]]] \ # + transloss_beta * palette.nearby_deltaEs[search_index[:]] ** transloss_gamma # # shape: (palette_color_num x nearby_color_num) # # # if key_frame: # # DP_previous_index = np.argmin(palette.DP_loss).repeat(len(search_index)) # # palette.DP_loss[:] = np.inf # Can be optimized using the previous search_index # # palette.DP_loss[search_index] = 0 # # previous_color_loss = 0 # # else: # # transloss = transloss_beta * np.exp(-transloss_theta * frame_mean_delta) \ # # * palette.nearby_deltaEs[search_index[:]] ** transloss_gamma # # previous_color_loss_table = palette.DP_loss[palette.nearby_indexes[search_index[:]]] + transloss # # tmp_argmin = np.argmin(previous_color_loss_table, axis=1) # shape: (palette_color_num) # # DP_previous_index = palette.nearby_indexes[search_index, tmp_argmin] # shape: (palette_color_num) # previous_color_loss = previous_color_loss_table[range(len(tmp_argmin)), tmp_argmin] # Calculate transfer Loss and previous DP index transloss = transloss_beta * np.exp(-transloss_theta * frame_mean_delta) \ * palette.nearby_deltaEs[search_index[:]] ** transloss_gamma previous_color_loss_table = palette.DP_loss[palette.nearby_indexes[ search_index[:]]] + transloss tmp_argmin = np.argmin(previous_color_loss_table, axis=1) # shape: (palette_color_num) DP_previous_index = palette.nearby_indexes[ search_index, tmp_argmin] # shape: (palette_color_num) previous_color_loss = previous_color_loss_table[range(len(tmp_argmin)), tmp_argmin] # Calcualte distance loss distance_loss = min_distance_each_color - distance_standard distance_loss[distance_loss > 0] = 0 distance_loss = np.abs(distance_loss)**distance_gamma DP_loss = previous_color_loss + distance_loss # # distance_loss = -min_distance_each_color # DP_loss = previous_color_loss_table[range(len(tmp_argmin)), tmp_argmin] + distance_loss log_statistics["max_min_distance"].append(min_distance_each_color.max()) log_statistics["max_min_distance_color"].append( palette_standardLAB[np.argmax(min_distance_each_color)]) return DP_previous_index, DP_loss
Showcases *Delta E* colour difference computations. """ import numpy as np import colour from colour.utilities import message_box message_box('"Delta E" Computations') Lab_1 = np.array([100.00000000, 21.57210357, 272.22819350]) Lab_2 = np.array([100.00000000, 426.67945353, 72.39590835]) message_box(('Computing "Delta E" with "CIE 1976" method from given ' '"CIE L*a*b*" colourspace matrices:\n' '\n\t{0}\n\t{1}'.format(Lab_1, Lab_2))) print(colour.delta_E(Lab_1, Lab_2, method='CIE 1976')) print(colour.difference.delta_E_CIE1976(Lab_1, Lab_2)) print('\n') message_box(('Computing "Delta E" with "CIE 1994" method from given ' '"CIE L*a*b*" colourspace matrices:\n' '\n\t{0}\n\t{1}'.format(Lab_1, Lab_2))) print(colour.delta_E(Lab_1, Lab_2, method='CIE 1994')) print(colour.difference.delta_E_CIE1994(Lab_1, Lab_2)) print('\n') message_box(('Computing "Delta E" with "CIE 1994" method from given ' '"CIE L*a*b*" colourspace matrices for "graphics arts" ' 'applications:\n'
Showcases *Delta E* colour difference computations. """ import numpy as np import colour from colour.utilities import message_box message_box('"Delta E" Computations') Lab1 = np.array([100.00000000, 21.57210357, 272.22819350]) Lab2 = np.array([100.00000000, 426.67945353, 72.39590835]) message_box(('Computing "Delta E" with "CIE 1976" method from given ' '"CIE L*a*b*" colourspace matrices:\n' '\n\t{0}\n\t{1}'.format(Lab1, Lab2))) print(colour.delta_E(Lab1, Lab2, method='CIE 1976')) print(colour.difference.delta_E_CIE1976(Lab1, Lab2)) print('\n') message_box(('Computing "Delta E" with "CIE 1994" method from given ' '"CIE L*a*b*" colourspace matrices:\n' '\n\t{0}\n\t{1}'.format(Lab1, Lab2))) print(colour.delta_E(Lab1, Lab2, method='CIE 1994')) print(colour.difference.delta_E_CIE1994(Lab1, Lab2)) print('\n') message_box(('Computing "Delta E" with "CIE 1994" method from given ' '"CIE L*a*b*" colourspace matrices for "graphics arts" ' 'applications:\n'