An improved technique for output-sensitive hidden surface removal

We derive a new output-sensitive algorithm for hidden surface removal in a collection ofn triangles, viewed from a pointz such that they can be ordered in an acyclic fashion according to their nearness toz. Ifk is the combinatorial complexity of the outputvisibility map, then we obtain a sophisticated randomized algorithm that runs in (randomized) timeO(n^4/3 log^2.89 n +k ^3/5 n ^{4/5 +} for any > 0. The method is based on a new technique for tracing the visible contours using ray shooting.Work by the first author was partially supported by the ESPRIT II Basic Research Actions Program of the EC, under Contract No. 3075 (project ALCOM). Work by the second author has been supported by Office of Naval Research Grant N00014-87-K-0129, by National Science Foundation Grant CCR-89-01484, and by grants from the U.S.-Israeli Binational Science Foundation, the NCRD-the Israeli National Council for Research and Development-and the Fund for Basic Research in Electronics, Computers, and Communication administered by the Israeli Academy of Sciences. A preliminary version of this paper appeared as part of the conference proceedings paper [17].     

Variations on ray shooting

We solve some problems related toray shooting in the plane, such as finding the first object hit by a query ray or counting the number of objects intersected by the query line. Our main results are an algorithm for finding the first hit when the objects are lines, and an algorithm for the case when the objects are segments. If the segments form simple polygons, this information can be used for reducing the complexity of the algorithms. The algorithms are efficient in space and in query time. Moreover, they are simple and therefore of practical use.This research was partially supported by the NY Metropolitan Research Fund. The second author is currently at IBM Haifa Research Group, Haifa 32000, Israel.     

A review of recent hidden surface removal techniques

Techniques for the removal of hidden surfaces and/or hidden lines from computer generated pictures have continued to be developed and to be applied in other areas. This review covers much recent work in removal methods and some of the newer applications. A broad classification of the many references is given.     

Space Efficient Dynamic Orthogonal Range Reporting

In this paper we present new space efficient dynamic data structures for orthogonal range reporting. The described data structures support planar range reporting queries in time O(log n+klog log (4n/(k+1))) and space O(nlog log n), or in time O(log n+k) and space O(nlog  ^ε n) for any ε>0. Both data structures can be constructed in O(nlog n) time and support insert and delete operations in amortized time O(log ² n) and O(log nlog log n) respectively. These results match the corresponding upper space bounds of Chazelle (SIAM J. Comput. 17, 427–462, 1988) for the static case. We also present a dynamic data structure for d-dimensional range reporting with search time O(log  ^d−1 n+k), update time O(log  ^d n), and space O(nlog  ^d−2+ε n) for any ε>0. The model of computation used in our paper is a unit cost RAM with word size log n. A preliminary version of this paper appeared in the Proceedings of the 21st Annual ACM Symposium on Computational Geometry 2005. Work partially supported by IST grant 14036 (RAND-APX).     

A systolic algorithm for hidden surface removal

With the advent of VLSI it has become possible to map parallel algorithms for compute-bound problems directly on silicon. Systolic architecture is very good candidate for VLSI implementation because of its regular and simple design, and regular communication pattern. In this paper, a systolic algorithm and corresponding systolic architecture, a linear systolic array, for the scanline-based hidden surface removal problem in three-dimensional computer graphics have been proposed. The algorithm is based on the concept of sample spans or intervals. The worst case time taken by the algorithm is O(n), n being the number of segments in a scanline. The time taken by the algorithm for a given scene depends on the scene itself, and on an average considerable improvement over the worst case behaviour is expected. A pipeline scheme for handling the I/O process has also been proposed which is suitable for VLSI implementation of the algorithm.     

Efficient traversal of well-behaved hierarchical trees of extents for ray-tracing complex scenes

Traversal of hierarchial trees of extents (HTE) requires computation of intersections between rays and bounding volumes whose faces are parallel to the cartesian axes. By redefining the HTE so that nonoverlapping bounding volumes are generated, a well-behaved data structure is obtained in which geometrical coherence is applied to speed up its traversal. We distinguish two types of bounding volumes: internal boxes contain the ray's origin whileexternal bounding volumes do not contain the ray's origin. To traverse the HTE, we look first to polygons in the internal bounding volumes and deal with external boxes only when no ray-polygon intersection is found in internal nodes. As external nodes in the HTE define pruned subtrees of external bounding volumes, geometrical characteristics of the boxes are exploited for HTE traversal. A coding scheme allows a 6-bit code to determine which faces of a bounding volume need to be tested for intersection. Also, our well-behaved HTE allows for reuse of intersection points at lower levels of the tree.     

An Efficient Output-Size Sensitive Parallel Algorithm for Hidden-Surface Removal for Terrains

We describe an efficient parallel algorithm for hidden-surface removal for terrain maps. The algorithm runs in O(log ⁴ n) steps on the CREW PRAM model with a work bound of O((n+k) \polylog ( n)) where n and k are the input and output sizes, respectively. In order to achieve the work bound we use a number of techniques, among which our use of persistent data structures is somewhat novel in the context of parallel algorithms. Received July 29, 1998; revised October 5, 1999.     

An optimal algorithm for reporting visible rectangles

We consider the following problem as defined by Grove et al. [Internat. J. Comput. Geom. Appl. 9 (1999) 207-217]: Given a set of n isothetic rectangles in 3D space determine the subset of rectangles, that are not completely hidden. We present an optimal algorithm for this problem that runs in O(nlogn) time and O(n) space. Our result is an improvement over the one of Grove et al. by a logarithmic factor in storage and is achieved by using a different approach. An analogous approach gives non-trivial solutions for other kinds of objects too.     

Linear-time algorithms for visibility and shortest path problems inside triangulated simple polygons

Given a triangulation of a simple polygonP, we present linear-time algorithms for solving a collection of problems concerning shortest paths and visibility withinP. These problems include calculation of the collection of all shortest paths insideP from a given source vertexS to all the other vertices ofP, calculation of the subpolygon ofP consisting of points that are visible from a given segment withinP, preprocessingP for fast "ray shooting" queries, and several related problems.Work on this paper by this author has been supported by Office of Naval Research Grant N00014-82-K-0381, National Science Foundation Grant No. NSF-DCR-83-20085, and by grants from the Digital Equipment Corporation, the IBM Corporation, and from the U.S.-Israel Binational Science Foundation.Work on this paper by this author has been supported by National Science Foundation Grant DCR-86-05962.     

Optimum sweeps of simple polygons with two guards

A polygon P admits a sweep if two mobile guards can detect an unpredictable, moving target inside P  , no matter how fast the target moves. Two guards move on the polygon boundary and are required to always be mutually visible. The objective of this study is to find an optimum sweep such that the sum of the distances travelled by the two guards in the sweep is minimized. We present an O(n²)$O(n^2)$ time and O(n)$O(n)$ space algorithm for optimizing this metric, where n   is the number of vertices of the given polygon. Our result is obtained by reducing this problem to finding a shortest path between two nodes in a graph of size O(n)$O(n)$.     

Maintaining the visibility map of spheres while moving the viewpoint on a circle at infinity

We investigate three-dimensional visibility problems for scenes that consist ofn non-intersecting spheres. The viewing point moves on a flightpath that is part of a circle at infinity given by a planeP and a range of angles {(t)¦t[01]} [02]. At timet, the lines of sight are parallel to the ray inP, which starts in the origin ofP and represents the angle(t) (orthographic views of the scene). We give an algorithm that computes the visibility graph at the start of the flight, all time parameters at which the topology of the scene changes, and the corresponding topology changes. The algorithm has running time0(n + k + p) logn), wheren is the number of spheres in the scene;p is the number of transparent topology changes (the number of different scene topologies visible along the flight path, assuming that all spheres are transparent); andk denotes the number of vertices (conflicts) which are in the (transparent) visibility graph at the start and do not disappear during the flight.The second author was supported by the ESPRIT II Basic Research Actions Program, under Contract No. 3075 (project ALCOM).     

