ProteinShader: illustrative rendering of macromolecules
© Weber; licensee BioMed Central Ltd. 2009
Received: 26 July 2008
Accepted: 30 March 2009
Published: 30 March 2009
Cartoon-style illustrative renderings of proteins can help clarify structural features that are obscured by space filling or balls and sticks style models, and recent advances in programmable graphics cards offer many new opportunities for improving illustrative renderings.
The ProteinShader program, a new tool for macromolecular visualization, uses information from Protein Data Bank files to produce illustrative renderings of proteins that approximate what an artist might create by hand using pen and ink. A combination of Hermite and spherical linear interpolation is used to draw smooth, gradually rotating three-dimensional tubes and ribbons with a repeating pattern of texture coordinates, which allows the application of texture mapping, real-time halftoning, and smooth edge lines. This free platform-independent open-source program is written primarily in Java, but also makes extensive use of the OpenGL Shading Language to modify the graphics pipeline.
By programming to the graphics processor unit, ProteinShader is able to produce high quality images and illustrative rendering effects in real-time. The main feature that distinguishes ProteinShader from other free molecular visualization tools is its use of texture mapping techniques that allow two-dimensional images to be mapped onto the curved three-dimensional surfaces of ribbons and tubes with minimum distortion of the images.
The study of protein structure is an intensely active area of research. The number of proteins for which a three-dimensional structure has been solved has increased exponentially in recent years, and there are currently over 56,000 entries in the Protein Data Bank (PDB [1, 2]), a publicly accessible single worldwide archive of structural data for biological macromolecules. The three-dimensional structure of a protein determines what other molecules it is capable of binding and interacting with, so a deep understanding of protein structure is critical for predicting protein function and for designing drugs that interact with proteins.
The basic building blocks of protein, amino acids, are small enough that they can be easily understood using simple balls and sticks models that show every atom and bond. Proteins, however, are typically composed of hundreds or even thousands of amino acids, making detailed three-dimensional models very difficult to understand. Fortunately, artistic ribbon representations of the protein backbone can be used to clarify regions of secondary structure, for example by using spiral ribbons for α-helices and arrows for β-strands , and simplified cartoon-style models using ribbons and tubes are commonly used in molecular visualization programs.
The World Index of BioMolecular Visualization Resources web page  has an extensive listing of free molecular visualization programs that can run on ordinary personal computers. One of the most influential of these is RasMol , which is written in the C programming language, and is available on Windows, Macintosh, Linux, and Unix platforms [6, 7]. RasMol's success was apparently due to an excellent compromise between rendering speed and image quality so that even large proteins can be rotated in real time . More recently, Java based molecular visualization tools have become popular, in large part because of Java's platform independence, and a typical PDB web page for a protein now contains links to allow interactive three-dimensional images to be displayed using Java programs such as KiNG , WebMol , or Jmol .
Recent advances in programmable graphics cards offer a number of new opportunities for illustrating proteins. Many inexpensive, commonly available graphics cards now fully support the use of the OpenGL Shading Language (GLSL ), which is used to write small programs, known as shaders, for modifying the graphics pipeline to produce sophisticated visual effects . A few free molecular visualization tools have begun to take advantage of these new opportunities. The Visual Molecular Dynamics program uses GLSL to improve image quality and rendering speed [14, 15], while QuteMol goes further by using GLSL to add illustrative rendering effects (also known as non-photorealistic rendering) such as borders around atoms and halo effects that make space filling, balls and sticks, and liquorice models much easier to interpret [16, 17].
The ProteinShader program described in this paper further exploits GLSL by using custom texture mapping and lighting calculations implemented on the graphics card to produce ribbon and tube cartoon-style illustrative renderings of proteins that approximate what an artist might create by hand using pen and ink. Custom shading calculations are also used to map text labels and decorative textures onto the curved surfaces of tubes and ribbons shown in color.
ProteinShader is written primarily in Java, which was chosen because of its platform independence, as well as the ability of a Java Swing-based GUI to adopt the look and feel of the current operating system . The Javadoc tool  was used to extract comments from the source code and generate the API (Application Programming Interface) files that are included in the help directory of the ProteinShader distribution. The current version of ProteinShader, beta 0.9.4, is available as Additional files 1 and 2, or can be downloaded from SourceForge , where future versions will be posted.
To obtain hardware-accelerated rendering of high quality three-dimensional perspective images of a protein, the low-level Open Graphics Library (OpenGL [21, 22]) that runs on most modern graphics cards is used. The ribbons and tubes used by ProteinShader are drawn as collections of flat polygons tiled together to form continuous surfaces, and texture mapping coordinates are assigned to individual vertices as they are generated. Because OpenGL is primarily intended to work with the C/C++ language, Java Bindings for OpenGL (JOGL [23, 24]) is used to allow the Java code to access OpenGL.
To map textures onto the surfaces of ribbons and tubes, vertex and fragment shaders written in the OpenGL Shading Language [12, 13] are used. The vertex shader allows a programmer to manipulate directional vectors associated with a vertex, while the fragment shader is for applying custom equations for setting the color of each surface fragment (potential future pixel) [13, 25].
To speed up the number of frames per second that can be rendering during an animation (a constant rotation), geometry is cached on the graphics card by using OpenGL display lists . When tested with an inexpensive good quality mid-range graphics card, the ATI Radeon X1600, caching geometry in advance resulted in a nine-fold increase in performance for ribbons and a thirteen-fold increase in performance for tubes (data not shown).
Results and discussion
Overview of the ProteinShader GUI
Menu bar options.
In addition to Open and Quit, there is an Export Image submenu that allows the image on the canvas to be saved as a PNG or JPEG file.
The Cartoon submenu allows the protein to be displayed as Tubes, Ribbons, Tubes and Ribbons, or Frenet Frames. The Atom submenu offers Space Filling (spheres), Balls and Sticks (spheres and cylinders), or Sticks (cylinders).
Coarse-level of control over whether Amino Acids, Heterogens, or Waters are visible. Control panels in Table 2 provide a more fine-grained control.
Choosing Original resets the protein to its original size and front orientation, while Front, Back, left, Right, Top, and Bottom affect the protein's orientation, but not the camera distance.
Sets the background color on the canvas to Black, Gray, Light Gray, White, or opens a Chooser dialog box that can be used to select any color.
Opens and closes the control panel on the right side of the canvas.
Opens the desktop's default web browser and loads a help html file.
Subpanels of the retractable right-side control panel.
The left-side subpanel allows selection of any model, chain, residue, water, heterogen, or atom of the protein. This subpanel is always present, whereas the right-side subpanel can be changed to any of the subpanels listed below.
Applies texture maps and other special effects to ribbon and tube segments (the term segment refers to the length of a tube or ribbon that corresponds to an individual amino acid). This subpanel is visible in Figure 1.
Sets the color of tube and ribbon segments. Default colors based on region or amino acid type can be used, or a color chooser dialog box can be opened.
Sets any segment or group of segments in a tube or ribbon to be opaque, translucent, or invisible.
Cartoon Side Chains
Used to display amino acid side chains in combination with tubes or ribbons. The side chains can be shown as space filling, balls and sticks, or sticks.
Allows constant motion about the x-axis and/or y-axis of the protein. The frames per second will be displayed in the upper left of the canvas.
Provides options for smoothing out the aliasing (jagged diagonal line) effect that often occurs at the edges of geometrically defined objects.
Sets the color of atoms in a space filling, balls and sticks, or sticks style display. Default colors based on atom or amino acid type can be applied, or a color chooser dialog box can be opened.
Sets any atom or group of atoms to be opaque, translucent, or invisible. A slider allows any degree of translucency from 0 to 100%.
Adjusts the radii of spheres in a space filling or balls and sticks style display.
Can be used to turn off automatic tiling (level of detail control) for spheres and cylinders. This panel has no effect on ribbon and tube style displays.
In addition to the ribbons and tubes cartoon-type representations, the Style menu above the canvas can also be used to select atom-type representations: space filling (spheres), balls and sticks (spheres and cylinders), and sticks (cylinders). Dragging the mouse across the canvas can be used to rotate or zoom in on images, or an image can be rotated at constant speed by using a motion control panel. Details on mouse movements or the various control panels and menus can be found by using the Help menu above the canvas.
General strategy for tubes and ribbons
Three-dimensional ribbons and tubes can be drawn by sweeping a waist polygon along a curved line at regular intervals and, at each point along the curve, aligning the polygon to a local coordinate frame (an xyz-axis system) that keeps the plane of the polygon perpendicular to the tangent of the curve . When two copies of the polygon are placed at adjacent points along the curve, connecting their vertices can be used to define the small, flat polygons that ultimately approximate the curved surface of the ribbon or tube. In ProteinShader, the curved line and local coordinate frames needed for creating ribbons and tubes are generated using the xyz-coordinates of the α-carbons in each polypeptide chain.
Local coordinate frames for α-carbons
N, B, and T form a right-handed perpendicular xyz-axis system, with N and T in the plane represented by the light green triangle in Figure 3A. Written as column vectors, N, B, and T form the rotation matrix shown in Figure 3B. This matrix can be used to take a waist polygon drawn in the xy-plane of a global xyz-coordinate system and rotate it into the xy-plane of the local coordinate frame for an α-carbon.
To develop a curved line that passes through the α-carbons in a chain, Hermite interpolation  is used. The curved line is actually a spline, a series of piecewise cubic polynomial equations, where each polynomial equation begins at one α-carbon and ends at the next. The xyz-coordinates and tangent vectors of the two α-carbons are used to solve the constants A, B, C, and D in the set of parameterized equations shown in Figure 3C. The parameter t is set to 0.0 at α-carbon (i) and to 1.0 at α-carbon (i + 1), so intermediate values of t can be used to solve for the xyz-coordinates of any point on the curved line. The tangent vectors used in the calculations are adjusted to a length of 4.0 because that gives a reasonable curvature for α-helices and β-strands.
An algorithm is also needed for interpolating between the local coordinate frames of α-carbons. The tangent (z-axis) of each interpolated frame could be calculated from the first derivatives of the equations shown in Figure 3C, and a simplistic linear interpolation could be used to calculate a normal (x-axis) and binormal (y-axis) for each point. However, a much smoother interpolation can be achieved by using the spherical linear interpolation (SLERP) parameterized equation shown in Figure 3D[35–37].
SLERP, which is based on the use of quaternions, is commonly used in computer graphics for gliding a camera through a scene because it avoids the quirks and jerky motion of earlier methods . A quaternion is a four-tuple devised by W. R. Hamilton to extend complex numbers into multiple dimensions, but it can also be used to represent a three-dimensional rotation in space [35, 37]. A rotation matrix can be converted into a quaternion , and interpolating between quaternions produces a smoother rotation than attempting to interpolate between matrices.
To maintain the three-dimensional structure of a tube or ribbon, the waist polygon drawn in the xy-plane of each local coordinate frame should be kept perpendicular to the spline, so the tangent (z-axis) of each local frame should closely matches the tangent of the spline. A minor problem with using SLERP is that the tangent of each interpolated quaternion (the z-axis of the local frame that the quaternion is equivalent to) will not necessarily match the tangent calculated by Hermite interpolation.
To fix any discrepancy between the SLERP- and Hermite-calculated tangents, the tangents are compared, and if there is more than one degree of difference, a rotation is used to make the SLERP tangent match the Hermite tangent. The axis and angle of rotation are calculated using the cross product and dot product, respectively, of the two tangents, and for convenience the axis and angle are converted into a quaternion.
Multiplying the interpolated quaternion by the tangent-fix-up quaternion adjusts the interpolated quaternion so that if it was converted back into a rotation matrix, its tangent would now match the tangent of the spline. The net effect of these manipulations is that the tangent (z-axis) of each local frame along the spline is determined by Hermite interpolation, while the SLERP algorithm provides for a smooth, gradual rotation of the xy-axes.
To visualize the spline and local coordinate frames produced by the Hermite-SLERP algorithm, the Style menu above the canvas has a Frenet Frames option. An α-helix from the c-Jun protein  is shown as Frenet Frames in Figure 3E, where the local frames use the same color scheme as in Figure 3A, and the interpolated frames are shown on a smaller scale. In Figure 3F, the same α-helix is shown after selecting Tubes from the Style menu and Wireframe from the Decorations panel. The red end cap is the waist polygon that is swept along the spline while drawing the tube, and the lines of the wireframe connect the vertices that define the surface of the tube. In Figure 3G, the α-helix is shown after selecting Plain from the Decorations panel and using the Cartoon Color panel to apply colors based on amino acid type. Phong lighting calculations [40, 41] are used to smooth out the appearance of the tube's surface and to add specular highlighting (the shiny plastic-like appearance) to enhance the three-dimensional quality of the image.
To fix this problem, the local coordinate frames for successive α-carbons are compared to check for a radical change in direction. The frames are aligned along their tangents (z-axes) by using the procedure described earlier for making SLERP-calculated tangents match Hermite-calculated tangents, and if the angle between the two binormal vectors (y-axes) is greater than 90 degrees, the second frame is rotated 180 degrees about its tangent (z-axis). After performing this fix-up step along a β-strand's length, the frames will be aligned as shown in Figure 4C. The appearance of the ribbon is greatly improved as shown in Figure 4D, and the antiparallel nature of the two β-strands becomes more obvious because the crests and valleys of the ribbons coincide.
It might seem simpler to assume that the coordinate frame for every second α-carbon should be rotated. However, that strategy will not always work because there are occasional irregularities in the structure of lengthy β-strands, as well as some problems with how β-strands are defined.
Combining side chains with ribbons
Segments and texture mapping
If a region of secondary structure were stored as a single collection of vertices, dynamically applying colors or textures to mark individual amino acids would become quite complex. Therefore, the basic geometric unit of organization for rendering tubes and ribbons in the ProteinShader program is a segment, which is defined as a length of a tube or ribbon that corresponds to a single amino acid. A segment's center is the xyz-coordinates of its α-carbon, while its beginning and end are the midpoints along the spline to the previous and next α-carbon, respectively.
Vertices at the beginning of a segment are assigned a t-coordinate of 0.0, while vertices at the end are assigned a t-coordinate of 1.0. The s-coordinate, on the other hand, increases in the counter clockwise direction as the vertices of the waist polygon are drawn in the xy-plane, and the exact start and end values are somewhat variable. For example, the broad surfaces of ribbons have s-coordinates from 0.0 to 1.0, but on the narrow sides of ribbons the s-coordinates run from 0.0 to only 0.125. For tubes, the s-coordinate runs from 0.0 to 2.0 so that the same texture map will be wrapped around the tube twice.
The Patterns, Text Labels, and Wireframe buttons of the Decorations subpanel accomplish their effects by using texture mapping. The images in the Patterns menu are read from PNG (Portable Network Graphics ) or JPEG (Joint Photographic Experts Group ) files in the textures/patterns subdirectory, and the menu can be modified by editing a configuration file. The lines for the wireframe images are calculated on-the-fly, while the images needed for amino acid labels are generated whenever a protein structure is first loaded by extracting letters and digits from an image file. Texture mapping is also important for creating pen-and-ink style drawings.
Pen-and-ink style drawings
To produce pen-and-ink style drawings, a variety of edge lines need to be added. For ribbons, many of the edge lines can be added by darkening fragments of a surface if they have an s or t coordinate close to the minimum or maximum. For tubes, however, this approach is only useful at the beginning or end of a segment, as what appears to be an edge along the length of a tube is determined by the view angle.
Instead of a sharp cutoff, the smoothing function graphed in Figure 7B is used to determine edge line intensity: I = exp2(-2d2), where d = 2cosine(θ) and θ is the angle between N and V. This equation is from a paper on single-pass wireframe rendering , where d was a distance. The equation is also used to smooth edge lines generated from texture coordinates.
The result of these edge-line calculations can be seen by comparing two images of the human growth hormone protein . In Figure 7C, a color model has been converted to grayscale by using the equation: gray = 0.30 red + 0.59 green + 0.12 blue. In Figure 7D, edge lines generated from the view angle have been applied along with texture-coordinate based edges added to segment end caps.
To emphasize bends in the middle of segments, a second texture has been applied to the image in Figure 8 (see lower right inset), and the intensity of the texture is proportional to how strongly a segment's spline is bent. A bend factor on a linear scale from 0.0 to 1.0 is calculated by comparing the tangents at the beginning and end of a segment. If the tangents have an angle close to 180 degrees when placed tail to tail, the spline is nearly straight and the bend factor is close to 0.0. If the angle is almost 50 degrees, the segment is strongly bent, and the bend factor is close to 1.0.
Halftoning and bend textures can be selected from menus in the Decorations panel shown in Figure 1. The textures are stored as PNG  or JPEG  files, and the Help menu has directions for adding new textures. Textures can be assigned to individual segments of a ribbon or tube, so the pen-and-ink style drawing can be mixed with other options (Patterns, Text Labels, Wireframe, and Plain).
Performance costs for shaders
Proteins used in performance testing.
F1 ATPase inhibited by DCCD
GroEL-GroES-(ADP)7 chaperonin complex
For Figure 11, the Decorations subpanel of the ProteinShader GUI was used to select shaders for special effects while rendering a tubes style display. For each test protein in Figure 11F, if the Phong lighting (Plain) frames per second is considered to be 100%, switching to the wireframe shaders or adding patterns by texture mapping typically results in a fairly minor reduction of less than 20%, while more complex calculations such as adding text labels or halftoning result in reductions of almost 50%. Given the quality of the images obtained, the performance costs for using custom vertex and fragment shaders seems reasonable. A caveat to these results, however, is that a fairly recent good quality graphics card is required.
The proteins tested in Figure 11F range from 175 amino acids to about 8,000 amino acids (see Table 3), and each approximate doubling in protein size results in a roughly 2-fold reduction in frames per second. Overall, the 46-fold increase in number of residues from the smallest to the largest test protein (1AQB to 1AON) results in very close to a 46-fold decrease in frames per second (from 153 to 3.2 frames per second for Phong lighting (Plain) and from 86.7 to 1.9 frames per second for Halftoning). These results indicate that, at least within this size range, rendering times scale in a nearly linear manner for tubes style displays with custom shaders.
The ProteinShader control panel has an Antialiasing subpanel, where the option to antialias black edges of halftoning images can be selected. By adding gray pixels outside object boundaries, this option partially smooths out the jagged edges, as shown in Figure 12B. To accomplish this effect, a translucent black silhouette of each tube or ribbon segment is rendered four times with a slight offset (a half pixel up, down, left, or right) before rendering the segment with halftoning.
The Antialiasing subpanel also provides an option for smoothing any image by rendering the entire scene several times with jitter and blending the images. The scene can be jittered from 2 to 16 times using jitter values taken from the OpenGL Programming Guide , and this antialiasing can be combined with the silhouette-based antialiasing to produce nicely smoothed dark edges, as shown in Figures 12C and 12D.
Antialiasing dramatically slows rendering during an animation, as shown in Figure 12E. The silhouette-based antialiasing slows rendering by about 3-fold, while jittering the entire scene n times will slow rendering down about n-fold. Because of the performance costs, antialiasing is intended mainly for saving static images as PNG or JPEG files. Antialiasing is used on all of the images in previous figures, except for Figures 10 and 11.
The ProteinShader program is a platform-independent Java-OpenGL molecular visualization tool that exploits recent advances in programmable graphics cards. The primary accomplishment of this free, open-source code program is its ability to render a protein as a cartoon-style drawing that approximates what an artist might create by hand using pen and ink (see Figures 1, 2, 8, and 9). The artistic effects employed by ProteinShader rely heavily on texture mapping, where two-dimensional images are systematically mapped onto the curved surfaces of three-dimensional ribbons and tubes. To minimize distortions or irregularities in the images used as textures, a hybrid Hermite-SLERP algorithm was developed for generating smooth, gradually rotating tubes and ribbons.
The custom texture mapping and lighting calculations needed for rendering pen-and-ink style images are implemented using vertex and fragment shaders written in the OpenGL Shading Language [12, 13], which is supported on most new graphics cards for ordinary desktop and laptop computers. Shaders are also used for mapping text labels and decorative textures onto the surfaces of ribbons and tubes shown in color.
To create images suitable for publication, the program has antialiasing options that can nicely smooth out the jagged (pixelated) edges that are often seen in computer-generated images. However, antialiasing dramatically slows rendering time, so it may not be suitable for animations, unless a fairly high-end graphics card is used. The performance costs for using custom shaders rather than OpenGL's built-in lighting equations appears to be fairly minor on recent graphics cards.
As an aid to future development, a Frenet frames style display allows the user to visualize the mathematics that underlies the tubes and ribbons. Key areas for future development are representations of DNA, which is not currently supported, and selection by clicking on parts of an image. In the present version of the ProteinShader program, all manipulations are done through user-friendly menus and control panels.
Availability and requirements
Project name: ProteinShader
Project home page: http://proteinshader.sourceforge.net
Operating system: Platform independent (tested on Linux, Macintosh OS X, and Windows XP)
Programming languages: Java and OpenGL Shading Language
Other requirements: Java 1.5 and a graphics card supporting OpenGL 2.0 or higher.
License: GNU General Public License
Restrictions to use by non-academics: None
- RSCB Protein Data Bank[http://www.rcsb.org]
- Berman HM, Westbrook J, Feng Z, Gilliland G, Bhat TN, Weissig H, Shindyalov IN, Bourne PE: The Protein Data Bank. Nucleic Acids Res 2000, 28: 235–242.PubMed CentralView ArticlePubMedGoogle Scholar
- Richardson JS: The anatomy and taxonomy of protein structure. Adv Protein Chem 1981, 34: 167–339.View ArticlePubMedGoogle Scholar
- World Index of Biomolecular Visualization Resources[http://molvis.sdsc.edu/visres/molvisfw/titles.jsp]
- Sayle RA, Milner-White EJ: RASMOL: biomolecular graphics for all. Trends Biochem Sci 1995, 20(9):374.View ArticlePubMedGoogle Scholar
- Home Page for RasMol and OpenRasMol[http://www.openrasmol.org]
- Bernstein HJ: Recent changes to RasMol, recombining the variants. Trends Biochem Sci 2000, 25(9):453–455.View ArticlePubMedGoogle Scholar
- Martz E: Protein Explorer: easy yet powerful macromolecular visualization. Trends Biochem Sci 2002, 27(2):107–109.View ArticlePubMedGoogle Scholar
- KiNG Display Software[http://kinemage.biochem.duke.edu/software/king.php]
- WebMol Java PDB Viewer[http://www.cmpharm.ucsf.edu/cgi-bin/webmol.pl]
- Jmol: an open-source Java viewer for chemical structures in 3D[http://www.jmol.org]
- OpenGL Shading Language Specification[http://www.opengl.org/documentation/glsl]
- Shreiner D, Woo M, Neider J, Davis T: OpenGL 2.0 and the OpenGL Shading Language. In OpenGL Programming Guide. Fifth edition. Upper Saddle River, NJ: Addison-Wesley; 2005:623–664.Google Scholar
- Visual Molecular Dynamics[http://www.ks.uiuc.edu/Research/vmd]
- Humphrey W, Dalke A, Schulten K: VMD: visual molecular dynamics. J Mol Graph 1996, 14(1):33–38.View ArticlePubMedGoogle Scholar
- Tarini M, Cignoni P, Montani C: Ambient occlusion and edge cueing for enhancing real time molecular visualization. IEEE Trans Vis Comput Graph 2006, 12(5):1237–1244.View ArticlePubMedGoogle Scholar
- The Swing Tutorial[http://java.sun.com/docs/books/tutorial/uiswing/index.html]
- Javadoc Tool Home Page[http://java.sun.com/j2se/javadoc/index.jsp]
- ProteinShader Project Summary Page[http://sourceforge.net/projects/proteinshader]
- Shreiner D, Woo M, Neider J, Davis T: OpenGL Programming Guide. Fifth edition. Upper Saddle River, NJ: Addison-Wesley; 2005.Google Scholar
- The JOGL API Project[http://jogl.dev.java.net]
- Davis G: Learning Java Bindings for OpenGL (JOGL). Bloomington, IN: AuthorHouse; 2004.Google Scholar
- Rost RJ: OpenGL Shading Language. Upper Saddle River, NJ: Addison-Wesley; 2006.Google Scholar
- Shreiner D, Woo M, Neider J, Davis T: Display lists. In OpenGL Programming Guide. Fifth edition. Upper Saddle River, NJ: Addison-Wesley; 2005:277–300.Google Scholar
- Zanotti G, Panzalorto M, Marcato A, Malpeli G, Folli C, Berni R: Structure of pig plasma retinol-binding protein at 1.65 A resolution. Acta Crystallogr D Biol Crystallogr 1998, 54(5):1049–1052.View ArticlePubMedGoogle Scholar
- Brandon C, Tooze J: Membrane proteins. In Introduction to Protein Structure. Second edition. New York: Garland Publishing; 1998:223–250.Google Scholar
- Weiss MS, Schulz GE: Porin conformation in the absence of calcium. Refined structure at 2.5 A resolution. J Mol Biol 1993, 231(3):817–824.View ArticlePubMedGoogle Scholar
- Kobe B, Deisenhofer J: Mechanism of ribonuclease inhibition by ribonuclease inhibitor protein based on the crystal structure of its complex with ribonuclease A. J Mol Biol 1996, 264(5):1028–1043.View ArticlePubMedGoogle Scholar
- Imada K, Inagaki K, Matsunami H, Kawaguchi H, Tanaka H, Tanaka N, Namba K: Structure of 3-isopropylmalate dehydrogenase in complex with 3-isopropylmalate at 2.0 A resolution: the role of Glu88 in the unique substrate-recognition mechanism. Structure 1998, 6(8):971–982.View ArticlePubMedGoogle Scholar
- Doyle DA, Morais Cabral J, Pfuetzner RA, Kuo A, Gulbis JM, Cohen SL, Chait BT, MacKinnon R: The structure of the potassium channel: molecular basis of K+ conduction and selectivity. Science 1998, 280(5360):69–77.View ArticlePubMedGoogle Scholar
- Hill FS: Extruded shapes. In Computer Graphics using OpenGL. Second edition. Upper Saddle River, NJ: Prentice Hall; 2000:310–321.Google Scholar
- Hill FS: Hermite interpolation. In Computer Graphics using OpenGL. Second edition. Upper Saddle River, NJ: Prentice Hall; 2000:644–645.Google Scholar
- Gamasutra: Rotating Objects Using Quaternions[http://www.gamasutra.com/features/19980703/quaternions_01.htm]
- Sacred Software: Quaternions[http://www.sacredsoftware.net/tutorials/Quaternions/Quaternions.xhtml]
- Shoemake K: Animating rotation with quaternion curves. Comput Graph (ACM) 1985, 19(3):245–254.View ArticleGoogle Scholar
- Maths: Conversion Matrix to Quaternion[http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm]
- Junius FK, O'Donoghue SI, Nilges M, Weiss AS, King GF: High resolution NMR solution structure of the leucine zipper domain of the c-Jun homodimer. J Biol Chem 1996, 271(23):13663–13667.View ArticlePubMedGoogle Scholar
- Hill FS: Phong shading. In Computer Graphics using OpenGL. Second edition. Upper Saddle River, NJ: Prentice Hall; 2000:435–436.Google Scholar
- OpenGL Directional Lights II[http://www.lighthouse3d.com/opengl/glsl/index.php?ogldir2]
- Hill FS: Adding textures to faces. In Computer Graphics using OpenGL. Second edition. Upper Saddle River, NJ: Prentice Hall; 2000:439–465.Google Scholar
- Shreiner D, Woo M, Neider J, Davis T: Assigning texture coordinates. In OpenGL Programming Guide. Fifth edition. Upper Saddle River, NJ: Addison-Wesley; 2005:420–421.Google Scholar
- PNG: Portable Network Graphics[http://www.libpng.org/pub/png]
- JPEG: Joint Photographic Experts Group[http://www.jpeg.org]
- Baerentzen JA, Nielsen SL, Gjael M, Larsen BD, Christensen NJ: Single-pass wireframe rendering. In ACM SIGGRAPH Conference Sketches: July 2006; Boston. ACM Press, New York; 2006.Google Scholar
- Chantalat L, Jones ND, Korber F, Navaza J, Pavlovsky AG: The crystal-structure of wild-type growth-hormone at 2.5 angstrom resolution. Protein Pept Lett 1995, 2: 333–340.Google Scholar
- Freudenberg B, Masuch M, Strothotte T: Real-time halftoning: a primitive for non-photorealistic shading. In Proceedings of the 13th Eurographics Workshop on Rendering: 26–28 June 2002; Pisa, Italy. Springer-Verlag Wien, New York; 2002:227–232.Google Scholar
- Freudenberg B, Masuch M, Strothotte T: Real-time halftoning: fast and simple stylized shading.In Game Programming Gems 4 Edited by: Kirmse A. Charles River Media; 2004, 443–450. [http://wwwisg.cs.uni-magdeburg.de/~stefans/npr/entry-Freudenberg-2004-RTH.html]Google Scholar
- Cunningham BC, Wells JA: High-resolution epitope mapping of hGH-receptor interactions by alanine-scanning mutagenesis. Science 1989, 244(4908):1081–1085.View ArticlePubMedGoogle Scholar
- Hill FS: Aliasing; antialiasing techniques. In Computer Graphics using OpenGL. Second edition. Upper Saddle River, NJ: Prentice Hall; 2000:577–586.Google Scholar
- Shreiner D, Woo M, Neider J, Davis T: Antialiasing. In OpenGL Programming Guide. Fifth edition. Upper Saddle River, NJ: Addison-Wesley; 2005:247–260.Google Scholar
- Shreiner D, Woo M, Neider J, Davis T: The accumulation buffer. In OpenGL Programming Guide. Fifth edition. Upper Saddle River, NJ: Addison-Wesley; 2005:482–495.Google Scholar