The Visual Computer manuscript No.(will be inserted by the editor)

Hanli Zhao ⋅ Charlie C. L. Wang (corresponding author) ⋅ Yong Chen ⋅

Xiaogang Jin

Parallel and Efficient Boolean on Polygonal Solids

Submitted February 6, 2011; Accepted March 11, 2011

Abstract We present a novel framework which can ef-ficiently evaluate approximate Boolean set operationsfor B-rep models by highly parallel algorithms. This isachieved by taking axis-aligned surfels of Layered DepthImages (LDI) as a bridge and performing Boolean oper-ations on the structured points. As compared with priorsurfel-based approaches, this paper has much improve-ment. Firstly, we adopt key-data pairs to store LDI morecompactly. Secondly, robust depth peeling is investigatedto overcome the bottleneck of layer-complexity. Thirdly,an out-of-core tiling technique is presented to overcomethe limitation of memory. Real-time feedback is providedby streaming the proposed pipeline on the many-coregraphics hardware.

Keywords Boolean operations ⋅ Layered DepthImages ⋅ Depth peeling ⋅ Out-of-core ⋅ CUDA

1 Introduction

Boolean operations, such as union (∪), subtraction (−)and intersection (∩), are useful for combining simplemodels to create complex solid objects on a Construc-

tive Solid Geometry (CSG) tree, which has a variety of

H. ZhaoCollege of Physics & Electronic Information Engineering,Wenzhou University, Wenzhou, 325035, ChinaE-mail: hanlizhao@gmail.com

C. C. L. WangDepartment of Mechanical and Automation Engineering, TheChinese University of Hong Kong, Hong Kong, ChinaE-mail: cwang@mae.cuhk.edu.hk

Y. ChenEpstein Department of Industrial and Systems Engineering,University of Southern California, CA, USAE-mail: yongchen@usc.edu

X. JinState Key Lab of CAD & CG, Zhejiang University, Hangzhou,310058, ChinaE-mail: jin@cad.zju.edu.cn

applications in computer-aided design and manufactur-ing (CAD/CAM), virtual reality and computer graphics(e.g., [7, 17, 18]).

Polygonal meshes are the most popular boundaryrepresentation (B-rep) for 3D models. Although manycommercial CAD systems, such as Rhinoceros [3] andACIS [1], are able to compute Boolean on polygons, theyhave difficulty in modeling very complex models (e.g.,the scaffold of Bone as shown in Fig. 1). Polygons pro-vide the simplest way to approximate freeform solids andthe computation of Boolean is not necessary to be ex-act in many areas, such as biomedical engineering, jew-elry industry and game industry. This gives us an op-portunity to overcome the robustness problem [14] andto speed up the computation by using an approximatemethod. Recent researches have shown that densely ori-ented point sets are competent to fulfill such a task. Sev-eral algorithms [4, 23, 32] have been investigated to per-form Boolean on oriented points but they do not operateon B-rep models directly. Some methods [6,30] can pro-cess B-rep models using well-structured points in Lay-ered Depth Images (LDI). However, both the efficiencyand the memory-usage still have much room for improve-ment.

In this paper we aim to develop a framework thatfully exploits the advantages of LDI [27] and the power ofGraphics Processing Unit (GPU) for evaluating approx-imate Boolean operations on polygonal meshes. Our al-gorithm is efficient, parallel, and scalable compared withprior approaches. These good properties are achieved byintroducing the following work. First of all, we adopta compact representation for LDI which contains axis-aligned surfels sampled from the boundary of input solids.By utilizing the atomic operation in graphics global mem-ory, we develop a programmable rasterizer to captureall layers of LDI in a single pass. Moreover, the prob-lem of limited sampling resolution is avoided by split-ting the whole working envelope into multiple smallertiles and processing them independently using the out-of-core strategy. Note that the computation in the wholepipeline is highly parallel, thus allowing for a GPU-based

2 Hanli Zhao et al.

Subtraction

Subtraction

Subtraction

offset-Bone

Bone

Cellular-

Scaffold

Cellular-

Scaffold

Cellular-

ScaffoldSubtraction

Fig. 1 A high-quality osseous scaffold is modeled with our system: (left) input models (Bone, offset of Bone, and cellular-scaffold), (middle) the layout of solids where 3× 3× 3 of cellular-scaffold models are tiled together, resulting in a CSG treewith a depth of 28, (mid-bottom) surfel-represented Boolean result, where surfels with different colors are from differentinput solids, and (right) the cross-section view of the output osseous tissue. The approximation resolution is 512 × 512 inthis example.

