Abstract: With fast 3D graphics becoming more and more available even on low end platforms, the focus in hardware-accelerated rendering is beginning to shift towards higher quality rendering and additional functionality instead of simply higher performance implementations based on the traditional graphics pipeline. In this paper we present techniques for realistic shading and lighting using computer graphics hardware. In particular, we discuss multipass methods for high quality local illumination using physically-based reflection models, as well as techniques for the interactive visualization of non-diffuse global illumination solutions. These results are then combined with normal mapping for increasing the visual complexity of rendered images. Although the techniques presented in this paper work at interactive frame rates on contemporary graphics hardware, we also discuss some modifications of the rendering pipeline that help to further improve both performance and quality of the proposed methods. CR Categories: I.3.1 [Computer Graphics]: Hardware Architecture—Graphics processors; I.3.3 [Computer Graphics]: Picture/Image Generation—Bitmap and frame buffer operations; I.3.6 [Computer Graphics]: Methodology and Techniques— Standards I.3.7 [Computer Graphics]: Three-Dimensional Graphics and Realism—Color, Shading, Shadowing and Texture

Abstract: A system and method for seamlessly combining client-only rendering techniques with server-only rendering techniques. The approach uses a composite stream containing three distinct streams. Two of the streams are synchronized and transmit camera definition, video of server-rendered objects, and a time dependent depth map for the server-rendered object. The third stream is available to send geometry from the server to the client, for local rendering if appropriate. The invention can satisfy a number of viewing applications. For example, initially the most relevant geometry can stream to the client for high quality local rendering while the server delivers renderings of less relevant geometry at lower resolutions. After the most relevant geometry has been delivered to the client, the less important geometry can be optionally streamed to the client to increase the fidelity of the entire scene. In the limit, all of the geometry is transferred to the client and the situation corresponds to client-only rendering system where local graphics hardware is used to improve fidelity and reduce bandwidth. Alternatively, if a client does not have local three-dimensional graphics capability then the server can transmit only the video of the server-rendered object and drop the other two streams. In either case, the approach also permits for a progressive improvement in the server-rendered image whenever the scene becomes static. Bandwidth that was previously used to represent changing images is allocated to improving the fidelity of the server-rendered image whenever the scene becomes static.

Abstract: Multi-projector systems are increasingly being used to provide large-scale and high-resolution displays for next-generation interactive 3D graphics applications, including large-scale data visualization, immersive virtual environments, and collaborative design. These systems must include a very high-performance and scalable 3D rendering subsystem in order to generate high-resolution images at real-time frame rates. This paper describes a sort-first parallel rendering system for a scalable display wall system built with a network of PCs, graphics accelerators, and portable projectors. The main challenge is to develop scalable algorithms to partition and assign rendering tasks effectively under the performance and functionality constraints of system area networks, PCs, and commodity 3-D graphics accelerators. We have developed three coarse-grained partitioning algorithms, incorporated them into a working prototype system, and run initial experiments aimed at evaluating algorithmic trade-offs and performance bottlenecks in such a system. Results of our experiments indicate that the coarse-grained characteristics of the sort-first architecture are well suited for constructing a parallel rendering system running on a PC cluster.

Abstract: We present a new technique which enables direct volume rendering based on 3D texture mapping hardware, enabling shading as well as classification of the interpolated data. Our technique supports accurate lighting for a one directional light source, semi-transparent classification, and correct blending. To circumvent the limitations of one general classification, we introduce multiple classification spaces which are very valuable to understand the visualized data, and even mandatory to comprehensively grasp the 3D relationship of different materials present in the volumetric data. Furthermore, we illustrate how multiple classification spaces can be realized using existing graphics hardware.In contrast to previously reported algorithms, our technique is capable of performing all the above mentioned tasks within the graphics pipeline. Therefore, it is very efficient: The three dimensional texture needs to be stored only once and no load is put onto the CPU. Besides using standard OpenGL functionality, we exploit advanced per pixel operations and make use of available OpenGL extensions.

Abstract: A new method for transforming colors into spectra, which we applied to rendering light interference using a standard ray tracer, significantly enhances color-based rendering software and graphics platforms.

