Fast Hybrid Approach for Texturing Point Models

Volume 23 (2004), number 4 pp. 715–725 COMPUTER GRAPHICS forum

Fast Hybrid Approach for Texturing Point Models

Haitao Zhang, Feng Qiu and Arie Kaufman

Center for Visual Computing (CVC) and Computer Science Department, Stony Brook University, Stony Brook, NY 11794-4400, [email protected], [email protected], [email protected]

AbstractWe present three methods for texturing point models from sample textures. The first method, the point parameteri-zation method, uses a fast distortion-bounded parameterization algorithm to flatten the point model’s surface intoone or more 2D patches. The sample texture is mapped onto these patches and alpha blending is used to minimizethe discontinuity in the gaps between the patches. The second method is based on neighborhood matching where acolor is assigned to each point by searching the best match within an irregular neighborhood. The hybrid methodcombines the former two methods, capitalizing on the advantages of both. The point parameterization method isused first to color most of the points, and the point neighborhood-matching method is then applied to the pointsbelonging to the gaps between the parameterized patches to minimize the discontinuity. We opt for fast texturegeneration, while some discontinuities may appear in the gaps of anisotropic textures.

Keywords: texture synthesis, texture mapping, point model, parameterization, neighborhood matching, hybridmethod.

ACM CCS: I.3.7 [Computer Graphics]: Color, shading, shadowing and texture.

1. Introduction

Coloring an arbitrary surface from a sample texture canbe achieved by existing texture synthesis algorithms [1–4].These algorithms use neighborhood matching to find a bestmatch among all pixels of the sample texture. Speed is aconcern for this brute force search although there are somemethods to speed up the search process while compromis-ing the synthesized texture quality. We call these algorithmsneighborhood-matching methods. Another kind of methodsfor texturing arbitrary surfaces is to cover the surfaces withpatches taken from the sample texture [5,6]. A local param-eterization is created for each patch on the surfaces and thetexture is mapped directly onto that parameterized patch. Dis-tortion and discontinuity are the main artifacts that should beminimized. These methods are referred to as texture place-ment [1] or pattern mapping [6]. We call these approachesparameterization methods.

With the development of 3D scanning technologies, rep-resenting an object by a set of surface points has becomean important 3D model format. Levoy and Whitted [7] have

proposed the use of points as a display primitive and as auniversal metaprimitive for objects modeling. Grossman [8]has presented a point-based rendering system for samplingand rendering. Surfels [9] and QSplat [10] use multireso-lution data structures to organize the point samples and de-vise rendering algorithms based on their data structure. Alexaet al. [11] use point sets to represent shapes and apply localparameterization for multiresolution rendering. Zwicker et al.[12] have used Elliptical Weighted Average (EWA) splattingfor rendering. This technique can be accelerated by hardware[13]. Pauly and Gross [14] have introduced some surface sim-plification algorithms for point models. PointShop3D [15] isa point model editing system which supports editing opera-tions directly on the point models. Texture mapping over asurface patch is implemented by using a minimum distortionpatch parameterization algorithm.

Currently, nearly all texture synthesis and texture param-eterization methods for 3D models are applied to surfacemeshes. Alexa et al. [16] have introduced a method forestablishing local frames over point models, which is usedfor texturing point models with a neighborhood-matching

c© The Eurographics Association and Blackwell Publishing Ltd2004. Published by Blackwell Publishing, 9600 GarsingtonRoad, Oxford OX4 2DQ, UK and 350 Main Street, Malden,MA 02148, USA. 715

Submitted August 2003Revised November 2003

Accepted May 2004

716 Zhang et al. /Fast Hybrid Approach for Texturing Point Models

method. For a point model, one way to texture it is to trian-gulate it into a mesh and apply an existing method for meshes.Since point models have no coherence information, triangu-lation is not trivial. After triangulation, parameterization ofthe 3D mesh surface is still needed in texturing the surface. Itis better to devise efficient methods to recover coherence in-formation required for texturing directly from point models.Some operations needed in texturing, such as model hierarchyconstruction are much easier and more efficient when appliedto point models. In this paper, we combine and extend exist-ing texturing methods and apply them to point models. Givena point model and a sample texture, every point of the modelis colored properly so that the surface of the point modelshows a texture pattern similar to the sample texture. We fo-cus on the techniques for fast texture generation over pointmodels from isotropic sample textures. For the anisotropictextures, some discontinuities may appear in limited areas ofthe models.

