PyMOL Wiki - User contributions [en]

Contact Surface

2013-02-15T15:11:59Z

MartinChristen: /* The Code */

= Overview =
This script calculates individual or global contact areas between a receptor molecule and a (multimodel) bundle of docked ligand structures.
The exact contact surface area values (in Angstrom^2) are printed to the screen and also appended to a file called contactareas.txt.
If only a single global contact surface is calculated, a selection named "contact" is created that includes all receptor atoms within 3.9A of any ligand atom to illustrate the ''approximate'' contact surface.

The parameters are:

'''receptor''' ''(string)''
:: The name of the selection/object representing the receptor protein

'''ligand''' ''(string)''
:: The name of the selection/object representing the ligand
:: Note that this may be another protein!

'''states''' ''(integer)'', default:0
:: Calculate contact surface between the receptor and the first n states of the ligand.
:: If states = 0, the script calculates a global contact surface which takes all possible ligand states into account.

= Usage =
<source lang="python">
contact_surface receptor, ligand, [states=0]
</source>

= The Code =
<source lang="python">
#contact_surface v.3.0
#Copyleft Martin Christen, 2013

from pymol import cmd,stored
def contact_surface(receptor,ligand,states=0):

"""
AUTHOR
Martin Christen

DESCRIPTION
This script calculates individual or global contact surfaces between a
receptor molecule and a bundle of docked ligand structures (which have
to be loaded into PyMOL as a multimodel object).

The exact contact surface area values (in Angstrom^2) are printed to
the screen and also appended to a file called contactareas.txt

If only a single global contact surface is calculated, a selection
named "contact" is created that includes all receptor atoms within
3.9A of any ligand atom.

USAGE
contact_surface receptor, ligand, [states=0]

PARAMETERS

receptor (string)
The name of the selection/object representing the receptor protein

ligand (string)
The name of the selection/object representing the ligand.
Note that this may be another protein!

states (integer)
Calculate contact surface between the receptor and the first n states
of the ligand. If states = 0 (default), the script calculates a global
contact surface which takes all possible ligand states into account.
"""
# sanity check the number of states
states = abs(int(states))

# make sure all atoms within an object occlude one another
cmd.flag('ignore','none')

# use solvent-accessible surface with high sampling density
cmd.set('dot_solvent','1')
cmd.set('dot_density','3')

#if the 'states' parameter = 0 create a superposition of all ligand states
if states == 0:
cmd.split_states(ligand)
cmd.group('ligandtemp',ligand+"_*")
cmd.create(ligand+"_all",'ligandtemp')
cmd.delete('ligandtemp')

#create complex
cmd.create('complextemp',ligand+"_all "+receptor)

#measure area
ligand_area=cmd.get_area(ligand+"_all")
receptor_area=cmd.get_area(receptor)
complex_area=cmd.get_area('complextemp')
#normalize since the area is counted TWICE (once on receptor and once on ligand)
contact_area=((ligand_area + receptor_area) - complex_area) / 2
#delete complex
cmd.delete('complextemp')

#create the contact surface
cmd.select('contact',"("+receptor+" and ("+ligand+"_all around 3.9))")

#print contact surface area
f=open('contactareas.txt','a')
print "%s - %s : " % (receptor,ligand),
print >>f, "%-s\t%-s\t" % (receptor,ligand),
print >>f, "%-s" % (contact_area)
print contact_area
f.close()
print "The GLOBAL contact area between "+receptor+ " and "+ligand+" is (A^2):"
print ((ligand_area + receptor_area) - complex_area) / 2

#If 'states' <> 0 calculate the contact areas to the first 'states' ligand states.
#No individual contact surface objects are created to avoid overloading PyMOL.
else:
#create an object for each ligand state
cmd.split_states(ligand)

#sanity check: do not exceed that maximum number of states
if states > cmd.count_states(ligand):
states = cmd.count_states(ligand)

