def related(self, y, i, q):
lumas = [0, 20, 40, 60, 80, 100]
for ix, luma in enumerate(lumas):
relcol = rgb2hash(*yiq_to_rgb(luma, i, q))
self.rccans[ix]['background'] = relcol
self.rccans[ix].background = relcol
self.rcls[ix]['text'] = relcol
comp_col = rgb2hash(*yiq_to_rgb(100 - y, -i, -q))
self.cccan['background'] = comp_col
self.cccan.background = comp_col
self.ccl['text'] = comp_col
def overlord(self, rgb=None, hsv=None):
"""Supervisory procedure to control calls from handle functions.
Parameters
----------
rgb : tuple of integers
call from rgb
hsv : tuple of integers
call from hsv
Returns
-------
draws gradients and sets other colour system
"""
if rgb:
red, green, blue = rgb[0], rgb[1], rgb[2]
hue, sat, value = rgb_to_hsv(red, green, blue)
from_colour = hsv_to_rgb(*(hue, 0, value))
to_colour = hsv_to_rgb(*(hue, 100, value))
draw_gradient(self.scan,
from_colour,
to_colour,
width=self.canvas_w)
from_colour = hsv_to_rgb(*(hue, sat, 0))
to_colour = hsv_to_rgb(*(hue, sat, 100))
draw_gradient(self.vcan,
from_colour,
to_colour,
width=self.canvas_w)
self.hvar.set(hue)
self.svar.set(sat)
self.vvar.set(value)
X, Y = polar2cart(hue, sat, self.wheel_w, self.wheel_iw)
ring_radius = self.ring_radius
for i in self.can_hsv.find_withtag("ring"):
self.can_hsv.coords(i, X - ring_radius, Y - ring_radius,
X + ring_radius, Y + ring_radius)
self.related(hue, sat, value, red, green, blue)
elif hsv:
hue, sat, value = hsv[0], hsv[1], hsv[2]
red, green, blue = hsv_to_rgb(hue, sat, value)
draw_agradient(self.acan, (127, 127, 127), (red, green, blue),
width=self.canvas_w)
alpha = self.avar.get()
vdraw_gradient(self.cmcan, (red, green, blue), alpha=alpha)
draw_gradient(self.rcan, (0, green, blue), (255, green, blue),
width=self.canvas_w)
draw_gradient(self.gcan, (red, 0, blue), (red, 255, blue),
width=self.canvas_w)
draw_gradient(self.bcan, (red, green, 0), (red, green, 255),
width=self.canvas_w)
self.evar.set(rgb2hash(red, green, blue))
self.rvar.set(red)
self.gvar.set(green)
self.bvar.set(blue)
self.related(hue, sat, value, red, green, blue)
def related(self, h, s, v, r, g, b):
"""Creating related Colours, 5 in saturation, 5 for value,
1 complementary
Parameters
----------
h : float
hue
s : float
saturation
v : float
value
r : int
red
g : int
green
b : int
blue
"""
sats = [25, 50, 75, 100]
vals = [25, 50, 75, 100]
for ix, sat in enumerate(sats):
srelcol = rgb2hash(*hsv_to_rgb(h, sat, v))
self.srccans[ix]['background'] = srelcol
self.srccans[ix].background = srelcol
self.srcls[ix]['text'] = srelcol
vrelcol = rgb2hash(*hsv_to_rgb(h, s, sat))
self.vrccans[ix]['background'] = vrelcol
self.vrccans[ix].background = vrelcol
self.vrcls[ix]['text'] = vrelcol
comp_col = rgb2hash(255 - r, 255 - g, 255 - b)
self.cccan['background'] = comp_col
self.cccan.background = comp_col
self.ccl['text'] = comp_col
def rgbhandle(self, evt=None):
"""command callback for red, green, blue"""
red = self.rvar.get()
green = self.gvar.get()
blue = self.bvar.get()
alpha = self.avar.get()
draw_gradient(self.rgbcans[0], (0, green, blue), (255, green, blue),
width=self.canvas_w)
draw_gradient(self.rgbcans[1], (red, 0, blue), (red, 255, blue),
width=self.canvas_w)
draw_gradient(self.rgbcans[2], (red, green, 0), (red, green, 255),
width=self.canvas_w)
draw_agradient(self.rgbcans[3], (127, 127, 127), (red, green, blue),
width=self.canvas_w)
vdraw_gradient(self.cmcan, (red, green, blue), alpha=alpha)
self.evar.set(rgb2hash(red, green, blue))
self.overlord(rgb=(red, green, blue))
def bhandle(self, evt=None):
"""Command callback for blue.
Parameters
----------
evt : str
command handle
"""
red = self.rvar.get()
green = self.gvar.get()
blue = self.bvar.get()
alpha = self.avar.get()
draw_gradient(self.rcan, (0, green, blue), (255, green, blue),
width=self.canvas_w)
draw_gradient(self.gcan, (red, 0, blue), (red, 255, blue),
width=self.canvas_w)
draw_agradient(self.acan, (127, 127, 127), (red, green, blue),
width=self.canvas_w)
vdraw_gradient(self.cmcan, (red, green, blue), alpha=alpha)
self.evar.set(rgb2hash(red, green, blue))
self.overlord(rgb=(red, green, blue))
def checksb(self, evt=None):
"""Procedure called by rgb colour spinboxes.
Parameters
----------
evt : str
bind handles
"""
alpha = self.avar.get()
red = self.rvar.get()
green = self.gvar.get()
blue = self.bvar.get()
draw_agradient(self.acan, (127, 127, 127), (red, green, blue),
width=self.canvas_w)
draw_gradient(self.rcan, (0, green, blue), (255, green, blue),
width=self.canvas_w)
draw_gradient(self.gcan, (red, 0, blue), (red, 255, blue),
width=self.canvas_w)
draw_gradient(self.bcan, (red, green, 0), (red, green, 255),
width=self.canvas_w)
vdraw_gradient(self.cmcan, (red, green, blue), alpha=alpha)
self.evar.set(rgb2hash(red, green, blue))
self.overlord(rgb=(red, green, blue))
def overlord(self, rgb=None, yiq=None):
"""Supervisory procedure to control calls from handles.
Parameters
----------
rgb : tuple of integers
rgb
yiq : tuple of integers
yiq
Returns
-------
draws gradients and sets other colour system
"""
if rgb:
red, green, blue = rgb[0], rgb[1], rgb[2]
y, i, q = rgb_to_yiq(red, green, blue)
from_colour = yiq_to_rgb(*(0, i, q))
to_colour = yiq_to_rgb(*(100, i, q))
draw_gradient(self.cans[0],
from_colour,
to_colour,
width=self.canvas_w)
from_colour = yiq_to_rgb(*(y, -100, q))
to_colour = yiq_to_rgb(*(y, 100, q))
draw_gradient(self.cans[1],
from_colour,
to_colour,
width=self.canvas_w)
from_colour = yiq_to_rgb(*(y, i, -100))
to_colour = yiq_to_rgb(*(y, i, 100))
draw_gradient(self.cans[2],
from_colour,
to_colour,
width=self.canvas_w)
self.yvar.set(y)
self.ivar.set(i)
self.qvar.set(q)
X = i * 3 / 2 + 150
Y = q * 3 / 2 + 150
ring_radius = self.ring_radius
for s in self.canYiq.find_withtag("ring"):
self.canYiq.coords(s, X - ring_radius, Y - ring_radius,
X + ring_radius, Y + ring_radius)
self.related(y, i, q)
if yiq:
y, i, q = yiq[0], yiq[1], yiq[2]
red, green, blue = yiq_to_rgb(y, i, q)
draw_agradient(self.rgbcans[3], (127, 127, 127),
(red, green, blue),
width=self.canvas_w)
alpha = self.avar.get()
vdraw_gradient(self.cmcan, (red, green, blue), alpha=alpha)
draw_gradient(self.rgbcans[0], (0, green, blue),
(255, green, blue),
width=self.canvas_w)
draw_gradient(self.rgbcans[1], (red, 0, blue), (red, 255, blue),
width=self.canvas_w)
draw_gradient(self.rgbcans[2], (red, green, 0), (red, green, 255),
width=self.canvas_w)
self.evar.set(rgb2hash(red, green, blue))
self.rvar.set(red)
self.gvar.set(green)
self.bvar.set(blue)
self.related(y, i, q)
