def getDistance(self, pixels1, pixels2): lab1 = colour.XYZ_to_Lab(colour.sRGB_to_XYZ(pixels1)) lab2 = colour.XYZ_to_Lab(colour.sRGB_to_XYZ(pixels2)) dist = mean_squared_error(pixels1, pixels2) #dist = np.sqrt((pixels1[:, 0] - pixels2[:, 0])**2 + (pixels1[:, 1] - pixels2[:, 1])**2 + (pixels1[:, 2] - pixels2[:, 2])**2) #dist = np.sum(dist) return dist
def convert_to_XYZ(img): img_data = np.asarray(img) r, g, b = [img_data[:, :, i] for i in range(img_data.shape[-1])] isAdobeRGB = is_adobe_rgb(img) if isAdobeRGB: XYZ = AdobeRGB_to_XYZn(r, g, b) else: XYZ = colour.sRGB_to_XYZ(img_data / 255) return XYZ
def calculate_EVILS_CLAW( RGB_input, CLAW_compression=1.0, CLAW_identity_limit=None, CLAW_maximum_input=None, CLAW_maximum_output=None, ): XYZ_RGB = colour.sRGB_to_XYZ(RGB_input) EVILS_eiY = calculate_EVILS_eiY(XYZ_RGB) eiH, eiC, eiY = np.split(calculate_EVILS_eiHCY(EVILS_eiY), 3, axis=-1) eiC_max = np.amax(eiC) # eiC_n = np.ma.divide( # eiC, # eiC_max # ).filled(fill_value=0.0) if CLAW_maximum_input is None: # Set CLAW_maximum_input to a reasonable portion of the output # range. Scalar. CLAW_maximum_input = eiC_max else: CLAW_maximum_input *= eiC_max if CLAW_maximum_output is None: # Set CLAW_maximum_output to the input to assure that a majority of # values are unchanged. Scalar CLAW_maximum_output = CLAW_maximum_input * 0.6 else: CLAW_maximum_output *= CLAW_maximum_input if CLAW_identity_limit is None: # Set breakpoint to a reasonably high value to leave a majority # of values untouched. CLAW_identity_limit = 0.0 else: CLAW_identity_limit *= CLAW_maximum_output EVILS_CLAW_ratio = np.where( eiC > CLAW_identity_limit, power_compression( X_input=eiC, X_maximum=CLAW_maximum_input, Y_maximum=CLAW_maximum_output, compression_power=CLAW_compression, identity_breakpoint=CLAW_identity_limit, ), eiC, ) # Chroma scale here is relative to what the adjust_chroma tool expects. # So here we assume that maximal chroma is 100%, and simply subtract # the normalized output of the input chroma from the compressed signal # chroma. This scaling could likely be improved. chroma_scalar = EVILS_CLAW_ratio / eiC return adjust_chroma(RGB_input, chroma_scalar)
def test_de2000() -> None: rgb = get_random_01x01x01_with_corners(1000) xyz = sRGB_to_XYZ(rgb) lab = XYZ_to_Lab(xyz) de = delta_E_CIE2000(lab[:-1], lab[1:]) my_de = dE_2000_jit(lab[:-1], lab[1:]) assert np.allclose(de, my_de), np.hstack( [de.reshape(-1, 1), my_de.reshape(-1, 1)])
def rgb_to_k(r, g, b): RGB = np.array([r, g, b]) # Conversion to tristimulus values. XYZ = colour.sRGB_to_XYZ(RGB / 255) # Conversion to chromaticity coordinates. xy = colour.XYZ_to_xy(XYZ) # Conversion to correlated colour temperature in K. CCT = colour.xy_to_CCT(xy, 'hernandez1999') #print(f"{r}{g}{b}") return CCT
def set_convertor(name, ill='D65'): """ Binds the conversion functions LCH2RGB() and RGB2LCH() to the choosen colour package """ global LCH2RGB, RGB2LCH, convertor, illuminant if name not in ['custom', 'colorspacious', 'colourscience']: print("Unknown conversion module") return convertor = name illuminant = ill if name == 'custom': LCH2RGB = lambda L, C, H: XYZ2RGB(Lab2XYZ(LCH2Lab((L, C, H)))) RGB2LCH = lambda R, G, B: Lab2LCH(XYZ2Lab(RGB2XYZ((R, G, B)))) if name == 'colorspacious': from colorspacious import cspace_convert func_LCH2RGB = lambda L, C, H: cspace_convert([L, C, H], { "name": "CIELCh", "XYZ100_w": ill }, "sRGB1") func_RGB2LCH = lambda R, G, B: cspace_convert([R, G, B], "sRGB1", { "name": "CIELCh", "XYZ100_w": ill }) if name == 'colourscience': import colour as cs cs_ill = cs.ILLUMINANTS['CIE 1931 2 Degree Standard Observer'][ill] func_LCH2RGB = lambda L, C, H: cs.XYZ_to_sRGB( cs.Lab_to_XYZ(cs.LCHab_to_Lab([L, C, H]), illuminant=cs_ill)) func_RGB2LCH = lambda R, G, B: cs.Lab_to_LCHab( cs.XYZ_to_Lab(cs.sRGB_to_XYZ([R, G, B]), illuminant=cs_ill)) if name == 'colorspacious' or name == 'colourscience': def LCH2RGB(L, C, H): if hasattr(L, '__iter__'): RGB = np.array(list(map(func_LCH2RGB, L, C, H))) R = RGB[:, 0] G = RGB[:, 1] B = RGB[:, 2] else: R, G, B = func_LCH2RGB(L, C, H) return R, G, B def RGB2LCH(R, G, B): if hasattr(R, '__iter__'): LCH = np.array(list(map(func_RGB2LCH, R, G, B))) L = LCH[:, 0] C = LCH[:, 1] H = LCH[:, 2] else: L, C, H = func_RGB2LCH(R, G, B) return L, C, H print("convertor = '%s' (illuminant = '%s')" % (name, illuminant))
def image_color_temperature(path): #convert image to array of pixels array = np.array(image_dominant_color_rgb(path)) #conver to xyz https://www.colourphil.co.uk/xyz_colour_space.shtml XYZ = colour.sRGB_to_XYZ(array / 255) #dont need the z value xy = colour.XYZ_to_xy(XYZ) #convert to its kelvin temperature CCT = colour.xy_to_CCT(xy, 'hernandez1999') return CCT
def ColorFidelityMetric(rgbX, rgbY): M = 0 Q = 0 #W * H * 3に変形 rgbX_ = np.reshape(rgbX, (inputImg.shape[0], inputImg.shape[1], 3)) rgbY_ = np.reshape(rgbY, (inputImg.shape[0], inputImg.shape[1], 3)) #RGB-->Lab XYZ_X = colour.sRGB_to_XYZ(rgbX_) XYZ_Y = colour.sRGB_to_XYZ(rgbY_) Lab_X = colour.XYZ_to_Lab(XYZ_X) Lab_Y = colour.XYZ_to_Lab(XYZ_Y) #ウィンドウサイズごとのFidelityMetricを計算 for (cropX, cropY) in SlidingWindow(Lab_X, Lab_Y, 1, 8): # if the window does not meet our desired window size, ignore it if cropX.shape[0] != 8 or cropX.shape[1] != 8: continue #オリジナル画像のクリップ cropL_X = cropX[:, :, 0].flatten() cropa_X = cropX[:, :, 1].flatten() cropb_X = cropX[:, :, 2].flatten() #加工画像のクリップ cropL_Y = cropY[:, :, 0].flatten() cropa_Y = cropY[:, :, 1].flatten() cropb_Y = cropY[:, :, 2].flatten() Ql = FidelityMetric(cropL_X, cropL_Y) Qa = FidelityMetric(cropa_X, cropa_Y) Qb = FidelityMetric(cropb_X, cropb_Y) Q += np.sqrt(Ql**2 + Qa**2 + Qb**2) M += 1 return Q / M
def main(): while True: time.sleep(1) img = get_cap() avg_color_rgb = bgr_to_rgb(avg_image_colors(img)) avg_color_xyz = colour.sRGB_to_XYZ(avg_color_rgb) avg_color_xy = colour.XYZ_to_xy(avg_color_xyz) avg_color_cct = colour.xy_to_CCT(avg_color_xy, 'hernandez1999') avg_img_color_cct_xy = colour.temperature.CCT_to_xy(avg_color_cct) print("Average RGB Value: {}, Rounded CCT: {}, Sent xy: {}".format( avg_color_rgb, avg_color_cct, avg_img_color_cct_xy)) set_acs_sample(avg_img_color_cct_xy[0], avg_img_color_cct_xy[1])
def getNaturalness(self, rgb): XYZ = colour.sRGB_to_XYZ(rgb) LUV = colour.XYZ_to_Luv(XYZ) #彩度と色相の計算(色相は0-2pi-->角度(0-360)に変換) sat = np.sqrt(LUV[:, 1]**2 + LUV[:, 2]**2) / 100 hue = np.arctan2(LUV[:, 2], LUV[:, 1]) hue[hue < 0] += 2 * np.pi LHS = np.c_[LUV[:, 0], np.rad2deg(hue), sat] #Thresolding L and S components LHS = LHS[np.where((LHS[:, 0] >= 20) & (LHS[:, 0] <= 80) & (LHS[:, 2] >= 0.1))] #Calcurate average and pixel num of saturation value skin = LHS[np.where((LHS[:, 1] >= 25) & (LHS[:, 1] <= 70)), 2] grass = LHS[np.where((LHS[:, 1] >= 95) & (LHS[:, 1] <= 135)), 2] sky = LHS[np.where((LHS[:, 1] >= 185) & (LHS[:, 1] <= 260)), 2] if (skin.shape[1] == 0): n_skin = 0 S_skin = 0 else: n_skin = skin.shape[1] S_skin = np.mean(skin) if (grass.shape[1] == 0): n_grass = 0 S_grass = 0 else: n_grass = grass.shape[1] S_grass = np.mean(grass) if (sky.shape[1] == 0): n_sky = 0 S_sky = 0 else: n_sky = sky.shape[1] S_sky = np.mean(sky) #Calcurate local CNI value N_skin = np.power(np.exp(-0.5 * ((S_skin - 0.76) / 0.52)**2), 4) N_grass = np.exp(-0.5 * ((S_grass - 0.81) / 0.53)**2) N_sky = np.exp(-0.5 * ((S_sky - 0.43) / 0.22)**2) return (n_skin * N_skin + n_grass * N_grass + n_sky * N_sky) / (n_skin + n_grass + n_sky)
def BGR2LAB(image): """ Converts OpenCV BGR image to CIE Lab image Lab Scale L| 0:100 | a| -100:100 | b| -100:100 | :param image: BGR image :return: Lab image """ image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) image_srgb = image_rgb.astype(np.float32) / 255 image_lab = colour.XYZ_to_Lab(colour.sRGB_to_XYZ(image_srgb)) return image_lab
def calculate_input_temp(frame) -> float: array_RGB = numpy.array(list(cv2.mean(frame)[0:3][::-1])) array_tristimulus = colour.sRGB_to_XYZ(array_RGB / 255) array_chromaticity = colour.XYZ_to_xy(array_tristimulus) temporary = colour.xy_to_CCT(array_chromaticity, 'hernandez1999') if temporary < 1000: # print('Warm bound') return 1000 elif temporary > 12000: # print('Cold bound') return 12000 return temporary
def rgb_to_temperature(rgb): """ Convert sRGB to temperature in Kelvin. First, we convert to tristimulus values. Second, we convert to chromaticity coordinates. Third, we convert to color temp in K from Hernandez paper. Parameters ---------- rgb : List/tuple of rgb values, e.g. [255.0, 235.0, 12.0] Returns ------- numeric : CCT (correlated color temperature) in kelvin """ rgb_array = numpy.array(rgb) xyz = colour.sRGB_to_XYZ(rgb_array / 255) xy = colour.XYZ_to_xy(xyz) cct = colour.xy_to_CCT_Hernandez1999(xy) return cct
def get_main_color(R,G,B): sRGB = [R/255,G/255,B/255] RGB = np.array(sRGB) XYZ = colour.sRGB_to_XYZ(sRGB) Lab = colour.XYZ_to_Lab(XYZ) LCHab = colour.Lab_to_LCHab(Lab) L = int(LCHab[0]);C = int(LCHab[1]);ab = int(LCHab[2]) print([L,C,ab]) if C<40:# 1 if L<10: return 'black' elif L>90: return 'white' else: return 'gray' elif ab<45:# 2 if L<30: return 'brown' elif L>70: return 'pink' else: return 'red' elif ab<75:# 3 if L<30: return 'brown' else: return 'orange' elif ab<105:# 4 return 'yellow' elif ab<210:# 5 return 'green' elif ab<315:# 6 return 'blue' elif ab>330:# 7 if L>50: return 'pink' else: return 'purple' else: return 'purple'
def parse_value(self, value): if self.sensor_type == "relay_a": value = value[0] elif self.sensor_type == "relay_b": value = value[1] elif self.sensor_type == "acceleration": value = value[2] elif self.sensor_type == "colour_temp": r, g, b, c = [int(x / 257) for x in value] RGB = np.array([r, g, b]) XYZ = colour.sRGB_to_XYZ(RGB / 255) xy = colour.XYZ_to_xy(XYZ) CCT = colour.xy_to_CCT_Hernandez1999(xy) value = CCT if isinstance(value, numbers.Number): if hasattr(self, "multiplier"): value = value * self.multiplier if hasattr(self, "offset"): value = value + self.offset return value
def test_converters(): np.set_printoptions(precision=4) hsv = get_random_01x01x01_with_corners(size=10) # ground truths rgb = HSV_to_RGB(hsv) xyz = sRGB_to_XYZ(rgb) xyy = XYZ_to_xyY(xyz) luv = XYZ_to_Luv(xyz) lchuv = Luv_to_LCHuv(luv) lab = XYZ_to_Lab(xyz) lchab = Lab_to_LCHab(lab) for fun, src, trg in [ [HSV_to_RGB_jit, hsv, rgb], [sRGB_to_XYZ_jit, rgb, xyz], [xyY_to_XYZ_jit, xyy, xyz], [XYZ_to_xyY_jit, xyz, xyy], [XYZ_to_Luv_D65_jit, xyz, luv], [XYZ_to_Lab_D65_jit, xyz, lab], [Luv_to_LCHuv_jit, luv, lchuv], [Lab_to_LCHab_jit, lab, lchab], ]: print(f"testing {fun.__name__}") my_trg = fun(src) succ = np.allclose(my_trg, trg, equal_nan=True, atol=1e-3) if not succ: bad_rows = (( ~np.isclose(my_trg, trg, equal_nan=True, atol=1e-3)).sum( axis=-1).astype(bool)) print("FAILED") print("output comparison (bad rows)") print(np.hstack([my_trg, trg])[bad_rows]) print("absolute difference (bad rows)") print(np.hstack([src, np.abs(my_trg - trg)])[bad_rows]) assert 0
drawtype='box', 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
import numpy as np import colour RGB_r = np.array([1, 0, 0]) RGB_g = np.array([0, 1, 0]) RGB_b = np.array([0, 0, 1]) XYZ_r = colour.sRGB_to_XYZ(RGB_r, apply_EOCF=False) XYZ_g = colour.sRGB_to_XYZ(RGB_g, apply_EOCF=False) XYZ_b = colour.sRGB_to_XYZ(RGB_b, apply_EOCF=False) xyY_r = colour.XYZ_to_xyY(XYZ_r); xyY_g = colour.XYZ_to_xyY(XYZ_g); xyY_b = colour.XYZ_to_xyY(XYZ_b); print(xyY_r) print(xyY_g) print(xyY_b)
def get_artwork_colors(): # Define scope scope = 'current_user_playing_track user-read-private user-read-playback-state user-modify-playback-state' # Obtain Spotify Token (username, client_id, and client_secret will vary per user - for additional information see Spotify API documentation.) try: token = util.prompt_for_user_token("Chris Penny", client_id='dd41386aabca41aa8dd7ba2f947782b3',client_secret='4bf7eefcbf7241298d92b9f5ad6fe3f0',redirect_uri='http://google.com/') # Error Case - Remove token cache and replace except (AttributeError, JSONDE): os.remove(f".cache-{username}") token = util.prompt_for_user_token("Chris Penny", client_id='dd41386aabca41aa8dd7ba2f947782b3',client_secret='4bf7eefcbf7241298d92b9f5ad6fe3f0',redirect_uri='http://google.com/') # Generate spotipy object using Spotify Token spot_obj = spotipy.Spotify(auth=token) # Call spotipy attribute for the currently playing track track = spot_obj.current_user_playing_track() #print(list(track)) # For Debug # NOTE: While the current_user_playing_track() attribute results in a dictionary, the album art image URL is not assigned to a key and must be extracted by parsing. items = track['item'] # Convert dictionary object to string and parse the album art image URL. string_items = str(items) image_loc = string_items.find('images') image_loc_end = string_items.find('width', image_loc) image_url = string_items[image_loc+34:image_loc_end-4] # Use the urllib library to save the image as a temporary file in a sub-directory. req.urlretrieve(image_url, "Temporary Image Directory/temp_artwork.jpg") #print(image_url) # For Debug album_art_test = Image.open("Temporary Image Directory/temp_artwork.jpg").convert("L") album_art = Image.open("Temporary Image Directory/temp_artwork.jpg") # print(album_art.mode) # For Debug histogram = album_art.histogram() # print(rgb_data) # For Debug # Convert image to a numpy array. rgb_tuples = np.asarray(album_art) # print(rgb_tuples) # For Debug # print(type(rgb_tuples.shape)) # For Debug # Stack with Numpy for i in range(0, len(rgb_tuples)): if i==0: np_stack = rgb_tuples[i] if i > 0: np_stack = np.vstack((np_stack, rgb_tuples[i])) # print(np.shape(np_stack)) # For Debug pd_rgb_stack = pd.DataFrame(np_stack, columns = ['r', 'g', 'b']) pd_rgb_stack['rgb'] = (pd_rgb_stack['r'].astype(str)) + '_' + (pd_rgb_stack['g'].astype(str)) + '_' + (pd_rgb_stack['b'].astype(str)) pd_rgb_stack['check_sum'] = pd_rgb_stack[['r', 'b', 'g']].sum(axis=1) # print(pd_rgb_stack['check_sum'].head(20)) # For Debug check_sum_mean = pd_rgb_stack['check_sum'].mean() # print(check_sum_mean) # For Debug # Sort by Value Counts to find modal values and return in order of frequency pd_rgb_sorted = pd_rgb_stack['rgb'].value_counts().to_frame() pd_rgb_sorted.astype(int) # print(pd_rgb_sorted.iloc[0]) # For Debug # print(pd_rgb_sorted) # For Debug # print(pd_rgb_stack['rgb'].head()) # For Debug # print(pd_rgb_stack['r']) # For Debug # Initialize Values for While Loop rgb_temp_std = 0 rgb_temp_sum = 0 i = -1 #and (rgb_temp_sum < 50) # Implement While Loop to ensure selected color is not black/white/greyscale (in which all rgb values are approximately the same) while (rgb_temp_std < 15): i += 1 temp = pd_rgb_sorted.index[i] parse_1 = temp.find('_') parse_2 = temp.find('_', parse_1+1) rgb_temp = pd.DataFrame({'r':[temp[0:parse_1]], 'g':[temp[parse_1+1: parse_2]], 'b':[temp[parse_2+1:]]}).astype(int) rgb_temp_std = np.std(rgb_temp, 1)[0] rgb_temp_sum = rgb_temp['r'] + rgb_temp['g'] + rgb_temp['b'] rgb_temp_sum = rgb_temp_sum.astype(int) rgb_select_1 = rgb_temp print('The first selected color is:') print(rgb_select_1) # Write selected rgb values to respective variables for use in distance calculation pd_rgb_stack['r_select'] = rgb_select_1['r'][0] pd_rgb_stack['g_select'] = rgb_select_1['g'][0] pd_rgb_stack['b_select'] = rgb_select_1['b'][0] # Perform distance calculation (<-- distance formula applied to RGB values) pd_rgb_stack['dist_score'] = np.sqrt(np.square(pd_rgb_stack['r'] - pd_rgb_stack['r_select']) + np.square(pd_rgb_stack['g'] - pd_rgb_stack['g_select']) + np.square(pd_rgb_stack['b'] - pd_rgb_stack['b_select'])) # print(pd_rgb_stack['dist_score'].head(20)) # Inspect Counts dist_score_sorted = pd_rgb_stack['dist_score'].value_counts().to_frame() # Calculate Standard Deviation of Distance Score dist_score_std = np.std(pd_rgb_stack['dist_score']) # print(dist_score_std) # Recreate Sorted List on DF ## pd_rgb_sorted = pd_rgb_stack['rgb'].value_counts().to_frame() ## pd_rgb_sorted.astype(int) # Perform left join on pd_rgb_stack to get distance scores in same dataframe pd_rgb_merged = pd_rgb_stack.join(pd_rgb_sorted, on = 'rgb', how = 'left', rsuffix = '_count') # Sort Merged DF and remove duplicates pd_rgb_merged = pd_rgb_merged.sort_values(by = ['rgb_count', 'dist_score'], ascending = False) pd_rgb_merged['std'] = np.std(pd_rgb_merged[['r','g','b']], axis = 1) pd_rgb_merged = pd_rgb_merged.drop_duplicates() # Reset Initial Values for Second While Loop rgb_temp_std = 0 rgb_temp_sum = 0 temp_dist_score = 0 j = -1 # Second While Loop while (rgb_temp_std < 15 or temp_dist_score < 2*dist_score_std or temp_sum < 120): j += 1 temp = pd_rgb_merged.iloc[j]['rgb'] temp_r = pd_rgb_merged.iloc[j]['r'] temp_g = pd_rgb_merged.iloc[j]['g'] temp_b = pd_rgb_merged.iloc[j]['b'] temp_dist_score = pd_rgb_merged.iloc[j]['dist_score'] temp_sum = pd_rgb_merged.iloc[j]['check_sum'] rgb_temp_std = pd_rgb_merged.iloc[j]['std'] rgb_select_2 = pd.DataFrame({'r':[temp_r], 'g':[temp_g], 'b':[temp_b]}).astype(int) print('The second selected color is:') print(rgb_select_2) # Generate Histograms and Plot histogram_test = album_art_test.histogram() #print(histogram_test) r_hist = histogram[1:256] r_hist_max = r_hist.index(max(r_hist)) g_hist = histogram[257:512] g_hist_max = g_hist.index(max(g_hist)) b_hist = histogram[513:768] b_hist_max = b_hist.index(max(b_hist)) rgb_max = [r_hist_max, g_hist_max, b_hist_max] # print(rgb_max) # Generate Histogram Plot with RGB channels # fig, histo = pypl.subplots() # histo.plot(r_hist, 'r') # histo.plot(g_hist, 'g') # histo.plot(b_hist, 'b') # histo.plot(histogram_test, 'black') # pypl.show() Uncomment to show histogram plot # Assuming sRGB encoded colour values. RGB = np.array([r_hist_max, g_hist_max, b_hist_max]) # RGB Values rgb_for_conversion = np.vstack((rgb_select_1.values, rgb_select_2.values)) # rgb_select_1 = rgb_select_1.values # rgb_select_2 = rgb_select_2.values # rgb_for_conversion = [rgb_select_1, rgb_select_2] # print(rgb_for_conversion) # Conversion to tristimulus values. XYZ = colour.sRGB_to_XYZ(rgb_for_conversion / 256) print(XYZ) # Conversion to chromaticity coordinates. xy = colour.XYZ_to_xy(XYZ) print(xy) return(xy)
print(img.shape) # (height,width,channel) print(img.size) # 像素數量 print(img.dtype) # 數據類型 print(img) # 列印圖像的numpy數組,3緯數組 #%% # 網址1:https://colour.readthedocs.io/en/v0.3.13/generated/colour.sRGB_to_XYZ.html # 網址2:https://colour.readthedocs.io/en/v0.3.7/colour.html # 網址3:https://colour.readthedocs.io/en/v0.3.13/generated/colour.Lab_to_LCHab.html?highlight=lch#colour.Lab_to_LCHab # sRGB_to_XYZ #import colormath #from colormath.color_objects import LabColor, XYZColor #from colormath.color_conversions import convert_color import colour import numpy as np sRGB = [200 / 255, 150 / 255, 100 / 255] RGB = np.array(sRGB) XYZ = colour.sRGB_to_XYZ(sRGB) Lab = colour.XYZ_to_Lab(XYZ) LCHab = colour.Lab_to_LCHab(Lab) L = int(LCHab[0]) C = int(LCHab[1]) ab = int(LCHab[2]) #%% LCHab = ['41', '59', '27'] LCHab = np.array(LCHab) L = int(LCHab[0]) C = int(LCHab[1]) ab = int(LCHab[2]) #%% r = 255 g = 89 b = 0
def HEX_2_LAB(hex): return colour.XYZ_to_Lab( colour.sRGB_to_XYZ(colour.notation.HEX_to_RGB(hex)))
def HEX_2_XYY(hex): return colour.XYZ_to_xyY( colour.sRGB_to_XYZ(colour.notation.HEX_to_RGB(hex)))
parser.add_argument('--alpha', type=float, default=1.0) parser.add_argument('--gamma', type=float, default=1.0) args = parser.parse_args() print('load training data') with gzip.open(args.training_data_path, 'rb') as f: raw, jpeg = pickle.load(f) raw = np.array(raw, dtype=np.float32) jpeg = np.array(jpeg, dtype=np.float32) raw /= 255 jpeg /= 255 if args.color_space == 'lab': raw = colour.XYZ_to_Lab(colour.sRGB_to_XYZ(raw)) jpeg = colour.XYZ_to_Lab(colour.sRGB_to_XYZ(jpeg)) print('load xgboost models') with open(args.model_file_path, 'rb') as f: models = pickle.load(f) print('lattice regression') print('define A') lattice_size = args.lut_size lattice_points = np.linspace(0.0, 1.0, lattice_size) A = np.array( [p for p in product(lattice_points, lattice_points, lattice_points)],
def generate_documentation_plots(output_directory): """ Generates documentation plots. Parameters ---------- output_directory : unicode Output directory. """ colour.utilities.filter_warnings() colour_style() np.random.seed(0) # ************************************************************************* # "README.rst" # ************************************************************************* arguments = { 'tight_layout': True, 'transparent_background': True, 'filename': os.path.join(output_directory, 'Examples_Plotting_Visible_Spectrum.png') } plot_visible_spectrum('CIE 1931 2 Degree Standard Observer', **arguments) arguments['filename'] = os.path.join( output_directory, 'Examples_Plotting_Illuminant_F1_SD.png') plot_single_illuminant_sd('FL1', **arguments) arguments['filename'] = os.path.join(output_directory, 'Examples_Plotting_Blackbodies.png') blackbody_sds = [ colour.sd_blackbody(i, colour.SpectralShape(0, 10000, 10)) for i in range(1000, 15000, 1000) ] plot_multi_sds( blackbody_sds, y_label='W / (sr m$^2$) / m', use_sds_colours=True, normalise_sds_colours=True, legend_location='upper right', bounding_box=(0, 1250, 0, 2.5e15), **arguments) arguments['filename'] = os.path.join( output_directory, 'Examples_Plotting_Cone_Fundamentals.png') plot_single_cmfs( 'Stockman & Sharpe 2 Degree Cone Fundamentals', y_label='Sensitivity', bounding_box=(390, 870, 0, 1.1), **arguments) arguments['filename'] = os.path.join( output_directory, 'Examples_Plotting_Luminous_Efficiency.png') sd_mesopic_luminous_efficiency_function = ( colour.sd_mesopic_luminous_efficiency_function(0.2)) plot_multi_sds( (sd_mesopic_luminous_efficiency_function, colour.PHOTOPIC_LEFS['CIE 1924 Photopic Standard Observer'], colour.SCOTOPIC_LEFS['CIE 1951 Scotopic Standard Observer']), y_label='Luminous Efficiency', legend_location='upper right', y_tighten=True, margins=(0, 0, 0, .1), **arguments) arguments['filename'] = os.path.join( output_directory, 'Examples_Plotting_BabelColor_Average.png') plot_multi_sds( colour.COLOURCHECKERS_SDS['BabelColor Average'].values(), use_sds_colours=True, title=('BabelColor Average - ' 'Spectral Distributions'), **arguments) arguments['filename'] = os.path.join( output_directory, 'Examples_Plotting_ColorChecker_2005.png') plot_single_colour_checker( 'ColorChecker 2005', text_parameters={'visible': False}, **arguments) arguments['filename'] = os.path.join( output_directory, 'Examples_Plotting_Chromaticities_Prediction.png') plot_corresponding_chromaticities_prediction(2, 'Von Kries', 'Bianco', **arguments) arguments['filename'] = os.path.join( output_directory, 'Examples_Plotting_CCT_CIE_1960_UCS_Chromaticity_Diagram.png') plot_planckian_locus_in_chromaticity_diagram_CIE1960UCS(['A', 'B', 'C'], **arguments) arguments['filename'] = os.path.join( output_directory, 'Examples_Plotting_Chromaticities_CIE_1931_Chromaticity_Diagram.png') RGB = np.random.random((32, 32, 3)) plot_RGB_chromaticities_in_chromaticity_diagram_CIE1931( RGB, 'ITU-R BT.709', colourspaces=['ACEScg', 'S-Gamut'], show_pointer_gamut=True, **arguments) arguments['filename'] = os.path.join(output_directory, 'Examples_Plotting_CRI.png') plot_single_sd_colour_rendering_index_bars(colour.ILLUMINANTS_SDS['FL2'], **arguments) # ************************************************************************* # Documentation # ************************************************************************* arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_CVD_Simulation_Machado2009.png') plot_cvd_simulation_Machado2009(RGB, **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Single_Colour_Checker.png') plot_single_colour_checker('ColorChecker 2005', **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Multi_Colour_Checkers.png') plot_multi_colour_checkers(['ColorChecker 1976', 'ColorChecker 2005'], **arguments) arguments['filename'] = os.path.join(output_directory, 'Plotting_Plot_Single_SD.png') data = { 500: 0.0651, 520: 0.0705, 540: 0.0772, 560: 0.0870, 580: 0.1128, 600: 0.1360 } sd = colour.SpectralDistribution(data, name='Custom') plot_single_sd(sd, **arguments) arguments['filename'] = os.path.join(output_directory, 'Plotting_Plot_Multi_SDs.png') data_1 = { 500: 0.004900, 510: 0.009300, 520: 0.063270, 530: 0.165500, 540: 0.290400, 550: 0.433450, 560: 0.594500 } data_2 = { 500: 0.323000, 510: 0.503000, 520: 0.710000, 530: 0.862000, 540: 0.954000, 550: 0.994950, 560: 0.995000 } spd1 = colour.SpectralDistribution(data_1, name='Custom 1') spd2 = colour.SpectralDistribution(data_2, name='Custom 2') plot_multi_sds([spd1, spd2], **arguments) arguments['filename'] = os.path.join(output_directory, 'Plotting_Plot_Single_CMFS.png') plot_single_cmfs('CIE 1931 2 Degree Standard Observer', **arguments) arguments['filename'] = os.path.join(output_directory, 'Plotting_Plot_Multi_CMFS.png') cmfs = ('CIE 1931 2 Degree Standard Observer', 'CIE 1964 10 Degree Standard Observer') plot_multi_cmfs(cmfs, **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Single_Illuminant_SD.png') plot_single_illuminant_sd('A', **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Multi_Illuminant_SDs.png') plot_multi_illuminant_sds(['A', 'B', 'C'], **arguments) arguments['filename'] = os.path.join(output_directory, 'Plotting_Plot_Visible_Spectrum.png') plot_visible_spectrum(**arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Single_Lightness_Function.png') plot_single_lightness_function('CIE 1976', **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Multi_Lightness_Functions.png') plot_multi_lightness_functions(['CIE 1976', 'Wyszecki 1963'], **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Single_Luminance_Function.png') plot_single_luminance_function('CIE 1976', **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Multi_Luminance_Functions.png') plot_multi_luminance_functions(['CIE 1976', 'Newhall 1943'], **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Blackbody_Spectral_Radiance.png') plot_blackbody_spectral_radiance( 3500, blackbody='VY Canis Major', **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Blackbody_Colours.png') plot_blackbody_colours(colour.SpectralShape(150, 12500, 50), **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Single_Colour_Swatch.png') RGB = ColourSwatch(RGB=(0.32315746, 0.32983556, 0.33640183)) plot_single_colour_swatch(RGB, **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Multi_Colour_Swatches.png') RGB_1 = ColourSwatch(RGB=(0.45293517, 0.31732158, 0.26414773)) RGB_2 = ColourSwatch(RGB=(0.77875824, 0.57726450, 0.50453169)) plot_multi_colour_swatches([RGB_1, RGB_2], **arguments) arguments['filename'] = os.path.join(output_directory, 'Plotting_Plot_Single_Function.png') plot_single_function(lambda x: x ** (1 / 2.2), **arguments) arguments['filename'] = os.path.join(output_directory, 'Plotting_Plot_Multi_Functions.png') functions = { 'Gamma 2.2': lambda x: x ** (1 / 2.2), 'Gamma 2.4': lambda x: x ** (1 / 2.4), 'Gamma 2.6': lambda x: x ** (1 / 2.6), } plot_multi_functions(functions, **arguments) arguments['filename'] = os.path.join(output_directory, 'Plotting_Plot_Image.png') path = os.path.join(colour.__path__[0], '..', 'docs', '_static', 'Logo_Medium_001.png') plot_image(colour.read_image(str(path)), **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Corresponding_Chromaticities_Prediction.png') plot_corresponding_chromaticities_prediction(1, 'Von Kries', 'CAT02', **arguments) arguments['filename'] = os.path.join(output_directory, 'Plotting_Plot_Spectral_Locus.png') plot_spectral_locus(spectral_locus_colours='RGB', **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Chromaticity_Diagram_Colours.png') plot_chromaticity_diagram_colours(**arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Chromaticity_Diagram.png') plot_chromaticity_diagram(**arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Chromaticity_Diagram_CIE1931.png') plot_chromaticity_diagram_CIE1931(**arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Chromaticity_Diagram_CIE1960UCS.png') plot_chromaticity_diagram_CIE1960UCS(**arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Chromaticity_Diagram_CIE1976UCS.png') plot_chromaticity_diagram_CIE1976UCS(**arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_SDs_In_Chromaticity_Diagram.png') A = colour.ILLUMINANTS_SDS['A'] D65 = colour.ILLUMINANTS_SDS['D65'] plot_sds_in_chromaticity_diagram([A, D65], **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_SDs_In_Chromaticity_Diagram_CIE1931.png') plot_sds_in_chromaticity_diagram_CIE1931([A, D65], **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_SDs_In_Chromaticity_Diagram_CIE1960UCS.png') plot_sds_in_chromaticity_diagram_CIE1960UCS([A, D65], **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_SDs_In_Chromaticity_Diagram_CIE1976UCS.png') plot_sds_in_chromaticity_diagram_CIE1976UCS([A, D65], **arguments) arguments['filename'] = os.path.join(output_directory, 'Plotting_Plot_Pointer_Gamut.png') plot_pointer_gamut(**arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_RGB_Colourspaces_In_Chromaticity_Diagram.png') plot_RGB_colourspaces_in_chromaticity_diagram( ['ITU-R BT.709', 'ACEScg', 'S-Gamut'], **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_RGB_Colourspaces_In_Chromaticity_Diagram_CIE1931.png') plot_RGB_colourspaces_in_chromaticity_diagram_CIE1931( ['ITU-R BT.709', 'ACEScg', 'S-Gamut'], **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_RGB_Colourspaces_In_' 'Chromaticity_Diagram_CIE1960UCS.png') plot_RGB_colourspaces_in_chromaticity_diagram_CIE1960UCS( ['ITU-R BT.709', 'ACEScg', 'S-Gamut'], **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_RGB_Colourspaces_In_' 'Chromaticity_Diagram_CIE1976UCS.png') plot_RGB_colourspaces_in_chromaticity_diagram_CIE1976UCS( ['ITU-R BT.709', 'ACEScg', 'S-Gamut'], **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_RGB_Chromaticities_In_' 'Chromaticity_Diagram_Plot.png') RGB = np.random.random((128, 128, 3)) plot_RGB_chromaticities_in_chromaticity_diagram(RGB, 'ITU-R BT.709', **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_RGB_Chromaticities_In_' 'Chromaticity_Diagram_CIE1931.png') plot_RGB_chromaticities_in_chromaticity_diagram_CIE1931( RGB, 'ITU-R BT.709', **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_RGB_Chromaticities_In_' 'Chromaticity_Diagram_CIE1960UCS.png') plot_RGB_chromaticities_in_chromaticity_diagram_CIE1960UCS( RGB, 'ITU-R BT.709', **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_RGB_Chromaticities_In_' 'Chromaticity_Diagram_CIE1976UCS.png') plot_RGB_chromaticities_in_chromaticity_diagram_CIE1976UCS( RGB, 'ITU-R BT.709', **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Ellipses_MacAdam1942_In_Chromaticity_Diagram.png') plot_ellipses_MacAdam1942_in_chromaticity_diagram(**arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Ellipses_MacAdam1942_In_' 'Chromaticity_Diagram_CIE1931.png') plot_ellipses_MacAdam1942_in_chromaticity_diagram_CIE1931(**arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Ellipses_MacAdam1942_In_' 'Chromaticity_Diagram_CIE1960UCS.png') plot_ellipses_MacAdam1942_in_chromaticity_diagram_CIE1960UCS(**arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Ellipses_MacAdam1942_In_' 'Chromaticity_Diagram_CIE1976UCS.png') plot_ellipses_MacAdam1942_in_chromaticity_diagram_CIE1976UCS(**arguments) arguments['filename'] = os.path.join(output_directory, 'Plotting_Plot_Single_CCTF.png') plot_single_cctf('ITU-R BT.709', **arguments) arguments['filename'] = os.path.join(output_directory, 'Plotting_Plot_Multi_CCTFs.png') plot_multi_cctfs(['ITU-R BT.709', 'sRGB'], **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Single_Munsell_Value_Function.png') plot_single_munsell_value_function('ASTM D1535-08', **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Multi_Munsell_Value_Functions.png') plot_multi_munsell_value_functions(['ASTM D1535-08', 'McCamy 1987'], **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Single_SD_Rayleigh_Scattering.png') plot_single_sd_rayleigh_scattering(**arguments) arguments['filename'] = os.path.join(output_directory, 'Plotting_Plot_The_Blue_Sky.png') plot_the_blue_sky(**arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Colour_Quality_Bars.png') illuminant = colour.ILLUMINANTS_SDS['FL2'] light_source = colour.LIGHT_SOURCES_SDS['Kinoton 75P'] light_source = light_source.copy().align(colour.SpectralShape(360, 830, 1)) cqs_i = colour.colour_quality_scale(illuminant, additional_data=True) cqs_l = colour.colour_quality_scale(light_source, additional_data=True) plot_colour_quality_bars([cqs_i, cqs_l], **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Single_SD_Colour_Rendering_Index_Bars.png') illuminant = colour.ILLUMINANTS_SDS['FL2'] plot_single_sd_colour_rendering_index_bars(illuminant, **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Multi_SDs_Colour_Rendering_Indexes_Bars.png') light_source = colour.LIGHT_SOURCES_SDS['Kinoton 75P'] plot_multi_sds_colour_rendering_indexes_bars([illuminant, light_source], **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Single_SD_Colour_Quality_Scale_Bars.png') illuminant = colour.ILLUMINANTS_SDS['FL2'] plot_single_sd_colour_quality_scale_bars(illuminant, **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Multi_SDs_Colour_Quality_Scales_Bars.png') light_source = colour.LIGHT_SOURCES_SDS['Kinoton 75P'] plot_multi_sds_colour_quality_scales_bars([illuminant, light_source], **arguments) arguments['filename'] = os.path.join(output_directory, 'Plotting_Plot_Planckian_Locus.png') plot_planckian_locus(**arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Planckian_Locus_In_Chromaticity_Diagram.png') plot_planckian_locus_in_chromaticity_diagram(['A', 'B', 'C'], **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Planckian_Locus_In_Chromaticity_Diagram_CIE1931.png') plot_planckian_locus_in_chromaticity_diagram_CIE1931(['A', 'B', 'C'], **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_Planckian_Locus_In_Chromaticity_Diagram_CIE1960UCS.png') plot_planckian_locus_in_chromaticity_diagram_CIE1960UCS(['A', 'B', 'C'], **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_RGB_Colourspaces_Gamuts.png') plot_RGB_colourspaces_gamuts(['ITU-R BT.709', 'ACEScg', 'S-Gamut'], **arguments) arguments['filename'] = os.path.join( output_directory, 'Plotting_Plot_RGB_Colourspaces_Gamuts.png') plot_RGB_colourspaces_gamuts(['ITU-R BT.709', 'ACEScg', 'S-Gamut'], **arguments) arguments['filename'] = os.path.join(output_directory, 'Plotting_Plot_RGB_Scatter.png') plot_RGB_scatter(RGB, 'ITU-R BT.709', **arguments) # ************************************************************************* # "tutorial.rst" # ************************************************************************* arguments['filename'] = os.path.join(output_directory, 'Tutorial_Visible_Spectrum.png') plot_visible_spectrum(**arguments) arguments['filename'] = os.path.join(output_directory, 'Tutorial_Sample_SD.png') sample_sd_data = { 380: 0.048, 385: 0.051, 390: 0.055, 395: 0.060, 400: 0.065, 405: 0.068, 410: 0.068, 415: 0.067, 420: 0.064, 425: 0.062, 430: 0.059, 435: 0.057, 440: 0.055, 445: 0.054, 450: 0.053, 455: 0.053, 460: 0.052, 465: 0.052, 470: 0.052, 475: 0.053, 480: 0.054, 485: 0.055, 490: 0.057, 495: 0.059, 500: 0.061, 505: 0.062, 510: 0.065, 515: 0.067, 520: 0.070, 525: 0.072, 530: 0.074, 535: 0.075, 540: 0.076, 545: 0.078, 550: 0.079, 555: 0.082, 560: 0.087, 565: 0.092, 570: 0.100, 575: 0.107, 580: 0.115, 585: 0.122, 590: 0.129, 595: 0.134, 600: 0.138, 605: 0.142, 610: 0.146, 615: 0.150, 620: 0.154, 625: 0.158, 630: 0.163, 635: 0.167, 640: 0.173, 645: 0.180, 650: 0.188, 655: 0.196, 660: 0.204, 665: 0.213, 670: 0.222, 675: 0.231, 680: 0.242, 685: 0.251, 690: 0.261, 695: 0.271, 700: 0.282, 705: 0.294, 710: 0.305, 715: 0.318, 720: 0.334, 725: 0.354, 730: 0.372, 735: 0.392, 740: 0.409, 745: 0.420, 750: 0.436, 755: 0.450, 760: 0.462, 765: 0.465, 770: 0.448, 775: 0.432, 780: 0.421 } sd = colour.SpectralDistribution(sample_sd_data, name='Sample') plot_single_sd(sd, **arguments) arguments['filename'] = os.path.join(output_directory, 'Tutorial_SD_Interpolation.png') sd_copy = sd.copy() sd_copy.interpolate(colour.SpectralShape(400, 770, 1)) plot_multi_sds( [sd, sd_copy], bounding_box=[730, 780, 0.25, 0.5], **arguments) arguments['filename'] = os.path.join(output_directory, 'Tutorial_Sample_Swatch.png') sd = colour.SpectralDistribution(sample_sd_data) cmfs = colour.STANDARD_OBSERVERS_CMFS[ 'CIE 1931 2 Degree Standard Observer'] illuminant = colour.ILLUMINANTS_SDS['D65'] with domain_range_scale('1'): XYZ = colour.sd_to_XYZ(sd, cmfs, illuminant) RGB = colour.XYZ_to_sRGB(XYZ) plot_single_colour_swatch( ColourSwatch('Sample', RGB), text_parameters={'size': 'x-large'}, **arguments) arguments['filename'] = os.path.join(output_directory, 'Tutorial_Neutral5.png') patch_name = 'neutral 5 (.70 D)' patch_sd = colour.COLOURCHECKERS_SDS['ColorChecker N Ohta'][patch_name] with domain_range_scale('1'): XYZ = colour.sd_to_XYZ(patch_sd, cmfs, illuminant) RGB = colour.XYZ_to_sRGB(XYZ) plot_single_colour_swatch( ColourSwatch(patch_name.title(), RGB), text_parameters={'size': 'x-large'}, **arguments) arguments['filename'] = os.path.join(output_directory, 'Tutorial_Colour_Checker.png') plot_single_colour_checker( colour_checker='ColorChecker 2005', text_parameters={'visible': False}, **arguments) arguments['filename'] = os.path.join( output_directory, 'Tutorial_CIE_1931_Chromaticity_Diagram.png') xy = colour.XYZ_to_xy(XYZ) plot_chromaticity_diagram_CIE1931(standalone=False) x, y = xy plt.plot(x, y, 'o-', color='white') # Annotating the plot. plt.annotate( patch_sd.name.title(), xy=xy, xytext=(-50, 30), textcoords='offset points', arrowprops=dict(arrowstyle='->', connectionstyle='arc3, rad=-0.2')) render( standalone=True, limits=(-0.1, 0.9, -0.1, 0.9), x_tighten=True, y_tighten=True, **arguments) # ************************************************************************* # "basics.rst" # ************************************************************************* arguments['filename'] = os.path.join(output_directory, 'Basics_Logo_Small_001_CIE_XYZ.png') RGB = colour.read_image( os.path.join(output_directory, 'Logo_Small_001.png'))[..., 0:3] XYZ = colour.sRGB_to_XYZ(RGB) colour.plotting.plot_image( XYZ, text_parameters={'text': 'sRGB to XYZ'}, **arguments)
data = response.json() image_id = data['id'] url2 = data['image'] response = requests.get(url2) with open(r'%s.jpg' %image_id,'wb') as f: f.write(response.content) # Open the image. img_bgr = cv2.imread('%s.jpg' %image_id) img = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB) #Apply gamma correction. gamma = 2.4 gamma_img = np.array(255*(img / 255) ** gamma, dtype = 'uint8') avg_color_gamma = gamma_img.mean(axis=0).mean(axis=0) dominant_color_gamma = dominant(gamma_img) XYZ1 = colour.sRGB_to_XYZ(dominant_color_gamma) xy = colour.XYZ_to_xy(XYZ1) saveCIE(xy, image_id) url = 'https://www.gyanvihar.org/arastu/uploads/' files = {'image': open('%s.png' %image_id, 'rb')} requests.post(url, files=files)
sd_dark_skin, illuminant=colour.SDS_ILLUMINANTS["D65"] ) / 100 ) ) print("\n") RGB = np.array([0.45675795, 0.30986982, 0.24861924]) message_box( f'Converting to the "CAM16-UCS" colourspace from given "Output-Referred" ' f'"sRGB" colourspace values:\n\n\t{RGB}' ) print(colour.convert(RGB, "Output-Referred RGB", "CAM16UCS")) specification = colour.XYZ_to_CAM16( colour.sRGB_to_XYZ(RGB) * 100, XYZ_w=colour.xy_to_XYZ( colour.CCS_ILLUMINANTS["CIE 1931 2 Degree Standard Observer"]["D65"] ) * 100, L_A=64 / np.pi * 0.2, Y_b=20, ) print( colour.JMh_CAM16_to_CAM16UCS( colour.utilities.tstack( [ specification.J, specification.M, specification.h, ]
def on_click4(self): #foto stream = io.BytesIO() with picamera.PiCamera() as camera: camera.start_preview() time.sleep(2) camera.capture(stream, format='jpeg') # Construct a numpy array from the stream data = np.frombuffer(stream.getvalue(), dtype=np.uint8) # "Decode" the image from the array, preserving colour image = cv2.imdecode(data, 1) # OpenCV returns an array with data in BGR order. If you want RGB instead # use the following... image = image[:, :, ::-1] cv2.imwrite('original.png', image) pixmap = QtGui.QPixmap('./original.png').scaled( 200, 180, QtCore.Qt.KeepAspectRatio) self.label_3.setPixmap(pixmap) image = image[150:190, 300:360] cv2.imwrite('escala.png', image) pixmap = QtGui.QPixmap('./escala.png').scaled( 200, 180, QtCore.Qt.KeepAspectRatio) self.label_4.setPixmap(pixmap) ########################################################### #Promedio de pixeles####################################### ########################################################### r = image[:, :, 0] g = image[:, :, 1] b = image[:, :, 2] rp = r.sum() / (r.shape[0] * r.shape[1]) gp = g.sum() / (g.shape[0] * g.shape[1]) bp = b.sum() / (b.shape[0] * b.shape[1]) ########################################################### #uso de la libreria colour-science para hallar los kelvin## ############################################################ RGB = np.array([rp, gp, bp]) # Conversion to tristimulus values. XYZ = colour.sRGB_to_XYZ(RGB / 255) # Conversion to chromaticity coordinates. xy = colour.XYZ_to_xy(XYZ) # Conversion to correlated colour temperature in K. CCT = colour.temperature.xy_to_CCT_Hernandez1999(xy) #rp,gp,bp self.CCT = CCT if self.CCT < 0: self.label_5.setText( _translate("MainWindow", "KELVIN OUT: " + str("intenta de nuevo"), None)) self.label_5.setText( _translate("MainWindow", "KELVIN OUT: " + str(round(self.CCT)), None)) offRed() offBlue() self.pushButton_4.setStyleSheet( _fromUtf8("background-color: rgb(29, 29, 29);")) print(self.CCT)
def detect_breaking_events(time, crx_dist, rgb, crx_start=None, crx_end=None, px_mtrc="lightness", colours=None, resample_rule="100L", algorithm="peaks", peak_detection="local_maxima", posterize=False, ncolours=0, threshold=0.1, tswindow=11, denoise=True, pxwindow=3, mask_drysand=False, fix_constrast=False): """ Detect wave breaking events. Two main methods are implemented: 1 - Peak detection: detect wave breaking as lightness peaks in the timestack Two peak detection methods are implemented: 1-a Local maxima. Uses peaklocalextremas() function from pywavelearn to detect local maximas corresponding to wave breaking. 1-b Differential. Uses the first temporal derivative of the pixel intensity to detect sharp transitions in the timestack that should correspond to wave breaking. In both cases, the user can tell to the script to classifiy the identified pixel peaks based on known colours. For exemple, water is usually blue, sand is brownish and breaking waves are whiteish. Only peaks corresponding to wave breakin are append to the output structure. This is step done using classifiy_colour() from pywavelearn. 2 - Edge detection: detect wave breaking as sharp edges in the timestack Two-options are available: 2-a Edges only. Wave breaking events are obtained applying a sobel filter to the timestack. Edge locations (time,space) are obrained as: - argument of the maxima (argmax) of a cross-shore pixel intenstiy series obtained at every timestamp. - local maximas of a cross-shore pixel intenstiy series obtained at every timestamp. 2-b Edges and colours. Wave breaking events are obtained applying a Sobel filter to the timestack and the detected Edges are classified using the colour information as in 1-a. Edge locations (time,space) are obrained as: - argument of the maxima (argmax) of a cross-shore pixel intenstiy series obtained at every timestamp. - local maximas of a cross-shore pixel intenstiy series obtained at every timestamp. ---------- Args: time (Mandatory [np.array]): Array of datetimes. crx_dist (Mandatory [np.array]): Array of cross-shore locations. rgb (Mandatory [np.array]): timestack array. Shape is [time,crx_dist,3]. crx_start (Optional [float]): where in the cross-shore orientation to start the analysis. Default is crx_dist.min(). crx_start (Optional [float]): where in the cross-shore orientation to finish the analysis. Default is crx_dist.max(). px_mtrc (Optional [float]): Which pixel intenstiy metric to use. Default is "lightness". resample_rule (Optional [str]): To which frequency interpolate timeseries Default is "100L". algorithm (Optional [str]): Wave breaking detection algorithm. Default is "peaks". peak_detection (Optional [str]): Peak detection algorithm. Default is "local_maxima". threshold (Optional [float]): Threshold for peak detection algorithm. Default is 0.1 tswindow (Optional [int]): Window for peak detection algorithm. Default is 11. denoise (Optional [bool]): = Denoise timestack using denoise_bilateral Default is True. pxwindow (Optional [int]): Window for denoise_bilateral. Default is 3. posterize (Optional [bool]): If true will reduce the number of colours in the timestack. Default is False. ncolours (Optional [str]): Number of colours to posterize. Default is 16. colours (Optional [dict]): A dictionary for the colour learning step. Something like: train_colours = {'labels':[0,1,2], 'aliases': ["sand","water","foam"], 'rgb':[[195,185,155], [30,75,75], [255,255,255]] 'target':2} Default is None. mask_drysand (Experimental [bool]) = Mask dry sand using a colour-temperature (CCT) relationship. Default is False. ---------- Return: time (Mandatory [np.array]): time of occurance of wave breaking events. breakers (Mandatory [np.array]): cross-shore location of wave breaking events. """ if not crx_start: crx_start = crx_dist.min() crx_end = crx_dist.max() if posterize: print(" + >> posterizing") rgb = colour_quantization(rgb, ncolours=ncolours) # get colour data if algorithm == "colour" or algorithm == "edges_and_colour": target = colours["target"] labels = colours["labels"] dom_colours = colours["rgb"] # denoise a little bedore computing edges if denoise: rgb = denoise_bilateral(rgb, pxwindow, multichannel=True) # scale back to 0-255 rgb = (rgb - rgb.min()) / (rgb.max() - rgb.min()) * 255 # mask sand - Not fully tested if mask_drysand: print(" + >> masking dry sand [Experimental]") # calculate colour temperature cct = colour.xy_to_CCT_Hernandez1999( colour.XYZ_to_xy(colour.sRGB_to_XYZ(rgb / 255))) # scale back to 0-1 cct = (cct - cct.min()) / (cct.max() - cct.min()) * 255 # mask i, j = np.where(cct == 0) rgb[i, j, :] = 0 if fix_constrast: print(" + >> fixing contrast") rgb = exposure.equalize_hist(rgb) # rgb = (rgb-rgb.min())/(rgb.max()-rgb.min())*255 # detect edges if algorithm == "edges" or algorithm == "edges_and_colour": print(" + >> calculating edges") edges = sobel_h(rgb2grey(rgb)) # get pixel lines and RGB values at selected locations only if algorithm == "peaks" or algorithm == "colour": print(" + >> extracting cross-shore pixels") # rescale rgb = (rgb - rgb.min()) / (rgb.max() - rgb.min()) * 255 Y, crx_idx = get_analysis_locations(crx_dist, crx_start, crx_end) Time, PxInts, RGB = get_pixel_lines(time, rgb, crx_idx, resample_rule=resample_rule, pxmtc=px_mtrc) # get analysis frequency and a 1 sececond time window if not tswindow: fs = (time[1] - time[0]).total_seconds() win = np.int((1 / fs)) else: win = tswindow print(" + >> detecting breaking events") PeakTimes = [] print_check = False if algorithm == "peaks" or algorithm == "colour": if peak_detection == "argmax": peak_detection = "local_maxima" print(" - >> setting peak detection to local maxima") # loop over data rows for pxint, rgb in zip(PxInts, RGB): # calculate baseline bline = baseline(pxint, 2) # calculate pixel peaks if peak_detection == "local_maxima": _, max_idx = peaklocalextremas(pxint - bline, lookahead=win, delta=threshold * (pxint - bline).max()) elif peak_detection == "differential": # calculate first derivative pxintdt = np.diff(pxint - bline) # remove values below zero pxintdt[pxintdt <= 0] = 0 # scale from 0 to 1 pxintdt = pxintdt / pxintdt.max() # get indexes max_idx = indexes(pxintdt, thres=threshold, min_dist=win) else: raise ValueError # colour learning step if algorithm == "colour": if not print_check: print(" + >> colour learning") print_check = True # classifiy pixels breaker_idxs = [] for idx in max_idx: y_pred = classify_colour(rgb[idx], dom_colours, labels) if y_pred[0] == target: breaker_idxs.append(idx) # peaks only else: breaker_idxs = max_idx PeakTimes.append(Time[breaker_idxs]) # organize peaks and times Xpeaks = [] Ypeaks = [] for i, pxtimes in enumerate(PeakTimes): for v in pxtimes: Xpeaks.append(v) for v in np.ones(len(pxtimes)) * Y[i]: Ypeaks.append(v) # edges case if algorithm == "edges": Xpeaks = [] Ypeaks = [] # loop in time for i, t in enumerate(time): # cross-shore line crx_line = edges[i, :] # peaks with robust peak detection if peak_detection == "differential" or \ peak_detection == "local_maxima": crx_line = (crx_line - crx_line.min()) / (crx_line.max() - crx_line.min()) if not np.all(crx_line == 0): idx_peak = indexes(crx_line, thres=1 - threshold, min_dist=win) # apped peaks for peak in idx_peak: if crx_dist[peak] > crx_start and crx_dist[peak] < crx_end: Xpeaks.append(t) Ypeaks.append(crx_dist[peak]) # peaks with simple argmax - works better without colour learning else: peak = np.argmax(crx_line) if crx_dist[peak] > crx_start and crx_dist[peak] < crx_end: Xpeaks.append(t) Ypeaks.append(crx_dist[peak]) # edges + colour learning case if algorithm == "edges_and_colour": Ipeaks = [] Jpeaks = [] # loop in time for i, t in enumerate(time): # cross-shore line crx_line = edges[i, :] if peak_detection == "differential" or \ peak_detection == "local_maxima": crx_line = (crx_line - crx_line.min()) / (crx_line.max() - crx_line.min()) # peaks if not np.all(crx_line == 0): idx_peak = indexes(crx_line, thres=1 - threshold, min_dist=win) if not np.all(crx_line == 0): idx_peak = indexes(crx_line, thres=1 - threshold, min_dist=win) # apped peaks for peak in idx_peak: if crx_dist[peak] > crx_start and crx_dist[peak] < crx_end: Ipeaks.append(i) Jpeaks.append(peak) else: peak = np.argmax(crx_line) if crx_dist[peak] > crx_start and crx_dist[peak] < crx_end: Ipeaks.append(i) Jpeaks.append(peak) # colour learning step Xpeaks = [] Ypeaks = [] for i, j in zip(Ipeaks, Jpeaks): if not print_check: print(" + >> colour learning") print_check = True # classify colour y_pred = classify_colour(rgb[i, j, :], dom_colours, labels) if y_pred[0] == target: Xpeaks.append(time[i]) Ypeaks.append(crx_dist[j]) # sort values in time and outout y = np.array(Ypeaks)[np.argsort(date2num(Xpeaks))] x = np.array(Xpeaks)[np.argsort(Xpeaks)] return ellapsedseconds(x), y
colorspace = colour.models.BT709_COLOURSPACE colorspace.use_derived_transformation_matrices(True) RGB_to_XYZ_m = colorspace.RGB_to_XYZ_matrix XYZ_to_RGB_m = colorspace.XYZ_to_RGB_matrix # for performance use a larger interval. Harder to solve, must raise tol interval = 40 shape = colour.SpectralShape(380.0, 730.0, interval) # spd via Meng-ish Burns-ish recovery target_XYZ = colour.sRGB_to_XYZ([1,0,0]) spd = XYZ_to_spectral(target_XYZ, cmfs=CMFS.align(shape), illuminant=illuminant_SPD, interval=interval, tolerance=1e-8, max_refl=1.00) print("red SPD is", spd.values) target_XYZ = colour.sRGB_to_XYZ([0,1,0]) spd = XYZ_to_spectral(target_XYZ, cmfs=CMFS.align(shape), illuminant=illuminant_SPD, interval=interval, tolerance=1e-8, max_refl=1.00) print("green SPD is", spd.values) target_XYZ = colour.sRGB_to_XYZ([0,0,1]) spd = XYZ_to_spectral(target_XYZ, cmfs=CMFS.align(shape), illuminant=illuminant_SPD, interval=interval, tolerance=1e-8, max_refl=1.00) print("blue SPD is", spd.values) CMFS_ = CMFS.align(spd.shape).values.transpose() # align and transpose the CMFS illuminant_SPD_ = illuminant_SPD.align(spd.shape).values # align illuminant vector
def _pick_color_mode(self, tdw, x, y, mode): # init shared variables between normal and CIECAM modes doc = self.doc tdw = self.doc.tdw app = self.doc.app p = self.app.preferences elapsed = None t, x, y, pressure = doc.get_last_event_info(tdw) # TODO configure static pressure as a slider? # This would allow non-pressure devices to use # pressures besides 50% for brushes too if pressure is None: pressure = 0.5 if p['color.pick_blend_use_pressure'] is False: pressure = 0.0 if t <= doc.last_colorpick_time: t = (time.time() * 1000) # limit rate for performance min_wait = p['color.adjuster_min_wait'] if doc.last_colorpick_time: elapsed = t - doc.last_colorpick_time if elapsed < min_wait: return cm = app.brush_color_manager prefs = cm.get_prefs() lightsource = prefs['color.dimension_lightsource'] if lightsource == "custom_XYZ": lightsource = prefs['color.dimension_lightsource_XYZ'] else: lightsource = colour.ILLUMINANTS['cie_2_1931'][lightsource] doc.last_colorpick_time = t pickcolor = tdw.pick_color(x, y, size=int(3/tdw.renderer.scale)) brushcolor = self._get_app_brush_color() brushcolor_rgb = brushcolor.get_rgb() pickcolor_rgb = pickcolor.get_rgb() # grab the color with sRGB context pickcolor_cie = lib.color.CIECAMColor(color=pickcolor, cieaxes=brushcolor.cieaxes) # if brush and pick colors are the same, nothing to do if brushcolor_rgb != pickcolor_rgb: pickcolor_hsv = pickcolor.get_hsv() brushcolor_hsv = brushcolor.get_hsv() cm = self.doc.app.brush_color_manager # normal pick mode if mode == "PickAll": cm.set_color(pickcolor) elif mode == "PickIlluminant": ill = colour.sRGB_to_XYZ(np.array(pickcolor_rgb))*100 if ill[1] <= 0: return fac = 1/ill[1]*100 p['color.dimension_lightsource'] = "custom_XYZ" p['color.dimension_lightsource_XYZ'] = ( ill[0]*fac, ill[1]*fac, ill[2]*fac ) # update pref ui app.preferences_window.update_ui() # reset the brush color with the same color # under the new illuminant brushcolor.lightsource = ill * fac app.brush.set_color_hsv(brushcolor.get_hsv()) app.brush.set_ciecam_color(brushcolor) elif mode == "PickandBlend": alloc = self.doc.tdw.get_allocation() size = max(int(p['color.preview_size'] * .01 * alloc.height), self.MIN_PREVIEW_SIZE) if self.starting_color is None: self.starting_color = pickcolor dist = np.linalg.norm( np.array(self.starting_position) - np.array((x, y))) dist = np.clip(dist / size + pressure, 0, 1) if p['color.pick_blend_reverse'] is True: dist = 1 - dist self.blending_ratio = dist brushcolor_pig = lib.color.PigmentColor(color=brushcolor) pickcolor_pig = lib.color.PigmentColor( color=self.starting_color) self.blending_color = brushcolor_pig.mix(pickcolor_pig, dist) elif mode == "PickTarget": doc.last_color_target = pickcolor else: # pick V, S, H independently # using CIECAM brushcolornew = brushcolor if mode == "PickHue": brushcolornew.h = pickcolor_cie.h elif mode == "PickLuma": brushcolornew.v = pickcolor_cie.v elif mode == "PickChroma": brushcolornew.s = pickcolor_cie.s app.brush.set_color_hsv(brushcolornew.get_hsv()) app.brush.set_ciecam_color(brushcolornew) return None
noise=np.random.normal(0,meanlc*0.01,np.shape(dRGB)) dRGB+=noise g=np.array(g) print("start optimization...") I_init=np.ones((Nx,Ny)) y = mfista_grouplasso(I_init, dRGB, g, lambda_gl = 1.e-1) plt.imshow(y) plt.savefig("carGroupLasso.png") ti=timg.reshape(np.shape(timg)[0]*np.shape(timg)[1],3) #XYZからxyへ変換 ti=timg.reshape(np.shape(timg)[0]*np.shape(timg)[1],3) XYZ = colour.sRGB_to_XYZ(ti) xy = colour.XYZ_to_xy(XYZ) #CIE_1931_chromaticity_diagram_colours_plot(bounding_box=(-0.1, 0.9, -0.1, 0.9), standalone=False) #plot_chromaticity_diagram_CIE1931(bounding_box=(0.15, 0.65, 0.15, 0.65), standalone=False) #sRGB領域へプロット #plt.plot(xy[:,0], xy[:,1], 'o', markersize=2, label="sRGB",color="gray",alpha=0.2) fig=plt.figure(figsize=(10,5)) ax=fig.add_subplot(121,aspect=1.0) ax.scatter(xy[:,0], xy[:,1],facecolors=ti,alpha=1,s=2) ax.set_xlim(0.15,0.62) ax.set_ylim(0.2,0.62) ax.set_title("Original") #plt.legend() yi=y.reshape(np.shape(y)[0]*np.shape(y)[1],3)