#calculate contact surface area
print "The contact areas between "+receptor+" and "+ligand+" [states 1 - "+str(states)+"] are (A^2):"
#start looping
for s in range(1,states+1):
#create complex
cmd.create("tmp",ligand,s,1)
cmd.create('complextemp',"tmp "+receptor)
#measure areas
ligand_area=cmd.get_area('tmp')
receptor_area=cmd.get_area(receptor)
complex_area=cmd.get_area('complextemp')
#normalize since the area is counted TWICE (once on receptor and once on ligand)
contact_area=((ligand_area + receptor_area) - complex_area)/2
#delete temporary files
cmd.delete('tmp')
cmd.delete(ligand+"_*")
cmd.delete('complextemp')
#print contact surface area
f=open('contactareas.txt','a')
print "%s - %s_%-5s: " % (receptor,ligand,s),
print >>f, "%-s\t%-s_%-5s\t" % (receptor,ligand,s),
print >>f, "%-s" % (contact_area)
print contact_area
f.close()

cmd.extend("contact_surface",contact_surface)
</source>

[[Category:Script_Library]]
[[Category:Math_Scripts]]
[[Category:Structural_Biology_Scripts]]

Contact Surface

2013-02-15T15:11:12Z

MartinChristen:

= Overview =
This script calculates individual or global contact areas between a receptor molecule and a (multimodel) bundle of docked ligand structures.
The exact contact surface area values (in Angstrom^2) are printed to the screen and also appended to a file called contactareas.txt.
If only a single global contact surface is calculated, a selection named "contact" is created that includes all receptor atoms within 3.9A of any ligand atom to illustrate the ''approximate'' contact surface.

The parameters are:

'''receptor''' ''(string)''
:: The name of the selection/object representing the receptor protein

'''ligand''' ''(string)''
:: The name of the selection/object representing the ligand
:: Note that this may be another protein!

'''states''' ''(integer)'', default:0
:: Calculate contact surface between the receptor and the first n states of the ligand.
:: If states = 0, the script calculates a global contact surface which takes all possible ligand states into account.

= Usage =
<source lang="python">
contact_surface receptor, ligand, [states=0]
</source>

= The Code =
<source lang="python">
#contact_surface v.3.0
#Copyleft Martin Christen, 2013

from pymol import cmd,stored
def contact_surface(receptor,ligand,states=0):

"""
AUTHOR
Martin Christen

DESCRIPTION
This script calculates individual or global contact surfaces between a
receptor molecule and a bundle of docked ligand structures (which have
to be loaded into PyMOL as a multimodel object).

The exact contact surface area values (in Angstrom^2) are printed to
the screen and also appended to a file called contactareas.txt

If only a single global contact surface is calculated, a selection
named "contact" is created that includes all receptor atoms within
3.9A of any ligand atom.

USAGE
contact_surface receptor, ligand, [states=0]

PARAMETERS

receptor (string)
The name of the selection/object representing the receptor protein

ligand (string)
The name of the selection/object representing the ligand.
Note that this may be another protein!

states (integer)
Calculate contact surface between the receptor and the first n states
of the ligand. If states = 0 (default), the script calculates a global
contact surface which takes all possible ligand states into account.
"""
# sanity check the number of states
states = abs(int(states))

# make sure all atoms within an object occlude one another
cmd.flag('ignore','none')

# use solvent-accessible surface with high sampling density
cmd.set('dot_solvent','1')
cmd.set('dot_density','3')

#if the 'states' parameter = 0 create a superposition of all ligand states
if states == 0:
cmd.split_states(ligand)
cmd.group('ligandtemp',ligand+"_*")
cmd.create(ligand+"_all",'ligandtemp')
cmd.delete('ligandtemp')

#create complex
cmd.create('complextemp',ligand+"_all "+receptor)

#measure area
ligand_area=cmd.get_area(ligand+"_all")
receptor_area=cmd.get_area(receptor)
complex_area=cmd.get_area('complextemp')
#normalize since the area is counted TWICE (once on receptor and once on ligand)
contact_area=((ligand_area + receptor_area) - complex_area) / 2
#delete complex
cmd.delete('complextemp')

