Accelerating Evolutionary Construction Tree Extraction via Graph Partitioning
Markus Friedrich, Sebastian Feld, Thomy Phan, Pierre-Alain Fayolle
AAccelerating Evolutionary Construction Tree Extraction viaGraph Partitioning
Markus Friedrich, Sebastian Feld, Thomy PhanInstitute for Computer ScienceLudwig-Maximilians-University MunichOettingenstr. 6780538 Munich, Germany{markus.friedrich|sebastian.feld|thomy.phan}@ifi.lmu.de Pierre-Alain FayolleDivision of Information and SystemsThe University of AizuAizu-Wakamatsu City965-8580 Fukushima, [email protected]
ABSTRACT
Extracting a Construction Tree from potentially noisy point clouds is an important aspect of Reverse Engineeringtasks in Computer Aided Design. Solutions based on algorithmic geometry impose constraints on usable modelrepresentations (e.g. quadric surfaces only) and noise robustness. Re-formulating the problem as a combinatorialoptimization problem and solving it with an Evolutionary Algorithm can mitigate some of these constraints at thecost of increased computational complexity. This paper proposes a graph-based search space partitioning schemethat is able to accelerate Evolutionary Construction Tree extraction while exploiting parallelization capabilities ofmodern CPUs. The evaluation indicates a speed-up up to a factor of 46 . .
2% to 88 . Keywords
Reverse Engineering (RE) – i.e., the recovery of amodel’s geometric representation from potentiallynoisy and incomplete sensor data – is an importantaspect of modern Computer Aided Design (CAD)pipelines. It allows for convenient model editing basedon real-world physical objects, thus simplifying andaccelerating the product design process. An expressiveand intuitive model representation scheme extensivelyused in solid modeling is Constructive Solid Geom-etry (CSG). It describes complex rigid solids by abinary tree with regularized Boolean set-operations(e.g., union, intersection, subtraction) as inner nodesand primitive solids (e.g., cubes, spheres, cylindersand cones) as leaves. Such a tree is also known as amodel’s Construction Tree. Due to the popularity ofCSG in CAD, it is desirable to have tools at hand thatare able to reliably recover a model’s CSG-tree fromits point cloud representation stemming from sensorrecordings. CSG-tree generation might be solved by
Permission to make digital or hard copies of all or part ofthis work for personal or classroom use is granted withoutfee provided that copies are not made or distributed for profitor commercial advantage and that copies bear this notice andthe full citation on the first page. To copy otherwise, or re-publish, to post on servers or to redistribute to lists, requiresprior specific permission and/or a fee. converting the input point cloud to a Boundary Repre-sentation (B-rep) and then by conversion of the B-repto CSG with methods based on algorithmic geometrythat usually require exact geometric intersectioncomputations [SV93, BC04]. These approaches areusually restricted to a single model representation forprimitives, e.g. a surface description that uses quadrics,and can be sensitive to inexact representations.To overcome these constraints, CSG-tree generationcan be formulated as a combinatorial optimizationproblem over the possible permutations of primitivesand set-operations for a fixed maximum CSG-treedepth. Metaheuristics, like Genetic Algorithms (GAs)can then be employed for optimization [Mit98].One of the most severe disadvantages of GA-basedsolutions are computation times of minutes and hoursfor comparably small models (less than 10 primitives)[FP16]. This issue is addressed in this paper.The basic idea of the described acceleration schemeis to exploit spatial relationships between primitives:Primitives that do not overlap spatially are not con-sidered to be operands of a CSG-operation. Thisknowledge can be used to partition overlapping primi-tives and to compute partial per-partition results that arelater on merged into a single CSG-tree. In particular,this paper makes the following contributions: a r X i v : . [ c s . G R ] A ug An acceleration scheme based on spatial searchspace partitioning together with a robust mergemechanism. • A description and analysis of parallelization strate-gies for the proposed algorithms.The paper has the following structure: Section 2 dis-cusses related work in the field of CSG-tree extractionand surface reconstruction. It is followed by an in-troduction to the theoretical principles of the proposedmethod (Section 3). The problem to solve is detailed inSection 4. The proposed solution is described in Sec-tion 5 and evaluated in Section 6. Section 7 summarizesthe results and sketches possible future work.
This work is related to different domains such as sur-face reconstruction from discrete point clouds, ReverseEngineering of solid models and conversion from B-repto CSG. In this section, important related work in thesedomains is briefly discussed.
The problem of reconstructing a surface from a discretepoint cloud has been the subject of much attention incomputer graphics. The most popular methods includefitting implicit surfaces such as [OBA + +
17] presents a widesurvey of the topic. Using these methods, the recon-structed objects lack information that can be used forinspection or re-use of the object in further modeling.
The goal of Reverse Engineering is the creation ofconsistent geometric models from point cloud data[VMC97, BMV01]. They usually output B-rep modelsmade of parametric patches.The conversion from B-rep to CSG was first inves-tigated for two-dimensional, linear polygons, thenlater extended by Shapiro et al. for handling curvedpolygons [SV91b, Sha01]. The extension to three-dimensional objects was initially solved by Shapiroand Vossler in [SV91a, SV93] and later improved byBuchele and Crawford in [BC04]. These works rely onthe fact that surfaces are composed of quadric surfacepatches. Another issue is the handling of inexact repre-sentations. These methods work under the assumptionthat the patches form a clean partition of the targetsolid. However, in practice, we are dealing with inputpoint clouds that are potentially noisy, contain holes,or have additional details and thus the fitted primitivesmay not fit perfectly. This could impact the cellularclassification on which these methods rely.
In [XF14], a greedy approach is used to build a CSG-representation with cuboids as primitives. This ap-proach is limited to the reconstruction of buildings.Close to the proposed approach are methods that handlenoisy and incomplete point clouds such as [SWK07] forfitting primitives and methods that try to convert themto a higher level representation such as [FP16], see also[BTS +
17, Sections 7 and 8]. One of the goals of thiswork is to improve the running time of the EvolutionaryAlgorithm used in [FP16] via geometric consideration,i.e. the overlapping in space of primitives.
The extraction of a CSG-tree from a point cloud posesa complex problem which is usually solved with a pro-cessing pipeline that comprises the following steps:1.
Point cloud generation and pre-processing:
Pointclouds are generated by laser scanners or tactilemeasurement devices. Other techniques use pho-togrammetric algorithms to gather depth informa-tion from (un-)calibrated camera images [HZ03].Measured point clouds usually contain significantamounts of noise and outliers. These can be trimmedfrom the data-set using e.g. statistical approaches[RC11].2.
Point cloud segmentation and primitive fitting:
The point cloud must be segmented and primitiveparameters have to be fitted to the correspondingpoints. Approaches that fulfill both tasks for simplegeometric shapes are e.g. specialized variants of theRandom Sample Consensus (RANSAC) technique[SWK07].3.
CSG-tree generation:
CSG-tree generation can bedone with methods based on algorithmic geome-try such as [SV93, BC04], or via evolutionary ap-proaches such as [FP16] for handling inexact repre-sentations.4.
CSG-tree optimization:
The resulting CSG-treemight not be optimal in terms of size and depth.Additional optimization techniques can simplify thetree structure [SV91a].
Primitives are basic shapes located at CSG-tree leaves.A primitive p is fully described by its signed distancefunction f p : R (cid:55)→ R . The surface of p is implicitlydefined by the zero-set of f p : { x ∈ R : f p ( x ) = } . Itssurface normal at point x ∈ R is given by the gradi-ent ∇ f p ( x ) . If the gradient does not exist at x or is tooexpensive to compute, finite difference approximationscan be used. .3 Boolean Set-Operations The set-operations intersection, union, complementand subtraction are implemented using min- andmax-functions [Ric73]: • Intersection: S ∩ S : = min ( f S , f S ) • Union: S ∪ S : = max ( f S , f S ) • Complement: S : = − f S • Subtraction: S \ S : = S ∩ S where S i is the solid corresponding to the set { x ∈ R : f S i ≥ } ( i = , Evolutionary Algorithms are biology-inspired, stochas-tic metaheuristics for solving optimization problems[ES + + + The problem of accelerating GA-based CSG-tree ex-traction from point clouds is considered as the open re-search question addressed by this paper. The focus ison CSG-tree generation and optimization (step 3 and4 of the pipeline detailed in Section 3.1). As input,a point-set of potentially noisy 3-d measurements of a connected geometric model is considered. We also as-sume that the point-set is already segmented with fittedprimitives, using techniques depicted in step 1 and 2 ofthe pipeline described in Section 3.1.The desired output is a CSG-tree that represents thescanned real-world model as accurately as possible. Ameasure for accuracy is given by the distance betweenthe CSG-tree induced surface and the points of the in-put point cloud. CSG-tree extraction approaches basedon a GA [FP16] can handle inaccuracies but come withthe disadvantage of potentially high computation times.
The basic idea for accelerating CSG-tree extraction isto partition the search space into independent groups ofspatially overlapping primitives. This exploits the factthat primitives that do not overlap are not considered tobe operands of a CSG-operation. CSG-tree extractionis then conducted on a per-partition level. Finally, re-sulting trees are combined in a subsequent merge stepwithout loss of result quality and correctness.An overview of the full CSG-tree extraction pipeline isdepicted in Fig. 2. Each of the steps is described in de-tail in the following sub-sections, following the order ofexecution. (a) Primitives. (b) PO-graph. (c) Partitions.(d) Per-partition trees. (e) Merged tree.
Figure 2: The search space partitioning pipeline.
For expressing spatial relationships between primitives,the Primitive Overlap (PO)-graph is introduced. Itrepresents spatial overlap between primitives using anundirected graph G = ( P , O ) , where P = { p , . . . , p n p } is the set of n p primitives as vertices and O is the edge-set that contains 2-tuples of overlapping primitives o = ( p i , p j ) , where i , j ∈ { , . . . , n p } with i (cid:54) = j .The PO-graph is generated based on the location,orientation and geometric shape of the primitives, seeFig. 2b. Complex shapes can be approximated withsimpler bounding volumes like Oriented Boundingoxes (OBBs) or the convex hull of the correspondingpoint-set [PH77].For better scalability, the computational complexity canbe reduced from O ( n p ) (overlap check between eachprimitive and each other primitive) to O ( n p log ( n p )) using hierarchical space partitioning schemes like e.g.Octrees [Mea82]. With known primitives and their spatial relations givenby the PO-graph, the goal is now to find independentsearch space partitions.A partition is a set of primitives in which each primitivehas an overlap with each other primitive. In this con-text, independence means that per-partition solutionsare not influenced by the solutions of other partitions.See Fig. 3 for explanatory examples.The problem of finding all independent search spacepartitions is equivalent to the problem of finding allmaximum complete subgraphs (maximum cliques) in G . For finding the set of maximum cliques in G , theBron-Kerbosch Algorithm (BKA)[BK73] is employeddue to its behavior on random graphs: It was experi-mentally shown in [BK73] that the computational com-plexity of BKA is almost independent of graph size forrandom graphs. In a worst case scenario (using Moon-Moser Graphs [MM65]), computational complexity isproportional to ( . ) n , where n is the size of the graph.Note that, if there is only a single partition for a par-ticular PO-graph, the search space partitioning methoddegenerates to standard GA-based CSG-tree extraction. A BCD (a) Incorrect.
A BCD (b) Correct.
Figure 3: In (a), per-patition solution parts containingA and C are partially influenced by B (red area) but Bis not part of the partition. In (b), D is not part of thepartition and influences C only in an area (green) thatdoes not overlap with other partition members. Thus,per-partition solutions are not influenced by D.
With known partitions, CSG-tree extraction isconducted for each partition separately in a divide-and-conquer manner. A variant of the GA described in[FP16] is used with the objective function E ( t ) : = | S | ∑ i = (cid:110) e − d i ( t ) + e − θ i ( t ) (cid:111) − α · size ( t ) , (1) where t is the tree candidate, S is the point-set cor-responding to the partition’s primitives and size ( t ) isthe number of nodes in tree t weighted by a factor α . d i ( t ) = β · f t ( s i ) is the signed distance between point s i and the surface defined by tree t weighted by a fac-tor β . θ i ( t ) = γ · arccos ( ∇ ˆ f t ( s i ) · n i ) is the angle be-tween the point normal n i and the normalized gradientat position s i weighted by a factor γ . α , β and γ areuser-controlled parameters. The first term in Equation1 (under the sum) estimates how close the surface in-duced by t matches the point cloud, while the secondterm penalizes trees with a large number of nodes. Thegiven objective function has to be maximized for t .Initially, the population T is filled with n T randomlygenerated trees with a height ≤ h max . For the maximumtree height, the approximation h max ≈ (cid:113) π / · n pp · ( n pp − ) (2)is used, where n pp is the number of primitives in thepartition. It is based on the average height of binarytrees for a given number of internal nodes [FO82] andachieved good results in all experiments carried out.Each GA iteration i contains the following steps:1. The population of the previous iteration T i − isranked according to Equation 1.2. The current population is initialized with the n b bestcandidates from T i − .3. As long as T i has not reached maximum populationsize n T , two candidates are selected from T i − via Tournament Selection parameterized with k ts (the size of the set of randomly chosen populationmembers from which the best member is selected)[MG95]. During crossover, the two selected candi-dates exchange randomly selected subtrees with aprobability of γ cr . Then, with a probability of γ mu ,each resulting tree is mutated. Either a randomlychosen subtree is replaced with a new randomlygenerated subtree with a probability of µ mu . Or,with a probability of 1 − µ mu , the whole tree isreplaced with a new randomly generated tree.4. The termination condition is met if the score of thebest CSG-tree candidate of an iteration does not im-prove over n tc iterations.The most computationally expensive step in GA-basedCSG-tree recovery is the evaluation of Equation 1 foreach element of a candidate-set. Since evaluations canbe conducted for each candidate independently, parallelprocessing schemes can be applied efficiently. In ad-dition, the solution space partitioning allows for a per-partition parallelization strategy. Both options were im-plemented for multi-core processors. Their evaluationis discussed in Section 6. .4 Merge of Per-Partition Trees Merging all trees corresponding to partitions into a sin-gle tree is not trivial. A simple union of all tree rootnodes may lead to incorrect results if primitives that arepart of multiple cliques are not splitted. Split operationson arbitrary primitive shapes tend to be complex andshould be avoided. See Fig. 4 for examples. The pro-posed merge strategy does not need splits but insteadtries to merge trees with a subtree in common. Resultcorrectness is given since no additional operations areintroduced and operation order is preserved. The strat-egy consists of the following steps:1. All trees are inserted in a list L without any spe-cific order. Extracted trees might contain artefactsaffecting their mergeability (e.g., intersections withthe same primitive for both operands). For each treein L , artefacts are removed by traversing the tree andreplacing found patterns iteratively with their sim-plifications (e.g., replacing p ∩ p with p ). The pro-cess ends if no more artefacts can be removed.2. Two trees t and t are removed from the headof L , and their largest common subtree t lcs iscomputed (with a computational complexity of O ( max ( size ( t ) , size ( t ))) ). The subtree’s leaf-setmust be a subset of the leaf-sets of both, t and t .The largest common subtree found might exist morethan once in both trees. Thus, the root nodes of eachappearance of the subtree in t and t are stored inthe lists N and N (see Fig. 5a).If t lcs is empty, t is appended to L and a new treecandidate t is removed from the head of L . In thiscase, the largest common subtree search is repeatedwith the new t .3. For each node in N and N , we check if it is avalid merge candidate by traversing the correspond-ing tree ( t or t ) from root node to leaves followingAlgorithm 1. If the node can be reached this way, itis considered a valid merge candidate. The node isthen replaced by the root of the other tree resultingin a merged tree t m . If more than one valid candidateexists, the candidate corresponding to the larger treeis replaced by the root of the smaller tree. If bothtrees are of the same size, the candidate of t is cho-sen (see Fig. 5b).If there is no valid merge candidate, the procedureis repeated with the next smaller common subtree in t and t . If no other common subtree exists, t isreplaced by a new tree candidate from the head of L . Then, the largest common subtree search and itssubsequent steps are repeated with the new t .4. The merged tree t m is prepended to L .5. The merge process continues until there is only asingle node left in L . Since the model to recon- struct is connected, a pair of mergeable trees existsin each iteration. Thus, the merge process alwaysterminates.Figure 4: Merge strategies. Top: Wrong tree mergeusing union over all partition trees. Erroneous geometryin red (compare with Fig. 2a). Bottom: Correct treemerge using union over all partition trees with primitivesplitting (green curve). (a) (b) Figure 5: (a) Two merge trees ( t left, t right) with alargest common subtree (green). N contains the purplenode, N the orange node. (b) The merged tree t m . def isValid( curNode, node ) :if curNode = node :return true if curNode.nodeType = Operation :if curNode.operationType = Difference :return isValid( curNode.children[0],node ) elif curNode.operationType = Union :for child ∈ curNode.children :if isValid( child, node ) :return true return false isValid( t.root, node ) Algorithm 1:
Checks if node node is a valid mergecandidate in tree t .The merge process has an asymptotic computationalcomplexity of O ( | L | ) since in the worst case L has tobe traversed for each merge. EVALUATION
The proposed partitioning scheme has been evaluatedon a laptop with quad core CPU and 16GB of RAMon four different models. For models M0, M1 andM2, point clouds were generated by sampling a pre-defined CSG-model that served as ground-truth. Gaus-sian noise ( µ = . , σ = . ) was added to the pointsto simulate measurement errors. Model M3 is based onreal measurements, and primitive fitting was done withRANSAC [SWK07]. See Fig. 10 for the intermediatesteps results for model M1, and Fig. 11 for point cloudsand renderings for models M0, M2 and M3. Table 1depicts model details. M0 M1
M2 M3 • Baseline:
Single-threaded (BST), multi-threadedGA (BMTGA). • Search Space Partitioning:
Single-threaded (SST),per-partition multi-threaded (SMTP) multi-threadedGA (SMTGA), per-partition and GA multi-threaded(SMTPGA) combined.
Timings for baseline and search space partitioningvariants were measured for all models with high- andlow-detail sampling (except for model M3 for whichonly a single point cloud exists). Measurements varysignificantly for the same benchmark setting due to thestochastic behavior of GA-based methods. In order todeal with this variance, each experiment was repeated5 times.In the following, timing results for all methods in com-bination with high-detail sampling are discussed. SeeFig. 6 and 7 for an overview of the results. For modelM0, SMTGA is the fastest method. It outperforms the
Parameter Name Value
Population size n T n b γ cr γ mu µ mu k ts α log ( ) Distance weight β . γ . / π n tc h max see Eq. 2Table 2: Parameters for the baseline and search spacepartitioning approach.baseline by a factor of 15 . . . . . . . n T parts, with each part having similarexecution times. For per-partition variants, granularityis determined by the (potentially lower) number ofpartitions, and per-partition execution times may varysignificantly depending on partition sizes.Results for per-partition variants do not show timingsfor the different pipeline steps since in all experiments,per-partition CSG-tree extraction is by far the mostdominant factor. Timings for PO-graph generation,search space partitioning and tree merge make less than1 o / oo of the total runtime. Fig. 9 contains average depths and sizes of resultingtrees for baseline and partitioning variants. For the lat-ter, tree depths have increased by 25 .
0% (model M1) to285 .
0% (model M2) compared to the input tree, whileor baseline approaches, an increase of 0 .
0% (modelM1) to 125 .
0% (model M2) is visible. Tree sizes showsimilar behavior: Partitioning variants produce 46 . .
2% (model M0) larger trees, whilebaseline approaches increase tree size by only 0 . .
7% (model M2). Comparing treesizes between partitioning and baseline approaches di-rectly reveals that the former results in 25 .
2% (modelM2) to 88 .
6% (model M3) larger trees.This adverse behavior shown by partitioning variants isdue to the final merge step: In each iteration, the twotrees that are close to each other in the tree list and havea common subtree of at least size 1 are merged insteadof the two trees with the largest common subtree of alltree pairs in the merge list. Since the focus of this workis on performance, this is acceptable. In addition, thetree optimization strategy described in Section 5.4 (step1) was also applied to baseline results for better com-parability, which has positive impact on resulting treedepths and sizes.
Fig. 8 depicts measurement results for the ratio high low : duration high duration low , (3)which quantifies the dependency between point cloudsize and corresponding computation times. It indicatesthat, for larger models (model M0 and M2), the fastestpartitioning approach scales up to 1 . model 0 model 20500010000150002000025000 D u r a t i o n [ s ] bstbmtgasstsmtpsmtgasmtpga Figure 6: Timings for all approach combinations andmodels M0 and M2 with high-detail sampling (blacklines: standard deviations).
In this work, a technique for accelerating an Evolution-ary Algorithm for extracting a CSG-tree from a pointcloud was proposed. It is based on a partitioning ofthe search space obtained from computing the maxi-mum cliques of a graph of overlapping primitives, and model 1 model 30100200300400500600700800 D u r a t i o n [ s ] bstbmtgasstsmtpsmtgasmtpga Figure 7: Timings for all approach combinations andmodels M1 and M3 with high-detail sampling (blacklines: standard deviations). model 0 model 1 model 20.000.250.500.751.001.251.501.75 t i m e r a t i o / p o i n t s r a t i o bstbmtgasstsmtpsmtgasmtpga Figure 8: Ratio between high-detail and low-detailpoint cloud size factor and corresponding timing fac-tors for all models (see Equation 3). The red line in-dicates linear scaling with a slope of 1 with respect topoint cloud size. Model M3 exists only in high-detail.on merging CSG-trees extracted for each partition. Theexperimental evaluation indicated a significant speed-up over the baseline approach (the Evolutionary Algo-rithm) for different modes of parallelization.One possible direction for future work is the imple-mentation of the GA for massively parallel computinghardware, combined with the proposed partitioning ap-proach. A decreased tree size in the partitioning ap- size depth size depth size depth size depthmodel 0 model 1 model 2 model 301020304050607080 Input TreePartitionBaseline
Figure 9: Average tree size and depth for baseline andpartitioning methods (black lines: standard deviations).roach could also be achieved by improving the mergeprocess. Finally, since the partitioning (and merge)approach described in this work is independent of thetechnique used for the CSG-tree construction, the sameapproach could potentially be used with the CSG-treeconversion approaches in [SV91a, BC04]. [BC04] Suzanne F Buchele and Richard H Craw-ford. Three-dimensional halfspace con-structive solid geometry tree constructionfrom implicit boundary representations.
Computer-Aided Design , 36(11):1063–1073, 2004.[BK73] Coen Bron and Joep Kerbosch. Algo-rithm 457: finding all cliques of an undi-rected graph.
Communications of the ACM ,16(9):575–577, 1973.[BMV01] Pál Benk˝o, Ralph R Martin, and TamásVárady. Algorithms for reverse engi-neering boundary representation models.
Computer-Aided Design , 33(11):839–851,2001.[BTS +
17] Matthew Berger, Andrea Tagliasacchi,Lee M Seversky, Pierre Alliez, Gael Guen-nebaud, Joshua A Levine, Andrei Sharf,and Claudio T Silva. A survey of surfacereconstruction from point clouds.
Com-puter Graphics Forum , 36(1):301–329,2017.[ES +
03] Agoston E Eiben, James E Smith, et al.
Introduction to evolutionary computing ,volume 53. Springer, 2003.[FO82] Philippe Flajolet and Andrew M. Odlyzko.The average height of binary trees andother simple trees.
J. Comput. Syst. Sci. ,25:171–213, 1982.[FP16] Pierre-Alain Fayolle and Alexander Pasko.An evolutionary approach to the extractionof object construction trees from 3d pointclouds.
Computer-Aided Design , 74:1–17,2016.[HZ03] Richard Hartley and Andrew Zisserman.
Multiple view geometry in computer vi-sion . Cambridge university press, 2003.[KH13] Michael Kazhdan and Hugues Hoppe.Screened poisson surface reconstruction.
ACM Trans. Graph. , 32(3):29:1–29:13,July 2013.[Mea82] Donald Meagher. Geometric modeling us-ing octree encoding.
Computer Graphicsand Image Processing , 19(2):129 – 147,1982. [MG95] Brad L Miller and David E Goldberg. Ge-netic algorithms, tournament selection, andthe effects of noise.
Complex Systems ,9:193–212, 1995.[Mit98] Melanie Mitchell.
An introduction to ge-netic algorithms . MIT press, 1998.[MM65] John W Moon and Leo Moser. On cliquesin graphs.
Israel Journal of Mathematics ,3(1):23–28, Mar 1965.[OBA +
03] Yutaka Ohtake, Alexander Belyaev, MarcAlexa, Greg Turk, and Hans-Peter Sei-del. Multi-level partition of unity implicits.
ACM Trans. Graph. , 22(3):463–470, 2003.[PH77] Franco P. Preparata and Se June Hong.Convex hulls of finite sets of points in twoand three dimensions.
Communications ofthe ACM , 20(2):87–93, 1977.[RC11] Radu Bogdan Rusu and Steve Cousins.3d is here: Point cloud library (pcl). In
Robotics and automation (ICRA), 2011IEEE International Conference on , pages1–4. IEEE, 2011.[Ric73] A. Ricci. A constructive geometry forcomputer graphics.
The Computer Jour-nal , 16(2):157–160, 1973.[Sha01] Vadim Shapiro. A convex deficiency treealgorithm for curved polygons.
Interna-tional Journal of Computational Geometry& Applications , 11(02):215–238, 2001.[SV91a] Vadim Shapiro and Donald L Vossler. Con-struction and optimization of csg represen-tations.
Computer-Aided Design , 23(1):4–20, 1991.[SV91b] Vadim Shapiro and Donald L Vossler.Efficient csg representations of two-dimensional solids.
Journal of MechanicalDesign , 113(3):292–305, 1991.[SV93] Vadim Shapiro and Donald L Vossler. Sep-aration for boundary to csg conversion.
ACM Transactions on Graphics (TOG) ,12(1):35–55, 1993.[SWK07] Ruwen Schnabel, Roland Wahl, and Rein-hard Klein. Efficient ransac for point-cloudshape detection.
Computer graphics forum ,26(2):214–226, 2007.[VMC97] Tamás Várady, Ralph R Martin, and Jor-dan Cox. Reverse engineering of geometricmodels-an introduction.
Computer-AidedDesign , 29(4):255–268, 1997.[XF14] Jianxiong Xiao and Yasutaka Furukawa.Reconstructing the world’s museums.
In-ternational Journal of Computer Vision ,110(3):243–258, Dec 2014. a) Segmented point-set.
Box_0 Sphere_0Cylinder_0Sphere_1 (b) PO-graph. (c) Rendering of resulting model.
DifferenceUnion Sphere_1Union Cylinder_0Box_0 Sphere_0 (d) CSG-tree ground-truth.
UnionUnion UnionSphere_0 DifferenceCylinder_0 Sphere_1Sphere_0 DifferenceBox_0 Sphere_1 (e) CSG-tree from baseline.
UnionDifference DifferenceUnion Sphere_1Cylinder_0 Box_0 Union DifferenceCylinder_0 Sphere_0 Cylinder_0 Sphere_0 (f) CSG-tree from partitioning scheme.
Figure 10: Results of all pipeline steps for model M1. The wing-like structure is based on a simple cube whosesigned distance function is distorted by a sinusoidal term. This demonstrates the flexibility of the proposed ap-proach in terms of possible model representations. (a) Model M0. (b) Model M2. (c) Model M3.(a) Model M0. (b) Model M2. (c) Model M3.