We present a point parameterization method (Section 3),based on a fast distortion-bounded parameterization algo-rithm to flatten the point model’s surface into one or morepatches. The sample texture is mapped onto these patchesand alpha blending is used to fill in the gaps between patches.The drawback to this method is that discontinuity betweenpatches is unavoidable. In Section 4, we present an alterna-tive method, point neighborhood-matching, which eliminatesthis problem. In our point neighborhood-matching method,an irregular neighborhood is created for every point from itsneighboring points. This is used for finding the best match tocolor the point. A point model hierarchy is built for multires-olution synthesis. This method yields seamless textures butis compute intensive. In order to achieve fast texturing, wepresent a hybrid method (Section 5) to capitalize on the bene-fits of both. The point parameterization method is used first tocolor most of the points, followed by the point neighborhood-matching method for coloring points in the gaps betweenpatches to get a seamless surface texture.

2. Previous Work

2.1. Surface neighborhood-matching methods

The surface neighborhood-matching methods for 3D modelshave been inspired by the success of the 2D texture syn-thesis [17–20]. Based on Markov random field model, DeBonet [18] has synthesized new textures by sampling succes-sive spatial frequency bands from the sample texture. Efrosand Leung [19] have simplified this pixel-by-pixel synthesismethod by taking pixels directly from the sample texture. Theregion of neighboring synthesized points is compared withthe similar regions in the sample texture, and the pixel is col-ored using the best match. The search for the best match is anexpensive process whose run time is proportional to the sizeof the sample texture. Wei and Levoy [20] have used a sim-ilar idea for a multiresolution synthesis method to deal withtextures with large patterns. The shape of the neighborhood

is fixed so that a tree-structured vector quantization can beused to accelerate the neighborhood-matching process for theprice of a slight decrease in texture quality. Ashikhmin [17]has proposed coherent synthesis, which restricts the searchspace for the neighborhood matching to the locations nearthe best matches of the already synthesized neighboring pix-els. Thus, the computation is reduced greatly and it is rathersuccessful in synthesizing textures with highly structured pat-terns, but the discontinuity-free results cannot be guaranteed.

The 2D neighborhood-matching methods have been ex-tended to 3D mesh surfaces [1–4]. For each vertex, a fixedshape neighborhood is created by interpolating in the localparameterization near the vertex. The orientation of the lo-cal parameterization is determined by a vector field spec-ified by the user or created randomly. A mesh hierarchy isbuilt for multiresolution synthesis. Similar to the 2D case, theneighborhood-matching process is still the bottleneck. Yinget al. [4] have also extended the coherent synthesis methodto 3D mesh. Tong et al. [21] have used a neighborhood-matching method to synthesize bidirectional texture func-tions over meshes based on surface textons. Alexa et al. [16]have extended the neighborhood-matching method to pointmodels based on their techniques for generating directionfields over point-sampled geometry. In this paper, we ex-tend the surface neighborhood-matching methods to 3D pointmodels by using an irregular neighborhood.

2.2. Surface parameterization methods

The textures generated by coherent syntheis [4,17] are actu-ally a group of patches taken from sample textures that aretiled together. Instead of synthesizing vertex by vertex (pixelby pixel for 2D), surface parameterization methods createtextures patch by patch and minimize the discontinuities be-tween patches. Efros and Freeman [22] have presented imagequilting, a parameterization method for 2D texture synthesis.They find a minimum error boundary cut in the overlappingblocks to minimize the discontinuity. The patch-based sam-pling method proposed by Liang et al. [23] tries to minimizethe discontinuity by searching the best patch in the sampletexture. Kwatra et al. [24] have used a graph-cut technique tostitch together irregular paths along optimal seams. Nealenand Alexa [25] have used a hybrid method for 2D texturesynthesis by recoloring the overlapping regions after the pa-rameterization method. The lapped textures method proposedby Praun et al. [5] covers a 3D mesh surface by pasting ir-regular texture patches onto it. Alpha blending is used in theregions where patches overlap. Soler et al. [6] have presenteda hierarchical method for texturing arbitrary mesh surfaces.Patches are selected to minimize the fitting error with al-ready textured neighboring patches. If the fitting error is toolarge, the patch is split into smaller ones. Dischler et al. [26]have presented an analytical extension of the lapped texturesmethod. They first segment the sample texture image intoelementary components called texture particles. These tex-ture particles are then recomposed into surfaces according

c© The Eurographics Association and Blackwell Publishing Ltd 2004

Zhang et al. /Fast Hybrid Approach for Texturing Point Models 717

to spatial arrangements computed from the sample texture.In this paper, we present a fast parameterization method forpoint models. Furthermore, we extend the 2D hybrid methodto point models in order to solve the discontinuity problem.

3. Point Parameterization Method