#create the contact surface
cmd.select('contact',"("+receptor+" and ("+ligand+"_all around 3.9))")

#print contact surface area
f=open('contactareas.txt','a')
print "%s - %s : " % (receptor,ligand),
print >>f, "%-s\t%-s\t" % (receptor,ligand),
print >>f, "%-s" % (contact_area)
print contact_area
f.close()
print "The GLOBAL contact area between "+receptor+ " and "+ligand+" is (A^2):"
print ((ligand_area + receptor_area) - complex_area) / 2

#If 'states' <> 0 calculate the contact areas to the first 'states' ligand states.
#No individual contact surface objects are created to avoid overloading PyMOL.
else:
#create an object for each ligand state
cmd.split_states(ligand)

#sanity check: do not exceed that maximum number of states
if states > cmd.count_states(ligand):
states = cmd.count_states(ligand)

#calculate contact surface area
print "The contact areas between "+receptor+" and "+ligand+" [states 1 - "+str(states)+"] are (A^2):"
#start looping
#for s in range(1,cmd.count_states(ligand)+1):
for s in range(1,states+1):
#create complex
cmd.create("tmp",ligand,s,1)
cmd.create('complextemp',"tmp "+receptor)
#measure areas
ligand_area=cmd.get_area('tmp')
receptor_area=cmd.get_area(receptor)
complex_area=cmd.get_area('complextemp')
#normalize since the area is counted TWICE (once on receptor and once on ligand)
contact_area=((ligand_area + receptor_area) - complex_area)/2
#delete temporary files
cmd.delete('tmp')
cmd.delete(ligand+"_*")
cmd.delete('complextemp')
#print contact surface area
f=open('contactareas.txt','a')
print "%s - %s_%-5s: " % (receptor,ligand,s),
print >>f, "%-s\t%-s_%-5s\t" % (receptor,ligand,s),
print >>f, "%-s" % (contact_area)
print contact_area
f.close()

cmd.extend("contact_surface",contact_surface)
</source>

[[Category:Script_Library]]
[[Category:Math_Scripts]]
[[Category:Structural_Biology_Scripts]]

Contact Surface

2013-02-15T15:10:45Z

MartinChristen:

= Overview =
This script calculates individual or global contact areas between a receptor molecule and a (multimodel) bundle of docked ligand structures.
The exact contact surface area values (in Angstrom^2) are printed to the screen and also appended to a file called contactareas.txt.
If only a single global contact surface is calculated, a selection named "contact" is created that includes all receptor atoms within 3.9A of any ligand atom to illustrate the ''approximate'' contact surface.

The parameters are:

'''receptor''' ''(string)''
:: The name of the selection/object representing the receptor protein

'''ligand''' ''(string)''
:: The name of the selection/object representing the ligand
:: Note that this may be another protein!

'''receptor''' ''(string)''
:: The name of the selection/object representing the receptor protein

'''states''' ''(integer)'', default:0
:: Calculate contact surface between the receptor and the first n states of the ligand.
:: If states = 0, the script calculates a global contact surface which takes all possible ligand states into account.

= Usage =
<source lang="python">
contact_surface receptor, ligand, [states=0]
</source>

= The Code =
<source lang="python">
#contact_surface v.3.0
#Copyleft Martin Christen, 2013

from pymol import cmd,stored
def contact_surface(receptor,ligand,states=0):