implementation. To the best of our knowledge, this isthe first algorithm that is capable of computing Booleancombinations of freeform polygonal shapes in real-time(see the examples shown in Fig. 11). Even for a verycomplex CSG tree such as the one shown in Fig. 1, weare able to obtain the result of the high-quality osseoustissue in 1.7 sec. on an NVIDIA Geforce GTX 480 GPUwhile consuming only 600MB of the graphics memory.

In summary, this paper addresses the following im-portant questions in geometric modeling:

– How to support real-time approximate geometric feed-back for a CSG tree with polygonal models?

– How to support highly accurate approximation thatmay be beyond the memory capacity of graphics hard-ware?

The solution to these problems is the major contributionof our approach.

The rest of our paper is organized as follows. Af-ter briefly reviewing some related previous work in thenext section, Section 3 introduces an overview of ournew Boolean evaluation framework. Section 4 presentsthe parallelization techniques on the GPU in detail. Ex-perimental results and related discussions are given in

Section 5. Finally, Section 6 concludes the advantage ofour approach and suggests some future work.

2 Related Work

Boolean operations of solids have been investigated incomputer graphics for many years. For a comprehensivesurvey, we refer readers to [26]. Here, we only review theBoolean algorithms based on surfels [24] and orientedpoints.

Many approaches [9–12, 25] employ the image-baseddepth-layering or depth-peeling technique to achieve theinteractive rendering of CSG models. They graduallypeel candidate points from the boundaries of CSG prim-itives and only display the nearest boundary points ofthe Boolean result. The points can be fast sampled us-ing the graphics hardware [8] and encoded as pixels inLDI. However, these approaches only solve the fast ren-dering problem but do not provide the ability to obtainthe geometric shape of resultant solids.

Surfel is a representation that can approximate theshape of a solid model on some oriented sample points.Boolean operations on freeform solids represented by sur-

Parallel and Efficient Boolean on Polygonal Solids 3

Fig. 2 A comparison between LDI and CLDI sampled from (left) Bunny with the resolution of 150 × 150 pixels: (middle)three axis-aligned LDI texture arrays with 10, 8, and 8 layers respectively, and (right) the corresponding CLDI with only34.7k, 40.1k, and 30.9k elements respectively. We can see that only 18% pixels of LDI need to be stored in CLDI for therepresentation of the same model.

fels have been developed in [4,23]. Since most CAD/CAMapplications, such as CAE analysis, CNC machining andrapid prototyping, need the B-rep of solid models, addi-tional surface reconstruction from the surfel-representedsolid is required.

Zhou et al. [32] introduced a parallel surface recon-struction algorithm by extending the marching cubes al-gorithm [20] with a GPU-based octree. They also pre-sented an interactive Boolean tool for oriented point set.However, their adaptive marching cubes algorithm tendsto smooth the sharp features in the underlying geometry.Moreover, their in-core reconstruction can only handleoctrees with a limited number of depths.

Chen andWang [6] presented an approximate Booleanapproach that can preserve sharp features in the resul-tant solids. They made use of a variant of LDI, namedas Layered Depth-Normal Images (LDNI), for the effi-cient volumetric test [29], and employed the quadraticerror function (QEF) in dual contouring [15] for sur-face generation. However, only the sampling of LDNIis performed using GPU-based depth peeling whereasother algorithms are performed on the CPU. Althoughmulti-threaded schemes are designed, the parallelism islimited. Wang et al. [30] further transferred the LDNI-based algorithm to the GPU to improve the efficiency.Unfortunately, as the workload on each thread is notwell balanced, the primary algorithm still cannot pro-vide real-time feedback. In addition, their algorithm can-not process models which contain more than 256 LDIlayers because the stencil buffer used in their samplingmethod only has 8 bits in the current graphics hardwarearchitecture. Moreover, redundancy in graphics memoryconsumption seriously limits its applications. All theseproblems are solved by our approach below.

3 Framework Overview

An expression of Boolean operations is usually de-scribed as a binary tree (i.e., CSG tree), on which leavesrepresent primitive shapes and inner nodes are Boolean

Algorithm 1 Streaming Boolean Operations

1: Input Boolean tree accompanied with polygonal meshes2: for each volumetric tile in bounding volume do3: for each axis in {x, y, z} do4: for each node n by depth-first tree traversal do5: if n is a leaf then6: Sample axis-aligned surfels by rasterizing n7: Shell sort per-pixel surfels8: else9: Merge sort candidate surfels from children10: Boolean on the sorted candidate surfels11: end if12: end for13: Obtain boundary surfels from the root node14: Accumulate the QEF matrices for boundary cells15: Mark interior/exterior cells along the axis16: end for17: Output vertices by solving the QEF matrices18: Output indices by connecting boundary cells19: end for20: return merge all tiles of polygons into a closed manifold

operators. First of all, if the out-of-core computation isenabled, the bounding volume is divided into multiplevolumetric tiles with the same size. We then performBoolean on each tile along three axes separately.

