Gallery‎ > ‎Videos‎ > ‎


About the Cover

On the cover: 
ePMV, the embedded Python Molecular Viewer, runs molecular modeling software directly inside of professional 3D animation applications (hosts). This system allows users to generate professional quality visuals or perform computational experiments with relative ease. It provides a flexible suite of hybrid tools to generate multiscale scenes that are both scientifically accurate and artistic. To construct this image of a molecular sculptor's workbench, ePMV representations of all new protein structures reported in this issue were scaled up ten million times and placed as tangible models onto a table and shelf using collision detection and gravity forces. The scene is lit by a single sun lamp positioned outside of a virtual window and rendered with a technology called global illumination that calculates object surface interreflection to produce a photorealistic effect. An animated version and a “making of” this scene can be viewed online at For more details, see Johnson et al., pp. 293–303. Cover image created by Graham Johnson and Ludovic Autin using ePMV running in the example host Cinema 4D. The editors and the cover authors would like to thank all of the contributors from this issue who made their structure coordinates available ahead of print.

Key of 9 molecular structures– from the top left:

   Coarse Molecular Surface (CMS) colored by polarity from Liao, J.C.C. et al pg. x-y. (2oq0 biological unit)

   CMS as unpolished sculpture from Lee, C. F. et al. pg. x-y. (3now)

   White ribbon cartoon with polarity colored sidechains pinned up to dry from Koehler, C. et al. pg. x-y. (2rqm)

   Ribbon cartoon with RNA ladder encased in clear acrylic CMS from Adams, P. et al. pg. x-y. (3qoq)

   CMS as a lit candle from Chen, J. and Wang, J. pg. x-y. (2kgl)

   Molecular Surface (MS) painted by polarity with green RNA from Simon, B., et al. pg. x-y. (2xfm)

   CMS not yet painted from Aksel, T et al. pg. x-y. (2lb6)

   MS sculpture emerging from coarse molecular surface via drill from Ferris, H. U., et al. pg. x-y. (2l7h)

   Spacefilling model colored-by-residue from Adams, P. et al pg. x-y. (PDBid)

Preview quality render of cover
fly-through (Previsualization)
Making of the cover (unedited footage, temp. post).
Fast, low quality, render of
scene fly-through
Global Illumination render (AKA beauty pass)
This is a rough render.  A final render with
additional physics will post on 

FIGURE 1. Recent shifts in molecular graphics protocols

Screen-captured video, showing a comparison of ePMV to an export-import protocol. 

(Play these 2 videos simultaneously to see a rough speed comparison of a typical project where the user decides to change from CPK coloring to secondary structure coloring. No need to repeat the export/import process with ePMV.)

Molecular Viewer Export to Professional 3D Software Import strategy used until 2009 for Maya (Maya users gained access to Molecular Maya) and 2010 for Blender and Cinema 4D:

ePMV protocol allows all activities to be performed in a single interface in Blender, Maya, Cinema 4D, and a variety of other potential hosting software packages that are Python aware. The models are fully and reversibly editable and many other algorithms can interoperate on them from this interface (see other figures below):

Early protocols, up to the late 1990s, used academic workstations for molecular visualization and required significant post processing to produce publication-quality files. The width of lines in the diagram represent the effort, as estimated from time records kept by Johnson, to create over 3000 PDB-based visualizations since 1998. Straightforward renderings of clean PDB input, e.g., to show a cartoon backbone for a textbook figure, took as few as 15 minutes from start to finish, while more complex representations often took days to set up and hours to render. With time, the capabilities of dozens of software packages merged and expanded to streamline these protocols and to provide new capabilities that were more accessible to novice users. As shown at the center, however, the connections between these methods remained varied and inconsistent. ePMV, shown at the bottom, links the scientific software directly to professional animation applications, combining their abilities and providing access to powerful new tools. ePMV can visualize typical subjects in less than 20 seconds–from entering the PDB code, to selecting the molecular representations, to setting the image style/dimensions, and then rendering a press-ready TIFF. These subjects can be further animated and simulated with relative ease from within the same GUI.

FIGURE 2. Program architecture

Screen-captured video discusses this architecture, highlights the connection to the data and shows advantages of the system.