In this section, we describe our point parameterizationmethod for texturing point models based on a fast distortion-bounded point surface parameterization algorithm.

3.1. Algorithm overview

First, we introduce some definitions which are used through-out this paper. A point model is represented by a set of surfacepoints:

P Mn = {pi | pi = (di , ni , ci ), i = 1 to n}, (1)

where n is the number of points, di, ni and ci are the position,normal and color of the ith point pi. We define Nk(pi) asthe k-neighborhood of point pi, which is the set of the firstk nearest points to point pi. The points are organized by ablock data structure. The bounding box of the point modelis segmented into regular blocks and each block containsno more than 100 points. Thus, finding Nk(pi) is fulfilledefficiently by searching in the blocks near pi. The goal oftexturing the point model PMn is to assign the color value ci

for each point pi according to a sample texture.

Our parameterization algorithm flattens the surface of thepoint model PMn into one or more 2D patches. It is a region-growing method which expands the patches by adding neigh-boring points according to some criteria. There are three kindsof points: free points, patch points and gap points. Initially,all points are free points. A patch is started from a seed pointrandomly chosen from the free points. Then, a free point nearthe patch is selected for evaluation. If the distortion caused byadding this free point to the patch is within a certain thresh-old, it becomes a patch point. Otherwise, it becomes a gappoint. The region cannot be grown beyond these gap points.When no free points can be added to the current patch, theiteration for the next patch begins if there are still free pointsleft. Once the iterations end, one or more patches have beencreated and every point is classified as either a patch point ora gap point. The gap points separate neighboring patches ortwo different parts of the same patch. The sample texture ismapped onto the patches and the gap points are textured byalpha blending. This parameterization algorithm is similar tothe mesh parameterization presented by Sorkine et al. [27].Since we are dealing with point models and the goal of ourparameterization is for texturing, the two algorithms differin major steps such as criteria for adding points, distortioncalculation and self-intersection prevention.

3.2. Patch growing with bounded distortion

Each patch point pi is associated with a position qi on the 2Dpatch and the orientation 〈 �Ni , �Si , �Ti 〉 of the patch. When the

A

P

F

Fp

�Np

�Sp

�Tp

�Nf

�Sf

�Tf

Figure 1: Computing position and orientation of candidatepatch point F according to a neighboring patch point P.

patch is created from a seed point pj, it is the tangent planeat point pj. Thus, �N j = n j and 〈�Sj , �Tj〉 is a pair of orthogonalvectors on the tangent plane which determines the orientationof the texture. We assign the orientation randomly or use theprojection of the up vector (0,1,0) on the tangent plane as �Tj .A local coordinate system of the patch is established with theseed point pj as its origin and 〈�Sj , �Tj 〉 as its axes.

A free point F with the maximum number of patch points inits k-neighborhood Nk(F) is selected as the candidate patchpoint. A priority queue of free points is maintained duringthe iterations, which uses the number of patch points in thek-neighborhood as the key for sorting. If pi ∈ Nk(pj), it isvery likely that pj ∈ Nk(pi). We update the priority queuein this way: after adding a point pi to the current patch, allthe free points in Nk(pi) increase their keys by 1. Thus, wecan efficiently get the candidate patch point for the patchexpansion.

The position qf and orientation 〈 �N f , �S f , �T f 〉 of the candi-date patch point F can be computed from each of its neigh-boring patch points. Figure 1 illustrates how to compute qf

and 〈 �N f , �S f , �T f 〉 of F from one of its neighboring patchpoints P. The plane A is defined by the three orthogonalvectors 〈 �Np, �Sp, �Tp〉 of P with normal �Np and local coor-dinates 〈�Sp, �Tp〉.Fp is at the position qf by projecting F toplane A followed by a scaling to make |FpP| = |FP|. Then,plane A is rotated around P (the rotation axis goes throughP and is orthogonal to FpP and FP) until FpP overlaps withF P. 〈 �Np, �Sp, �Tp〉 becomes 〈 �N f , �S f , �T f 〉 after the rotation.The formulas for computing qf and 〈 �N f , �S f , �T f 〉 are given inthe Appendix.

If there are m patch points in Nk(F), we will get m posi-tions and orientations: {(ql

f , 〈 �Nlf ,

�Slf ,

�T lf 〉)|l = 1, . . . , m} for

F. The final position and orientation for F is the weightedaverage of these values, where the weights wl are inverselyproportional to the distance between F and the correspondingpatch points. The three vectors in the weighted average ori-entation 〈 �N f , �S f , �T f 〉 are nearly orthogonal since we restrictthe distortion as discussed below.



