|
|
| (22 intermediate revisions by 4 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. "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.
| + | 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 34: |
Line 42: |
| | | | |
| | ==Contact== | | ==Contact== |
| − | Gregor.Hagelueken@helmholtz-hzi.de | + | Gregor Hagelueken, |
| − | | + | 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.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,...)
| + | [[Category:Plugins]] |
| − | return coldesc
| + | [[Category:Script_Library|Helicity Check]] |
| − | </source>
| + | [[Category:Coloring]] |
| | + | [[Category:Pymol-script-repo]] |