Convex hulls of objects bounded by algebraic curves

We present an0(n ·d ^o(1)) algorithm to compute the convex hull of a curved object bounded by0(n) algebraic curve segments of maximum degreed.Research supported in part by NSF Grant MIP-85 21356, ARO Contract DAA G29-85-C0018 under Cornell MSI, and ONR Contract N00014-88-K-0402. This paper is an updated version of a part of [6].     

Kinetic heap-ordered trees: Tight analysis and improved algorithms

The most natural kinetic data structure for maintaining the maximum of a collection of continuously changing numbers is the kinetic heap. Basch, Guibas, and Ramkumar proved that the maximum number of events processed by a kinetic heap with n numbers changing as linear functions of time is O(nlog²n) and . We prove that this number is actually Θ(nlogn). In the kinetic heap, a linear number of events are stored in a priority queue, consequently, it takes O(logn) time to determine the next event at each iteration. We also present a modified version of the kinetic heap that processes O(nlogn/loglogn) events, with the same O(logn) time complexity to determine the next event.     

Efficient selection, storage, and retrieval of irregularly distributed elevation data

The advantages and disadvantages of various digital terrain models are discussed briefly and a new model for triangulating a set of nonuniformly distributed three-dimensional surface observations is described. An algorithm for hierarchical subdivision of a set of data points into nested triangles is proposed. The algorithm selects a subset of the data points which reduce the maximum error between a piecewise linear approximation of the surface using only the selected points and the elevations of the points not selected. The data structure used is such that for any given degree of approximation (in the maximum-error sense) only the necessary points need to be stored. Furthermore, an efficient method is available to approximate the elevation of the surface at any point not included in the original data. The performance of the algorithm is demonstrated experimentally.     