The final Boolean result is obtained by recursivelytraversing the CSG tree using the depth-first scheme. Foreach leaf node, we convert the B-rep model into a solidbounded by surfels using axis-aligned ray-casting. Foreach inner node, we first collect all candidate surfels fromits children nodes and sort the merged samples accordingto their depth values. Next, valid boundary surfels areextracted by performing Boolean on the candidate surfelsin an efficient way. After traversing the CSG tree, theresultant surfel-represented solid is obtained at the rootnode.

Efficient surface reconstruction is conducted to out-put B-rep models as the result of Boolean. We developa modified version of dual contouring in this paper. Theoptimal position of each boundary cell is determined bythe QEF matrix, which can be accumulated by all theboundary surfels in the cell.

4 Hanli Zhao et al.

Note that the whole pipeline design is highly parallel,which enables a real-time response by GPU-based imple-mentation. We adopt key-data pairs to store the pointsmore compactly as compared with prior LDI-based algo-rithms. As a result, in addition to memory reduction, theparallelism is also improved as no threads are launchedfor void operations. Algorithm 1 provides the pseudo-code of our approximate Boolean framework.

4 Parallelization on the GPU

As shown in Algorithm 1, except for a few control set-tings, every processing step can be streamed on the many-core graphics hardware, including conversion of poly-gons into surfel-represented solids, Boolean on surfels,B-rep reconstruction and volumetric tiling. We chooseNVIDIA’s CUDA [2] computing environment in our GPUimplementation. CUDA exposes new hardware featureswhich are very useful for data-parallel computation. Oneimportant feature is that it allows arbitrary gatheringand scattering of graphics memory in GPU threads. Inthis section, we introduce our parallel and efficient Booleanalgorithm in detail.

4.1 Compact LDI Data Structure

In the prior approaches, LDI is usually stored as an arrayof two-dimensional textures. Its size grows linearly withthe layer-complexity of a model. However, as shown inFig. 2 (left), the actual number of sampled points in eachtexture decreases significantly with the increase of thedepth layer. Such a primary way to store LDI consumestoo much graphics memory and limits the application ofusing LDI to represent complex models (e.g., the scaffoldmodels in Fig. 1).In this paper, we develop an efficientdata structure to store such sparsely distributed data.

Inspired by the solver developed in [28] for large sparselinear systems which only store non-zero values with cor-responding indices, we adopt a compact representationhere, called CLDI, for the sparse data points in LDI. Oneach pixel in a model represented by LDI, there are mul-tiple surfels with different depth values. We store theirdepth values as well as normals sequentially in a longdata array. The access to each surfel in the data arrayis achieved by using a key array where each key storesthe number of surfels per pixel as well as the index of itsfirst surfel in the long data array. As illustrated in Fig.2 (right), all empty data points (about 82% pixels inthis example) are not stored, thus a significant memoryreduction is achieved.

In order to improve the performance of CLDI, ouralgorithm uses GPU-based parallel primitives [13] heav-ily. The scan primitive is employed to count the requireddata size before allocating a GPU array and to obtainindices of sample points to the array. The compact prim-itive is used to discard empty sample points, while the

Fig. 3 The colored pixels are inside the two adjacent tri-angles according to rasterization rules. The yellow pixels arecovered once while the light blue and dark blue ones are cov-ered twice. The light blue pixels just lie on the silhouetteedge and should be rasterized twice in order to guarantee theclosure of solid represented by surfels.

sort primitive efficiently clusters elements with a sort-ing identifier. In addition to memory reduction, we alsoexplain how CLDI could improve the performance below.

4.2 Robust Sampling

Rasterizer on the graphics hardware is designed accord-ing to rasterization rules about how to map geometricdata into raster data. The raster data are snapped to in-teger locations and per-pixel attributes are linearly inter-polated from per-vertex attributes before being passed toa pixel shader. Any pixel center which falls inside a tri-angle is drawn. A pixel is also assumed to be inside if itlies on the top edge or the left edge of the triangle. Atop edge is an edge that is exactly horizontal and abovethe other two edges of the triangle, and a left edge is anedge that is not exactly horizontal and on the left sideof the triangle.

An edge is called silhouette if two triangles that sharethis edge are facing opposite directions with respect tothe viewpoint. There is a special case that a silhouette isthe top/left edge of its two adjacent triangles and thereare some pixels which just lie on this silhouette. Accord-ing to rasterization rules as well as the depth less compar-ison function, these pixels are rasterized only once in tra-ditional depth-peeling techniques, as illustrated in Fig.3. However, such a case will break the boundary of solidsas described in [6, 29]. To avoid this problem, Wang etal. [30] used the stencil buffer instead of the depth buffer.They peel each layer of surfels by gradually increasingthe stencil value. Unfortunately, such a sampling tech-nique introduces a new issue. The stencil buffer only has8 bits in the current graphics hardware architecture and8-bit data can only represent maximum 256 values. If acomplex B-rep model contains more than 256 LDI lay-ers, missampling will occur because of the stencil buffer.Moreover, modern hardware rasterizers can only capturea rather limited number of fragment data in one renderpass [5,22], thus for complex models, multiple renderingpasses are needed. As a result, sampling B-rep models

