Abstract: A system for rendering visual images that combines sophisticated anti-aliasing and pixel blending techniques with control pipelining in hardware embodiment. A highly-parallel rendering pipeline performs sophisticated polygon edge interpolation, pixel blending and anti-aliasing rendering operations in hardware. Primitive polygons are transformed to subpixel coordinates and then sliced and diced to create "pixlink" elements mapped to each pixel. An oversized frame buffer memory allows the storage of many pixlinks for each pixel. Z-sorting is avoided through the use of a linked-list data object for each pixlink vector in a pixel stack. Because all image data values for X, Y, Z, R, G, B and pixel coverage A are maintained in the pixlink data object, sophisticated blending operations are possible for anti-aliasing and transparency. Data parallelism in the rendering pipeline overcomes the processor efficiency problem arising from the computation-intensive rendering algorithms used in the system of this invention. Single state machine control is made possible through linked data/control pipelining.

Abstract: A rendering subsystem with enhanced capability for handling both 2D rendering and 3D rendering tasks. Since the 2D rendering tasks may be generated by the operating system (or other user-interfacing software), it is highly desirable not to interfere with rapid performance of 2D rendering, even if substantial 3D rendering tasks have been loaded into the pipeline. To avoid this, the innovative system uses dual independent contexts, and suspends 3D rendering operation during periods of 2D rendering demand. Moreover, a certain percentage of cycles is reserved, as a minimum, to be available for 2D operations if any have been requested. Window ownership identifiers are maintained for each pixel, but these identifiers are only updated when the 3D rendering operations have been suspended. Moreover, the window position (offset) values are only updated during periods when 3D rendering has been suspended.

Abstract: One of the main techniques used by software renderers to produce stunningly realistic images is programmable shading—executing an arbitrarily complex program to compute the color at each pixel. Thus far, programmable shading has only been available on software rendering systems that run on general-purpose computers. Rendering each image can take from minutes to hours.Parallel rendering engines, on the other hand, have steadily increased in generality and in performance. We believe that they are nearing the point where they will be able to perform moderately complex shading at real-time rates. Some of the obstacles to this are imposed by hardware, such as limited amounts of frame-buffer memory and the enormous computational resources that are needed to shade in real time. Other obstacles are imposed by software. For example, users generally are not granted access to the hardware at the level required for programmable shading.This paper first explores the capabilities that are needed to perform programmable shading in real times. We then describe the design issues and algorithms for a prototype shading architecture on PixelFlow, an experimental graphics engine under construction. We demonstrate through examples and simulation that PixelFlow will be able to perform high-quality programmable shading at real-time (30 to 60 Hz) rates. We hope that our experience will be useful to shading implementors on other hardware graphics systems.

Abstract: Maximum projection is a volume rendering technique that, for each pixel, finds the maximum intensity along a projector. For certain important classes of data, this is an approximation to summation rendering which produces superior visualizations.In this paper we will show how maximum projection rendering with additional depth cues can be implemented using simple affine transformations in object space. This technique can be used together with 3D graphics libraries and standard graphics hardware,thus allowing interactive manipulations of the volume data. The algorithm presented in this paper allows for a wide range of tradeoffs between interactivity and image quality.

Abstract: A graphics rendering system allows an application program to make immediate or retained mode calls to render a model, without needing to know how many passes the renderer requires to complete the scene. The application program invokes the rendering subsystem and the rendering subsystem returns a re-traverse flag indicating whether the rendering of the model is complete. If the flag indicates that rendering is not yet complete, the application program again invokes the rendering subsystem. Calls to the rendering subsystem may be placed inside a loop in the application program, which repeats until the re-traverse flag indicates completion. When the re-traverse flag indicates that rendering is not yet complete, the application program repeats the same sequence of calls, thereby effectively re-traversing the model. Application program calls to the rendering system can also specify the renderer to use. In this manner, switching to a different renderer at any time during the building or editing of a model becomes a trivial task for the application program. Also, more than one renderer can be active simultaneously. The current state of rendering for each renderer is stored in a respective "view object" (or objects) which the application program specifies when calling the rendering system. The system is also extensible to support dynamically registered renderers.

Abstract: Splatting is an object-space direct volume rendering algorithm that produces images of high quality, but is computationally expensive like many other volume rendering algorithms. This paper presents a new technique that enhances the speed of splatting without trading off image quality. This new method reduces rendering time by employing a simple indexing mechanism which allows to visit and splat only the voxels of interest. It is shown that this algorithm is suitable for the dynamic situation in which viewing parameters and opacity transfer functions change interactively. We report experimental results on several test data sets of useful size and complexity, and discuss the cost/benefit trade-off of our method.