"""
AUTHOR
Martin Christen

DESCRIPTION
This script calculates individual or global contact surfaces between a
receptor molecule and a bundle of docked ligand structures (which have
to be loaded into PyMOL as a multimodel object).

The exact contact surface area values (in Angstrom^2) are printed to
the screen and also appended to a file called contactareas.txt

If only a single global contact surface is calculated, a selection
named "contact" is created that includes all receptor atoms within
3.9A of any ligand atom.

USAGE
contact_surface receptor, ligand, [states=0]

PARAMETERS

receptor (string)
The name of the selection/object representing the receptor protein

ligand (string)
The name of the selection/object representing the ligand.
Note that this may be another protein!

states (integer)
Calculate contact surface between the receptor and the first n states
of the ligand. If states = 0 (default), the script calculates a global
contact surface which takes all possible ligand states into account.
"""
# sanity check the number of states
states = abs(int(states))

# make sure all atoms within an object occlude one another
cmd.flag('ignore','none')

# use solvent-accessible surface with high sampling density
cmd.set('dot_solvent','1')
cmd.set('dot_density','3')

#if the 'states' parameter = 0 create a superposition of all ligand states
if states == 0:
cmd.split_states(ligand)
cmd.group('ligandtemp',ligand+"_*")
cmd.create(ligand+"_all",'ligandtemp')
cmd.delete('ligandtemp')

#create complex
cmd.create('complextemp',ligand+"_all "+receptor)

#measure area
ligand_area=cmd.get_area(ligand+"_all")
receptor_area=cmd.get_area(receptor)
complex_area=cmd.get_area('complextemp')
#normalize since the area is counted TWICE (once on receptor and once on ligand)
contact_area=((ligand_area + receptor_area) - complex_area) / 2
#delete complex
cmd.delete('complextemp')

#create the contact surface
cmd.select('contact',"("+receptor+" and ("+ligand+"_all around 3.9))")

#print contact surface area
f=open('contactareas.txt','a')
print "%s - %s : " % (receptor,ligand),
print >>f, "%-s\t%-s\t" % (receptor,ligand),
print >>f, "%-s" % (contact_area)
print contact_area
f.close()
print "The GLOBAL contact area between "+receptor+ " and "+ligand+" is (A^2):"
print ((ligand_area + receptor_area) - complex_area) / 2

#If 'states' <> 0 calculate the contact areas to the first 'states' ligand states.
#No individual contact surface objects are created to avoid overloading PyMOL.
else:
#create an object for each ligand state
cmd.split_states(ligand)

#sanity check: do not exceed that maximum number of states
if states > cmd.count_states(ligand):
states = cmd.count_states(ligand)

#calculate contact surface area
print "The contact areas between "+receptor+" and "+ligand+" [states 1 - "+str(states)+"] are (A^2):"
#start looping
#for s in range(1,cmd.count_states(ligand)+1):
for s in range(1,states+1):
#create complex
cmd.create("tmp",ligand,s,1)
cmd.create('complextemp',"tmp "+receptor)
#measure areas
ligand_area=cmd.get_area('tmp')
receptor_area=cmd.get_area(receptor)
complex_area=cmd.get_area('complextemp')
#normalize since the area is counted TWICE (once on receptor and once on ligand)
contact_area=((ligand_area + receptor_area) - complex_area)/2
#delete temporary files
cmd.delete('tmp')
cmd.delete(ligand+"_*")
cmd.delete('complextemp')
#print contact surface area
f=open('contactareas.txt','a')
print "%s - %s_%-5s: " % (receptor,ligand,s),
print >>f, "%-s\t%-s_%-5s\t" % (receptor,ligand,s),
print >>f, "%-s" % (contact_area)
print contact_area
f.close()

cmd.extend("contact_surface",contact_surface)
</source>

[[Category:Script_Library]]
[[Category:Math_Scripts]]
[[Category:Structural_Biology_Scripts]]

Contact Surface

2013-02-15T15:10:05Z

MartinChristen: Script to calculate and display the contact surface area between a receptor and one or more ligand molecules. ~~~~

= Overview =
This script calculates individual or global contact areas between a receptor molecule and a (multimodel) bundle of docked ligand structures.
The exact contact surface area values (in Angstrom^2) are printed to the screen and also appended to a file called contactareas.txt
If only a single global contact surface is calculated, a selection named "contact" is created that includes all receptor atoms within 3.9A of any ligand atom to illustrate the ''approximate'' contact surface.

