Hardware-Accelerated Interactive Illustrative Stipple Drawing ofPolygonal Objects

Vision, Modeling, and Visualization 2002

Aidong Lu† Joe Taylor† Mark Hartner‡ David Ebert†Charles Hansen‡

†School of Electrical and Computer EngineeringPurdue University, West Lafayette, IN 47906

{alu, jtaylor, ebertd}@purdue.edu‡School of Computing, University of Utah, Salt Lake City, UT

{hartner, hansen}@cs.utah.edu

Abstract

Pen and ink rendering techniques provide artistic,illustrative, and informative representations of ob-jects. With recent advances in hardware graph-ics technology, several researchers have developedinteractive non-photorealistic rendering techniques,including hatching, toon rendering, and silhouettes.However, the stippling method of drawing andshading using dots has not received as much focus.In this paper, we present an interactive system forstipple drawing of surface-based objects that pro-vides illustrative stipple renderings of multiple ob-jects and includes adaptation of the stippling to pro-vide a consistent rendering of objects at any scale.We also describe the use of the latest graphics hard-ware capabilities for accelerating the rendering byperforming the silhouette rendering on the GPU andthe stipple density enhancement calculations as avertex program.

1 Introduction

Pen and ink illustration techniques have proven tobe very effective in scientific, technical, and med-ical illustration [4]. Within the computer graph-ics community, the hatching style has received themost attention (e.g., [3, 7, 9, 10]). An alternativepen and ink technique that uses the specific place-ment of dots to convey shape, structure, and shadingis stippling [1, 5, 7]. While stippling has receivedless research attention than hatching, it is a veryeffective illustration technique that has several ad-vantages over hatching. First, it is more effective at

conveying subtle form. Second, hatching and linebased techniques can improperly suggest nonexis-tent textures, ribbing, or segmentation of the model[4].

Most previous work in computer generated stip-pling performs the stippling process as a non-interactive post-process after rendering a grey-scaleimage [1], similar to dithering techniques. Thesesystems use approaches such as Vornoi diagrams forstipple point placement to approximate a specificgrey-level in the resultant image. Praun et al. [7]presented an interactive texture-based approach forreal-time hatching and showed an example of a stip-pled texture as tone art map rendering. However,their system requires the expensive pre-generationof the mip-map textures and concentrates on ap-propriate orientation and blending of the textures togenerate the resultant images. In contrast, our sys-tem uses actual points as geometry to achieve stip-ple rendered images, as can be seen in Figures 1and 2.

Figure 1: An example stipple rendering of a blobbydataset. The left image has uniform stipple place-ment. The right image has shading enhancement toconvey simple surface shading.

VMV 2002 Erlangen, Germany, November 20–22, 2002

Figure 2: Two example stipple renderings of a dragon with varying levels of stipple density.

Stippling is especially effective when combinedwith silhouette techniques to define the boundary ofan object. We have developed an interactive stip-ple rendering system for surface-based objects thatprovides effective, illustrative drawings of multipleobjects at interactive rates that incorporates distancebased adaptation of the stippling to provide consis-tent rendering of objects at any scale.

2 The Interactive Stippling System

The interactive point-based system renders bothpoints and polygons to create effective stipple draw-ings. Points are rendered to produce the stipplepatterns and polygons are rendered to create sil-houettes, toon shading, and perform hidden surface(point) removal. The system consists of an ini-tial point generation phase, followed by the view-dependent multi-scale rendering phase describedbelow.

2.1 Initial Point Generation

The initial points for each polygon are generatedrandomly within the polygon and then redistributedto approximate a Poisson-disc distribution [1]. Thisapproximately spaced placement of points simu-lates traditional stipple placement techniques. Twofactors are used to initially adjust the maximumnumber of stipples for each polygon, Nmax:

1. Maximum Point Density, Dmax: The user isallowed to adjust a maximum point density pa-

rameter to change the overall tone of the im-age.

2. Relative Point Density, Dr: The number ofpoints is automatically adjusted based on therelative size of the initial screen area of theprojected polygon so that larger polygons re-ceive more stipples. This ensures that the stip-ple pattern is independent of the object tes-sellation. The approximated projected screenarea is based on the polygon area and depthand orientation of the polygon as follows:

area = areaorig ∗ cos(Nz ∗ π) ∗ Zrel

where Nz is the z component of the imagespace polygon normal, and Zrel is the relativedepth of the polygon in the scene.

Therefore, the maximum stipples for each polygonis calculated as the following:

Nmax = Objectmax ∗ min(Dmax, Dr)

During interactive rendering, this value is ad-justed per frame based on distance and shading en-hancements described in the next section.

Illustrative stipple rendering is achieved by ren-dering the resulting points as geometric primitives.Frame-to-frame coherence of stipples is achievedsince their location within a polygon does not varyover time: only the number of stipples per poly-gon varies based on shading and distance calcula-tions. To eliminate any stipple “popping”, the in-tensity of the last stipple for each polygon is based

666

on the fractional portion of the density value. Un-fortunately, even with back-face culling, geometrywhich would not have been rendered with hiddensurface methods contributes stipples to the final im-age. Therefore, to achieve correct hidden surfaceremoval, we displace the stipples by a small epsilonalong the normal direction. We use the OpenGLpolygon offset which takes into effect the orienta-tion of the polygon when calculating the offset.

2.2 Shading

To achieve an effective stipple drawing, the shadingof the surface must be conveyed by the density ofthe stipples. Therefore, a simple modification to theLambertian diffuse illumination of the Blinn-Phongmodel, (N ·L)n, is used to shade the object, whichpotentially reduces the number of points drawn perpolygon for each frame. The reduction in the num-ber of points provides perceived shading based onthe number of stipples. Figure 1 shows the effect ofshading on the stipple placement. Note the detailswhich become visible with shading.

2.3 Distance Based Scale Enhancement

A desirable quality of a pen and ink rendering isthat the object appears with consistent brightnesswhen rendered at multiple scales. This problem wasaddressed in hatching by Winkenbach et al. [10],where they solved the sampling and reconstructionproblem to produce hatching of a consistent grey-level across multiple scales. For point-renderedstipples, we achieve consistent rendering at multi-ple scales by modifying the number of points drawnper polygon.1 There are two issues which impactthe number of stipples due to scale: the relativeplacement of the object in the viewing frustum, andthe relative position of each polygon in the object’sbounding box. We refer to the first as extrinsic dis-tance enhancement and the second as intrinsic dis-tance enhancement.

The extrinsic distance enhancement modulatesthe point density on a per-object basis to provideconsistent appearance. We compute the extrinsicdistance enhancement differently based on whethera polygon projects larger than or smaller than a user

1As described above, this is also adjusted based on the area ofthe polygon to correctly render models with non-uniform tessella-tion.

specified minimum screen coverage area for stip-pling (two to nine pixels).

If the polygon’s projection is large enough togenerate a stipple pattern, we use the following for-mula to adjust the point density:

pnt density = shaded pnt density/(Zmin

2−Zcurr)pr

where Zmin is the closest Z value in the scene andall other object Z values are less than this. Zcurr

is the depth of the center of the polygon, and pr isa user parameter to control the amount of extrinsicdistance enhancement. The orientation of the poly-gon in the view frustum is also used to adjust thepoint density based on the cosine of the z compo-nent of the image space normal vector. The resultsof this enhancement can be seen in Figure 3.

Figure 3: This image shows the extrinsic dis-tance enhancement where the polygon’s projectionis larger than a pixel. The three images with dif-ferent sized triangles show how the system auto-matically modifies the original number of stipplesto provide a consistent appearance.

When the projection of a polygon becomes toosmall, creating a shaded stipple pattern is not prac-tical, and we must select an appropriate percentageof the polygons to achieve a consistent grey-levelimage as the object decreases in size. When pro-cessing polygons in strips or area mode, we use thepolygon’s current approximate screen area2 to de-termine the number of polygons that cover our min-imum stipple screen area, N . We use a probabil-ity function based on this calculated area to deter-mine if the polygon should be drawn. We, therefore,only generate stipples for every N th polygon. Sim-ilarly, for other types of meshes, a random probabil-ity value can be assigned to each polygon and usedin conjunction with the projected area to determinewhich surface elements to process. The approxi-mated projected screen area is based on the initial

2This value is updated per frame based on the changing depthand orientation of the polygon to the camera.

666

