Stream-Processing Point Data

Renato Pajarola and Miguel Sainz

UCI-ICS Technical Report No. 04-02Department of Computer ScienceUniversity of California, Irvine

March 2004

2

Stream-Processing Point Data

Renato Pajarola

*

Miguel Sainz

*

Computer Graphics Lab Computer Science DepartmentUniversity of California Irvine

Abstract

With the fast increasing size of captured 3D models, i.e. fromhigh-resolution laser range scanning devices, it has become moreand more important to provide basic point processing methodsfor large raw point data sets. In this paper we present a novelstream-based point processing framework that orders unorga-nized raw points along a spatial dimension and processes themsequentially. The major advantage of our novel concept is itsextremely low main memory usage and its applicability to processvery large data sets out-of-core in a sequential order. Further-more, the framework supports local operators and is extensible toconcatenate multiple operators successively.

Keywords:

point processing, sequential processing, normal esti-mation, fairing

1. Introduction

Points as rendering and modeling primitives have become a pow-erful alternative to traditional polygonal object representation. Infact, points or 3D coordinates are the fundamental geome-try-defining entities. Satisfying provably correct surface samplingcriteria as discussed in [17], a set of points in 3Dspace fully defines the geometry as well as the topology of a sur-face including boundaries, components and genus. We assumehere that input point sample data sets reasonably sample the rep-resented surface, i.e. satisfying the Nyquist sampling criteria.Points are also the natural raw output data primitives of the 3Dgeometry capturing stage in most 3D geometry acquisition sys-tems, i.e. laser range scanning or large objects [15].

With the dramatically increasing use and precision of 3D cap-turing devices it is critical to support raw point cloud data in apractical way. In particular, basic point processing operationssuch as normal direction estimation or fairing must be supported.Such operators can only be computed efficiently if the unorga-nized point data can be loaded into main memory and organizedin some spatial indexing data structure. This approach, while opti-mal up to some size limit, will decrease quickly in efficiencywhen the models exceed available physical main memory. In thecase of large mismatch between model size and physical mainmemory size it may almost cause this

main memory

approach tocome to a halt. Furthermore, combining multiple operations can-not easily be addressed in an efficient way by merely combiningmultiple stages of applying operators.

In this paper we set the stage for a new

stream-processing

concept, a novel approach for processing points sequentially toimprove memory access coherency and dramatically limit mainmemory usage. This sequential stream-processing model directlyallows us to process extremely large models out-of-core withoutthe need to partition the models or process them on very largeserver machines. In fact, our stream-processing framework hassuch a low main memory usage that physical main memory limi-tation is practically irrelevant and extremely large models can beprocessed on very memory-limited machines.

The operations that are supported by the proposed concept arelocal operators ƒ(

p

) that perform a function on a point

p

and itslocal neighborhood. Many basic operations such as normal esti-mation on raw point data sets follow this principle and require thedefinition of a local neighborhood and then perform a computa-tion of attributes based on this neighborhood [14, 17]. Also filteroperations such as fairing are in this category and in generalrequire a local neighborhood to operate on. Surface parameterestimation and filter operations are amongst the standard tasks forprocessing points. Our new concept supports any direct localoperator ƒ(

p

) that is non-recursive in nature and that does notinclude any traversal of the samples beyond a limited local neigh-borhood.

2. Related Work

Conceptually, the most closely related work to our approach aresweep-line techniques in computational geometry [dBvKOS97].The basic concept follows that idea of sweeping a line, or a planein 3D, through the data set and consider the events when a dataelement is passed by the sweep-line. We extend this concept toprocessing a stream of points in 3D and to allow for several oper-ations to be performed in consecutive stages.

Further related work is the approach to process trianglemeshes in a sequential order [8, 9]. This technique grows trianglemesh regions sequentially in a fixed order that limits main mem-ory usage by keeping information of active elements only. In par-ticular, the active elements only consist of a small fraction of themesh. This technique provides very efficient compression [8],rendering and simplification [9] of very large meshes. While thistechnique operates on a data set with a well defined and compactneighborhood definition given by the mesh connectivity, our pro-posed framework operates on a much lower level of processingraw points.

A very interesting approach to treat points in a sequential wayhas been proposed in [4]. There, a novel fast point renderingapproach has been proposed by linearizing a multiresolution hier-archy into a single sequence of nodes, and basically performinglevel-of-detail selection and rendering directly on the GPU. Themethod does not address any low-level processing tasks and is notdirectly applicable to large data sets exceeding physical mainmemory or geometry cache sizes.

