A new lossless orthogonal simplification method for 3D objects based on bounding structures

Graphical Models 76 (2014) 181–201

Contents lists available at ScienceDirect

Graphical Models

journal homepage: www.elsevier .com/locate /gmod

A new lossless orthogonal simplification method for 3D objectsbased on bounding structures q

http://dx.doi.org/10.1016/j.gmod.2014.01.0021524-0703/� 2014 Elsevier Inc. All rights reserved.

q This paper has been recommended for acceptance by Hanan Sametand Peter Lindstrom.⇑ Corresponding author.

E-mail addresses: [email protected] (I. Cruz-Matías), [email protected] (D. Ayala).

Irving Cruz-Matías ⇑, Dolors AyalaDepartment de Llenguatges i Sistemes Informàtics, Universitat Politècnica de Catalunya, Barcelona, Spain

a r t i c l e i n f o a b s t r a c t

Article history:Received 7 May 2013Received in revised form 27 January 2014Accepted 31 January 2014Available online 18 February 2014

Keywords:SimplificationLODBounding volumesOrthogonal polyhedraBinary volumes

This paper presents a new approach to simplify 3D binary images and general orthogonalpseudo-polyhedra (OPP). The method is incremental and produces a level-of-detailsequence of OPP, where any object of this sequence bounds the previous objects and,therefore, is a bounding orthogonal approximation of them. The sequence finishes withthe axis-aligned bounding box. OPP are encoded using the Extreme Vertices Model, a com-plete model that stores a subset of their vertices and performs fast Boolean operations.Simplification is achieved by using a new strategy, which relies on the application of 2DBoolean operations. We also present a technique, based on model continuity, for bettershape preservation. Finally, we present a data structure to encode in a progressive and loss-less way the generated sequence. Tests with several datasets show that the proposedmethod produces smaller storage sizes and good quality approximations compared withother methods that also produce bounding objects.

� 2014 Elsevier Inc. All rights reserved.

1. Introduction

The growing size and complexity of datasets affects notonly the computation speed of their characteristics, butalso their disk storage and rendering efficiency. Simplifica-tion techniques can diminish these problems. Moreover, insome situations it is advantageous to exchange an exactgeometric representation of an object for an approximatedone, which can be processed more efficiently. Boundingstructures are widely used in model simplification toaccelerate or improve some tasks such as collision detec-tion, distance computation or any basic set membershipoperation. The most used bounding structure is theminimum axis-aligned bounding box (AABB) although

other structures are used such as spheres, oriented boxesor convex polyhedra.

We present a new approach to simplify objects, whichis restricted to orthogonal pseudo-polyhedra (OPP) andtherefore it can be applied to 3D binary digital images orbinary volume datasets as they can be represented byOPP. From an initial OPP, the method computes a level-of-detail (LOD) sequence of bounding volumes that are alsoOPP. The sequence is finite and ends with a convex OPPthat is the AABB of all the sequence. We will denote asBOPP (bounding OPP) such bounding structures. BOPP sat-isfy basically two properties: (1) any BOPP contains theprevious one and, therefore, all of them completely containthe original object and (2) all of the BOPP, as well as theoriginal object, have the same AABB.

OPP are represented by the Extreme Vertices Model(EVM) and the simplification is achieved using a newapproach we call merging faces, which displaces sets offaces and merges them by applying 2D Boolean operations.Our approach deals with general 3D orthogonal objects

http://crossmark.crossref.org/dialog/?doi=10.1016/j.gmod.2014.01.002&domain=pdf

http://dx.doi.org/10.1016/j.gmod.2014.01.002

mailto:[email protected]

mailto:dolorsa@lsi. upc.edu

mailto:dolorsa@lsi. upc.edu

http://dx.doi.org/10.1016/j.gmod.2014.01.002

http://www.sciencedirect.com/science/journal/15240703

http://www.elsevier.com/locate/gmod

182 I. Cruz-Matías, D. Ayala / Graphical Models 76 (2014) 181–201

with any number of shells, cavities and through holes. Weanalyze different strategies suitable for merging faces andwe also develop a technique that relies on the object con-tinuity in order to get a better shape preservation by avoid-ing abrupt changes. Finally, we propose a data structurethat allows encoding in a progressive and lossless waythe generated BOPP sequence. The method has been testedwith several datasets and compared with several methodsthat also produce bounding objects, showing good qualityof the approximations and smaller storage sizes.

2. Related work

Model simplification has been extensively applied totriangular meshes [13]. Some of these techniques havebeen extended to tetrahedral meshes and use a methodol-ogy to evaluate the approximation error and the quality ofthe obtained mesh [12]. Methods for LOD sequences of tri-angular and tetrahedral meshes can also be found exten-sively in the literature [45,53]. There also exist methodsto simplify quadrilateral meshes [25,51].

In contrast to these methods, that rely on geometricoperations such as edge-collapse or clustering, the simpli-fication can follow other strategies. Morphological opera-tors like filleting and rounding, equivalent to opening andclosing, can be used to simplify 2D binary images as wellas 3D triangular meshes [58]. Alternative representationscan be used such as octrees [5,48,54] in such a way thatthe geometry as well as the topology can be simplified,or BSP [27] obtaining a LOD sequence with a decreasingnumber of nodes. A carving strategy is applied to an octreemodel [54] as well as to a tetrahedral mesh [26] to simplifythe topology. Simplification strategies have also beendeveloped for B-Rep models [49] by removing connectedsets of faces, and for point clouds [42].

There has been also an intensive research in surfacesimplification in a progressive and lossless way, appliedspecially to triangle meshes [3,23,35,39,41,43]. Early meth-ods are called connectivity-driven, as they change progres-sively the connectivity [3,39]. Recent approaches fortriangle meshes, called geometry-driven, perform an spacepartitioning by using intermediate structures as kd-trees[23] or octrees [35,41,43] in order to code the mesh. Theyobtain better compression rates and quality of the approx-imation, measured by some distance defined on the surfacepoints [4].

2.1. Bounding volumes

Many of the aforementioned approaches provideapproximations designed either to preserve the originaltopology between the original and the simplified objector just to obtain an approximated shape. Nevertheless, insome cases it is desirable to compute an approximationthat is also a bounding volume. Bounding volumes are usedin many applications such as collision detection [29], raytracing [24,57], graphics interaction [28] and volume ofinterest computation [21].

Several works use classical bounding volumes, such asspheres [31,22] and AABB [50,60]. Nevertheless, other

kinds of bounding volumes are used such as convex poly-topes with faces oriented in a reduced set of orientations[32] or oriented polytopes that take into account the objectvelocity or dynamic collision detection [14]. Moreover,hybrid bounding volumes are also used. Bounding boxesare enhanced with planes computed from the intersectionbetween two objects [56]. Slab cut balls built from a ballcut by a slab (intersection region between two parallelplanes) present a good balance between tightness andtesting costs [34], and an oriented bounding box tree, en-hanced with bounding spheres at each node, is used tospeed up collision detection applying the more efficientsphere test first to eliminate distant objects [11].

Orthogonal polyhedra have been proposed as geometricbounds for CSG because general set membership opera-tions with them are very efficient [2]. However, in thiswork the authors present a Boolean operations algorithmusing EVM, but do not present methods to compute bound-ing orthogonal polyhedra.

On the other hand, orthogonal polyhedra are used asbounding structures in a coarsening strategy [19]. In thiswork, orthogonal polyhedra are represented with the ver-tex-list representation [20], which stores a subset of verti-ces with a weight needed for orientation purposes. Theauthors present two simplification strategies. One of them,moving faces, performs face displacements but fails forobjects with holes or more than one connected component.The other strategy, rectangle pairs does not have thisrestriction and performs a partition of the object in boxes,takes them in pairs, obtaining the AABB of this pairs, andfinally performs the union of these AABB.

Some methods produce bounding volume hierarchies ofpolygonal meshes for fast collision detection between mas-sive models [59] and for haptic rendering [38]. Othermethods produce a hierarchy of polygonal convex volumes(a shrink-wrap around the object) [27,37]. Meanwhile,orthogonally convex polygons can be computed as orthog-onal hulls for 2D images [9]. An orthogonal polygon isorthogonally convex if any axis-parallel line intersects itin at most one line segment. This problem has beenextended to orthogonally convex polyhedra [8]. Suchconvex polygons like the convex hull, are not suitable tosimplify objects that are not close to a convex shape, i.e.objects with many concavities and holes.

Methods that generate bounding approximations evalu-ate the quality of the approximations as the tightness ofthe bounding volume with respect to the volume of the ori-ginal object.

2.1.1. Progressive bounding volumesIn this section, three methods that produce a progres-

sive LOD sequence of bounding volumes are described insome detail. These methods are compared with theapproach presented in this paper in Section 7.1.

The first method is a technique presented by Samet andKochut [48] to progressively approximate and compress ina lossless way binary 3D objects represented by pointerlessoctrees. This method is forest-based and deals with theinternal nodes to progressively transmit n blocks, wheren is not longer than the minimum number of either blackor white blocks in the octree. This pointerless octree is

I. Cruz-Matías, D. Ayala / Graphical Models 76 (2014) 181–201 183

represented by its leaf nodes, where each leaf q is uniquelyidentified by the path leading from the root to q called loca-tional code. This path is represented as a sequence of direc-tional codes: 1–8 for each of the eight directions in theoctree (UNW, UNE, USW, USE, DNW, DNE, DSW, DSE).The locational code for any node is an integer computedby a recursive function. In this method, not all the approx-imations are a bounding volume of the original object.