Abstract: One of the most important goals of interactive computer graphics is to allow a user to freely walk around a virtual recreation of a real environment that looks as real as the world around us. But hand-modeling such a virtual environment is inherently limited and acquiring the scene model using devices also presents challenges. Interactively rendering such a detailed model is beyond the limits of current graphics hardware, but image-based approaches can significantly improve the status quo. We present an end-to-end system for acquiring highly detailed scans of large real world spaces, consisting of forty to eighty million range and color samples, using a digital camera and laser rangefinder. We explain successful techniques to represent these large data sets as image-based models and present contributions to image-based rendering that allow these models to be rendered in real time on existing graphics hardware without sacrificing the high resolution at which the data sets were acquired.

Abstract: A method, computer system or computer program for intereactively constructing, editing, rendering and manipulating geoscience models including aggregating the functionality of a geometry system and a graphics system, enforcing consistency between the geometry system and the graphics system, and interfacing the geometry system and the graphics system to an application through an integration layer.

Abstract: Apparatus and methods are provided for allowing two graphics controllers to cooperate on a single screen and for modifying the AGP protocol to provide symmetric capabilities for both AGP targets and AGP masters. According to one embodiment of the present invention two graphics controllers may cooperate as one virtual graphics controller. A first graphics controller renders a first subset of pixels of a display to a local memory of the first graphics controller. A second graphics controller renders a second subset of pixels of the display to a local memory of the second graphics controller. Then, after both the first graphics controller and the second graphics controller have completed their respective rendering, merging the content of the local memory of the first graphics controller and the content of the local memory of the second graphics controller.

Abstract: A graphics system enables an automatic choice between existing host rendering programs, existing hardware acceleration methods, and enhanced software acceleration programs for rendering graphic primitives. The graphics system accesses the speed and accuracy characterizations of a hardware accelerator attached to the system. Then, for each graphics primitive available from the enhanced software acceleration programs, the graphics system invention compares the speed and accuracy of the attached hardware accelerator with that of the enhanced software acceleration programs. The graphics system invention then selects which graphics primitives should be rendered by the enhanced software acceleration programs and which graphics primitives should be rendered by the attached hardware accelerator.

Abstract: A method and system for optimizing image quality while operating an interactive graphics application within a data processing system. First, the image rendering speed for each of the rendering modes available within the interactive graphics application are assessed. Upon initial operation of the interactive graphics system, a default rendering mode is activated. During operation of the interactive graphics application, the processing load imposed on the data processing system is monitored and utilized as a user activity metric. The active rendering mode is updated in accordance with the user activity metric, such that the speed of the selected rendering mode varies inversely with the current processing load.

Abstract: Extensions to the texture-mapping support of the abstract graphics hardware pipeline and the OpenGL API are proposed to better support programmable shading, with a unified interface, on a variety of future graphics accelerator architectures. Our main proposals include better support for texture map coordinate generation and an abstract, programmable model for multitexturing. As motivation, we survey several interactive rendering algorithms that target important visual phenomena. With hardware implementation of programmable multitexturing support, implementations of these effects that currently take multiple passes can be rendered in one pass. The generality of our proposed extensions enable efficient implementation of a wide range of other interactive rendering algorithms. The intermediate level of abstraction of our API proposal enables high-level shader metaprogramming toolkits and relatively straightforward implementations, while hiding the details of multitexturing support that are currently fragmenting OpenGL into incompatible dialects. CR Categories: 1.3.1 [Computer Graphics]: Hardware Architecture-Graphics Processors; 1.3.7 [Computer Graphics]: Three-Dimensional Graphics and Realism-Color, shading, shadowing, and texture.

Abstract: Reflections and refractions are important visual effects that have long been considered too costly for interactive applications. Although most contemporary graphics hardware supports reflections off curved surfaces in the form of environment maps, refractions in thick, solid objects cannot be handled with this approach, and the simplifying assumptions of environment maps also produce visible artifacts for reflections. Only recently have researchers developed techniques for the interactive rendering of true reflections and refractions in curved objects. This paper introduces a new, light field based approach to achieving this goal. The method is based on a strict decoupling of geometry and illumination. Hardware support for all stages of the technique is possible through existing extensions of the OpenGL rendering pipeline. In addition, we also discuss storage issues and introduce methods for handling vector-quantized data with graphics hardware.

