Colorama
Jump to navigation
Jump to search
COLORAMA
COLORAMA is a PyMOL plugin which allows to color objects using adjustable scale bars.
Program features
In RGB mode, each color R, G, B is represented by one scale bar which can be manually adjusted while the selected object is colored in real time. For convenience, it is as well possible to switch to the HSV color system.
Additionally, a color gradient with user-defined start- and end-colors can be created for the selected molecule.
Screenshot
Usage
Install the program by copying the code below into an empty text file (e.g. "color_select.py") located in the \Pymol\modules\pmg_tk\startup directory. The program will launch automatically after PyMOL is started. COLORAMA does not properly work with PyMOL versions older than 1.0.
Single color
- Type the name of a PyMOL object to be colored into the COLORAMA entry field.
- Push the "Set" button.
- The scales are adjusted to the current color which is additionally visualized in a field left to the scales.
- If one of the scales is moved, the color of the selected object will change in real-time.
- Pushing the RGB or HSV buttons on the left allows to switch between both color systems.
Color gradients
- After an object has been selected, push the "G" button (gradient).
- Select the start color by pushing "C1" and adjusting it using the scales.
- Select the end color "C2" in the same way.
- To create the gradient, push "Set gradient".
A new object will be created which is called "dummy-OLD_OBJECT". The B-factor column of this object is overwritten and now contains the number of each residue. The original object is left unchanged. The gradient mode can be left by pushing "M" (monochrome). This part of the program uses a modified version of the color_b script by Robert L. Campbell & James Stroud.
Contact
Gregor.Hagelueken@helmholtz-hzi.de
Code
"""
--- COLORAMA: Coloring Widget for PyMOL ---
Author : Gregor Hagelueken
Program : Color_select
Date : Oct 2007
Version : 0.1.0
Mail : gha@helmholtz-hzi.de
COLORAMA is a plugin for the PyMOL Molecular Graphics System.
It allows to color molecules using RGB or HSV colors which can be manually adjusted.
Alternatively, a user defined color gradient can be applied to the molecule.
The program works properly with PyMOL versions >=1.0.
The program uses a modified version of the color_b program by Robert L. Campbell & James Stroud
for the gradient calculation and the RGBToHTMLColor function by Paul Winkler.
Literature:
DeLano, W.L. The PyMOL Molecular Graphics System (2002) DeLano Scientific, San Carlos, CA, USA. http://www.pymol.org
----------------------------------------------------------------------
----------------------------------------------------------------------
"""
import colorsys,sys
from pymol import cmd,stored
from Tkinter import *
class Colorama:
def __init__ (self,master):
#create frames
self.F1 = Frame(roota, padx=5, pady=5, bg='red')
self.F2 = Frame(roota, padx=5, pady=5, bg='green')
self.F3 = Frame(roota, padx=5, pady=5, bg='blue')
self.F4 = Frame(self.F1, padx=5, pady=5, bg='yellow')
self.F5 = Frame(self.F1, padx=5, pady=5, bg='white')
self.F6 = Frame(self.F1, padx=5, pady=5, bg='pink')
#color system radiobuttons
self.Radiocolorsystem = IntVar()
self.RGB = Radiobutton (self.F3, text='RGB', indicatoron=0, variable=self.Radiocolorsystem, value=1, command=self.Scalergb)
self.HSV = Radiobutton (self.F3, text='HSV', indicatoron=0, variable=self.Radiocolorsystem, value=2, command=self.Scalehsv)
#mono/gradient and Farbe1/Farbe2 radiobuttons
self.RadioMonoGradient = IntVar()
self.RadioFarbe12 = IntVar()
self.Monobutton = Radiobutton (self.F3, text='M', indicatoron=0, variable=self.RadioMonoGradient, value=1, command=self.Mono)
self.Gradbutton = Radiobutton (self.F3, text='G', indicatoron=0, variable=self.RadioMonoGradient, value=2, command=self.Grad)
self.Farbe1button = Radiobutton (self.F3, text='C1', indicatoron=0, variable=self.RadioFarbe12, value=1, command=self.Farbe1)
self.Farbe2button = Radiobutton (self.F3, text='C2', indicatoron=0, variable=self.RadioFarbe12, value=2, command=self.Farbe2)
#preselect RGB and mono
self.RGB.select()
self.Monobutton.select()
self.Farbe1button.select()
self.monograd='mono'
self.colorsystem='rgb'
self.farbe12='farbe1'
#initialize the scales
self.Scales()
#other GUI elements
self.selectionentry = Entry(master=self.F5, font=('Arial', 10))
self.selectionentry.insert(0,"")
self.selectionbutton = Button(master=self.F5, text='Set', command=self.setselection)
self.setgradientbutton = Button(master=self.F5, text='Set Gradient', command=self.setgradient)
self.label = Label(master=self.F4, text="None", font=('Arial', 10))
self.selectionlabel = Label(master=self.F4, text="Active:", font=('Arial', 10))
self.inputlabel = Label (master=self.F5, text="Object:", font=('Arial', 10))
self.colorfield1 = Label(master=self.F3,width=3, height=10)
self.colorfield2 = Label(master=self.F3,width=3, height=10)
self.selection=""
self.setselection()
#start layout procedure
self.layout()
def layout(self):
self.F1.pack(side=TOP, anchor=NW)
self.F4.pack(side=BOTTOM, fill=X, anchor=W)
self.F5.pack(side=TOP)
self.F2.pack(side=RIGHT, fill=Y)
self.F3.pack(side=LEFT, fill=X)
#entry and buttons
self.setgradientbutton.pack(side=RIGHT,fill=X, anchor=NE)
self.selectionbutton.pack(side=RIGHT, anchor=N)
self.selectionentry.pack(side=RIGHT,fill=X, anchor=NE)
#labels
self.inputlabel.pack(side=TOP, anchor=NW)
self.selectionlabel.pack(side=LEFT, anchor=W)
self.label.pack(side=LEFT)
#colorfields
self.colorfield2.pack(side=RIGHT)
self.colorfield1.pack(side=RIGHT)
#scales
self.ScaleRed.pack(side=RIGHT, fill=Y)
self.ScaleGreen.pack(side=RIGHT, fill=Y)
self.ScaleBlue.pack(side=RIGHT, fill=Y)
#radiobuttons
self.RGB.pack(side=TOP, fill=X)
self.HSV.pack(side=TOP, fill=X)
self.Monobutton.pack(side=TOP, fill=X)
self.Gradbutton.pack(side=TOP, fill=X)
self.Farbe1button.pack(side=TOP, fill=X)
self.Farbe2button.pack(side=TOP, fill=X)
def Scales(self):
self.ScaleRed = Scale(master=self.F2, label='R', length='3c',
from_=0, to=255,
#set(startred),
command=self.setzeFarbe)
self.ScaleGreen = Scale(master=self.F2, label='G', length='3c',
from_=0, to=255,
#set(startgreen),
command=self.setzeFarbe)
self.ScaleBlue = Scale(master=self.F2, label='B', length='3c',
from_=0, to=255,
#set(startblue),
command=self.setzeFarbe)
def Scalergb(self):
if (self.colorsystem=='hsv'):
h=float(self.ScaleRed.get())
s=float(self.ScaleGreen.get())
v=float(self.ScaleBlue.get())
rgbcolor = colorsys.hsv_to_rgb(h,s,v)
r=255*rgbcolor[0]
g=255*rgbcolor[1]
b=255*rgbcolor[2]
self.ScaleRed.config(label='R', from_=0, to=255, resolution=1)
self.ScaleGreen.config(label='G', from_=0, to=255, resolution=1)
self.ScaleBlue.config(label='B', from_=0, to=255, resolution=1)
self.ScaleRed.set(r)
self.ScaleGreen.set(g)
self.ScaleBlue.set(b)
self.colorsystem='rgb'
def Scalehsv(self):
if (self.colorsystem=='rgb'):
r=float(self.ScaleRed.get())/255
g=float(self.ScaleGreen.get())/255
b=float(self.ScaleBlue.get())/255
hsvcolor = colorsys.rgb_to_hsv(r,g,b)
h=hsvcolor[0]
s=hsvcolor[1]
v=hsvcolor[2]
self.ScaleRed.config(label='H', from_=0, to=1, resolution=0.01)
self.ScaleGreen.config(label='S', from_=0, to=1, resolution=0.01)
self.ScaleBlue.config(label='V', from_=0, to=1, resolution=0.01)
self.ScaleRed.set(h)
self.ScaleGreen.set(s)
self.ScaleBlue.set(v)
self.colorsystem='hsv'
def Mono(self):
self.monograd='mono'
def Grad(self):
self.monograd='grad'
def Farbe1(self):
#Let the scales know which color is to be changed
self.farbe12='farbe1'
#set scales to farbe1
if (self.monograd=='grad'):
if (self.colorsystem=='rgb'):
startred=self.farbe1[0]
startgreen=self.farbe1[1]
startblue=self.farbe1[2]
self.ScaleRed.set(startred)
self.ScaleGreen.set(startgreen)
self.ScaleBlue.set(startblue)
elif (self.colorsystem=='hsv'):
hsvcolor=colorsys.rgb_to_hsv(self.farbe1[0], self.farbe1[1], self.farbe1[2])
h=hsvcolor[0]
s=hsvcolor[1]
v=hsvcolor[2]
self.ScaleRed.set(h)
self.ScaleGreen.set(s)
self.ScaleBlue.set(v)
def Farbe2(self):
#Let the scales know which color is to be changed
self.farbe12='farbe2'
#set scales to farbe1
if (self.monograd=='grad'):
if (self.colorsystem=='rgb'):
startred=self.farbe2[0]
startgreen=self.farbe2[1]
startblue=self.farbe2[2]
self.ScaleRed.set(startred)
self.ScaleGreen.set(startgreen)
self.ScaleBlue.set(startblue)
elif (self.colorsystem=='hsv'):
hsvcolor=colorsys.rgb_to_hsv(self.farbe2[0], self.farbe2[1], self.farbe2[2])
h=hsvcolor[0]
s=hsvcolor[1]
v=hsvcolor[2]
self.ScaleRed.set(h)
self.ScaleGreen.set(s)
self.ScaleBlue.set(v)
def setselection(self):
if (self.selectionentry.get() != ""):
self.selection=self.selectionentry.get()
#Color of each residue is stored in stored.colorlist to check if the molecule has a colorgradient
stored.colorlist = []
cmd.iterate (self.selection+" & name CA", "stored.colorlist.append(int(color))")
if (len(stored.colorlist)==0):
#for other objects (e.g. density...)
stored.colorlist.append(cmd.get_object_color_index(self.selection))
stored.colorlist.append(cmd.get_object_color_index(self.selection))
initialcolornterm=cmd.get_color_tuple(stored.colorlist[0])
initialcolorcterm=cmd.get_color_tuple(stored.colorlist[len(stored.colorlist)-1])
self.farbe1=initialcolornterm[0]*255, initialcolornterm[1]*255, initialcolornterm[2]*255
self.farbe2=initialcolorcterm[0]*255, initialcolorcterm[1]*255, initialcolorcterm[2]*255
#Set active object to label
self.label.config(text=self.selection)
#check if there is a gradient and adjust Mono/Gradbutton
if (initialcolornterm==initialcolorcterm):
self.Monobutton.select()
self.Mono()
elif (initialcolornterm!=initialcolorcterm):
self.Gradbutton.select()
self.Grad()
#adjust colorfields
self.colorfield1.config(bg=self.RGBToHTMLColor(self.farbe1))
self.colorfield2.config(bg=self.RGBToHTMLColor(self.farbe2))
self.Farbe1button.select()
self.Farbe1()
#Set scales to initialcolor of the new object
if (self.colorsystem=='rgb'):
startred=255*initialcolornterm[0]
startgreen=255*initialcolornterm[1]
startblue=255*initialcolornterm[2]
self.ScaleRed.set(startred)
self.ScaleGreen.set(startgreen)
self.ScaleBlue.set(startblue)
elif (self.colorsystem=='hsv'):
hsvcolor=colorsys.rgb_to_hsv(initialcolornterm[0], initialcolornterm[1], initialcolornterm[2])
h=hsvcolor[0]
s=hsvcolor[1]
v=hsvcolor[2]
self.ScaleRed.set(h)
self.ScaleGreen.set(s)
self.ScaleBlue.set(v)
def setzeFarbe(self, event):
if ((self.selection != "") & (self.monograd == 'mono')):
if (self.colorsystem=='rgb'):
col=[]
#read RGB values from scales
r=int(self.ScaleRed.get())
g=int(self.ScaleGreen.get())
b=int(self.ScaleBlue.get())
rgbcolor=r,g,b
#Prepare a rgb tupel
col.append(rgbcolor)
#hexcolor for colorfields
hexcolor=self.RGBToHTMLColor(rgbcolor)
self.colorfield1.config(bg=hexcolor)
self.colorfield2.config(bg=hexcolor)
cmd.delete(self.selection+"_color")
cmd.set_color(self.selection+"_color", col[0])
cmd.color(self.selection+"_color", self.selection)
del col[0]
elif (self.colorsystem=='hsv'):
col=[]
#read HSV values from scales
h=float(self.ScaleRed.get())
s=float(self.ScaleGreen.get())
v=float(self.ScaleBlue.get())
#HSV to RGB and change from 1.0, 1.0, 1.0 format to 255,255,255 format
rgbcolor = colorsys.hsv_to_rgb(h,s,v)
r = 255*rgbcolor[0]
g = 255*rgbcolor[1]
b = 255*rgbcolor[2]
#as above
rgbcolor = r,g,b
col.append(rgbcolor)
#hexcolor for colorfields
hexcolor=self.RGBToHTMLColor(rgbcolor)
self.colorfield1.config(bg=hexcolor)
self.colorfield2.config(bg=hexcolor)
cmd.delete(self.selection+"_color")
cmd.set_color(self.selection+"_color", col[0])
cmd.color(self.selection+"_color", self.selection)
del col[0]
elif ((self.selection !="") & (self.monograd == 'grad')):
if (self.colorsystem=='rgb'):
col=[]
#read RGB values from scales
r=int(self.ScaleRed.get())
g=int(self.ScaleGreen.get())
b=int(self.ScaleBlue.get())
rgbcolor=r,g,b
#Prepare a rgb tupel
col.append(rgbcolor)
#hexcolor for colorfields
hexcolor=self.RGBToHTMLColor(rgbcolor)
if (self.farbe12=='farbe1'):
self.colorfield1.config(bg=hexcolor)
self.farbe1=rgbcolor
elif (self.farbe12=='farbe2'):
self.colorfield2.config(bg=hexcolor)
self.farbe2=rgbcolor
elif (self.colorsystem=='hsv'):
col=[]
#read HSV values from scales
h=float(self.ScaleRed.get())
s=float(self.ScaleGreen.get())
v=float(self.ScaleBlue.get())
#HSV to RGB and change from 1.0, 1.0, 1.0 format to 255,255,255 format
rgbcolor = colorsys.hsv_to_rgb(h,s,v)
r = 255*rgbcolor[0]
g = 255*rgbcolor[1]
b = 255*rgbcolor[2]
#as above
rgbcolor = r,g,b
col.append(rgbcolor)
#hexcolor for colorfields
hexcolor=self.RGBToHTMLColor(rgbcolor)
if (self.farbe12=='farbe1'):
self.colorfield1.config(bg=hexcolor)
self.farbe1=rgbcolor
elif (self.farbe12=='farbe2'):
self.colorfield2.config(bg=hexcolor)
self.farbe2=rgbcolor
def setgradient(self):
stored.residuelist = []
cmd.iterate (self.selection, "stored.residuelist.append(int(resi))")
firstresidue=min(stored.residuelist)
lastresidue=max(stored.residuelist)
rs=float(self.farbe1[0])/float(255)
gs=float(self.farbe1[1])/float(255)
bs=float(self.farbe1[2])/float(255)
re=float(self.farbe2[0])/float(255)
ge=float(self.farbe2[1])/float(255)
be=float(self.farbe2[2])/float(255)
hsvcolorstart = colorsys.rgb_to_hsv(rs, gs, bs)
hs=hsvcolorstart[0]
ss=hsvcolorstart[1]
vs=hsvcolorstart[2]
hsvcolorend = colorsys.rgb_to_hsv(re, ge, be)
he=hsvcolorend[0]
se=hsvcolorend[1]
ve=hsvcolorend[2]
color_grad(selection=self.selection, minimum=firstresidue, maximum=lastresidue, hs=hs, he=he,ss=ss,se=se,vs=vs,ve=ve)
def RGBToHTMLColor(self, rgb_tuple):
#by Paul Winkler
""" convert an (R, G, B) tuple to #RRGGBB """
hexcolor = '#%02x%02x%02x' % rgb_tuple
# that's it! '%02x' means zero-padded, 2-digit hex values
return hexcolor
def __init__(self):
open_Colorama()
def open_Colorama():
#initialize window (roota)
global roota
roota = Tk()
roota.title(' COLORAMA by gha')
global colorama
colorama = Colorama(roota)
def color_grad(selection='',item='b',mode='hist',gradient='bgr',nbins=11,sat=1,value=1,minimum='1',maximum='1',dummy='dummy_all', hs=1, he=1, ss=1,se=1,vs=1,ve=1, colorname='init'):
"""
--- color_grad: color gradient tool for PyMOL ---
Author : Gregor Hagelueken
Program : Color_grad
Date : Oct 2007
Version : 0.1.0
Mail : gha@helmholtz-hzi.de
This is a modified version of the color_b program by Robert L. Campbell & James Stroud
Literature:
DeLano, W.L. The PyMOL Molecular Graphics System (2002) DeLano Scientific, San Carlos, CA, USA. http://www.pymol.org
----------------------------------------------------------------------
----------------------------------------------------------------------
"""
nbins=int(nbins)
sat=float(sat)
value=float(value)
hs=float(hs)
he=float(he)
ss=float(ss)
se=float(se)
vs=float(vs)
ve=float(ve)
colorname='color_'+selection
nbins=int(maximum)-int(minimum)+2
dummy="dummy-"+selection
colname="col"+selection
# make sure sat and value are in the range 0-1.0
sat = min(sat, 1.0)
sat = max(sat, 0.0)
value = min(value, 1.0)
value = max(value, 0.0)
# make sure lowercase
gradient.lower()
mode.lower()
# Sanity checking
if nbins == 1:
print "\n WARNING: You specified nbins=1, which doesn't make sense...resetting nbins=11\n"
nbins=11
if mode not in ('hist','ramp'):
print "\n WARNING: Unknown mode ",mode, " -----> Nothing done.\n"
return
if selection == '':
print "\n USAGE: color_grad dimB, minimum=380, maximum=531, hs=0.3, he=0.25,ss=0.7,se=0.2,vs=1,ve=0.5\n"
return
elif gradient not in ('bgr','rgb','rainbow','reverserainbow','bwr','rwb',
'bmr','rmb','rw','wr','gw','wg','bw','wb','gy','yg','gray','grey','reversegray','reversegrey'):
print "\n WARNING: Unknown gradient: ",gradient, " -----> Nothing done.\n"
return
print "MODE, GRADIENT, NBINS:", mode,gradient, nbins
# get list of B-factors from selection
m = cmd.get_model(selection)
sel = []
b_list = []
if len(m.atom) == 0:
print "Sorry, no atoms selected"
else:
if item == 'b':
for i in range(len(m.atom)):
m.atom[i].b=m.atom[i].resi
b_list.append(m.atom[i].b)
elif item == 'q':
for i in range(len(m.atom)):
b_list.append(m.atom[i].q)
else:
print "Not configured to work on item %s" % item
return
cmd.load_model(m, dummy)
print selection
max_b = maximum
min_b = minimum
print "Minimum and Maximum B-values: ", min_b, max_b
#nbins = (max_b - min_b)
if mode == 'hist':
# check if minimum or maximum was specified and use the entered values
if minimum != '':
min_b = int(minimum)-1
if maximum != '':
max_b = int(maximum)+1
# histogram:
# color in bins of equal B-value ranges
# subtract 0.1 from the lowest B in order to ensure that the single
# atom with the lowest B value doesn't get omitted
bin_width = (max_b - min_b)/nbins
sel.append(selection + " and (%s = %4.4g" % (item,min_b + bin_width) + ")")
for j in range(1,nbins):
#sel.append(selection + " and %s > %4.4g" % (item,min_b + j*bin_width))
sel.append(dummy + " and %s = %4.4g" % (item,min_b + j*bin_width))
# call the function to create the gradient which returns a list of colours
colours = make_gradient(sel,gradient,nbins,sat,value,hs,he,ss,se,vs,ve,colorname)
# do the colouring now
for j in range(nbins):
print "Color select: ",sel[j]
cmd.color(colours[j],sel[j])
sel = []
colours = []
# function for creating the gradient
def make_gradient(sel,gradient,nbins,sat,value,hs,he,ss,se,vs,ve,colorname):
if gradient == 'bgr' or gradient == 'rainbow':
col=[]
coldesc=[]
for j in range(nbins):
# must append the str(sel[j]) to the color name so that it is unique
# for the selection
coldesc.append(colorname + str(j))
# coldesc.append('col' + str(sel[j]) + str(j))
# create colors using hsv scale (fractional) starting at blue(.6666667)
# through red(0.00000) in intervals of .6666667/(nbins -1) (the "nbins-1"
# ensures that the last color is, in fact, red (0)
# rewrote this to use the colorsys module to convert hsv to rgb
hsv = (hs - (hs-he) * float(j) / (nbins-1), ss-(ss-se)*float(j)/(nbins-1), vs-(vs-ve)*float(j)/(nbins-1) )
#convert to rgb and append to color list
rgb = colorsys.hsv_to_rgb(hsv[0],hsv[1],hsv[2])
col.append(rgb)
# cmd.set_color("col" + str(sel[j]) + str(j),col[j])
cmd.set_color(colorname + str(j),col[j])
#cmd.color(,resi[j])
# return the gradient as a list of colors named by their index (i.e. col0,col1,col2,col3,...)
return coldesc