# demonstate colour mixing in famous models
# 5/2004 Wolfgang Urban@schule.at

from Tkinter import *

IN_IDLE = 0

##########################################################################
def RGB2CMY((r,g,b)):
    return [1-r,1-g,1-b]

def CMY2RGB((c,m,y)):
    return [1-c,1-m,1-y]

def RGB2HSV((r,g,b),h):    
    maximum = max(r,g,b)
    minimum = min(r,g,b)
    # calculate value
    v = maximum
    # calculate saturation
    if maximum != 0:
        s = (maximum-minimum)/maximum
    else: s = 0.0
    if s == 0.0:
        # h = None
        pass
    else:
        delta = maximum-minimum
        if r==maximum: h = (g-b)/delta
        if g==maximum: h = 2+(b-r)/delta
        if b==maximum: h = 4+(r-g)/delta
        h = h*60.0
        if h<0.0: h += 360.0
        
    return [h,s,v]

def HSV2RGB((h,s,v)):
    if s==0:
        if h == None:
            r=g=b = v
        else:
            r=g=b = v
            # print "Error: s=0 but h defined"
            pass
    else:
        if h>=360.0: h -= 360.0
        h = h/60.0
        i = int(h)
        f = h-i
        p = v*(1-s)
        q = v*(1-s*f)
        t = v*(1-s*(1-f))
        if i==0: r,g,b = v,t,p
        elif i==1: r,g,b = q,v,p
        elif i==2: r,g,b = p,v,t
        elif i==3: r,g,b = p,q,v
        elif i==4: r,g,b = t,p,v
        elif i==5: r,g,b = v,p,q

    return [r,g,b]


def RGB2HLS((r,g,b),h):    
    maximum = max(r,g,b)
    minimum = min(r,g,b)
    l = (maximum+minimum)/2.0

    if maximum==minimum:
        # s,h = 0,None # achromatic case
        s = 0
    else:
        if l<=0.5:
            s = (maximum-minimum)/(maximum+minimum)
        else:
            s = (maximum-minimum)/(2-maximum-minimum)
        # calculate hue
        delta = maximum-minimum
        if r==maximum:  h = (g-b)/delta
        elif g==maximum:  h = 2+(b-r)/delta
        elif b==maximum:  h = 4+(r-g)/delta
        h = h*60.0
        if h<0.0: h += 360.0

        h += 120.0
        if h>=360: h -= 360.0

    return [h,l,s]

def HLS2RGB((h,l,s)):

    def value(n1,n2,hue):
        if hue>=360.0: hue -= 360.0
        if hue<0.0: hue += 360.0
        if hue<60.0: return n1+(n2-n1)*hue/60.0
        elif hue<180.0: return n2
        elif hue<240.0: return n1+(n2-n1)*(240.0-hue)/60.0
        else: return n1

    h -= 120.0
    if h<0.0: h += 360.0

    if l<=0.5:
        m2 = l*(1+s)
    else:
        m2 = l+s-l*s
    m1 = 2*l-m2

    if s==0:
        if h==None:
            r=g=b=l
        else:
            r=g=b=l
            # print "Error: s=0 but h defined"
    else:
        r = value(m1,m2,h+120.0)
        g = value(m1,m2,h)
        b = value(m1,m2,h-120.0)
    return [r,g,b]


##########################################################################


class ColorScale(Scale):
    def __init__(self,parent,v1,v2,dv,var,action):
        Scale.__init__(self,parent,orient=HORIZONTAL,from_=v1,to_=v2,length=256,
                       resolution=dv, 
                       showvalue=1,repeatinterval=8,
                       variable = var, command=action)

class ColorFrame(Frame):
    def __init__(self,parent,labels,max1,max2,max3,var1,var2,var3,action):
        Frame.__init__(self,parent,relief=GROOVE,bd=3)
        myscale = [0]*len(labels)
        label = [0]*len(labels)
        label[0] = Label(self,text=labels[0],relief=FLAT,font=("Courier",16,"bold"))
        label[1] = Label(self,text=labels[1],relief=FLAT,font=("Courier",16,"bold"))
        label[2] = Label(self,text=labels[2],relief=FLAT,font=("Courier",16,"bold"))
        label[0].grid(row=0,column=0)
        label[1].grid(row=1,column=0)
        label[2].grid(row=2,column=0)
        if max1<=150.0:
            myscale[0] = ColorScale(self,0.0,max1,0.5,var1,action)
        else:
            myscale[0] = ColorScale(self,0.0,max1,1.0,var1,action)
        myscale[1] = ColorScale(self,0.0,max2,0.5,var2,action)
        myscale[2] = ColorScale(self,0.0,max3,0.5,var3,action)
        myscale[2] = ColorScale(self,0.0,max3,1.0,var3,action)
        myscale[0].grid(row=0,column=1)
        myscale[1].grid(row=1,column=1)
        myscale[2].grid(row=2,column=1)