A host application can embed Python and Python applications. A host must provide a Python wrapper for its API to translate code from the host’s low-level (high-speed) language to the relatively user-friendly Python language. With a common foundation of Python, ePMV can translate logic, architecture, and command variations between the host and PMV. We have selected PMV to serve as a foundation that can store the molecular model state, manipulate the model, and plug in other Python model manipulators– hence the title, embedded PMV. 

FIGURE 3. Information flow in ePMV

A screenshot from a host application, Cinema 4D, on the left, typifies a host GUI which consists of a 3D viewport, a hierarchical object manager, a python command-line interface, and other scene managers (interfaces for animation, materials, etc., slightly dimmed in this image). Into this host environment, we have scripted an ePMV GUI that acts as part of the host GUI to automate Python commands and provide a multi-line scripting window. Supplemental table 1 highlights features included in the alpha-release version of the ePMV GUI. 1) The ePMV Adaptor translates user events, passed by the host, including host-model-manipulations, from host syntax into commands that the PMV Model can understand then passes these commands to the Model itself. 2) Python-linked manipulation algorithms operate on the current Model state to generate a Resulting model state that the Model passes back to the ePMV Adaptor as an event. 3) ePMV plugs a host-specific library of helper functions into the Adaptor and translates the Resulting model into a set of commands recognizable by the host, which in this example, is a professional animation package called Cinema 4D. The resulting host functions update the view port with a synchronized version of the model. 

The screenshot in this Host View shows a four-panel viewport where perspective and orthogonal windows can draw the scene simultaneously with a variety of different rendering styles including OpenGL Shaded, Quick Shaded, and Quick Shaded with Lines. The front view was rendered to show the quality of output generated for movies and stills. A blue texture was made and dragged onto Helix2A to replace PMV’s default pink, and Strand1A (outlined in white) was selected to show the correlation between the geometric objects in the viewport and their representations in the hierarchy manager. The entire process can take less than 30 seconds, from starting the software to producing a publication ready image.

FIGURE 4. Examples of ePMV Models and Rendering

A) Residues 5 to 46, isolated from Trios phosphate isomerase (PDB ID 1tim (Banner et al., 1976)) show a β-α-β motif.   These realtime screen captures demonstrate how ePMV can produce various representations of data consistently across three different hosts. To produce this demonstration scene, a Python script run through ePMV generates a variety of representations of PDB data in three different 3D animation packages: Maya, Blender, and Cinema 4D. Most are standard geometric representations, such as the spacefilling (sphere) or molecular surface (Sanner et al., 1996) models. One backbone, left-middle, is traced with skeletal joint objects set up as an inverse-kinematic armature that can be pushed and pulled like a chain to deform any attached geometry as exemplified in figure 6.D below. 

demonstration in Cinema4D (Mac)

demonstration in Maya 2011 (XP)

demonstration in Blender 2.49 (XP)

B) A detailed demonstration of the sections of the GUI from Cinema 4D/Py4D with buttons, menus, and text boxes that support this basic functionality. Many images show renderings from Cinema 4D with the render-time option of ambient occlusion turned on to enhance the surface pockets for two of the representations from the scene and includes an editorial cast shadow to highlight the facile ray tracing options available in hosts.

(C) PDB ID 1t5s (Sorensen et al.,2004) was used to generate a standard structural biology figure that examines the ATP binding site. The electron density map of the calcium pump was retrieved from the Electron Density Server (EDS, (Kleywegt et al.,2004)) and isovalued at 0.23 (Bajaj et al., 1996). A backbone tube was generated along with stick renderings for the ligand and receptor. Color-by-polarity was applied to the receptor and Color-by-atom was applied to the ACP ligand. Host-based fog creates depth-cuing. 

(D) Selections made with the GUI can be combined with basic functions for research analysis. Here, a homology model target (blue) is compared to its template (gray) and to the actual crystal structure for 1m52.pdb (yellow) that came out at a later date. Crystallographic ligands for the template (red) and the resolved structure (green) highlight functionality of the kinase switch loop.

FIGURE 5. Complex ePMV scene rendered for different audiences and purposes

