This is a read-only mirror of pymolwiki.org

Difference between revisions of "Colorama"

From PyMOL Wiki
Jump to navigation Jump to search
m
m (23 revisions)
 
(10 intermediate revisions by 2 users not shown)
Line 1: Line 1:
 +
{{Infobox script-repo
 +
|type      = plugin
 +
|filename  = plugins/colorama.py
 +
|author    = [[User:Gha|Gregor Hagelueken]]
 +
|license  = -
 +
}}
 +
 
=COLORAMA=
 
=COLORAMA=
  
Line 12: Line 19:
  
 
==Usage==
 
==Usage==
 +
This plugin is included in the project [[git_intro | Pymol-script-repo]].
  
Install the program by copying the code below into an empty text file (e.g. "colorama.py") located in the \Pymol\modules\pmg_tk\startup directory. After PyMOL has been started, the program can be launched from the PLUGINS menu. COLORAMA has not been tested with PyMOL versions older than 1.0.
+
Manual install the plugin by copying the code below into an empty text file (e.g. "colorama.py") located in the \Pymol\modules\pmg_tk\startup directory. After PyMOL has been started, the program can be launched from the PLUGINS menu. COLORAMA has not been tested with PyMOL versions older than 1.0.
  
 
===Single color===
 
===Single color===
Line 35: Line 43:
 
==Contact==
 
==Contact==
 
Gregor Hagelueken,
 
Gregor Hagelueken,
gh50@st-andrews.ac.uk
+
hagelueken'at'pc.uni-bonn.de
 
 
==Code==
 
<source lang="python">
 
"""
 
--- COLORAMA: Coloring Widget for PyMOL ---
 
Author  : Gregor Hagelueken
 
Program : Color_select
 
Date    : Oct 2007
 
Version : 0.1.1
 
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[-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):
 
    self.menuBar.addmenuitem('Plugin', 'command',
 
                            'Colorama',
 
                            label = 'Colorama',
 
                            command = lambda s=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 x in m.atom:
 
        x.b=x.resi
 
        b_list.append(x.b)
 
       
 
    elif item == 'q':
 
      for x in m.atom:
 
        b_list.append(x.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
 
</source>
 
 
 
==Download==
 
[[Media:colorama-0.1.1.tar.bz2|colorama-0.1.1.tar.bz2]]
 
  
 
[[Category:Plugins]]
 
[[Category:Plugins]]
 
[[Category:Script_Library|Helicity Check]]
 
[[Category:Script_Library|Helicity Check]]
 
[[Category:Coloring]]
 
[[Category:Coloring]]
 +
[[Category:Pymol-script-repo]]

Latest revision as of 01:21, 28 March 2014

Type PyMOL Plugin
Download plugins/colorama.py
Author(s) Gregor Hagelueken
License -
This code has been put under version control in the project Pymol-script-repo

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

COLORAMA-screenshot.jpg

Usage

This plugin is included in the project Pymol-script-repo.

Manual install the plugin by copying the code below into an empty text file (e.g. "colorama.py") located in the \Pymol\modules\pmg_tk\startup directory. After PyMOL has been started, the program can be launched from the PLUGINS menu. COLORAMA has not been tested with PyMOL versions older than 1.0.

Single color

  1. Type the name of a PyMOL object to be colored into the COLORAMA entry field.
  2. Push the "Set" button.
  3. The scales are adjusted to the current color which is additionally visualized in a field left to the scales.
  4. If one of the scales is moved, the color of the selected object will change in real-time.
  5. Pushing the RGB or HSV buttons on the left allows to switch between both color systems.

Color gradients

  1. After an object has been selected, push the "G" button (gradient).
  2. Select the start color by pushing "C1" and adjusting it using the scales.
  3. Select the end color "C2" in the same way.
  4. 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, hagelueken'at'pc.uni-bonn.de