projected area of the polygon and the current viewlocation as follows:

area = areaorig ∗ cos(Nz ∗ π) ∗ Z′

rel

where Nz is the z component of the image spacepolygon normal, and Z ′

rel is the relative depth ofthe polygon compared to its original position. Thisarea value is then used to determine the probabilitythat a given polygon has its stipples drawn, usingone of the two methods above. An example of thisenhancement can be seen in Figures 4, 5, and 6.

Figure 4: This image shows the multi-scale extrin-sic enhancement where polygons become smallerthan one pixel. The system automatically adjuststhe stipples to provide a consistent appearance.

Our intrinsic distance enhancement also modifiesthe number of stipples rendered to provide user con-trollable depth cuing internal to the model. Intrinsicdepth enhancement allows the user to focus atten-tion on the closest portion of a polygonal model,using the relative depth of the polygon within theobject’s bounding box. For this enhancement, weuse the following equation:

pnt density = curr pnt density∗(1+(Zcurr/A)de)

where Zcurr is the depth of the polygon, (−A, A)is the depth range in the object and de is a usercontrolled parameter that allows the enhancementrate to vary, which exaggerates or lessens the effect.The results of intrinsic distance enhancement can beseen in Figure 7 by comparing the stippling on the

left horse and the right horse. The horse on the lefthas no intrinsic distance enhancement, whereas, thestippling on the body and hind legs of the horse onthe right is lighter, exaggerating the depth relation-ship within the model.

Figure 7: This image shows the effects of distanceenhancement. The left image has no depth enhance-ment, while the image on the right has the relativedepth of the horse’s components exaggerated.

3 Hardware Acceleration

We have designed our system to balance the com-putation that is performed on the CPU with thatperformed on the GPU to achieve the best perfor-mance. One main division of the workload is be-tween the stipple density calculation on the CPUand the silhouette calculation on the GPU. We havealso implemented GPU-based resolution, distance,and light enhancement for the stipple rendering andwill continue to explore moving more of our calcu-lations to the vertex processing unit of the GPU.

3.1 Silhouette Rendering

Silhouettes have become a vital part of many non-photorealistic rendering techniques [2, 8]. Goochet al. [2] have shown that silhouettes can empha-size structure and detail, as well as be a aestheti-cally pleasing. We have incorporated two differentapproaches to silhouette rendering in our stipplingsystem.

The first approach is based on Raskar and Co-hen’s method for interactive silhouette lines [8].They describe a simple method for displaying

666

Figure 5: Another example of the multi-scale extrinsic enhancement applied to a statue model. The leftimage has no enhancement; the middle image has point intensity added for anti-aliasing; and the rightimage has extrinsic enhancement.

image-based silhouettes using standard OpenGLhardware. Their method involves rendering front-facing polygons into the depth buffer, while back-facing polygons are rendered in wireframe modewith a slight offset and a depth test set to equal,yielding silhouette lines of uniform thickness.

When the object occupies a large portion of theimage, thicker silhouette lines give a better result.However, when the object is moved away from theviewpoint, the silhouette lines should become thin-ner to give a consistent appearance. We use the ob-ject’s bounding sphere to scale the silhouette linewidth based on the object’s distance from the cam-era. The radius, which is orthogonal to the viewingdirection, is projected onto the screen. The rela-tive size provides a scaling factor for the silhouettethickness. Figure 8 shows an example of the Stan-ford bunny rendered without silhouettes (left) andwith silhouettes (right). The two smaller silhouettebunnies show the effects of thinning the silhouettes.The top-most has the thinning enabled, whereas thebottom smaller bunnies use the same pixel size asthe larger object.

Our second approach is to use a “toon” shadersilhouette approach and the vertex programmabil-ity extension to OpenGL. In a vertex program thatis executed for each triangle, we compute the dotproduct of the eye vector and the surface normalvector and multiply this by an increasing ramp func-tion, clamped between 0.0 and 1.0. This becomesthe intensity of the surface. Only surfaces whosenormals are nearly perpendicular to the eye vectorwill have intensity near 1.0, thus producing a sil-houette. The sharpness of the silhouette is deter-mined by the steepness of the ramp function. Fig-ure 9 shows an example of the Stanford bunny ren-dered using this technique with and without stip-ples. The weakness of this approach is that the sil-houette is not uniform when comparing edges ofhigh and low curvature. This can clearly be seenwhen comparing the silhouette at the feet and earsof the rabbit to the silhouette along its back andchest. To improve the overall rendered quality,these images were generated with an implementa-tion using two separate vertex programs: one for thesilhouette polygons and one for the stipple points.