Abstract: We present a method for efficiently calculating the interference of complex-valued two-dimensional wave patterns that is useful during the generation of synthetic holograms. These patterns are represented as a special kind of images (textures), and the interference is calculated in a computer graphics rendering process. This enables us to leverage hardware support for holographic imaging that is implemented in many state-of-the-art computer workstations. Using this approach, we gain a speedup of a factor of 60–90 compared with conventional calculation methods for interfering wave patterns. Our method is evaluated numerically, examples are shown, and the program code is outlined.

Abstract: Not only photorealistic rendering but non-photorealistic rendering is considered an important research topic in artistic image synthesis. However, little attention has been given to colored pencil drawing. This paper proposes a volume graphics model for colored pencil drawing. The model consists of three sub-models, which describe in a volumetric fashion, the microstructure of paper, pigment distribution on paper, and pigment redistribution, respectively. The model takes advantage of volumetric offset distance accessibility and line integral convolution, and thus is highly controllable with a small number of parameters. A couple of synthesized color pencil drawing data sets are rendered using an existing volume visualizer to empirically prove that the model is descriptive enough to produce realistic images of colored pencil drawing.

Abstract: W h a t is IBR? Image-based rendering (IBR) describes a set of techniques that al low three-dimensional graphical inter'action with objects and scenes whose original specification began as images or photographs. In an IBR pipeline, processing is applied to a set of input photographs creating an intermediate data structure. Later, this data structure is used to create new images of the scene or object. Computer vision provides tools to analyze Images and create models representing shape and surface properties. Computer graphics provides cools to take models and create images. This suggests that image-based rendering can be achieved by combining computer vision and computer graphics techniques. However, is combining the bestknown computer vision and graphics techniques the best we can do? Many computer vision algorithms are just not very robust, and high quality rendering can be compu=tional!y expensive, To better explore the connection between computer graphics and computer vision we ask the fol lowing question. How concise a model should one t ry to create from the image data using computer vision analysis? At one extreme, one could ask for a smooth surface representa t ion annotated w i th shading parameters.A less concise and unified representat ion is s imply a set of depth images, where a depth (z) value is assodar_=cl with each pixel of the original photographs. An even less concise representation associates with each image pixel a color value and a ~y direction. Concise representations are flexible. They permi t s t ra ight forward manipulat ions of models, including modifying shape and material properties. In addition, they al low for measurements and other forms of geometric reasoning (i.e. collision and proximity detect ion) . However, as we demand a more concise representation, the analysis becomes more difficult and the associated computer vision algorithms less reliable. Furthermore, more computation is required to synthesize images from these more concise representations. This leads us to the following questions. Is the transformation of images to the most concise representation possible a requirement for generating new images? Is a threedimensional model the best way of maintaining both the realism and integrity of the source images? Is a model merely a form of compression, for that matter, Iossy compression? Are we willing to tolerate such losses? Image-based rendering approaches threedimensional graphics problems by designing data st ructures that can be robust ly computed from images and can subsequently be used to create high quali ty images at minimal computat ional cost. Thus, imagebased rendering forces us to think about how to best use computer vision and computer graphics concepts and cools in conjunction with each other,

Abstract: This paper describes a real-time shadow generation algorithm for static polygonal environments illuminated by movable point light sources. The algorithm combines a technique of volumetric shadow rendering using stencil buffers with a binary space partitioning (BSP) tree, and includes new easy-to-implement approaches to improvement techniques used in shadow volume algorithms, such as silhouette detection to reduce the number of redundant shadow polygons and the computation of capping polygons to handle cases where the shadow volumes are clipped by the eye-view near clipping plane. Such a hybrid approach solves important limitations on the original shadow rendering algorithm, and also achieves real-time frame rates when using modest size scenes (about 500 shadow polygons), according to measurements performed on personal computers using current graphics hardware. Per-phase timing results from the implementation are provided along the text and compared with those of the standard algorithm.

