The MPIRE Users Manual

Introduction to Volume Rendering

Volume rendering is a problem that requires significant amounts of memory and processing power. While computers are becoming more powerful each year, the size of volume data sets are growing just as fast (if not faster). This is not only the result of improving scanners for medical data, but also volume data sets created from supercomputer simulations. Because of this, volume rendering solutions need to be found on today's hardware since waiting for faster hardware results in larger data sets.

There are two main approaches to rendering volume data sets: surface fitting or direct volume rendering. While impressive images have been created with surface fitting techniques, algorithms of this type represent a data reduction method that can only represent surfaces and hard boundaries between volume elements of different types. Direct volume rendering methods such as ray casting, splatting and shear-warp create images directly from the volume data without the use of an intermediate polygonal approximation. For perspective, rendering a 512x512x512 data set requires a minimum of 4 bytes per voxel (512MB). One of the datasets from the Visible Human Project (VHP) is a Computed Tomography (CT) data set that is 512x512x1873 (1.8GB to render) in size. The VHP also has two microtomed data sets that are 2048x1216x1878 (14 GB) and 2048x1216x5189 (38 GB) in size.

To support interactive volume rendering, the entire data set must reside in RAM - waiting for several GBs to be read from disk for each image is not an option. The increasing availability of parallel computers with hundreds or thousands of processors provides a viable solution. For example, the Cray T3E at SDSC has 256 processing elements (PEs) with 128MB of RAM per PE (for a total of 32GB).

Massively Parallel Interactive Rendering Environment (MPIRE)

MPIRE is a distributed, direct volume rendering system that contains multiple interfaces to multiple parallel direct volume rendering engines running on multiple platforms. There are currently two graphical interfaces, a Java applet and a custom AVS (Application Visualization System) module, that provide the same interactive features. The current rendering engines include implementations of the ray casting and splatting algorithms for the Cray T3D/T3E and single processor SGI workstations. MPIRE was developed under a grant from Cray Research, Inc. and is in the public domain.

The following figure shows the architecture for MPIRE. The interface can be run on any platform and starts the session by connecting to renderd, a daemon which provides access to the MPIRE engines on the desired render host. The daemon starts a rendering engine on the render host and provides port numbers for communication between the interface and rendering engine. Refer to Communications Protocol for more detailed information about the MPIRE communication protocol.

This architecture provides flexibility and allows for future expansion. For example, porting MPIRE to a new computer only requires a new rendering engine and a slight modification to renderd to allow it to start a process on the new computer - no changes to the interface would be required. Also, different implementations of volume rendering algorithms on the T3E and other systems could be controlled by the same interface (and renderd), providing a testbed for comparison of the algorithms.

System Requirements

MPIRE is designed to run the interface on a machine local to the user and the rendering engine on a remote system with communication taking place via sockets and signals. The rendering engines currently available include parallel implementations of the splatting and ray casting algorithms for the Cray T3D system running UNICOS version 8.0.0.0 or higher, and the Cray T3E system running UNICOS/mk 1.3.1 or higher, and a serial implementation of the splatting algorithm for single processor SGI workstations running IRIX 5.3 or higher.

memory
There is a direct correlation between the size of the data set rendered and the RAM required. Depending on your needs, the rendering modules can be compiled for maximum data set size or for maximum image fidelity. The flexibility of the interfaces allows you to use either version, or both.
processors
On parallel systems, the larger the number of PEs over which the rendering module is run, generally the better the performance. The best rendering performance can usually be achieved with a workload-to-PE ratio of one data slice to one PE. Note that each processor must have at least one slice to render.
hard disk storage
The various pieces of MPIRE are distributed as follows. All storage sizes given below are approximate and refer to the binaries and source code respectively.
- Render Host
  - 1.0MB / 0.1MB splatting rendering engine
  - 0.9MB / 0.1MB ray casting rendering engine
  - 0.2MB / 0.1MB rendering library
  - 0.2MB / 0.1MB rendering daemon
  - 32.0MB sample volume data
- Interface Host
  - 0.7MB / 0.1MB AVS module interface
  - 0.1MB / 0.1MB Java applet interface
  - 0.1MB sample control files
software
The AVS module interface requires the data flow visualization package AVS. The Java applet interface requires a Java-capable WWW browser. Both interfaces provide roughly equivalent control over all rendering parameters.

Installation Instructions

For detailed instructions on the installation procedure for MPIRE, please refer to the README files provided in the MPIRE software distribution. You will need to install one or more of the MPIRE graphical user interfaces, the MPIRE rendering daemon renderd, the MPIRE rendering library, and one or more of the MPIRE rendering engines.

How This Manual is Put Together

The MPIRE Users Manual (this text) provides you with a concise introduction and general reference to the layout and use of MPIRE's many features. It is designed for users who are already familiar with the basic concepts involved in using AVS and/or Java applets. In addition, basic knowledge of medical data and volume rendering is helpful.

This manual is divided into five sections.

About MPIRE & This Manual is an introduction to what MPIRE can do for you, what computer equipment you need to use this software, and the short part about the organization of the documentation that you are reading now.
Overview of the MPIRE AVS Interface provides you with the basics of using the AVS module interface to render your first image.
Overview of the MPIRE Java Interface provides you with the basics of using the Java applet interface to render your first image.
MPIRE Interface Parameters Reference contains an in-depth examination of all of the MPIRE widgets available through either the AVS or Java interfaces.
Appendix includes information about the format of parameter and materials files, a glossary, and the details of the MPIRE communications protocol.

Conventions

This manual is written with conventions which are designed to clarify, and to draw your attention to certain kinds of information. This is done to help you quickly find documentation specific to a given subject, and to help you better understand many of the concepts involved in using MPIRE.

The names of menus, commands, panels, directories, fields, files, and buttons are bolded. They are spelled just as they appear on the screen.
The names of books, manuals, or other types of documentation, including specific sections of this manual, are italicized.
Pictures of various components of MPIRE are included as they appear on screen, to scale. These pictures are included to help clarify the features described in the surrounding text.
The contents of data files and other plain ASCII text are printed using a constant width font, so the printed version closely resembles what you would see on a computer screen.