def shandle(self, evt=None):
"""Command callback for saturation.
Parameters
----------
evt : str
command handle
"""
hue = self.hvar.get()
sat = self.svar.get()
self.svar.set(int(0.5 + sat))
value = self.vvar.get()
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)
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.overlord(hsv=(hue, sat, value))
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 resize_rcan(self, event):
"""Bind function for red resizing
Parameters
----------
event : str
"""
W = event.width
red = self.rvar.get()
green = self.gvar.get()
blue = self.bvar.get()
draw_gradient(self.rcan, (0, green, blue), (255, green, blue), width=W)
def resize_bcan(self, event):
"""Bind function for blue resizing
Parameters
----------
event : str
"""
W = event.width
red = self.rvar.get()
green = self.gvar.get()
draw_gradient(self.bcan, (red, green, 0), (red, green, 255), width=W)
def resize_gcan(self, event):
"""Bind function for green resizing
Parameters
----------
event : str
"""
W = event.width
red = self.rvar.get()
blue = self.bvar.get()
draw_gradient(self.gcan, (red, 0, blue), (red, 255, blue), width=W)
def resize_scan(self, event):
"""Bind function for saturation resizing
Parameters
----------
event : str
"""
W = event.width
self.canvas_w = W
hue = self.hvar.get()
value = self.vvar.get()
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=W)
def resize_vcan(self, event):
"""Bind function for value resizing
Parameters
----------
event : str
"""
W = event.width
self.canvas_w = W
hue = self.hvar.get()
sat = self.svar.get()
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=W)
def door_bell(self, ring):
"""Calling procedure from cursor binds.
Parameters
----------
ring : tuple of int
hue, saturation values
"""
hue, sat = ring
value = self.vvar.get()
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.overlord(hsv=(hue, sat, value))
def checksb100(self, event=None):
"""Procedure called by saturation and value spinboxes.
Parameters
----------
event : str
bind handles
"""
hue = self.hvar.get()
sat = self.svar.get()
value = self.vvar.get()
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.overlord(hsv=(hue, sat, value))
def vhandle(self, evt=None):
"""Command callback for value.
Parameters
----------
evt : str
command handle
"""
hue = self.hvar.get()
sat = self.svar.get()
value = self.vvar.get()
self.vvar.set(int(0.5 + value))
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.overlord(hsv=(hue, sat, value))
def checksyiq(self, evt):
"""Procedure called by yiq spinboxes.
Parameters
----------
evt : str
bind handles
"""
y = float(self.yvar.get())
i = float(self.ivar.get())
q = float(self.qvar.get())
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)
def door_bell(self, ring):
"""Bind callback from cursor.
Parameters
----------
ring : tuple of int
y, i, q values
"""
# calls from bind
i, q = ring
y = float(self.yvar.get())
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, 0, 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, 0))
to_colour = yiq_to_rgb(*(y, i, 100))
draw_gradient(self.cans[2],
from_colour,
to_colour,
width=self.canvas_w)
self.overlord(yiq=(y, i, q))
def checkhash(self, evt=None):
"""Procedure called by entry for hash.
Parameters
----------
evt : str
bind handles
"""
hash0 = self.ent0.get()
if len(hash0) == 7:
red, green, blue = hash2rgb(hash0)
alpha = self.avar.get()
self.rvar.set(red)
self.gvar.set(green)
self.bvar.set(blue)
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.overlord(rgb=(red, green, blue))
def yhandle(self, *evt):
"""Command callback for y.
Parameters
----------
evt : str
command handle
"""
y = float(self.yvar.get())
i = float(self.ivar.get())
q = float(self.qvar.get())
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.overlord(yiq=(y, i, q))
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 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 resize_yiq(self, event, can=''):
W = event.width
self.canvas_w = W
y = float(self.yvar.get())
i = float(self.ivar.get())
q = float(self.qvar.get())
if can == self.cans[0]:
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=W)
if can == self.cans[1]:
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=W)
if can == self.cans[2]:
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=W)
def resize(self, event, can=''):
W = event.width
self.canvas_w = W
red = self.rvar.get()
green = self.gvar.get()
blue = self.bvar.get()
if can == self.rgbcans[3]:
draw_agradient(self.rgbcans[3], (127, 127, 127),
(red, green, blue),
width=W)
if can == self.rgbcans[0]:
draw_gradient(self.rgbcans[0], (0, green, blue),
(255, green, blue),
width=W)
if can == self.rgbcans[1]:
draw_gradient(self.rgbcans[1], (red, 0, blue), (red, 255, blue),
width=W)
if can == self.rgbcans[2]:
draw_gradient(self.rgbcans[2], (red, green, 0), (red, green, 255),
width=W)
def iqhandle(self, *evt):
"""Command callback for i.
Parameters
----------
evt : str
command handle
"""
y = float(self.yvar.get())
i = float(self.ivar.get())
q = float(self.qvar.get())
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)
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.overlord(yiq=(y, i, q))
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 build(self):
"""Widget construction."""
lf1 = LabelFrame(self.fr0, text='rgb')
lf1.grid(column=0, row=0, sticky='new')
lf1.columnconfigure(1, weight=1)
rl0 = Label(lf1, text='red ')
rl0.grid(column=0, row=0, sticky='s')
self.rcan = Canvas(lf1,
width=self.canvas_w,
height=self.canvas_h,
bd=0,
highlightthickness=0)
self.rcan.grid(column=1,
row=0,
sticky='sew',
padx=self.sliderlength // 2)
self.rcan.bind("<Configure>", self.resize_rcan)
rsc = TtkScale(lf1,
self.scale_l,
from_=0,
to=255,
variable=self.rvar,
orient='horizontal',
command=self.rhandle,
tickinterval=20)
rsc.grid(column=1, row=1, sticky='new')
vcmdsb = root.register(sb_okay)
rsb = Spinbox(lf1,
from_=0,
to=255,
textvariable=self.rvar,
validate='key',
validatecommand=(vcmdsb, '%d', '%P', '%S', 255),
command=self.rhandle,
width=5)
rsb.grid(column=2, row=1, sticky='nw')
rsb.bind('<KeyRelease>', self.checksb)
rel = Label(lf1)
rel.grid(column=2, row=2)
gl0 = Label(lf1, text='green')
gl0.grid(column=0, row=3)
self.gcan = Canvas(lf1,
width=self.canvas_w,
height=self.canvas_h,
bd=0,
highlightthickness=0)
self.gcan.grid(column=1,
row=3,
sticky='sew',
padx=self.sliderlength // 2)
self.gcan.bind("<Configure>", self.resize_gcan)
gsc = TtkScale(lf1,
self.scale_l,
from_=0,
to=255,
variable=self.gvar,
orient='horizontal',
command=self.ghandle,
tickinterval=20)
gsc.grid(column=1, row=4, sticky='new')
gsb = Spinbox(lf1,
from_=0,
to=255,
textvariable=self.gvar,
validate='key',
validatecommand=(vcmdsb, '%d', '%P', '%S', 255),
command=self.ghandle,
width=5)
gsb.grid(column=2, row=4, sticky='nw')
gsb.bind('<KeyRelease>', self.checksb)
gel = Label(lf1)
gel.grid(column=2, row=5)
bl0 = Label(lf1, text='blue ')
bl0.grid(column=0, row=6, sticky='s')
self.bcan = Canvas(lf1,
width=self.canvas_w,
height=self.canvas_h,
bd=0,
highlightthickness=0)
self.bcan.grid(column=1,
row=6,
sticky='new',
padx=self.sliderlength // 2)
self.bcan.bind("<Configure>", self.resize_bcan)
bsc = TtkScale(lf1,
self.scale_l,
from_=0,
to=255,
variable=self.bvar,
orient='horizontal',
command=self.bhandle,
tickinterval=20)
bsc.grid(column=1, row=7, sticky='new')
bsb = Spinbox(lf1,
from_=0,
to=255,
textvariable=self.bvar,
validate='key',
validatecommand=(vcmdsb, '%d', '%P', '%S', 255),
command=self.bhandle,
width=5)
bsb.grid(column=2, row=7, sticky='nw')
bsb.bind('<KeyRelease>', self.checksb)
bel = Label(lf1)
bel.grid(column=2, row=8)
lf3 = LabelFrame(self.fr0, text='colour mix')
lf3.grid(column=1, row=0, sticky='nw')
self.cmcan = cmcan = Canvas(lf3,
width=30,
height=30,
bd=0,
highlightthickness=0)
cmcan.grid(column=0, row=0, sticky='n', columnspan=2)
cmcan.grid_propagate(0)
vdraw_gradient(self.cmcan, (255, 0, 0), alpha=255)
cml = Label(lf3, text='hash\nvalue')
cml.grid(column=0, row=1)
vcmd = root.register(is_okay)
self.ent0 = ent0 = Entry(lf3,
width=8,
validate='key',
validatecommand=(vcmd, '%i', '%P', '%S'),
textvariable=self.evar)
ent0.grid(column=1, row=1)
ent0.bind('<KeyRelease>', self.checkhash)
lf5 = LabelFrame(lf3, text='related colours', style='Wide.TLabelframe')
lf5.grid(column=0, row=2, sticky='nw', columnspan=2)
self.srcls = []
self.vrcls = []
self.srccans = []
self.vrccans = []
relateds = [25, 50, 75, 100]
stexts = ['25% sat', '50% sat', '75% sat', '100% sat']
vtexts = ['25% val', '50% val', '75% val', '100% val']
for ix, rel in enumerate(relateds):
Label(lf5, text=stexts[ix]).grid(row=1 + 2 * ix,
column=0,
sticky='n')
self.srcls.append(Label(lf5))
self.srcls[ix].grid(row=1 + 2 * ix, column=1, sticky='n')
self.srccans.append(
Canvas(lf5, width=30, height=30, bd=0, highlightthickness=0))
self.srccans[ix].grid(row=2 * ix,
column=0,
sticky='n',
columnspan=2)
Label(lf5, text=vtexts[ix]).grid(row=9 + 2 * ix,
column=0,
sticky='n')
self.vrcls.append(Label(lf5))
self.vrcls[ix].grid(row=9 + 2 * ix, column=1, sticky='n')
self.vrccans.append(
Canvas(lf5, width=30, height=30, bd=0, highlightthickness=0))
self.vrccans[ix].grid(row=8 + 2 * ix,
column=0,
sticky='n',
columnspan=2)
self.cccan = Canvas(lf5,
width=30,
height=30,
bd=0,
highlightthickness=0)
self.cccan.grid(column=0, row=17, sticky='n', columnspan=2)
self.ccla = Label(lf5, text="comp'y")
self.ccla.grid(column=0, row=18, sticky='n')
self.ccl = Label(lf5, text="")
self.ccl.grid(column=1, row=18, sticky='n')
al0 = Label(lf1, text='alpha')
al0.grid(column=0, row=10, sticky='s')
self.acan = Canvas(lf1,
width=self.canvas_w,
height=self.canvas_h,
bd=0,
highlightthickness=0)
self.acan.grid(column=1,
row=10,
sticky='new',
padx=self.sliderlength // 2)
self.acan.bind("<Configure>", self.resize_acan)
asc = TtkScale(lf1,
self.scale_l,
from_=0,
to=255,
variable=self.avar,
orient='horizontal',
command=self.ahandle,
tickinterval=20)
asc.grid(column=1, row=11, sticky='new')
asb = Spinbox(lf1,
from_=0,
to=255,
textvariable=self.avar,
validate='key',
validatecommand=(vcmdsb, '%d', '%P', '%S', 255),
command=self.ahandle,
width=5)
asb.grid(column=2, row=11, sticky='nw')
asb.bind('<KeyRelease>', self.checksba)
ael = Label(lf1, text=' ')
ael.grid(column=2, row=12, sticky='s')
draw_gradient(self.rcan, (0, 0, 0), (255, 0, 0), width=self.canvas_w)
draw_gradient(self.gcan, (255, 0, 0), (255, 0, 255),
width=self.canvas_w)
draw_gradient(self.bcan, (255, 0, 0), (255, 255, 0),
width=self.canvas_w)
draw_agradient(self.acan, (127, 127, 127), (255, 0, 0),
width=self.canvas_w)
lf4 = LabelFrame(self.fr0, text='hsv')
lf4.grid(column=2, row=0, sticky='news')
lf4.columnconfigure(1, weight=1)
hl0 = Label(lf4, text='hue ')
hl0.grid(column=0, row=0, sticky='s')
self.hcan = Canvas(lf4,
width=self.canvas_w,
height=self.canvas_h,
bd=0,
highlightthickness=0)
self.hcan.grid(column=1,
row=0,
sticky='sew',
padx=self.sliderlength // 2)
self.hcan.bind("<Configure>", self.resize_hcan)
hsc = TtkScale(lf4,
self.scale_l,
from_=0,
to=360,
variable=self.hvar,
orient='horizontal',
command=self.hhandle,
tickinterval=30)
hsc.grid(column=1, row=1, sticky='new')
vcmdsb = root.register(sb_okay)
hsb = Spinbox(lf4,
from_=0,
to=360,
textvariable=self.hvar,
validate='key',
validatecommand=(vcmdsb, '%P', '%S', 360),
command=self.hhandle,
width=5)
hsb.grid(column=2, row=1, sticky='nw')
hsb.bind('<KeyRelease>', self.checksbh)
hel = Label(lf4)
hel.grid(column=2, row=2)
sl0 = Label(lf4, text='sat ')
sl0.grid(column=0, row=3)
self.scan = Canvas(lf4,
width=self.canvas_w,
height=self.canvas_h,
bd=0,
highlightthickness=0)
self.scan.grid(column=1,
row=3,
sticky='sew',
padx=self.sliderlength // 2)
self.scan.bind("<Configure>", self.resize_scan)
ssc = TtkScale(lf4,
self.scale_l,
from_=0,
to=100,
variable=self.svar,
orient='horizontal',
command=self.shandle,
tickinterval=10)
ssc.grid(column=1, row=4, sticky='new')
ssb = Spinbox(lf4,
from_=0,
to=100,
textvariable=self.svar,
validate='key',
validatecommand=(vcmdsb, '%P', '%S', 100),
command=self.shandle,
width=5)
ssb.grid(column=2, row=4, sticky='nw')
ssb.bind('<KeyRelease>', self.checksb100)
sel = Label(lf4)
sel.grid(column=2, row=5)
vl0 = Label(lf4, text='value')
vl0.grid(column=0, row=6, sticky='s')
self.vcan = Canvas(lf4,
width=self.canvas_w,
height=self.canvas_h,
bd=0,
highlightthickness=0)
self.vcan.grid(column=1,
row=6,
sticky='new',
padx=self.sliderlength // 2)
self.vcan.bind("<Configure>", self.resize_vcan)
vsc = TtkScale(lf4,
self.scale_l,
from_=0,
to=100,
variable=self.vvar,
orient='horizontal',
command=self.vhandle,
tickinterval=10)
vsc.grid(column=1, row=7, sticky='new')
vsb = Spinbox(lf4,
from_=0,
to=100,
textvariable=self.vvar,
validate='key',
validatecommand=(vcmdsb, '%P', '%S', 100),
command=self.vhandle,
width=5)
vsb.grid(column=2, row=7, sticky='nw')
vsb.bind('<KeyRelease>', self.checksb100)
vel = Label(lf4)
vel.grid(column=2, row=8)
# assume initial setting 0,100,100 hsv
to_colour = hsv_to_rgb(*(0, 100, 100))
hue_gradient(self.hcan, width=self.canvas_w)
draw_gradient(self.scan, (255, 255, 255),
to_colour,
width=self.canvas_w)
draw_gradient(self.vcan, (0, 0, 0), to_colour, width=self.canvas_w)
self.can_hsv = can_hsv = Canvas(lf4,
width=self.wheel_w,
height=self.wheel_w,
bg='#d9d9d9')
can_hsv.grid(column=0, row=9, columnspan=3, pady=25, sticky='n')
self.hsv_gamut = PhotoImage(file='../figures/colour_wheel.png')
can_hsv.create_image(0, 0, anchor='nw', image=self.hsv_gamut)
self.ring = circle(can_hsv,
307,
158,
self.ring_radius,
width=self.ring_width,
outline='#555555',
activeoutline='black',
tags='ring')
can_hsv.bind('<Button-1>', self.click_ring)
can_hsv.tag_bind('ring', '<B1-Motion>', self.drag_ring)
self.related(0, 100, 100, 255, 0, 0)
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)
def build(self):
"""Widget construction."""
lf1 = LabelFrame(self.fr0, text='rgb')
lf1.grid(column=0, row=0, sticky='new')
lf1.columnconfigure(1, weight=1)
vcmdsb = root.register(sb_okay)
self.rgbcans = []
rgbsboxes = []
rgbcomps = ['r', 'g', 'b', 'a']
rgbnames = ['red ', 'green', 'blue ', 'alpha']
rgbvars = [self.rvar, self.gvar, self.bvar, self.avar]
rgbhandles = [
self.rgbhandle, self.rgbhandle, self.rgbhandle, self.ahandle
]
binds = [self.checksb, self.checksb, self.checksb, self.checksba]
for ix, comp in enumerate(rgbcomps):
Label(lf1, text=rgbnames[ix]).grid(row=3 * ix, column=0)
Label(lf1).grid(row=2 + 3 * ix, column=2)
self.rgbcans.append(
Canvas(lf1,
height=self.canvas_h,
width=self.canvas_w,
bd=0,
highlightthickness=0))
self.rgbcans[ix].grid(row=3 * ix,
column=1,
sticky='ew',
padx=self.sliderlength // 2)
def handler_rgb(event, self=self, ix=ix):
return self, self.resize(event, can=self.rgbcans[ix])
self.rgbcans[ix].bind("<Configure>", handler_rgb)
#can= self.rgbcans[ix]))
TtkScale(lf1,
self.scale_l,
from_=0,
to=255,
variable=rgbvars[ix],
orient='horizontal',
command=rgbhandles[ix],
tickinterval=20).grid(row=1 + 3 * ix,
column=1,
sticky='new')
rgbsboxes.append(
Spinbox(lf1,
from_=0,
to=255,
textvariable=rgbvars[ix],
validate='key',
validatecommand=(vcmdsb, '%d', '%P', '%S', 0, 255),
command=rgbhandles[ix],
width=5))
rgbsboxes[ix].grid(row=1 + 3 * ix, column=2, sticky='nw')
rgbsboxes[ix].bind('<KeyRelease>', binds[ix])
lf3 = LabelFrame(self.fr0, text='colour mix')
lf3.grid(column=1, row=0, sticky='nw')
self.cmcan = cmcan = Canvas(lf3,
width=30,
height=30,
bd=0,
highlightthickness=0)
cmcan.grid(column=0, row=0, sticky='n', columnspan=2)
cmcan.grid_propagate(0)
vdraw_gradient(self.cmcan, (255, 0, 0), alpha=255)
cml = Label(lf3, text='hash\nvalue')
cml.grid(column=0, row=1)
vcmd = root.register(is_okay)
self.en = en = Entry(lf3,
width=8,
validate='key',
textvariable=self.evar,
validatecommand=(vcmd, '%i', '%P', '%S'))
en.grid(column=1, row=1)
en.bind('<KeyRelease>', self.checkhash)
lf5 = LabelFrame(lf3, text='related colours')
lf5.grid(column=0, row=2, sticky='nw', columnspan=2)
self.rcls = []
self.rccans = []
relateds = [0, 20, 40, 60, 80, 100]
rtexts = ['0% Y', '20% Y', '40% Y', '60% Y', '80% Y', '100% Y']
for ix, rel in enumerate(relateds):
Label(lf5, text=rtexts[ix]).grid(row=1 + 2 * ix,
column=0,
sticky='n')
self.rcls.append(Label(lf5))
self.rcls[ix].grid(row=1 + 2 * ix, column=1, sticky='n')
self.rccans.append(
Canvas(lf5, width=30, height=30, bd=0, highlightthickness=0))
self.rccans[ix].grid(row=2 * ix,
column=0,
sticky='n',
columnspan=2)
self.cccan = Canvas(lf5,
width=30,
height=30,
bd=0,
highlightthickness=0)
self.cccan.grid(column=0, row=12, sticky='n', columnspan=2)
self.ccla = Label(lf5, text="comp'y")
self.ccla.grid(column=0, row=13, sticky='n')
self.ccl = Label(lf5, text="")
self.ccl.grid(column=1, row=13, sticky='n')
draw_gradient(self.rgbcans[0], (0, 0, 0), (255, 0, 0),
width=self.canvas_w)
draw_gradient(self.rgbcans[1], (255, 0, 0), (255, 255, 0),
width=self.canvas_w)
draw_gradient(self.rgbcans[2], (255, 0, 0), (255, 0, 255),
width=self.canvas_w)
draw_agradient(self.rgbcans[3], (127, 127, 127), (255, 0, 0),
width=self.canvas_w)
lf4 = LabelFrame(self.fr0, text='yiq')
lf4.grid(column=2, row=0, sticky='ew')
lf4.columnconfigure(1, weight=1)
vcmdyiq = root.register(yiq_okay)
self.cans = []
sboxes = []
comps = ['y', 'i', 'q']
names = ['luma', 'i hue', 'q hue']
tkvars = [self.yvar, self.ivar, self.qvar]
handles = [self.yhandle, self.iqhandle, self.iqhandle]
froms = [0, -100, -100]
ticks = [10, 20, 20]
for ix, comp in enumerate(comps):
Label(lf4, text=names[ix]).grid(row=3 * ix, column=0)
Label(lf4).grid(row=2 + 3 * ix, column=2)
self.cans.append(
Canvas(lf4,
width=self.canvas_w,
height=self.canvas_h,
bd=0,
highlightthickness=0))
self.cans[ix].grid(row=3 * ix,
column=1,
sticky='ew',
padx=self.sliderlength // 2)
def handler_yiq(event, self=self, ix=ix):
return self, self.resize_yiq(event, can=self.cans[ix])
self.cans[ix].bind("<Configure>", handler_yiq)
#can=self.cans[ix]))
TtkScale(lf4,
from_=froms[ix],
to=100,
variable=tkvars[ix],
orient='horizontal',
length=self.scale_l,
command=handles[ix],
tickinterval=ticks[ix]).grid(row=1 + 3 * ix,
column=1,
sticky='new')
sboxes.append(
Spinbox(lf4,
from_=froms[ix],
to=100,
textvariable=tkvars[ix],
validatecommand=(vcmdyiq, '%d', '%P', '%S', froms[ix],
100),
validate='key',
command=handles[ix],
width=5,
increment=1))
sboxes[ix].grid(row=1 + 3 * ix, column=2, sticky='nw')
sboxes[ix].bind('<KeyRelease>', self.checksyiq)
# assume initial setting 30,100.0,40.56 yiq
to_colour = yiq_to_rgb(*(30, 100.0, 40.56))
draw_gradient(self.cans[0],
yiq_to_rgb(0.0, 100.0, 40.56),
yiq_to_rgb(100, 100, 40.56),
width=self.canvas_w)
draw_gradient(self.cans[1],
yiq_to_rgb(30, -100.0, 40.56),
to_colour,
width=self.canvas_w)
draw_gradient(self.cans[2],
yiq_to_rgb(30, 100, -100),
yiq_to_rgb(30, 100, 100),
width=self.canvas_w)
self.related(30, 100.0, 40.56)
self.canYiq = canYiq = Canvas(lf4, width=self.space, height=self.space)
canYiq.grid(column=0, row=9, columnspan=3, pady=25, sticky='n')
self.yiqGamut = PhotoImage(file='../figures/colour_space.png')
canYiq.create_image(0, 0, anchor='nw', image=self.yiqGamut)
self.ring = circle(canYiq,
300.0,
210.84,
self.ring_radius,
width=self.ring_width,
activeoutline='#555555',
tags='ring')
canYiq.bind('<Button-1>', self.move_ring)
canYiq.tag_bind('ring', '<B1-Motion>', self.move_ring)
