We present a method that takes a raster image as input and produces a painting-like image composed of strokes rather than pixels. Unlike previous automatic painting methods, we attempt to use very few brush-strokes. This is accomplished by first segmenting the image into features, finding the medial axes points of these features, converting the medial axes points into ordered lists of image tokens, and finally rendering these lists as brush strokes. Our process creates images reminiscent of modern realist painters who often want an abstract or sketchy quality in their work. CR Categories: I.3.7 [Computing Methodologies ]: Computer Graphics-2D Graphics

Surface light fields can be used to render the complex reflectance properties of a physical object. One limitation is that they can only represent the fixed lighting conditions of the environment where the model was captured. If a specific lighting condition is desired, then there are two options: either use a combination of physical lights as an approximation, or capture a full 6D surface reflectance field and only use the portion that corresponds to the desired lighting. In this paper we present a method for capturing a surface light field using the virtual illumination from an environment map. We use a simple setup consisting of a projector, a camera, a pan-tilt unit, and tracking fiducials to recreate the desired lighting environment. To decrease noise and improve the quality of the capture under low- and highdynamic range environment maps, we use an extended version of the multiplexed illumination algorithm. We show results from objects captured under different lighting environments.

Photon mapping places an enormous burden on the memory hierarchy. Rendering a 512 x 512 image of a simple scene can require more than 196 Gbytes of raw bandwidth to the photon map data structure. This bandwidth is a major obstacle to real-time photon mapping. This paper investigates two approaches for reducing the required bandwidth: 1) reordering the kNN searches and 2) cache conscious data structures. Using a Hilbert curve reordering, we demonstrate an experimental lower bound of 15 Mbytes of bandwidth for the same scene. Unfortunately, this improvement of four orders of magnitude requires a prohibitive amount of intermediate storage. We introduce two novel cost-effective algorithms that reduce the bandwidth by one order of magnitude. Scenes of different complexities are shown to exhibit similar reductions in bandwidth. We explain why the choice of data structure does not achieve similar reductions. We also examine the interaction of query reordering with two photon map acceleration techniques, importance sampling, and the irradiance cache. Query reordering exploits the additional coherence that arises from the use of importance sampling in scenes with glossy surfaces. Irradiance caching also benefits from query reordering, even when complex surface geometry reduces the effectiveness of the irradiance cache.

The rendering of photorealistic surface appearance is one of the main challenges facing modern computer graphics. Image-based approaches have become increasingly important because they can capture the appearance of a wide variety of physical surfaces with complex reflectance behavior. In this dissertation, I focus on Surface Light Fields, an image-based representation of view-dependent and spatially-varying appearance. Constructing a Surface Light Field can be a time-consuming and tedious process. The data sizes are quite large, often requiring multiple gigabytes to represent complex reflectance properties. The result can only be viewed after a lengthy post-process is complete, so it can be difficult to determine when the light field is sufficiently sampled. Often, uncertainty about the sampling density leads users to capture many more images than necessary in order to guarantee adequate coverage. To address these problems, I present several approaches to simplify the capture of Surface Light Fields. The first is a "human-in-the-loop" interactive feedback system based on the Online SVD. As each image is captured, it is incorporated into the representation in a streaming fashion and displayed to the user. In this way, the user receives direct feedback about the capture process, and can use this feedback to improve the sampling. To avoid the problems of discretization and resampling, I used Incremental Weighted Least Squares, a subset of Radial Basis Function which allows for incremental local construction and fast rendering on graphics hardware. Lastly, I address the limitation of fixed lighting by describing a system that captures the Surface Light Field of an object under synthetic lighting.

Astronomy began as a visual science, first through careful observations of the sky using either an eyepiece or the naked eye, then on to the preservation of those images with photographic media and finally the digital encoding of that information via CCDs. This last step has enabled astronomy to move into a fully automated era -- where data is recorded, analyzed and interpreted often without any direct visual inspection. Sky in Google Earth completes that circle by providing an intuitive visual interface to some of the largest astronomical imaging surveys covering the full sky. By streaming imagery, catalogs, time domain data, and ancillary information directly to a user, Sky can provide the general public as well as professional and amateur astronomers alike with a wealth of information for use in education and research. We provide here a brief introduction to Sky in Google Earth, focusing on its extensible environment, how it may be integrated into the research process and how it can bring astronomical research to a broader community. With an open interface available on Linux, Mac OS X and Windows, applications developed within Sky are accessible not just within the Google framework but through any visual browser that supports the Keyhole Markup Language. We present Sky as the embodiment of a virtual telescope.

An Image-Based Rendering (IBR) approach to appearance modelling enables the capture of a wide variety of real physical surfaces with complex reflectance behaviour. The challenges with this approach are handling the large amount of data, rendering the data efficiently, and previewing the model as it is being constructed. In this paper, we introduce the Incremental Weighted Least Squares approach to the representation and rendering of spatially and directionally varying illumination. Each surface patch consists of a set of Weighted Least Squares (WLS) node centers, which are low-degree polynomial representations of the anisotropic exitant radiance. During rendering, the representations are combined in a non-linear fashion to generate a full reconstruction of the exitant radiance. The rendering algorithm is fast, efficient, and implemented entirely on the GPU. The construction algorithm is incremental, which means that images are processed as they arrive instead of in the traditional batch fashion. This human-in-the-loop process enables the user to preview the model as it is being constructed and to adapt to over-sampling and under-sampling of the surface appearance.