三维动态几何中直线消隐的实现

由于OpenGL图形系统没有提供现成的直线动态消隐的功能，因此在设计三维动态几何软件时，直线的动态消隐很困难。利用OpenGL图形系统，在研究现有的消隐技术——深度缓存算法的基础上，通过两条直线的叠加和视点移动角度的计算，实现了直线的动态消隐。而且，这种方法也适用于被曲面遮挡的直线的消隐，和被平面或者曲面遮挡的曲线的消隐。     

Dynamic Connectivity for Axis-Parallel Rectangles

In this paper we give a fully dynamic data structure to maintain the connectivity of the intersection graph of n axis-parallel rectangles. The amortized update time (insertion and deletion of rectangles) is and the query time (deciding whether two given rectangles are connected) is O(1). It slightly improves the update time (O(n ^0.94)) of the previous method while drastically reducing the query time (near O(n ^1/3)). In addition, our method does not use fast matrix multiplication results and supports a wider range of queries. This work has been supported by an NSERC grant.     

Data structures and the time complexity of ray tracing

The time complexity of ray tracing is a function of the data structures used for space division. Octree and hierarchical extents have been suggested as effective choices. In this paper, complexity parameters are suggested to characterize images and show that both octrees and hierarchies are appropriate choices if given most favorable images. Also, a unified technique is proposed and shown to be better than previous methods for all images. Octrees and hierarchies are particular cases of the new proposed algorithm.     

A coordinate system associated with points scattered on a surface

Coordinate systems associated to a finite set of sample points have been extensively studied, especially in the context of interpolation of multivariate scattered data. Notably, Sibson proposed the so-called natural neighbor coordinates that are defined from the Voronoi diagram of the sample points. A drawback of those coordinate systems is that their definition domain is restricted to the convex hull of the sample points. This makes them difficult to use when the sample points belong to a surface. To overcome this diffculty, we propose a new system of coordinates. Given a closed surface S, i.e. a (d−1)-manifold of the coordinate system is defined everywhere on the surface, is continuous, and is local even if the sampling density is finite. Moreover, it is inherently (d−1)-dimensional while the previous systems are d-dimensional. No assumption is made about the ordering, the connectivity or topology of the sample points nor of the surface. We illustrate our results with an application to interpolation over a surface.     

Dynamic fractional cascading

The problem of searching for a key in many ordered lists arises frequently in computational geometry. Chazelle and Guibas recently introduced fractional cascading as a general technique for solving this type of problem. In this paper we show that fractional cascading also supports insertions into and deletions from the lists efficiently. More specifically, we show that a search for a key inn lists takes timeO(logN +n log logN) and an insertion or deletion takes timeO(log logN). HereN is the total size of all lists. If only insertions or deletions have to be supported theO(log logN) factor reduces toO(1). As an application we show that queries, insertions, and deletions into segment trees or range trees can be supported in timeO(logn log logn), whenn is the number of segments (points).This research was supported by the Deutsche Forschungsgemeinschaft under Grants Me 620/6-1 and SFB 124, Teilprojekt B2. A preliminary version of this research was presented at the ACM Symposium on Computational Geometry, Baltimore, 1985.