Parallel and Efficient Boolean on Polygonal Solids 5

into correct surfel-represented solids becomes the mainbottleneck of Boolean techniques presented in [6, 30].

In this paper, we devise a robust and fast samplingmethod which is inspired by the main idea of FreePipein [19]. First of all, rasterization resolution Rs, axis-aligned bounding box (AABB) and appropriate orthogo-nal model-view-projection matrix are set as input param-eters. Back-face culling is disabled and frustum clippingis enabled. We then rasterize the B-rep model accordingto the scan-line scheme and rasterization rules. For eachscanned pixel, we obtain an interpolated depth. In orderto avoid read-modify-write (RMW) hazards in graphicsglobal memory, the atomicInc operation [2] of CUDA isemployed. We allocate a counter per pixel in global mem-ory and initialize it to 0. With the atomicInc operation,the k-th incoming fragment of a certain pixel increasesthe counter to k + 1 and return the source value k. Fi-nally, the depth and normal are stored into the k-th entryof CLDI without RMW hazards. Note that k is a 32-bitunsigned integer and can be used to sample a model withup to 232 layers.

The proposed sampling algorithm performs two passesof the programmable rasterization. In the first pass, weonly increase the counter array to obtain the per-pixelnumbers of surfels. Then the scan primitive is utilized tocount the size of CLDI and to obtain per-pixel indices toCLDI. In the second pass, all surfel data are truly filled inCLDI. As can be seen in Fig. 2, all layers of surfels arecompactly captured in the second pass. Moreover, twosurfels are correctly sampled on silhouette edges, whichensures the correctness of a solid represented by the sam-pled surfels.

4.3 Boolean on Surfels

To evaluate the result of each inner node on the CSGtree, Boolean operations are performed on the modelsrepresented by the children nodes. The output surfels ofchildren nodes are collected as candidate surfels. Beforeapplying Boolean operations, surfels on a ray must besorted by their depth values. CUDA does not supportrecursive functions, so we choose the Shell sort to obtainsurfels sorted on each pixel from the leaf nodes. For innernodes, since the surfels in each of their children nodeshave been sorted during prior depth-first traversal, one-pass merge sort, which has linear time complexity, canbe used to generate the candidate list of sorted surfels.

Let {pi∣i = 1, 2, ...,m} be the sorted surfels on apixel, di be the depth of pi, and fi be the entry/exitflag of the solid interior represented by children surfels.For each surfel-represented intermediate solid, every per-pixel surfel with even index represents entering the solidinterior and we set fi = 1, while the one with odd in-dex represents leaving and we set fi = −1. For subtrac-tion, the entry/exit flags of surfels from the right childare interchanged to obtain the complement. By going

Intersection

Union

Subtraction

Fig. 4 By processing each pixel independently, the elimina-tion of interior surfels on Sphere and Torus could be highlyparallel. See how the entry/exit flags are changed accordingly.

through {pi∣i = 1, 2, ...,m} sequentially, we identify apair of points pi and pj that satisfy ∣di − dj ∣ ≤ � andfi ⋅ fj < 0, where � is slightly greater than 0. If a pairof such points are identified, both will be removed fromCLDI to avoid the ambiguity introduced by overlappedsurfaces. Then we go through each pi sequentially againand accumulate each fi iteratively. As a result, the en-try of the solid interior increases fi by 1 while the leavedecreases fi by 1. Now, the interior/exterior configura-tion on samples can be easily determined by checking fisequentially: fi = 1 denotes the entry of resultant solidfor union and subtraction whereas fi = 2 denotes theentry for intersection. After applying Boolean on CLDI,invalid surfels are effectively discarded whereas bound-ary surfels are retained. An illustration has been givenin Fig. 4.

Compared with the sparsely distributed textures forstoring LDI or LDNI in prior methods [6, 30], althoughthreads for empty pixels stop immediately, the resourcepreparation and recycling, and thread synchronizationwaste a lot of time. The parallelism is therefore reduced.On the contrary, our method shows better parallelismsince we launch threads only for non-zero pixels whenusing the compact data structure, CLDI.

4.4 B-rep Reconstruction

After the whole CSG tree is traversed using the depth-first strategy, the resultant surfel-bounded solid can beobtained at the root node. An efficient surface recon-struction algorithm is then required to output a B-repmodel. Kobbelt et al. [16] proposed a feature-preserved