In a visual world, the ability to sketch is an important asset for communicating complex ideas. However, sketching is a frustrating task for many people, and most never progress beyond a rudimentary skill level. In this paper we present SKIT, a computer-assisted sketch instruction tool. SKIT attempts to teach beginning students one of the important skills of sketching, the ability to perceive effectively. It is based on traditional art instruction techniques, which break the complex task of drawing into smaller tasks. These sub-tasks are combined into a final drawing, which can be then rendered using several different NPR styles. We also present preliminary results from people who have used SKIT.

1 Abstract This document is intended to provide a brief background on Principal Component Analysis (PCA), Singular

In this paper we introduce a simple procedure to calibrate a surface light field capture system. This system was developed to capture the illumination from a virtual environment map [2]. However, the system has the drawback of a complex calibration procedure that is limited to planar screens. We propose a simple calibration procedure using a reflective calibration object that is able to deal with arbitrary screen geometries. Our calibration procedure is not limited to our application and can be used to calibrate most camera projector systems.

Photon mapping is a global illumination algorithm for generating and visualizing a sparse representation of the incident radiance on surfaces. Photon mapping places an enormous burden on the memory hierarchy. A 512x512 image using the standard kd-tree data structure requires more than 196GB of raw bandwidth to access the photon map. This bandwidth is a major obstacle to our long term goal of designing hardware capable of real time photon mapping.This paper investigates two approaches for reducing the required bandwidth: 1) reordering the kNN searches; and 2) cache conscious data structures. Using a Hilbert curve reordering, we demonstrate an approximate lower bound of 15MB of bandwidth. This improvement of four orders of magnitude requires a prohibitive amount of intermediate storage. We then demonstrate two more cost-effective algorithms that reduce the bandwidth by one order of magnitude to 24GB with IMB of storage. We explain why the choice of data structure can not, by itself, achieve this reduction. Irradiance caching, a popular technique that reduces the number of required kNN searches, receives the same proportional benefit as the higher quality photon gathers.

We present a system for interactively capturing, constructing, and rendering surface light fields by incrementally building a low rank approximation to the surface light field. Each image is incorporated into the lighting model as it is captured, providing the user with real-time feedback. This feedback enables the user to preview the lighting model and direct the image acquisition towards undersampled areas of the object. We also provide a novel datadriven quality heuristic to aid the user in identifying undersampled regions. Our system is an order of magnitude faster than previous systems, and reduces the time necessary to capture the images and construct a surface light field from hours to minutes.

We introduce a technique to rapidly generate summed-area tables using graphics hardware. Summed area tables, originally introduced by Crow, provide a way to filter arbitrarily large rectangular regions of an image in a constant amount of time. Our algorithm for generating summed-area tables, similar to a technique used in scientific computing called recursive doubling, allows the generation of a summed-area table in O(log n) time. We also describe a technique to mitigate the precision requirements of summed-area tables. The ability to calculate and use summed-area tables at interactive rates enables numerous interesting rendering effects. We present several possible applications. First, the use of summed-area tables allows real-time rendering of interactive, glossy environmental reflections. Second, we present glossy planar reflections with varying blurriness dependent on a reflected object's distance to the reflector. Third, we show a technique that uses a summed-area table to render glossy transparent objects. The final application demonstrates an interactive depth-of-field effect using summed-area tables.

Radiosity is a widely used technique for global illumination. Typically the computation is performed offline and the result is viewed interactively. We present a technique for computing radiosity, including an adaptive subdivision of the model, using graphics hardware. Since our goal is to run at interactive rates, we exploit the computational power and programmability of modern graphics hardware. Using our system on current hardware, we have been able to compute and display a radiosity solution for a 10,000 element scene in less than one second.

A good use for the raw computation power of the next generation of graphics hardware is global illumination. Historically, global illumination algorithms have been executed on general purpose CPUs that are able to support complex data structures easily. The performance advantage of graphics hardware lies in its regular and independent computational structure. To retain this advantage there is a growing need for hardware friendly data structures that support non-traditional uses of the GPU such as global illumination. We propose a hardware friendly data structure for the interactive rendering of glossy surfaces by storing a pre-computed, view-independent representation of the incident radiance. The data structure and rendering algorithm approximates the Monte Carlo integration techniques commonly used in global illumination algorithms. The algorithm is applied to photon mapping and achieves interactive results on current graphics hardware. Due to its nature, the data structure is well suited to dynamic updates.

A common metric of VE quality is presence --- the degree to which the user feels like they are in the virtual scene as opposed to the real world. Presence is important for many VE applications [Hodges et al. 1994]. Since presence is a subjective condition, it is most commonly measured by self-reporting, either during the VE experience or immediately afterwards by questionnaires. There is vigorous debate in the literature as to how to best measure presence [Meehan 2001].

In this paper, we present a method for real-time visual simulation of diverse dynamic phenomena using programmable graphics hardware. The simulations we implement use an extension of cellular automata known as the coupled map lattice (CML). CML represents the state of a dynamic system as continuous values on a discrete lattice. In our implementation we store the lattice values in a texture, and use pixel-level programming to implement simple next-state computations on lattice nodes and their neighbors. We apply these computations successively to produce interactive visual simulations of convection, reaction-diffusion, and boiling. We have built an interactive framework for building and experimenting with CML simulations running on graphics hardware, and have integrated them into interactive 3D graphics applications.

We present a method that takes a raster image as input and produces a painting-like image composed of strokes rather than pixels. Our method works by first segmenting the image into features, finding the approximate medial axes of these features, and using the medial axes to guide brush stroke creation. System parameters may be interactively manipulated by a user to effect image segmentation, brush stroke characteristics, stroke size, and stroke frequency. This process creates images reminiscent of those contemporary representational painters whose work has an abstract or sketchy quality. Our software is available at http://www.cs.utah.edu/npr/ArtisticVision.