The parameters are:

'''receptor''' ''(string)''
:: The name of the selection/object representing the receptor protein

'''ligand''' ''(string)''
:: The name of the selection/object representing the ligand
:: Note that this may be another protein!

'''receptor''' ''(string)''
:: The name of the selection/object representing the receptor protein

'''states''' ''(integer)'', default:0
:: Calculate contact surface between the receptor and the first n states of the ligand.
:: If states = 0, the script calculates a global contact surface which takes all possible ligand states into account.

= Usage =
<source lang="python">
contact_surface receptor, ligand, [states=0]
</source>

= The Code =
<source lang="python">
#contact_surface v.3.0
#Copyleft Martin Christen, 2013

from pymol import cmd,stored
def contact_surface(receptor,ligand,states=0):

"""
AUTHOR
Martin Christen

DESCRIPTION
This script calculates individual or global contact surfaces between a
receptor molecule and a bundle of docked ligand structures (which have
to be loaded into PyMOL as a multimodel object).

The exact contact surface area values (in Angstrom^2) are printed to
the screen and also appended to a file called contactareas.txt

If only a single global contact surface is calculated, a selection
named "contact" is created that includes all receptor atoms within
3.9A of any ligand atom.

USAGE
contact_surface receptor, ligand, [states=0]

PARAMETERS

receptor (string)
The name of the selection/object representing the receptor protein

ligand (string)
The name of the selection/object representing the ligand.
Note that this may be another protein!

states (integer)
Calculate contact surface between the receptor and the first n states
of the ligand. If states = 0 (default), the script calculates a global
contact surface which takes all possible ligand states into account.
"""
# sanity check the number of states
states = abs(int(states))

# make sure all atoms within an object occlude one another
cmd.flag('ignore','none')

# use solvent-accessible surface with high sampling density
cmd.set('dot_solvent','1')
cmd.set('dot_density','3')

#if the 'states' parameter = 0 create a superposition of all ligand states
if states == 0:
cmd.split_states(ligand)
cmd.group('ligandtemp',ligand+"_*")
cmd.create(ligand+"_all",'ligandtemp')
cmd.delete('ligandtemp')

#create complex
cmd.create('complextemp',ligand+"_all "+receptor)

#measure area
ligand_area=cmd.get_area(ligand+"_all")
receptor_area=cmd.get_area(receptor)
complex_area=cmd.get_area('complextemp')
#normalize since the area is counted TWICE (once on receptor and once on ligand)
contact_area=((ligand_area + receptor_area) - complex_area) / 2
#delete complex
cmd.delete('complextemp')

#create the contact surface
cmd.select('contact',"("+receptor+" and ("+ligand+"_all around 3.9))")

#print contact surface area
f=open('contactareas.txt','a')
print "%s - %s : " % (receptor,ligand),
print >>f, "%-s\t%-s\t" % (receptor,ligand),
print >>f, "%-s" % (contact_area)
print contact_area
f.close()
print "The GLOBAL contact area between "+receptor+ " and "+ligand+" is (A^2):"
print ((ligand_area + receptor_area) - complex_area) / 2

#If 'states' <> 0 calculate the contact areas to the first 'states' ligand states.
#No individual contact surface objects are created to avoid overloading PyMOL.
else:
#create an object for each ligand state
cmd.split_states(ligand)

#sanity check: do not exceed that maximum number of states
if states > cmd.count_states(ligand):
states = cmd.count_states(ligand)