Since points as rendering primitives have been discussed in[16] and [12], many rendering techniques and systems have beenproposed such as [25, 23, 24, 2, 11

,

2]. In general these tech-niques address high-level point processing tasks such as multires-olution modeling and rendering of points with normals and spatialextent. More low-level processing techniques on point data setscan be found in [18, 20]. However, they are aimed at processingmoderate point set sizes in main memory and assume that somebasic processing such as an initial normal estimation has beendone beforehand.

3. Basic Sweep-Plane Concept

The basic concept of our framework is to process the input points in a sequential order such that each point

p

i

isread only once from the input-stream, kept in an active workingset

A

for some minimal amount of time and then written to the

p1 … pn, , R3∈

p1 … pn, , R3∈

*

pajarola@acm.org, msainz@ics.uci.edu

3

output-stream as illustrated in Figure 1. This dramaticallyincreases memory-access coherency for large data sets as all oper-ations only involve points from the rather small set

A

. Moreover,since the set

A

is orders-of-magnitude smaller then the entire dataset it can generally be maintained efficiently in main-memory andbecause input and output are streams of points this directly leadsto an out-of-core framework for stream-processing points.

FIGURE 1.

Sweep-plane process overview

As shown in Figure 1, we conceptually move a

sweep-plane

through space along the

z

-axis (without restricting the generalityof this concept to any direction)

.

Every time a new point from theinput stream is hit by the sweep-plane it is added to

A

. The activeset

A

is continuously monitored and the local operator ƒ(

p

) isapplied to the point

p

for which all necessary data is available.Furthermore, the smallest element of

A

is examined and if it doesnot possibly contribute anymore to applying the operator ƒ to anyfuture point it can safely be written to the output stream. In theremainder of this paper we will use

small

and

large

in the contextof the sequential ordering. In the following section we describe inmore detail the process for local neighborhood construction andapplication of a local operator.

When points have not yet been read from the input stream, orafter they have been written to the output stream, their data gener-ally resides on external disk memory, or possibly within somememory mapped virtual file memory. On the other hand, whenelements

live

in the active set

A

they reside in virtual main mem-ory and extra data is temporarily stored such as a list of

k

-nearestneighbors and other attributes.

Since raw point data sets rarely come with the structure ofbeing sequentially ordered in space they must be ordered in apre-process. This can efficiently be done for very large data setsby external sort techniques [12,24], and in practice the

rsort

[15]implementation has been used for similar tasks.

4. Nearest Neighbors and Local Operator

4.1 Nearest Neighborhood Determination

Any local operator ƒ(

p

i

) requires information about the localneighborhood of points

surrounding

p

i

. Thisneighborhood

K

i

can either be defined by a maximal

range

or as anumber

k

of nearest neighbors. We will mainly focus on the

k

-nearest neighbors here but a fixed

range

can also be supportedefficiently by varying

k

for each point.To compute all

k

-nearest neighbors efficiently, or any neigh-borhood set for that matter, it is essential to maintain a spatialindex structure

Q

K

over the the active set

A

that allows for very

selective spatial (range-) queries. However, since we are process-ing a stream of points and want the spatial data structure to holdas few active elements as possible, we must remove the smallestactive element from this data structure at the earliest possibletime. Thus the index

Q

K

must also incorporate a priority-queue inthe sequential ordering. Furthermore, despite frequent insertionsand deletions this spatial data structure must also be reasonablybalanced to support efficient access. Hence the main challenges indefining and implementing

Q

K

are:

•

exhibit strong spatial selectivity

•

support dynamic insertions of new points

p

i

•

support removal of smallest priority-queue element

p

i-m

•

maintain a balance of O(log

m

)

•

preserve the sorted priority-queue property dynamically

The selection of choice for

Q

K

is a kD-heap that combines adynamic, quasi balanced kD-tree with a priority heap. ThekD-tree was selected over other spatial data structures due to itssimple binary tree structure, efficient incremental insertion andremoval operations, and the ability to influence the balancedynamically. In fact, since the points are streamed in one dimen-sion it makes sense to only have a two-dimensional kD-tree parti-tioning the sweep-plane. The priority-queue is integrated with thekD-tree as a heap that parallels the kD-tree binary tree structure.Each kD-tree node holds a pointer to the smallest element in itssubtree. Figure 2 shows an example kD-tree with alternating