Abstract: A low level hardware dependent graphics library (binding library) between hardware independent graphics libraries and a graphics hardware unit. The binding library procedures provide a relatively low level interface that couples directly with the graphics hardware unit and only requires a relatively small amount of rewriting to accommodate different graphics hardware units while requiring no change of the hardware independent graphics libraries. The binding library procedures provide a quality meter adjustable between low speed processing high quality image rendering and low quality but faster speed image rendering. The binding library procedures perform batch processing by receiving an array of batch cells, each batch cell comprising a separate primitive. The batch array can be handed off to the binding library procedures at one setting and then processed sequentially. This configuration insures that no instruction cache misses occur during parameterization of the array (e.g., the parameterization routine fits within a standard code cache) and that few data cache misses occur. Also, the binding library procedures allow automatic translation between different texture mapping data formats so that either RGB-alpha format can be used or a format using an index into the color pallet can be used. By providing a low level interface, the present invention provides a system that is readily adaptable to different hardware graphics accelerators without requiring modifications to the graphics libraries.

Abstract: Increasingly, 3D graphics is becoming the rule rather than the exception in applications such as games, CAD/CAM, and video production. Some LSIs provide rendering capabilities, but require an additional CPU to perform essential geometry transformations. Fujitsu's chip set solves that problem using two processors to render 300,000 polygons per second (for flat-shaded triangles with texture)-performance comparable to that of advanced game machines.

Abstract: Volume rendering is a key technique in scientific visualization that lends itself to significant exploitable parallelism. The high computational demands of real-time volume rendering and continued technological advances in the area of VLSl give impetus to the development of special-purpose volume rendering architectures. This paper presents and characterizes three recently developed volume rendering engines which are based on the ray-casting method. A taxonomy of the algorithmic variants of ray-casting and details of each ray-casting architecture are discussed. The paper then compares the machinefeatures and provides an outlook onfuture developments in the area of volume rendering hardware.

Abstract: We describe the operational principles of a scalable hardware accelerator for volume rendering. The basic philosophy is to provide an atomic unit which already provides sophisticated volume graphics at interactive rendering speed. Realtime speed can then be achieved by operating multiple units in parallel. The basic unit consists of just four VLSI chips and the volume memory and thus meets the requirements of a small size and low costs. Nevertheless, it provides arbitrary perspective projections (e.g. for walk-throughs), Phong shading, a freely moveable light source, depth-cueing and interactive, non-binary classification (semi-transparent display) at a frame rate of about 2.5 Hz for 2563 data sets.

Abstract: Normally rendered images are the polished output of rendering software and are. by definition, perfect'. However, as we think about rendering abstractions of the underlying models. rather than photorealistic images. it becomes evident that user involvement is necessary to tune rendered images to his or her satisfaction. In this paper we outline methods to tune rendered images. We concentrate on line-drawings as these are most readily edited to make the modelled objects appear more abstract. Rather than having users edit individual lines, out emphasis lies on studying, what users really want to achieve, and how we can support them more directly to attain these effects. This emphasis is used to guide the design of the user-interface to the system for tuning line-drawings. We present a tool which allows high-level intent-based interaction to generate line-drawings from rendered 3D-models. Included in the system are editing facilities to fine-tune and thereby individualting line-drawings-High-level interaction draws on statistical methods to distribute lines over the rendered image. We show how the interaction can be improved if information about the model is available to the image editor.

Abstract: Interactive Rendering combines the geometrical precision of classical computer graphics with the representational freedom of a paint program. It is more sympathetic to the ways in which designers use images, and overcomes many of the frustrations experienced in rendering from CAD models. The scene is generated in a standard viewing application, but saved as a specially enhanced raster image. The extra information allows the Interactive Renderer to apply brushed-on rendering effects which are sensitive to the perspective of the image. Effects can be applied locally or overall, and may be overlaid, blended and erased to create complex combinations. A huge range of treatments are obtainable, both photorealistic and not.