(A) A cell biology scene modeled with ePMV and host geometry, running in sample host Cinema 4D, depicts pathways of Ca2+ release and uptake using molecular structures from many sources. ePMV can quickly model representations of structural data while host tools can be used to model geometries to represent unknown or abstracted components. The host can then be used to assemble all of the models into a contextual scene. This scene includes a coarse molecular surface for receptor tyrosine kinase (PDB IDs 3kxz (Moy et al., 2010) and 2e9w (Yuzawa et al., 2007)) connected with two host cylinders to represent the unresolved transmembrane domains. Lipids are based on PDB coordinates pulled from a molecular dynamics simulation and simplified as an extruded rectangle on the right. The receptor and trimeric G-protein, and calcium pump (entries 1f88 (Palczewski et al., 2000) and 1got (Lambright et al., 1996) from the PDBTM were modeled with coarse molecular surfaces (Bajaj et al., 1996) and the receptor made transparent using a host texture to reveal an underlying ePMV ribbon model. The calcium pump (PDB ID 1t5s (Sorensen et al.,2004)) was loaded from the optional Orientations of Protein Membranes Database to ensure a proper translation and procession in the membrane. Low-confidence representations of the voltage and store-operated channels were hand-modeled using host tools to complete the story with minimal distraction. The entry 1061 (Sato et al., 2004) was loaded from the EMDB (Henrick et al., 2003) and isocontoured (Bajaj et al., 1996) to represent the Active IP3 receptor and a gray texture was applied to a duplicated instance to represent the inactive state, since no density map models exist for this conformation.

(B) A textbook figure based on the entire scene and rendered with educational style settings.

(C) A second camera (“Editorial camera”) was placed at an extreme angle, and editorial style scene settings were selected to render the scene with a dramatic editorial mood.

(D) A looping turntable animation of the calcium pump is useful for professional slide presentations and websites.


(E) A detailed animation shows conformational change in the calcium pump, based on two crystallographic structures (PDB ID 1su4 (MacLennan and Green, 2000) and 1t5s (Sorensen et al.,2004)). Domain-localized linear interpolation of the atoms from a molecular dynamics simulation performed with Modeller in ePMV and a hinged bone skeleton (host) for large domain motion was used to morph between the two experimental conformations, host-based vibration was applied to the ligand to imply Brownian motion, and the position of the ligand was keyframed to migrate into the binding pocket at a specific time. A host physics engine was used to prevent the vibrating ligand from colliding with the atoms in the receptor.

FIGURE 6. ePMV interoperations between host and external algorithms

The following screencaptured videos show ePMVs ability to interoperate scientific algorithms with features native to the host:

A) Monte Carlo mechanics perform ab initio folding of a short amino-acid sequence via PyRosetta (Chaudhury et al., 2010) to yield an alpha helix. Tutorial

B) A molecular dynamics simulation using Modeller (Eswar et al.,2008) was performed on HIV protease (PDB ID 3nu3 (Shen et al., 2010)). Tutorial

C) AutoFill builds an atomic model based on (Takamori et al., 2006) onto synaptic cleft vesicles imported from an electron microscope tomography model from (Arthur et al., 2010). Boundaries for the fill were generated interactively with native host tools. Tutorial

D) The Interactive Molecular Driver (Stone et al., 2001) or the realtime option in the Modeller widget allows realtime interactive molecular dynamics with additional forces provided by the user’s mouse gestures. Tutorial
Interactive Molecular Driver:

Modeller realtime MD:

E) Augmented reality allows a user to interact with data via hand held markers tracked by a camera (Gillet et al., 2005), in this case, to perform an interactive rigid body docking with intuitive mid-air hand gestures. Tutorial

F) The backbone of crambin (PDB ID 1crn (Teeter, 1984)) is animated to flex using inverse kinematic joints at each a-carbon. This can be coupled to a realtime molecular dynamics simulation as shown in 6D above. Tutorial

G) Molecules generated on a grid using host-based instancing are randomized and animated to imply Brownian motion with random walks combined with Newtonian physics solvers and collision avoidance. Tutorial

H) The screengrab opens with a user trying to dock a ligand into an active site- a complicated 3D puzzle. Rigid-body collision detection algorithms contributed by the host allow the ligand to be hand-guided into this binding site with real time scores (visible as text and color gradients on the atoms) provided by Python modules like Autodock (Huey et al, 2007) and PyRosetta (Chaudhury et al., 2010). Tutorial
I) Later in the sequence, host-provided physics shortcuts (soft-body springs for bonds) allow interactive flexible docking with real-time scoring within the receptor and the ligand as well. Tutorial

J) An atomic model is fit to an electron micrograph using symmetry instancing to generate the molecular and 2D crystallographic symmetry. Tutorial