x

,

y

split dimensions and heap structure in the

z

dimension.

FIGURE 2.

Integration of kD-tree and priority-heap.

The two basic operations that are supported are: incrementalinsertion of a new element into the kD-tree, and removal of anarbitrary element while satisfying the kD-tree structure[dBvKOS97]. Both operations are followed by a bottom-upupdate of the priority-heap relation.

A more complex operation is the

k

-nearest neighbor updatewhich is solved in two phases. In the first phase, just before thenext element

p

i

read from the input stream is inserted, a query on

Q

K

finds the smaller one-sided

k

-nearest neighbors

K

i

which areall smaller than

p

i

, since

Q

K

only contains previous points in thesequential ordering. The element

p

i

is then inserted into

Q

K

withits temporary neighborhood

K

i

. This starts the second

k

-nearestneighbor search phase where

p

i

resides in the kD-heap – the firststage while being in the active set

A

as shown in Figure 3 – and

K

i

is continually updated. During the above query when an element

p

i-j

in

Q

K

is tested to update

K

i

, simultaneously

p

i

is tested toupdate

K

i-j

. Therefore,

K

i

is continually updated with the largerone-sided

k

-nearest neighbors while

p

i

is in

Q

K

and new elements

p

i+j

are inserted.

x

y

z

sweep-plane

input streamoutput stream activeset A

Ki pi1… pik

, ,{ }=

split coordinate6,2 (6)

pi

5,5 (7) 7,6 (8)

8,9 (5)9,4 (10)2,6 (1)4,3 (3)

1,8 (4) 3,7 (9) 9,9 (2)

pi-9

smallest element

4

FIGURE 3. Stages of a simple stream-processing pipeline. A point moves from right-to-left through these stages.

The last major operation on the kD-heap QK is the removal ofsmallest elements. As it is imperative to keep the size of QK assmall as possible for fast k-nearest neighbor updates, we need toremove elements whose k-nearest neighborhood is completed asearly as possible. Therefore, our kD-heap supports a query to finda sorted list L, smallest first, of elements pj in QK for which thecurrent sweep-plane has moved beyond the farthest, kth-nearestneighbor in Kj. The elements of this list L can then be removedfrom QK. However, note that L is only partially sorted withrespect to the sequential ordering and hence its elements cannotimmediately be passed to the next stage. Therefore, the elementspj of L are first passed to a sorting buffer B – the second stagewhile being in the active set A as shown in Figure 3 – thatre-establishes the global ordering. The smallest element pj of Bhas regained its correct global ordering as soon as it is smallerthan the smallest element in QK and in that case it can be passedto the next processing stage.

4.2 Local OperatorAfter passing the kD-heap QK and when leaving the sorting bufferB, an element pj has a fully determined k-nearest neighborhood Kjand the local operator ƒ(pj) can be applied. However, it must beguaranteed that all elements referred to by Kj can be accessedbefore performing ƒ(pj). Note that Kj refers to elements that canbe smaller as well as larger than pj in the sequential ordering. Ele-ments that are larger are guaranteed to be maintained in the activeset A either by the current kD-heap QK or the sorting buffer B. Onthe other hand, also the elements of Kj smaller than pj must bekept in the active set A. Hence upon leaving the sorting buffer B,just after applying the operator ƒ(pj), the element pj cannot be dis-carded yet and is passed to a FIFO queue F – the third and laststage while being in the active set A as shown in Figure 3. ThisFIFO queue F assures that every element pl referenced by anynearest neighbor set Kj of a larger point pj in the sorting buffer Bor the kD-heap QK is forced to stay in the active set A.

Therefore, the first element pl of F can leave the active set Aand be written to the output stream when it is not anymore refer-enced by any other (larger) element pj in A. This relation is man-aged by a simple priority queue ZQ, over all elements pj in QKand B, that maintains the smallest referenced element (z-refer-ence) in . Thus the first element pl of F has fully com-pleted its service in the active set A when it is beyond the smallestreference managed by ZQ. This completes the three stagestream-processing pipeline shown in Figure 3 for establishing ak-nearest neighborhood and computing a local operator. The localoperator ƒ(pj) can be applied on pj and its neighborhood Kj whenit is moved from the sorting buffer B to the FIFO queue F.

