An Improved Output-size Sensitive Parallel Algorithm for Hidden-Surface Removal for Terrains

Transcription

1 An Improve Output-size Sensitive arallel Algorithm for Hien-Surface Removal for Terrains Neelima Gupta an Saneep Sen Department of Computer Science an Engineering Inian Institute of Technology New Delhi 006, Inia, Abstract We escribe an efficient parallel algorithm for hiensurface removal for terrain maps. The algorithm runs in O(log 4 n) steps on the CREW RAM moel with a work boun of O((n + k)polylog(n)) where n an k are the input an output sizes respectively. In orer to achieve the work boun we use a number of techniques, among which our use of persistent ata-structures is somewhat novel in the contet of parallel algorithms. To the best of our knowlege this is the most efficient parallel algorithm for hien-surface removal for an important class of -D scenes.. Introuction.. The roblem The hien-surface elimination problem (see [4] for early history) has been a funamental problem in computer graphics an can be state as - given n polyheral faces in R an a projection plane, we wish to etermine which portions of the faces are visible when viewe in a given irection. We are intereste in an object-space solution (inepenent of the isplay evice) for this problem. That is, we are intereste in a combinatorial escription of the visible scene which can then be renere on any isplay evice. The image-space solutions compute the visibility information at every piel which makes them evice epenent. It has been shown that the worst case output size for hien surface elimination can be (n ) for n segments, an hence, the worst case optimal algorithms for these problems will have a running time of (n ). There are algorithms whose running times are sensitive to the number of intersections, I, (of the projections of the segments) in the image plane. However, in practice, the size of the isplaye image can be far less than the number of intersections in the image plane. By size, we mean the number of vertices an eges of the isplaye image as a (planar) graph. This woul happen when a large number of these intersections are occlue by the visible surfaces. We will stuy a special class of surfaces calle polyheral terrains which occur frequently in practice. A terrain is a three-imensional polyheral surface which can be represente as a function of two variables. Most geographical features can be represente in this manner. A large number of scenes in graphics applications can be moelle efficiently an effectively by polyheral terrains. The term (upper) will refer to the piece-wise linear function Z(y), which is the point-wise maimum in +z irection of the projection of eges onto the z, y plane. Other commonly use terms for upper- are upperenvelope an silhouette. Therefore, a is a monotone polygon with respect to the y,ais. In fact, monotonicity turns out to be a very useful property in making the algorithm somewhat simpler than hien-surface removal algorithm for general surfaces. However, even for terrains, it is known that the maimum size of the visible image can be (n ). Our aim is to esign a fast output-sensitive (we will often use output-sensitive instea of output-size sensitive) parallel algorithmfor terrains, which computes a escription of the output in a evice-inepenent manner... Sequential algorithms Several sequential algorithms eist for the problem. (See [, 5, 4,, 7, 8,,, 9, 8, 5, 4, 6]). For the class of polyheral terrains, Reif an Sen [9] esigne the first efficient algorithm whose running time is O((k + n) log n) where k is the output size... arallel algorithms Relatively littlework has been one in the contet of parallel algorithms for hien-surface removal. Reif an Sen [9] ha propose a parallelization of their algorithm with polylog(n) running time. The more challenging theoretical goal was to keep the work boun close to the outputsensitive sequential algorithm. The resulting algorithm was quite comple an require parallel (ynamic) upates on a