Figure 2: Parameterization of a sphere point model. Top-left:parameterized patch (patch points near gaps shown in red).Top-right: color-coding of the parameterization distortion(red for high distortion and blue for low distortion). Bottom-left: before alpha blending (gap points shown in green).Bottom-right: after coloring the gap points.

There are two kinds of distortions in adding point F: posi-tion distortion and orientation distortion. We define the dis-tortions using the average and maximum differences betweenthe m values and the final value:

Dpos(F) = w1

∑ml=1{wl |ql

f − q f |}∑ml=1 wl

+ mmaxl=1

{wl |qlf − q f |}, (2)

Dori(F) = w2

∑ml=1{wl (2 − �Sl

f · �S f − �T lf · �T f )}

∑ml=1 wl

+ mmaxl=1

{wl (2 − �Slf · �S f − �T l

f · �T f )}, (3)

D(F) = w3 Dori(F) + w4 Dpos(F), (4)

A unit length will be introduced later in Section 3.4, whichis used for normalization of the position distortion to makeit scale-independent. If the distortion D(F) is within a user-defined threshold, F becomes a patch point. Otherwise, itbecomes a gap point. We use w1 = w2 = 1, w3 = 3, w4 = 2,threshold = 1.6 without any noticeable distortions. Figures 2and 3 show two examples of our parameterization method.We can see that this parameterization algorithm flattens the3D surfaces by region growing and creating cuts in the regionswhere the distortion exceeds the threshold.

Figure 3: Parameterization of a bunny point model. Top-left: parameterized patch (there are global self-intersectionsinside the yellow circle). Bottom-left: before alpha blending(gap points shown in green). Bottom-right: after coloringthe gap points (there is discontinuity inside the green box,top-right is its close-up view).

3.3. Self-intersection

There are two types of self-intersections: local self-intersections and global self-intersections. A local self-intersection occurs when a surface region folds over on theparameterized patch. When adding a point pi to the patch,we only use those neighboring patch points pj that satisfyni · nj > 0. No noticeable local self-intersection will appearin practice after adding this simple constraint. The globalself-intersection occurs when different regions in the patchoverlap. In Figure 3, there are global self-intersections inthe parameterization of the bunny model. The overlapped re-gions do not overlap in the 3D model and they do not connectdirectly. The global self-intersections will not create any ar-tifacts in the resulting texture. Therefore, in our method, wedisregard global self-intersections.

3.4. Texturing

After the parameterization algorithm, points are classifiedinto patch points and gap points. First, the patch points arecolored by texture mapping. A unit length on the parameter-ized patch which is equivalent to the side length of a pixel inthe sample texture should be determined. We make the pointdensity on the patch roughly the same as the sample textureby taking the average distance between each point and itsnearest point as the unit length. This unit length can be ad-justed by the user to change the texture scale over the model.If the sample texture is tileable, the size of the parameterizedpatch is not restricted, which usually results in a single patchfor the model. Then, a random position is chosen from the



sample texture for the patch origin and the sample texture istiled onto the patch. We need to restrict the size of the patchesif the sample texture cannot be tiled. A size smaller than thesample texture is chosen as the maximum size a patch cangrow to. In the parameterization algorithm, a free point can-not be added into the patch if it makes the patch size largerthan the maximum size. Under this size restriction, more thanone patch will be generated. A random patch within the sam-ple texture is selected for each parameterized patch for thetexture mapping.

The gap points are colored in an order similar to the candi-date patch point selection of the parameterization algorithm:the gap point pi with the maximum number of patch pointsin its k-neighborhood is the next point to color. For eachneighboring patch point of the gap point pi, a position onthat patch for pi can be calculated using the same methoddescribed above. The color in the corresponding sample tex-ture is assigned to pi. Alpha blending is used to blend allthe colors that pi gets. The weights used in the blending areinversely proportional to the distance from pi to the corre-sponding neighboring patch points. The gap point becomesa patch point after coloring. As we can see in the result ofbunny model in Figure 3, discontinuity in the textures withanisotropic patterns cannot be avoided by this parameteri-zation method. This problem can be solved by our hybridmethod discussed in Section 5.

4. Point Neighborhood-Matching Method

In this section, we describe our point neighborhood-matchingmethod for synthesizing textures over a point model. Wei andLevoy [3] and Turk [2] use a regular square neighborhoodin their neighborhood-matching methods for mesh models,which is created by resampling in the local parameteriza-tion surrounding the vertex to be colored. Unlike the meshmodel, where it is easy to find the three vertices of a trianglefor resampling, the point model does not have such coher-ence information. It is a challenging task to create a regularneighborhood on the point model surface. Alexa et al. [16]use a regular grid as the neighborhood in their texture synthe-sis method for point models, and the colors of close samplepoints are used for the neighborhood instead of resampling.We overcome this difficulty by using an irregular neighbor-hood and resample this neighborhood in the sample texture.

