Image-space simplifications have been used to accelerate the calculation of computer graphic images since the dawn of visual simulation. Texture mapping has been used to provide a means by which images may themselves be used as display primitives. The work reported by this paper endeavors to carry this concept to its logical extreme by using interpolated images to portray three-dimensional scenes. The special-effects technique of morphing, which combines interpolation of texture maps and their shape, is applied to computing arbitrary intermediate frames from an array of prestored images. If the images are a structured set of views of a 3D object or scene, intermediate frames derived by morphing can be used to approximate intermediate 3D transformations of the object or scene. Using the view interpolation approach to synthesize 3D scenes has two main advantages. First, the 3D representation of the scene may be replaced with images. Second, the image synthesis time is independent of the scene complexity. The correspondence between images, required for the morphing method, can be predetermined automatically using the range data associated with the images. The method is further accelerated by a quadtree decomposition and a view-independent visible priority. Our experiments have shown that the morphing can be performed at interactive rates on today’s high-end personal computers. Potential applications of the method include virtual holograms, a walkthrough in a virtual environment, image-based primitives and incremental rendering. The method also can be used to greatly accelerate the computation of motion blur and soft shadows cast by area light sources.

Visibility algorithms for walkthrough and related applications have grown into a significant area, spurred by the growth in the complexity of models and the need for highly interactive ways of navigating them. In this survey, we review the fundamental issues in visibility and conduct an overview of the visibility culling techniques developed in the last decade. The taxonomy we use distinguishes between point-based and from-region methods. Point-based methods are further subdivided into object and image-precision techniques, while from-region approaches can take advantage of the cell-and-portal structure of architectural environments or handle generic scenes.

This paper describes an object-space shadow generation algorithm for static polygonal environments illuminated by movable point light sources. The algorithm can be easily implemented on any graphics system that provides fast polygon scan-conversion and achieves near real-time performance for environments of modest size. It combines elements of two kinds of current shadow generation algorithms: two-pass object-space approaches and shadow volume approaches. For each light source a Binary Space Partitioning (BSP) tree is constructed that represents the shadow volume of the polygons facing it. As each polygon's contribution to a light source's shadow volume is determined, the polygon's shadowed and lit fragments are computed by filtering it down the shadow volume BSP tree. The polygonal scene with its computed shadows can be rendered with any polygon-based visible-surface algorithm. Since the shadow volumes and shadows are computed in object space, they can be used for further analysis of the scene. Pseudocode is provided, along with pictures and timings from an interactive implementation.

In computer graphics, rendering is the process by which an abstract description of a scene is converted to an image. When the scene is complex, or when high-quality images or high frame rates are required, the rendering process becomes computationally demanding. To provide the necessary levels of performance, parallel computing techniques must be brought to bear. Although parallelism has been exploited in computer graphics since the early days of the field, its initial use was primarily in specialized applications. The VLSI revolution of the late 1970Õs and the advent of scalable parallel computers during the late 1980Õs changed this situation. Today, parallel hardware is routinely used in graphics workstations, and numerous software-based rendering systems have been developed for general-purpose parallel architectures. This article provides a broad introduction to the subject of parallel rendering, encompassing both hardware and software systems. The focus is on the underlying concepts and the issues which arise in the design of parallel rendering algorithms and systems. We examine the different types of parallelism and how they can be applied in rendering applications. Concepts from parallel computing, such as data decomposition, task granularity, scalability, and load balancing, are considered in relation to the rendering