Abstract: Rendering photorealistic virtual objects from their real images is one of the main research issues in mixed reality systems. We previously proposed the Eigen-Texture method (K. Nishino et al., 1999), a new rendering method for generating virtual images of objects from their real images to deal with the problems posed by past work in image based methods and model based methods. Eigen-Texture method samples appearances of a real object under various illumination and viewing conditions, and compresses them in the 2D coordinate system defined on the 3D model surface. However, we had a serious limitation in our system, due to the alignment problem of the 3D model and color images. We deal with this limitation by solving the alignment problem; we do this by using the method originally designed by P. Viola (1995). The paper describes the method and reports on how we implement it.

Abstract: This paper presents a method for modelling graphics scenes consisting of multiple volumetric objects. A two-level hierarchical representation is employed, which enables the reduction of the overall storage consumption as well as rendering time. With this approach, different objects can be derived from the same volumetric dataset, and 2D images can be trivially integrated into a scene. The paper also describes an efficient algorithm for rendering such scenes on ordinary workstations, and addresses issues concerning memory requirements and disk swapping.

Abstract: Photorealistic rendering methods produce accurate solutions to the rendering equation but are computationally expensive and typically noninteractive. Some researchers have used graphics hardware to obtain photorealistic effects but not at interactive frame rates. We describe a technique to achieve near photorealism of simple indoor scenes at interactive rates using both CPUs and graphics hardware in parallel. This allows the user the ability to interactively move objects and lights in the scene. Our goal is to introduce as many global illumination effects as possible while maintaining a high frame rate. We describe methods to generate soft shadows, approximate one-bounce indirect lighting, and specular reflection and refraction effects.

Abstract: A computer-implemented method and system for performing graphics rendering on demand on a graphics subsystem, with only nominal host system operations being required. High-level specifications of graphics operations in a computer program are captured as I/O hardware programs in a memory. A graphics processor in the subsystem issues instructions in the captured programs to a graphics accelerator, which executes the instructions to perform graphics operations. The graphics accelerator has a status indicator containing status information relating to hardware events incident to the graphics operations. Under the control of instructions in the captured program, the graphics processor monitors the status indicator, and either issues, or delays issuing, the instructions in the captured programs, depending upon the status information in the indicator.

Abstract: We present a new technique which enables direct volume rendering based on 3D texture mapping hardware, enabling shading as well as classification of the interpolated data. Our technique supports accurate lighting for a one directional light source, semi-transparent classification, and correct blending. To circumvent the limitations of one general classification, we introduce multiple classification spaces which are very valuable to understand the visualized data, and even mandatory to comprehensively grasp the 3D relationship of different materials present in the volumetric data. Furthermore, we illustrate how multiple classification spaces can be realized using existing graphics hardware. In contrast to previously reported algorithms, our technique is capable of performing all the above mentioned tasks within the graphics pipeline. Therefore, it is very efficient: The three dimensional texture needs to be stored only once and no load is put onto the CPU. Besides using standard OpenGL functionality, we exploit advanced per pixel operations and make use of available OpenGL extensions.

Abstract: 3D graphics performance is increasing faster than any other computing application. Almost all PC systems now include 3D graphics accelerators for games, CAD, or visualization applications. Many of the microarchitectural techniques that have been used to enhance the performance of microprocessors can be applied to graphics systems as well. We present an architecture for an out-of-order, superscalar rasterizer for 3D graphics. This allows the concurrent execution of multiple graphics primitives while maintaining exact sequential semantics. Experimental results show 1.5-3.6X speedups on real applications using a simple model, similar to the results from many integer benchmarks on superscalar processors. Enhanced techniques specific to 3D graphics for decomposing large triangles and breaking false dependence chains increase performance to more than 10x a sequential system.