2 share neste ata structure that were not onlyhar to implement but also ifficult to analyze. Here, we eploit some of their ieas but aopt a ifferent strategy to buil the parallel ata-structure. The resulting algorithm is relatively simpler an also easier to analyze. The main reason for this is that the unerlying ata-structure is static although it has to be rebuilt a (small) number of times. Our bouns are also superior in the sense that we are able to match the bouns of [9] in a stanar RAM moel (processor allocation was assume to be free in the moel use by [9]). Goorich, Ghouse an Bright [] presente parallel algorithms for hien-surface elimination. For the general scenes, their algorithm computes all the I pairwise intersections on the projection plane. For the case of iso-oriente rectangles inr, their algorithmis output-sensitivean runs in O(log n) time using O((n+k) log n) total parallel operations. The cru of their metho is a parallel ata-structure calle array-of-trees introuce by Atallah, Goorich an Kosaraju [0], that has some flavour of persistent atastructures. In this paper, we make more irect use of persistent ata-structures in our parallel algorithm. The importance of output-size sensitivity for parallel algorithms cannot be over-emphasize for the following simple reason. The avantage of using etra processors will be lost otherwise (for small output-size) as compare to an efficient output-sensitivesequential algorithm. The rest of the paper is organize as follows. In section, we give a brief overview of our approach. In section, we escribe some of the basic parallel routines use frequently in the main algorithm. Section 4 forms the cru of the paper. Since the algorithm is somewhat involve, we give a top-own escription of the algorithm an the ata-structures accompanie by analysis.. An overview of our algorithm Recall from the introuctionthat terrains in thispaper refer to piecewise linear surfaces which meet a vertical line in eactly one point. Assume that the surface is a function z = f(; y), it is being viewe from = an the viewing plane is the z, y plane. We are viewing the scene in a irection perpenicular to the projection plane, however the algorithm works for perspective projection as well. A characteristic of these surfaces is that the upper bounary of the projection of the line segments on the z, y plane is monotone with respect to the y,ais. We assume that the terrainis availableas a graph G whose vertices are -tuples (; y; z) of coorinates such that z = f(; y) an whose eges correspon to the segments of the polyheral surface. The terms eges an segments have therefore been use interchangeably. We also assume that only the top part of the surface is visible, i.e., the faces closest to the observer rise from the groun level. A key property that allows one to solve the visibility problem efficiently is that the eges can be orere from front to back using the following observation. roject G on the, y plane (call it G y ) an now the orering of the segments in the scene in the increasing istance from the viewer correspons to the orering of the eges of G y along. That is, we can efine a partial orer on the eges as follows : ege e i e j if there is a ray in the viewing irection that intersects e i before e j. The projection of the eges on the, y plane preserves this orering. In the sequential algorithm, the eges are processe one by one sequentially in orer. The algorithmmaintains an upper of the eges processe so far an tests the visibility of the net ege being processe by etermining its intersection with the current. Since the eges are processe in the orer of increasing istance from the viewer, the lies in front of the net ege an therefore occlues the portion of the ege which lies behin it. Thus the portion of the projecte ege lying below the (which is a simple monotone polygon) is not visible an hence is iscare. The upper is upate with the visible portions of the ege. Clearly, the portion of an ege eclare visible is visible in the final image (i.e. it cannot be occlue by eges processe later). Some vertices an eges of the may be elete at this point which only means that they are no longer part of the upper bounary of the final image but they are very much visible in the final image an therefore are remembere. Finally, we have all the vertices an eges of the final image which can be use by the renering proceure to raw it on the screen... An overview of the parallel algorithm In the parallel scenario the above sequential algorithm has two major stumbling blocks. First, the eges are processe sequentially an the upper s are compute incrementally. We overcome this problem with the help of a Separator Tree an computing s using an approach similar to systolic implementation of parallel prefi computation. Separator tree provies a way to orer the eges in the increasing istance from the viewer in parallel an also allows one to process them concurrently. Secon, the intersections of an ege with a are compute sequentially. We use the ivie-an-conquer approach to etect the intersections efficiently in parallel. We orer the eges using a separator tree. Let e ;e :::e n be the orere set of input eges. Let i enote the i th, i.e. the upper of the eges e ;e :::e i. Our aim is to compute i 8 i = :::n. We call them actual s (however we will omit actual most of the times an mention it only if it is not clear from the contet). We compute these s in two phases. In phase we compute in parallel, for all the noes of the separator tree the upper of the eges in the leaves of the subtree roote at the noe (the eges in the leaves of the separator tree are sorte in the increasing istance from the viewer). Call the resulting tree as the computation tree (CT). Notice that these s are not the actual s we are look-