#calculate contact surface area
print "The contact areas between "+receptor+" and "+ligand+" [states 1 - "+str(states)+"] are (A^2):"
#start looping
#for s in range(1,cmd.count_states(ligand)+1):
for s in range(1,states+1):
#create complex
cmd.create("tmp",ligand,s,1)
cmd.create('complextemp',"tmp "+receptor)
#measure areas
ligand_area=cmd.get_area('tmp')
receptor_area=cmd.get_area(receptor)
complex_area=cmd.get_area('complextemp')
#normalize since the area is counted TWICE (once on receptor and once on ligand)
contact_area=((ligand_area + receptor_area) - complex_area)/2
#delete temporary files
cmd.delete('tmp')
cmd.delete(ligand+"_*")
cmd.delete('complextemp')
#print contact surface area
f=open('contactareas.txt','a')
print "%s - %s_%-5s: " % (receptor,ligand,s),
print >>f, "%-s\t%-s_%-5s\t" % (receptor,ligand,s),
print >>f, "%-s" % (contact_area)
print contact_area
f.close()

cmd.extend("contact_surface",contact_surface)
</source>

[[Category:Script_Library]]
[[Category:Math_Scripts]]
[[Category:Structural_Biology_Scripts]]

Cluster Count

2013-02-14T11:30:54Z

MartinChristen: New script to get statistics on b-factors ~~~~

= Overview =
This script calculates statistics on the B-values for all atoms in the selected object, prints the information on screen and appends it to a file called "cluster_count.txt".

= Usage =
<source lang="python">
cluster_count object
</source>

= Example =
<source lang="python">
cluster_count 1ubq

#output on screen:

Number of atoms in ' 1ubq ': 602
Minimum and Maximum B-values: 2.0 42.75
Average B-value: 13.4131063029
Standard deviation of the B-values: 8.70767140923
This data will be appended to cluster_count.txt

#output in file cluster_count.txt; the format is:
#objectname N minB maxB aveB stdevB
1ubq 602 2.000 42.750 13.413 8.708
</source>

= The Code =
<source lang="python">

# Script: cluster_count.py
# Copyleft 2010 Martin Christen

from pymol import cmd,stored
def cluster_count(selection):

"""
AUTHOR

Martin Christen

DESCRIPTION

This script calculates statistics on the B-values for all atoms in
the selected object, prints the information on screen and appends
it to the file "cluster_count.txt".

Output format on screen:
------------------------
Number of atoms in 'selection': 0
Minimum and Maximum B-values: 0.0
Average B-value : 0.0
Standard deviation of the B-values (best): 0.0 (0.0)
This data will be appended to cluster_count.txt

Output format in cluster_count.txt:
-----------------------------------
selection N minB maxB aveB stdevB

EXAMPLE

cluster_count 1ubq

Number of atoms in ' 1ubq ': 602
Minimum and Maximum B-values: 2.0 42.75
Average B-value: 13.4131063029
Standard deviation of the B-values: 8.70767140923
This data will be appended to cluster_count.txt

(in cluster_count.txt:)
1ubq 602 2.000 42.750 13.413 8.708

USAGE

cluster_count selection

"""

# get list of B-factors from selection
m = cmd.get_model(selection)
sel = []
b_list = []
dummy = []
for i in range(len(m.atom)):
b_list.append(m.atom[i].b)

#determine min and max
try: max_b = max(b_list)
except ValueError: max_b=0
try: min_b = min(b_list)
except ValueError: min_b=0

#determine average
try: average_b= float(sum(b_list)) / len(b_list)
except ZeroDivisionError: average_b=0

#determine standard deviation
for i in range(len(m.atom)):
if m.atom[i]>average_b:
dummy.append((m.atom[i].b-average_b)**2)
if m.atom[i]<average_b:
dummy.append((average_b-m.atom[i].b)**2)
try: stdev_b= (sum(dummy) / (len(m.atom)-1))**(1/2.0)
except ZeroDivisionError: stdev_b=0

#print values on screen
print "Number of atoms in '", selection,"': ", len(b_list)
print "Minimum and Maximum B-values: ", min_b, max_b
print "Average B-value: ", average_b
print "Standard deviation of the B-values: ", stdev_b
print "This data will be appended to cluster_count.txt"