As prototypical local operator ƒ(pj) applied to Kj we select thenormal estimation N(pj) by least squares fitting [14, 1, 22, 17] todemonstrate our basic framework. This computes the orientationof a fitting plane through a set of points by an eigenvalue and

eigenvector analysis of the covariance matrix. We adopted a mov-ing least squares (MLS) approach similar to [1] with a weightedcovariance

.

The average of the point set is given by p. Theweight function θ(r) is a smooth, radially symmetric, monotonedecreasing Gaussian function . The variance σ2

is adaptively defined as the local point density estimate, see also [17]. Thus the normal nj of

a point pj is computed as the eigenvector of the MLS covarianceMj over corresponding to the smallest eigenvalue of Mj.Potentially it is numerically more robust to define the normal asthe normalized vector product of the two eigenvectors corre-sponding to the two largest eigenvalues of Mj.

In fact, in addition to the normal nj estimate of a point pj wealso compute a bounding sphere radius rj over all points in Kj, andalso an elliptical disk approximating the anisotropic distributionof points in Kj. These attributes can be used by a point-based ren-dering system to visualize the processed point set as circular orelliptical disks.

5. FairingTo demonstrate the applicability of the proposed stream-process-ing framework we introduce a smoothing filter operation. How-ever, processing data as a stream does not allow for iterative orrecursive operations to be performed. For this reason we adopt thenon-iterative feature preserving fairing operator presented in [10].Its applicability to triangle soups makes it also suitable for modi-fication to point sets. Fairing along the lines of [10] requires a tan-gent plane normal estimate which we described in the previoussection. Furthermore, it also requires accessing spatially closeneighbors. Therefore, the basic framework to establish a k-nearestneighborhood presented in Section 4 directly applies to the fairingoperator as well.

Given a point pi and its neighbors Ki, we extend the smooth-ing operation Φ to points as follows

,

with summation over all points . The operator denotes the projection of pi onto the tangent plane of

point pj and the value aj corresponds to an area weight. The nor-malization term wi is the sum of weights

. The Gaussian weight func-tion f(r) adjusts the influence of a point based on spatial distanceand favors nearby points for smoothing, while g(r) tends to pre-serve sharp features by giving less weight to points with differentnormal orientations [10]. All necessary information to performthis fairing operator Φ(pi) is given by the stream-processingframework as described in Section 4. This includes the normal

x

y

z

sweep-plane

kD-heap

active set A

sorting bufferFIFO queue input streamoutput stream

pi-m pi

p1pn

largersmaller

K Kj∪=

Mj Kj 1+( ) 1–p p–( ) p p–( )T θ p p–( )⋅ ⋅

p Kj pj∪∈∑⋅=

Kj pj∪

θ r( ) e r2– 2σ2⁄=

π MAXp Kj∈ p pj–( )2 Kj⁄⋅

Kj pj∪

pi' Φ pi( ) wi1– Πj pi( )aj f pj pi–( ) g Πj pi( ) pi–( )⋅ ⋅∑⋅= =

pj Ki pi∪∈Πj pi( )

aj f pj pi–( ) g Πj pi( ) pi–( )⋅ ⋅∑

5

estimates nj used for the projection as well as circular or ellip-tical bounding disks used to calculate the area aj of a point pj.

FIGURE 4. Stages of a complex stream-processing pipeline for fairing. Region-of-action overlap is indicated for thedifferent local operators.

The outlined smoothing operator Φ(pi) is a local operator sim-ilar to the normal estimation N(pi) explained in Section 4.2 andoperates on pi and its k-nearest neighbors Ki. Note, however, thatits application must fit into the stream-processing pipeline cor-rectly with respect to available and referenced data as illustratedin Figure 4. In particular, smoothing points makes it necessary torecompute a new normal, as well as circular or elliptical boundingdisk parameters, after applying the fairing operator. Hence weapply a normal estimator ni = N(pi) followed by the fairing opera-tor pi’ = Φ(pi) and again followed by a normal estimationni’ = N(pi’). Moreover, as the fairing operator Φ(pi) changes thecoordinates of points it must strictly be avoided that the normalestimators operate on a mix of faired and non-faired points. Keep-ing a second copy of the original input point coordinates, how-ever, this can be avoided and the fairing operator can overlap bothnormal operators in the sequential processing of points as shownin Figure 4.