class ShowFrame(Frame):
    def __init__(self,parent,c):
        Frame.__init__(self,parent,relief=GROOVE,bd=5)
        self.label = Label(self,bg="#ffffff",width="10",height=12)
        self.label.pack()
        c.linklabel(self.label)
        

class Colors:
    def __init__(self):
        self.rgb_r,self.rgb_g,self.rgb_b = DoubleVar(),DoubleVar(),DoubleVar()
        self.cmy_c,self.cmy_m,self.cmy_y = DoubleVar(),DoubleVar(),DoubleVar()
        self.hsv_h,self.hsv_s,self.hsv_v = DoubleVar(),DoubleVar(),DoubleVar()
        self.hls_h,self.hls_l,self.hls_s = DoubleVar(),DoubleVar(),DoubleVar()
        self.rgb = [0,0,0]
        self.cmy = [0,0,0]
        self.hsv = [0,0,0]
        self.hls = [0,0,0]
        
    def linklabel(self,label):
        self.label = label 

    def updateall(self):
        self.rgb_r.set(self.rgb[0]*100)
        self.rgb_g.set(self.rgb[1]*100)
        self.rgb_b.set(self.rgb[2]*100)
        self.cmy_c.set(self.cmy[0]*100)
        self.cmy_m.set(self.cmy[1]*100)
        self.cmy_y.set(self.cmy[2]*100)
        self.hsv_h.set(self.hsv[0])
        self.hsv_s.set(self.hsv[1]*100)
        self.hsv_v.set(self.hsv[2]*100)
        self.hls_h.set(self.hls[0])
        self.hls_l.set(self.hls[1]*100)
        self.hls_s.set(self.hls[2]*100)
        [r,g,b]=self.rgb
        self.label.configure(bg="#%02x%02x%02x"%(r*255.0,g*255.0,b*255.0))
        return


    def adjust_rgb(self,event):
        self.rgb[0] = self.rgb_r.get()/100.0
        self.rgb[1] = self.rgb_g.get()/100.0
        self.rgb[2] = self.rgb_b.get()/100.0
        self.cmy = RGB2CMY(self.rgb)
        self.hsv = RGB2HSV(self.rgb,self.hsv[0])
        self.hls = RGB2HLS(self.rgb,self.hls[0])

        self.updateall()
    
    def adjust_cmy(self,event):
        self.cmy[0] = self.cmy_c.get()/100.0
        self.cmy[1] = self.cmy_m.get()/100.0
        self.cmy[2] = self.cmy_y.get()/100.0
        self.rgb = CMY2RGB(self.cmy)
        self.hsv = RGB2HSV(self.rgb,self.hsv[0])
        self.hls = RGB2HLS(self.rgb,self.hls[0])

        self.updateall()

    def adjust_hsv(self,event):
        self.hsv[0] = self.hsv_h.get()*1.0
        self.hsv[1] = self.hsv_s.get()/100.0
        self.hsv[2] = self.hsv_v.get()/100.0
        self.rgb = HSV2RGB(self.hsv)
        self.cmy = RGB2CMY(self.rgb)
        self.hls = RGB2HLS(self.rgb,self.hls[0])

        self.updateall()


    def adjust_hls(self,event):
        self.hls[0] = self.hls_h.get()*1.0
        self.hls[1] = self.hls_l.get()/100.0
        self.hls[2] = self.hls_s.get()/100.0
        self.rgb = HLS2RGB(self.hls)
        self.cmy = RGB2CMY(self.rgb)
        self.hsv = RGB2HSV(self.rgb,self.hsv[0])

        self.updateall()



def start():
    global c
    root = Tk()
    root.title("Farbmodelle")
    c = Colors()
    
    rgbframe = ColorFrame(root,"RGB",100,100,100,c.rgb_r,c.rgb_g,c.rgb_b,c.adjust_rgb)
    rgbframe.grid(row=0,column=0,padx=5,pady=5)
    cmyframe = ColorFrame(root,"CMY",100,100,100,c.cmy_c,c.cmy_m,c.cmy_y,c.adjust_cmy)
    cmyframe.grid(row=1,column=0,padx=5,pady=5)
    hsvframe = ColorFrame(root,"HSV",360,100,100,c.hsv_h,c.hsv_s,c.hsv_v,c.adjust_hsv)
    hsvframe.grid(row=0,column=2,padx=5,pady=5)
    hlsframe = ColorFrame(root,"HLS",360,100,100,c.hls_h,c.hls_l,c.hls_s,c.adjust_hls)
    hlsframe.grid(row=1,column=2,padx=5,pady=5)

    sf = ShowFrame(root,c)
    sf.grid(row=0,column=1,rowspan=2)

    if not IN_IDLE: root.mainloop()

#########################################

if not IN_IDLE: start()