#write information to cluster_count.txt
f=open('cluster_count.txt','a')
print >>f, '%-10s %8d %8.3f %8.3f %8.3f %8.3f' % (selection, len(m.atom), min_b, max_b, average_b, stdev_b)
f.close()
cmd.extend("cluster_count",cluster_count)
</source>

[[Category:Script_Library]]
[[Category:ObjSel_Scripts]]

Make Figures

2013-02-13T16:56:46Z

MartinChristen: New script to easily create figures. ~~~~

= Overview =
This script will aid you in making publication quality figures for the currently displayed scene.
It understands a variety of preset "modes" and sizes.

= Usage =
<source lang="python">
make_figure filename [, mode] [, size (default=900 pixels)] [,opaque]
</source>

The parameters are:

'''filename''' : The name of the resulting image file.
::''The extension '''.png''' is added automatically.''

''NOTE'': if no further arguments are given, the script generates quick figures for general use:
::* figures are not ray-traced
::* TWO figures at 300 x 300 px, 72 dpi
::* views are rotated 180° about y (front and back view)
::* _front_quick and _back_quick are appended to the filename

'''mode''' : Type of figure desired. Possible values are as follows:

::'''''single''''' = "single view"
::* one ray-traced 300 dpi figure of the current view

::'''''fb''''' = "front and back view"
::* TWO ray-traced 300 dpi figures
::* views are rotated 180° about y
::* _front and _back are appended to the filename

::'''''sides''''' = "four side views"
::* FOUR ray-traced 300 dpi figures
::* view is incrementally rotated by 90° about y
::* _1, _2, _3, and _4 are appended to the filename

::'''''stereo''''' = "stereoview"
::* TWO ray-traced 300 dpi figures
::* views are shifted by +/- 3 degrees
::* image dimensions are fixed at 750 x 750 pixels (size arguments are ignored)
::* _L and _R are appended to the filename
::* the output files are meant to be combined side by side to generate a stereo image

'''size''' : Size of the figure(s) in pixels or in "panels"
::* DEFAULT = 900 pixels if a mode is specified
::* if size is 12 or smaller, the script interprets it as a number of "panels" to make.
::* panel sizes in pixels are hardcoded in the source but can easily be modified.

'''opaque''' : Create an opaque background.
::* By default the figure background is 100% transparent.

= Examples =
<source lang="python">

#quick 'n' dirty front and back views of the scene
#300x300 pixels at 72 dpi, transparent background
# filenames will be output_front_quick.png and output_back_quick.png
make_figure output

# one ray-traced PNG file 975x975 pixels at 300dpi, with opaque background
# filename will be output.png
make_figure output, single, 975, opaque

# two panels (1350x1350 px each at 300dpi) of the "front" and "back" view on transparent background
# filenames will be output_front.png and output_back.png
make_figure output, fb, 2

# four panels (900x900 px each) where the view is incrementally rotated by 90° about y, transparent background
# filenames will be output_1.png, output_2.png, output_3.png and output_4.png
make_figure output, sides,4

#stereoview of the current scene with opaque background
#size is fixed to 2x 750x750px
# filenames will be output_L.png and output_R.png
make_figure output, stereo, opaque
</source>

= The Code =
<source lang="python">
#make_figure v.3.0
#Copyleft Martin Christen, 2010

from pymol import cmd
def make_figure(output='', mode='',size=900,opaque='transparent'):

