Abstract: Head-mounted displays with dense pixel arrays used for virtual reality applications require high frame rates and low latency rendering. This forms a challenging use case for any rendering approach. In addition to its ability of generating realistic images, ray tracing offers a number of distinct advantages, but has been held back mainly by its performance. In this paper, we present an approach that significantly improves image generation performance of ray tracing. This is done by combining foveated rendering based on eye tracking with reprojection rendering using previous frames in order to drastically reduce the number of new image samples per frame. To reproject samples a coarse geometry is reconstructed from a G-Buffer. Possible errors introduced by this reprojection as well as parts that are critical to the perception are scheduled for resampling. Additionally, a coarse color buffer is used to provide an initial image, refined smoothly by more samples were needed. Evaluations and user tests show that our method achieves real-time frame rates, while visual differences compared to fully rendered images are hardly perceivable. As a result, we can ray trace non-trivial static scenes for the Oculus DK2 HMD at 1182 × 1464 per eye within the the VSync limits without perceived visual differences.

Abstract: With ever-increasing display resolution for wide field-of-view displays---such as head-mounted displays or 8k projectors---shading has become the major computational cost in rasterization. To reduce computational effort, we propose an algorithm that only shades visible features of the image while cost-effectively interpolating the remaining features without affecting perceived quality. In contrast to previous approaches we do not only simulate acuity falloff but also introduce a sampling scheme that incorporates multiple aspects of the human visual system: acuity, eye motion, contrast (stemming from geometry, material or lighting properties), and brightness adaptation. Our sampling scheme is incorporated into a deferred shading pipeline to shade the image's perceptually relevant fragments while a pull-push algorithm interpolates the radiance for the rest of the image. Our approach does not impose any restrictions on the performed shading. We conduct a number of psycho-visual experiments to validate scene- and task-independence of our approach. The number of fragments that need to be shaded is reduced by 50% to 80%. Our algorithm scales favorably with increasing resolution and field-of-view, rendering it well-suited for head-mounted displays and wide-field-of-view projection.

Abstract: Path tracing is one of several techniques to render photorealistic images by simulating the physics of light propagation within a scene. The roots of path tracing are outside of computer graphics, in the Monte Carlo simulations developed for neutron transport. A great strength of path tracing is that it is conceptually, mathematically, and often-times algorithmically simple and elegant, yet it is very general. Until recently, however, brute-force path tracing techniques were simply too noisy and slow to be practical for movie production rendering. They therefore received little usage outside of academia, except perhaps to generate an occasional reference image to validate the correctness of other faster but less general rendering algorithms. The last ten years have seen a dramatic shift in this balance, and path tracing techniques are now widely used. This shift was partially fueled by steadily increasing computational power and memory, but also by significant improvements in sampling, rendering, and denoising techniques. In this survey, we provide an overview of path tracing and highlight important milestones in its development that have led to it becoming the preferred movie rendering technique today.

Abstract: Photo realistic effects in a complex animation scene can be achieved using the process of rendering. Rendering is more time and cost consuming process as it involves pixel based light and camera effects that will be converted into actual photo realistic scenes. To upgrade quality of animated scenes up to the mark, rendering requires high end computational set up. Processing cost of rendering goes on increasing as the quality and efficiency required increases. Required computational set up includes high end computational resources which are not affordable to a small scale animator. So with the present work we here are going to provide a solution to this problem so that small scale animator also can have effective rendering at a low cost and better efficiency. We are going to provide a Blender based low cost distributed, efficient rendering set up.

Abstract: Maps are widely used to visualize geo-information so that map users can develop related understandings about the real world. Such a process for communicating information is largely dependent on the rendering of map elements using different symbols points and linear and area symbols. To meet the demand of more dynamic and comprehensive visualization in map rendering, it is essential to improve the rendering efficiency. This paper focuses on these research topics, especially the difficulty in constructing and drawing linear map symbols. By employing shader language, a function-based linear symbol building and rendering method is presented in this paper. The basic idea of this function-based method is to build a map-rendering solution that employs graphic processing unit GPU acceleration technology to improve the rendering efficiency. A ‘function’ is used to represent the algorithm that draws certain simple or complex linear map symbols. This function reflects the structure of a linear map symbol describing the symbol construction information and also the rendering process of the symbolized linear map elements handled on a per-pixel basis by the shader program. Based on the Open Geospatial Consortium OGC, Styled Layer Descriptor SLD specifications, four basic line types i.e., solid lines, dashed lines, gradient color lines, and transition lines are implemented in the proposed method, and the implementation of line markers, line joins and line caps is also discussed. Three experiments are conducted to demonstrate improvements in map rendering. The results show that a variety of linear map symbols can be constructed in a uniform way, which suggests that the proposed method addresses the difficulty in drawing linear map symbols. With this method, the efficiency of rendering linear map elements is substantially improved compared to using the graphics device interface plus GDI+ and anti-grain geometry AGG methods; it also provides an applicable approach for developing map rendering systems. Using this function-based concept, the complexity of building linear map symbols and drawing linear map elements can be decreased.