The different data structures and stages of the active set A fora combined normal estimation with bounding disks, and fairingoperator are illustrated in Figure 4. In contrast to the basicstream-processing stages described in Section 4, a second FIFOqueue is necessary. The sorting buffer B is also modified in itsbehavior in the following way. Since the fairing operator Φ(pi)changes pi it can only be applied to points that are not in the rangeof the k-nearest neighborhood Kj of any larger point pj. This isassured by checking a priority queue ZQ1 equivalent to the oneexplained in Section 4. Moreover, the neighborhood Ki can onlyreference elements pl that have passed the normal operator sincetheir normals nl are required for fairing. These requirementsextend the scope of the sorting buffer B and the time elementsremain in it. The fairing operator Φ(pi) is then applied to the ele-ments pi leaving this modified sorting buffer stage and which arepassed to the following FIFO queue F1. Because we have a thirdoperator to recompute the normal of the smoothened points, thequeue F1 buffers points until the set Ki of its smallest element pionly refers to points that have been faired before, thus are smallerthan any element in the sorting buffer B. The second normal esti-mation is performed when a point leaves F1. Finally the FIFOqueue F2 is necessary to keep all elements pi active which areneeded by the second normal operator. Therefore, the first ele-ment pi of F2 can leave the active set A when it is not referencedby any larger element pj in A. This relation is assured by anotherpriority queue ZQ2 managing the smallest references from all ele-ments pj in QK, B and F1.

This completes the extended normal estimation and fairingstream-processing pipeline shown in Figure 4.

6. AnalysisIn terms of memory requirements we note that the most criticalpart in all processing stages is the spatial data structure to provideefficient access to all points and their neighbors. Ingeneral, constructing as well as querying a balanced spatial datastructure requires O(n log n) time and O(n) space. While this isoptimal it may nevertheless consume too much main memory.Our stream-processing framework has the property that only alimited number of m<<n points are active at any moment in time.The active set A = consists of points not fullyprocessed for which a new point pi on the sweep plane may benecessary to complete the processing task, or processed pointswhich are still required by others to complete the processing task.Thus in main memory only the m active points must be main-tained, organized in an indexing data structure requiring onlyO(m) main memory space.

The processing performance is mainly determined by the spa-tial indexing and the determination of all k-nearest neighbors.Since the k-nearest neighbor query is only performed on the ele-ments in the kD-heap QK of the active set A, the cost of comput-ing all k-nearest neighbors will strongly depend on the size andbalance of the kD-heap data structure.

In the pre-process the points are sorted in onedirection, using an external memory sort algorithm in O(n log n)time.

7. ExperimentsAll point processing experiments were performed on a PowerMacG4 dual 800MHz1 CPU with 512MB main memory. Pre-processresults for ordering the data sets sequentially are ommitted. Alldata sets are ordered along the z-dimension without consideringthe actual main orientation of the model.

The streaming of points was implemented using memorymapped arrays. The ordering pre-process writes the sequentiallyordered points into a memory mapped file that is read subse-quently by the stream-processing algorithm. The output stream isalso written to a memory mapped file.

Πj

x

y

z

sweep-plane

kD-heap

active set A

sorting bufferFIFO 1 input streamoutput stream

pi-m pi

p1pn

FIFO 2

normal estimation N(p)normal estimation N(p)

fairing Φ(p)region-of-action of the local operators

larg

e

smal

l

largersmaller

1. Note that the software is not parallelized and runs only on one CPU.

p1 … pn, ,

pi 1– … pi m–, ,

p1 … pn, ,

6

For k-nearest neighbor finding and normal estimation,Figure 5 shows the sizes of the various data structures of theactive set with respect to the progress of the stream-processthrough the point sequence. One can see that while there is somevariation, the general trend is that the active set data structures areorders-of-magnitude smaller than the input point set. In moredetail, the kD-heap and the FIFO data structure maintain signifi-cantly more elements than the sorting buffer, which is expected inthe case of a simple normal estimation operator as described inSection 4. The size of the kD-heap is the most important measur-ing factor as the k-nearest neighbor search heavily depends on itand consumes most of the processing time. The FIFO queue isalso of much less importance.

Lucy exhibits some strong growth of the data structures up tomaintaining around 300,000 points at a very early time but thendramatically drops to only manage some 20,000 points dynami-

cally in the active set during the remainder of the stream-process-ing.

