Abstract: Illustrative volume visualization frequently employs non-photorealistic rendering techniques to enhance important features or to suppress unwanted details. However, it is difficult to integrate multiple non-photorealistic rendering approaches into a single framework due to great differences in the individual methods and their parameters. In this paper, we present the concept of style transfer functions. Our approach enables flexible data-driven illumination which goes beyond using the transfer function to just assign colors and opacities. An image-based lighting model uses sphere maps to represent non-photorealistic rendering styles. Style transfer functions allow us to combine a multitude of different shading styles in a single rendering. We extend this concept with a technique for curvature-controlled style contours and an illustrative transparency model. Our implementation of the presented methods allows interactive generation of high-quality volumetric illustrations.

Abstract: We have designed and implemented VMGL, a virtual machine monitor (VMM) independent, graphics processing unit (GPU) independent, and cross-platform OpenGL virtualization solution. VMGL allows applications executing within virtual machines (VMs) to leverage hardware rendering acceleration, thus solving a problem that has limited virtualization of a growing class of graphics-intensive applications. VMGL also provides applications running within VMs with suspend and resume capabilities across GPUs from different vendors. Our experimental results from a number of graphics-intensive applications show that VMGL provides excellent rendering performance, within 14% or better of that obtained with native graphics hardware acceleration. Further, VMGL's performance is two orders of magnitude better than that of software rendering, the commonly available alternative today for graphics-intensive applications running in virtualized environments. Our results confirm VMGL's portability across VMware Workstation and Xen (on VT and non-VT hardware), and across Linux (with and without paravirtualization), FreeBSD, and Solaris. Our results also show that the resource demands of VMGL align well with the emerging trend of multi-core processors.

Abstract: Demand in the consumer market for graphics hardware that accelerates rendering of 3D images has resulted in commodity devices capable of astonishing levels of performance. These results were achieved by specifically tailoring the hardware for the target domain. As graphics accelerators become increasingly programmable however, this performance has made them an attractive target for other domains. Specifically, they have motivated the transformation of costly algorithms from a general purpose computational model into a form that executes on said graphics hardware. We investigate the implementation and performance of modular exponentiation using a graphics accelerator, with the view of using it to execute operations required in the RSA public key cryptosystem.

Abstract: Light fields can be used to represent an object's appearance with a high degree of realism. However, unlike their geometric counterparts, these image-based representations lack user control for manipulating them. We present a system that allows a user to interactively manipulate, composite and render multiple light fields. LightShop is a modular system consisting of three parts: 1) a set of functions that allow a user to model a scene containing multiple light fields, 2) a ray-shading language that describes how an image should be constructed from a set of light fields, and 3) a real-time light field rendering system in OpenGL that can plug into existing 3D engines as a GLSL shader.We show applications in digital photography and we demonstrate how to integrate light fields into a modern space-flight game using LightShop.

Abstract: In general, one aspect of the subject matter described in this specification can be embodied in a method that includes rendering Hyper Text Markup Language (HTML) content, in an HTML rendering engine, to primitives of a vector graphics rendering engine; rendering the primitives, in the vector graphics rendering engine, to provide a user interface; receiving an input event via the user interface; determining, in the HTML rendering engine, a change in appearance for the user interface based on the input event; and updating at least one of the primitives for rendering by the vector graphics rendering engine in accordance with the change in appearance to update the user interface.

Abstract: A system and method of delivering a multi-media message to a recipient is disclosed. The multi-media message is created by a sender and contains a talking entity for delivering a sender message. A determination is made as to whether the recipient device has rendering software for delivering a video portion of the multi-media message. If the recipient device does not have the rendering software, the multi-media message is streamed from a server such that a generic rendering software device will deliver the multi-media message.