6 Hanli Zhao et al.

Fig. 5 A boundary surfel p intersected with the axis-alignedray e corresponds to four adjacent boundary cells C00, C01,C10, and C11.

Fig. 6 2D illustration of (left) Hermite data and (right) thedual contouring.

Extended Marching Cubes method and Ju et al. [15] im-proved their method by using dual contouring to avoidthe explicit test for sharp features. In this paper, we mod-ify their dual contouring to fit for our compact represen-tation and implement it on the GPU.

Since orthogonal projection is used in the samplingstep, each pixel width is � = ∥AABB∥/Rs. The AABBis divided into multiple equal-sized cubic cells with anedge length �. As shown in Fig. 5, each cell is positionedto intersect the axis-aligned sampling rays; thus, the res-olution is Rg = Rs + 1. Each boundary surfel corre-sponds to four adjacent boundary cells and serves as aHermite sample in these cells. The construction of QEFmatrix from these Hermite samples is actually an accu-mulation procedure. At the beginning, the elements ofQEF matrices are all assigned as zero. We then scattereach boundary surfel to its four neighboring cells andappend the related QEF parameters into an array. Weassociate each element of the array with a cell identifierand an index. After scattering, the sort primitive [13] isused to cluster elements with the same identifier. Next,we sum up per-cell QEF parameters and eliminate dupli-cated cell elements by using the compact primitive [13].The resultant QEF matrix is obtained after conductingaccumulation along all the three axes of sampling.

After the QEF matrices of all boundary cells are es-tablished, we can compute optimal positions following Juet al. [15]. We can see the vertices are moved to shape

Fig. 7 The overlapped parts between adjacent tiles are pro-cessed asymmetrically to guarantee a correct topology.

features in Fig. 6. The topology of boundary polygonsis reconstructed simply by processing each axis indepen-dently. For each boundary surfel p, we connect the fouradjacent boundary cells to form a quadrangle. The faceof the quadrangle must conform to the orientation of p.

4.5 Out-of-Core Boolean

The above Boolean evaluation algorithms are computedin-core. However, for very large sampling resolutions, thesize of CLDI can grow quickly beyond the memory capac-ity provided by the graphics hardware even if we employsuch a compact representation. An effective out-of-corescheme is needed to meet the requirement of high ap-proximation accuracies.

In order to fit the graphics memory constraints, wesplit the AABB into smaller volumetric tiles and applyAlgorithm 1 to them independently. The critical partthen is to guarantee that these independently generatedmeshes can be merged into a proper two-manifold sur-face. In this paper, we define the tiles to be overlappedwith their adjacent tiles by one pixel width �. By tak-ing advantage of frustum culling, we only sample sur-fels within current volumetric tiles. During dual contour-ing, for each cell, point scattering and quadrangle outputshould be avoided to be performed more than once (seeFig. 7). Specifically, the surfels in the overlapped partsare not scattered to adjacent tiles. In addition, for eachquadrangle, if any of its four adjacent cells lies in theright, front or top overlapped area, it is discarded. Thisasymmetric contouring technique guarantees that pointscattering and quadrangle output are performed exactlyonce.

The proposed out-of-core technique enables virtuallyunlimited rasterization resolutions since we can split thebounding volume into tiles and process them sequentiallyto save memory or in parallel to reduce computationtime.

Parallel and Efficient Boolean on Polygonal Solids 7

Test Boolean Expression Model Triangles Model Triangles1 CGI2011 ∩ Hexigon CGI2011 5K Hexigon 33K

Bunny 60K offset-Bunny 381K2 Bunny − (offset-Bunny − cubic-Truss) − Sphere cubic-Truss 701K Sphere 30K3 (Dragon ∪ Dragon ∪ Dragon) − Buddha Dragon 49K Buddha 378K

Dinosaur 112K4 Dinosaur − Fandisk − Helix Helix 74K Fandisk 3K

5 Hub − Flower Hub 162K Flower 15K

Table 1 Test Boolean expressions with input models.

Test Resolution LDI Layers for Each Model Memory Triangles

(512× 2)2 (26, 6, 2) + (828, 2, 2) 223MB 2,380K1 (512× 4)2 (26, 6, 2) + (828, 2, 2) 609MB 9,866K

1282 (10, 8, 10) + (10, 8, 8) + (54, 54, 56) + (2, 2, 2) 41MB 227K2 5122 (12, 10, 10) + (14, 10, 12) + (54, 54, 56) + (2, 2, 2) 489MB 3,729K

1282 (12, 14, 8) + (12, 14, 8) + (12, 14, 8) + (12, 16, 10) 18MB 87K3 5122 (14, 16, 10) + (14, 16, 10) + (14, 16, 10) + (16, 22, 10) 274MB 1,441K