Abstract: A computer-implemented method and system for performing graphics rendering on demand on a graphics subsystem, with only nominal host system operations being required. An application program requiring graphics to be rendered is coded to bound a sequence of calls to basic rendering functions, defining a desired image to be rendered, between begin-program and end-program identifiers. When the application program is executed on a host operating system, a begin-program identifier invokes a function in a graphics device driver in the host system. The function captures the calls to the rendering functions within the application program in a memory as hardware instructions to the graphics subsystem. When the function encounters an end-program identifier, it registers the captured hardware instructions with the host system as an executable program. Subsequently, the application may render the image upon demand by calling the registered executable program, which will execute from the memory on the graphics subsystem, with only nomimal host processor operations being required. Thus, host processor operations and memory normally required for performing graphics rendering are conserved.

Abstract: We have been developing a system named "mutual tele-existence" which allows for face-to-face communication between remote users (Tachi et al., 1996). Although image-based rendering (IBR) is suitable for rendering human figures with a complex geometry, conventional IBR techniques cannot readily be applied to our system. Because most IBR techniques include time-consuming processes, they cannot capture the source images and simultaneously render the destination images. In this paper, we propose a novel method focusing on real-time rendering. Moreover, we introduce equivalent depth of field to measure the fidelity of the synthesized image. If the object is in this range, accurate rendering is guaranteed. Then, we introduce a prototype machine that has 12 synchronized cameras on the linear actuator. Finally, we present some experimental results of our prototype machine.

Abstract: High-performance 3D graphics accelerators traditionally require multiple chips on multiple boards. In contrast, Neon-a single chip-performs like a multichip design, accelerating openGL 3D rendering and X11 and windows/NT 2D rendering.

Abstract: In this paper we introduce the notion of a parallel temporal depth buffer (or t-buffer) to speed up the rendering process for ray-traced animations. The t-buffer is a conceptually simple data structure which stores knowledge about coherent pixel values across the duration of an animation. Through the use of this information, we can potentially avoid recomputing a significant number of redundant pixel values and thus substantially reduce overall computing time. Although the t-buffer is general enough to be used with a variety of rendering methods, the algorithm employed in this work targets ray-traced animations and therefore readily lends itself to parallelization. A clustered (or distributed) computing environment is an efficient and effective candidate to handle the parallel computation due to its relatively low cost and the high computation to communication ratio inherent in the processing. The results from this method show substantial reductions in computation and overall rendering time with relatively low overhead.

Abstract: We discuss hardware extensions to 3D-texturing units, which are very small but nevertheless remove some substantial performance limits typically found when using a 3D-texturing unit for volume rendering. The underlying algorithm uses only a slight mod$cation of existing method, which limits negative impacts on application software. In particular, the method speeds up the compositing operation, improves texture cache eflciency and allows for early ray termination and empty space skipping. Early ray termination can not be used in the traditional approach. Simulations show that, depending on data set properties, the performance of readily available, low-cost PC graphics accelerators is already suflcient for real-time volume visualization. Thus, in terms ofperformance, the TRIANGLECASTER-extensions can make dedicated volume rendering accelerators unnecessary. CCS

Abstract: A coiled bimetal element for rotationally moving a choke valve of an electrically controlled automatic choke is directly heated through an electric current from a battery, and the current flowing through the bimetal is adjusted depending upon the atmospheric temperature and the engine temperature. Further, the current is reduced to a small amount after the choke valve is fully open.

Abstract: This paper presents a method to generate dynamic shading of image-based objects without geometric models. Since conventional rendering techniques cannot be used to render the shading of this type of objects, image processing operation, such as interpolation or combination of image data, is performed. However, the variation of the shading of objects is not linear. Therefore, complicated processing is required to generate the desired shading, and they may not be compatible with real-time systems. Then, to perform the variation of the shading of image-based objects in a real-time system, we adopted a very simple method. From a set of image-based data with several different light conditions we select the image-based data with the light condition that is the closest to that of the rendering time, and use it to reconstruct the image. However, as it is necessary to save a large number of image data in this method, the volume of data is huge. Then we developed a method to reduce the data volume while maintaining real-time rendering. In this paper, we present not only our method, but also its application in the real-time system CyberMirage.