3 ing for. These are only intermeiate s which are use to compute the actual s in phase. In phase we compute the actual s using an approach similar to the systolic implementation of parallel prefi computation [9]. Starting from the root of the computation tree the computation procees towars the leaves level by level. In this phase, at any noe, the computation involves merging of two s - an (actual) inherite from its parent an an (intermeiate) compute in the previous phase by one of its chilren. Merging is one by fining the intersections of the segments of the intermeiate with the other an upating the other. However, as we will see later, our visibility structure (i.e. the vertices of the s) may be share among ifferent noes at the same level of CT. We can not affor to keep these s totally inepenent of each other because that will jeoparize our main objective of esigning an output-sensitive algorithm. Instea of keeping a visibilitystructure for each at a fie level of CT we keep just one structure maintaining information about all the intersections compute so far an also provie a search structure to etect the intersections at the net level of CT. We shall nee frequent applications of the slow-own lemma which (in our contet) can be formally state as follows. Let t p;r enote the time to allocate p processors to a number of tasks whose total processor requirement is O(r). That is t p;r is the time to solve the problem of processor allocation of size r with p processors. Lemma. Let A be a parallel algorithm that eecutes in phases an performs a total number of N tasks (each task is not necessarily unit time but is performe by a single processor). Then the algorithm can be eecute in time O((t p;n +t)+n t=p) using p processors in a RAM where t is the time taken for each task. roof: This is a straightforwar generalization of Brent s slow-own lemma. Lemma. Let A be a parallel algorithm that eecutes in phases. Let N i be the number of tasks in phase i, each eecutes in O(t i ) time with p i processors. Let t = i= t i an N = ma i fn i p i g. Then the algorithmcan be eecute in O(t p;n + t + N t=p) time with p processors.. The parallel algorithm We escribe the algorithm in a top-own manner, treating the important steps in iniviual subsections accompanie by etaile analysis. Given a -D surface as a straight line graph in three imensions, we project the line-segments on the, y plane. By the property of terrain maps, no two projecte segments will intersect. If the graph is not triangulate, we triangulate the graph using the algorithm of Atallah, Cole an Goorich [] for parallel triangulation. Since it is a planar graph, the number of eges an faces is still O(n). Henceforth our iscussions will be with respect to the triangulate graph. The main steps of the algorithm are: share segments at v at l Figure. l is the left chil of the noe v in CT, at l is the of the subset of eges of the set whose is compute at v.. Orer the eges of the triangulate graph using seperator trees... rofile computation (a) hase : Compute the intermeiate s -to compute the s we take the projection of the line segments on the z, y plane. For each noe v in the separator tree o in parallel: compute the of the eges in the leaves of the subtree roote at v. Weshall call these s intermeiates. Note that these are not necessarily part of the final visible scene. As mentione earlier, we call the resulting tree the rofile Computation Tree. We shall use the term layer to imply a level of CT. Observe that the segments of the s may be share among the layers of CT (see Figure ). (b) hase : Compute the actual s - compute the actual (visible) s starting from the root of the CT, proceeing layer by layer towars the leaves. This step constitutes the cru of our algorithm. Step can be implemente in O(log n) time using a linear number of processors in an EREW RAM using a proceure ue to Tamassia an Vitter [5]. Their result can be summarize as follows: Fact Let S be a planar triangulate subivision with n vertices. Then the separator tree consisting of monotone chains that ecompose S can be constructe by an EREW RAM in O(log n) time using n processors. Lemma. The of a set of m segments can be constructe in O(log m) time using O(m(m)= log m) processors in a CREW RAM. roof: This is one by iviing the set of segments in two equal halves, computing the s recursively for each half an merging the s. Details are ommitte here. Thus Step a can be one in O(log n) time using O(n(n)) processors in a CREW RAM... Computing the actual s Given the s an the ata structure for intersection etection at a given layer, say L ofct, several actual s are compute at the net layer in parallel. Suppose at a