1282 (6, 12, 12) + (4, 6, 4) + (6, 8, 8) 7MB 25K4 (512× 2)2 (8, 12, 12) + (6, 6, 4) + (8, 8, 8) 194MB 1,676K

1282 (16, 18, 4) + (8, 6, 6) 17MB 163K5 5122 (16, 18, 4) + (8, 6, 6) 351MB 2,503K

Table 2 Statistics of our tests. The sampling resolutions, peeled LDI layers, graphics memory peaks, and numbers of outputtriangles are reported.

Ours Wang et al.’s MethodTest Coarser Mesh Finer Mesh Coarser Mesh Finer Mesh Rhinoceros ACIS

1 3.68s 12.59s FAILED FAILED FAILED FAILED2 121ms 944ms 717ms 5.32s FAILED FAILED3 84ms 585ms 328ms 2.59s 19s FAILED4 51ms 2.46s 183ms FAILED 10s 633s5 53ms 643ms 202ms 2.09s FAILED FAILED

Table 3 Performance comparisons. In addition to its high efficiency, our system can deal with various complex Booleantrees.

Fig. 8 Validation tests: (top left) input Cube and Cylinderprimitives, (top middle) three component models by − and∩; and for the case of Cylinder tangentially contacting Cube,results of (top right) ∪, (bottom left) Cylinder − Cube and(bottom right) Cube − Cylinder.

5 Results

We have tested our novel Boolean system on a PC witha 2.80GHz Intel Core i5 760 CPU (4GB main memory)and an NVIDIA GeForce GTX 480 GPU (480 streamingprocessors and 1.5GB graphics memory). Our algorithm

uses floating point arithmetic and approximate computa-tion, and involves no explicit intersection calculation. Foreach cubic cell with edge length �, the maximum erroris the diagonal length

√3� (ref. [31]). Fig. 8 shows the

results of validation tests using basic Cube and Cylin-der primitives. Our approach is able to produce Booleansolids with sharp features preserved and robustly dealwith overlapped cases. The subtraction of Cylinder re-sults in a cracked Cube because of the degeneration ofthin shells and the approximation error which is stillwithin our controllable maximum error

√3�. We can

get a better accuracy with a finer grid resolution Rg asmore polygons will be generated. We use low-resolutionintermediate models for real-time preview while high-resolution models for final output.

We further test our algorithm using complex modelsand Boolean expressions listed in Table 1. The corre-sponding statistics are given in Table 2. The maximumresolution of each tile is set as 5122, while the numbers ofLDI layers are counted in x, y and z axes, respectively.Moreover, we record the peaks of graphics memory con-sumed in our algorithm. The output Boolean models areshown in Fig. 9 and Fig. 11, where the intersection partsare zoomed in for better illustration.

With the data compaction and out-of-core techniques,the memory peaks vary from 7MB to 609MB. All the test

8 Hanli Zhao et al.

Fig. 9 An example of CGI2011 ∩ Hexagon: (top left) the input CGI2011 model and hundreds of Hexagons, (top right) theresult of Rhinoceros, (mid-right) the result of ACIS, and (bottom) our result.

0%

10%

20%

30%

40%

50%

60%

70%

80%

90%

100%

Test 1 Coarser Test 1 Finer Test 2 Coarser Test 2 Finer Test 3 Coarser Test 3 Finer Test 4 Coarser Test 4 Finer Test 5 Coarser Test 5 Finer

Conversion to Surfels

Boolean on Surfels

Polygon Reconstruction

Host-Device Transfer

Fig. 10 Statistics of ratio of running time in each step.

data are small enough to be fit in the graphics memoryentirely. In the prior algorithm of Wang et al. in [30],each LDNI pixel requires 8 bytes of graphics memory, so476MB are consumed to store all pixels of LDNI of thefiner hollowed-Bunny and their dual contouring withoutcompaction requires even more memory. Their in-corealgorithm actually cannot model high-resolution solids.We also test to split the CGI2011 model by hundredsof Hexagons and Wang et al.’s system crashes for thistest because the Hexagon model has more than 256 LDIlayers. To our surprise, even Rhinoceros [3] and ACIS [1]fail to produce a correct solid for the decent-topologymodels due to numerical errors, whereas our approach isable to output a satisfying result (see Fig. 9).

Table 3 shows the performance comparisons amongour system, Wang et al.’s system [30], Rhinoceros andACIS. Multi-pass depth peeling and sparse data struc-ture seriously decrease the parallelism of Wang et al.’s

