06506083

A Search-and-Validate Method forFace Identification from Single Line Drawings

Mei Chee Leong, Yong Tsui Lee, and Fen Fang

AbstractSeveral studies have been made in finding the faces of an object depicted in a line drawing, but the problem has not been

completely solved. Although existing methods can find the correct faces in most cases, there is no mechanism to ascertain that they

are indeed correct, leaving the human user to do so. This paper uses a two-stage approachfind potential faces, then validate their

correctnessto ensure that only correct faces are delivered ultimately. The face finding itself uses a double breadth-first search

algorithm, which yields the shortest path, to find the potential faces. The basic premise is that the smallest faces found are more likely

the correct ones. They serve as the seed potential faces, from which the algorithm proceeds to search for more faces. If the potential

faces found satisfy the validation rules, then they are accepted as correct. Otherwise, the wrong potential faces are identified and

removed, and new ones found in their place. The validation process is then repeated. The algorithm is fast and reliable, can deal with

planar-faced manifold and nonmanifold objects, and can deliver the different results when a drawing has multiple interpretations. Our

extensive tests show that the method can deal with most cases efficiently, including those that previous methods cannot solve.

Index Terms3D reconstruction, breadth-first search, face identification, single line drawing

1 INTRODUCTION

RECONSTRUCTION of 3D models from 2D line drawings hasbeen an active research area in the past three decades.Generally, the reconstruction process has two steps: faceidentification, followed by 3D geometry reconstruction [1].This paper focuses on the first step, which is to identify thecorrect faces of the object depicted in a single 2D linedrawing, defined as the projection of the wireframe of anobject from a general viewpoint which reveals all the edgesand vertices, and the drawing can be represented by asingle edge-vertex graph [2]. Here, the objects are restrictedto planar polyhedra.

A number of methods for face identification from linedrawings have been reported, and they will be reviewed inSection 2. Suffice to say for now that these methods can findthe correct faces in most cases, but theymay fail in some. Theproblem is that, in all these methods, it is up to the humanuser to discern the correct results from the incorrect ones.The algorithms themselves are none the wiser. This poses aproblemwhen face finding is a part of an automated process,as in the case of 3D reconstruction. This paper presents amethod that incorporates result validation as a part of theface identification process, with a mechanism to makecorrection automatically when the result fails the validation.When no correct result can be found, such as when thedrawing does not actually depict a proper object, thealgorithm would say so. The face identification itself uses a

shortest path approach, which could deal with both planar-faced manifolds and nonmanifolds, and is not limited toobjects with trihedral vertices. The kernel of our method isbased on the spanning tree built by a double breadth-firstsearch (BFS) algorithm, which is faster and requires lessstorage in finding the shortest loop in a connected graphcompared to a single breadth-first search algorithm.

We arrange the remainder of the paper as follows:Section 2 presents the recent works in face finding. Section 3explains the terminologies used in the remainder of thispaper. Section 4 presents a list of properties used to identifythe real faces of an object. Section 5 gives an overview of ourapproach and Section 6 presents the details of thealgorithm, followed by the validation process in Section 7.Experimental results as well as comparisons with existingmethods are presented in Section 8. Section 9 concludes.

2 RELATED WORK

Varley andCompany [3] presented a historical survey on facedetection approaches and categorized them into six groups:

1. geometric approaches,2. purely graph-theoretical approaches,3. search-based approaches,4. pseudorandom approaches,5. shortest path approaches, and6. other approaches.

Approach 1, as in the work of Markowsky and Wesley[4], requires a full 3D wireframe formed by 3D vertices. Theinput data are then used to calculate the plane equations.This approach is not applicable in our work as we only use2D wireframes. In Approach 2, Agarwal and Waggenspack[5] use a purely graph-theoretical algorithm to derivethe surface topologies from wireframe representations.It works well for nonplanar and not three-connectedgraphs. However, geometric information is still necessaryin solving ambiguous models and identifying topologically

2576 IEEE TRANSACTIONS ON PATTERN ANALYSIS AND MACHINE INTELLIGENCE, VOL. 35, NO. 11, NOVEMBER 2013

. The authors are with the School of Mechanical and Aerospace Engineering,Nanyang Technological University, 50 Nanyang Avenue, N3-02a-08,Singapore 639798, Singapore. E-mail: {leongmc, mytlee}@ntu.edu.sg,[email protected].

Manuscript received 31 Oct. 2012; revised 27 Feb. 2013; accepted 14 Apr.2013; published online 18 Apr. 2013.Recommended for acceptance by C.-K. Tang.For information on obtaining reprints of this article, please send e-mail to:[email protected], and reference IEEECS Log NumberTPAMI-2012-10-0868.Digital Object Identifier no. 10.1109/TPAMI.2013.82.

0162-8828/13/$31.00 2013 IEEE Published by the IEEE Computer Society

correct but geometrically incorrect faces. Approaches 3 to 6are more effective in face finding where the results arepromising and the computational time is reasonable.Methods in Approaches 3 and 4 can be used to deal withgeneral objects, i.e., manifold and nonmanifold objects.However, Approach 3 becomes slow when the number offaces increases, while the efficiency of Approach 4 dependson the chosen parameters in the initialization. Varley andCompanys method [3] belongs to Approach 5; it worksfaster, but does not deal with nonmanifold objects and hastest cases that produce wrong results. We will look intothese approaches individually in the following sections.

The intention of our paper is to extend the study andestablish a method that is fast, reliable, and able to copewith general objects.

2.1 Search-Based Method

Shpitalni and Lipson [6] employ the search-based approachin their work, which was later improved by Liu and Lee [7].Both works involve two combinatorial problems: finding allsets of potential face loops in the line drawing, followed byan optimization method to choose the best solution.Shpitalni and Lipson use the circuit space method to searchfor all the potential faces, and solve the optimizationproblem with the A* algorithm. Due to the exponentiallyincreasing combinatorial search related to its size, itbecomes inefficient and time consuming when the numberof faces increases to more than 20 [7].

Liu and Lee [7] revisit the problem and employ a depth-first search (DFS) algorithm to generate the potential faces,and select the optimal solution with a maximum weightclique finding algorithm. The resulting faces are the sameas Shpitalni and Lipsons, but the execution time for Liuand Lees algorithm is much lower when handling objectswith more than 20 faces [7]. However, it still faces the sameproblem of exponential time complexity over the numberof vertices.

Both methods cope well with manifold and nonmani-fold objects. In cases where multiple solutions are found,image regularities [8] are used to determine the mostplausible solution.

2.2 Pseudorandom Method

Liu and Tang [9] propose a more efficient face findingapproach for general objects by developing a hybridvariable-length genetic algorithm combining a local searchheuristic. Their approach finds the solution by direct searchin the line drawing to overcome the combinatorial problemsfaced by Shpitalni and Lipson [6] and Liu and Lee [7].Incorporated into the local search algorithm are the upperbound ranks, geometric constraints, and a novel heuristiccalled minimal edge face phenomenon [9]. The local searchalgorithm is then applied in the mutation and crossoveroperations to obtain the fittest chromosomes.

The experimental results show that the execution timegrows almost linearly with the number of edges in thedrawing. It is a major improvement in the computationaltime and memory requirements when the number of facesincreases to more than 30 [1]. To handle drawings withmultiple solutions, the algorithm runs a postprocess tosearch for the most plausible solution using image regula-rities as done in [6] and [7].

2.3 Shortest Path Method

Varley and Company [3] present an improved version ofDijikstras Algorithm [10] by imposing context-dependentpath length as the traversal cost to find the least cost closedloops in a graph. For each pair of paths in the graph, amating value is calculated as a function to reflect thecoplanarity condition, and each connected path is asso-ciated with a priority value.

Initially, each edge is decomposed into two half-edgeswith opposite direction, and is represented by a string. Astring is defined as an ordered sequence of two or morevertices, where no repeated vertex is allowed. The algorithmstarts with an arbitrary trihedral junction, where theyconcatenate one string heading toward the junction andanother string leaving the junction. Two strings are con-catenated to form a longer string if the last vertex of onestring is the first vertex of the other. If the last vertex of astring is the first vertex of another, these two strings aremerged to form a face. The algorithm works on several facessimultaneously and searches for the first face to becompleted, which tends to be a smaller face and is morelikely to be a correct one. This helps to reduce the possibilityof choosing the wrong solutions when approaching largerfaces with multiple edges.

Their approach is as reliable as the genetic algorithmmethod by Liu and Tang [9], but with shorter processingtime. In the experimental result, a line drawing with250 edges requires one second of processing time to obtainall the correct faces, which is fast enough to be used in aninteractive system. Also, the very comprehensive experi-mental data presented in [3] show that there are a smallnumber of cases for which the algorithm produces thewrong results. The limitation of this approach is that it onlyworks on manifold objects.