Abstract: Previous approaches to rendering large point clouds on immersive displays have generally created a trade-off between interactivity and quality. While these approaches have been quite successful for desktop environments when interaction is limited, virtual reality systems are continuously interactive, which forces users to suffer through either low frame rates or low image quality. This paper presents a novel approach to this problem through a progressive feedback-driven rendering algorithm. This algorithm uses reprojections of past views to accelerate the reconstruction of the current view. The presented method is tested against previous methods, showing improvements in both rendering quality and interactivity.

Abstract: In this paper, we explore the Raspberry pi 2 B+ (RPI) graphics in terms of electrical power and energy. We use a novel method to correlate graphics processing, CPU load and electrical power consumption and total energy. By using different benchmarks both with and without the GPU rendering and a Power Gauge, the power consumption difference between GPU rendering and software rendering can be measured. Our results are showing that the number of frames rendered per second increases dramatically when hardware rendering is used, as does electrical power. Interestingly, because the hardware rendering takes less time, we have found that the total energy consumed per rendered frame can be lower despite the electrical power during hardware rendering being higher.

Abstract: This work is a proof of concept, where we explore the possibility of rendering natural scenes in a head mounted display device without meshing Real-time, stereoscopic full-HD rendering is obtained for a 14 million points scene, using a low end graphics card for virtual reality (Nvidia GeForce GTX 970), within an Oculus Rift DK2 High quality is achieved by using splatting, while real-time rendering is made possible by the means of a good data structure and a complexity reduction of the scene with techniques such as Optimized Sub-Sampling, Level of Detail and Frustum Culling Altogether, those techniques lead to a good virtual reality immersion Choices and limitations of the proposed techniques are discussed

Abstract: We present Spire, a shading language and compiler framework that facilitates rapid exploration of shader optimization choices (such as frequency reduction and algorithmic approximation) afforded by modern real-time graphics engines. Our design combines ideas from rate-based shader programming with new language features that expand the scope of shader execution beyond traditional GPU hardware pipelines, and enable a diverse set of shader optimizations to be described by a single mechanism: overloading shader terms at various spatio-temporal computation rates provided by the pipeline. In contrast to prior work, neither the shading language's design, nor our compiler framework's implementation, is specific to the capabilities of any one rendering pipeline, thus Spire establishes architectural separation between the shading system and the implementation of modern rendering engines (allowing different rendering pipelines to utilize its services). We demonstrate use of Spire to author complex shaders that are portable across different rendering pipelines and to rapidly explore shader optimization decisions that span multiple compute and graphics passes and even offline asset preprocessing. We further demonstrate the utility of Spire by developing a shader level-of-detail library and shader auto-tuning system on top of its abstractions, and demonstrate rapid, automatic re-optimization of shaders for different target hardware platforms.

Abstract: Since the advent of the smartphone, all high-end mobile devices have required graphics acceleration in the form of a GPU. Today, even low-power devices such as smartwatches use GPUs for rendering and composition. However, the computer architecture community has largely ignored these developments when evaluating new architecture proposals.

Abstract: Sort-last parallel rendering can be improved by considering the rendering of multiple images at a time. Most parallel rendering algorithms consider the generation of only a single image. This makes sense when performing interactive rendering where the parameters of each rendering are not known until the previous rendering completes. However, in situ visualization often generates multiple images that do not need to be created sequentially. In this paper we present a simple and effective approach to improving parallel image generation throughput by amortizing the load and overhead among multiple image renders. Additionally, we validate our approach by conducting a performance study exploring the achievable speed-ups in a variety of image-based in situ use cases and rendering workloads. On average, our approach shows a 1.5 to 3.7 fold improvement in performance, and in some cases, shows a 10 fold improvement.