The irregular neighborhood is constructed by mapping thek-neighborhood points onto the tangent plane of the point tobe colored, as shown in Figure 4. The mapping is exactly thesame as computing the position of the patch point describedin Section 3. Assuming the point density is roughly uniformover the model surface, which is a 2D manifold, the sizeof an irregular k-neighborhood is equivalent to the size of a√

k × √k square neighborhood. Since the points in the irreg-

ular neighborhood have in general noninteger coordinates,bilinear interpolation is needed to get the corresponding col-ors in the sample texture to be matched. For each point to

Pi

N1

N2

N3

N4

N5

N6

N7

N8

N9

P1

P2

P3

P4

P5

P6

P7P8

P9

Figure 4: Irregular neighborhood of point pi created fromits k-neighborhood. In this example, k = 9, N 9(pi) ={p1, . . . , p9} and {N 1, . . . , N 9} is the irregular neighbor-hood of pi.

be colored, interpolation is required for each pixel in thesample texture. This is time-consuming compared to the reg-ular neighborhood method with only one interpolation on themesh per vertex. We supersample the sample texture of sizeA × B using bilinear interpolation with scale m to create anew texture of size mA × mB. In the neighborhood-matchingprocess, interpolation is avoided by using the nearest pixel inthe new texture. Only those pixels corresponding to the orig-inal sample texture are searched for best match, so that thesize of the search space remains the same although the texturesize has been expanded. In practice, m = 8 is enough to cre-ate the same quality texture as the result from using bilinearinterpolation in the sample texture. The texture orientation isassigned with a fixed or a random direction.

The synthesis order of the points is determined by main-taining a priority queue of uncolored points, which is verysimilar to the candidate patch point selection in our param-eterization method. The key for sorting the priority queue isthe number of the colored points in a k-neighborhood of theuncolored points. Figure 5 shows the synthesized texture af-ter coloring 33%, 66% and 100% points of the bunny pointmodel by using a 25-neighborhood.

4.1. Multiresolution synthesis

In order to use a relatively small neighborhood for sampletextures with a large pattern size, and to capture patterns withdifferent scales, a point model hierarchy should be createdfor multiresolution synthesis [2,3]. Unlike the mesh hierar-chy construction, which needs to update the mesh connec-tivity and maintains surface consistency, constructing a pointmodel hierarchy is simple. There are many algorithms to con-struct a point model hierarchy [14]. Since preserving accurategeometry is not an important issue for the hierarchy, which iscreated for texture synthesis, we use a fast and simple cluster-ing method. Four near points are clustered together to formone point in the lower resolution so that the number of points



Figure 5: From left to right: coloring 33%, 66% and 100% points of the bunny point model using a 25-neighborhood.

Figure 6: Multiresolution synthesis. The dinosaur point model is textured using four-level hierarchy with a 30-neighborhood.The number of points in the four levels are 886, 3518, 14 055 and 56 194, from left to right, top to bottom, respectively.

in a lower resolution is one-quarter of the number of pointsin the higher resolution. In addition, the point density in anyarea in the lower resolution is proportional to the point den-sity in the corresponding area in the higher resolution. Theunclustered point with the maximum number of clusteredpoints in its k-neighborhood is the next point for clustering.On some occasions, an unclustered point cannot find threenearby unclustered points. A new point is still created fromthis cluster although the number of points in the cluster isless than 4. This occurrence is very rare because of the orderof clustering. For example, a lower resolution model createdfrom the dinosaur model of 56194 points has 14055 points,among which only 9 points are from clusters with less than4 points (Figure 6).

In the multiresolution synthesis, a point model hierarchyand a corresponding sample texture pyramid are constructedwith the same depth specified by the user. The texture synthe-sis starts from the lowest resolution to the highest resolution(i.e. the original model). All points in the lowest level in the

model hierarchy are colored randomly. For all other levels,the neighborhood for matching consists of points from twolevels, the colored points in the k-neighborhood of the cur-rent resolution and all the points in the lower resolution cor-responding to the k-neighborhood of the current resolution.

4.2. Coherent synthesis

In the neighborhood-matching process, for every point to becolored, a matching error is computed for every pixel in thesample texture and the color of the pixel with the smallestmatching error is used. This brute force search for findingthe best match is a bottleneck in the neighborhood-matchingmethod. Coherent synthesis [4,17] speeds up this processby decreasing the search space. For each colored point, itremembers the pixel in the sample texture where its colorcomes from. The search space for the best match for a pointpi is restricted to the pixels near the corresponding pixelsof the colored points in Nk(pi). Figure 7 is an example of