Abstract: Methods, systems, graphical computer interfaces, and computer readable media are disclosed to enable optimizing video frame rendering characteristics for an application The method includes rendering a video frame and capturing push buffer settings representing the rendering of the video frame The method also includes modifying an aspect of the push buffer settings while bypassing the application, and re-rendering the frame with the modified aspect The method further enables comparing the rendering with the re-rendering, and presenting comparison results Graphical user interfaces are provided to enable the functionality, without having to modify code of the application to appreciate what potential changes to the application can present in terms of performance rendering and processing efficiencies

Abstract: We present a new post processing method of simulating depth of field based on accurate calculations of circles of confusion. Compared to previous work, our method derives actual scene depth information directly from the existing depth buffer, requires no specialized rendering passes, and allows easy integration into existing rendering applications. Our implementation uses an adaptive, two-pass filter, producing a high quality depth of field effect that can be executed entirely on the GPU, taking advantage of the parallelism of modern graphics cards and permitting real time performance when applied to large numbers of pixels.

Abstract: The present invention relates to a method for the creation of large hierarchical computer graphics datasets. The method comprises combination (401) of one or more primitive computer graphics data objects (400) into larger data objects, and simplifying each of the said combined data objects (402). The simplified objects are then reused (405) in further combination steps in order to increasingly create higher order objects. The created hierarchical computer graphics data set is inherently optimized for fast rendering, and a method of rendering such data is also described.

Abstract: In contrast to sort-first, sort-last parallel rendering has the distinct advantage that the task division for parallel geometry processing and rasterization is simple, and can easily be incorporated into most visualization systems. However, the efficient final depth-compositing for polygonal data, or alpha-blending for volume data of partial rendering results is the key to achieve scalability in sort-last parallel rendering. In this paper, we demonstrate the efficiency as well as flexibility of the direct send sort-last compositing algorithm, and compare it to existing approaches, both in a theoretical analysis and in an experimental setting.

Abstract: The currently observed exponentially increasing size of 3D models prohibits rendering them using brute force methods. Researchers have proposed various output-sensitive rendering algorithms to overcome this challenge. This article provides an overview of this technology.

Abstract: Digitally rendered radiographs (DRR) are a vital part of various medical image processing applications such as 2D/3D registration for patient pose determination in image-guided radiotherapy procedures. This paper presents a technique to accelerate DRR creation by using conventional graphics hardware for the rendering process. DRR computation itself is done by an efficient volume rendering method named wobbled splatting. For programming the graphics hardware, NVIDIAs C for Graphics (Cg) is used. The description of an algorithm used for rendering DRRs on the graphics hardware is presented, together with a benchmark comparing this technique to a CPU-based wobbled splatting program. Results show a reduction of rendering time by about 70%-90% depending on the amount of data. For instance, rendering a volume of 2x10{sup 6} voxels is feasible at an update rate of 38 Hz compared to 6 Hz on a common Intel-based PC using the graphics processing unit (GPU) of a conventional graphics adapter. In addition, wobbled splatting using graphics hardware for DRR computation provides higher resolution DRRs with comparable image quality due to special processing characteristics of the GPU. We conclude that DRR generation on common graphics hardware using the freely available Cg environment is a major step toward 2D/3D registrationmore » in clinical routine.« less

Abstract: Commodity graphics hardware has seen incredible growth in terms of performance, programmability, and arithmetic precision. Even though these trends have been primarily driven by the entertainment industry, the price-to-performance ratio of graphics processors (GPUs) has attracted the attention of many within the high-performance computing community. While the performance of the GPU is well suited for computational science, the programming interface, and several hardware limitations, have prevented their wide adoption. In this paper we present Scout, a data-parallel programming language for graphics processors that hides the nuances of both the underlying hardware and supporting graphics software layers. In addition to general-purpose programming constructs, the language provides extensions for scientific visualization operations that support the exploration of existing or computed data sets.

Abstract: A method and an apparatus for notifying a display driver to update a display with a graphics frame including multiple graphics data rendered separately by multiple graphics processing units (GPUs) substantially concurrently are described. Graphics commands may be received to dispatch to each GPU for rendering corresponding graphics data. The display driver may be notified when each graphics data has been completely rendered respectively by the corresponding GPU.