Abstract: Interactive visualizations of large-scale datasets can greatly benefit from parallel rendering on a cluster with hardware accelerated graphics by assigning all rendering client nodes a fair amount of work each. However, interactivity regularly causes unpredictable distribution of workload, especially on large tiled displays. This requires a dynamic approach to adapt scheduling of rendering tasks to clients, while also considering data locality to avoid expensive I/O operations. This article discusses a dynamic parallel rendering load balancing method based on work packages which define rendering tasks. In the presented system, the nodes pull work packages from a centralized queue that employs a locality-aware dynamic affinity model for work package assignment. Our method allows for fully adaptive implicit workload distribution for both sort-first and sort-last parallel rendering.

Abstract: This book focuses on advanced rendering techniques that run on the DirectX and/or OpenGL run-time with any shader language available. It includes articles on the latest and greatest techniques in real-time rendering, including MLAA, adaptive volumetric shadow maps, light propagation volumes, wrinkle animations, and much more. The book emphasizes techniques for handheld programming to reflect the increased importance of graphics on mobile devices. It covers geometry manipulation, effects in image space, shadows, 3D engine design, GPGPU, and graphics-related tools.

Abstract: Efficient occlusion culling in dynamic scenes is a very important topic to the game and real-time graphics community in order to accelerate rendering. We present a novel algorithm inspired by recent advances in depth culling for graphics hardware, but adapted and optimized for SIMD-capable CPUs. Our algorithm has very low memory overhead and is 3x faster than previous work, while culling 98% of all triangles culled by a full resolution depth buffer approach. It supports interleaving occluder rasterization and occlusion queries without penalty, making it easy to use in scene graph traversal or rendering code.

Abstract: We present a framework that supports the development and evaluation of vision algorithms in the context of driver assistance applications and traffic surveillance. This framework allows the creation of highly realistic image sequences featuring traffic scenarios. The sequences are created with a realistic state of the art vehicle physics model; different kinds of environments are featured, thus providing a wide range of testing scenarios. Due to the physically-based rendering technique and variable camera models employed for the image rendering process, we can simulate different sensor setups and provide appropriate and fully accurate ground truth data.

Abstract: We present an off-the-shelf, low-latency Optical See-through Head-Mounted Displays (OST-HMD) for Augmented Reality (AR). Temporally consistent visualization is crucial for realizing immersive AR experiences. This is challenging since it requires both accurate head-tracking and low-latency rendering of AR content. Building a system which meets both constraints usually requires experts on computer vision/graphics and expensive display hardware. This work demonstrates that such high spatio-temporal fidelity is achievable with commodity hardware available today. We build a custom OST-HMD system that consists of a virtual reality HMD, i.e., the Oculus Rift DK2, and half-mirror optics, and adapt the rendering pipeline in order to integrate the OST-HMD calibration framework. An evaluation with a user-perspective camera shows that the system achieves mean temporal error of <1 ms (95% reduction of the latency from naive, no-predictive rendering), and median spatial error <0.3° in the viewing angle with maximum error at most 1.0°.

Abstract: Building designers rely on predictive rendering techniques to design naturally and artificially lit environments. However, despite decades of work on the correctness of global illumination rendering techniques, our ability to accurately predict light levels in buildings-and to do so in a short time frame as part of an iterative design process-remains limited. In this paper, we present a novel approach to parallelizing construction of an irradiance cache over multiple-bounce paths. Relevant points for irradiance calculation based on one or multiple cameras are located by tracing rays through multiple-bounce paths. Irradiance values are then saved to a cache in reverse bounce order so that the irradiance calculation at each bounce samples from previously calculated values. We show by comparison to high-dynamic range photography of a moderately complex space that our method can predict luminance distribution as accurately as Radiance, the most widely validated tool used today for architectural predictive rendering of daylit spaces, and that it is faster by an order of magnitude.

Abstract: Innovations in video decoding and rendering operations in a graphics pipeline, in which at least some of the operations are performed using a graphics processing unit (“GPU”), are described. For example, a video playback tool aggregates texture values for intra-coded blocks of a picture in central processing unit (“CPU”) memory, then transfers the texture values for the intra-coded blocks from the CPU memory to GPU memory. The video playback tool performs operations to decode the encoded data and reconstruct the picture. For a given block (e.g., of a macroblock, coding unit) of the picture, a graphics primitive represents texture values for the given block as a point for processing by the GPU. The video playback tool uses one or more shader routines, executable by the GPU, to transfer texture values to a display buffer. In some cases, the video playback tool also performs decoding operations with the shader routines.