Figure 7: Point neighborhood-matching results using a 25-neighborhood on a sphere point model. Left: noncoherentsynthesis using four-level hierarchy, with an average searchspace size of 13 568 (the same as the sample texture size).Middle: sample texture of size 128 × 106. Right: coherentsynthesis, with an average search space size of 23 (disconti-nuity inside the yellow circle).

a coherent synthesis, which can preserve highly structuredpatterns, but cannot guarantee discontinuity-free results.

5. Hybrid Method

Our point parameterization method is fast, yet highly struc-tured patterns can be preserved. Since it cannot guaranteeseamless connection between patches, discontinuity usuallyappears as a noticeable artifact. The point neighborhood-matching method is slow, but there is no discontinuity inthe synthesized textures. By extending the 2D hybrid method[25] to point models, our hybrid method makes full use ofthese two methods and capitalizes on the advantage of both. Itapplies the point parameterization method first to texture thepatch points, followed by the point neighborhood-matchingmethod for coloring the uncolored gap points.

The gap width is approximately√

k/2 when k-neighborhood is used in the parameterization method. If thiswidth is much smaller than the pattern size of the sample tex-ture, discontinuity may still appear after the neighborhood-matching step. In order to avoid discontinuity, gaps are ex-panded to the size of the texture pattern if necessary after theparameterization method. The gap width will increase by

√k

after all the patch points belonging to the k-neighborhood ofany gap point are changed to gap points. If multiresolutionsynthesis is used as the neighborhood-matching step, a pointmodel hierarchy is created from the result of the parameteri-zation method. Points in the lower resolution of the hierarchyare colored points if and only if all the corresponding pointsin the upper resolution are colored points. The uncoloredpoints are textured using neighborhood matching from lowerto higher resolution. When using a large sample texture forthe parameterization method, a smaller sample texture withall texture patterns (this can be a portion of the large sam-ple texture) can be used in the neighborhood-matching step.This can significantly reduce the best match search time sincethe neighborhood-matching processing time is proportional

Figure 8: Hybrid method. Top-left: after the point parameter-ization method (7% gap points). Top-right: after gap expan-sion (23% gap points). Bottom: after the point neighborhood-matching method.

to the size of the sample texture. Figure 8 shows the result ofthe bunny point model using our hybrid method.

6. Results

High speed has been achieved by our texturing methods.Table 1 shows the texturing speed using the methods pre-sented in this paper. All the tests have been conducted on a2.53 GHz P4 PC with 1 G RAM. All processing steps such asfinding k-neighborhood of each point are counted for the com-putation time. The point parameterization method can reacha speed above 26 000 points/sec. Except for the coherent syn-thesis, the running time for the point neighborhood-matchingmethod is proportional to the sample texture size and theneighborhood size. In the hybrid method, 70–95% of thepoints are colored by the point parameterization method andthe remaining points are textured by the point neighborhood-matching method. The average speed of the hybrid methodis about 900–4000 points/sec. Our parameterization methodand hybrid method for point models are much faster than theexisting methods for mesh models [2,3,5,6]. For example,



Table 1: Texturing Speed

Number Sample Texture Neighborhood Total Time SpeedModel of Points Size Size (seconds) (point/sec)

Point Parameterization MethodSphere 16386 64 × 64 25 0.30 54 620Bunny 34834 128 × 128 36 0.96 26 285Santa 75781 128 × 128 25 1.83 41 410Dinosaur 56194 64 × 64 36 1.52 36 969

Sample Texture Neighborhood Hierarchy Coherent Total Time SpeedSize Size Levels Synthesis (seconds) (point/sec)

Point-Neighborhood-Matching Method (Test Model: Dinosaur With 56 194 Points)64 × 64 25 1 N 70 83964 × 64 49 1 N 120 466128 × 128 25 1 N 244 23064 × 64 25 4 N 130 431128 × 128 49 4 N 894 6264 × 64 25 1 Y 1.8 31 012128 × 128 49 1 Y 4.5 12 361

Number Sample Texture Neighborhood Hierarchy Coherent Gap Point Total Time SpeedModel of Points Size Size Levels Synthesis Percentage (seconds) (points/sec)