Abstract: Since its invention 20 years ago, irradiance caching has been successfully used to accelerate global illumination computation in the Radiance lighting simulation system. Its widespread use had to wait until computers became fast enough to consider global illumination in production rendering. Since then, its use is ubiquitous. Virtually all commercial and open-source rendering software base the global illumination computation upon irradiance caching. Although elegant and powerful, the algorithm often fails to produce artifact-free images. Unfortunately, practical information on implementing the algorithm is scarce.The objective of the class is twofold. The first and main objective is to expose the irradiance caching algorithm along with all the details and tricks upon which the success of its practical implementation is dependent. Various image artifacts that the basic algorithm can produce will be shown along with a recipe to suppress them. We will also put strong emphasis on practical aspects of irradiance caching integration in production environments and discuss the particularities used in two big production houses, namely PDI/DreamWorks and Pixar.The second objective is to acquaint the audience with the recent research results that increase the speed and extend the functionality of basic irradiance caching. Those include: exploiting temporal coherence to suppress temporal flickering; extending the caching mechanism to rendering glossy surfaces; accelerating the algorithm by porting it to the GPU. Advantages and disadvantages of those methods will be discussed.

Abstract: There is provided a graphics processing system that includes a main processing unit and a graphics processing unit (GPU) The main processing unit puts rendering commands generated using a graphics library in the queue of a command buffer in a main memory In this process, the library function offered by the graphics library is converted into the rendering commands, without any rendering attributes retained in the library The GPU reads and executes the rendering commands stacked in the command buffer, and generates rendering data in a frame buffer

Abstract: Scientists, engineers, and artists regularly use illustrations in design, training, and education to display conceptual information, describe problems, and solve those problems. Researchers have developed many advanced rendering techniques on desktop platforms to facilitate illustration generation, but adapting these techniques to mobile platforms has not been easy. We discuss how advanced illustrative rendering techniques, such as interactive cutaway views, ghosted views, silhouettes, and selective rendering, have been adapted to mobile devices. We also present MobileVis, our interactive, illustrative 3D graphics and text rendering system that lets users explore 3D models' interior structures, display parts annotations, and visualize instructions, such as assembly and disassembly procedures for mechanical models

Abstract: This paper presents a new shading model for real-time rendering of plant leaves that reproduces all important attributes of a leaf and allows for a large number of leaves to be shaded. In particular, we use a physically based model for accurate subsurface scattering on the translucent side of directly lit leaves. For real-time rendering of this model, we formulate it as an image convolution process and express the result in an efficient directional basis that is fast to evaluate. We also propose a data acquisition method for leaves that uses off-the-shelf devices.

Abstract: Visually realistic Augmented Reality (AR) entails addressing several difficult problems. The most difficult problem is that of rendering the virtual objects with illumination which is consistent with the illumination of the real scene. The paper describes a complete AR rendering system centered around the use of High Dynamic Range environment maps for representing the real scene illumination. The main contribution lies in a novel, physically-based approach to rendering shadows cast by virtual objects without changing the shadows already present in the images of the real scene. The proposed approach effectively involves real-time estimation of the diffuse albedos of the real scene, and essentially relighting these areas to take virtual shadows into account. Another contribution lies in the fact that the proposed approach is designed to run on graphics hardware and is scalable in the sense that it offers a simple way to balance performance with visual quality.

Abstract: A multi-mode parallel 3-D graphics system having multiple graphics processing pipelines with multiple GPUs supporting a parallel graphics rendering process having time, frame and object division modes of operation, wherein each GPU comprises video memory, a geometry processing subsystem and a pixel processing subsystem, and wherein 3D scene profiling is performed in real-time, and the parallelization state/modes of the system are dynamically controlled to meet graphics application requirements. The multiple modes of parallel graphics rendering use real-time graphics application profiling, and dynamic control over time-division, frame-division, and object-division modes of parallel operation, within the same parallel graphics platform, which can be realized on PC-based computing system architectures.