Abstract: The popularity of many-light rendering, which converts complex global illumination computations into a simple sum of the illumination from virtual point lights (VPLs), for predictive rendering has increased in recent years A huge number of VPLs are usually required for predictive rendering at the cost of extensive computational time While previous methods can achieve significant speedup by clustering VPLs, none of these previous methods can estimate the total errors due to clustering This drawback imposes on users tedious trial and error processes to obtain rendered images with reliable accuracy In this paper, we propose an error estimation framework for many-light rendering Our method transforms VPL clustering into stratified sampling combined with confidence intervals, which enables the user to estimate the error due to clustering without the costly computing required to sum the illumination from all the VPLs Our estimation framework is capable of handling arbitrary BRDFs and is accelerated by using visibility caching, both of which make our method more practical The experimental results demonstrate that our method can estimate the error much more accurately than the previous clustering method

Abstract: The invention provides a fractal image generation and rendering method based on a game engine and CPU parallel processing, relates to the technical field of CPU parallel processing in an image game engine, and aims to solve the technical problems in the prior art that image data information division is unreasonable, the rendering performance and the efficiency are low due to limited arranging structures of commands such as parallel processing and synchronous operation, and the performance requirements of real-time rendering cannot be met. In addition, the invention provides a new technical problem which specifically is how to realize highly-efficient and high-quality image rendering by simultaneously using more than two fractal algorithms in parallel. A software rendering generation algorithm is constructed based on fractal characteristics; and the CPU parallel processing technology is utilized to process fractal image geometrical characteristics in real time, a control flow instruction parallel algorithm is utilized to optimize rendering generated pipe lines, rapid generation and rendering of a fractal image model are realized, and a rapid and accurate display effect in a user PC machine is achieved.

Abstract: As browsers expand their functionality, they continuously act as a platform for portable application development within a web page. To bring interactive 3D graphics closer to the web developer, frameworks allowing a declarative scene description in line with the HTML markup exist. However, these approaches utilize client-side rendering and are thus limited in the scene complexity and rendering algorithms they can provide on a given device. We present the extension of the declarative 3D framework XML3D to support server-based rendering. The server back-end enables distributed rendering with an arbitrary hierarchy of cluster nodes. In the back-end, we deploy a custom real-time ray-tracer. To distribute the ray-tracer, we present a load balancing method which exploits frame-to-frame coherence in a real-time context. The load balancer achieves strong scalability without inducing communication overhead during rendering to coordinate the workers.

Abstract: The article presents a way of visualizing point clouds created by 3D scanning in a coal mine. The first part focuses on the choice of individual algorithms for point cloud pre-processing (using the library PCL — Point Cloud Library), namely voxelization, outlier removing and smoothing. Then it is described the main rendering algorithm of the software — the chosen way of point rendering and some more advanced methods including shading and coloring. In the end there are mentioned some optimizations of rendering speed and especially few new methods of providing additional data to the user, especially related to distance measurements.

Abstract: Modern smartphone display system come equipped with powerful GPU's capable of rendering advanced 2D and 3D graphics. These GPU's make up a significant portion of the system power profile due to the high resolution and framerate of smartphone display. These display features are selected during the design phase of a smartphone and correspond to the capabilities of the human visual system (HVS). However, the level of detail observable by the HVS is not static and changes with user-smartphone distance. In this paper we propose Scope, a system which alters the rendering resolution and framerate on a smartphone to scale display rendering workload in response to real time changes in user-smartphone distance. We demonstrate a new method of measuring this distance in real-time which is able to minimize front-facing camera sampling through the use of sensor fusion techniques. The result is that Scope requires a power overhead of only 20mW on average as the front-facing camera need only be sampled 4 times per minute. We demonstrate that Scope is able to reduce smartphone power consumption up to 58% while retaining visual quality in most cases.

Abstract: In rendering, textures are usually consuming more graphics memory than the geometry. This is especially true when rendering regular sampled volume data as the geometry is a single box. In addition, volume rendering suffers from the curse of dimensionality. Every time the resolution doubles, the number of projected pixels is multiplied by four but the amount of data is multiplied by eight. Data compression is thus mandatory even with the increasing amount of memory available on today's GPUs. Existing compression schemes are either lossy or do not allow on-the-fly random access to the volume data while rendering. Both of these properties are, however, important for high quality direct volume rendering. In this paper, we propose a lossless compression and caching strategy that allows random access and decompression on the GPU using a compressed volume object.