Hybrid MethodBunny 34 834 64 × 64 25 1 N 12 8.2 4254Bunny 34 834 64 × 64 25 4 N 13 13.6 2559Bunny 34 834 64 × 64 49 4 N 13 24.3 1433Santa 75 781 64 × 64 25 3 N 9.7 23.7 3203Santa 75 781 128 × 128 25 3 N 10 82.4 920Dinosaur 56 194 64 × 64 25 4 N 27 39.6 1417Dinosaur 56 194 128 × 128 49 1 Y 27 2.9 19 133

Wei and Levoy [3] report that the synthesis time for a spheremesh model with 24 576 vertices using a sample texture ofsize 64 × 64 is 695 seconds with exhaustive search or 82seconds with TSVQ acceleration on a 450 MHz Pentium IImachine, excluding the preprocessing time. For comparisonpurposes, we have used the same sample texture for a spherepoint model with 32 769 points using our hybrid method ona 500 MHz Pentium II machine. The running time is 41 sec-onds, including all the operations such as k-neighborhoodsearch and point model hierarchy construction.

Figure 9 shows more results of our texturing methods forpoint models. We can see that the texture quality is compara-ble to the best results of existing methods [2,3,5,6] for meshmodels. The images that appear in this paper are all renderedby EWA splatting [12].

In the parameterization method, texture orientation is notconsidered in the patch expansion. For isotropic textures,this is not a problem. For anisotropic textures, inconsistencyof texture orientation will appear in the boundaries of the

patches (for example, the ball joint in Figure 9). The hybridmethod uses the parameterization method as the first step,thus also bears the same limitations.

7. Conclusions and Future Work

We have presented several methods for texturing point mod-els directly from sample textures, focusing on isotropic tex-tures. The point parameterization method is fast while thepoint neighborhood-matching method can create seamlesstextures. The hybrid method combines these methods to-gether so that a seamless texture can be quickly generated.

One interesting issue for future work is to use the graph-ics hardware which supports fragment programming andfloating-point precision to accelerate the best match searchin the neighborhood-matching process. Given a sample tex-ture I, a neighborhood containing m points with positions{offset(i)|i = 1, . . . , m} and colors {color(i)|i = 1, . . . , m},the matching error for pixel i can be expressed by the follow-ing equation:



Figure 9: More texturing results: rocker arm (parameterization method), ball joint (parameterization method), engine part(hybrid method), dragon (hybrid method), vase (hybrid method) and happy buddha (parameterization method).



Figure 10: Left: original point model of Santa and four sample textures; right: new textures synthesized over four parts ofthe model using the sample textures. The hat texture is synthesized using our hybrid method; the coat and trousers textures aresynthesized using our point parameterization method; and the shoes texture is synthesized with our point neighborhood-matchingmethod.

ERRORi =m∑

j=1

{[I (i + offset( j)) − color( j)]2}. (5)

A fragment program is generated from the m position andcolor values while the sample texture is binded as texture.Five instructions are needed for one term in equation (5): tex-ture coordinate calculation, texture fetching, substraction, dotproduct and addition. The matching error results for all pixelsare saved in an off-screen floating-point pixel buffer withoutany loss of precision. We have successfully implemented itusing GeForce FX 5800 Ultra graphics card. Currently, thesynthesis speed is slower than software implementation. Webelieve that this is a promising direction to explore.

There are several other possible directions for future work.It is possible to incorporate the method for assigning directionfields over the point model [16] to make the texture orientationas consistent as possible. One challenge is how to maintain theassigned texture orientation consistency in the patch expan-sion of the parameterization method. It is more useful to usedifferent textures in different regions of the model. We seg-ment the model (for example, the Santa model in Figure 10)manually and apply the texturing method to each part. It isbetter to incorporate automatic or semi-automatic segmen-tation methods to make the process more flexible. Memorywill become a bottleneck when the number of points in themodel is very large. Out-of-core methods could be developedto deal with large point models.

Acknowledgments

This work has been partially supported by a NSF grant CCR-0306438 and ONR grant N000140110034. The point modelsare courtesy of Cyberware and Stanford University ComputerGraphics Laboratory.

Appendix

Formulas for computing the position qf and the orientation〈 �N f , �S f , �T f 〉 in the parameterization method (Figure 1):

�V = F − P,

�V0 = �V /| �V |,q f = ( �V · �Sp, �V · �Tp),

�N ′f = �Np − ( �V0 · �Np) �V0,

�N f = �N ′f /| �N ′

f |,�T f = ( �V0 · �Tp) �V0 + ( �V0 · �Sp) �N f × �V0,

�S f = �T f × �N f .

Free point F should satisfy:

| �V0 · �Np| �= 1.

Otherwise, free point F is in the direction of the normal ofpatch point P. Thus, F should not be added to the patch.



References

1. G. Gorla, V. Interrante and G. Sapiro. Growing fittedtextures. In SIGGRAPH, p. 191, August 2001.