Abstract: Non-photorealistic rendering has placed much emphasis on developing algorithms that determine the appearance of renditions. To successfully deploy NPR rendering systems using these algorithms, however, one has to consider how artists, illustrators, or lay people can influence the created renditions. Many systems require a cyclical process of parameter tweaking, rendering, and validation before one is satisfied with the final rendition. We present an interactive NPR canvas in which a user can construct a rendition with pre-rendered primitives and modify these primitives using tools that provide spatially explicit computational assistance. We call this approach modeling with rendering primitives. Our technique has the advantage of algorithmic support for creating NPR renditions but requires neither global parameter adjustments and re-rendering cycles nor attribute changes on individually selected primitives. We demonstrate the applicability of this interaction technique for the creation of painterly rendering, pointillism, and decorative mosaics.

Abstract: A computer network-based 3D rendering system. A client computer is coupled to a server over a computer network (e.g., Internet). A user uses a front-end interface to manipulate lower resolution 3D objects at a client computer, sends the parameters of the 3D objects to the server, which generates a higher resolution 3D model. The server then generates a high resolution 2D image (e.g., JPEG), and sends it to the client computer for display. The server may include a video card for generating high quality 2D images. The 3D rendering system allows the client computer to display a high quality image regardless of the capabilities of the client computer. Further, use of the video card at the server allows high quality 2D images to have a better resolution than those available in video games, but at a higher speed than a conventional 3D rendering software that runs on CPU, for example.

Abstract: The present invention provides a virtual machine system and a method for sharing a graphics card amongst virtual machines. A VMM of the virtual machine system is provided with a resource-converting module, which converts data exchanged between a graphics card drive module of a GOS in the foreground and the graphics card based on a resource-converting table, and also intercepts accesses to the real graphics card by a GOS in the background and then responds to its operations on the graphics card. The VMM is further provided with a switching module, which alters a state of a VM based on a command for switching the VM, saves a graphics card state before the VM is switched to the background and restores the stored graphics card state to the graphics card when the VM is switched back to the foreground. Further, the GOSs each comprise a graphics card drive module corresponding to the real graphics card for accessing the real graphics card. The systems and the methods according to the present invention enable the GOSs to access the real graphics card, and also enable switching among a plurality of virtual machines.

Abstract: In this paper, we present two techniques for streaming the output of computer games to an end device for remote gaming in a local area network. We exploit the streaming methods in the European project Games@Large, which aims at creating a networked game platform for home and hotel environments. A local PC based server executes a computer game and streams the graphical and audio output to local devices in the rooms, such that the users can play everywhere in the network. Dependent on the target resolution of the end device, different types of streaming are addressed. For small displays, the graphical output is captured and encoded as a video stream. For high resolution devices, the graphics commands of the game are captured, encoded, and streamed to the client. Since games require significant feedback from the user, special care has to be taken to achieve these constraints for very low delays.

