The goal of this research is to exploit the computational capability of high performance and parallel computation by coupling it with the flexibility and interactivity of a visualization and data flow programming environment such as AVS, in order to facilitate the examination and prediction of biomolecular interactions. This project has not focused upon a particular parallel architecture, but has rather looked at the interplay between graphics interaction and high performance computing. By focusing on the scientific problem of protein structure and interactions, we have been able to integrate a number of novel approaches into an important biological problem. Component Based Visualization Building upon our experience with AVS, a data-flow visualization architecture, and Python, an object oriented, interpreted scripting and programming environment, we have explored a novel approach to integrating visualization and computing, by developing a visualization method which can be incorporated into any computational task. Within a typical molecular modeling environment, scientists use packages such as Sybyl from Tripos and Insight from MSI for molecular visualization. These programs put the emphasis on the biochemistry. They provide a rich, but difficult to extend, set of application specific functionalities and implement rather simple and specialized visualization capabilities. Another approach is a package such as AVS. This """"""""data flow"""""""" oriented environment allows the visualization of a much wider set of geometries with a fairly extensive set of controls over the rendering modes and parameters. However, this environment has proven to be difficult to specialize and to extend with application specific functionalities like the ones present in the two above mentioned molecular modeling packages. Moreover, all these programs exist in their own environment. In other words they cannot be embedded into another application; they are rather difficult to extend; they usually do not inter-operate very well with ot her programs; and they cannot be used programmatically. To address these limitations we have developed a general purpose geometry viewer based on OpenGL and written in the high level, object oriented interpreted language Python (www.python.org/). We have chosen this language for the following reasons: it is a fairly simple and small language that is easy to learn, yet it is very powerful. Its dynamically interpreted character makes it an excellent tool for rapidly prototyping applications. It is easily extensible and we have managed to make most of our computational tools available in this programmable environment in a matter of months thereby increasing substantially their interoperability (see last year's progress report). We felt that a visualization module would be a very useful addition to our collection of tools, because it could be used for the visualization of data coming from any of our computational methods, it would be tightly integrated in our environment and completely customizable and reusable. In some sense, this is a new way to approach scientific visualization. The rendering capability is now just another tool available in our working environment. This viewer is written in the Python programming language. It requires a Python interpreter (source code and binaries for a large number of computers are freely available) as well as the following standard extensions: """"""""OpenGL"""""""" the interface to the OpenGL library, """"""""Numeric Python"""""""" an extension to store and manipulate efficiently large arrays of numbers, and """"""""Tkinter"""""""" the interface to the Tk package which was used for the graphical user interface (GUI). Of course the Tk and OpenGL, or it's free Software emulation """"""""Mesa"""""""", has to be installed. The viewer currently made of close to 40 classes describing objects like, cameras, various geometries, event handlers. etc.. (7600 lines of self documented code). The following geometries can be created and displayed in the viewer: indexed line and polygon sets, polyline sets, sphere sets, 3D text sets. But any user created object that inherits from the """"""""Geom"""""""" base class can be displayed in this viewer. Objects displayed in a viewer form a user-defi ned hierarchy in which 3D transformations are inherited. Properties such as rendering mode or colors can be inherited too. A virtual trackball allows a user to transform objects, cameras, light sources, arbitrary clipping planes and textures using the mouse. The GUI provides visual feedback of the current transformation mode and the object hierarchy. It also provides panels to control rendering parameters such as line and point width, polygon mode, shading mode, line and points anti-aliasing, polygon culling, scene anti-aliasing, depthcueing, back-ground color, light sources parameters and light model parameters etc. The following features are currently implemented: * bject hierarchy with transformation inheritance * optional properties inheritance * depth cueing with fog start and fog end controls * line and points anti-aliasing * scene anti-aliasing * complete OpenGL light model * multiple directional light sources * light property editor * material property editor * Point, Line, Fill, Outline polygon mode for front and back facing polygons * polygon culling * 1D and 2D texture mapping * arbitrary clipping planes * transient objects * smart bounding box * front/back clipping plane control * event manager to add/replace callback function bound to mouse/keyboard events * support to display indexed line and polygon sets, sphere sets, 3D text, polyline sets * automatic material-binding-mode setting * automatic normal vectors generation * automatic lighting-calculation toggle Because this viewer is entirely written in Python it inter-operates very naturally with all other computational methods we have ported to Python. It can easily be specialized either by subclassing the viewer to create a new object or by overwriting some methods.
Showing the most recent 10 out of 270 publications
