Results 1  10
of
42
Kinetic Data Structures  A State of the Art Report
, 1998
"... ... In this paper we present a general framework for addressing such problems and the tools for designing and analyzing relevant algorithms, which we call kinetic data structures. We discuss kinetic data structures for a variety of fundamental geometric problems, such as the maintenance of convex hu ..."
Abstract

Cited by 91 (28 self)
 Add to MetaCart
... In this paper we present a general framework for addressing such problems and the tools for designing and analyzing relevant algorithms, which we call kinetic data structures. We discuss kinetic data structures for a variety of fundamental geometric problems, such as the maintenance of convex hulls, Voronoi and Delaunay diagrams, closest pairs, and intersection and visibility problems. We also briefly address the issues that arise in implementing such structures robustly and efficiently. The resulting techniques satisfy three desirable properties: (1) they exploit the continuity of the motion of the objects to gain efficiency, (2) the number of events processed by the algorithms is close to the minimum necessary in the worst case, and (3) any object may change its `flight plan' at any moment with a low cost update to the simulation data structures. For computer applications dealing with motion in the physical world, kinetic data structures lead to simulation performance unattainable by other means. In addition, they raise fundamentally new combinatorial and algorithmic questions whose study may prove fruitful for other disciplines as well.
OutputSensitive Visibility Algorithms for Dynamic Scenes with Applications to Virtual Reality
, 1996
"... An outputsensitive visibility algorithm is one whose runtime is proportional to the number of visible graphic primitives in a scene modelnot to the total number of primitives, which can be much greater. The known practical outputsensitive visibility algorithms are suitable only for static scene ..."
Abstract

Cited by 44 (1 self)
 Add to MetaCart
An outputsensitive visibility algorithm is one whose runtime is proportional to the number of visible graphic primitives in a scene modelnot to the total number of primitives, which can be much greater. The known practical outputsensitive visibility algorithms are suitable only for static scenes, because they include a heavy preprocessing stage that constructs a spatial data structure which relies on the model objects' positions. Any changes to the scene geometry might cause significant modifications to this data structure. We show how these algorithms may be adapted to dynamic scenes. Two main ideas are used: first, update the spatial data structure to reflect the dynamic objects' current positions; make this update efficient by restricting it to a small part of the data structure. Second, use temporal bounding volumes (TBVs) to avoid having to consider every dynamic object in each frame. The combination of these techniques yields efficient, outputsensitive visibility algorithms for scenes with multiple dynamic objects. The performance of our methods is shown to be significantly better than previous outputsensitive algorithms, intended for static scenes. TBVs can be
Visibility Sorting and Compositing without Splitting for Image Layer Decomposition
 In Proceedings of the 25th Annual Conference on Computer Graphics & Interactive Techniques
, 1998
"... 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 app ..."
Abstract

Cited by 33 (3 self)
 Add to MetaCart
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 visibilitycorrect 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. Kdtrees 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 realtime animation of scenes involving hundreds of objects each comprising hundreds or thousands of polygons.
ImageBased Objects
, 1999
"... We present a compact, imagebased representation for threedimensional objects with complex shapes that can be rendered with correct perspective from arbitrary viewpoints using a listpriority algorithm. Objects are represented by six layered depth images sharing a single center of projection. They ca ..."
Abstract

Cited by 33 (4 self)
 Add to MetaCart
We present a compact, imagebased representation for threedimensional objects with complex shapes that can be rendered with correct perspective from arbitrary viewpoints using a listpriority algorithm. Objects are represented by six layered depth images sharing a single center of projection. They can be scaled, and freely translated and rotated, being used as primitives to construct more complex scenes. We also present a new listpriority algorithm for rendering such scenes and a back face culling strategy for a class of imagebased objects. We demonstrate these concepts by constructing imagebased representations from both synthetic and real objects, and rendering them at interactive rates on a PC. Due to their minimum storage requirements and rendering simplicity, imagebased objects can find potential uses in games, virtual museum applications, and web catalogs. CR Categories and Subject Descriptors: I.3.3 [Computer Graphics]: Picture/Image Generation  Display Algorithms; I.3.7 [...
Cylindrical Static and Kinetic Binary Space Partitions
, 1997
"... 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 ..."
Abstract

Cited by 30 (15 self)
 Add to MetaCart
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 xyplane. 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...
Mixing Translucent Polygons with Volumes
, 1999
"... We present an algorithm which renders opaque and/or translucent polygons embedded within volumetric data. The processing occurs such that all objects are composited in the correct order, by rendering thin slabs of the translucent polygons between volume slices using sliceorder volume rendering. We ..."
Abstract

Cited by 27 (1 self)
 Add to MetaCart
We present an algorithm which renders opaque and/or translucent polygons embedded within volumetric data. The processing occurs such that all objects are composited in the correct order, by rendering thin slabs of the translucent polygons between volume slices using sliceorder volume rendering. We implemented our algorithm with OpenGL on current generalpurpose graphics systems. We discuss our system implementation, speed and image quality, as well as the renderings of several mixed scenes.
Binary space partitions for fat rectangles
 IN: PROC. 37TH ANNU. IEEE SYMPOS. FOUND. COMPUT. SCI
, 1996
"... We consider the practical problem of constructing binary space partitions (BSPs) for a set S of n orthogonal, nonintersecting, twodimensional rectangles inIR3such that the aspect ratio of each rectangle inSis at most, for some constant 1. We present an n2^O(p log n)time algorithm to build a bina ..."
Abstract

Cited by 22 (6 self)
 Add to MetaCart
We consider the practical problem of constructing binary space partitions (BSPs) for a set S of n orthogonal, nonintersecting, twodimensional rectangles inIR3such that the aspect ratio of each rectangle inSis at most, for some constant 1. We present an n2^O(p log n)time algorithm to build a binary space partition of for S. We also show that if m of the n rectangles in S have aspect ratios greater than, we can construct a BSP of size npm2O(plogn) for S in npm2O(plogn) time. The constants of proportionality in the bigoh terms are linear in log. We extend these results to cases in which the input contains nonorthogonal or intersecting objects.
Kinetic Binary Space Partitions for Intersecting Segments and Disjoint Triangles (Extended Abstract)
, 1998
"... 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 twodimensional BSP has depth O(log n) and size O(n log n + k) and can be ..."
Abstract

Cited by 20 (10 self)
 Add to MetaCart
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 twodimensional 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 threedimensional 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...
Lower Bounds For Kinetic Planar Subdivisions
 IN PROC. 15TH ACM SYMP. ON COMPUTATIONAL GEOMETRY
, 1999
"... We revisit the notion of kinetic efficiency for noncanonicallydefined discrete attributes of moving data, like binary space partitions and triangulations. Under reasonable computational models, we obtain lower bounds on the minimum amount of work required to maintain any binary space partition o ..."
Abstract

Cited by 15 (9 self)
 Add to MetaCart
We revisit the notion of kinetic efficiency for noncanonicallydefined discrete attributes of moving data, like binary space partitions and triangulations. Under reasonable computational models, we obtain lower bounds on the minimum amount of work required to maintain any binary space partition of moving segments in the plane or any Steiner triangulation of moving points in the plane. Such lower bounds the first to be obtained in the kinetic contextare necessary to evaluate the efficiency of kinetic data structures when the attribute to be maintained is not canonically defined.
Razor: An Architecture for Dynamic Multiresolution Ray Tracing
, 2006
"... Rendering systems organized around the ray tracing visibility algorithm provide a powerful and general tool for generating realistic images. These systems are being rapidly adopted for offline rendering tasks, and there is increasing interest in utilizing ray tracing for interactive rendering as wel ..."
Abstract

Cited by 15 (1 self)
 Add to MetaCart
Rendering systems organized around the ray tracing visibility algorithm provide a powerful and general tool for generating realistic images. These systems are being rapidly adopted for offline rendering tasks, and there is increasing interest in utilizing ray tracing for interactive rendering as well. Unfortunately, standard ray tracing systems suffer from several fundamental problems that limit their flexibility and performance, and until these issues are addressed ray tracing will have no hope of replacing Zbuffer systems for most interactive graphics applications. To realize the full potential of ray tracing, it is necessary to use variants such as distribution ray tracing and path tracing that can compute compelling visual effects: soft shadows, glossy reflections, ambient occlusion, and many others. Unfortunately, current distribution ray tracing systems are fundamentally inefficient. They have high overhead for rendering dynamic scenes, use excessively detailed geometry for secondary rays, perform redundant computations for shading and secondary rays, and have irregular data access and computation patterns that are a poor match for costeffective hardware. We describe Razor, a new software architecture for a distribution ray tracer that addresses these issues. Razor supports watertight multiresolution geometry using a novel interpolation technique and a multiresolution kDtree acceleration structure built ondemand each frame from a tightly integrated application scene graph. This dramatically reduces the cost of supporting dynamic scenes and improves data access and computation patterns for secondary rays. The architecture also decouples shading computations from visibility computations using a twophase shading scheme. It uses existing bestpractice techniques including bundling rays into SIMD packets for efficient computation and memory access. We present an experimental system that implements these techniques, although not in real time. We present results from this system demonstrating the effectiveness of its software architecture and algorithms.