2.4 Generalized High-Dimensional Face Finding

Li et al. [11] propose a new idea of detecting an nD (highdimensional) object from a single 2D line drawing. The twomain ideas of this approach are localization and deletion.The algorithm locally constructs the r 1D faces whileuseless rD faces are deleted.

Starting from an origin vertex, localization is done byconsidering only the subgraph of the origin and itsneighboring vertices. Then, they search for rD cycles whichcorrespond to r 1D faces in the local wireframe byconsidering both topological and geometric information.After identifying the faces, some of the edges are blocked,preventing any more new r 1D faces from sharing thesame edges. Hence, these edges are deleted and the searchscope is reduced. Later, the current local wireframe is set asthe origin, and the processes of localization, construction,and deletion are repeated, while the older origin is deleted.

Li et al. claim that their algorithm outperforms all otherface finding algorithms in both speed and range ofapplication. It can handle complex 3D objects of over10,000 faces within one and a half hours. However, it doesnot deal with nonmanifolds, and does not mention how thefaces found are validated [3].

2.5 Summary

All the existing methods have shortcomings. In particular,none guarantee that they will return the correct resultnor have they the ability to flag the incorrect ones. As

LEONG ET AL.: A SEARCH-AND-VALIDATE METHOD FOR FACE IDENTIFICATION FROM SINGLE LINE DRAWINGS 2577

mentioned earlier, this becomes a problem when facefinding is a part of an automated process, such as 3Dreconstruction. We will now present a new method thatovercomes this deficiency while improving on the perfor-mance in general.

3 TERMINOLOGY

Here, we define the terms that will be used in the remainder

of the paper. Most are commonly known, a few are created

for this paper.

. Graph, GA graph consists of two finite sets, thevertex set V G and the edge set EG. The lines andpoints in a drawing correspond to the edges andvertices in a graph.

. Cycle/LoopA cycle or loop is a closed path in Gthat begins and ends at the same vertex.

. Multiedge loop/faceA loop/face with more thanfour edges.

. Vertex degree, dvThe degree of a vertex v is thenumber of edges adjacent to v.

. Vertex rank, RvThe rank of a vertex v is thenumber of faces whose boundaries contain v.

. Edge rank, ReThe rank of an edge e is thenumber of faces whose boundaries contain e.

. ChordA chord is an edge that connects twononadjacent vertices in a cycle.

. TreeA tree is a connected graph with no cycles.

. Spanning treeA spanning tree of a graph G is atree that contains every vertex of G.

. Tentative faceA tentative face is a cycle with nointersecting edges and no internal chords, and hasyet to be verified as a potential face.

. Potential faceA potential face is a tentative facewhich can coexist with other potential faces of anobject. A set of potential faces that satisfy thevalidation requirements is verified as the correctface set of a valid 3D interpretation.

. Internal faceAn internal face is an imaginary facewhere only its bounding edges are visible on thesurface.

. ManifoldA manifold, or, more specifically, amanifold of dimension two (two-manifold), is anobject where the neighborhood of every point ishomeomorphic to a sphere. The neighborhood ofeach point on the boundary of a manifold solid hastwo contiguous regions: the regions inside andoutside the solid [12]. Examples of manifold objectsare shown in Figs. 1a and 1b.

. Simple manifoldA manifold which cannot bedecomposed into smaller manifolds along existing

edges or vertices (see Fig. 1b). A simple manifold is asubset of manifold.

. Simple nonmanifoldA combination of sheet facesto form a nonsolid object (see Fig. 1c). Simplenonmanifold is a subset of nonmanifold. In general,nonmanifolds may be formed by a combination ofmanifolds, simple nonmanifolds, and danglingedges (see Fig. 1d).

4 IDENTIFICATION of POTENTIAL FACES

Before presenting our algorithm, we first introduce some ofthe geometric properties used to identify real faces of aplanar object. These properties are incorporated in the facefinding process to discard cycles that cannot be real faces,reducing the number of tentative faces found. The followingproperties have been presented and proven in the work ofShpitalni and Lipson [6] and Liu et al. [2]:

. Property 1: A self-intersecting cycle cannot be a realface.

. Property 2: A cycle with an internal chord cannot bea real face.

. Property 3: Based on the Face Adjacency Theorem[6], two adjacent faces sharing two or more edgescan coexist if and only if these common edges arecollinear.

. Property 4: If two cycles share two nonadjacentvertices and if the virtual chord joining these twovertices is inside both the cycles, fully or partially,then both the cycles cannot be real faces. Fig. 2ashows two cycles that coexist with an externalvirtual chord AB; Figs. 2b and 2c show two cyclesthat enclose a virtual chord AB, fully and partially,respectively; they cannot be real faces.

. Property 5: For manifold objects, the rank of eachedge must be exactly two.

Properties 1 and 2 apply to individual cycles; a cyclesatisfying them is a tentative face. Properties 3 and 4 relatetwo different cycles, determining if they can coexist; atentative face must satisfy them to qualify as a potentialface. Properties 1 to 4 apply to manifolds and nonmanifolds,while Property 5 applies to manifolds only.

5 ALGORITHM OVERVIEW

Our algorithm solves the face identification problem for

both manifold objects and simple nonmanifold objects. Two

or more manifolds that join to form a nonmanifold will not


Fig. 1. (a) Manifolds, (b) simple manifolds, (c) simple nonmanifolds, and(d) nonmanifolds.

Fig. 2. (a) Virtual chord AB forms an external chord of both cycles.(b) Virtual chord AB forms an internal chord of both cycles. (c) Virtualchord AB fully enclosed in one cycle, and partially in another.

be covered here because the latter can be easily andautomatically partitioned into the constituting manifoldsand processed separately [13]. Similarly, drawings contain-ing a combination of manifolds and nonmanifolds, such asmanifolds with dangling edges and faces, can be parti-tioned into the individual components and will also not betreated here.

The problem statement of our work is: Given a 2D linedrawing of a planar object, return the correct faces of itsvalid 3D interpretation. A correct face set is found when itpasses our validation criteria. In cases where no correct faceset can be found, such as for nonsense objects or erroneousinput drawings, an error message will be delivered. A 2Dline drawing is the projection of a wireframe object whereall the vertices and edges, including the hidden ones, arevisible. Any vertex existing explicitly in the object must be avertex in the drawing also and has to be explicitly identifiedby the user. For instance, Fig. 3 shows a 2D line drawing ofa single edge-vertex graph. The intersecting point of lines IEand BO is identified explicitly as vertex G.

With the correct input data, our algorithm can nowproceed to search for the potential faces. Basically, ouralgorithm has three main stages: 1) Find triangular andquadrilateral loops, 2) find multiedge loops, and 3) validatethe faces found. If the validation fails, remove the wrongloops and repeat Stage 2.

Our face finding process starts by searching for all thetriangular and quadrilateral loops and storing them aspotential faces. These are short loops which are more likelyto form real faces [3]. (In this paper, to be succinct, we usethe term long or short to mean loops with a high or lownumber of edges, not the physical length of the loops.) Theyform the seed potential faces, from which we can proceedto search for the multi-edge faces using breadth-first search.The end results are then put through a validation process. Ifthe faces pass the validation, then the desired outcome isobtained, else the algorithm backtracks and looks for someother faces. The process overview is summarized in theflow chart in Fig. 4.

Before presenting the details, we use an example toprovide a clear picture of the algorithm and illustrate howbreadth-first search is used to find the faces. The drawing inFig. 3 depicts a manifold object with 23 edges:

AB AC AN BD BG CD CM DE EF EG FH FL GI GO HI HJIK JK JL KO LM MN NO

The algorithm starts by searching for the triangular andquadrilateral loops. The example has no triangular loop, butsix quadrilateral loops: ACDBA, ANMCA, BGEDB, FLJHF,GOKIG, and HJKIH, which satisfy Properties 3 and 4 andthus form the initial potential faces.

Fig. 3 is a simple manifold where the upper bound of therank for each edge is two, denoting that each edge can only becontained in at most two faces. The calculation of the upperbound of edge rank will be explained further in the nextsection. Edges bordering one potential face have the rank ofone,while those shared by two potential faces have rank two.Edges AC, BD, HJ, and IK, each shared by two of the abovequadrilateral loops, cannot be used to form other new faces,and are removed from the edge list. So the remaining edgesof rank one (underlined) and rank zero are:

AB AN BG CD CM DE EF EG FH FL GI GO HI JK JL KOLM MN NO

