Let S be a set of n non-intersecting objects in space for which we want to determine the portions visible from some viewing point. We assume that the objects are ordered by depth from the viewing point (e.g., they are all horizontal and are viewed from infinity from above). In this paper we give an algorithm that computes the visible portions in time O((U(n)+ k)log 2 n), where U(n ) is a super-additive bound on the maximal complexity of the union of (the projections on a viewing plane of) any n objects from the family under consideration, and k is the complexity of the resulting visibility map. The algorithm uses O(U(n)logn) working storage. The algorithm is useful when the objects are "fat" in the sense that the union of the projection of any subset of them has small (i.e., subquadratic) complexity. We present three applications of this general technique: (i) For disks (or balls in space) we have U(n) = O(n), thus the visibility map can be computed in time O((n + k) log 2 n). (ii) For 'fat' triangles (where each internal angle is at least some fixed 0 degrees) we have U(n) = O(nloglogn) and the algorithm runs in time O((n log log n + k)log 2 n). (iii) The method also applies to computing the visibility map for a polyhedral terrain viewed from a fixed point, and yields an O((na(n)+ k)logn) algorithm.

Abstract-In this paper, we present an algorithm for hidden surface removal for a class of poly-hedral surfaces which have a property that they can be ordered relatively quickly. For example, our results apply directly to terrain maps. A distinguishing feature of our algorithm is that its running time is sensitive to the actual size of the visible image, rather than the total number of intersections in the image plaue which can be much larger than the visible image. The time complexity of this algorithm is O((k + n) log ’ n) where n and /c are, respectively, the input and the output sizes. Thus, in a significant number of situations this will be faster than the worst case optimal algorithms which have running time of n(n’) irrespective of the output size.

In this paper we study the ray shooting problem for three special classes of polyhedral objects in space: axis-parallel polyhedra, curtains (unbounded polygons with three edges, two of which are parallel to the z-axis and extend downward to minus infinity) and fat horizontal triangles (triangles parallel to the y-plane whose angles are greater than some fixed constant). For all three problems structures are presented using O(n 2+) preprocessing, for any fixed e > 0, with O(log n) query time. We also study the general ray shooting problem in an arbitrary set of (possibly intersecting) triangles. Here we present a structure that uses O(n 4+e) preprocessing and has a query time of O(log n). As an

We investigate 3-d visibility problems in which the viewing position moves along a straight flightpath. Specifically we focus on two problems: determining the points along the flightpath at which the topology of the viewed scene changes, and answering ray-shooting queries for rays with origin on the flightpath. Three progressively more specialized problems are considered: general scenes, terrains, and terrains with vertical flightpaths. 1.

Abstract not found

We consider the following dynamic data structure problem. Given a collection of rigid bodies moving in 3-dimensional space and hinged together in a kinematic structure, our goal is to efficiently maintain a data structure that allows us to quickly answer range queries as the bodies move. This kinematic data structure problem arises in a variety of applications such as conformational search in molecular biology, simulation of hyper-redundant robots, collision detection, and computer animation. We study several models for dynamic maintenance of such structures and devise algorithms under these models. We obtain tight results on the worst-case, amortized, and randomized complexity of the data structure problem. For the offline version of the problem, we establish NP-hardness and provide efficient approximation algorithms.

We consider the family of area bisectors of a polygon #possibly with holes# in the plane. Wesay that two bisectors of a polygon P are combinatorially distinct if they induce di#erent partitionings of the vertices of P.We show that there are simple polygons with n vertices that have# #n 2 # combinatorially distinct area bisectors #matching the obvious upper bound#, and we present an output-sensitive algorithm for computing an explicit representation of all the bisectors of a given polygon. Our study is motivated by the development of novel, #exible feeding devices for parts positioning and orienting. The question of determining all the bisectors of polygonal parts arises in connection with the development of e#cient part positioning strategies when using these devices. 1 Introduction Let P be a polygon in the plane, possibly with holes, and having n vertices in total. We denote by V the set of vertices of P.For a directed line # in the plane, we denote by h l ### #resp. hr #### the...

In this paper we consider the following problems: given a set T of triangles in 3-space, with jT j = n, a) answer the query " given a line l, does l stab the set of triangles?" (query problem). b) find whether a stabbing line exists for the set of triangles (existence problem). c) Given a ray ae, which is the first triangle in T hit by ae? The following results are shown. 1. There is an \Omega\Gamma n 3 ) lower bound on the descriptive complexity of the set of all stabbers for a set of triangles. 2. The existence problem for triangles on a set of planes with g different plane inclinations can be solved in O(g 2 n 2 log n) time (Theorem 2). 3. The query problem is solvable in quasi-quadratic O(n 2+ffl ) preprocessing and storage and logarithmic O(log n) query time (Theorem 4). 4. All stabbing results for triangles extend, with the same asymptotic bounds, to sets of convex polyhedra with total complexity n. 5. Using O(n 3+ffl ) preprocessing time and storage we can det...

this paper we give an algorithm for the hidden-line elimination problem that is optimal in the worst case, and also takes advantage of problem instances that are "simpler" than in the worst case. Intuitively, our approach is to exploit the polygonal 2

We present an algorithm for the hidden-surface elimination problem for rectangles, which is also known as window rendering. The time complexity of our algorithm is dependent on both the number of input rectangles, n, and on the size of the output, k. Our algorithm obtains a trade-off between these two components, in that its running time is O(r(n 1 1=r k)), where 1 r log n is a tunable parameter. By using this method while adjusting the parameter r "on the fly" one can achieve a running time that is O(n log n k(log n= log(1 k=n))). Note that when k is \Theta(n), this achieves an O(n log n) running time, and when k is \Theta(n 1 ffl ) for any positive constant ffl, then this achieves an O(k) running time, both of which are optimal. A preliminary announcement of this research is to appear at the 17th International Colloquium on Automata, Languages, and Programming. Part of this research was carried out while the authors were visiting Princeton University for the DIMACS ...