Abstract: iii ACKNOWLEDGMENTS I would like to thank my advisor, Sandip Kundu, for his thoughtful and patient guidance, motivation and support. I would also like to extend my gratitude to the members of my committee, Wayne P. Burleson and Ramgopal Mettu, for their helpful comments and suggestions on all stages of this thesis. I would like to thank Ian Buck and his team at Stanford University whose material I have used, excerpted and referenced in this thesis. The members of the GPGPU (General Purpose Computation using Graphics Hardware) forums, particularly Mike Houston and the Brook GPU community at Stanford University deserve appreciation. The forums were an invaluable source of information and helped clear many concepts. The GPU Gems 2 book was an extremely useful reference. A special thank you to all those, whose support and friendship helped me to stay focused on this project and provided me with constant encouragement. Thanks are also due to my family for their support, love and affection. Logic Simulation is widely used to verify the logical correctness of hardware designs. In this work, we present the implementation of a generic graphics processor based logic simulator and compare it with the corresponding CPU (desktop) based implementation. The motivation for this study arises from the increasing computational power of graphics processors (GPUs). Graphics hardware performance is roughly doubling every six months, and they are outpacing CPUs in raw computational power. GPUs are becoming increasingly programmable and their prices are falling steeply. Most desktops now come built-in with programmable graphics processors. The highly parallel nature of graphics computations enables GPUs to use additional transistors for computation, achieving higher arithmetic intensity with the same transistor count. Applications such as Ray Tracing, Fluid Modeling, Radiology imaging etc have shown speed-ups on graphics processors. This led us to investigate the use of GPUs to run concurrent algorithms for logic simulation. We present the implementation and analyze performance bottlenecks and finally draw conclusions as to whether the GPU can be used for speeding up the logic simulation algorithm.

Abstract: ParaView is a popular open-source general-purpose scientific visualization application One of the many visualization tools available within ParaView is the volume rendering of unstructured meshes Volume rendering is a technique that renders a mesh as a translucent solid, thereby allowing the user to see every point in three-dimensional space simultaneously Because volume rendering is computationally intensive, ParaView now employs a unique parallel rendering algorithm to speed the processes The parallel rendering algorithm is very flexible It works equally well for both volumes and surfaces, and can properly render the intersection of a volume and opaque polygonal surfaces The parallel rendering algorithm can also render images for tiled displays In this paper, we explore the implementation of parallel unstructured volume rendering in ParaView

Abstract: The alias-free shadow maps technique is the first shadow map-based algorithm that computes shadows at floating-point accuracy and handles transparent surfaces elegantly. However, its major disadvantage is that it is a specialized software rendering technique, because shadow computations are performed by using irregular sampling point locations. We present a new algorithm that inherits the strengths of alias-free shadow maps and has an efficient hardware-accelerated implementation. With our method, the sampling points are transformed into multiple layers of regular pixel boundaries with a point sprite rendering technique, and the rasterized geometry is modified to include the necessary information for computing accurate shadow terms. We also present novel acceleration techniques and propose a few hardware modifications to enable real-time implementations.

Abstract: A multi-mode parallel graphics rendering and display system supporting real-time graphics rendering and display operations using a graphics hub device. The system includes a CPU memory space, one or more CPUs for executing graphics-based applications, and a multi-mode parallel graphics rendering system (MPGRS) supporting multiple modes of parallel operation including object division, image division, and time division. The MMPGRS includes a plurality of graphic processing pipelines (GPPLs) that support a parallel graphics rendering process employing one or more modes of parallel operation. Each mode of parallel operation includes at least a decomposition stage, a distribution stage and a recomposition stage, and the MMPGRS also includes a decomposition module for supporting the decomposition stage, a distribution module for supporting the distribution stage, a recomposition module for supporting the recomposition stage, and a graphics hub device (GHD) for interconnecting the CPU memory space with the GPPLs, and supporting basic functionalities of the distribution and recomposition modules during the run-time of the graphics-based application. An automatic mode controller automatically controls the mode of parallel operation of the parallel graphics rendering subsystem during the run-time of the graphics-based application.

Abstract: Multi-mode parallel graphics rendering system (MMGRPS) embodied within a host computing system and employing the profiling of scenes in a graphics-based application. The MMPGRS supports multiple modes of parallel operation selected from the group consisting of object division, image division, and time division. A plurality of graphic processing pipelines (GPPLs) support a parallel graphics rendering process that employs one or more of the object division, image division and/or time division modes of parallel operation in order to execute graphic commands and process graphics data, and render pixel-composited images containing graphics for display on a display device during the run-time of the graphics-based application. An automatic mode control module automatically controls the mode of parallel operation of the MMPGRS during the run-time of the graphics-based application.