666

Figure 6: Another example of the multi-scale extrinsic enhancement applied to a hand model. The left handhas no enhancement, the middle image has point intensity added for anti-aliasing, and the right image hasextrinsic enhancement.

While the silhouette vertex program implements thetechnique as described, the stipple vertex programuses a decreasing ramp function causing stipplesnear the silhouette to fade. The slope of the de-creasing function determines the sharpness of thisfade. Other approaches to silhouette enhancementinclude a per-pixel approach using cubemap tex-tures and register combiners, as well as a multi-passtechnique using an offset viewport for each pass [6].

Figure 9: This image shows our toon shading vertexprogram silhouette method.

3.2 GPU-based Distance and ResolutionEnhancement

We have been able to increase the performance ofthe stipple renderer by implementing all of the stip-ple enhancements (resolution, distance, lighting) onthe GPU using the vertex program extension ofOpenGL on the Nvidia GeForce3. The conversionof these functions to the vertex program hardwareinstruction set is simple, with the standard trick forconverting conditionals to vertex programs (com-pute both paths and select one of the results). Forthe power function, the lighting coefficients instruc-tion (LIT) was used for a fast, approximate cal-culation. The vertex program currently uses 36operations per vertex, which allows for future en-hancements for stippling to be computed with ver-tex programs. Compared to software stipple render-ing only, the current performance increase rangesfrom 0% to almost 100%. The more polygons inthe model, the greater the speedup. With silhouetterendering added, depending on the view, the ver-tex program enhancements can be as much as 50%faster than software stipple rendering (with hard-ware silhouettes).

When the computations are done in software,the density for a given surface is calculated, andonly the number of stipples (vertices) that are to be

666

Figure 8: The left image shows stipples without silhouette edges. The right large bunny has image-basedsilhouettes enabled. To the right and above the lower bunny demonstrates the silhouette thinning method.

drawn are sent to the hardware. When the compu-tations are done in the vertex program, every po-tential stipple (vertex) for a given surface is sent tothe GPU and the density calculation is performedper stipple. Additionally, an index value, rangingfrom one to the total number of potential vertices, isneeded for each stipple. If this index value is greaterthan the calculated density for that vertex, fast depthculling is used to eliminate further processing of thevertex by adding a large offset to the homogeneousz coordinate of the vertex.

Although this vertex program calculation isfaster, it requires redundant calculations comparedto the software (CPU) implementation because thedensity calculations are performed once per stip-ple (vertex) instead of once per surface (triangle).This redundancy, however, removes the dependencywithin the set of potential stipples for a given sur-face on a single calculation (density calculation).Independent stipple calculation can be utilized foreven greater performance on the latest, and future,generations of graphics boards that feature multipleparallel vertex processing pipelines (e.g., the NvidiaGeForce4).

4 Results

The results of the stippling system can be seen inFigures 2 through 9 Our performance informationis for 1280x1024 rendering on a PC with dual In-tel Xeon 2.2 GHz processors and a GeForce3 Ti

500 graphics board. Table 1 shows the performanceof the system on several different models, demon-strating that interactive stipple rendering can be per-formed for useful-sized models on current graphicshardware. This table shows that currently, silhou-ette rendering occupies a significant portion of therendering time and also that vertex programs canspeed up the stipple rendering by up to 100%, de-pending on the model. The extrinsic distance en-hancements shown in Figures 3 and 4 demonstratethat the system can create appropriate stipple ren-derings of models at a wide range of scales and canapply these enhancement techniques to different ob-jects within the same scene. As the projection of theobject becomes smaller, the extrinsic distance en-hancement automatically switches techniques. Fora particular scale, the distance enhancement main-tains consistent perceived shading by modulatingthe number of stipples. The intrinsic distance en-hancement shown in Figure 7 can create subtle orexaggerated depth effects for illustrative renderingand artistic results. Both of our silhouette tech-niques enhance the quality of the final images andshow a range of artistic styles that can be conveyedwith the stipple rendering system.