The second method is a progressive solid simplificationapproach for 3D objects represented by binary space parti-tion (BSP), presented by Huang and Wang [27]. It producesa LOD sequence with a decreasing number of nodes byusing a combination of two techniques: (1) a volumebounded convex simplification that collapses parts withsmall volumes into a simple convex volume enclosing thevolumetric cells on the input object and (2) a plane col-lapse method which reduces the BSP tree depth ensuringthat the input object is enclosed by the simplified BSP tree.In this way, from an initial object C0, a progressivesequence of simplified BSP trees, Ci, can be computed, suchthat XðCiÞ# XðCiþ1Þ; i ¼ 0 . . . n� 1, where XðCiÞ is thespace occupied by Ci.

Finally, the third method is based on a structure calledbounding-planes octree (BP-O) proposed by Melero et al.[37], which is based on an octree where each node containsa set of planes taken from the input polygonal model.These planes form a convex bounding volume that includescompletely the portion of the 3D object contained in thenode. The nodes only contain the indices of the planesand all the planes are stored in an external data structureaccessed by the octree. The same idea applies to the finalgeometry, stored at leaf nodes. To construct the BP-O, thepolygons are classified in a 3D grid first, then, they areassigned to each leaf node and all leaf nodes are groupedin order to have a minimum number of planes per node.After selecting the bounding planes at leafs, internal nodesare built by following the path from the root node to eachleaf, computing their bounding planes in a bottom-uprecursion. For progressive transmission, planes containedin low levels of the BP-O are sent first, and so on until leaflevel.

3. Background

3.1. Orthogonal polyhedra

Orthogonal polyhedra are two-manifold polyhedra withall their faces oriented in the three main axes. OPP are reg-ular orthogonal polyhedra with a possible non-manifoldboundary. OPP are a restricted class of polyhedra consider-ing its geometry, but concerning topology OPP are general,as they present any number of shells, cavities and holes.General OPP are OPP with vertex coordinates having anyvalue in R3. Polycubes are a subset of OPP all of whose ver-tices have integer coordinates, formed by joining one ormore equal cubes (voxels) face to face. The continuous ana-log of a 3D binary digital image is an OPP [30,33].

OPP have been used in 2D to represent the extractedpolygons from numerical control data [40]. Some 3D appli-cations of OPP are: general computer graphics applications

such as geometric transformations and Boolean operations[1,10,20], virtual MIP without skeleton [47], direct skeletoncomputation (instead of iterative peeling techniques)[18,36], and orthogonal hull computation [8,9]. OPP havebeen also used in theory of hybrid systems to model thesolutions of reachable states [10,17].

3.2. Extreme Vertices Model

In this paper we represent 3D binary digital imageswith the Extreme Vertices Model (EVM).

Let Q be a finite set of points in R3, the ABC-sorted set ofQ is the set resulting from sorting Q according to A-coordi-nate, then to B-coordinate, and then to C-coordinate. Let Pbe an OPP, a brink is the maximal uninterrupted segmentbuilt out of a sequence of collinear and contiguoustwo-manifold edges of P and its ending vertices are calledextreme vertices (EV). An OPP can be represented in a con-cise way with the ABC-sorted set of its EV and such repre-sentation scheme is called EVM. EVM is an implicit B-Repmodel and therefore represents OPP unambiguously [55].

EVM only needs to store EV, with no additional infor-mation such as neighboring relations among vertices,edges, or faces, since all these elements can be computedfrom them. Therefore, the storage requirements for anOPP P in its EVM representation is OðnÞ; n being the num-ber of EV, and n 6 v , where v is the total number ofvertices.

Let P be an OPP and Pc a plane whose normal is parallel,without loss of generality, to the X axis, intersecting it atx ¼ c, where c ranges from �1 to 1. Then, this planesweeps the whole space as c varies within its range, inter-secting P at some intervals. Let us assume that this inter-section changes at c ¼ c1; . . . ; cn. More formally,P \Pci�d – P \Pciþd; 8i ¼ 1; . . . ; n, where d is an arbi-trarily small quantity. Then, CiðPÞ ¼ P \Pci

is called a cutof P and SiðPÞ ¼ P \Pcs ; ci < cs < ciþ1, is called a section ofP. Two cuts bounding a section Ci and Ciþ1 are called con-secutive cuts. See Fig. 1.

Sections can be computed from cuts and vice versa:

S0ðPÞ ¼ SnðPÞ ¼ ; ð1ÞSiðPÞ ¼ Si�1ðPÞ��CiðPÞ; 8i ¼ 1 . . . n� 1 ð2ÞCiðPÞ ¼ Si�1ðPÞ��SiðPÞ; 8i ¼ 1 . . . n ð3Þ

where n is the number of cuts and � denotes the xor oper-ation. Overline symbolizes the project operator, that pro-jects a d-dimensional set of vertices lying on anorthogonal plane, like a cut or a section, onto the corre-sponding main plain, discarding their dth coordinate. Thestar exponent⁄ denotes a regularized Boolean operation.A regularized set is defined as the closure of its interior.Regularized Boolean operations are needed to ensure 3Dhomogeneity [52].

Eq. (3) can be rewritten by expressing the �� operationas the union of differences: 8i ¼ 1; . . . ; n:

CiðPÞ ¼ ðSi�1ðPÞ��SiðPÞÞ[�ðSiðPÞ��Si�1ðPÞÞ ð4Þ

and any cut can be decomposed into its forward difference(FD) and backward difference (BD):

b

Fig. 1. An EVM-encoded OPP. Top: EV marked with dots, cuts decom-posed in FD (blue) and BD (orange), normal vectors represented witharrows; a vertical brink from vertex a to c is marked where these verticesare both EV while vertex b is not. Bottom: The OPP split at its cuts.Sections of the object highlighted in yellow. (For interpretation of thereferences to color in this figure legend, the reader is referred to the webversion of this article.)


FDiðPÞ ¼ Si�1ðPÞ��SiðPÞBDiðPÞ ¼ SiðPÞ��Si�1ðPÞ

ð5Þ

FDiðPÞ is the set of CiðPÞ faces whose normal vectorpoints to the positive side of the coordinate axis perpendic-ular to CiðPÞ, and BDiðPÞ is the set of faces whose normalvector points to the negative side (see Fig. 1 top). Thisproperty guarantees the correct orientation of faces andthe computation of the non-EV.

General EVM Boolean operations are carried out byapplying recursively (in nD) the same Boolean operationover the (n � 1) D OPP sections. The base case performsthis operation in 1D. The xor operation is even faster,EVMðP��QÞ ¼ EVMðPÞ��EVMðQÞ, i.e., it is a simple point-wise xor, without section computation. For more detailsconcerning EVM see [2,46]. Although EVM has beenextended to nD [44], in this paper we deal with dimensionn 6 3.

4. Merging faces strategy

4.1. Basic merging

The idea of the merging faces strategy is to work withpairs of consecutive cuts of an OPP, where for each cut ofa pair, a displacement of its faces in the direction of theircorresponding normal vector is applied and, then, the dis-placed faces are merged with those faces of the other cut

with the same normal vector. We define as BðPÞ, thebounding OPP (BOPP) of an OPP P obtained with the merg-ing faces strategy.

Formally, let P be an OPP and let CA and CB be two con-secutive cuts of P and FDA; BDA; FDB and BDB their corre-sponding forward and backward differences (see Eq. (5)).To obtain a coarsened OPP, the merging faces process dis-places BDB to the position of BDA and displaces FDA to theposition of FDB. Then, the new cuts newCA and newCB thatrepresent the merged faces and replace CA and CB respec-tively in the input object, are computed according to thenext equation:

newCA ¼ BDA[�BDB

newCB ¼ FDA[�FDB

ð6Þ

The merging process displaces faces in the direction oftheir respective normal vector, i.e., outward of the object,but only those faces in which this displacement goes tothe consecutive cut (faces FDA of CA and BDB of CB) and thenperforms the union of these displaced faces with theremaining faces of each cut which have the same normalvector (FDB of CB and BDA of CA, respectively).

If P is represented as an ABC-sorted EVM, for a singletraversal of cuts the application of this process only willcoarsen P in the A-coordinate. Therefore, to obtain BðPÞthe process must be repeated for the other two main direc-tions. Fig. 2 shows a 2D example where the process is ap-plied for the two main directions. Observe that the resultcan be slightly different depending on the ordering inwhich the three main directions are selected. In order tospeed up the computation, the best first candidate wouldbe the ABC-ordering with A-axis having less number ofcuts, but as EVM does not report this value, it can beapproximated by cn � c1; c1 and cn being respectively thecoordinates of the first and last cut in this direction.

Although non-extreme vertices are not stored in EVM,when cuts are decomposed in forward and backward dif-ferences, they appear and the merging faces strategy dealscorrectly with them. For instance, Fig. 2(a) has a non-extreme vertex in CB that shows up when BDB and FDB

are computed and that appears in newCB (Fig. 2(b)).Since the displacements are done outward of the object,

and are restricted by the cuts of the initial object, theresulting OPP will never extend beyond these cuts and,therefore, will contain the initial object. This process satis-fies the subset property for bounding structures, i.e.P # BðPÞ.

4.2. Treatment of the void space

An OPP may have any number of rings on faces, throughholes and shells (cavities or connected components). In ageneral OPP, Eq. (6) does not give the desirable result.For example, applying this equation to the pair of cutsdepicted in Fig. 3(a), the same OPP without coarsening isobtained. Notice that a hole in 2D is equivalent to a cavityin 3D. To deal with this issue, we first detect and then closethe void spaces.

Given the pair of consecutive cuts ðCA; CB), BDA and BDB

are sets of faces whose normal vectors point to the

(a) (b) (c) (d) (e)Fig. 2. 2D example. (a) Faces displaced in a first step. (b) Result after applying Eq. (6) and faces displaced in a second step. (c) Final result for the XY-sorting.(d) Faces displaced for the YX-sorting. (e) Resulting BOPP.

(a) (b)Fig. 3. A 2D OPP with a single hole. (a) Faces merged in order to close thehole. (b) Result and end for the XY-sorting.


opposite direction of FDA and FDB, but only the pair formedby FDA and BDB can represent a void space between thecuts. Therefore, a void space (vS) is given by the intersec-tion of their projections, i.e.:

vSðCA;CBÞ ¼ FDA\�BDB ð7Þ

The removal of vS from both newCA and newCB, closesthe void space between CA and CB. Then, Eq. (6) is extendedwith Eq. (7):

newCA ¼ BDA[�BDB� �

�� FDA\�BDB� �

newCB ¼ FDA[�FDB� �

�� FDA\�BDB� � ð8Þ

When vS ¼ ;, Eqs. (8) and (6) are equivalent. As this lastoperation contributes just to close interior void spaces, thesubset property is still guaranteed. Fig. 3 shows an exam-ple with a single hole. In Fig. 3(a) FDA ¼ BDB andvSðCA;CBÞ ¼ FDA ¼ BDB. Then, applying Eq. (8), newCB ¼ ;and the hole is closed (Fig. 3(b)). As shows Eq. (8), basicmerging and void space removal are performed at once.Note that the simple removal of the void space would havethe same effect that the closing morphological operation.

In 3D, all types of void space between cuts are detectedas those shown in Fig. 4. There are cases in which the voidspace is not detected in all three directions, but is alwaysdetected in one or two of them. For example, in Fig. 4(a)and (b) the void space is not detected in Y-direction butis detected either in X or Z-direction. However, there areother cases in which the void space is detected in all direc-tions. In Fig. 4(c) a void space is detected in X or Y-directionand the through hole is partially closed, i.e., only the spacebetween the processed cuts gets closed, and the wholethrough hole will be closed in the next direction; but, ifwe begin with Z-direction, the detected void space allows

to close the whole through hole. The cavity depicted inFig. 4(d) will be closed in any direction.

Although there are cases, as the simple concavity inFig. 4(a), that could be solved with the application of Eq.(6), for general void spaces, as those in Fig. 4(b)–(d), Eq.(8) must be applied in order to completely close the hole.Fig. 5(a) shows a 3D example with through holes. ApplyingEq. (8) in X-direction, the computed new cuts, newCA ¼ ;and newCB (Fig. 5(c)) partially close the hole, resulting inan object with a concavity (Fig. 5(d)), which will be closedin the next direction.

4.3. Merging faces optimization

Two EVM properties, that state that for two specialcases union and difference consist in simple point-wisexor operations [2], together with two EVM theorems, per-mit to rewrite Eq. (8) in a way faster to compute.

� Property 1: Let P and Q be two OPP such that P\�Q ¼ ;,having EVMðPÞ and EVMðQÞ as their models, thenEVMðP[�QÞ ¼ EVMðPÞ��EVMðQÞ.� Property 2: Let P and Q be two OPP such that P � Q , with

EVMðPÞ and EVMðQÞ as their models, thenEVMðP��QÞ ¼ EVMðPÞ��EVMðQÞ.

Theorem 1. The projection of FD and BD of two consecutivecuts (CA; CB) are quasi-disjoint sets respectively, i.e.FDA\�FDB ¼ ; and BDA\�BDB ¼ ;.

Proof. The proof is based on the Jordan theorem and thefact that any ray crossing the boundary of the polyhedron,alternatively goes from outside to inside and vice versa.Therefore, in any OPP, assuming that FDA\�FDB – ;, wouldmean that a ray could cross FDA going outside and thencross FDB going outside again, which is a contradiction.The same reasoning applies to BD. h

Theorem 2. vSðCA; CBÞ# BDA[�BDB� �

and vSðCA;CBÞ#FDA[�FDB� �

.

Proof. From Eq. (7), vSðCA;CBÞ ¼ FDA\�BDB. Without lossof generality:ðFDA\�BDBÞ# BDB # BDA[�BDB

� �, and

thus,ðFDA\�BDBÞ# BDA[�BDB� �

. In a similar wayvSðCA;CBÞ# FDA[�FDB

� �can be proved. h

(a) (b)

(c) (d)Fig. 4. Some configurations of void spaces in 3D. (a) Concavity. (b) Through hole. (c) Through hole in L-shape, (d) Internal hole or cavity.

(a) (b)

(c) (d)Fig. 5. A 3D OPP with holes. (a) Original object. (b) Faces merged in a first step. (c) Resulting cuts and (d) Result for the XYZ-sorting.


According to these theorems and the aforementionedEVM properties, Eq. (8) can be rewritten as:

newCA ¼ BDA��BDB�� FDA\�BDB� �

newCB ¼ FDA��FDB�� FDA\�BDB� � ð9Þ

4.4. Selection criteria for cuts

So far, we have said that the merging faces process takespairs of consecutive cuts for a single traversal of cuts in anymain direction. However, we must establish the way andorder in which such pairs are selected. We have examined


four alternatives, which are explained below with 2Dexamples. In all of them, we consider a traversal for theXY-sorting EVM, taking cuts from lowest to highest valuein the X-coordinate and supposing that there are n cuts.

Alternative 1. The first alternative consists in taking cutstwo by two ðCA ¼ Ci;CB ¼ Ciþ1Þ; i ¼ 1; i < n; i ¼ iþ 2, i.e.first the pair ðC1; C2Þ, then ðC3;C4Þ, and so on. This alterna-tive seems to be the most natural and has the particularitythat, although all cuts are taken into account in a singletraversal, those sections between cuts that are not consid-ered as a pair (for instance ðC2;C3Þ) are not modified in theresulting object (see Theorem 3 at the end of this section).See Fig. 6(a).

Alternative 2. In this alternative, pairs of cuts are takenin a chained form: ðCA ¼ Ci;CB ¼ Ciþ1Þ; i ¼ 1; i < n;i ¼ iþ 1, i.e., first the pair ðC1;C2Þ, then ðC2;C3Þ, and soon. In this alternative as we consider each possible pair ofcuts, all the cuts as well as all the sections are modified.

Fig. 6. Alternatives to select pairs of cuts.

However, this alternative fails to create a valid object afterapplying Eq. (9). This is due to the fact that newCi is, in gen-eral, different when it is computed from the pair ðCi�1;CiÞthan from the pair ðCi;Ciþ1Þ.

Alternative 3. This case also considers pairs of cuts in achained form, but instead of taking the i-th cut as CA, thenewCB of the last step is taken. We start taking the pairðC1;C2Þ, which generates the pair ðnewC1;newC2Þ, thenwe take ðnewC2;C3Þ, then ðnewC3;C4Þ, and so on. Note thatonly in the first step this alternative is similar to the previ-ous ones, and like Alternative 2, each possible pair of cuts istaken into account, but as CA is the newCB of the previousstep, there are no conflicts to generate a valid object. How-ever, this alternative has a cascading effect, where somefaces are dramatically extended after each step. SeeFig. 6(b).

Alternative 4 This alternative consists in modifyingsections instead of pairs of cuts. We again consider pairsof cuts in a chained form, but instead of generating twonew cuts, we only compute newCA using Eq. (9) and thenwe compute a new section from newCA and the previoussection of the original object using Eq. (2), i.e.:newSi ¼ Si�1��newCA. Although this alternative seems topreserve the morphology of the object, the result is similarto a morphological dilation operation, and therefore, theobject expands, quickly losing its appearance. See Fig. 6(c).

From these four alternatives, we have chosen Alterna-tive 1 for the following reasons: Alternative 2 is discardedfor not creating a valid object. Applying Alternative 3 theobject is drastically deformed due to the cascading effect.Alternative 4 seems to preserve the morphology but theobject expands. Fig. 7 shows the results after running thedifferent alternatives with one traversal for each one ofthe three main directions in the Binzilla dataset indicatingthe number of EV.

Theorem 3. Let Ck and Ckþ1 be two consecutive cuts of anOPP P that are not considered as a pair in the merging facesprocess, and let Sk be the section between them. The newsection, newSk, between the corresponding cuts newCk andnewCkþ1 is not modified, i.e. newSk ¼ Sk.

Proof. The chosen approach to prove it is by induction.Basis. If the first modified pair is ðC1;C2Þ, then, the first

cuts that are not considered as pair are C2 and C3, so, weshow that newS2 ¼ S2. From Eqs. (2) and (3) can be inferredthat: SkðPÞ ¼ ��i¼1

kCiðPÞ.) newS2 ¼ newC1��newC2

According to Eq. (9):) newS2 ¼ ðBD1�� BD2��vSðC1;C2ÞÞ�� ðFD1��FD2��

vSðC1;C2ÞÞ�� is an associative and commutative operator in EVM:) newS2 ¼ ðBD1��FD1Þ��ðBD2��FD2Þ��ðvSðC1;C2Þ��

vSðC1;C2ÞÞBy definitions of backward and forward differences:) newS2 ¼ C1��C2

) newS2 ¼ S2

Inductive step. Let Ck and Ckþ1 be two consecutive cutsthat are not considered as a pair, we assume thatnewSk ¼ Sk. So, the next pair that can be processed is

Fig. 7. Results of the different alternatives applied to the Binzilla dataset. (a) Original object. (b) Alternative 1. (c) Alternative 3. (d) Alternative 4.


ðCkþ1;Ckþ2Þ, in this way, Ckþ2 and Ckþ3 will not beconsidered as a pair. Now we show that newSkþ2 ¼ Skþ2.

newSkþ2 ¼ ��i¼1kþ2newCi

) newSkþ2 ¼ newSk��newCkþ1��newCkþ2.

Similar to the basis step:

) newSkþ2 ¼ newSk��ðBDkþ1 ��BDkþ2��vSðCkþ1; Ckþ2ÞÞ��ðFDkþ1��FDkþ2��vSðCkþ1;Ckþ2ÞÞ) newSkþ2 ¼ newSk��ðBDkþ1��FDkþ1Þ��ðBDkþ2��FDkþ2Þ