Next, we proceed to search for multi-edge loops. Thestrategy is to start from one of the remaining edges with thelowest rank, and use its two end points as the roots of twobreadth-first search trees, labeled Left and Right. Eachbreadth-first search forms a tree of vertices, with a parentvertex pointing to the vertices immediately connected to it.The newest level of a tree contains the latest vertices found;we shall call this the front. We alternate in finding the newfronts of the Left and Right Trees. Every time a new front isfound on one tree, we check it against the current front ofthe other tree. If there are common vertices on the twofronts, then we have found a loop whose vertices can beobtained by tracing back the parents on the two trees. Thisloop forms a tentative face if there are no intersecting edgesand no internal chords in the loop.

In the example, we could select one of the edges EF, LM,or NO as the algorithms input as their ranks are zero. Thereason to start with an edge with a lower rank is that itoffers the possibility of obtaining more new tentative facessharing the edge, reducing the number of searches for theremaining edges. Assume that edge EF is selected, and wedesignate vertex E as the root of Left Tree, and vertex F asthe root of Right Tree. Breath-first search now takes placealternately in the two directions. Here, we found edges EDand EG are connected to vertex E, while edges FH andFL are connected to vertex F . So now we have vertices D


Fig. 3. Hinge arm [3]; vertex G exists explicitly.

Fig. 4. Overview of the process flow.

and G as the new front of Left Tree, while vertices H and Lare the new front of Right Tree (see Fig. 5).

The exploration continues, obtaining vertices C, O, and Ion the Left, and then vertices I and M on the Right. Notethat vertex B is not included on the Left front as both edgesBG, GE have been used in the potential face BGEDB; itviolates Property 3. At this point, we note that vertex Iexists in both fronts. By tracing back the parents, a tentativeface EGIHFE is found. As this tentative face can coexist withthe other potential faces, it is then added to the potentialface list. Vertex I is then removed from the front of bothtrees. Once a potential face is formed, we check the path ofeach remaining vertex in the fronts against Property 3. Onthe Left Tree, we have path CDEF from vertex C and pathOGEF from vertex O. Path OGEF violates Property 3 due tothe sharing of two noncollinear edges GE and EF. Hence,we are now left with vertex C on the Left, and vertex M onthe Right in their respective fronts for further propagation.From vertex C on the Left, we continue to vertex M, wherethe two trees meet again. A tentative face EDCMLFE isformed, which is verified as a potential face later.

The traversal process stops when there are no morevertices available on either front of the trees. Fig. 5illustrates the complete edge and vertex traversal startingfrom edge EF.

With the two new potential faces (EGIHFE andEDCMLFE), the ranks of edges CD, CM, DE, EF, EG, FH,FL, GI, and HI become two. They are thus removed from theedge list and the remaining edges of rank one (underlined)and zero are:

AB AN BG GO JK JL KO LM MN NOEdge NOwith rank zero is then selected as the next input

for the algorithm. With the same traversal process as edgeEF, we now obtain two more potential faces NABGON andNMLJKON, as shown in Fig. 6. All the remaining edges inthe list now have the rank of two, and so all of them areremoved from the list. With no more edges in the list, theprocess is completed and the algorithm terminates.

So the potential faces found are: ACDBA, ANMCA,BGEDB, FLJHF, GOKIG, HJKIH, EGIHFE, EDCMLFE,NABGON, and NMLJKON. The next stage is to verifywhether all these faces found are correct. In this example,the face set meets the validation rules: satisfies Property 5,as well as the Euler-Poincare equation [14], which relatesthe number of vertices, edges, faces through holes andshells in a manifold. Details of the validation process willbe explained further in Section 7. Therefore, the facefinding process is completed with the correct faces as thefinal result.

This is a straightforward example aimed at providing abasic idea on how the algorithm works. There are further

details for dealing with more complicated situations, andthese will be explained in the full algorithm, whichcomes next.

6 THE ALGORITHM DETAILS

6.1 Data Structures

Useful data structures are created to facilitate the facefinding process. There are four important structures:

1. vertex adjacency matrix,2. edge adjacency matrix,3. edge-edge intersection matrix,4. upper bound of edge and vertex rank.

The graph of a drawing is represented as a vertexadjacency matrix, A. Aij 1 denotes that vertices i and j areconnected by an edge in a line drawing, while Aij 0means they are not connected. From the vertex adjacencymatrix, we can build an edge adjacency matrix, M, using1 to indicate nonadjacent edges and 1 for adjacentedges. This matrix is used to determine whether twoadjacent edges can be used to form a face.

When a new potential face is formed, we need to updatethe edge adjacency matrix, changing element Mij from 1to 0 to indicate that adjacent edges i and j that border theface have been used. Note that when two collinear edges aand b belong to a face, elements Mab and Mba still remain1, indicating that a and b can still be used to form otherfaces, as stated in Property 3.

Another useful matrix, the edge-edge intersection matrix,K, is used to ease the identification of tentative faces. Asmentioned earlier, we define a tentative face as a loop withno intersecting edges or internal chords. In the intersectionmatrix, Kij 1 denotes that edges i and j intersect eachother, whereas Kij 0 denotes no intersection.

Equations (1)-(4) are adopted from [6] to calculate theupper bound of edge rank Re and vertex rank Rvof a line drawing:

Rv dv dv 1=2; 1

Re mindv1; dv2 1; 2

Rv X

Reh i

=2; 3

where the sum is over all edges e meeting at vertex v,

Re minRv1; Rv2; 4where v1 and v2 are the two endpoints of edge e.


Fig. 6. Traversal of vertices and edges from edge NO.Fig. 5. Traversal of vertices and edges from edge EF.

Equations (1) and (2) are used to compute the pre-liminary estimation of the upper bound of edge and vertexranks, while (3) and (4) are then applied iteratively until theranks of all the edges and vertices comply with the upperbound rank equations. The results obtained from all fourequations should be integers. In the case where (3) producesa noninteger value, the result is rounded down. Fig. 7ashows an example of the upper bound rank computation ona nonmanifold object.

When two edges meeting at a vertex are collinear, two ormore adjacent faces can share the same collinear edges. Achain of collinear edges may be formed, spanning overseveral vertices, as shown by the chain AB C D inFig. 7b. In this situation, (5) is used to replace (2) in findingthe upper bound rank [6], where vL denote all the verticesalong the collinear edges on the left of e, including its leftendpoint, while nL denote the number of these vL vertices.This similarly applies to the right; vR denote the verticesalong the collinear edges on the right of e, including its rightendpoint, and nR denote the number of these vR vertices. InFig. 7b, the degree of each vertex A;B;C, and D is three. Tocompute the upper bound rank for edge BC, we locateverticesA andB on the left of edge BC, and vertices C andDon the right. On the left side, nL is two, and the sum of thevertices degree, dA dB, is six. The same applies to theright side. Substituting these values into (5), we obtain theupper bound rank of edge BC, which is three:

Re minhX

dvL 2nL;X

dvR 2nRi 1: 5

In our algorithm, we utilize the upper bound rankequation to determine the type of object in the drawing. IfRe 1 exists in a line drawing, the object has to be anonmanifold, and we assume it to be a simple nonmanifoldbecause we only deal with that. Otherwise, we consider theobject as a manifold. Admittedly, this may not be true; thiswill be discussed later.

6.2 The Algorithm to Search for Triangular andQuadrilateral Loops

As mentioned previously, our algorithm starts by findingall the triangular and quadrilateral loops in the linedrawing. We adopt the method of Varley and Company[3] to find these loops. Triangular loops can be found bychecking each edge AB with their adjacent vertices. If avertex C which connects to both vertices A and B exists,

then it forms a potential face with cycle ABCA. To search forquadrilateral loops, we go through each pair of nonadjacentedges in the line drawing. For example, we have twononadjacent edges DE and FG. If both edges DF and EG orboth edges DG and EF exist and do not intersect each other,we store the cycle as a potential face after verifying itscoexistence with other potential faces.

The next step is to identify the edges in the graph whichcan be used to form multi-edge faces. Recall that multi-edge means more than four edges in our context. For inputto the algorithm, we look for edges that have not been fullyused yet. If all the edges have been fully used, it means thatthe drawing has triangular or quadrilateral loops only, andwe can move straight on to the validation processpresented in Section 7.

6.3 The Algorithm to Search for Multi-Edge Loops

The face finding algorithm for multi-edge loops uses theshortest path approach, as our main intention is to find allthe possible short paths that can form a loop from a startingedge. Both breadth-first search and depth-first search areuseful techniques in path finding problems in graphtraversal [15], [16]. BFS starts by exploring all the nodeswhich are one level down the root node. It expands thepaths from all the nodes in the current level to the next leveluntil the goal is reached or when all the nodes have beenexplored. In contrast, DFS starts from the root node andexplores each branch as far as possible until it reaches thegoal or hits a leaf node. If it hits a leaf node, the searchcontinues at the next branch that has not been explored.

