- Email: [email protected]
Hidden-line rendering with a dynamic P-buffer
Computers & Graphics 24 (2000) 443}451
Technical Section
Hidden-line rendering with a dynamic P-bu!er Xiaobu Yuan*, Xiaomin Dong Department of Computer Science, Memorial University of Newfoundland, St. John's, Nyd, Canada A1B 3X5
Abstract This paper introduces a continuous research work on the P-bu!er algorithm presented in Yuan and Sun (Computers & Graphics, 1997; 21(3): 359}66). The original paper discussed the idea of rendering in image space hidden lines into dashed lines with a screen-aligned pattern. Further experiments and applications con"rmed the di$culty of designing a universal static pattern to handle di!erent lines that may come from a huge variety of object shapes in practice. To solve the problem, this paper investigates the design of a dynamic "ltering pattern and its generalizations. This improvement results in a modi"ed P-bu!er algorithm that is capable of rendering hidden lines into dot, dash, or dotted}dash lines with evenly spaced or adjustable lengths. 2000 Elsevier Science Ltd. All rights reserved. Keywords: P-bu!er algorithms; Hidden-line rendering; Time-critical rendering; Dynamic pattern design; C## pseudocode
1. Introduction Pictures provide a highly leveraged means of communication. Scienti"c visualization, as a typical example, presents large collections of numerical values in forms of computer-rendered pictures. Human vision then allows a user to exercise his creative and analytic capabilities and to capture the information contained within the data sets. Moreover, pictures connect users to computer-synthesized worlds, allowing them to directly manipulate graphics models. For instance, in the designing phase of computer-aided design (CAD) numerical values, such as the scaling or rotating of a cube, can be speci"ed by dragging a corner vertex with an electronic mouse, instead of typing through a keyboard. Pictorial presentation of computerized information promotes visual perception and thus makes human}computer interaction easier. Computer-rendered pictures can be either shaded or line drawing pictures that present information at di!erent levels of photo-realism [1]. When the objects in a picture are all polyhedrons, Phong shading is an e$cient technique for rendering shaded pictures. It deter-
* Corresponding author. Tel.: #1-709-737-3207; fax: #1709-737-2009. E-mail address: [email protected] (X. Yuan)
mines the illumination of each pixel on the visible polygonal surfaces by checking its surface normal and its relationship with lighting and viewing directions. Computing illumination with interpolated surface normal also smoothes approximated facets into curved surfaces. Moreover, ray tracing on accurate object models produces the most realistic pictures, but its huge demand of computational power makes it impractical in real-time applications [2]. Despite the high quality of shaded pictures, they su!er from longer rendering time and provide less knowledge of object structures than line drawing pictures. Rendering shaded pictures is therefore not as information e$cient as rendering line drawing pictures in interactive applications whose fundamental purpose of picture rendering is to convey the exact shape and dimensions of objects [3,4]. In comparison, line drawing pictures are clear and concise. They may have hidden lines removed from the pictures, as a shaded picture does; and more importantly, they can include hidden lines to provide information about the hidden surfaces, which is usually not available with shading techniques. The pictures in Figs. 1 and 2 show, in line drawing, a set of machinery parts of a door guide. It includes a pin, a bushing, a wheel, a bracket, and a taper pin. These two pictures demonstrate the basic advantages and disadvantages of rendering with or without hidden lines. When rendered without hidden lines, the neat picture of Fig. 1
0097-8493/00/$ - see front matter 2000 Elsevier Science Ltd. All rights reserved. PII: S 0 0 9 7 - 8 4 9 3 ( 0 0 ) 0 0 0 3 9 - X
444
X. Yuan, X. Dong / Computers & Graphics 24 (2000) 443}451
Fig. 1. A line drawing without hidden lines.
Fig. 2. A line drawing with solid hidden lines.
contains enough information to tell the shape of each of the objects, their relative size, and their spatial relationships. By simply looking at Fig. 1, however, it is neither sure if all the holes run through the objects nor certain about what the structures look like on the invisible side. These hidden surfaces therefore become inaccessible for direct object manipulation during human}computer interaction. Making hidden lines visible is a natural way of revealing the concealed information. Fig. 2, as an example, provides the information about object structures by adding hidden lines to Fig. 1. Unfortunately, the presence of hidden lines as solid lines also demolishes the clue of front}back association of the objects themselves and the dimensional relationship between them. The problem is a result of using the same line style for both the visible and invisible lines, which makes them visually indistinguishable [1]. This example shows the necessity of not only rendering hidden lines but also in a style di!erent from the visible lines. There are two groups of algorithms for hidden line rendering. They are object space algorithms and image space algorithms [5]. Algorithms in the "rst group determine line segments and their visibility by intersecting projected surface boundaries and evaluating their orders in depth. This group of algorithms can render hidden lines in any style provided there is a closed-form solution between the front and back surfaces [6]. Due to the
computational complexity of surface intersection, line drawing algorithms working in object space usually process polygonal surfaces and, in rare cases, quadric surfaces [7,8]. More recent research work in this group can be found in [9]. Image space algorithms, on the other hand, have the favorable capability of handling a wide range of object shapes. Instead of conducting the time-consuming calculation on surface intersections, the traditional imagespace Z-bu!er algorithm uses the values in a depth bu!er to determine the surfaces closest to the viewer [10]. Meanwhile, a frame bu!er allows the front surfaces to write over those in the behind and thus produces pictures of visible surfaces only. In addition to the improvements of processing speed and anti-aliasing provided by Carpenter [11], Myers [12] and Warnock [13], a modi"cation introduced by the P-bu!er algorithm discloses the hidden information [14]. It uses a binary pattern to break hidden lines and display them di!erently from the solid lines of visible surfaces. Line drawing algorithms working in image space are suitable in time-critical applications such as human} computer interaction. They can not only process complicated object shapes but also render hidden lines in a di!erent style with much less time. However, one of the noticeable drawbacks of rendering hidden lines in image space is that the hidden lines rendered with the P-bu!er algorithm are not evenly spaced, as opposed to what object space algorithms can produce. It is a de"ciency of the P-bu!er algorithm caused by its attempt of dashing hidden lines with a single static pattern that remains the same and supposedly works with all pictures. As an improvement to the P-bu!er algorithm, this paper revises the static "ltering pattern into a dynamic pattern whose `contentsa change according to the picture to render. The use of such a dynamic pattern results in a modi"ed P-bu!er algorithm that can render hidden lines into dotted lines. Further generalization of this pattern subsequently allows the rendering of hidden lines in forms of dashed lines, dotted}dash lines, or in any other styles with evenly spaced or adjustable lengths. Experiment results demonstrate that the modi"ed Pbu!er algorithm is capable of producing hidden lines in di!erent styles, with high quality, and at a speed close to the traditional Z-bu!er algorithm.
2. A dynamic pattern for dotted hidden lines In a line drawing picture, all its pixels either are on boundary edges or fall into the background. Both the visible and invisible lines are projections of surface boundaries from three-dimensional objects to twodimensional pictures. The basic operation of computer graphics generates boundary lines with connected pixels. There is, however, no di!erence between visible and
X. Yuan, X. Dong / Computers & Graphics 24 (2000) 443}451
445
Fig. 3. Bitmaps without/with distinguishable hidden points.
hidden lines at their original formation from object models. As a result, using the conventional way of drawing background and edge pixels, a picture that shows a curve segment blocked by a rectangular surface may simply look like Fig. 3(a). The "rst step of rendering hidden lines is therefore to distinguish them from visible lines. Between the two bu!ers in the Z-bu!er algorithm, the depth bu!er is unchangeable because its elements contain the depth information that is vital to tell the front}back relationship of surfaces. On the other hand, the content of the frame bu!er, which consists of pixels initialized to the background color, will not be of any use until the scan line updates all the elements. Therefore, the modi"ed P-bu!er algorithm (appendix) reuses the frame bu!er to keep track of the hidden lines before setting its elements to the desired picture. The algorithm accomplishes the usual work of initialization in the "rst block of its class constructor `P}Buffer(.)a, i.e., to set the two bu!ers with background colors and values. The second block then updates the elements of the two bu!ers by processing one by one all the objects in a scene. In this block, the function `Pixel}Determine(.)a returns the depth `za of an object surface at pixel(x, y) and indicates with #ag `boundarya if it is an edge point. If `za is closer than the value currently kept in `depth}buffer[x][y]a, it becomes the new value of this element. Meanwhile, `frame}buffer[x][y]a changes from `0a to either `1a or `3a to register an edge point when `boundarya is `truea. Whenever the new depth `za indicates a front surface point, `frame}buffer[x][y]a changes to `1a if this point is also an edge point because it is an edge point currently in the front. Otherwise, the frame bu!er ele-
ment changes to `3a if its current value is `1a due to the fact that this edge point turns to invisible as there is a new surface point in front of it. If the `za value, on the other hand, indicates an edge point in the back, `frame}buffer[x][y]a changes to `3a to mark a hidden edge point. In such a way, the second block of the constructor sets the frame bu!er with distinguishable edge points. The result of this process is, assuming `1a stands for a black point and `3a gray, a picture as Fig. 3(b). With invisible edge points identi"ed, it becomes a straightforward process to dot hidden lines. The function `edges}Dotted( )a scans through the entire picture processing all the pixels marked with `3a. At the "rst appearance of hidden edge points along the scan line, `frame}buffer[x][y]a changes to `1a to mark a black dot. Meanwhile, all its unprocessed neighbors becomes white (`0a), which makes a one-dot space around the black dot. There is however one exception, i.e., black (`1a) neighbors keep their value because they belong to visible lines and visible lines are always black. This function then continues processing the next hidden edge points until the scan line reaches to the end. At this time, the picture stored in the frame bu!er is ready for display. Fig. 4(a) illustrates the running of the dotting function on Fig. 3(b). When the scan line runs from top to bottom and from left to right, the "rst encountered hidden edge point is point `1a. According to the function, the "rst action is to change the value from `3a to `1a, and then sets the neighbors to `0a, which are the pixels `2a and `3a. In a similar manner, pixels `4a, `6a, `10a, 2, and `34a turn to black and their neighbor pixels `5a, `7a, `8a, `9a, `11a, 2, and `33a turn white. In particular, when the scan line reaches to pixel `20a, its left pixel is not under consideration as it is a processed pixel. As for pixel
446
X. Yuan, X. Dong / Computers & Graphics 24 (2000) 443}451
Fig. 4. Bitmaps with dotted hidden points.
`21a, it cannot be switched to `0a because this is a visible edge point. The same discussion applies to pixels `35a, `36a, and `37a. Fig. 4(a) is a perfect line drawing picture that shows black visible lines and evenly dotted hidden lines. Depending on the length of hidden line segments and their shapes, some dots may not be as evenly spaced as what Fig. 4(a) presents. For example, a `Ua-shape curve segment may have two white spaces between two black dots at its bottom. As shown in Fig. 4(b), the `Ua-shape curve segment at the top left has evenly spaced dots and blank spaces. However, the one at the lower right has two blank spaces (white pixels `13a and `17a between black pixels `12a and `16a). The di!erence between the two shapes is that one has an odd number of pixels and the other even number. The even segment has to have a space at its end (pixel `17a), which connects with pixel `13a and hence makes an extra space. This will not be a problem if the dotting process follows the hidden lines instead of using the scan line. In addition, on a display of high resolution, dotted lines may simply appear to be gray lines since human eyes cannot tell apart single pixels. Therefore, there is a need to generalize the algorithm and make it possible to render hidden lines in other styles, such as dash lines, dotted}dash lines, or any other desired length and spacing of black segments. The next section of this paper discusses how to further improve the performance of the P-bu!er algorithm.
3. Generalizations for dash lines and other styles Dash lines di!er from dot lines in the length of black and white (spacing) segments. Similar to dotting hidden
lines, the rendering of dash lines also requires identi"able hidden line pixels. Therefore, there is also a need of registering di!erent types of pixels. As the pixel types are still visible, invisible, and background, the registration process of dash lines can simply reuse the process of dot lines. In the modi"ed P-bu!er algorithm (appendix), the constructor `P}Buffer(.)a is good enough to do the work for both the dotted and dashed hidden lines. After receiving a length from the calling function, function `edges}Dashed(.)a uses two loops to go through all the pixels in a picture. At each of the hidden line pixels (marked with `3a), the rendering function calls a recursive tracing function `edges}Trace(.)a to alternatively produce dashes and spaces while tracking down hidden lines. While the tracing function does the actual rendering, the rendering function eliminates the possibility of missing any hidden lines after each individual tracing. The result is a picture of dashed hidden lines at the completion of the two loops of `edges}Dashed(.)a. Illustrated in Fig. 5(a) is an example that shows the procedure of tracing a hidden line (Fig. 3(b)). When the rendering function `edges}Dashed (.)a encounters the "rst hidden pixel `1aa, it passes the index of this pixel to the tracing function `edges}Trace(.)a. Meanwhile, it tells the tracing function to start with a black dash whose current length is one. The tracer, in turn, "rst sets the indexed frame-bu!er element to the speci"ed color. Since the next pixel increases the dash length by one, the tracing function then checks if this length is longer than the speci"ed length. If so, it switches the color and starts a new dash. Among the eight neighbors of pixel `1aa, only pixels `1ba and `1ca are hidden line points. The trace from pixel
X. Yuan, X. Dong / Computers & Graphics 24 (2000) 443}451
447
Fig. 5. Bitmaps with dashed hidden points.
`1ba stops right after it starts because none of its neighboring pixels are hidden line points (`1aa was, but its value changed to `1a before processing `1ba). When the trace extends from pixel `1ca to pixel `2aa, the dash length adds up to four, which is larger than, presumably, an allowable dash length `3a. Consequently, the dash color changes to white and the dash length resets to one. At the intersection of the curve segment at pixel `2ca, the trace turns to pixel `3aa simply by the choice of order for processing neighboring pixels. A change of the processing order may change the tracing direction, but the rendering style remains unchanged. After four black dashes and three white (spacing) dashes, this branch rejoins the intersection with pixel `10ba. Due to the fact that the processed hidden line points have surrendered their original value as hidden points, the trace goes automatically to the direction of pixel `10ca. Finally, this trace stops at pixel `11ca as there are no more hidden line points connected to it. This generalization allows the P-bu!er algorithm to render hidden lines into dashed lines. The fundamental idea is to switch the color, while tracing hidden edge points, when a dash reaches to a "xed length. If the length is also #exible, this idea can be easily extended to render hidden lines of any desired styles. The pseudo-code in the appendix has several commentary lines listed between `/*a and `*/a. By substituting the underneath lines with those commentary lines and adding those ended with `*;*/a, the rendering function `edges}Dashed(.)a becomes a new function `edges}Flexible(.)a. The new rendering function takes in two parameters that specify a line style with a pattern array. For a dotted}dash line, as an example, the pattern given by `dash}lengths[ ]a is `+3, 1, 1, 1,a and the number of
elements `dash}numbera is `4a. Due to the extra information, the new tracing function `edges}Trace(.)a has one more parameter that indicates the index of the current segment. Whenever the indexed segment is longer than its allowable length, the function needs not only to alter the length and color but also to reset the index. Except for this modi"cation, the rest of the tracing function does not need any change. Running function `edges}Flexible(.)a in Fig. 3(b) produces Fig. 5(b). Between Figs. 5(a) and (b), there is no di!erence in the order of traced hidden points. The changed black segments and white (spacing) dots are a re#ection of the changed line style. In fact, the methods that produce dotted and dashed lines are special cases of the one that produces #exible line styles. In other words, the method of rendering hidden lines in #exible styles de"nes a universal dynamic pattern that can handle di!erent hidden lines and render them in di!erent line styles.
4. Experiments and discussion The new method has been implemented in the C## programming language and tested with a variety of different objects. Shown in Figs. 6}8, are the results of rendering curved hidden lines in dot, dash, and dotted dash lines. Experiments with other objects of only planar surfaces were also conducted to test the speed performance of the modi"ed P-bu!er algorithm and to compare it with the other algorithms. In principle, the complexity of hidden-line algorithms depends on the number of objects to process and the size of pictures to produce. As listed in Table 1, object}space algorithms
448
X. Yuan, X. Dong / Computers & Graphics 24 (2000) 443}451
Fig. 6. Line drawing with dotted hidden lines.
Fig. 7. Line drawing with dashed hidden lines.
Fig. 8. Line drawing with dotted}dash lines.
X. Yuan, X. Dong / Computers & Graphics 24 (2000) 443}451 Table 1 Complexity comparison of hidden-line algorithms
Image}space algorithms Object}space algorithms
449
Table 3 Comparison with some other hidden-line algorithms
Input size
Output size
Lower bound
Upper bound
n
image
)(n)
O(n)
n
O(n)
)(n)
O(n log n)
have a complexity in the range of O(n) and O(n log n), where n is the number of objects [15]. In comparison, the complexity of image}space algorithms has a linear relationship with n. The modi"ed P-bu!er algorithm uses several more conditional and assignment statements than the Z-bu!er algorithm in its process of checking boundary pixels and dotting or dashing hidden lines. The number of extra operations depends on the number of boundary pixels, which in most applications is much smaller than the total number of pixels in a picture. It has yet nothing to do with the complexity of a scene such as the number, shape, size, and position or orientation of objects. The added operations therefore need far less computation than the other required operations do, such as to retrieve the pixels in image}space algorithms or to "nd object intersections in object}space algorithms. Though in theory most pixels are reachable from di!erent directions, the recursive process stops at any processed pixel. Besides, the additional operations do not increase the level of computation complexity as they perform simpler processing and on fewer pixels. To "t into the existing comparison in literature, a second group of experiments was on a set of polygonal objects with the same and/or di!erent number of vertices and polygons. The result shows that in all the cases the modi"ed Pbu!er algorithm has a performance close to the Z-bu!er algorithm (Table 2). In addition, from the converted "gures in Table 3, it is clear that the modi"ed P-bu!er algorithm has a lower complexity than the other algorithms listed in [16].
Algorithms
Performance ratio
Ray tracing Warnock Spanning scan line Scan-line Z-bu!er Dashed lines Dotted lines Z-bu!er
9.2 6.2 2.1 1.9 1.2 1.05 1
5. Conclusion Hidden-line rendering is di!erent from hidden-line removal because it requires not only to render solid visible lines but also to display invisible line in di!erent styles. While ordinary image}space algorithms are actually hidden-line removal algorithms that cannot provide information of hidden surfaces, object}space algorithms, though having the capability of rendering hidden lines in any style, have limits on processable object shapes. The modi"ed P-bu!er algorithm works in image space. It can produce solid visible lines as dotted or (adjustable) dashed hidden lines. Experiments demonstrate that it has a low computational complexity as well. This improvement makes the P-bu!er algorithm a useful tool in timecritical applications. Continuous research is being conducted to investigate its application in practice and its further improvements.
Acknowledgements Thanks are due to the National Science and Engineering Research Council of Canada (NSERC) for funding the research and to Faculty members and students in the Departments of Computer Science and Mathematics and Statistics for their discussions.
Table 2 Experiment with polygonal objects 227 vertices
Z-bu!er Dotted lines Dashed lines
388 vertices
221 polygons
332 polygons
198 polygons
612 polygons
2.0 2.1 2.4
2.2 2.3 2.5
3.8 3.9 4.2
4.1 4.2 4.7
450
X. Yuan, X. Dong / Computers & Graphics 24 (2000) 443}451
Appendix. The modi5ed P-bu4er algorithm // dexnes the eight neighbors clockwise starting from the left neighbor int neighbors [8,2] "+!1, 0, 0,!1, 1, 0, 0, 1,!1,!1, 1,!1, 1, 1,!1, 1,; Class P}Bu!er + public: // This is a constructor that prepares for the frame buwer. P}Bu!er(int image}height, int image}width, OBJECT *object}list) + double z, **depth}bu!er; short value, boundary, closer; OBJECT object; width"image}width; height"image}height; frame}bu!er"new short[width][height]; depth}bu!er"new double[width][height]; for (y"0; y ( image}height; y##) for (x"0; x( image}width; x##) depth}bu!er[x][y]"frame}bu!er[x][y]"0;
,
// This block renders the visible lines and prepares for the invisible. while (Object}Retrieve(object}list, & object)) while (Pixel}Determine(object, & y, & x, & z, & boundary)) + closer"(z* depth}bu!er[x][y])? 1 : 0; if (closer) depth}bu!er[x][y]"z; if (boundary) frame}bu!er[x][y]"(closer) ? 1 : 3; else if (frame}bu!er[x][y]""1) frame}bu!er[x][y]"3;
short** edges}Dotted( )+ for (y"0; y( height; y ##) for (x"0; x( width; x ##) if (frame}bu!er[x][y]"" 3) + picture}bu!er[x][y]" 1; if (frame}bu!er[i#1][ j]""3) frame}bu!er[i#1][ j]"0; if (frame}bu!er[i][ j#1]""3) frame}bu!er[i][ j#1]"0; if (frame}bu!er[i!1][ j#1]""3) frame}bu!er[i!1][ j#1]"0; if (frame}bu!er[i#1][ j#1]""3) frame}bu!er[i#1][ j#1]"0; , return frame}bu!er; , /*short** edges+Flexible(short dash+number, short *dash+lengths) + short** edges}Dashed(short dash}length) + /* d}number"dash}number!1; /* d}lengths"new short[d}number]; /* for (k"0; k(dash}number; k;;)d}lengths[k]"dash}lengths[k]; length"dash}length; for (y"0; y ( height; y ##) for (x"0; x ( width; x ##) if (frame}bu!er[x][y]""3) /* edges}Trace(x, y, 1, 1, 0); edges}Trace(x, y, 1, 1); return frame}bu!er; ,
// initialize the buwers
// process each object
// // // //
update depth buwer add an edge point reset to invisible end of P}Buwer(.)
// xnd a hidden point // blacken this point // whiten the neighbors
// send back the picture // end of edges}Dotted( ) */ *#*/ *#*/ */
// xnd a hidden point */ // trace hidden lines // send back the picture
X. Yuan, X. Dong / Computers & Graphics 24 (2000) 443}451
private: int x, y, i, j, k, width, height; short value, **frame}bu!er, length; /*short d}number, *d}lengths; /*edges}Trace(int i, int j, short distance, short color, short index) edges}Trace(int i, int j, short distance, short color) + frame}bu!er[i][ j]"color; /* if (;;distance ' d}lengths[index]) + if (##distance ' length)+ /* if (;;index 'd}number) index"0; distance"1; color"(color""1) ? 0 : 1; ,
/*
,
,
for (k"0; k(8; k##) + i"x#neighbors[k][0]; j"y#neighbors[k][1]; if (frame}bu!er[i][ j]""3) edges}Trace(i, j, distance, color, index); edges}Trace(i, j, distance, color); ,
References [1] Foley J, Van Dam A, Feiner S, Hughes J. Computer graphics: principles and practice, 2nd (in C) ed. Reading, MA: Addison-Wesley, 1996. [2] Glassner A, editor. An introduction to ray tracing. London: Academic Press, 1989. [3] Barrow H, Tenebaum J. Interpreting line drawing as three-dimensional surfaces. Arti"cial Intelligence 1981;17(1}3):75}116. [4] Freeman H. Computer processing of line-drawing images. ACM Computing Surveys 1974;6(1):57}97. [5] Sutherland I, Sproul R, Schumacker R. A characterization of ten hidden-surface algorithms. ACM Computing Surveys 1974;6(1):1}55. [6] Dooley D, Cohen M. Automatic illustration of 3D geometric models: Lines. Computer Graphics (1990 Symposium on Interactive 3D Graphics) 1990;24(2):77}82. [7] Liu Y, Zsombormurray P. Intersection curves between quadric surfaces of revolution. Transactions of the Canadian Society for Mechanical Engineering 1995; 19(4):435}53. [8] Miller J, Goldman R. Geometric algorithms for detecting and calculating all conic sections in the intersection of any 2 natural quadric surfaces. Graphical Models and Image Processing 1995;57(1):55}66.
451
*#*/ */
*/ *#*/
// process the 8 neighbors
*/ // trace if invisible // end of edges}Trace(.) // end of P}Buwer
[9] Markosian L, Kowalski MA, Trychin SJ, Bourdev LD, Goldstein DD, Hughes JF. Real-time nonphotorealistic rendering. In: Whitted T, editor. SIGGRAPH '97 Conference Proceedings, August 1997. p. 415}20. [10] Catmull E. A subdivision algorithm for computer display of curved splines. Ph.D. thesis, Computer Science Department, University of Utah, Salt Lake City, UT 1974. [11] Carpenter L. The A-bu!er: an antialiased hidden surface method. In: Proceedings of SIGGRAPH '84 in Computer Graphics, vol. 18, 1984. p. 103}8. [12] Myers A. An e$cient visible surface program. Report to the national science foundation, Computer Graphics Research Group, Ohio State University, Columbus, OH, July 1975. [13] Warnock J. a hidden-surface algorithm for computer generated half-tone pictures. Technical Report TR 4-15 NTIS AD 753 671, Computer Science Department, University of Utah, Salt Lake City, UT, June 1969. [14] Yuan X, Sun H. P-bu!er: a hidden-line algorithm in image-space. Computers & Graphics 1997;21(3): 359}66. [15] Fiume E. The mathematical structure of raster graphics. San Diego, CA: Academic Press, 1989. [16] Rogers D. Procedural elements for computer graphics. New York: McGraw-Hill, 1985.
Technical Section
Hidden-line rendering with a dynamic P-bu!er Xiaobu Yuan*, Xiaomin Dong Department of Computer Science, Memorial University of Newfoundland, St. John's, Nyd, Canada A1B 3X5
Abstract This paper introduces a continuous research work on the P-bu!er algorithm presented in Yuan and Sun (Computers & Graphics, 1997; 21(3): 359}66). The original paper discussed the idea of rendering in image space hidden lines into dashed lines with a screen-aligned pattern. Further experiments and applications con"rmed the di$culty of designing a universal static pattern to handle di!erent lines that may come from a huge variety of object shapes in practice. To solve the problem, this paper investigates the design of a dynamic "ltering pattern and its generalizations. This improvement results in a modi"ed P-bu!er algorithm that is capable of rendering hidden lines into dot, dash, or dotted}dash lines with evenly spaced or adjustable lengths. 2000 Elsevier Science Ltd. All rights reserved. Keywords: P-bu!er algorithms; Hidden-line rendering; Time-critical rendering; Dynamic pattern design; C## pseudocode
1. Introduction Pictures provide a highly leveraged means of communication. Scienti"c visualization, as a typical example, presents large collections of numerical values in forms of computer-rendered pictures. Human vision then allows a user to exercise his creative and analytic capabilities and to capture the information contained within the data sets. Moreover, pictures connect users to computer-synthesized worlds, allowing them to directly manipulate graphics models. For instance, in the designing phase of computer-aided design (CAD) numerical values, such as the scaling or rotating of a cube, can be speci"ed by dragging a corner vertex with an electronic mouse, instead of typing through a keyboard. Pictorial presentation of computerized information promotes visual perception and thus makes human}computer interaction easier. Computer-rendered pictures can be either shaded or line drawing pictures that present information at di!erent levels of photo-realism [1]. When the objects in a picture are all polyhedrons, Phong shading is an e$cient technique for rendering shaded pictures. It deter-
* Corresponding author. Tel.: #1-709-737-3207; fax: #1709-737-2009. E-mail address: [email protected] (X. Yuan)
mines the illumination of each pixel on the visible polygonal surfaces by checking its surface normal and its relationship with lighting and viewing directions. Computing illumination with interpolated surface normal also smoothes approximated facets into curved surfaces. Moreover, ray tracing on accurate object models produces the most realistic pictures, but its huge demand of computational power makes it impractical in real-time applications [2]. Despite the high quality of shaded pictures, they su!er from longer rendering time and provide less knowledge of object structures than line drawing pictures. Rendering shaded pictures is therefore not as information e$cient as rendering line drawing pictures in interactive applications whose fundamental purpose of picture rendering is to convey the exact shape and dimensions of objects [3,4]. In comparison, line drawing pictures are clear and concise. They may have hidden lines removed from the pictures, as a shaded picture does; and more importantly, they can include hidden lines to provide information about the hidden surfaces, which is usually not available with shading techniques. The pictures in Figs. 1 and 2 show, in line drawing, a set of machinery parts of a door guide. It includes a pin, a bushing, a wheel, a bracket, and a taper pin. These two pictures demonstrate the basic advantages and disadvantages of rendering with or without hidden lines. When rendered without hidden lines, the neat picture of Fig. 1
0097-8493/00/$ - see front matter 2000 Elsevier Science Ltd. All rights reserved. PII: S 0 0 9 7 - 8 4 9 3 ( 0 0 ) 0 0 0 3 9 - X
444
X. Yuan, X. Dong / Computers & Graphics 24 (2000) 443}451
Fig. 1. A line drawing without hidden lines.
Fig. 2. A line drawing with solid hidden lines.
contains enough information to tell the shape of each of the objects, their relative size, and their spatial relationships. By simply looking at Fig. 1, however, it is neither sure if all the holes run through the objects nor certain about what the structures look like on the invisible side. These hidden surfaces therefore become inaccessible for direct object manipulation during human}computer interaction. Making hidden lines visible is a natural way of revealing the concealed information. Fig. 2, as an example, provides the information about object structures by adding hidden lines to Fig. 1. Unfortunately, the presence of hidden lines as solid lines also demolishes the clue of front}back association of the objects themselves and the dimensional relationship between them. The problem is a result of using the same line style for both the visible and invisible lines, which makes them visually indistinguishable [1]. This example shows the necessity of not only rendering hidden lines but also in a style di!erent from the visible lines. There are two groups of algorithms for hidden line rendering. They are object space algorithms and image space algorithms [5]. Algorithms in the "rst group determine line segments and their visibility by intersecting projected surface boundaries and evaluating their orders in depth. This group of algorithms can render hidden lines in any style provided there is a closed-form solution between the front and back surfaces [6]. Due to the
computational complexity of surface intersection, line drawing algorithms working in object space usually process polygonal surfaces and, in rare cases, quadric surfaces [7,8]. More recent research work in this group can be found in [9]. Image space algorithms, on the other hand, have the favorable capability of handling a wide range of object shapes. Instead of conducting the time-consuming calculation on surface intersections, the traditional imagespace Z-bu!er algorithm uses the values in a depth bu!er to determine the surfaces closest to the viewer [10]. Meanwhile, a frame bu!er allows the front surfaces to write over those in the behind and thus produces pictures of visible surfaces only. In addition to the improvements of processing speed and anti-aliasing provided by Carpenter [11], Myers [12] and Warnock [13], a modi"cation introduced by the P-bu!er algorithm discloses the hidden information [14]. It uses a binary pattern to break hidden lines and display them di!erently from the solid lines of visible surfaces. Line drawing algorithms working in image space are suitable in time-critical applications such as human} computer interaction. They can not only process complicated object shapes but also render hidden lines in a di!erent style with much less time. However, one of the noticeable drawbacks of rendering hidden lines in image space is that the hidden lines rendered with the P-bu!er algorithm are not evenly spaced, as opposed to what object space algorithms can produce. It is a de"ciency of the P-bu!er algorithm caused by its attempt of dashing hidden lines with a single static pattern that remains the same and supposedly works with all pictures. As an improvement to the P-bu!er algorithm, this paper revises the static "ltering pattern into a dynamic pattern whose `contentsa change according to the picture to render. The use of such a dynamic pattern results in a modi"ed P-bu!er algorithm that can render hidden lines into dotted lines. Further generalization of this pattern subsequently allows the rendering of hidden lines in forms of dashed lines, dotted}dash lines, or in any other styles with evenly spaced or adjustable lengths. Experiment results demonstrate that the modi"ed Pbu!er algorithm is capable of producing hidden lines in di!erent styles, with high quality, and at a speed close to the traditional Z-bu!er algorithm.
2. A dynamic pattern for dotted hidden lines In a line drawing picture, all its pixels either are on boundary edges or fall into the background. Both the visible and invisible lines are projections of surface boundaries from three-dimensional objects to twodimensional pictures. The basic operation of computer graphics generates boundary lines with connected pixels. There is, however, no di!erence between visible and
X. Yuan, X. Dong / Computers & Graphics 24 (2000) 443}451
445
Fig. 3. Bitmaps without/with distinguishable hidden points.
hidden lines at their original formation from object models. As a result, using the conventional way of drawing background and edge pixels, a picture that shows a curve segment blocked by a rectangular surface may simply look like Fig. 3(a). The "rst step of rendering hidden lines is therefore to distinguish them from visible lines. Between the two bu!ers in the Z-bu!er algorithm, the depth bu!er is unchangeable because its elements contain the depth information that is vital to tell the front}back relationship of surfaces. On the other hand, the content of the frame bu!er, which consists of pixels initialized to the background color, will not be of any use until the scan line updates all the elements. Therefore, the modi"ed P-bu!er algorithm (appendix) reuses the frame bu!er to keep track of the hidden lines before setting its elements to the desired picture. The algorithm accomplishes the usual work of initialization in the "rst block of its class constructor `P}Buffer(.)a, i.e., to set the two bu!ers with background colors and values. The second block then updates the elements of the two bu!ers by processing one by one all the objects in a scene. In this block, the function `Pixel}Determine(.)a returns the depth `za of an object surface at pixel(x, y) and indicates with #ag `boundarya if it is an edge point. If `za is closer than the value currently kept in `depth}buffer[x][y]a, it becomes the new value of this element. Meanwhile, `frame}buffer[x][y]a changes from `0a to either `1a or `3a to register an edge point when `boundarya is `truea. Whenever the new depth `za indicates a front surface point, `frame}buffer[x][y]a changes to `1a if this point is also an edge point because it is an edge point currently in the front. Otherwise, the frame bu!er ele-
ment changes to `3a if its current value is `1a due to the fact that this edge point turns to invisible as there is a new surface point in front of it. If the `za value, on the other hand, indicates an edge point in the back, `frame}buffer[x][y]a changes to `3a to mark a hidden edge point. In such a way, the second block of the constructor sets the frame bu!er with distinguishable edge points. The result of this process is, assuming `1a stands for a black point and `3a gray, a picture as Fig. 3(b). With invisible edge points identi"ed, it becomes a straightforward process to dot hidden lines. The function `edges}Dotted( )a scans through the entire picture processing all the pixels marked with `3a. At the "rst appearance of hidden edge points along the scan line, `frame}buffer[x][y]a changes to `1a to mark a black dot. Meanwhile, all its unprocessed neighbors becomes white (`0a), which makes a one-dot space around the black dot. There is however one exception, i.e., black (`1a) neighbors keep their value because they belong to visible lines and visible lines are always black. This function then continues processing the next hidden edge points until the scan line reaches to the end. At this time, the picture stored in the frame bu!er is ready for display. Fig. 4(a) illustrates the running of the dotting function on Fig. 3(b). When the scan line runs from top to bottom and from left to right, the "rst encountered hidden edge point is point `1a. According to the function, the "rst action is to change the value from `3a to `1a, and then sets the neighbors to `0a, which are the pixels `2a and `3a. In a similar manner, pixels `4a, `6a, `10a, 2, and `34a turn to black and their neighbor pixels `5a, `7a, `8a, `9a, `11a, 2, and `33a turn white. In particular, when the scan line reaches to pixel `20a, its left pixel is not under consideration as it is a processed pixel. As for pixel
446
X. Yuan, X. Dong / Computers & Graphics 24 (2000) 443}451
Fig. 4. Bitmaps with dotted hidden points.
`21a, it cannot be switched to `0a because this is a visible edge point. The same discussion applies to pixels `35a, `36a, and `37a. Fig. 4(a) is a perfect line drawing picture that shows black visible lines and evenly dotted hidden lines. Depending on the length of hidden line segments and their shapes, some dots may not be as evenly spaced as what Fig. 4(a) presents. For example, a `Ua-shape curve segment may have two white spaces between two black dots at its bottom. As shown in Fig. 4(b), the `Ua-shape curve segment at the top left has evenly spaced dots and blank spaces. However, the one at the lower right has two blank spaces (white pixels `13a and `17a between black pixels `12a and `16a). The di!erence between the two shapes is that one has an odd number of pixels and the other even number. The even segment has to have a space at its end (pixel `17a), which connects with pixel `13a and hence makes an extra space. This will not be a problem if the dotting process follows the hidden lines instead of using the scan line. In addition, on a display of high resolution, dotted lines may simply appear to be gray lines since human eyes cannot tell apart single pixels. Therefore, there is a need to generalize the algorithm and make it possible to render hidden lines in other styles, such as dash lines, dotted}dash lines, or any other desired length and spacing of black segments. The next section of this paper discusses how to further improve the performance of the P-bu!er algorithm.
3. Generalizations for dash lines and other styles Dash lines di!er from dot lines in the length of black and white (spacing) segments. Similar to dotting hidden
lines, the rendering of dash lines also requires identi"able hidden line pixels. Therefore, there is also a need of registering di!erent types of pixels. As the pixel types are still visible, invisible, and background, the registration process of dash lines can simply reuse the process of dot lines. In the modi"ed P-bu!er algorithm (appendix), the constructor `P}Buffer(.)a is good enough to do the work for both the dotted and dashed hidden lines. After receiving a length from the calling function, function `edges}Dashed(.)a uses two loops to go through all the pixels in a picture. At each of the hidden line pixels (marked with `3a), the rendering function calls a recursive tracing function `edges}Trace(.)a to alternatively produce dashes and spaces while tracking down hidden lines. While the tracing function does the actual rendering, the rendering function eliminates the possibility of missing any hidden lines after each individual tracing. The result is a picture of dashed hidden lines at the completion of the two loops of `edges}Dashed(.)a. Illustrated in Fig. 5(a) is an example that shows the procedure of tracing a hidden line (Fig. 3(b)). When the rendering function `edges}Dashed (.)a encounters the "rst hidden pixel `1aa, it passes the index of this pixel to the tracing function `edges}Trace(.)a. Meanwhile, it tells the tracing function to start with a black dash whose current length is one. The tracer, in turn, "rst sets the indexed frame-bu!er element to the speci"ed color. Since the next pixel increases the dash length by one, the tracing function then checks if this length is longer than the speci"ed length. If so, it switches the color and starts a new dash. Among the eight neighbors of pixel `1aa, only pixels `1ba and `1ca are hidden line points. The trace from pixel
X. Yuan, X. Dong / Computers & Graphics 24 (2000) 443}451
447
Fig. 5. Bitmaps with dashed hidden points.
`1ba stops right after it starts because none of its neighboring pixels are hidden line points (`1aa was, but its value changed to `1a before processing `1ba). When the trace extends from pixel `1ca to pixel `2aa, the dash length adds up to four, which is larger than, presumably, an allowable dash length `3a. Consequently, the dash color changes to white and the dash length resets to one. At the intersection of the curve segment at pixel `2ca, the trace turns to pixel `3aa simply by the choice of order for processing neighboring pixels. A change of the processing order may change the tracing direction, but the rendering style remains unchanged. After four black dashes and three white (spacing) dashes, this branch rejoins the intersection with pixel `10ba. Due to the fact that the processed hidden line points have surrendered their original value as hidden points, the trace goes automatically to the direction of pixel `10ca. Finally, this trace stops at pixel `11ca as there are no more hidden line points connected to it. This generalization allows the P-bu!er algorithm to render hidden lines into dashed lines. The fundamental idea is to switch the color, while tracing hidden edge points, when a dash reaches to a "xed length. If the length is also #exible, this idea can be easily extended to render hidden lines of any desired styles. The pseudo-code in the appendix has several commentary lines listed between `/*a and `*/a. By substituting the underneath lines with those commentary lines and adding those ended with `*;*/a, the rendering function `edges}Dashed(.)a becomes a new function `edges}Flexible(.)a. The new rendering function takes in two parameters that specify a line style with a pattern array. For a dotted}dash line, as an example, the pattern given by `dash}lengths[ ]a is `+3, 1, 1, 1,a and the number of
elements `dash}numbera is `4a. Due to the extra information, the new tracing function `edges}Trace(.)a has one more parameter that indicates the index of the current segment. Whenever the indexed segment is longer than its allowable length, the function needs not only to alter the length and color but also to reset the index. Except for this modi"cation, the rest of the tracing function does not need any change. Running function `edges}Flexible(.)a in Fig. 3(b) produces Fig. 5(b). Between Figs. 5(a) and (b), there is no di!erence in the order of traced hidden points. The changed black segments and white (spacing) dots are a re#ection of the changed line style. In fact, the methods that produce dotted and dashed lines are special cases of the one that produces #exible line styles. In other words, the method of rendering hidden lines in #exible styles de"nes a universal dynamic pattern that can handle di!erent hidden lines and render them in di!erent line styles.
4. Experiments and discussion The new method has been implemented in the C## programming language and tested with a variety of different objects. Shown in Figs. 6}8, are the results of rendering curved hidden lines in dot, dash, and dotted dash lines. Experiments with other objects of only planar surfaces were also conducted to test the speed performance of the modi"ed P-bu!er algorithm and to compare it with the other algorithms. In principle, the complexity of hidden-line algorithms depends on the number of objects to process and the size of pictures to produce. As listed in Table 1, object}space algorithms
448
X. Yuan, X. Dong / Computers & Graphics 24 (2000) 443}451
Fig. 6. Line drawing with dotted hidden lines.
Fig. 7. Line drawing with dashed hidden lines.
Fig. 8. Line drawing with dotted}dash lines.
X. Yuan, X. Dong / Computers & Graphics 24 (2000) 443}451 Table 1 Complexity comparison of hidden-line algorithms
Image}space algorithms Object}space algorithms
449
Table 3 Comparison with some other hidden-line algorithms
Input size
Output size
Lower bound
Upper bound
n
image
)(n)
O(n)
n
O(n)
)(n)
O(n log n)
have a complexity in the range of O(n) and O(n log n), where n is the number of objects [15]. In comparison, the complexity of image}space algorithms has a linear relationship with n. The modi"ed P-bu!er algorithm uses several more conditional and assignment statements than the Z-bu!er algorithm in its process of checking boundary pixels and dotting or dashing hidden lines. The number of extra operations depends on the number of boundary pixels, which in most applications is much smaller than the total number of pixels in a picture. It has yet nothing to do with the complexity of a scene such as the number, shape, size, and position or orientation of objects. The added operations therefore need far less computation than the other required operations do, such as to retrieve the pixels in image}space algorithms or to "nd object intersections in object}space algorithms. Though in theory most pixels are reachable from di!erent directions, the recursive process stops at any processed pixel. Besides, the additional operations do not increase the level of computation complexity as they perform simpler processing and on fewer pixels. To "t into the existing comparison in literature, a second group of experiments was on a set of polygonal objects with the same and/or di!erent number of vertices and polygons. The result shows that in all the cases the modi"ed Pbu!er algorithm has a performance close to the Z-bu!er algorithm (Table 2). In addition, from the converted "gures in Table 3, it is clear that the modi"ed P-bu!er algorithm has a lower complexity than the other algorithms listed in [16].
Algorithms
Performance ratio
Ray tracing Warnock Spanning scan line Scan-line Z-bu!er Dashed lines Dotted lines Z-bu!er
9.2 6.2 2.1 1.9 1.2 1.05 1
5. Conclusion Hidden-line rendering is di!erent from hidden-line removal because it requires not only to render solid visible lines but also to display invisible line in di!erent styles. While ordinary image}space algorithms are actually hidden-line removal algorithms that cannot provide information of hidden surfaces, object}space algorithms, though having the capability of rendering hidden lines in any style, have limits on processable object shapes. The modi"ed P-bu!er algorithm works in image space. It can produce solid visible lines as dotted or (adjustable) dashed hidden lines. Experiments demonstrate that it has a low computational complexity as well. This improvement makes the P-bu!er algorithm a useful tool in timecritical applications. Continuous research is being conducted to investigate its application in practice and its further improvements.
Acknowledgements Thanks are due to the National Science and Engineering Research Council of Canada (NSERC) for funding the research and to Faculty members and students in the Departments of Computer Science and Mathematics and Statistics for their discussions.
Table 2 Experiment with polygonal objects 227 vertices
Z-bu!er Dotted lines Dashed lines
388 vertices
221 polygons
332 polygons
198 polygons
612 polygons
2.0 2.1 2.4
2.2 2.3 2.5
3.8 3.9 4.2
4.1 4.2 4.7
450
X. Yuan, X. Dong / Computers & Graphics 24 (2000) 443}451
Appendix. The modi5ed P-bu4er algorithm // dexnes the eight neighbors clockwise starting from the left neighbor int neighbors [8,2] "+!1, 0, 0,!1, 1, 0, 0, 1,!1,!1, 1,!1, 1, 1,!1, 1,; Class P}Bu!er + public: // This is a constructor that prepares for the frame buwer. P}Bu!er(int image}height, int image}width, OBJECT *object}list) + double z, **depth}bu!er; short value, boundary, closer; OBJECT object; width"image}width; height"image}height; frame}bu!er"new short[width][height]; depth}bu!er"new double[width][height]; for (y"0; y ( image}height; y##) for (x"0; x( image}width; x##) depth}bu!er[x][y]"frame}bu!er[x][y]"0;
,
// This block renders the visible lines and prepares for the invisible. while (Object}Retrieve(object}list, & object)) while (Pixel}Determine(object, & y, & x, & z, & boundary)) + closer"(z* depth}bu!er[x][y])? 1 : 0; if (closer) depth}bu!er[x][y]"z; if (boundary) frame}bu!er[x][y]"(closer) ? 1 : 3; else if (frame}bu!er[x][y]""1) frame}bu!er[x][y]"3;
short** edges}Dotted( )+ for (y"0; y( height; y ##) for (x"0; x( width; x ##) if (frame}bu!er[x][y]"" 3) + picture}bu!er[x][y]" 1; if (frame}bu!er[i#1][ j]""3) frame}bu!er[i#1][ j]"0; if (frame}bu!er[i][ j#1]""3) frame}bu!er[i][ j#1]"0; if (frame}bu!er[i!1][ j#1]""3) frame}bu!er[i!1][ j#1]"0; if (frame}bu!er[i#1][ j#1]""3) frame}bu!er[i#1][ j#1]"0; , return frame}bu!er; , /*short** edges+Flexible(short dash+number, short *dash+lengths) + short** edges}Dashed(short dash}length) + /* d}number"dash}number!1; /* d}lengths"new short[d}number]; /* for (k"0; k(dash}number; k;;)d}lengths[k]"dash}lengths[k]; length"dash}length; for (y"0; y ( height; y ##) for (x"0; x ( width; x ##) if (frame}bu!er[x][y]""3) /* edges}Trace(x, y, 1, 1, 0); edges}Trace(x, y, 1, 1); return frame}bu!er; ,
// initialize the buwers
// process each object
// // // //
update depth buwer add an edge point reset to invisible end of P}Buwer(.)
// xnd a hidden point // blacken this point // whiten the neighbors
// send back the picture // end of edges}Dotted( ) */ *#*/ *#*/ */
// xnd a hidden point */ // trace hidden lines // send back the picture
X. Yuan, X. Dong / Computers & Graphics 24 (2000) 443}451
private: int x, y, i, j, k, width, height; short value, **frame}bu!er, length; /*short d}number, *d}lengths; /*edges}Trace(int i, int j, short distance, short color, short index) edges}Trace(int i, int j, short distance, short color) + frame}bu!er[i][ j]"color; /* if (;;distance ' d}lengths[index]) + if (##distance ' length)+ /* if (;;index 'd}number) index"0; distance"1; color"(color""1) ? 0 : 1; ,
/*
,
,
for (k"0; k(8; k##) + i"x#neighbors[k][0]; j"y#neighbors[k][1]; if (frame}bu!er[i][ j]""3) edges}Trace(i, j, distance, color, index); edges}Trace(i, j, distance, color); ,
References [1] Foley J, Van Dam A, Feiner S, Hughes J. Computer graphics: principles and practice, 2nd (in C) ed. Reading, MA: Addison-Wesley, 1996. [2] Glassner A, editor. An introduction to ray tracing. London: Academic Press, 1989. [3] Barrow H, Tenebaum J. Interpreting line drawing as three-dimensional surfaces. Arti"cial Intelligence 1981;17(1}3):75}116. [4] Freeman H. Computer processing of line-drawing images. ACM Computing Surveys 1974;6(1):57}97. [5] Sutherland I, Sproul R, Schumacker R. A characterization of ten hidden-surface algorithms. ACM Computing Surveys 1974;6(1):1}55. [6] Dooley D, Cohen M. Automatic illustration of 3D geometric models: Lines. Computer Graphics (1990 Symposium on Interactive 3D Graphics) 1990;24(2):77}82. [7] Liu Y, Zsombormurray P. Intersection curves between quadric surfaces of revolution. Transactions of the Canadian Society for Mechanical Engineering 1995; 19(4):435}53. [8] Miller J, Goldman R. Geometric algorithms for detecting and calculating all conic sections in the intersection of any 2 natural quadric surfaces. Graphical Models and Image Processing 1995;57(1):55}66.
451
*#*/ */
*/ *#*/
// process the 8 neighbors
*/ // trace if invisible // end of edges}Trace(.) // end of P}Buwer
[9] Markosian L, Kowalski MA, Trychin SJ, Bourdev LD, Goldstein DD, Hughes JF. Real-time nonphotorealistic rendering. In: Whitted T, editor. SIGGRAPH '97 Conference Proceedings, August 1997. p. 415}20. [10] Catmull E. A subdivision algorithm for computer display of curved splines. Ph.D. thesis, Computer Science Department, University of Utah, Salt Lake City, UT 1974. [11] Carpenter L. The A-bu!er: an antialiased hidden surface method. In: Proceedings of SIGGRAPH '84 in Computer Graphics, vol. 18, 1984. p. 103}8. [12] Myers A. An e$cient visible surface program. Report to the national science foundation, Computer Graphics Research Group, Ohio State University, Columbus, OH, July 1975. [13] Warnock J. a hidden-surface algorithm for computer generated half-tone pictures. Technical Report TR 4-15 NTIS AD 753 671, Computer Science Department, University of Utah, Salt Lake City, UT, June 1969. [14] Yuan X, Sun H. P-bu!er: a hidden-line algorithm in image-space. Computers & Graphics 1997;21(3): 359}66. [15] Fiume E. The mathematical structure of raster graphics. San Diego, CA: Academic Press, 1989. [16] Rogers D. Procedural elements for computer graphics. New York: McGraw-Hill, 1985.