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])
