Results 1  10
of
33
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 92 (27 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.
Balanced Aspect Ratio Trees: Combining the Advantages of kd Trees and Octrees
"... Given a set S of n points in R^d, we show, for fixed d, how to construct in O(n log n) time a data structure we call the Balanced Aspect Ratio (BAR) tree. A BAR tree is a binary space partition tree on S that has O(logn) depth and in which every region is convex and “fat ” (that is, has a bounded as ..."
Abstract

Cited by 55 (8 self)
 Add to MetaCart
Given a set S of n points in R^d, we show, for fixed d, how to construct in O(n log n) time a data structure we call the Balanced Aspect Ratio (BAR) tree. A BAR tree is a binary space partition tree on S that has O(logn) depth and in which every region is convex and “fat ” (that is, has a bounded aspect ratio). While previous hierarchical data structures, such as kd trees, quadtrees, octrees, fairsplit trees, and balanced box decompositions can guarantee some of these properties, we know of no previous data structure that combines alI of these properties simultaneously. The BAR tree data structure has numerous applications ranging from solving several geometric searching problems in fixed dimensional space to aiding in the visualization of graphs and threedimensional worlds.
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
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 [...
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 32 (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.
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 29 (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
"... sizen2O(plogn) We consider the practical problem of constructing binary space partitions (BSPs) for a setSofnorthogonal, nonintersecting, twodimensional rectangles inIR3such that the aspect ratio of each rectangle inSis at most, for some constant1. We present ann2O(plogn)time algorithm to build a ..."
Abstract

Cited by 23 (6 self)
 Add to MetaCart
sizen2O(plogn) We consider the practical problem of constructing binary space partitions (BSPs) for a setSofnorthogonal, nonintersecting, twodimensional rectangles inIR3such that the aspect ratio of each rectangle inSis at most, for some constant1. We present ann2O(plogn)time algorithm to build a binary space partition of forS. We also show that ifmof thenrectangles inShave aspect ratios greater than, we can construct a BSP of sizenpm2O(plogn)forSinnpm2O(plogn)time. The constants of proportionality in the bigoh terms are linear inlog. 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 16 (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.