2. G. Turk. Texture synthesis on surfaces. In SIGGRAPH,pp. 347–354, 2001.

3. L. Wei and M. Levoy. Texture synthesis over arbi-trary manifold surfaces. In SIGGRAPH, pp. 355–360,2001.

4. L. Ying, A. Hertzmann and D. Zorin. Texture and shapesynthesis on surfaces. In EUROGRAPHICS RenderingWorkshop, pp. 301–312, 2001.

5. E. Praun, A. Finkelstein and H. Hoppe. Lapped textures.In SIGGRAPH, pp. 465–470, 2000.

6. C. Soler, M. Cani and A. Angelidis. Hierarchical patternmapping. In SIGGRAPH, pp. 673–680, 2002.

7. M. Levoy and T. Whitted. The Use of Points as a DisplayPrimitive. Technical Report 85-022, Computer ScienceDepartment, University of North Carolina at Chapel Hill,January 1985.

8. J. P. Grossman. Point Sample Rendering. MSc thesis,Department of Electrical Engineering and Computer Sci-ence, MIT, August 1998.

9. H. Pfister, M. V. Zwicker, J. Baar and M. Gross. Sur-fels: Surface elements as rendering primitives. In SIG-GRAPH, pp. 335–342, 2000.

10. S. Rusinkiewicz and M. Levoy. QSplat: A multiresolu-tion point rendering system for large meshes. In SIG-GRAPH, pp. 343–352, 2000.

11. M. Alexa, J. Behr, D. Cohen-Or, S. Fleishman, D. Levinand C. T. Silvay. Point set surfaces. IEEE Visualization,21–28, October 2001.

12. M. Zwicker, H. Pfister, J. van Baar and M. Gross. Surfacesplatting. In SIGGRAPH, pp. 371–378, 2001.

13. L. Ren, H. Pfister and M. Zwicker. Object space EWAsurface splatting: A hardware accelerated approach tohigh quality point rendering. In EUROGRAPHICS 2002Proceedings, pp. 461–470, 2002.

14. M. Pauly and M. Gross. Efficient simplification of point-

sampled surfaces. In IEEE Visualization, pp. 163–170,2002.

15. M. Zwicker, M. Pauly, O. Knoll and M. Gross. Pointshop3D. An interactive system for point-based surface edit-ing. In SIGGRAPH, pp. 322–329, 2002.

16. M. Alexa, T. Klug and C. Stoll. Direction fields overpoint-sampled geometry. Journal of WSCG, 11(1):27–32, 2003.

17. M. Ashikhmin. Synthesizing natural textures. In Sympo-sium on Interactive 3D Graphics, pp. 217–226, 2001.

18. J. S. D. Bonet. Multiresolution sampling procedure foranalysis and synthesis of texture images. In SIGGRAPH,pp. 361–368, 1997.

19. A. A. Efros and T. K. Leung. Texture synthesis by non-parametric sampling. In International Conference onComputer Vision, pp. 1033–1038, 1999.

20. L. Wei and M. Levoy. Fast texture synthesis using tree-structured vector quantization. In SIGGRAPH, pp. 479–488, 2000.

21. X. Tong, J. Zhang, L. Liu, X. Wang, B. Guo and H. Shum.Synthesis of bidirectional texture functions on arbitrarysurfaces. In SIGGRAPH, pp. 665–672, 2002.

22. A. A. Efros and W. T. Freeman. Image quilting for tex-ture synthesis and transfer. In SIGGRAPH, pp. 341–346,2001.

23. L. Liang, C. Liu, Y. Xu, B. Guo and H. Shum. Real-time texture synthesis by patch-based sampling. ACMTransactions on Graphics (TOG), 20(3):127–150, 2001.

24. V. Kwatra, A. Schodl, I. Essa, G. Turk and A.Bobick. Graphcut textures: Image and video synthesisusing graph cuts. In SIGGRAPH, pp. 277–286, 2003.

25. A. Nealen and M. Alexa. Hybrid texture synthesis. InEUROGRAPHICS Symposium on Rendering, pp. 97–105, 2003.

26. J. M. Dischler, K. Maritaud, B. Levy and D. Ghazanfar-pour. Texture particles. In EUROGRAPHICS 2002 Pro-ceedings, 21(3):401–410, 2002.

27. O. Sorkine, D. Cohen-Or, R. Goldenthal and D. Lischin-ski. Bounded-distortion piecewise mesh parameteriza-tion. IEEE Visualization, pp. 355–362, 2002.


Documents

Fast Hybrid Approach for Texturing Point Models