The BFS method is fast in searching for the shortest path,involving a small number of tree levels. However, itrequires extra storage for the child nodes at each level.DFS traverses deep into each branch to find a solution,which is not guaranteed to be the shortest one. BFS thusoutperforms DFS in meeting our objective, and is adoptedin our algorithm. Yet, if we are given a dense graph or anobject with large faces loops, we have to build a wide anddeep BFS tree to search for the shortest path. More storagewill be required for the increasing number of leaf nodes ineach level. To resolve this problem, we propose a doublebreadth-first search (DBFS) approach to distribute the leafnodes into two trees so that the depth and breadth of a treecan be reduced to half of the original size. The DBFSalgorithm is stated in Algorithm 1.

Algorithm 1. Double breadth-first search.

1. Initialize the parents of each edge to 1, and its colorto white.

2. Store each endpoint of input edge (e) as root node

of Left and Right Trees.

3. Set color of e to gray.

4. While there are still vertices available on both tress

5. While there are still vertices available on the Left Tree

6. For each edge adjacent to vertices of the current

front

7. If the edge is not visited by the Right Tree andis not colored black

8. Store its end vertex in the new front of

Left Tree.

9. Color the edge gray and color its parent

edge black.


Fig. 7. Computation of the upper bound of vertex and edge rank.(a) Object with faces sharing noncollinear edges, (b) object with facessharing collinear edges (bold underlined figures denote Rv, figures innormal font denote Re) [6].

10. End while.

11. If new front has common vertices with Right Tree

12. Check and form potential faces.13. Update each front against Property 3.

14. While there are still vertices available on the Right

Tree

15. For each edge adjacent to vertices of the current

front

16. If the edge is not visited by the Left Tree and

is not colored black

17. Store its end vertex in the new frontof Right Tree.

18. Color the edge gray and color its parent

edge black.

19. End while.

20. If new front has common vertices with Left Tree

21. Check and form potential faces.

22. Update each front against Property 3.

23. End while.

The input to Algorithm 1 is an edge with which we wishto form loops. We label the two BFS trees as Left and RightTrees. The end vertices of the input edge are storedseparately as the root nodes of the two trees. From a vertexon the tree, we proceed to find its neighboring vertices;these new vertices form the leaf nodes and are stored in anew level in front of the current level. The new fronts for theLeft and Right Trees are formed alternately. Whenever a newfront is formed, we check it against the front of the othertree for common vertices. If a common vertex is found, weform a loop and check whether it forms a tentative face thatcan coexist with other potential faces. If it does, a potentialface is found and we update the used edges in the edgeadjacency matrix. Then, we check the paths formed by theremaining vertices at each front against Property 3. If thepath violates Property 3, the vertex will be removed fromthe front. The traversals for both trees stop when there areno more vertices available on either front.

The algorithm traces the progress of the edges by coloringthem white, gray, or black. Initially, all the edges are coloredwhite to indicate unexplored edges. A visited edge iscolored gray, while a fully explored edge is colored black.

6.4 Multiple Valid Interpretations (Loop Ambiguity)

One of the problems working with wireframe models is loopambiguity. There may be multiple legitimate interpretations

of the same wireframe. They may represent different objectsor different orientations of the same object [17]. In the formersituation, we can select the most plausible solution based ongeometric information. In the latter, there is only one validface set where the ambiguity is caused by the differentviewing orientations. This ambiguity does not affect our facefinding process and is not considered here.

Fig. 8a shows an example with loop ambiguity, and thetwo valid interpretations of this object are shown in Figs. 8band 8c. In our algorithm,we start to search for themulti-edgeloops of Fig. 8a after obtaining all the quadrilateral potentialfaces. Assume edge AG is selected as the input; its edge andvertex traversal is illustrated in Fig. 9. At the end of thetraversal, there are four different paths thatmeet at vertexM,fromwhichwe can obtain four tentative faces:ABOLMEFGA,ABOLMQHGA, ADNLMEFGA, and ADNLMQHGA. Fromthese faces, we categorize them into two possible interpreta-tions, each consisting of adjacent faces sharing the samevirtual chord GM. Then, we check this chord againstProperty 4, whether it is enclosed by the two tentative facesof the same face set. Since both face sets satisfy Property 4,both interpretations are valid.

After getting two valid sets of faces in Fig. 8b and 8c, weneed to determine which the desired solution is. This isdone geometrically by calculating the parallelism value, asparallel features are often more desired. This parallelismvalue is the dot product of each pair of edges in thetentative face. By summing the parallelism values of allthe pairs in the tentative face and dividing the sum by thenumber of pairs, we get the average. The choice withthe highest average is the most desired solution. In this case,the chosen solution is Fig. 8c, with faces ABOLMQHGA andADNLMEFGA. However, the two blocks may not be sonicely oriented that there is an obvious preferred solution.In this case, our system could display the alternativesolutions and let the user select the preferred one.

7 THE VALIDATION PROCESS

Once all the potential faces have been identified, the nextstep is to verify whether they form the correct face set of avalid 3D interpretation. In this section, we explain thevalidation process and also the rectification if a solutionfails the validation. The validation processes for manifoldand simple nonmanifold objects are slightly different.

7.1 Simple Nonmanifold Objects

For simple nonmanifold objects, we need to verify that theactual rank of every edge complies with its upper bound


Fig. 8. (a) An example with loop ambiguity. Two different sets offaces (b) and (c) are valid solutions, but (c) is selected as a morereasonable solution.

Fig. 9. Traversal of vertices and edges from edge AG.

rank, but with no rank zero. For instance, Fig. 10a shows adrawing with the upper bound rank of each edge, whileFigs. 10b and 10c show two possible sets of faces that satisfythe upper bound rank [6].

It is possible that our system finds a set of faces thatsatisfies the validation requirements, but it is not thedesired face set. This is because very often nonmanifoldssolutions are nonunique, and there is nothing in the graphstructure of the drawing that sets one solution apart fromthe other. Thus, we only present the first solution thatsatisfies the validation requirements. The solution mayvary for line drawings of the same figure, but withdifferent input sequences.

When the validation checks are satisfied, we canconclude that all the potential faces found form a valid faceset of a nonmanifold. If edges with rank zero exist, we rerunthe algorithm in the next stage (see Section 7.7) with theseedges as input and search for new tentative faces. Then, wecheck the tentative faces against the potential faces usingProperties 3 and 4 to find a set that satisfies the validationrequirements. The number of stages required to obtain thecorrect faces is dependent on the topology of the object.However, we do set a limit for the maximum run of thealgorithm, which will be discussed further in Section 7.7.

7.2 Manifold Objects

The validation for a manifold object checks two rules:

1. The rank of each edge must be two (Property 5).2. The Euler-Poincare equation must be satisfied.

The Euler-Poincare equation [14] is given as

V E F 2S G 0; 6where V is the number of vertices, E the number of edges,F the number of faces, G the genus, denoting the number ofthrough holes in an object, and S the number of shells. Thenumber of shells is determined by the number of disjointgraphs in the line drawing, and the minimum value of S isone. Fig. 11a shows an object with a through hole, and thus

its G is one. In Fig. 11b, due to the lack of informationindicating that the two bottom faces are on the same plane,we do not consider the inner block as a through hole, andthus G is 0. As yet, we cannot automatically determine if athrough hole exists in a line drawing. Hence, we require theuser to specify the number of holes, with the default valueset at 0.

For a manifold object which satisfies all the validationcriteria, we conclude that the list of potential faces formsthe correct faces of the object. Otherwise, if the potentialfaces fail any of the validation requirements, it means thatsome of the faces are wrong or it may contain internal faces.We now explain the identification of the failure cases withtheir rectification.

7.3 Internal Faces

Liu et al. [18] observed that internal faces are formed byattaching two or more objects together, at two real faces R1and R2 on the same surface. They classified internal facesinto two types: 1) no edge sharing and 2) partial or completesharing of the edges of R1 and R2.

In this paper, we explicitly deal with internal faces ofType 2 only. For Type 1, where the loops are disconnected,R1 and R2 will be returned as separate real faces. Onlywhen extra information is available, probably from the user,saying that the two loops lie on the same plane could wereturn them as loops of the same face. The methods toidentify and filter out internal faces differ depending onthree contact cases:

1. R1 and R2 share only one edge.2. R1 and R2 share more than one but not all

noncollinear edges.3. R1 and R2 share all the edges.

All three cases have overlapping regions in the linedrawing. Fig. 12 presents four internal faces; Fa belongs toType 1, and Fb, Fc, and Fd belong to Type 2 faces.