Abstract: Processing and visualizing large scale volumetric and geometric datasets is mission critical in an increasing number of applications in academic research as well as in commercial enterprise. Often the datasets are, or can be processed to become, sparse. In this paper, we present VoxLink, a novel approach to render sparse volume data in a memory-efficient manner enabling interactive rendering on common, offthe- shelf graphics hardware. Our approach utilizes current GPU architectures for voxelizing, storing, and visualizing such datasets. It is based on the idea of perpixel linked lists (ppLL), an A-buffer implementation for order-independent transparency rendering. The method supports voxelization and rendering of dense semi-transparent geometry, sparse volume data, and implicit surface representations with a unified data structure. The proposed data structure also enables efficient simulation of global lighting effects such as reflection, refraction, and shadow ray evaluation.

Abstract: 3D graphical functions in cars enjoy growing popularity. For instance, analog instruments of the instrument cluster are replaced by digital 3D displays as shown by Mercedes-Benz in the F125 prototype car. The trend to use 3D applications expands into two directions: towards more safety-relevant applications such as the speedometer and towards third-party applications, e.g., from an app store. In order to save cost, energy, and installation space, all these applications should share a single GPU. GPU sharing brings up the problem of providing real-time guarantees for rendering content of time-sensitive applications like the speedometer. To solve this problem, we present a real-time GPU scheduling framework which provides strong guarantees for critical applications while still giving as much GPU resources to less important applications as possible, thus ensuring a high GPU utilization. Since current GPUs are not preemptible, we use the estimated execution time of each GPU rendering job to make the scheduling decisions. Our evaluations show that our scheduler guarantees given real-time constraints, while achieving a high GPU utilization of 97%. Moreover, scheduling is performed highly efficient in real-time with less than 10 μs latency.

Abstract: This paper aims at rendering interactive visual effects inherent to complex interactions between trees and rain in real-time in order to increase the realism of natural rainy scenes. Such a complex phenomenon involves a great number of physical processes influenced by various interlinked factors and its rendering represents a thorough challenge in Computer Graphics. We approach this problem by introducing an original method to render drops dripping from leaves after interception of raindrops by foliage. Our method introduces a new hydrological model representing interactions between rain and foliage through a phenomenological approach. Our model reduces the complexity of the phenomenon by representing multiple dripping drops with a new fully functional form evaluated per-pixel on-the-fly and providing improved control over density and physical properties. Furthermore, an efficient real-time rendering scheme, taking full advantage of latest GPU hardware capabilities, allows the rendering of a large number of dripping drops even for complex scenes.

Abstract: In this research, we study image composition in the context of computer rendering, investigate why composition is difficult with conventional rendering methods, and propose our solutions. Image composition is a process in which an artist improves a visual image to achieve certain aesthetic goals, and it is a central topic in studies of visual arts. Approaching the compositional quality of hand-made art work with computer rendering is a challenging task; but there is scarcely any in-depth research on this task from an interdisciplinary viewpoint between computer graphics and visual arts. Although recent developments of computer rendering have enabled the synthesis of high quality photographic images, most rendering methods only simulate a photographic process and do not permit straightforward compositional editing in the image space. In order to improve the visual quality of the digitally synthesized images, the knowledge of visual composition needs to be incorporated. This objective not only asks for novel algorithmic inventions, but also involves research in visual perception, painting, photography and other disciplines of visual arts. With examples from historical painting and contemporary photography, we inquire why and how a well-composed image elicits an aesthetic visual response from its viewer. Our analysis based on visual perception shows that the composition of an image serves as a guideline for the viewing process of that image; the composition of an image conveys an artist’s intention of how the depicted scene should be viewed, and directs a viewer’s eyes. A key observation is that for a composition to take effect, a viewer must be allowed to attentively look at the image for a period of time. From this analysis, we outline a few rules for composing light and shade in computer rendering, which serve as guidelines for designing rendering methods that create imagery beyond photorealistic depictions. Our original analysis elucidates the mechanism and function of image composition in the context of rendering, and offers clearly defined directions for algorithmic design. Theories about composition mostly remain in the literature of art critique and art history, while there are hardly any investigations on this topic in a technical context. Our novel analysis is an instructive contribution for enhancing the aesthetic quality of digitally synthesized images. We present two research projects that develop our analysis into rendering programs. We first show an interpolative material model, in which the surface shading is interpolated from input textures with a brightness value. The resultant rendering depicts surface brightness instead of light energy in the depicted scene. We also