def main(): target = sys.argv[1] # target IP (R,G,B) = (int(sys.argv[2]), int(sys.argv[3]), int(sys.argv[4])) print "Setting target %s to R=%i G=%i B=%i" % (target, R,G,B) S = socket.socket(socket.AF_INET,socket.SOCK_DGRAM) packet1 = KINETPortOut() packet2 = KINETPortOut() while(True): for H in range(0,360): #print H time.sleep (.001) packet1.port = 0x01 for i in range(0,50,2): hsl = HSLColor(H,.5+.5/360,float(i)/100.0) rgb = hsl.convert_to('rgb') packet1.payload[3*i] = rgb.rgb_r packet1.payload[3*i+1] = rgb.rgb_g packet1.payload[3*i+2] = rgb.rgb_b packet2.port = 0x02 for i in range(0,50,2): hsl = HSLColor(H,.5,float(i)/100.0+.5) rgb = hsl.convert_to('rgb') packet2.payload[3*i] = rgb.rgb_r packet2.payload[3*i+1] = rgb.rgb_g packet2.payload[3*i+2] = rgb.rgb_b for i in range(1,49,2): hsl = HSLColor(H+50,.5,float(i)/100.0) rgb = hsl.convert_to('rgb') packet1.payload[3*i] = rgb.rgb_r packet1.payload[3*i+1] = rgb.rgb_g packet1.payload[3*i+2] = rgb.rgb_b for i in range(1,49,2): hsl = HSLColor(H+50,.5+.5/360,float(i)/100.0+.5) rgb = hsl.convert_to('rgb') packet2.payload[3*i] = rgb.rgb_r packet2.payload[3*i+1] = rgb.rgb_g packet2.payload[3*i+2] = rgb.rgb_b N = int(random.uniform(0,49)) packet2.payload[3*N] = 255 packet2.payload[3*N+1] = 100 packet2.payload[3*N+2] = 100 packet1.payload[3*N] = 255 packet1.payload[3*N+1] = 100 packet1.payload[3*N+2] = 100 S.sendto(packet1, (target, 6038)); S.sendto(packet2, (target, 6038)); syncpacket = KINETSyncOut() S.sendto(syncpacket, (target, 6038)); S.close
def randomColor(): import random from colormath.color_objects import HSLColor, sRGBColor from colormath.color_conversions import convert_color rCol = (random.randint(0, 360),random.randint(0, 100)/100.0,random.randint(0, 100)/100.0) return convert_color(HSLColor(*rCol), sRGBColor).get_upscaled_value_tuple() ,random.randint(0, 255)
def RGB_to_HSL(cobj, *args, **kwargs): """ Converts from RGB to HSL. H values are in degrees and are 0 to 360. S values are a percentage, 0.0 to 1.0. L values are a percentage, 0.0 to 1.0. """ var_R = cobj.rgb_r var_G = cobj.rgb_g var_B = cobj.rgb_b var_max = max(var_R, var_G, var_B) var_min = min(var_R, var_G, var_B) var_H = __RGB_to_Hue(var_R, var_G, var_B, var_min, var_max) var_L = 0.5 * (var_max + var_min) if var_max == var_min: var_S = 0 elif var_L <= 0.5: var_S = (var_max - var_min) / (2.0 * var_L) else: var_S = (var_max - var_min) / (2.0 - (2.0 * var_L)) return HSLColor( var_H, var_S, var_L)
def apply_ops(pixels): current_rgb = np.array(pixels, dtype=int) # Do RGB operations for op in stages["rgb"]: if op in sums: for ctrl_array in sums[op].values(): current_rgb += ctrl_array try: # Do HSL operations np.clip(current_rgb, 0, 255, out=current_rgb) current_hsl = np.zeros_like(current_rgb) for i in range(PIXEL_COUNT): current_hsl[i, :] = convert_color(sRGBColor(*current_rgb[i]), HSLColor).get_value_tuple() for op in stages["hsl"]: if op in sums: for ctrl_array in sums[op].values(): current_hsl += ctrl_array # Convert to RGB finally final_rgb = np.zeros_like(current_hsl) for i in range(PIXEL_COUNT): final_rgb[i, :] = convert_color(HSLColor(*current_hsl[i]), sRGBColor).get_value_tuple() except Exception as e: logging.exception("update_pixels") final_rgb = current_rgb # Final clipping np.clip(final_rgb, 0, 255, out=final_rgb) return final_rgb.astype(np.uint8)
def modify_rgb(rgb_tuple, level=0.5, color_sensitivity=0.05): rgb = rgb_int_to_float(rgb_tuple) rgb_class = sRGBColor(rgb[0], rgb[1], rgb[2]) hsl = convert_color(rgb_class, HSLColor).get_value_tuple() intensity = get_intensity(int(hsl[0])) new_hsl = convert(hsl, intensity, level, color_sensitivity) new_hsl = HSLColor(new_hsl[0], new_hsl[1], new_hsl[2]) new_rgb = convert_color(new_hsl, sRGBColor).get_value_tuple() new_rgb_int = rgb_float_to_int(new_rgb) return new_rgb_int
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 convert_hue(hue, adjust=lum_adjust_color, min_delta=min_delta_background_color): """Create a color from a hue and adjust its luminance until the Delta E between the color and the background is sufficient. """ color_hsl = HSLColor(hue, 1, .5) color_lab = convert_color(color_hsl, LabColor) while True: if delta_e(color_lab, background) < min_delta: color_hsl.hsl_l += adjust color_lab = convert_color(color_hsl, LabColor) else: return [hue, color_lab]
def generate_random_color_map(min_scalar_value, max_scalar_value, num_cps, min_lightness=0.4, max_lightness=0.9, min_saturation=0.6, max_saturation=0.7): all_colors = [] prior_lightness = None for cdx in range(num_cps): rand_hue = np.random.uniform(0.0, 360.0) rand_saturation = np.random.uniform(min_saturation, max_saturation) cur_max_lightness = (cdx + 1) * ( (max_lightness - min_lightness) / num_cps) if prior_lightness is None: rand_lightness = np.random.uniform(min_lightness, cur_max_lightness) else: rand_lightness = np.random.uniform(prior_lightness, cur_max_lightness) prior_lightness = rand_lightness rand_rgb = convert_color( HSLColor(rand_hue, rand_saturation, rand_lightness), sRGBColor) all_colors.append(rand_rgb.get_value_tuple()) all_colors[num_cps / 2] = (0.95, 0.95, 0.95) color_mapping = [] prior_scalar_val = 0 for rdx, rgb in enumerate(all_colors): next_scalar_val = min_scalar_value + (max_scalar_value - min_scalar_value) * \ (float(rdx) / (len(all_colors) - 1)) scalar_val = prior_scalar_val + ( next_scalar_val - prior_scalar_val) * np.random.uniform(0.0, 1.0) if rdx == 0: color_mapping.append(min_scalar_value) prior_scalar_val = min_scalar_value elif rdx == len(all_colors) - 1: color_mapping.append(max_scalar_value) else: color_mapping.append(scalar_val) prior_scalar_val = scalar_val color_mapping.append(rgb[0]) color_mapping.append(rgb[1]) color_mapping.append(rgb[2]) return np.array(color_mapping).reshape(len(color_mapping) / 4, 4)
def hsl_to_rgb(self, a, b, c): hsl = HSLColor(a, b, c) rgb = convert_color(hsl, sRGBColor).get_value_tuple() if not self.is_valid_rgb(rgb): return self.correct_rgb([rgb[0] * 255, rgb[1] * 255, rgb[2] * 255]) return self.correct_rgb([rgb[0] * 255, rgb[1] * 255, rgb[2] * 255])
def hsltorgb(h, s, l): rgb = convert_color(HSLColor(h, s, l), sRGBColor) return int(rgb.rgb_r) & 0xff, int(rgb.rgb_g) & 0xff, int(rgb.rgb_b) & 0xff
def test_conversion_to_hsl_max_b(self): color = sRGBColor(0.482, 0.482, 1.0) hsl = convert_color(color, HSLColor) self.assertColorMatch(hsl, HSLColor(240.000, 1.000, 0.741))
def test_conversion_to_hsl_max_g(self): color = sRGBColor(123, 255, 50, is_upscaled=True) hsl = convert_color(color, HSLColor) self.assertColorMatch(hsl, HSLColor(98.634, 1.000, 0.598))
def test_conversion_to_hsl_max_r(self): color = sRGBColor(255, 123, 50, is_upscaled=True) hsl = convert_color(color, HSLColor) self.assertColorMatch(hsl, HSLColor(21.366, 1.000, 0.598))
def generate_opacity_color_gmm(min_scalar_value, max_scalar_value, num_modes, min_amplitude=0.1, variance_scale=0.5, begin_alpha=0.1, end_alpha=0.9): min_mean, max_mean = min_scalar_value + begin_alpha * ( max_scalar_value - min_scalar_value), min_scalar_value + end_alpha * ( max_scalar_value - min_scalar_value) means = np.random.uniform(min_mean, max_mean, size=num_modes) stdevs = np.zeros(num_modes) amplitudes = np.zeros(num_modes) max_boundary_lightness = 0.4 min_mode_lightness = 0.6 min_stdev = 0.05 color_gmm = np.zeros((num_modes + 2, 4)) color_gmm[0, 0] = min_scalar_value color_gmm[-1, 0] = max_scalar_value color_gmm[0, 1:] = convert_color( HSLColor(360.0 * np.random.uniform(), np.random.uniform(), np.random.uniform(0, max_boundary_lightness)), sRGBColor).get_value_tuple() color_gmm[-1, 1:] = convert_color( HSLColor(360.0 * np.random.uniform(), np.random.uniform(), np.random.uniform(0, max_boundary_lightness)), sRGBColor).get_value_tuple() for mdx, mean in enumerate(means): max_stdev = min(0.5 * (mean - min_mean), 0.5 * (max_mean - mean)) lower_stdev = min(min_stdev, max_stdev / num_modes) stdevs[mdx] = np.random.uniform(lower_stdev, max_stdev) amplitudes[mdx] = np.random.uniform(min_amplitude, 1) color_gmm[mdx + 1, 0] = mean color_gmm[mdx + 1, 1:] = convert_color( HSLColor(360.0 * np.random.uniform(), np.random.uniform(), np.random.uniform(min_mode_lightness, 1)), sRGBColor).get_value_tuple() sorted_color_inds = np.argsort(color_gmm[:, 0]) color_gmm = color_gmm[sorted_color_inds, :] if num_modes > 1: amplitudes /= np.sum(amplitudes) # mean, stdev, amplitude opacity_gmm = np.zeros((num_modes, 3)) opacity_gmm[:, 0] = means opacity_gmm[:, 1] = stdevs opacity_gmm[:, 2] = amplitudes sorted_opacity_inds = np.argsort(opacity_gmm[:, 0]) sorted_opacity_gmm = opacity_gmm[sorted_opacity_inds, :] # smooth out colors based on GMM smoothed_color_gmm = np.zeros((num_modes + 2, 4)) smoothed_color_gmm[0, :] = color_gmm[0, :] smoothed_color_gmm[-1, :] = color_gmm[-1, :] for cdx, color in enumerate(color_gmm[1:-1, :]): weights = np.exp(-np.power( (sorted_opacity_gmm[cdx, 0] - color_gmm[:, 0]), 2) / np.power(sorted_opacity_gmm[cdx, 1], 2)) normalized_weights = weights / np.sum(weights) smoothed_color_gmm[cdx + 1, 0] = sorted_opacity_gmm[cdx, 0] smoothed_color_gmm[cdx + 1, 1:] = np.sum( (color_gmm[:, 1:].T * normalized_weights).T, axis=0) return opacity_gmm, smoothed_color_gmm
for lum_1 in lum_1_domain: if lum_1 < min_luminance: continue lum_2_domain = np.arange( min(color_2_luminance - max_luminance_distance, min_luminance), max(color_2_luminance + max_luminance_distance, max_luminance), luminance_step) for lum_2 in lum_2_domain: if lum_2 < min_luminance: continue # Compute desaturated colors desaturated_color_1 = HSLColor(color_1_hue, sat, lum_1) desaturated_color_2 = HSLColor(color_2_hue, sat, lum_2) desaturated_lab_color_1 = convert_color(desaturated_color_1, LabColor) desaturated_lab_color_2 = convert_color(desaturated_color_2, LabColor) # Compute the distance_diff between them and the diff of distance distance = np.square( delta_e_cie2000(desaturated_lab_color_1, desaturated_lab_color_2) ) + np.square(delta_e_cie2000( desaturated_lab_color_1, lab_color_1)) + np.square( delta_e_cie2000(desaturated_lab_color_2, lab_color_2)) distance_diff = np.abs(distance - initial_distance)
def test_conversion_to_hsl_gray(self): color = sRGBColor(0.482, 0.482, 0.482) hsl = convert_color(color, HSLColor) self.assertColorMatch(hsl, HSLColor(0.000, 0.000, 0.482))
def _get_new_rgb(self, hsl): new_hsl = HSLColor(hsl[0], hsl[1], hsl[2]) new_rgb = convert_color(new_hsl, sRGBColor).get_value_tuple() new_rgb_int = self._rgb_float_to_int(new_rgb) return new_rgb_int
def setUp(self): self.color = HSLColor(200.0, 0.400, 0.500)
def hsl(l, c, h): return convert_color(HSLColor(h, c/100, l/100), sRGBColor, target_illuminant="d65")
#bigpic = sscale(bigpic) bigpics = [bigpic.subsurface([0,0,int(bigpic.get_width()/2), bigpic.get_height()]), bigpic.subsurface([int(bigpic.get_width()/2),0,int(bigpic.get_width()/2), bigpic.get_height()])] ###### from colormath.color_objects import sRGBColor, HSLColor c = sRGBColor(255, 0, 0, is_upscaled = True) c2 = sRGBColor(0, 0, 255, is_upscaled = True) from colormath import color_conversions converted = color_conversions.convert_color(c, HSLColor) converted2 = color_conversions.convert_color(c2, HSLColor) print(converted.hsl_h) print(converted2.hsl_h) final = HSLColor((converted.hsl_h/2 + converted2.hsl_h/2), converted.hsl_s/2 + converted2.hsl_s/2, converted.hsl_l/2 + converted2.hsl_l/2) print(final) print(color_conversions.convert_color(final, sRGBColor)) ##### while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False elif event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: running = False wide_screen.fill((0,0,0)) #wide_screen.blit(bigpic, [0,0])