The David head model exhibits a similar peak at about 2/3 ofthe time with about 50,000 points in the kD-heap. For the mostpart, however, only about 10,000 or less points are dynamicallymanaged in the active set.

The two David models, at 1mm and 2mm resolution, show aninteresting scaling behavior. The smaller 4M point David modelcauses the system to dynamically manage around 25,000 points inthe kD-heap. The seven times bigger 28M point David model onthe other hand, while peaking a few times into 100,000, for themost part requires only less than 40,000 elements in the kD-heap.

Variations in the active set size are due to variations in theobject shape and how the sweep-plane cuts through it, and alsohow the object is aligned with respect to the z-axis which definesthe sequential ordering.

We also performed some experiments with the proposed fair-ing operator described in Section 5. Similar results are reported inFigure 6. One can observe that the main-memory data structuresare generally orders-of-magnitude smaller than the processedinput point data set. Hence our proposed stream-processingframework efficiently stream-processes arbitrary large point datsets efficiently, and in particular with only very limited mainmemory usage.

FIGURE 5. kD-heap, sorting buffer and FIFO queue sizes plotted against the progress through the input point stream.

Model #PointsDavid 1mm 28,168,109David 2mm 4,129,534David head 2,000,646Lucy 14,022,961Dragon 435,545Female 302,948Balljoint 137,062

TABLE 1. Test model sizes.

7

FIGURE 6. kD-heap, sorting buffer and FIFO/FIFO2 queue sizes plotted against the progress through the input pointstream.

8. DiscussionsWe have presented a novel point processing framework based ona linear streaming of points and a sweep-plane algorithm fork-nearest neighborhood determination. To our knowledge this isthe first method that can apply local operators such as normal esti-mation and fairing without a data structure holding the entire dataset in in-core or virtual memory, and that is applicable to arbitrarylarge data sets out-of-core. It is also the only framework that sup-ports processing points as streams with only limited main mem-ory usage and that is extensible to apply multiple local operatorssuccessively on the point set.

Several implementation details are not optimized in the cur-rent framework. At present, the aspect ratio of the bounding boxof input models is not examined, even though a sequential order-ing along the z-dimension may not always be the optimal. In fact,the sequential ordering should be performed along the axis of thelongest bounding box side for better performance. Furthermore,most of the buffer and queue data structures are standard C++STL template containers and not specialized implementationsoptimized for performance. While the kD-tree priority-heap is acustom data structure and has some minor balancing techniquesincorporated, it is not the fastest possible implementation. Amongthe possible improvements is a much more agressive balancingstrategy to keep the k-nearest neighbor query cost low. Furtherwork would include the development of a specialized dynami-cally balanced spatial indexing structure.

The k-nearest neighborhood sweep-plane algorithm describedin Section 4 can under certain circumstances generate an approxi-mate k-nearest neighbor set instead of the exact solution. This hasto do with out-of-k-nearest-neighbor-range tests that in fact areextremely difficult to answer exactly. For example, it is unclearhow to quickly determine if a point cannot anymore contribute tothe k-nearest neighbor set of any subsequent point reached by thesweep-plane. The first observation we can make here is that withseveral test models no difference to the exact solution wasnoticed. The second observation is that a provably exact k-nearestneighborhood determination may not even be necessary for local

operators such as normal estimation and fairing. Additionally, ifthe framework is modified to compute a fixed-range d neighbor-hood with variable k for each point, then all out-of-range tests canexactly be performed with respect to d.

AcknowledgementsWe would like to thank the Stanford 3D Scanning Repository andDigital Michelangelo projects as well as Cyberware for freelyproviding geometric models to the research community.

References[1] Marc Alexa, Johannes Behr, Daniel Cohen-Or, Shackar Fleishman,

David Levin, and Claudio T. Silva. Point set surfaces. In ProceedingsIEEE Visualization 2001, pages 21–28. Computer Society Press, 2001.

[2] Mario Botsch and Leif Kobbelt. High-quality point-based rendering onmodern gpus. In Proceedings Pacific Graphics 2003, pages 335–343.IEEE, Computer Society Press, 2003.

[3] Mario Botsch, Andreas Wiratanaya, and Leif Kobbelt. Efficient highquality rendering of point sampled geometry. In Proceedings Eurograph-ics Workshop on Rendering, pages 53–64, 2002.

[4] Carsten Dachsbacher, Christian Vogelgsang, and Marc Stamminger.Sequential point trees. In Proceedings ACM SIGGRAPH 03, pages657–662. ACM Press, 2003.