"""

AUTHOR

Martin Christen

DESCRIPTION

"make_figure" creates publication-quality figures of the current scene.
It understands several predefined "modes" and sizes.

USAGE

make_figure filename [, mode] [, size (default=900 pixels)] [,opaque]

ARGUMENTS

mode = string: type of desired figure (single, fb, sides, stereo or -nothing-)
size = integer: size of the figure in pixels OR # panels (if <= 12)
opaque = specify an opaque background.
By default, the script makes the background transparent.
EXAMPLES

make_figure output
make_figure output, single, 975, opaque
make_figure output, fb, 2
make_figure output, sides,4
make_figure output, stereo

NOTES

"single" mode makes a single 300 dpi figure

"fb" mode makes TWO 300 dpi figure
("front" and "back", rotating by 180 degrees about y)

"sides" mode makes FOUR 300 dpi figures
("front" "left" "right" and back, rotating by 90 degrees clockwise about y)

"stereo" generates two 300 dpi, 750 px figures
("L" and "R", to be combined as a stereo image)
If you specify the stereo mode, the size argument is IGNORED.

If no mode argument is given, the script generates quick figures
for general use: TWO figures (front and back) at 300 x 300 px, 72 dpi.

Size is interpreted as pixels, except if the number is ridiculously small
(<=12), in which case the script as "number of panels" to make.

Edit the script manually to define corresponding values.

"""

#define sizes here (in pixels)
panel1 = 1800
panel2 = 1350
panel3 = 900
panel4 = 900
panel5 = 750
panel6 = 750
panel7 = 675
panel8 = 675
panel9 = 600
panel10 = 585
panel11 = 585
panel12 = 585

#verify size is an integer number and convert to pixels
size = int(size)
if size > 12:
pixels = size

elif size == 1:
pixels = panel1

elif size == 2:
pixels = panel2

elif size == 3:
pixels = panel3

elif size == 4:
pixels = panel4

elif size == 5:
pixels = panel5

elif size == 6:
pixels = panel6

elif size == 7:
pixels = panel7

elif size == 8:
pixels = panel8

elif size == 9:
pixels = panel9

elif size == 10:
pixels = panel10

elif size == 11:
pixels = panel11

elif size == 3:
pixels = panel12

#change background
cmd.unset('opaque_background')
if opaque == 'opaque':
cmd.set('opaque_background')

#apply mode
if output == '':
print 'no output filename defined\n'
print 'try: \'make_figure filename\''
return -1
# abort if no output file name given

if mode =='':
cmd.set('surface_quality',1)
cmd.set('opaque_background')
cmd.png(output+"_back_quick",300,300,dpi=72)
cmd.turn('y',180)
cmd.png(output+"_front_quick",300,300,dpi=72)
cmd.turn('y',180)
cmd.set('surface_quality',0)
# make front and back figures for quick mode

elif mode == 'single':
cmd.set('surface_quality',1)
cmd.set('ray_shadow',0)
cmd.ray(pixels, pixels)
cmd.png(output, dpi=300)
cmd.set('surface_quality',0)
# make a figure for single mode

elif mode == 'fb':
cmd.set('surface_quality',1)
cmd.set('ray_shadow',0)
cmd.ray(pixels, pixels)
cmd.png(output+"_front", dpi=300)
cmd.turn('y',180)
cmd.ray(pixels, pixels)
cmd.png(output+"_back", dpi=300)
cmd.turn('y',180)
cmd.set('surface_quality',0)
# make front and back figures for single mode

elif mode == 'sides':
cmd.set('surface_quality',1)
cmd.set('ray_shadow',0)
cmd.ray(pixels, pixels)
cmd.png(output+"_1", dpi=300)
cmd.turn('y',90)
cmd.ray(pixels, pixels)
cmd.png(output+"_2", dpi=300)
cmd.turn('y',90)
cmd.ray(pixels, pixels)
cmd.png(output+"_3", dpi=300)
cmd.turn('y',90)
cmd.ray(pixels, pixels)
cmd.png(output+"_4", dpi=300)
cmd.turn('y',90)
cmd.set('surface_quality',0)
# make front and back figures for single mode

elif mode == 'stereo':
cmd.set('surface_quality',1)
cmd.set('ray_shadow',0)
cmd.ray(750, 750, angle=-3)
cmd.png(output+"_R", dpi=300)
cmd.ray(750, 750, angle=3)
cmd.png(output+"_L", dpi=300)
# make stereo figure (for more control use stereo_ray)

cmd.extend('make_figure',make_figure)
</source>

[[Category:Script_Library]]
[[Category:UI_Scripts]]