Abstract: : This paper describes a mechanism for improving rendering rates dynamically during runtime in an interactive three-dimensional graphics application. Well-known techniques such as transforming hierarchical geometry into a flat list and removing redundant graphics primitives are often performed off-line on static databases, or continuously every rendering frame. In addition, these optimizations are usually performed over the whole database. We observe that much of the database remains static for a fixed period of time, while other portions are modified continuously (e.g. the camera position), or are repeatedly modified during some finite interval (e.g. during user interaction). We have implemented a runtime optimization mechanism which is sensitive to repeated, local database changes. This mechanism employs timing strategies which optimize only when the cost of optimization will be amortized over a sufficient number of frames. Using this optimization scheme, we observe a rendering speedup of roughly 2.5 in existing applications. We discuss our initial implementation of this mechanism, the improved timing measurements, the issues and assumptions we made, and future improvements.

Abstract: Binocular digital imaging is a rapidly developing branch of digital imaging. Any such system must have some means that allows each eye to see only the image intended for it. We describe a time-division multiplexing technique that we have developed for Silicon Graphics Inc. (SGITM) workstations. We utilize the `double buffering' hardware feature of the SGITM graphics system for binocular image rendering. Our technique allows for multiple, re-sizable, full-resolution stereoscopic and monoscopic windows to be displayed simultaneously. We describe corresponding software developed to exploit this hardware. This software contains user-controllable options for specifying the most comfortable zero-disparity plane and effective interocular separation. Several perceptual experiments indicate that most viewers perceive 3D comfortably with this system. We also discuss speed and architecture requirements of the graphics and processor hardware to provide flickerless stereoscopic animation and video with our technique.© (1995) COPYRIGHT SPIE--The International Society for Optical Engineering. Downloading of the abstract is permitted for personal use only.

Abstract: The fusion of multimedia and traditional computer graphics has long been predicted but has been slow to happen. The delay is due to many factors, including their dramatically different data type and bandwidth requirements. Digital has designed a pair of related graphics accelerator chips that integrate video rendering primitives with two-dimensional and threedimensional synthetic graphics primitives. The chips perform one-dimensional filtering and scaling on either YUV or RGB source data. One implementation dithers YUV source data down to 256 colors. The other converts YUV to 24-bit RGB, which is then optionally dithered. Both chips leave image decompression to the CPU. The result is significantly faster frame rates at higher video quality, especially for displaying enlarged images. The paper compares the implementation cost of various design alternatives and presents performance comparisons with software image rendering.

Abstract: A method of processing computer graphics information for rendering an image on a display comprising preparing a texture map in which each point is given one of a limited number of codes, each code identifying a parameter set which defines the colour and brightness of that point of the map. Prior to rendering, a conversion calculation is performed to provide a new parameter set for each code which is applicable to a particular polygon. This gives a look-up table used to render into the frame buffer.

Abstract: Global illumination researchers tend to think in terms of mesh density and sampling frequency, and their software reflects this in its user interface. Advanced rendering systems are rife with long command lines and parameters for tuning the sample densities, thresholds and other algorithm-specific variables, and the novice user is quickly lost in a sea of possibilities. This paper details a successful effort of making one such global illumination system usable by people who understand their problems, even if they do not understand the methods needed to solve them, through an assisted oracle approach. A single program is introduced to map a small set of intuitive control variables to the rendering commands and parameter settings needed to produce the desired output in a reasonable time. This new executive program then serves as the basis for a graphical user interface that is both friendly in its appearance and reliable in its performance. Finally, we conclude with some future directions for improving this interface.

Abstract: This paper presents a new approach to rendering arbitrary views of real-world objects of complex shapes, captured by a capturing device. We propose to represent an object by a small set of corresponding 2-D views, and to construct any other view as a combination of these views. We show that this combination can be linear, assuming proximity of the views, and we suggest how the visibility of constructed points can be solved. Our approach entirely eliminates the need for the difficult 3-D model reconstruction. We present results on real objects, indicating that our approach is feasible.

Abstract: In this paper we present a system for investigating molecule data by means of Virtual Reality techniques. This allows new insights into the structure of individual molecules as well as into the interaction between multiple molecules. Scientific Visualization, especially when performed in Virtual Environments, must consider two opposing demands: Maximum image quality at sufficient frame rates. With this in mind we discuss a general scheme for determining the quality of (3D) graphical computer systems. For this scheme, we are focusing on the user’s perception of the system. Therefore, we do not include factors like memory size or processor speed directly, even though they may influence other features which we consider crucial for Graphics System Quality (GSQ), e.g., rendering speed. We identify three components of Graphics System Quality: Data quality, image quality, and interaction quality. We show that our system for immersive investigation of molecule data is unique in its advanced combination of image quality and interaction quality.

Abstract: This paper presents an architecture capable of generating two dimensional images of volume data at video rates. This architecture fits into an image synthesis pipeline and uses only simple arithmetic operations and a look-up table to generate two dimensional images in real time. The shading algorithm is the grey-level gradient algorithm for shading volume data. Hardware simulations of the critical components can process a 256/sup 3/ data set at 20 frames a second using a parallel implementation. Image synthesis from volume data in real time is an important technique in visualization and graphics systems.

Abstract: Interactive volume visualization of unstructured grid data is a much sought after, but as yet elusive, goal in many scientific visualization applications. We present an architecture that ean possibly bring this goal within reach. In this architecture we combine the recently identified method of using texture mapping for volume rendering[5, 2] with anti-aliased voxelization. We show how the proposed architecture can be implemented with simple extensions to existing high-end graphics systems, using the SGI Reality Engine as an example. The architecture has the advantage of providing both direct volume rendering and polygon based rendering at high performance levels on the same hardware platform. We present some simulation results that demonstrate the validity of our arehitecture.

Abstract: Combined rendering of volume data and geometric objects (graphics objects) is important in a number of medical applications. Efficient generation of such rendering is required to support user interactions at a level that are useful in clinical applications. In this study, we describe the manipulation of graphics objects with volume data utilizing a widely used graphics API standard, OpenGL. >

Abstract: Traditional 3D graphics systems, e.g. Denali, with texture mapping capability implement the standard graphics pipeline in a pipelined parallel architecture. The systems are sufficiently powerful and flexible to support efficiently applications such as volume rendering. We discuss how Denali, manufactured by Kubota Graphics Corporation accelerates volume rendering. Volume rendering methods including maximum intensity projection and iso-surface rendering are implemented using Denali's 3D texture mapping capability. The volume rendering realization utilizes a partitioning data allocation scheme instead of a replicating approach to reduce dramatically texture memory requirements. Denali has two major parallel components: Transformation and Rasterization Modules (TRMs) and Frame Buffer Modules (FBMs). The flexible TRMs, containing a general purpose RISC processor, use object parallelism. The FBMs, containing hardware ASICs and pixel memory, use pixel parallelism. The TRMs and FBMs use dynamic and static load balancing schemes respectively to assign a roughly equal amount of computation to each parallel node. >

Abstract: Concepts of stereoscopic vision have been around for more than two thousand years. Despite this long history, its application to the field to architecture and design seems relatively unexplored. Synthesis of two technologies, the stereoscope and the computer, was the focus of the present study. The goal of the research was to determine if computer-generated stereoscopic pairs hold value for architectural design. Using readily available computer technology (Apple Macintosh) the research team modelled and rendered an existing project to verify the degree of correlation between the physical construct, the computer 3D model and resultant correlation between the physical construct, the computer 3D model and resultant rendered stereo-paired representation. The experiments performed in this study have shown that producing stereo-paired images that highly correlate to reality is possible using technology that is readily available in the marketplace. Both the technology required to produce (i.e., personal computer and modelling/rendering software) and view (i.e., modified stereoscope) the images is unimposing. Both devices can easily fit in a studio or a boardroom and together can be utilized effectively to permit designers, clients and end-users to experience proposed spaces and projects. Furthermore, these technologies are familiar (clients and end-users have already experienced them in other applications and settings) and assume a fraction of the cost of more dynamic, immersive virtual reality systems. Working from this base, limitations of the process as well as future applications of computer-generated stereoscopic images are identified.

Abstract: A general framework for fast visualization of multispectral volume data is presented. Dedicated hardware with a non-numeric coprocessor is utilized in the first step of the rendering pipeline to process the volume data and extract voxels according to feature characteristics. This capability is used to select voxels according to automatic classification results or real-time descriptions of regions of interest supplied by the user in an interactive environment. By this step we can in real-time reduce the number of voxels that have to be considered in the rendering and increase the speed of the volume rendering accordingly. The selected voxels are generated in a front-to-back (or back-to-front) order and projected to the view plane where a 3D rendering is accumulated with an adaptation of the shell rendering technique proposed by Udupa and Odhner. The paper includes an overview of the underlying hardware architecture and presents numerical experiments with a software simulator.© (1995) COPYRIGHT SPIE--The International Society for Optical Engineering. Downloading of the abstract is permitted for personal use only.