4 noe u of CT, we compute the actual j by merging i (i < j, i inherite from the parent of u) with an intermeiate ij precompute (by the left chil of u) in phase. For each segment s of ij we compute the intersection of s with i. Some of the vertices of i may be elete as they lie below s an hence o not contribute to j. Some new intersections may be etecte an ae to j. The intersection of a segment with a is compute as follows. Lemma. Given the ata structure for intersection etection of a of size m an a line segment s, we can fin all the k s intersections of s with in time O(maf(T I + t p;ks ) log m; k s T I =pg) with p processors on CREW RAM, where T I is the sequential time to etect the first intersection of a segment with. roof: Split the segment s aroun the mile iagonal (among the iagonals that the segment spans). Fin the intersection closest to in both the subsegments an recurse. The result follows by applying Lemma.. Further etails are ommitte here. To etect the first intersection between a segment an a (if an intersection eists), we use the ata structure an recursive search proceure of Chazelle an Guibas ([]). The sequential algorithm of Reif an Sen revolve aroun making this ata structure ynamic. See Figure. We will (a) a (b) Figure. (a). (b) CG ata structure for. refer to this structure of Chazelle an Guibas by CG ata structure in future. By an ege of CG we woul imply either a tree ege or a shooting pointer (shown as otte arcs in the figure) unless eplicitly state otherwise. Lemma. For a with m vertices, we can construct the CG ata structure in O(maflog m; t p;m + m log m=pg) time using p processors on the CREW RAM. roof: Follows from a straight-forwar ivie-anconquer strategy an then applying Lemma.. a c c b b The original ata structure of CG was somewhat more comple base on ual transforms. Here instea, to etect whether a segment intersects a between two iagonals a an b we augment each ege ab of the CG ata structure with the lower conve chain of the vertices of the between a an b. Call the resulting structure as augmente CG an refer to it as ACG hereafter. The above proceure is along the lines of reparata an Vitter [8]. A crucial factor here is sharing of common visible segments between the s being compute at ifferent noes of the same layer of CT. To hanle this problem, instea of keeping an ACG structure for every, we keep a single ACG structure for all the s. That is, we construct the CG on all the intersections foun upto a certain layer, say, L of CT. an augment each ege of it with the lower conve chains of all those s (all s compute so far) which participate in etecting the intersections at the net layer so that the proper chain is searche for intersection. (see Figure ). Here, we use a share ata-structure along the lines of a persistent binary tree structure [6] to store the conve chains of all the s taking care of their share visible portions. Lemma.4 The CG structure constructe on the k intersections compute upto a fie layer of CT can be augmente with all the conve chains in O(maflog k; t p;k log k + k log k=pg) time using p processors on a CREW RAM. roof: The constructions an the proof are very long an therefore ommitte. Lemma.5 At a fie layer of CT, the ACG structure can be constructe in O(maflog k; t p;k log k + k log k=pg) time using p processors on a CREW RAM, where k is the number of intersections compute upto that layer. roof: Follows from Lemmas. an.4. Lemma.6 All k s intersections of a segment s with a can be etecte in O(maflog k + t p;ks ) log n; k s log k=pg) time with p processors, where k is total number of intersections compute upto a fie layer of CT. roof: To search whether a ray intersects a an etect the first intersection in case it oes, procee level by level of ACG starting from the root, accoring to the recursive search proceure mentione earlier. At each level, it involves searching whether a ray intersects the conve chain corresponing to between two iagonals (not necessarily of ). ThisrequiresO(log k) phases each requiring O(log k) time. Thus the result follows from Lemma.. Hence by Lemma. all the intersections of all the segments of all the intermeiate s at the net layer of CT can be compute in O(maflog k; t p;k+n(n) log k +(k + n(n)) log k=pg) time, where n(n) is the total number of segments whose intersections are to be compute an k is the maimum number of intersections. Finally the processor allocation problem of size r can be one in O(r log r=p)