[5] Mark de Berg, Marc van Kreveld, Mark Overmars, and Otfried Schwarz-kopf. Computational Geometry: Algorithms and Applications.Springer-Verlag, Berlin, 1997.

[6] J.P. Grossman and William J. Dally. Point sample rendering. In Proceed-ings Eurographics Rendering Workshop 98, pages 181–192. Eurograph-ics, 1998.

[7] H. Hoppe, T. DeRose, T. Duchampt, J. McDonald, and W. Stuetzle. Sur-face reconstruction from unorganized points. In Proceedings ACM SIG-GRAPH 92, pages 71–78. ACM Press, 1992.

[8] Martin Isenburg and Stephan Gumhold. Compression for gigantic poly-gon meshes. In Proceedings ACM SIGGRAPH 2003, pages 935–942.ACM Press, 2003.

[9] Martin Isenburg, Peter Lindstrom, Stephan Gumhold, and Jack Snoeyink.Large mesh simplification using processing sequences. In ProceedingsIEEE Visualization 2003, pages 465–472. Computer Society Press, 2003.

8

[10] Thouis R. Jones, Fredo Durand, and Mathieu Desbrun. Non-iterative,feature-preserving mesh smoothing. In Proceedings ACM SIGGRAPH2003, pages 943–949. ACM Press, 2003.

[11] Aravind Kalaiah and Amitabh Varshney. Modeling and rendering pointswith local geometry. IEEE Transactions on Visualization and ComputerGraphics, 9(1):30–42, January-March 2003.

[12] Donald E. Knuth. The Art of Computer Programming, 3rd Edition. Add-ison-Wesley, 1998.

[13] Marc Levoy, Kari Pulli, Brian Curless, Szymon Rusinkiewicz, DavidKoller, Lucas Pereira, Matt Ginzton, Sean Anderson, James Davis, Jer-emy Ginsberg, Jonathan Shade, and Duane Fulk. The digital Michelan-gelo project: 3D scanning of large statues. In Proceedings SIGGRAPH2000, pages 131–144. ACM SIGGRAPH, 2000.

[14] Marc Levoy and Turner Whitted. The use of points as display primitives.Technical Report TR 85-022, Department of Computer Science, Univer-sity of North Carolina at Chapel Hill, 1985.

[15] John P. Linderman. rsort and fixcut. man pages, 1996. revised June 2000.[16] Gopi Meenakshisundaram. Theory and Practice of Sampling and Recon-

struction for Manifolds with Boundaries. PhD thesis, Department ofComputer Science, University of North Carolina Chapel Hill, 2001.

[17] Niloy J. Mitra and An Nguyen. Estimating surface normals in noisypoint cloud data. In Symposium on Computational Geometry, pages322–328. ACM, 2003.

[18] Mark Pauly and Markus Gross. Spectral processing of point-sampledgeometry. In Proceedings ACM SIGGRAPH 2001, pages 379–386. ACMPress, 2001.

[19] Mark Pauly, Markus Gross, and Leif P. Kobbelt. Efficient simplificationof point-sampled surfaces. In Proceedings IEEE Visualization 2002,pages 163–170. Computer Society Press, 2002.

[20] Mark Pauly, Richard Keiser, Leif Kobbelt, and Markus Gross. Shapemodeling with point-sampled geometry. In Proceedings ACM SIG-GRAPH 2003, pages 641–650. ACM Press, 2003.

[21] Hanspeter Pfister, Matthias Zwicker, Jeroen van Baar, and MarkusGross. Surfels: Surface elements as rendering primitives. In ProceedingsSIGGRAPH 2000, pages 335–342. ACM SIGGRAPH, 2000.

[22] Liu Ren, Hanspeter Pfister, and Matthias Zwicker. Object space EWAsurface splatting: A hardware accelerated approach to high quality pointrendering. In Proceedings EUROGRAPHICS 2002, pages –, 2002. alsoin Computer Graphics Forum 21(3).

[23] Szymon Rusinkiewicz and Marc Levoy. Qsplat: A multiresolution pointrendering system for large meshes. In Proceedings SIGGRAPH 2000,pages 343–352. ACM SIGGRAPH, 2000.

[24] Jeffrey S. Vitter. External memory algorithms and data structures: Deal-ing with massive data. ACM Computing Surveys, 33(2):209–271, 2001.