GPU algorithm, their performance still cannot meet therequirement of real-time interaction. On the contrary,more than three times of speedup is gained with ournew approach. The commercial softwares Rhinoceros andACIS can only process simple models and both CPU-based algorithms are naturally much slower than theGPU-based ones. With our novel system, real-time visualfeedback is achieved with the resolution of 1282 and thuscomplex models can be designed on the fly by interactiveediting of CSG trees, as demonstrated in our accompa-nying screen-captured video. Even for models with veryhigh resolutions, we are able to compute the final mod-els within a few seconds. With the increase of capacityof graphics memory, larger tiles can be used to furtherimprove the performance. Since our framework is highlyparallel not only inside each tile but also among tiles, wecan resort to a multi-GPU system or GPU cluster [21]for better approximation and even higher efficiency. Note

Parallel and Efficient Boolean on Polygonal Solids 9

Fig. 11 Example Boolean results with zoomed in (from left to right): Bunny − (offset-Bunny − cubic-Truss) − Sphere,(Dragon ∪ Dragon ∪ Dragon) − Buddha, Dinosaur − Fandisk − Helix, and Hub − Flower.

that prior systems are prone to fail for complex CSGtrees or high resolutions in approximation, whereas oursystem is much more robust.

We give the ratio of running time in each step inFig. 10. Boolean on surfels is rather fast and few dataare transferred between the host and the device. Theefficiency of sampling B-rep models to sorted surfels isdetermined by the layer-complexity of input solids. Poly-gon reconstruction is highly dependent on the samplingresolution and consumes a great portion of time.

6 Conclusions

In this paper, we have presented an efficient solid mod-eling framework which computes approximate Booleanoperations on polygonal solids using highly parallel al-gorithms. The main idea is to convert B-rep models intomodels represented by well structured surfels, discardinvalid interior surfels according to the CSG trees, and

contour them back into B-rep models as output. Booleanon the axis-aligned surfels is rather simple and fast. Bystreaming boolean operations, an out-of-core volumetrictiling technique is introduced to generate highly accurateresults with high sampling resolution.

The number of reconstructed polygons in current im-plementation depends on the sampling resolution. In thefuture we will explore an adaptive technique to furtherimprove the performance in the B-rep reconstruction step.As our CLDI structure is general, we also plan to incor-porate CLDI into various modeling applications.

Acknowledgements

The work was partially supported by HKSAR ResearchGrants Council (RGC) General Research Fund (GRF)on project CUHK/417508. The research of H. Zhao waspartially supported by the Zhejiang Provincial Natu-ral Science Foundation of China (Grant No. Y1110004),

10 Hanli Zhao et al.

the Scientific Research Fund of Zhejiang Provincial Ed-ucation Department, China (Grant No. Y201010070),the Science and Technology Plan Program of Wenzhou,China (Grant No. H20100088) and the Open ProjectProgram of State Key Lab of CAD&CG, Zhejiang Uni-versity, China (Grant No. A1117). The research of X. Jinwas supported by the Zhejiang Provincial Natural Sci-ence Foundation of China (Grant No. Z1110154) and theNational Natural Science Foundation of China (GrantNo. 60833007).

References

1. 3d acis modeling. In http://www.spatial.com. SpatialCorporation, 2010.

2. Cuda programming guide for cuda toolkit 3.0. Inhttp://developer.nvidia.com/object/gpucomputing.html.NVIDIA Corporation, 2010.

3. Rhinoceros. In http://www.rhino3d.com. Robert McNeel& Associates, 2010.

4. Bart Adams and Philip Dutre. Interactive boolean op-erations on surfel-bounded solids. ACM Transactions onGraphics, 22(3):651–656, 2003.

5. L. Bavoil and K. Myers. Order independent transparencywith dual depth peeling. In Technical Report. NVIDIACorporation, 2008.

6. Yong Chen and C. L. Charlie Wang. Layered depth-normal images for complex geometries - part one: Ac-curate modeling and adaptive sampling. In Proceedingsof the ASME International Design Engineering Techni-cal Conferences and Computers and Information in En-gineering Conference, Brooklyn, NY, 2008. ASME.

7. M. de Berg, M. van Kreveld, M. Overmars, andO. Schwarzkopf. Computional Geometry. Springer, 1997.

8. C. Everitt. Interactive order-independent transparency.In Technical Report. NVIDIA Corporation, 2001.

9. J. Goldfeather, J.P.M. Hultquist, and H. Fuchs. Fastconstructive-solid geometry display in the pixel-powersgraphics system. In Proceedings of SIGGRAPH ’86,pages 107–116, New York, NY, 1986. ACM.

10. J. Goldfeather, S. Molnar, G. Turk, and H. Fuchs. Nearreal-time csg rendering using tree normalization and ge-ometric pruning. IEEE Computer Graphics and Applica-tions, 9(3):20–28, 1989.