5 time using p processors on CREW RAM. Hence all the intersections at the net layer of CT can be compute in O(maflog n; (k + n(n)) log n=pg) time using p processors, or all intersections can be etecte in O(maflog 4 n; (k + n(n)) log n=pg) time over all layers of CT using p processors. we summarize our final result as follows. Theorem. The hien-surface elimination problem for terrains can be solve in O(maflog 4 n; (k + n(n)) log n=pg) time using p CREW processors where n an k are the input an the output sizes respectively. Remark For p = n(n)= log n, thework bounis O((k + n(n)) log n) which is within O(log n) factor of the sequential boun of Reif an Sen [0]. References [] M. J. Atallah, R. Cole, an M. T. Goorich. Cascaing ivie-an-conquer : A technique for esigning parallel algorithms. roceeingsof 8th IEEE Symposium on Founations Of Computer Science, pages 5 60, 987. [] M. Bern. Hien surface removal for rectangles. roc. of the 4th ACM Symp. on Computational Geometry, pages8 9, 988. [] B. Chazelle an L. Guibas. Visibility an intersection problems in plane geometry. roc. ACM Symposium on Computational Geometry, pages 5 46, 985. [4] M. eberg, D. Halpern, M. Overmars, J. Snoeyink, an M. Kreval. Efficient ray-shooting an hien-surface removal. roc. 7th ACM Symposium on Computational Geometry, pages 0, 99. [5] F. Devai. Quaratic bouns for hien-line elimination. roc. n Annual Symp. on Computational Geometry, pages 69 75, 986. [6] J.R.Driscoll,N.Sarnak,D.D.Sleator,anR.E.Tarzan. Make the ata-structures persistent. Journal of Computer an System Sciences, 8:86 4, 989. [7] M. T. Goorich. A polygonal approach to hien-line elimination. GVGI : Graphical Moels an Image rocessing, 54():, 99. [8] R. Guting an T. Ottmann. New algorithms for special cases of the hien-line elimination problem. roc. of the STACS, pages 6 7, 985. [9] R. Laner an M. Fischer. arallel prefi computation. Journal of ACM, 7(4):8 88, 980. [0] M. Atallah, M. Goorich, R. Kosaraju. arallel algorithms for evaluating sequences of set-manipulation operations. LNCS 9: Aegean Workshop on Computing, pages 0, 988. [] M. Atallah, M. Goorich an M. Overmaars. An inputsize/output-size trae-off inthe time-compleity of rectilinear hien-surface removal. roc. of ICAL, 990. [] M. Ghouse, M. Goorich an J. Bright. Generalize sweep methos for parallel computatioonal geometry. roc. of the n ACM Symp. on arallel Algorithms an Architectures, pages 80 89, 990. [] M. McKenna. Worst-case optimal hien-surface removal. ACM Transactions on Graphics, pages 9 8, 987. [4] O. Nurmi. A fast line-sweep algorithm for hien-line elimination. BIT, 5:466 47, 985. [5] M. Overmars, M. Kartz, an M. Sharir. Efficient hien surface removal for objects with small union size. Computational Geometry : Theory an Application, : 4, 99. [6] M. Overmars an M. Sharir. Output-sensitive hien-surface removal. roc. 0th IEEE Symp. on Founations of Computer Science, pages , 989. [7] M. H. Overmars an J. Leeuwen. Maintenance of configuration in the plane. Journal of Comput. an System Sciences, :66 04, 98. [8] F. reparata an J. Vitter. A simplifie technique for hienline elimination in terrains. roc. of STACS, 99. [9] J. Reif an S. Sen. An efficient output-sensitive hiensurface removal algorithm an its parallelization. roc. of 4th annual symposium on computational geometry, pages 9 00, 988. [0] J. Reif an S. Sen. An efficient output-sensitive hiensurface removal algorithm for polyheral terrains. Mathematical Computing Moelling, (5):89 04, 995. [] J. H. Reif. Synthesis of arallel Algorithms. Morgan Kaufmann, San Mateo, California, 99. [] A. Schmitt. Time an space bouns for hien-line an hien-surface elimination algorithms. EUROGRAHICS, pages 4 56, 98. [] Y. Shiloach an U. Vishkin. Fining the maimum, merging an sorting in a parallel computation moel. Journal of algorithms, ():88 0, 98. [4] R. F. Sproull, I. E. Sutherlan, an R. A. Schumacker. A characterization of ten hien-surface algorithms. Computing Surveys, 6(): 5, 974. [5] R. Tamassia an J. S. Vitter. Optimal parallel algorithms for transitive closure an point location in planar structures. roceeings of ACM Symposium on arallel Algorithm an Architectures, pages , 989. Figure. 4 Conve chain corresponing to Conve chain corresponing to Conve chain corresponing to