7.3.1 Two Real Faces Sharing One Common Edge

Face Fb in Fig. 13a illustrates an example of an internal faceformed by attaching two real faces F1 and F2 together, withcontact at one common edge EF. Note that this figure istopologically nonmanifold, as faces F1 and F2 share onlyone edge. However, if F1 and F2 are on the same plane, thenthey form a manifold geometrically. In this paper, we treatthe object as a manifold.

We observe that the rank of edge EF is four, while therest of the edges in the line drawing have rank two. Edge EFis shared by four faces, two of which form an internal faceas mentioned above, while the remaining two are real faces


Fig. 11. (a) A through hole (G 1), and (b) no through holes (G 0).

Fig. 12. Four internal faces.Fig. 10. (a) Maximum rank for each edge, (b) a box with front opening,and (c) a box with bottom opening [6].

(F3 and F4). Once we have identified the set of faces whichshare a common edge with rank greater than three, weseparate them from the list of potential faces and proceed tofilter out the internal face.

The process starts with creating pairs of faces from theidentified face set and checking for pairs with overlappingarea. In this example, we have three overlapping face pairs:F1-F2, F1-F3, and F2-F3. Next, we generate a tentative facefrom the pair of faces by subtracting the overlapping region.Pair F1-F2 generates face AFGHEDCBA, while subtractionof pair F1-F3 creates face AFIJEDCBA. Pair F2-F3 isdiscarded due to an intersecting edge in the face.

After this, we check the coexistence of these newtentative faces with the remaining potential faces, usingProperties 3 and 4. If a new face set is found compliant withall the properties and the validation requirements, weconclude that the set is correct. In the current case, tentativefaces F1-F2 and F1-F3 can each form a different face set thatpasses the validation.

In most cases, we will get only one set of potential facesthat satisfies the validation. In cases where loop ambiguityexists (current case), we select the tentative faces with thehighest average parallelism value as the solution, shown inFig. 13b, where the triangular prism lies on top of the block.Fig. 13c shows the triangular prism as a depression in theblock. Both interpretations are valid and either one of themcan be accepted as the final result.

7.3.2 Two Real Faces Sharing More than

One Noncollinear Edge

When there exist two faces lying on the same plane andsharing more than one noncollinear edge (faces F1 and F2share edges AB and AF in Fig. 14), our system initially findsthe smaller face, F2, as the potential face and discards thelarger face F1. This is because of the preference for smaller

faces as potential faces, which then prevent the forming ofsome larger faces due to violation of Property 3. Since edgesAB, BG, GF, and FA, are not collinear and already enclosinga potential face F2, we update the edge adjacency matrixaccordingly to indicate the adjacent edges that have beenused. Later, when we proceeded to the multi-edge facefinding process (Algorithm 1), cycle F1 could not be formedsince edges AB and AF have been used by F2. After runningthe algorithm, the remaining edges that cannot form a cycleinclude edges BC, CD, DE, and EF. Hence the ranks ofthese four edges remain at one, and the solution fails thevalidation. These edges will serve as the input in the nextstage of the algorithm (Section 7.7) to search for moretentative faces.

7.3.3 Two Real Faces Sharing All the Edges

In the situation where two faces share all their edges, eachedge will have a rank greater than two. For example, theedges AE, EH, HD, and DA of Face Fd in Fig. 15 are allshared by three different faces. The face AEHDA is hence aninternal face, and is therefore removed from the set ofpotential faces, leaving the rest, which form the real faces.This situation is easier to resolve than the previous ones aswe do not need to find the subtraction of two overlappingfaces or to search for other possible loops.

7.4 Wrong Potential Faces

Although the smallest loop that forms a potential face islikely to be a real face, there is the potential that it may notbe, especially at the early stage of a run. For example inFig. 16, two wrong quadrilateral faces, Q1 (DEFMD) and Q2(JKLNJ), are found in the initial stage and stored as potentialfaces. When executing the main algorithm, the correct face(ABCDEFGHIJKLA) could not be formed as its noncollinearedges (DE, EF, JK, KL) had been used by Q1 and Q2.

The approach that we use to resolve wrong potentialfaces is the same as in Section 7.3.2, where we rerun a fewstages of the main algorithm (Section 7.7) to search for moretentative faces. Then, we search for a set of potential facesthat pass the validation.


Fig. 14. Two faces contact at edges AB and AF. F1 ABCDEFA,F2 FC ABGFA.

Fig. 15. Two faces contact completely at edge AE, EH, HD, and DA.

Fig. 16. Two wrong potential faces found Q1 (DEFMD) and Q2 (JKLNJ).

Fig. 13. (a) Four faces sharing a common edge EF:F1 ABCDEFA,F2 Fb EFGHE, F3 EFIJE, F4 AFEDKLA, (b) thetriangular prism lies on top of the block, and (c) the triangular prismdepresses in the block.

7.5 Manifolds with No Trihedral Vertex

For manifolds with no trihedral vertex, there are some caseswhere, after obtaining all the potential faces, the rank ofevery edge is greater than two. This means that everypotential face may be an internal face, and so we cannotapply the method discussed in Section 7.3.3 to filter out theinternal faces. Fig. 17 shows an example with no trihedralvertex, and the rank of every edge is three.

To resolve this problem, we first arrange the potentialfaces found in descending order of the number of edges inthe loops. Initially, we discard the first face from theordered list, which reduces the rank of its bounding edgesto two. Then, we perform a linear search of all theremaining faces for the ones that have all their edges stillranked three, and discard them too. If the remaining facespass the validation, then a correct solution is found.Otherwise, we restore the ordered list of potential facesand proceed to discard the second face from the list, andrepeat the process. The process will terminate when acorrect face set is found or when all the potential faces in thelist have been gone through. The potential faces in the listare arranged in descending order so that larger faces areremoved first, as we presume that smaller faces are morelikely to be the correct ones.

For example, from the list of ordered potential faces inTable 1, we first assume Face 1 is an internal face that has tobe removed. Then we check the remaining list for otherinternal faces. Face 2 is since all its edges have rank three,and it is removed as well. Faces 3 and 4 remain as potentialfaces, while Faces 5 and 6 are removed. The rest of the faces(Faces 7-16) remain in the list. After that, we check whetherthe remaining face set passes the validation. It does andtherefore we conclude that this is the correct face set, with12 real faces and 4 internal faces.

Ifwe cannot obtain any correct face set after going throughall the potential faces in descending order, it is possible thatthe internal faces are the smaller ones. Therefore, werearrange the list in the reverse order (ascending fromsmaller to larger loops), and repeat the process.

A triangular torus as shown in Fig. 18a is another objectwith no trihedral vertex. The potential faces obtained by the

algorithm are six triangular and nine quadrilateral faces,and the rank of every edge is three. After going through thechecking process using a descending order list, we are stillunable to get a correct face set. By reversing the order of thefaces in the list, we now start the removal process from thesmallest face. Since all the triangular faces in the torusare internal faces (see Fig. 18b), we can now obtain thecorrect face set with 9 real faces and 6 internal faces. The 3Drepresentation of the torus is shown in Fig. 18c.

It is also possible that different interpretations can beobtained from a single line drawing. For instance, thedrawing of Fig. 19a gives rise to three possible face sets(see Fig. 19b). The algorithmwould find one of these sets anda different set may be found with a different input sequence.

The search in this algorithm is systematic but notexhaustive, and thus does not guarantee a correct solutionin every case. However, we do not have a case where it fails.The worst case time complexity of this search isOp2, wherep denotes the number of potential faces already found.

7.6 Manifolds That Fail the Euler-Poincare Equation

When a manifold object satisfies the edge rank validationbut fails the Euler-Poincare equation, we do not have theedges to initiate the rerun of the algorithm since all the edgesare ranked two. For instance, Fig. 20a shows a manifold with36 vertices, 56 edges, and 22 faces, 1 shell and 1 through hole.The faces found do not satisfy the Euler-Poincare equationdue to four wrong faces, as highlighted.

In the example, we observe that these wrong facesshare four vertices with degree more than three. Therefore,we separate the faces into two different sets: 1) faces with


TABLE 1List of Potential Faces for Fig. 17

Fig. 18. (a) Line drawing of a triangular torus [3]. (b) Six triangularinternal faces. (c) 3D interpretation.

Fig. 19. Manifold object with multiple valid interpretations [5].

Fig. 20. Different face sets with all their edges ranked two.

Fig. 17. A sample object with no trihedral vertex.