11. John Hable and Jarek Rossignac. Blister: Gpu-based ren-dering of boolean combinations of free-form triangulatedshapes. In Proceedings of SIGGRAPH ’05, pages 1024–1031, New York, NY, 2005. ACM.

12. John Hable and Jarek Rossignac. Cst: Constructive solidtrimming for rendering breps and csg. IEEE Transactionson Visualization and Computer Graphics, 13(5):1004–1014, 2007.

13. Mark Harris, Shubhabrata Sengupta, and John D.Owens. Parallel prefix sum (scan) with cuda. In HubertNguyen, editor, GPU Gems 3. Addison Wesley, 2007.

14. C. Hoffmann. Robustness in geometric computations.ASME Journal of Computing and Information Sciencein Engineering, 1(2):143–155, 2001.

15. Tao Ju, Frank Losasso, Scott Schaefer, and Joe Warren.Dual contouring of hermite data. ACM Transactions onGraphics, 21(3):339–346, 2002.

16. Leif P. Kobbelt, Mario Botsch, Ulrich Schwanecke, andHans-Peter Seidel. Feature sensitive surface extractionfrom volume data. In Proceedings of SIGGRAPH ’01,pages 57–66, New York, NY, 2001. ACM.

17. Shankar Krishnan, M. Gopi, Dinesh Manocha, andMark R. Mine. Interactive boundary computation ofboolean combinations of sculptured solids. ComputerGraphics Forum, 16(3):67–78, 1997.

18. Shankar Krishnan, Dinesh Manocha, M. Gopi, Tim Cul-ver, and John Keyser. Boole: A boundary evaluationsystem for boolean combinations of sculptured solids. In-ternational Journal on Computational Geometry and Ap-plications, 11(1):105–144, 2001.

19. Fang Liu, Meng-Cheng Huang, Xue-Hui Liu, and En-HuaWu. Freepipe: a programmable parallel rendering archi-tecture for efficient multi-fragment effects. In Proceedingsof the ACM Symposium on Interactive 3D Graphics andGames, pages 75–82, New York, NY, 2010. ACM.

20. William E. Lorensen and Harvey E. Cline. Marchingcubes: A high resolution 3d surface construction algo-rithm. In Proceedings of SIGGRAPH ’87, pages 163–169,New York, NY, 1987. ACM.

21. C. Muller, S. Frey, M. Strengert, C. Dachsbacher, andT. Ertl. A compute unified system architecture forgraphics clusters incorporating data locality. IEEETransactions on Visualization and Computer Graphics,15(4):605–617, 2009.

22. K. Myers and L. Bavoil. Stencil routed a-buffer. In ACMSIGGRAPH ’07 Technical Sketch Program. ACM Press,2007.

23. M. Pauly, R. Keiser, L. P. Kobbelt, and M. Gross. Shapemodeling with point-sampled geometry. In Proceedingsof SIGGRAPH ’03, pages 641–650, New York, NY, 2003.ACM.

24. H. Pfister, M. Zwicker, J. van Baar, and M. Gross. Sur-fels: Surface elements as rendering primitives. In SIG-GRAPH ’00: ACM SIGGRAPH 2000 Papers, pages 335–342, New York, NY, USA, 2000. ACM.

25. A. Rappoport and S. Spitz. Interactive boolean opera-tions for conceptual design of 3-d solids. In SIGGRAPH’97: ACM SIGGRAPH 1997 Papers, pages 269–278, NewYork, NY, USA, 1997. ACM.

26. J. Rossignac and A. Requicha. Solid modeling. Encyclo-pedia of Electrical and Electronics Engineering, 1999.

27. Jonathan Shade, Steven Gortler, Li-wei He, and RichardSzeliski. Layered depth images. In Proceedings of SIG-GRAPH ’98, pages 231–242, New York, NY, 1998. ACM.

28. S. Toledo, D. Chen, and V. Rotkin. Taucs, a li-brary of sparse linear solvers (version 2.2). Inhttp://www.tau.ac.il/˜stoledo/taucs/. 2003.

29. Matthias Trapp and Jurgen Dollner. Real-time volumet-ric tests using layered depth images. In Proceedings ofEUROGRAPHICS ’08, pages 235–238, 2008.

30. Charlie C. L. Wang, Yuen-Shan Leung, and Yong Chen.Solid modeling of polyhedral objects by layered depth-normal images on the gpu. Computer Aided Design,42(6):535–544, 2010.

31. Charlie C.L. Wang. Approximate boolean operationson large polyhedral solids with partial mesh reconstruc-tion. IEEE Transactions on Visualization and ComputerGraphics, Published Online, 2010.

32. Kun Zhou, Minmin Gong, Xin Huang, and Baining Guo.Data-parallel octrees for surface reconstruction. IEEETransactions on Visualization and Computer Graphics,16(6), 2010.