We present an efficient algorithm for visibility sorting a set of moving geometric objects into a sequence of image layers which are composited to produce the final image. Instead of splitting the geometry as in previous visibility approaches, we detect mutual occluders and resolve them using an appropriate image compositing expression or merge them into a single layer. Such an algorithm has many applications in computer graphics; we demonstrate two: rendering acceleration using image interpolation and visibility-correct depth of field using image blurring. We propose a new, incremental method for identifying mutually occluding sets of objects and computing a visibility sort among these sets. Occlusion queries are accelerated by testing on convex bounding hulls; less conservative tests are also discussed. Kd-trees formed by combinations of directions in object or image space provide an initial cull on potential occluders, and incremental collision detection algorithms are adapted to resolve pairwise occlusions, when necessary. Mutual occluders are further analyzed to generate an image compositing expression; in the case of nonbinary occlusion cycles, an expression can always be generated without merging the objects into a single layer. Results demonstrate that the algorithm is practical for real-time animation of scenes involving hundreds of objects each comprising hundreds or thousands of polygons.

We describe the first known algorithm for efficiently maintaining a Binary Space Partition (BSP) for n continuously moving segments in the plane. Under reasonable assumptions on the motion, we show that the total number of times the BSP changes is O(n 2 ), and that we can update the BSP in O(log n) expected time per change. We also consider the problem of constructing a BSP for n triangles in R 3 . We present a randomized algorithm that constructs a BSP of expected size O(n 2 ) in O(n 2 log 2 n) expected time. We also describe a deterministic algorithm that constructs a BSP of size O((n + k) log n) and height O(log n) in O((n + k) log 2 n) time, where k is the number of intersection points between the edges of the projections of the triangles onto the xy-plane. 1 Introduction The Binary Space Partition (BSP, also known as BSP tree), originally proposed by Schumacker et al. [26] and further refined by Fuchs et al. [16], is a hierarchical partitioning of space widely used i...

Abstract not found

We consider the practical problem of constructing binary space partitions (BSPs) for a set S of n orthogonal, non-intersecting, two-dimensional rectangles in R 3 such that the aspect ratio of each rectangle in S is at most ff, for some constant ff 1. We present an n2 O( p log n ) -time algorithm to build a binary space partition of size n2 O( p log n ) for S. We also show that if m of the n rectangles in S have aspect ratios greater than ff, we can construct a BSP of size n p m2 O( p log n ) for S in n p m2 O( p log n ) time. The constants of proportionality in the big-oh terms are linear in log ff. We extend these results to cases in which the input contains non-orthogonal or intersecting objects. A preliminary version of this paper appeared in the Proceedings of the 37th Annual Symposium on Foundations of Computer Science, 1996. y Support was provided by National Science Foundation research grant CCR--93--01259, by Army Research Office MURI grant DAAH04--9...

We presentasub-linear algorithm for computing and culling back-facing polygons that yields a signi#cant performance improvement in the interactive rendering of large polygonal models. The algorithm partitions a polygonal model it into hierarchical clusters based on the normals and positions of the polygons. It does not explicitly compute all the back-facing polygons but rather decides, in expectedconstant time, whether an entire cluster is back-facing. As a pre-processing step, the algorithm partitions the space into regions with respect to each cluster. During rendering, it exploits frame-to-frame coherence to track the view-point. The algorithm has been applied to a number of models and its performance is a function of number of clusters, the depth of the hierarchies, and the characteristics of the graphics system. In practice, we are able to cull 30 , 55# of the polygons in about 5 , 10# of the total CPU time per frame on an SGI Indigo2 Extreme for models composed of tens of tho...

We describe randomized algorithms for efficiently maintaining a binary space partition of continuously moving, possibly intersecting, line segments in the plane, and of continuously moving but disjoint triangles in space. Our two-dimensional BSP has depth O(log n) and size O(n log n + k) and can be constructed in expected O(n log² n + k log n) time, where k is the number of intersecting pairs. We can detect combinatorial changes to our BSP caused by the motion of the segments, and we can update our BSP in expected O(log n) time per change. Our three-dimensional BSP has depth O(log n), size O(n log² n+k 0 ), construction time O(n log³ n+k 0 log n), and update time O(log² n) (all expected), where k 0 is the number of intersections between pairs of edges in the xy- projection of the triangles. Under reasonable assumptions about the motion of the segments or triangles, the expected number of number o...