all the vertices of degree three, and 2) faces with verticesof degree more than three. Set 1 faces are retained aspotential faces, while Set 2 faces are possibly the wrongones. Then, we arrange the faces in Set 2 in ascendingorder of smaller loops to larger ones. We eliminate thefirst face in Set 2 and use its edges as the input to rerunthe main algorithm in an exhaustive search (Stage 2 inSection 7.7) to obtain more tentative faces. From the lists oftentative faces and the retained potential faces, we searchfor a face set that passes the validation. If a correct setcannot be found, we continue to eliminate the second facein Set 2 and repeat the process until a correct solution isfound or all the faces in Set 2 are removed.

For instance, the wrong faces in Fig. 20a are formed bytwo quadrilateral loops and two larger loops. Thesepossibly wrong loops are arranged in ascending order sothat the smallest faces will be eliminated first. This willreduce the input edges when rerunning the algorithm andspeed up the wrong face removal process.

Fig. 20b shows the two correct faces found after theremedy initiated by removing one of the wrong quad-rilateral faces in Set 2. This new set passes the validation. Itis also possible that all the wrong faces are formed bylarger loops in Set 2. In this case, the algorithm would stillproceed in the same way, but will take more time to arriveat the solution.

7.7 Stages of the Algorithm

In the case where we need to rerun the algorithm to findmore tentative faces, we might need to go through differentstages in the algorithm before the correct face set is found.For each stage, we set different constraints in the traversalof the vertices in the DBFS trees to obtain a different list oftentative faces. We will start from the first run of thealgorithm, which we call Stage 0, followed by thesubsequent stages when a validation fails. There are fivepossible stages, executed in sequence, except when a resultfails the Euler-Poincare equation.

In Stage 0, a tentative face found is checked against otherpotential faces for coexistence. Once a potential face isformed, we update the edge adjacency matrix to identify thenoncollinear edges that have been used. At the end of thestage, we would obtain a set of potential faces forvalidation. If the validation fails, we save the correctpotential faces and discard the wrong ones. The rank ofedges bordering the wrong faces will be reduced and areused as input to run the DBFS algorithm in Stage 1. ForStages 1 to 4, tentative faces found are stored in a list insteadof forming into potential faces. At the end of the stage, wewould obtain a list of tentative faces with the saved correctpotential faces. Then, we perform a systematic search to

find a subset of the tentative faces that can coexist with thepotential faces and passes the validation. The complexity ofthis search is Ot t p, where t denotes the number oftentative faces and p the number of potential faces. If noneof the face set satisfies the validation requirements, wemove forward to the next stage using the same input (edgesfrom the wrong potential faces). If the algorithm still cannotobtain a correct face set after Stage 4, it means no correctface set can be found and a message is issued accordingly.This may be due to improper drawings or nonmanifoldobjects which are not identified as such.

We use Fig. 21 for illustration and Table 2 to show thetraversal trees in each of these stages. In this figure, onequadrilateral face is found in the initial stage, which isABCDA. The four edges in this quadrilateral are thereforeranked 1, while the rest are ranked 0. One of these, sayedge DG, is picked as the input of the DBFS algorithm.

. Stage 0: This is the first run of the algorithm; treetraversal stops at edges that have been visited by theother tree.

In the example, the traversal stops when bothfronts meet at vertices H and K, forming twopotential faces DAHIGD and DAJKEFGD.

. Stage 1: Before rerunning the algorithm, discard allthe multi-edge potential faces found in the previousstage and retain only the triangular and quadrilat-eral potential faces. Then, reset the edge adjacency


Fig. 21. Example of some face loops in a manifold. The correct faces areshaded, while the quadrilateral loop ABCDA is an internal face.

TABLE 2Example of DBFS Traversal for Fig. 21

matrix accordingly. In this stage, the tree traversalstops when the edges have been fully explored.

In Table 2, vertex K on the front of Left Treecontinues its traversal to vertex E as edge EK has notbeen fully explored.

. Stage 2: The triangular and quadrilateral potentialfaces are retained as in Stage 1. The graph goesthrough a full exploration where the traversal ofeach front only stops if the path forms a self-intersecting cycle or encloses a chord.

In the example, vertex K on the Right Treetraverses to vertex J and stops. Both fronts cannotcontinue further as they will form internal chords intheir path.

. Stage 3: Discard all the potential faces and start withthe initial edge adjacency matrix. Tree traversalstops when edges have been fully explored.

. Stage 4: All the potential faces are discarded as inStage 3. The graph goes through an exhaustivesearch, but stops when the path forms a self-intersecting cycle or encloses a chord.

For most objects, the face finding is straightforward; we canobtain the correct face set in Stage 0 (82.6 percent of the morethan 200 test cases that we have) or in Stage 1 (12.5 percent).But for some, where the smallest faces (triangular andquadrilateral faces) found are the wrong ones, such asshown in Figs. 14 and 16, Stage 3 is required (3.5 percent). Sofar, all drawings with valid solutions are solved withinStage 3. Stage 4 has been utilized only for drawings with novalid solutions, as we need to do an exhaustive search toestablish that fact. The number of stages used dependson the topology of the drawings and the type of wrongfaces found.

Normally, the stages are executed in sequence, exceptwhen the result fails the Euler-Poincare equation, when itwould proceed from the current stage to Stage 2 directly. Inthis exceptional situation, potential faces whose vertices areall of degree three are retained, as opposed to the normalsituation where the triangular and quadrilateral faces areretained. This type of object constitutes 1.4 percent of thosewe have tested. The percentages given here provide agauge to the number of stages required and how efficientlythe algorithm can perform in general.

7.8 Sufficiency of the Validation for ManifoldObjects

The question remains whether the two rules in ourvalidation for manifold objects, i.e., that every edge mustbe ranked two and the object must satisfy the Euler-Poincare equation, are sufficient to establish that the facesfound are the correct faces of a valid 3D interpretation.

We do not have a theoretical proof to establish theanswer with full confidence as yet. What we have found isthat, in all our hundreds of test cases, the face set is correctonce the criteria are satisfied. We do not know of anysituation where the validation passes a wrong result.

We know of only one situation when a face set remainsinvalid after satisfying the two validation rules. But thissituation, first illustrated in Fig. 2, violates Property 4 and isremoved in the process of finding the potential faces and istherefore not an issue for validation. Fig. 22a shows another

example. The two incorrect loops, marked by thick edges,form a face set with the other loops which are correct. Therank of every edge in this set is two, and the set satisfies theEuler-Poincare equation. The two vertices marked by whitedots exist explicitly and are two nonadjacent vertices sharedby the two wrong loops. The virtual chord joining these twovertices lie inside both loops, and therefore violatesProperty 4. Hence, both loops cannot exist as potentialfaces and are removed. The correct edge loops are shown inFig. 22b.

This may be seen as another case of internal face, dealtwith in Section 7.3. However, it is not included as aninternal face by Liu et al. [18] and requires a differenttreatment; hence it is singled out here.

8 RESULTS

This section shows some results of our implementation.Most of the tests are taken from other papers, and wepresent comparisons of our test results with results ofprevious methods. We also show some tests of our own.Our system is implemented in C++ using Microsoft VisualStudio, running on a 2.66-GHz Core (TM) 2 Duo CPU.

Fig. 23 shows examples of manifold and nonmanifoldobjects. Those in Figs. 23a ,23b, 23c, 23d, 23e, 23f, 23g, 23h,23i, 23j, 23k, 23l, 23m, 23n, and 23o, are from Varley andCompany [3], while those in Figs. 23p, 23q, and 23r, comefrom Shpitalni and Lipson [6] and Liu and Tang [9].Figs. 23s, 23t, 23u, and 23v present four more interestingexamples of our own. The quantitative results for thesedrawings are shown in Table 3, with additional columnsshowing the number of stages required and the runningtime to process the same drawing as in [3]. We have notimplemented Varley and Companys algorithm [3] for thispaper. Thus, the times in Table 3 only provide a notion ofthe running time relative to the increasing number of edgesand the drawing complexity, not a direct comparison.

We can obtain all the correct faces for the figures inTable 3 within 1 s of processing time, including detection ofinternal faces and obtaining alternative solutions. Besidesthe drawings shown here, we have also tested all 68 casespresented in [3]. Our algorithm returns all the resultscorrectly, whereas the algorithm in [3] fails in two of thecases (Figs. 23j and 23k). Examining the results in Table 3,Varley and Companys method seems to work faster forobjects with a lower number of edges (see Figs. 23a, 23b,23c, 23d, 23e, 23f, 23g, 23h, and 23i). However, the rate ofincrease in the processing time is higher with an increasingnumber of edges, as can be seen from Figs. 23l, 23m, and23n The running time of our algorithm varies when thenumber of edges increases, but is related to the complexityof the drawing or the types of wrong faces found. Forinstance, although Fig. 23f has a low number of edges, the