��ðvSðCkþ1;Ckþ2Þ��vSðCkþ1;Ckþ2ÞÞ

) newSkþ2 ¼ newSk��ðCkþ1��Ckþ2Þ

As newSk ¼ Sk.

) newSkþ2 ¼ Sk��Ckþ1��Ckþ2

) newSkþ2 ¼ Skþ2 h

4.5. Shape preservation

In the presented method, merging two consecutive cutsis performed in all their extension. However, there areparts of these cuts that are isolated and merging themcould result in too abrupt changes.

Let ðCA;CBÞ be the pair of cuts to be merged, we will referas isolated faces those faces of CA disjoint with CB (on aprojecting plane) and vice versa. More formally: Let

(a) (Fig. 8. Shape preservation example. (a) A 3D OPP. (b) All cuts and extreme verttechnique to the pair ðCA ;CBÞ. (For interpretation of the references to color in th

CA ¼ C1A;C

2A; . . . ;CnA

A

n o; CB ¼ C1

B;C2B; . . . ;C

nBB

n o; IA ¼ I1

A; I2A; . . . ;

n

InIAA g and IB ¼ I1

B; I2B; . . . ; InIB

B

n obe the sets of faces of CA; CB

and the isolated faces of CA and CB respectively. The follow-ing conditions hold for faces of sets IA and IB:

IA # CA; IB # CB

IiA\�CB ¼ ;; 8i ¼ 1 . . . nIA

IiB\�CA ¼ ;; 8i ¼ 1 . . . nIB

ð10Þ

Removing isolated faces of the merging process resultsin a better approximation. The corresponding new valuesFD0A; BD0A; FD0B and BD0B involved in the merging processare computed as:

FD0A ¼ FDA��IA; BD0A ¼ BDA��IA

FD0B ¼ FDB��IB; BD0B ¼ BDB��IB

ð11Þ

these values are used in Eq. (9) to generate newC0A andnewC0B, such that:

newC 0A ¼ BD0A��BD0B�� FD0A\�BD0B� �

newC 0B ¼ FD0A��FD0B�� FD0A\�BD0B� � ð12Þ

after that, the isolated faces must be reintegrated. This pro-cess can be accomplished with a union operation, however,by definition IA and CA are disjoint sets and therefore, IA

and newC0A are also disjoint sets (the same applies to

b) (c)ices; in red, an isolated face. (c) Result of applying merging faces with theis figure legend, the reader is referred to the web version of this article.)

(a) (b)


IB;CB and newC0B). Then, according to the EVM Property 2,an xor operation is performed instead.

newCA ¼ newCA��IA

newCB ¼ newC 0B��IB

ð13Þ

Fig. 8 shows an example where an isolated face (if) isdepicted. Here, if remains in place, and only those facesthat share either an edge or a vertex are taken into accountthroughout the merging faces process. The application ofthis technique does not affect to the aforementioned subsetproperty (see Section 4.1) and produces better approxima-tions, for instance see Fig. 9.

Detecting isolated faces in 2D is straightforward by dis-placing the brinks in both cuts and checking for intersec-tion. In the 3D case, the sets of elements to analyze are2D faces, i.e., general orthogonal polygons. So, a differentstrategy is applied to individually separate each face ofCA and CB to detect the isolated ones.

We have used the Compact Union of Disjoint BoxesCUDB representation [16], a compact partitioning obtainedfrom the EVM, which can be thought as a special kind ofcell decomposition like octrees, bintrees and BSP. CUDB isaxis aligned like octrees and bintrees but the partition isdone along the object geometry like BSP. Then, cuts CA

and CB are converted to CUDB and their faces are extracted,and to check for intersection, we have implemented a 2Dadjacency detection algorithm. See Algorithm 1 for details,where in the set of faces F, a face is a 2D-CUDB with twoattributes, one of them is the cut to which the face belongsand the other one indicates whether the face has beenintersected or not.

Algorithm 1. getIsolatedFaces

Input: CA; CB {Cuts (2D-EVM) to analyze}Output: IA; IB {Set of Isolated faces of CA and CB}