5 Conclusions

Stippling is one of the most important and effec-tive methods for technical illustration. We haveshown that point-based stipple rendering can be

666

Dataset Number of Stipple Only Stipple & SilhouetteName Polygons Vertex Program No Vertex Program Vertex Program No Vertex Program

(fps) (fps) (fps) (fps)

horse 13,352 60.39 60.39 30.19 30.19low-res dragon 45106 32.05 30.4 15.60 15.24

bunny 69451 30.12 20.07 12.03 11.89skeleton1 124018 20.66 12.08 10.16 7.53skeleton2 522567 4.65 2.60 1.94 1.50

hand 654666 4.00 2.07 1.88 1.32dragon 871414 2.99 1.50 1.32 0.91

Table 1: Running times (frames per second) for different rendering techniques on several example polygonalmodels.

used to create effective and illustrative renderings ofsurface-based objects at interactive rates and acrossmultiple scales using the programming capabilitiesof the latest generation of graphics hardware. Theaddition of different hardware silhouette techniquesenhance the final renderings and create differentartistic styles in the renderings. While the currentsystem is very effective, we will further explore op-timizing the performance to allow interactive ren-dering of even more complex models.

6 Acknowledgments

This material is based upon work begun by ChrisMorris and is supported by the National Sci-ence Foundation under Grants: NSF ACI-0081581,NSF ACI-0121288, NSF IIS-0098443, NSF ACI-9978032, NSF MRI-9977218, NSF ACR-9978099,and the DOE VIEWS program.

References

[1] Oliver Deussen, Stefan Hiller, Cornelius vanOverveld, and Thomas Strothotte. Floatingpoints: A method for computing stipple draw-ings. Computer Graphics Forum, 19(3):41–50, August 2000. ISSN 1067-7055.

[2] Bruce Gooch, Peter-Pike Sloan, Amy Gooch,Peter Shirley, and Richard Riesenfeld. Inter-active technical illustration. In Proceedings ofSymposium on Interactive 3D Graphics, pages31–38, April 1999.

[3] Aaron Hertzmann and Denis Zorin. Illustrat-ing smooth surfaces. In Proceedings of SIG-GRAPH 2000, Computer Graphics Proceed-ings, Annual Conference Series, pages 517–526. ACM Press / ACM SIGGRAPH / Ad-

dison Wesley Longman, July 2000. ISBN 1-58113-208-5.

[4] Elaine R.S. Hodges. The Guild Handbook ofScientific Illustration. John Wiley and Sons,Inc., New York, 1989. ISBN 0-471-28896-9.

[5] M. Levoy and T. Whitted. The use of pointsas a display primitive. Technical Report 85-022, University of North Carolina-Chapel HillComputer Science Department, January 1985.

[6] One-pass silhouette rendering with geforceand geforce2. Technical report, June 2000.http://developer.nvidia.com/.

[7] Emil Praun, Hugues Hoppe, Matthew Webb,and Adam Finkelstein. Real-time hatching.In Proceedings of SIGGRAPH 2001, Com-puter Graphics Proceedings, Annual Confer-ence Series, pages 579–584. ACM Press /ACM SIGGRAPH, August 2001. ISBN 1-58113-292-1.

[8] Ramesh Raskar and Micheal Cohen. Imageprecision silhouette edges. In Proceedings ofSymposium on Interactive 3D Graphics, pages135–140, April 1999.

[9] Michael P. Salisbury, Sean E. Anderson, Ro-nen Barzel, and David H. Salesin. Interactivepen-and-ink illustration. In Proceedings ofSIGGRAPH 94, Computer Graphics Proceed-ings, Annual Conference Series, pages 101–108, Orlando, Florida, July 1994. ACM SIG-GRAPH / ACM Press. ISBN 0-89791-667-0.

[10] Georges Winkenbach and David H. Salesin.Rendering parametric surfaces in pen andink. In Proceedings of SIGGRAPH 96, Com-puter Graphics Proceedings, Annual Confer-ence Series, pages 469–476, New Orleans,Louisiana, August 1996. ACM SIGGRAPH /Addison Wesley. ISBN 0-201-94800-1.

666