Fig. 22. Objects with two face loops sharing two nonadjacent vertices.

smaller faces found are the wrong ones and it needs to runStages 0 to 3 before returning the correct face set. Fig. 23o isnot compared here as the input drawings are different forthe two systems. Our input has 207 edges with 306 ms ofprocessing time, while the input size of [3] is 251 edges with1087.1 ms. Figs. 23p, 23q, and 23r are not dealt with in [3].

Fig. 23s is an example of a drawing with no trihedralvertex and, because it is built with triangular faces only, theprocessing time is extremely short. The interesting feature inFig. 23t is its nonplanar internal face, but also of interest is itsvery high processing time as compared to the others. Here,the initial result fails the Euler-Poincare equation and thesystem needs to eliminate the possibly wrong potential faceswith vertices of higher degree. Note that Fig. 23t does not gothrough Stage 1 but jumps directly to the exhaustive searchat Stage 2. In this example, Stage 2 runs five iterations,eliminating five smallest faces before obtaining the correctface set. Fig. 23u has a vertex connecting two internal faces;the object is topologically nonmanifold but geometricallymanifold, while Fig. 23v, mentioned in Section 7.8, has aquadrilateral internal face with no shared edges.

8.1 Time Complexity Analysis

A number of algorithms are executed consecutively in theface finding. Most of these algorithms, including setting up

the edge adjacency matrix and finding the triangular andquadrilateral faces, have On2 complexity, where n denotesthe number of edges.

The algorithm that dominates the complexity is thetraversal of the DBFS trees with comparisons of the verticesin their respective fronts. In Stage 0, although an edge ismostly visited once in the DBFS trees, occasionally it can bevisited multiple times. This number of times is bounded byD, one less than the maximum degree of the vertices(max dv 1), which is a constant for a given drawing.The worst-case complexity of the tree traversal is thereforeODn. The number of vertices visited is the same as thenumber of edges visited by both trees. Hence, the worst-case complexity to check for common vertices at both frontsis OD2n2. If the same tree traversal has to be performedfor every edge in the drawing, the complexity becomesOnDnD2n2. Overall, the worst-case complexity ispolynomial, which is On3.

In Stages 1 and 3, the tree traversal stops at edges thathave been fully explored; this means that all its adjacentedges have been visited. The number of adjacent edges isdetermined by the degree of the two end vertices. Similarlyto Stage 0, we can set the upper bound on the number ofvisits to an edge as D. So the worst-case complexity is stillthe same, which is On3.

For the exhaustive search in Stages 2 and 4, an edge canbe visited many times, but it can only appear at most oncein each branch. In the worst case, all the edges appear inevery branch, giving the complexity of ODn. If themaximum vertex degree in a drawing is three, a binarytree can be formed and the worst-case complexity is O2n.The complexity of comparing the vertices at both frontswould be OD2n. The overall worst-case complexitywould be exponential, which is OnD2n. As edges canbe tied up in triangular and quadrilateral loops and henceare not available in the exhaustive search, the effectivevalue of n in the complexity in Stage 2 can be a lot smallerthan in Stage 4.


TABLE 3Results for Fig. 23

Fig. 23. (a)-(o) Fifteen manifold objects [3], (p)-(r) three nonmanifoldobjects [6], [9], and (s)-(v) some interesting examples of manifold objects.

The time complexity of the rectification processes is alsotaken into account if the set of potential faces found failsthe validation check. In most of the rectification processes,we discard the wrong potential faces and use their edgesto rerun the DBFS algorithm in different stages asmentioned in Section 7.7. Since we have retained most ofthe correct potential faces and the searching algorithmonly needs to find a small subset of faces, the timecomplexity is much lower than an exhaustive search.However, for the worst-case analysis, we assume that allthe potential faces found are wrong (we have notencountered this case) and the exhaustive search in theDBFS algorithm generates Dn tentative faces. The complex-ity of the search thus becomes OD2n.

In reality, the DBFS trees and their fronts are a lot smaller

than the worst case, so the practical complexity is a lot

better, rendering the theoretical analysis not meaningful.

We therefore present an analysis of the actual timings from

our comprehensive tests.The actual computation time is determined through

experiments using three sets of figures with linearly

increasing number of edges. Figs. 24, 25, and 26 are

reference drawings as presented by Liu and Tang [9] and

Varley and Company [3].

The face finding time for the individual drawings in

Figs. 24, 25, and 26, (stairs, buildings, and desks) are shown

in Table 4. Since there are no internal faces or wrong faces

found in Figs. 24 and 26, these figures only need to go

through the algorithm once. The execution time for simple

drawings like stairs can be short (~16 milliseconds for

100 edges). A simple drawing is a drawing with no loop

ambiguity or internal faces. Besides, all the smallest faces

formed in a simple drawing are usually the correct ones.On the other hand, the buildings in Fig. 25 have smaller

faces that are not real faces and fail the validation. They

need to go through the Stage 1 algorithm before arriving at

the correct face set. Table 4 shows that it requires a longer

execution time (~120 milliseconds for 100 edges).A chart is plotted using the data in Table 4 to show the

correlation between the processing time and the number of

edges (see Fig. 27). We observe that the computation time

increases linearly in practice as straight lines can be fitted to

all three sets of data.


Fig. 25. Buildings.

Fig. 26. Desks.

TABLE 4Results for Stairs, Buildings, and Desks

(See Figs. 24, 25, and 26)

Fig. 24. Stairs.

Also, we note that when the number of edges increasesin a set of figures, the increase in the processing time in ouralgorithm is much lower than in [3]. In these examples, bothsystems get the correct results within one second ofprocessing time. But the difference would become signifi-cant when we deal with a much larger input size.

8.2 Comparisons with Existing Methods

A number of face finding algorithms have been reported inthe literature. The methods of Shpitalni and Lipson [6], Liuand Lee [7], Liu and Tang [9] potentially require anexhaustive search of all the potential loops of edges thatexist in a drawing, resulting in an exponential complexity.Liu and Lees method slows down badly once the numberof faces exceeds 30. The method closest to our presentmethod is that of Varley and Companys [3], and we offer aclose comparison here.

The shortest path approach used in our work is a conceptshared with the method of Varley and Company [3]. Wework on a few faces simultaneously, and take the first loopthat is found (which is more likely a small loop) as correct.Varley and Company assemble half-edges into strings andmerge two strings to form a face if the last vertex in one isthe first vertex in the other. However, in our method we usetwo trees to traverse the vertices to form paths. The twotrees are initiated from the two endpoints of an edge; if thesame vertex appears in the front of both trees, a potentialface may be formed.

In the preprocessing in [3], triangular loops andquadrilateral loops generate a priority value for each string.In our method, we consider triangular and quadrilateralloops found in the initial stage as potential faces beforeworking on loops with higher number of edges. Triangularand quadrilateral loops in a line drawing are more likely toform real faces. Thus, when we proceed to find themultiedge loops, there will be fewer alternatives and alesser chance of getting the wrong ones. It is an efficientmethod for finding the correct faces of simple line drawings(where the smaller faces found are the correct ones).

In our algorithm to search for multi-edge loops, we startfrom a selected edge and search for the possible loopssharing it. The loops found are checked before storing aspotential faces. Varley and Company initiate their algorithmby merging strings at a trihedral vertex. It is only attrihedral junctions that they can be sure that the concate-nated string is part of a true face rather than an internal

face. However, this starting condition is not possible forobjects with no trihedral vertex.

Referring to the results and timings in Table 3, the timesto obtain the correct faces for simple drawings are lowercompared to the more complex ones, which includedrawings with multiple solutions, objects with internalfaces, or with smaller faces that are incorrect. For instance,Fig. 23f has the highest processing time among the othersdue to two wrong quadrilateral faces. The algorithm needsto run up to Stage 3 to obtain the correct solution. If thedrawing contains only triangular and quadrilateral faces(see Figs. 23a and 23s), the processing time can be very short.

After executing the main algorithm, a postprocessverifies whether all the potential faces found form thecorrect face set of a valid interpretation by checking theedge ranks and, in the case of manifolds, the Euler-Poincareequation. If wrong faces are found, they are replaced byalternatives until correct ones are found. If internal facesexist, they will be identified and deleted. The validationrequires time, but it is very efficient and it ensures, withhigh confidence, that the final results are correct. There is novalidation in [3].

The system of Varley and Company deals with manifoldobjects only. Ours deals with both manifold and simplenonmanifold objects, which is also true for the systemsreported in [6], [7], and [9]. Our system obtains the sameresults as Shpitalni and Lipson [6] and Liu and Tang [9] fornonmanifold objects, but is superior in terms of computa-tion time.