objA EVMtoCUDBðCAÞobjB EVMtoCUDBðCBÞCCLðobjAÞ {Connected component labeling process}CCLðobjBÞF extractFacesðojbAÞ [ extractFacesðojbBÞdetectAdjacency (F)FA Faces in F 2 objA and not intersect.FB Faces in F 2 objB and not intersect.IA CUDBtoEVMðFAÞIB CUDBtoEVMðFBÞ

Fig. 9. Shape preservation technique. (a) Original DiskBrake dataset. (b) and (c) Rhave <15% of EV of the original dataset.

Fig. 10. Example where all elements of CA and CB are isolated.

4.6. Merging faces algorithm

According to Alternative 1 for cuts selection, mergingfaces strategy takes cuts two by two, first the pairðC1;C2Þ, then ðC3;C4Þ, and so on. But, observe the particularcase in Fig. 5(b), where if CA ¼ C1 and CB ¼ C2; newCA andnewCB will be exactly the same as CA and CB respectively.This is due to the fact that FDA ¼ ; and BDB ¼ ;, which isthe condition that results in any displacement. The directapplication of this condition to Eq. (9) shows thisconclusion.

On the other hand, when the shape preservation tech-nique is applied, there may be consecutive cuts with allits faces detected as isolated (see Fig. 10), in such cases,there will be no displacement.

Moreover, the merging process is controlled by a maxi-mum displacement allowed, in such a way that only pairsof consecutive cuts that are at a distance less or equal thana displacement parameter, d, are actually merged. How-ever, if the increment of d is too large, far apart consecutivecuts can be merged causing abrupt changes. Therefore,given the pair of cuts ðCA ¼ Ci;CB ¼ Ciþ1Þ the conditionsto merge them are:

ðFDA – ; or BDB – ;Þ ð14ÞNot all faces of CA and CB are isolateddistanceðCA;CBÞ 6 d

If conditions in Exp. (14) are fulfilled, the pair ðCi; Ciþ1Þis processed with Eq. (13) to compute newCA and newCB,and the method continues, according to the selection crite-ria, with the pair ðCiþ2;Ciþ3Þ. Otherwise Ci is copied directlyto the simplified object and the method continues with the

esulting BOPP using and not using the technique respectively. Both BOPP


pair ðCiþ1; Ciþ2Þ. Note that the asseveration of IA ¼ CA isenough to determine that all faces are isolated, as it implic-itly means that IB ¼ CB, or vice versa.

Nevertheless, there may be cases where all faces of allthe possible pairs of cuts in the object are isolated (seeFig. 10), which means that the method has no effect andthe complete simplification process will never end. There-fore, in order to guarantee the property of finiteness, whenall faces of a given pair of cuts are isolated, we do not applythe shape preservation technique and use Eq. (9) instead ofEq. (13) for such pair.

Algorithm 2. mergingFaces

Input: P {EVM represented OPP}Input: sorting {ABC-sorting}Input: d {Displacement parameter}Input: displaceIF {Flag for isolated faces}Output: Q {EVM represented simplified OPP}

P:setSortingðsortingÞQ ;; Q :setSortingðsortingÞCA P:getNextCutðÞ; CB P:getNextCutðÞCD P:getReverseCutðÞ; CC P:getReverseCutðÞwhile CB – ; or CC – ; do

process falseif distanceðCA;CBÞ <¼ dÞ then

Compute FDA and BDB

if FDA – ; or FDB – ; thengetIsolatedFacesðCA;CB; IA; IBÞif IA – CA then {Not all faces are isolated}

FDA FDA��IA; BDB BDB��IB

if FDA – ; or FDB – ; thenCompute FDB and BDA

FDB FDB��IB; BDA BDA��IA

process trueend if

else {All faces are isolated}if displaceIF then

Fig. 11. LOD sequence generated by our approach, indicating on each BOPP theU3 ¼ AABBðUiÞ.

Compute FDB and BDA

process trueend if

end if {isolated faces condition}end if {displacement condition}

end if {distance condition}if process then {Formula application}

voidSpace FDA\�BDB

newCA BDA��BDB��voidSpacenewCB FDA��FDB��voidSpaceif IA – CA then {Not all faces are isolated}

newCA newCA��IA

newCB newCB��IB

end ifQ :insertCutðnewCAÞQ :insertCutðnewCBÞCA P:getNextCutðÞCB P:getNextCutðÞ

else {Omit and copy cut}Q :insertCutðCAÞCA CB

CB P:getNextCutðÞend if⁄⁄⁄Same for descending order with CC and CD

end while

Another issue that we have considered is that, if westart to analyze cuts in descending order along one maindirection, the result is barely different with respect to theresult in ascending order. Therefore, for symmetry preser-vation purposes the object is analyzed from both sides at atime. However, this symmetrical traversal does neitherimprove nor reduce the performance of the method.

Algorithm 2 shows the steps of the merging faces using alazy evaluation strategy to improve its performance. Agiven OPP P is ABC-sorted according to a given sortingand then it is processed in A-direction with a given param-eter of distance and a flag to indicate if cuts with all itsfaces as isolated are displaced or not.

number of EV (marked with black dots). (a) Original U0, (b) U1, (c) U2, (d)

Fig. 12. Sequence in Fig. 11 put together. Each EV indicates the objectnumbers to which it belongs.


5. Lossy simplification

5.1. Initial considerations

According to the merging faces algorithm, when apply-ing the shape preservation technique, if there are pairs ofcuts with all its faces isolated, we have two options, oneof them preserves the shape and the other one guaranteesthe finiteness of the method. Therefore, in order to takeadvantage of the shape preservation technique and stillguarantee that the method ends, we propose first to per-form three times the merging faces process, once per eachmain direction (having previously determined the bestsorting) with a given parameter of distance d, and notallowing to displace isolated faces when all the faces aredetected as such. Then, we perform three additional merg-ing faces process with the same parameter d, but nowallowing to displace the isolated faces.

Besides, we have observed that after applying the merg-ing faces process in the three main directions with a givendistance d, cuts with the same distance d between themmay still remain. This is because some faces of the inter-mediate cuts that are not considered as pairs (see Sec.4.4) or that were marked as isolated and not displaced,were not modified after the merging in the three maindirections. So, with the aforementioned three additionaltraversals we obtain a good quality of the approximationswhile guaranteeing the finiteness property.

5.2. Simplification algorithm

Let U0 be an initial OPP. A finite sequenceU1; U2; . . . ; Up of OPP can be generated, that fulfills thefollowing properties:

1. Uiþ1 ¼ BðUiÞ; 8i ¼ 0 . . . p� 1.

2. Ui # BðUiÞ; 8i ¼ 0 . . . p� 1, and, therefore,Ui # Uiþ1; 8i ¼ 0 . . . p� 1.

3. Up ¼ AABBðUiÞ; 8i ¼ 0 . . . p.

The first property indicates that the approach is incre-mental. The second one is the subset property. The lastproperty states that the sequence is finite and that endswith the AABB that is shared by all the OPP of thesequence. The AABB property can be demonstrated by con-sidering that the AABB of an OPP can be defined as theintersection of the six planes corresponding to the firstand last cut in the three main directions and the fact thatthe object will never extend beyond the initial cuts, and,in particular, the first and last ones. Moreover, we canobserve that the first cut only has BD faces and the lastone only FD faces. Then, in each iteration the first cut ofBðUiÞ will be either the same of Ui or the union betweenthe first cut and the BD of the second cut of Ui. Then, inthe last iteration, the first cut of Up, i.e. of the AABB, willcorrespond to the union of all the BD of all the cuts. Thesame reasoning applies for the last cut.

As the method is incremental, it actually computes allthe objects between U1 and Uk for successive values of d,d ¼ di; i ¼ 1; . . . ; k, obtaining the corresponding Ui.

Displacements di can be in any units and incremented inany quantity. For OPP corresponding to digital images thebasic unit is one voxel, i.e. di ¼ i. For general OPP, with floatcoordinate values, di can take any values ranging from theminimum distance between cuts and the AABB size.

The input of the method is an EVM represented OPP, P,which corresponds to the initial object U0, and there can bedifferent kinds of queries as:

� Give the maximum value for the displacement, dmax, i.e.the method performs iteratively the merging faces pro-cess and stops when d > dmax.� Give the maximum number of EV nv in the last BOPP,

i.e. the sequence ends with the object Uk, which hasno more than nv extreme vertices. In the particular caseof ending with the AABB, i.e. ok ¼ op ¼ AABBðPÞ; nvmust be 8.

Steps for the two queries in the proposed simplificationmethod are shown in Algorithm 3 (maximum value for thedisplacement) and Algorithm 4 (maximum number of EV),where get nev function returns the number of EV of thecorresponding object and detectBestSorting detects the bestsorting (see Section 4.1). Note that Algorithm 3 performs 6times the merging faces process per each distance. But, inAlgorithm 4 the method can stop even if the last threemerging faces processes for the same distance are not per-formed, since these intermediate objects are symmetricallycoherent BOPP.

Algorithm 3. EVMSimplification1

Input: P {EVM represented OPP}Input: dmax {Maximum value for the displacement}Output: Q {EVM represented BOPP}

Q PdetectBestSortingðABCsort;BACsort; CABsortÞfor d 1 to dmax do

Q mergingFaces (Q, ABCsort; d, false)Q mergingFaces (Q, BACsort; d, false)Q mergingFaces (Q, CABsort; d, false)Q mergingFaces (Q, ABCsort; d, true)Q mergingFaces (Q, BACsort; d, true)Q mergingFaces (Q, CABsort; d, true)if Q :Get nevðÞ ¼ 8 then break endif

end for


Algorithm 4. EVMSimplification2

Input: P {EVM represented OPP}Input: nv {Maximum number of EV in result}Output: Q {EVM represented BOPP}Q P; displaceIF false, d 1detectBestSortingðABCsort;BACsort;CABsortÞwhile Q :get nevðÞ > nv doQ mergingFaces ðQ ;ABCsort; d; displaceIFÞQ mergingFaces ðQ ; BACsort; d; displaceIFÞQ mergingFaces ðQ ; CABsort; d; displaceIFÞif displaceIF then d dþ 1 endifdisplaceIF :displaceIFif Q :Get nevðÞ ¼ 8 then break endifend while

5.3. Approximation quality

The presented approach generates bounding volumes,where every object Uiþ1 bounds object Ui as tightly as pos-sible. We measure the quality (tightness) HðUiÞ of a BOPPUi as the volume difference between Ui and the originalOPP U0, divided by the volume difference between the vol-ume of the AABB (Up) and U0, i.e.:

HðUiÞ ¼VðUiÞ � VðU0ÞVðUpÞ � VðU0Þ

; 8i ¼ 0 . . . p ð15Þ

where VðUiÞ is the volume of Ui computed by summing thevolumes of the slices (Sk) in its EVM representation usingthe following expression [1]:

VðPÞ ¼Xnc�1

k¼1

AreaðSkðPÞÞ � distðCkðPÞ; Ckþ1ðPÞ ð16Þ

where nc is the number of cuts and dist the distancebetween consecutive cuts that define a slice. The areais recursively computed in a similar way in 2D,where the perimeter is given by the length of the EVMbrinks.

(a)

(c)Fig. 13. The eight 3D configurations for EV. (a) one B voxel, (b) three B vo

This function is useful for indicating the distortion ofthe resulting BOPP, where HðUiÞ ¼ 0 means that Ui is theoriginal object U0 and HðUiÞ ¼ 1 means that Ui is the AABB.

6. Lossless progressive EVM encoding

In this section we describe the Progressive Extreme Ver-tices Encoding (PEVE), a data structure that encodes a BOPPsequence in a progressive and lossless way, with a reducedstorage size.

6.1. EVM encoding

In its raw format, EVM represents vertices as 3D points.Then, a 3D OPP is represented with a set of 3n values, nbeing the number of extreme vertices (EV). In storage size,this set occupies 3nb bits, b being the number of bits tostore a vertex coordinate.

EVM allows different schemes for data compressionusing the fact that EV are arranged in an ordered set of cuts[1]. There is not a general scheme since for each object itdepends on its shape and the ABC-ordering. Consideringan ABC-ordering, common A-coordinates, for EV lying oneach A-cut, and common B-coordinates, for EV lying oneach AB-cut, can be factored out. This compressed EVMuses two flags (2 bits) per each vertex to indicate respec-tively if A and B-coordinate are factored out and thus, thesevalues are not saved. Therefore, a vertex requires at most3bþ 2 bits when no coordinate is factored out, and onlybþ 2 bits when both A and B-coordinates are factored out.

6.2. Progressive Extreme Vertices Encoding (PEVE)

Throughout the merging faces process, there can be EVof object Ui that remain in object Uiþ1. Let CA and CB be apair of consecutive cuts, the following sets of vertices areremaining vertices:

(b)

(d)xels, (c) five B voxels, and (d) seven B voxels surrounding a vertex.

Fig. 14. Data structure for PEVE, indicating the number of bits required for each element. Top: The general structure, flagc indicates if the coordinate value isfactored out, flagv indicates if the v-scheme is factored out, b is the number of bits to encode a vertex coordinate. Bottom: structure for the three types ofvertices, where p is the number of encoded objects. Data that can eventually be excluded is highlighted in blue.


� Vertices belonging to ðEVMðBDAÞ � EVMðBDBÞÞ or toðEVMðFDBÞ � EVMðFDAÞÞ. This fact can be proved byapplying directly Eq. (9).� Vertices of the isolated faces of BDA and FDB when the

shape preservation technique is applied.

Therefore, PEVE encodes the sequence of objects in sucha way that remaining vertices are stored only once. Forinstance, Fig. 11 depicts a 2D LOD sequence generated bythe presented approach. For this dataset, the method pro-duces 3 more objects. Note that there are some remainingEV. Fig. 12 depicts the sequence put together and each EVis labeled with the object numbers to which it belongs.Note that, although there are vertices that only appearonce, there are also vertices that appear in two, three andeven in the four objects. Moreover, most of these verticesappear in consecutive objects, and only one appears innon-consecutive objects. For instance, the vertex in theupper-left corner of the object appears in all the objects,the vertex in the bottom-right corner appears from object1 to 3, while the vertex highlighted in yellow appears onlyin objects 0 and 2.

PEVE encodes EV of all objects into a single set, bystoring, for any vertex coordinate, an indicator to whichobjects this EV belongs. For storage purposes, we classifyEV into the next categories:

Unique (U):it appears once, i.e., it belongs only to one object Ui of thesequence.

Consecutive (C):it has a consecutive occurrence, i.e., it belongs to all objectsin an object interval ½Ui;Uj�, j > i.

Sporadic (S):it appears several times, either as an U or a C-vertex.

In a sporadic EV, the number of times it can appear is nomore than two in 2D and four in 3D as the following theo-rem proves.

Theorem 4. Let v be an EV in the LOD sequence, the numberof non successive occurrences throughout the simplificationprocess is no more than two in 2D, and four in 3D.

Fig. 15. ASCII representation of PEVE for the example in Fig. 11.

Proof. The proof is performed by enumeration. Consider a3D OPP embedded in a 3D grid in such a way that all OPP

vertices coincide with grid vertices. A vertex v is classifiedaccording to the color black (B) or white (W) of its eightsurrounding voxels. There are 28 ¼ 256 combinations,which applying reflections and rotations may be groupedinto 22 configurations. Eight of these configurations corre-spond to an EV and are those with an odd number of B andW surrounding voxels (see Fig. 13) while configurationswith an even number of B and W voxels do not correspondto EV [1]. Taking into account that the merging faces pro-cess always displaces faces outward the object, i.e. itenlarges the object, we can gradually go from 0 to 8 sur-rounding voxels, and not vice versa. Therefore, in the worstcase, if the number of surroundingvoxels of v changes stepby step, v can be EV at most four times (in odd configura-tions). The 2D case can be proved with the same reason-ing. h

Furthermore, experimental tests have yielded that spo-radic vertices appear rather infrequently, less than 6% of allEV in the LOD sequence.

Table 1Statistics and encoding results of the test datasets.

Model Size jEV j dmax jpairsj Time p jTEV j bytes crr crc

Venus 55 55 192 15,636 16 834 0.92 22 24,803 43,223 0.43 0.88FanDisk 275 300 153 21,010 64 1405 1.88 40 35,166 78,034 0.51 0.90Bunny 127 128 98 24,796 34 1219 1.86 29 41,335 71,153 0.47 0.85Aneurysm 213 215 240 50,318 40 6013 13.61 52 152,691 315,686 0.40 0.73Foot 110 310 112 51,532 45 2613 4.79 40 92,834 198,925 0.44 0.81DiskBrake 299 300 43 55,246 32 2410 4.51 34 108,101 228,187 0.45 0.84Athene 350 195 512 179,400 73 4052 13.10 54 286,099 573,122 0.39 0.77Phleg.Dragon 781 436 603 716,840 124 16,143 110.80 81 1,382,414 3,236,326 0.36 0.69Pelvis 905 1259 1108 2,082,078 206 42,665 471.30 119 4,762,211 11,672,096 0.31 0.61

Table 2Statistics of the test datasets storing logarithmically spacedapproximations.

Model p jTEV j Bytes

Venus 9 20,388 31,477FanDisk 10 28,535 58,865Bunny 10 33,298 51,698Aneurysm 12 81,461 140,685Foot 12 70,658 135,211DiskBrake 10 81,462 140,451Athene 13 239,607 432,231Phleg.Dragon 15 968,955 1,972,880Pelvis 16 2,871,608 6,170,999


The next v-scheme will be used in PEVE. For every ver-tex 2 bits are used to indicate its type, plus the followingassociated information that depends on the number ofobjects of the sequence, p:

� U-vertex: the object number to which it belongs, i.e.log2ðpÞ bits.� C-vertex: the number of the first and last objects to

which it belongs, i.e. 2log2ðpÞ bits.� S-vertex: 2 bits to indicate the number of intervals, plus

1 bit for each interval to indicate its type, followed bythe bits for the interval information. In the worst casean S-vertex can appear four times as C-vertex, i.e., itrequires at most 2þ 4ð1þ 2log2ðpÞÞ ¼ 6þ 8log2ðpÞ bits.

6.3. Data structure for progressive encoding

In order to progressively decode or transmit the wholeLOD sequence, PEVE must store first those EV that belongto object Up, then to Up�1, and so on. Therefore, EV aresorted in the following way:

1. First, according to the last object they belong indescending order.

2. Then by type (first S, then C, and then U-vertices).3. Finally by its XYZ-coordinates in ascending order.

In this way, we can decode first vertices correspondingto the more simplified object and progressively decode

Fig. 16. Quality distortion curves as a function

objects with a better LOD, yielding at the end the losslessinformation of the original object U0.

We group vertices by type since several U and C-verti-ces share the same v-scheme with other vertices of thesame type. Then, using a flag (1 bit) to indicate if thev-scheme is factored out, we avoid to store this informa-tion. The number of bits needed for a vertex coordinate isobtained from the resolution size of the dataset. Fig. 14depicts this data structure.

Fig. 15 shows PEVE in ASCII format for the datasetshown in Fig. 11. The whole sequence has 76 vertices butonly 51 vertices are encoded. After each vertex, letters U,C and S indicate the type, followed by its v-scheme; symbol⁄ indicates that v-scheme or a coordinate value is factored

of the percentage of total bytes decoded.


out. Moreover, observe that, when the first vertex whoselast object is U0 appears (vertex 29), it is not necessary tosave the v-scheme of the following vertices, as all of themare U-vertices belonging to U0, and therefore, this informa-tion can be omitted in the encoding.

Following with this example and considering 4 bits tocode a vertex coordinate, vertex 5 is coded with1þ 4þ 4þ 1þ 2þ 2þ 1þ 2þ 1þ 2 ¼ 20 bits, vertex 13with 1þ 4þ 4þ 1þ 2þ 2þ 2 ¼ 16 bits, vertex 14 with1þ 4þ 1 ¼ 6, and vertex 30 with 1þ 4 ¼ 5 bits. The wholeLOD sequence requires 54 bytes. Encoding each objectseparately with the compressed EVM (see Section 6.1)requires 61 bytes, and with EVM in its raw form (2 4 bitsper vertex), 76 bytes. Therefore, in the first case the com-pression ratio is 0.88 and in the second case 0.71.

7. Experimental results

PEVE has been tested on several 3D datasets withdifferent shape features such as size, number of connected

Fig. 17. Bunny. (a)–(d): Four objects generated with the octree-based method (approach.

Fig. 18. Pelvis. (a)–(d): Four objects generated with the BSP-based method (Fapproach.

components, concavities and holes. These datasets whereobtained from the following public repositories: Aim@-Shape, Models3d.ru, Stanford 3D Scanning, Czech RepublicSciences Academy and Czech TU, or own collection. Thecorresponding programs are written in C++ and have beentested on a PC Intel� Core 2 Duo CPU [email protected] GHz with3.2 GB RAM and running Linux.

We report here the results of simplification usingAlgorithm 4 with nv ¼ 8 and storing all intermediateobjects with PEVE. Statistics and results in a compilationof nine datasets are listed in Table 1. For each dataset itshows: size in voxels, number of extreme vertices (jEV j) inthe original dataset, maximum used distance (dmax), numberof processed pairs (jpairsj), i.e., number of times Eq. (9) isexecuted, global computation time to simplify the objectuntil the AABB (in seconds), total number of generated ob-jects (p), total number of extreme vertices (jTEV j), total PEVEstorage size in bytes, and compression rates with respect toa direct storage of the sequence in its raw EVM (crr) and withrespect to the compressed EVM (crc) (see Section 6.1). For

Figures featured in paper [48].). (e)–(h): Four objects generated with our

igures featured in paper [27]). (e)–(h): Four objects generated with our


these datasets the number of bits to encode a vertex coordi-nate varies from 7 to 11. All these datasets are shown inFigs. 9, 17, 18, 19, 20, 21 and 22. Note that, the number ofencoded objects is not 2dmax because there can be repeatedgenerated objects, and we do not consider them as a newobject.

Fig. 16(a) depicts the quality distortion curves of thetest datasets as a function of the percentage of total bytesdecoded (transmitted) in order to get the original object.This graph shows that the presented approach yields goodapproximations, H < 0:2, with only 10% of the decodeddata. Fig. 16(b) gives a closeup of the first 10%. Note thatthe more orthogonal or bigger is the object the less distor-tion it has along the simplification process (e.g. Pelvis,PhlegmaticDragon and Athene), while the opposite hap-pens with sparse or small objects (e.g. Aneurysm, Venusand DiskBrake).

7.1. Comparison with other methods

An ideal comparison would be against other methodswith the same dataset at the same scale, computing com-pression rates and visual quality. However, as we pointedout in Section 2, there are few methods that produce a pro-gressive LOD sequence of bounding volumes, and the cor-responding results are reported in different ways makinga global comparison hard. Nonetheless, we have chosenthose three methods in the revised literature that are morerelated to the presented one and we will perform ad hoccomparisons with each of them.

Fig. 19. Foot. (a)–(d): Four objects generated with the BSP-based method (Figures

The presented approach can generate sequences ofobjects in which pairs of consecutive objects only changein very few vertices. However, we are aware that for pro-gressive methods, logarithmically spaced approximationsare quite good. Therefore, in the following comparisonsthese kind of sequences will be generated, i.e., consecutiveobjects will satisfy the following statement: jEVðUiÞj 6 0:5jEVðUi�1Þj;8i ¼ 1; . . . ; p. Table 2 shows the statistics forthe test datasets with this restriction.

7.1.1. Comparison with an octree-based methodThe Bunny dataset has been tested by Samet and

Kochut in an octree-based approximation method [48].The size of the volume data is 1283 and, therefore, the re-gion octree has a maximum depth of 7 and the methodgenerates a LOD sequence of eight objects. In this method,29007 blocks are necessary to reconstruct the original Bun-ny. Each block is uniquely identified with a locational code,zn, which for any node xm is an integer computed with thenext recursive expression:

zi ¼0 i ¼ m

9 � zi�1 þ childtypeðxiÞ m < i 6 n

�

where the sequence < xi > represents all the directionalcodes on the path from the root node xn to node xm andchildtype returns the corresponding directional code.

Although this locational code supposes some compres-sion degree, the authors do not explain any way for furthercompression. However, we have compared the size of bothcodifications in two different ways. First, for an octree with

featured in paper [27]). (e)–(h): Four objects generated with our approach.

Fig. 20. Venus. (a)–(d): Four objects generated with the BSP-based method (Figures featured in paper [27]). (e)–(h): Four objects generated with ourapproach.


depth 7, in the worst case when all the directional codesare 8, this expression gives a maximum value of 8 � 90þ8 � 91 þ . . .þ 8 � 96 ¼ 4;782;968, therefore, the locationalcode for each block will require at most 23 bits. Thus, weestimate that the sequence of blocks of the Bunny requires,in this case, a total storage size of 83,396 bytes (29,007blocks � 23 bits). For the same dataset and at the same res-olution, PEVE requires 51,698 bytes for a total of 33,298 EVthat encode 10 objects. Note that in this case a vertex coor-dinate is encoded with log2ð128Þ ¼ 7 bits. This storage sizeis 0.619 of the storage size of the octree-based method.

On the other hand, we have considered the streams (inplain text) generated by both methods and then we havezipped them. For the octree-based method 29,007 randomnumbers between 1 and 4,782,968 have been generated,and for PEVE, we have generated a file like that shown inFig. 15. In this case, the total storage size of the zipped datastream of the octree-based method is 107,162 bytes1. ForPEVE, the zipped data stream requires 87,107 bytes. There-fore, this storage size is 0.812 of the storage size of theoctree-based method.

1 Similar results for more than 20 tests.

Fig. 17 shows a visual comparison of the approxima-tion quality of both methods. We show for each objectthe quantity of decoded (transmitted) bytes and the num-ber of elements (blocks and EV respectively). In all theapproximations PEVE gives a better indication of theshape with less storage cost, and even EVM objects with20,796 and 51,698 bytes look better than object with60,163 bytes in the octree-based method (see Fig. 17(b),(g) and (h).

7.1.2. Comparison with a BSP-based methodThe BSP-based method of Huang and Wang [27] (BSP,

from now on) generates approximations that are convexbounding volumes. Although this simplification methodis progressive, it is lossy and does not allow a progressivedecoding, so, we will compare separated approximations.We use three datasets tested with BSP: Pelvis, Foot andVenus (see Fig. 18–20). The basic element used in BSP isa plane represented by its four coefficients while for EVMis an EV represented by its three coordinates. Therefore,these datasets have been converted into EVM in such away that the number of EV is approximately 4/3 the num-ber of planes of the initial object.

Table 3Execution time (in seconds) for BSP and PEVE.

Model BSP PEVE

Venus 3.30 0.92Foot 12.50 4.79Donna 2382.00 471.30


Table 3 gives the execution time to obtain the LODsequence in both methods. BSP has been tested with C++program on a PC with Intel� Core 2 Quad [email protected] GHz. Note that although this PC is faster thanthe one we used, the execution times with BSP are higher.Fig. 18–20 show several approximations using BSP andPEVE for the Pelvis, Foot and Venus datasets showing foreach approximation the number of nodes (BSP), EV (PEVE)and the percentage of these elements with respect to theinitial object.

We make several observations concerning visual qual-ity. For the Foot dataset, the fingers in PEVE are noticeableeven in the 1.2% approximation (see Fig. 19(e)) while inBSP they look wrapped from the 30% approximation (seeFig. 19(c)). For the Pelvis dataset, PEVE approximationsmaintain better the genus (number of handles), the genusof the original Pelvis is 13, and this value is maintained inthe 28.1% approximation (see Fig. 18(g)), the genus for the6.2% and 0.5% approximations are 10 and 3 respectively.

On the other hand, the genus for the 30% approximationobtained by BSP seems to be less than 13 as some smallhandles are closed (see Fig. 18(b)) and in the 0.5% approx-imation holes look completely wrapped. Finally, for theVenus dataset, PEVE approximations maintain better theconcavities of the model than BSP.

7.1.3. Comparison with the BP-Octree methodMelero et al. have tested the BP-Octree (BP-O) [37] to

transmit progressively 3D objects over the network. We

Fig. 21. PhlegmaticDragon (a)–(c): Four objects generated by the BP-O methodapproach.

have tested the PhlegmaticDragon dataset, which has715,933 triangles (13298.9 kB in the PLY format). The gen-erated BP-O uses a tree with a maximum depth of 8, i.e., itcorresponds to a LOD sequence with nine objects. It con-tains 970,985 planes and supposes25,000 kB of transmit-ted data (1.8 times the original size). The authors claimthat the final geometry is never transmitted as a very fineapproximation of the model is reached at leaf nodes.However, if the original geometry was transmitted (truelossless), this size increases.

On the other hand, the original PhlegmaticDragon data-set has been represented in EVM with 716,840 EV(1309.9 kB, using the compressed EVM). Moreover, PEVEneeds 1972.9 kB (1.5 times the original size) to encode all15 generated objects. Note that the required storage sizein PEVE is noticeably smaller than using BP-O (7.8%) andthat in PEVE the original geometry is always transmittedwithout any extra cost.

In Fig. 21 we compare the visual quality of the shapeapproximation of BP-O and PEVE. For each approximation,we show the percentage of decoded transmitted elements(planes and EV respectively) with respect to the originalobject as well as the transmitted kB. In all approximationsPEVE gives a better indication of the shape with notablyless storage cost. Note that the BP-O approximation lookswrapped in low levels. Finally, although the authors donot indicate the PC used to generate the BP-O, they reportthe time it requires, 197.24 s, which is higher than to gen-erate PEVE, 110.8 s.

7.2. Application in structural parameters computation

Structural parameters allow to measure physical prop-erties of a sample such as osteoporosis degree of bones,suitability of biomaterials to be used as implants, transportand distribution of fluids into rocks for petrographicpurposes, grain shape for industrial and manufacturing

(Figures featured in paper [37]). (d)–(f): Four objects generated by our

Fig. 22. Examples of progressive decoded objects. From top to bottom. FanDisk, Aneurysm, and Athene datasets, indicating on each BOPP the percentage ofdecoded bytes.


applications. Recently, OPP represented either with EVM orCUDB have been demonstrated to be suitable to computestructural parameters of binary datasets compared withthe voxel model: Pore-size distribution [47], connectivity[7,16], sphericity and roundness [15]. Moreover, experi-mental tests have shown that the application of the simpli-fication method presented in this paper, can be used assupport in the structural parameters computation. Resultscan be summarized as follows (for details see [15]).

Regarding the pore-size distribution, the first approxi-mations of a porous sample retain enough relevantinformation and the generated histograms show a similarbehavior than the original sample, and as the approxima-tions contain less number of elements than the originaldataset, they are processed faster even considering thesimplification time. In the connectivity computation,objects containing big holes better preserve its genus (insome cases until approximations with 10% of encodeddata) than those objects containing small holes throughoutthe simplification. And, regarding the sphericity, as thisproperty is most dependent on elongation and the simpli-fication method keeps the AABB size in all the approxima-tions, the sphericity index changes slightly untilapproximations with 10% of encoded data.

8. Conclusions

We have presented an approach to simplify orthogonalpolyhedra and 3D binary images, represented with EVM. It

generates a LOD sequence of BOPP, which fulfill the com-mon subset and AABB properties of bounding structures.The approach is based on a merging faces strategy and dealswith OPP with any number of holes and connected compo-nents. It also includes a technique, based on model conti-nuity, for a better shape preservation. We have pointedout the efficiency and robustness of EVM Boolean opera-tions, specially xor, and we have taken full advantage ofthis operation. Finally, we have presented a data structure,PEVE, to encode in a progressive and lossless way the gen-erated LOD sequence.

From experimental results, we can conclude that theLOD sequence generated by this method is satisfactory interms of quality of the approximation, although betterquality is obtained when more orthogonal is the objectshape. Compared with other approaches, PEVE gives goodcompression rates and processing time. Moreover, the gen-erated bounding approximations are tighter, in general,than in other approaches, maintaining concavities, genusand other shape features at a very compressedapproximations.

The presented approach can be very useful in applica-tions that require bounding volumes and deal with many3D objects, specially where most of them are distributedin an orthogonal way, e.g. to speed up the collision detec-tion in the automatic pipe routing in ships [6].

As a future work, we are devising a new method forpore space partitioning, as an extension of our previouswork, based on narrow throat detection [47]. We will applythis method to real silica nano datasets. To analyze the


resulting complex forms we will simplify them with thepresented method before applying the pore space parti-tioning. As the simplified object bounds the original,detected narrow throats on it will be also narrow throatson the original. Currently, we are preparing a new paperwith these results and other benefits like those describedin Section 7.2 of performing simplification using OPP.

Other directions for future work include the study of anEVM and CUDB based data structure to efficiently encodetime-varying datasets.

Acknowledgments

This work was partially supported by the national Pro-jects TIN2008-02903 and TIN2011-24220 of the Spanishgovernment and a CONACYT grant of the Mexican govern-ment for I. Cruz-Matías. The authors thank the anonymousreviewers whose suggestions and questions gave themchallenge and opportunity to greatly improve the paper.

References

[1] A. Aguilera, Orthogonal Polyhedra: Study and Application, Ph.D.Thesis, LSI-Universitat Politècnica de Catalunya, 1998.

[2] A. Aguilera, D. Ayala, Orthogonal polyhedra as geometric bounds inconstructive solid geometry, in: Fourth ACM Sym. on Solid Modelingand Applications, ACM, 1997, pp. 56–67.

[3] P. Alliez, M. Desbrun, Progressive compression for losslesstransmission of triangle meshes, in: Proc. of the 28th Ann. Conf. onComp. Graphics, SIGGRAPH, ACM, 2001, pp. 195–202.

[4] C. Andújar, Octree-based Simplification of Polyhedral Solids, Ph.D.Thesis, LSI-Universitat Politècnica de Catalunya, 1999.

[5] C. Andújar, P. Brunet, D. Ayala, Topology-reducing surfacesimplification using a discrete solid representation, ACM Trans.Graph. 21 (2002) 88–105.

[6] A. Asmara, Optimum routing of piping in real ships under realconstraints, in: 7th Int. Conf. on Computer and IT Apps. in theMaritime Industries, USA: ONR Global, 2008, pp. 271–281.

[7] D. Ayala, E. Vergés, I. Cruz, A polyhedral approach to compute thegenus of a volume dataset, in: Proc. of the Int. Conf. GRAPP 2012,SciTePress, 2012, pp. 38–47.

[8] T. Biedl, B. Gen, Reconstructing orthogonal polyhedra from putativevertex sets, Comput. Geomet. 44 (2011) 409–417.

[9] A. Biswas et al., A linear-time combinatorial algorithm to find theorthogonal hull of an object on the digital plane, Inf. Sci. 216 (2012)176–195.

[10] O. Bournez, O. Maler, A. Pnueli, Orthogonal polyhedra:representation and computation, in: Hybrid Systems: Computationand Control. LNCS 1569, Springer, 1999, pp. 46–60.

[11] J.W. Chang, W. Wang, M.S. Kim, Efficient collision detection using adual OBB-sphere bounding volume hierarchy, Comput.-Aid. Des. 42(2010) 50–57.

[12] P. Cignoni, D. Costanza, C. Montani, C. Rocchini, R. Scopigno,Simplification of tetrahedral meshes with accurate errorevaluation, in: Proc. of VIS’00, IEEE, 2000, pp. 85–92.

[13] P. Cignoni, C. Montani, R. Scopigno, A comparison of meshsimplification algorithms, Comput. Graph. 22 (1998) 37–54.

[14] D.S. Coming, O.G. Staadt, Velocity-aligned discrete orientedpolytopes for dynamic collision detection, IEEE Trans. Visualizat.Comput. Graph. 14 (2008) 1–12.

[15] I. Cruz-Matías, Contribution to Structural Parameters Computation:Volume Models and Methods, Ph.D. Thesis, LSI-UniversitatPolitècnica de Catalunya, 2014.

[16] I. Cruz-Matías, D. Ayala, An efficient alternative to compute thegenus of binary volume models, in: Proc. of the Int. Conf. GRAPP2013, SciTePress, 2013, pp. 18–26.

[17] T. Dang, O. Maler, Reachability analysis via face lifting, in: HybridSystems: Computation and Control, Springer, 1998, pp. 96–109.

[18] D. Eppstein, E. Mumford, Steinitz theorems for orthogonalpolyhedra, in: Proceedings of the 2010 Annual Symposium onComputational Geometry, Springer, 2010, pp. 429–438.

[19] C. Esperança, H. Samet, Orthogonal polygons as bounding structuresin filter-refine query processing strategies, SSD ’97, vol. 1262,Springer-Verlag, 1997, pp. 197–220.

[20] C. Esperança, H. Samet, Vertex representations and their applicationsin computer graphics, Visual Comput. 14 (1998) 240–256.

[21] R. Fuchs, V. Welker, J. Hornegger, Non-convex polyhedral volume ofinterest selection, J. Comput. Med. Imag. Graph. 34 (2010) 105–113.

[22] N. Gagvani, D. Silver, Shape-based volumetric collision detection, in:Proceedings of the 2000 IEEE Symposium on Volume Visualization,VVS ’00, ACM, 2000, pp. 57–61.

[23] P.M. Gandoin, O. Devillers, Progressive lossless compression ofarbitrary simplicial complexes, ACM Trans. Graph. 21 (2002) 372–379.

[24] A. Glassner, An Introduction to Ray Tracing, Academic Press, 1989.[25] A. Greß, R. Klein, Efficient representation and extraction of 2-

manifold isosurfaces using kd-trees, Graph. Models 66 (2004) 370–397.

[26] N. Hagbi, J. El-Sana, Carving for topology simplification of polygonalmeshes, Comput. Aid. Des. 42 (2010) 67–75.

[27] P. Huang, C. Wang, Volume and complexity bounded simplificationof solid model represented by binary space partition, in: Proceedingsof Symp. SPM’10, ACM, 2010, pp. 177–182.

[28] J.J. Jiménez, F.R. Feito, R.J. Segura, Tetra-trees properties in graphicinteraction, Graph. Models 73 (2011) 182–201.

[29] P. Jiménez, F. Thomas, C. Torras, 3D collision detection: a survey,Comput. Graph. 25 (2000) 269–285.

[30] M. Khachan, P. Chenin, H. Deddi, Polyhedral representation andadjacency graph in n-dimensional digital images, Comput. Vis.Image Understand. 79 (2000) 428–441.

[31] D.J. Kim, L. Guibas, S.Y. Shin, Fast collision detection among multiplemoving spheres, IEEE Trans. Visual. Comput. Graph. 4 (1998) 230–242.

[32] J. Klosowski et al., Efficient collision detection using boundingvolume hierarchies of k-DOPs, IEEE Trans. Visual. Comput. Graph. 4(1998) 21–36.

[33] J. Lachaud, A. Montanvert, Continuous analogs of digital boundaries:a topological approach to iso-surfaces, Graph. Models 62 (2000)129–164.

[34] T. Larsson, T. Akenine-Möller, Bounding volume hierarchies of slabcut balls, Comput. Graph. Forum 28 (2009) 2379–2395.

[35] H. Lee, M. Desbrun, P. Schröder, Progressive encoding of complexisosurfaces, ACM Trans. Graph. 22 (2003) 471–476.

[36] J. Martínez, N. Pla, M. Vigo, Skeletal representations of orthogonalshapes, Graph. Models 75 (2013) 189–207.

[37] F.J. Melero, P. Cano, J.C. Torres, Bounding-planes octree: a newvolume-based lod scheme, Comput. Graph. 32 (2008) 385–392.

[38] M.A. Otaduy, M.C. Lin, Sensation preserving simplification for hapticrendering, in: ACM SIGGRAPH 2005 Courses, ACM, xxxx, p. 72.

[39] R. Pajarola, J. Rossignac, SQUEEZE: fast and progressivedecompression of triangle meshes, in: Proc. of Computer GraphicsInt. Conf., IEEE Computer Society, 2000, pp. 173–182.

[40] S.C. Park, B.K. Choi, Boundary extraction algorithm for cutting areadetection, Comput.-Aid. Des. 33 (2001) 571–579.

[41] T. Park, H. Lee, C.h. Kim, Progressive compression of geometryinformation with smooth intermediate meshes, in: Proc. of IbPRIA’07, LNCS, Springer-Verlag, 2007, pp. 89–96.

[42] M. Pauly, M. Gross, L.P. Kobbelt, Efficient simplification of point-sampled surfaces, in: Proc. of Conf. on Visualization, VIS ’02, IEEEComputer Society, 2002, pp. 163–170.

[43] J. Peng, C.C.J. Kuo, Geometry-guided progressive lossless 3d meshcoding with octree (ot) decomposition, ACM Trans. Graph. 24 (2005)609–616.

[44] R. Pérez-Aguila, Computing the discrete compactness of orthogonalpseudo-polytopes via their nD-EVM representation, Math. Probl.Eng. 2010 (2010) 28.

[45] O. Ripolles, M. Chover, J. Gumbau, F. Ramos, A. Puig-Centelles,Rendering continuous level-of-detail meshes by masking strips,Graph. Models 71 (2009) 184–195.

[46] J. Rodríguez, D. Ayala, A. Aguilera, EVM: a complete solid model forsurface rendering, in: Geometric Modeling for ScientificVisualization, Springer-Verlag, 2004, pp. 259–274.

[47] J. Rodríguez, I. Cruz, E. Vergés, D. Ayala, A connected-component-labeling-based approach to virtual porosimetry, Graph. Models 73(2011) 296–310.

[48] H. Samet, A. Kochut, Octree approximation and compressionmethods, in: Proc. of First Int. Symp. on 3D Data Proc. Vis. andTrans., IEEE Computer Society, 2002, pp. 460–469.

[49] R. Sun, S. Gao, W. Zhao, An approach to b-rep model simplificationbased on region suppression, Comput. Graph. 34 (2010) 556–564.

http://refhub.elsevier.com/S1524-0703(14)00004-6/h0045


































































































































[50] S. Suri, P.M. Hubbard, J.F. Hughes, Analyzing bounding boxes forobject intersection, ACM Trans. Graph. 18 (1999) 257–277.

[51] M. Tarini, et al., Practical quad mesh simplification, in: ComputerGraphics Forum (Special Issue of Eurographics 2010 Conference),vol. 29, 2010, pp. 407–418.

[52] R. Tilove, A. Requicha, Closure of Boolean operations on geometricentities, Comput.-Aid. Des. 12 (1980) 219–220.

[53] I.J. Trotts, B. Hamann, K.I. Joy, Simplification of tetrahedral mesheswith error bounds, IEEE Trans. Visual. Comput. Graph. 5 (1999) 224–237.

[54] J. Vanderhyde, A. Szymczak, Topological simplification of isosurfacesin volume data using octrees, Graph. Models 70 (2008) 16–31.

[55] M. Vigo, N. Pla, D. Ayala, J. Martínez, Efficient algorithms forboundary extraction of 2D and 3D orthogonal pseudomanifolds,Graph. Models 74 (2012) 61–74.

[56] A. Vogiannou et al., Enhancing bounding volumes using supportplane mappings for collision detection, Comput. Graph. Forum 29(2010) 1595–1604.

[57] I. Wald, S. Boulos, P. Shirley, Ray tracing deformable scenes usingdynamic bounding volume hierarchies, ACM Trans. Graph. 26(2007).

[58] J. Williams, J. Rossignac, Tightening: morphological simplification,Int. J. Comput. Geomet. Appl. 17 (2007) 487–503.

[59] S.E. Yoon, B. Salomon, M. Lin, D. Manocha, Fast collision detectionbetween massive models using dynamic simplification, in:Proceedings of the 2004 Eurographics/ACM SIGGRAPH symposiumon Geometry processing, ACM, xxxx, pp. 136–146.

[60] G. Zachmann, Minimal hierarchical collision detection, in:Proceedings of the ACM Symposium on Virtual Reality Softwareand Technology, ACM, 2002, pp. 121–128.

























Documents

A new lossless orthogonal simplification method for 3D objects based on bounding structures