The fundamental strength, which is a significant con-tribution of our work, is that our system checks if a result iscorrect and makes corrections if it is not. Also, we providealternative solutions if they exist. Other systems, as far aswe know, present only one solution and the user has todecide to take it or leave it.

9 CONCLUSION

Our approach of utilizing breadth first search in findingpolygonal faces is fast and reliable. We can obtain thecorrect results for manifolds and nonmanifolds with200 edges within one second of processing time and, atthe same time, present valid alternative solutions if theyexist. When wrong faces (including internal faces) arefound, our validation processes can resolve them andproduce the correct ones. In all of our tests for bothmanifold and nonmanifold objects, a face set that passes thevalidation test is always correct.

The basic philosophy employed in this method is: Firstfind a set of potential faces, then validate. If the validationfails, then make some corrections. Because finding the facesand the subsequent validation and correction are generallyefficient, the total time taken for the whole process is a lotless than the time taken by an algorithm that guards againstwrong results every step of the way.

There are two aspects for futurework. To utilize the Euler-Poincare equation, we need to know the number of throughholes in an object. The user needs to input this number atpresent as we do not know how to identify holes in a linedrawing automatically. We need to resolve this problem.


Fig. 27. Correlation between time (ms) and number of edges for stairs,buildings, and desks.

For nonmanifold objects consisting of a combination oftwo or more simple manifolds or manifolds and nonmani-folds, we look to partitioning these drawings into simplemanifolds and simple nonmanifolds before the face findingprocess. This work is already well underway.

ACKNOWLEDGMENTS

The authors would like to thank Nanyang TechnologicalUniversity for grants that support the work in this project.They also thank the reviewers for their substantive andpenetrating comments which helped to improve the paper.

REFERENCES[1] J. Liu, Efficient Search of Faces from Complex Line Drawings,

technical report, Multimedia Lab, Dept. of Information Eng., TheChinese Univ. of Hong Kong, 2003.

[2] J. Liu, Y. Lee, and W.K. Cham, Identifying Faces in a 2D LineDrawing Representing a Manifold Object, IEEE Trans. PatternAnalysis and Machine Intelligence, vol. 24, no. 12, pp. 1579-1593,Dec. 2002.

[3] P.A.C. Varley and P. Company, A New Algorithm for FindingFaces in Wireframes, Computer-Aided Design, vol. 42, no. 4,pp. 279-309, Apr. 2010.

[4] G. Markowsky and M.A. Wesley, Fleshing Out Wire Frames,IBM J. Research and Development, vol. 24, no. 5, pp. 582-597, 1980.

[5] S.C. Argawal and W.N. Waggenspack Jr., DecompositionMethod for Extracting Face Topologies from Wireframe Models,Computer-Aided Design, vol. 24, no. 3, pp. 123-140, 1992.

[6] M. Shpitalni and H. Lipson, Identification of Faces in a 2DLine Drawing Projection of a Wireframe Object, IEEE Trans.Pattern Analysis and Machine Intelligence, vol. 18, no. 10,pp. 1000-1012, Oct. 1996.

[7] J. Liu and Y. Lee, A Graph-Based Method for Face Identificationfrom a Single 2D Line Drawing, IEEE Trans. Pattern Analysis andMachine Intelligence, vol. 23, no. 10, pp. 1106-1119, Oct. 2001.

[8] H. Lipson and M. Shpitalni, Optimization-Based Reconstructionof a 3D Object from a Single Freehand Line Drawing, Computer-Aided Design, vol. 28, no. 8, pp. 651-663, 1996.

[9] J. Liu and X. Tang, Evolutionary Search for Faces from LineDrawings, IEEE Trans. Pattern Analysis and Machine Intelligence,vol. 27, no. 6, pp. 861-872, June 2005.

[10] E.W. Dijkstra, A Note on Two Problems in Connexion withGraphs, Numerische Mathematik I, vol. 1, pp. 269-271, 1959.

[11] H. Li, Q. Wang, L. Zhao, Y. Chen, and L. Huang, nD ObjectRepresentation and Detection from Single 2D Line Drawing,Computer Algebra and Geometric Algebra with Applications, vol. 3519,pp. 363-382, 2005.

[12] Spatial Docs, http://doc.spatial.com/index.php/Manifold_and_Non-manifold_Objects, 2013.

[13] Y. Sun and Y. Lee, Topological Analysis of a Single Line Drawingfor 3D Shape Recovery, Proc. Second Intl Conf. Computer Graphicsand Interactive Techniques in Australasia and South East Asia, pp. 167-172, 2004.

[14] J.A. Heissermann, A Generalized Euler-Poincare, Carnegie-MellonUniv. Eng. Design Research Center, 1991.

[15] B. Coppin, Artificial Intelligence Illuminated. Jones and BartlettPublishers, Inc., 2004.

[16] J.A. Bondy and U.S.R. Murty, Graph Theory. Springer, 2008.[17] Inst. for Computer Based Learning, Heriot-Watt Univ., http://

homepages.inf.ed.ac.uk/rbf/CVonline/LOCAL_COPIES/MARBLE/high/solids/wire.htm, 2013.

[18] J. Liu, Y. Chen, and X. Tang, Decomposition of Complex LineDrawings with Hidden Lines for 3D Planar-Faced Manifold ObjectReconstruction, IEEE Trans. Pattern Analysis and Machine Intelli-gence, vol. 33, no. 1, pp. 3-15, Jan. 2011.

Mei Chee Leong received the BE degree(Hons) from the National University of Malay-sia in 2007, and the MSc degree fromNanyang Technological University in 2011.She worked as a process mechanical engineerafter her BE degree and is currently aresearch associate in the School of Mechan-ical and Aerospace Engineering, NanyangTechnological University. Her research inter-ests include 3D modeling, computer graphics,

computer animation, and simulation.

Yong Tsui Lee received the BSc degree fromthe University of Leeds in 1977, the MS degreefrom the University of Rochester in 1980, andthe PhD degree from the University of Leeds in1983. He worked as a CAD system developerin the United Kingdom after receiving the PhDdegree until 1991, when he joined NanyangTechnological University in Singapore, where heis now an associate professor. His currentresearch interests include geometric modeling,

reverse engineering, sketch input for CAD systems, and, generally, 3Ddata capture for design and manufacturing.

Fen Fang received the BE degree from theAnHui Science and Technology University,China, in 2006, and the ME degree fromNanyang Technological University, Singapore,in 2009. She is currently working toward thePhD degree in the School of Mechanical andAerospace Engineering, Nanyang Technologi-cal University, in the field of 3D object recoveryfrom 2D drawings.

. For more information on this or any other computing topic,please visit our Digital Library at www.computer.org/publications/dlib.


/ColorImageDict > /JPEG2000ColorACSImageDict > /JPEG2000ColorImageDict > /AntiAliasGrayImages false /CropGrayImages true /GrayImageMinResolution 36 /GrayImageMinResolutionPolicy /Warning /DownsampleGrayImages true /GrayImageDownsampleType /Bicubic /GrayImageResolution 300 /GrayImageDepth -1 /GrayImageMinDownsampleDepth 2 /GrayImageDownsampleThreshold 2.00333 /EncodeGrayImages true /GrayImageFilter /DCTEncode /AutoFilterGrayImages false /GrayImageAutoFilterStrategy /JPEG /GrayACSImageDict > /GrayImageDict > /JPEG2000GrayACSImageDict > /JPEG2000GrayImageDict > /AntiAliasMonoImages false /CropMonoImages true /MonoImageMinResolution 36 /MonoImageMinResolutionPolicy /Warning /DownsampleMonoImages true /MonoImageDownsampleType /Bicubic /MonoImageResolution 600 /MonoImageDepth -1 /MonoImageDownsampleThreshold 1.00167 /EncodeMonoImages true /MonoImageFilter /CCITTFaxEncode /MonoImageDict > /AllowPSXObjects false /CheckCompliance [ /None ] /PDFX1aCheck false /PDFX3Check false /PDFXCompliantPDFOnly false /PDFXNoTrimBoxError true /PDFXTrimBoxToMediaBoxOffset [ 0.00000 0.00000 0.00000 0.00000 ] /PDFXSetBleedBoxToMediaBox true /PDFXBleedBoxToTrimBoxOffset [ 0.00000 0.00000 0.00000 0.00000 ] /PDFXOutputIntentProfile (None) /PDFXOutputConditionIdentifier () /PDFXOutputCondition () /PDFXRegistryName (http://www.color.org) /PDFXTrapped /False

/CreateJDFFile false /Description >>> setdistillerparams> setpagedevice

06506083

Documents

Transcript of 06506083