Planar domain simplification for modeling virtual-solids in plant and machinery layout

COMPUTER-AIDED DESIGN Computer-Aided Design 31 (1999) 597–610 www.elsevier.com/locate/cad

Planar domain simplification for modeling virtual-solids in plant and machinery layout N.S. Sapidis*, G. Theodosiou Department of Naval Architecture and Marine Engineering, National Technical University of Athens, Ship-Design Laboratory/CAGD Group, 9 Heroon Polytechneiou Str., Zografou, Athens 157-73, Greece Received 10 October 1998; received in revised form 10 June 1999; accepted 14 June 1999

Abstract Complex mechanical systems involve functionality constraints implying empty volumes that must exist at specific locations. These may be modeled as “virtual-solids” using standard solid modeling techniques. This approach requires an efficient simplification algorithm for planar domains. Such an algorithm is proposed here, which is based on examining all possible sequences of edges that might be simplified. A property is established that limits the parts of the domain’s boundary the algorithm must consider. Examples are included that demonstrate the validity of this algorithm. Finally, a detailed analysis establishes the advantages of the new algorithm over published techniques from the fields of “automatic nesting of irregular parts” and “automatic finite-element meshing”. q 1999 Elsevier Science Ltd. All rights reserved. Keywords: Functionality constraints; Layout; Extrusions; Detail suppression; Polygonization; Nesting

1. Motivation: functionality constraints in geometric modeling and the introduction of “virtual-solids” The specific application area we are concerned with is “object layout” referring to modeling techniques and design methodologies for a highly complex scene with thousands of objects, like an industrial plant or a ship’s interior structure and engine-room [5,6,19,20]. The particular example that we have in mind, in this paper, is a ship’s engine-room. This seems to represent the worst-case situation, as it corresponds to a limited area, where a large number of objects (machinery, tanks, pipes, compartment-walls, etc.) must coexist in close proximity. Although computer-aided design/engineering (CAD/CAE) techniques for modeling each one of the above objects improve continuously, this is not true for the problem of object layout as “objects are usually laid out … with careful mouse manipulation, or by numerically specifying transformations … This is a timeconsuming and error-prone process” [19]. Existing works (see references above) have focused only on the geometric consistency of a layout, which relates to collision-avoidance and positional constraints. Our research also considers functionality constraints related to operations like cargo management (for commercial ships), mission * Corresponding author. Tel.: 1 30-1-7721405; fax: 1 30-1-7721408. E-mail addresses: [email protected] (N.S. Sapidis); [email protected] (G. Theodosiou)

completion (for naval ships), manufacturing and product management (for an industrial plant), service and repair of mechanical subsystems, emergency operations (fire extinction), etc. It is easy to see that these functionality constraints relate primarily to modeling virtual-solids representing “empty volumes” that must exist at specific locations inside the plant. Example: Fig. 1 is a typical manufacturer’s drawing specifying “dismantling spaces” around a diesel alternator for maintenance and parts-replacement. 1 In general, a maintenance and/or parts-replacement operation requires moving a solid (“part”) along an arbitrary path, but for the overwhelming majority of cases (including those shown in Fig. 1), the required path is a straight-line segment. This is the only case considered in this paper. Thus, each constraint of Fig. 1 corresponds to a virtual-solid V modeled as a linear sweep (or extruded solid) [8,21] by sweeping a planar region D (specified either automatically, by an appropriate procedure, or interactively by the designer) along a straight-line segment LD perpendicular to D. Since the number of objects in the scene is already high, the idea of using virtual-solids is viable only if each Extrusion…D; LD † is guaranteed to be economical, regarding required storage. This is proportional to the number of faces in the virtual-solid, that is, the 1 It is obvious that the specification of the required dismantling-spaces is often vague, as it is stated customarily in terms of a distance from a machine’s face. The issue of alleviating this vagueness will be addressed elsewhere.

0010-4485/99/$ - see front matter q 1999 Elsevier Science Ltd. All rights reserved. PII: S0010-448 5(99)00048-2

598

N.S. Sapidis, G. Theodosiou / Computer-Aided Design 31 (1999) 597–610

Fig. 1. Diesel alternator and the required dismantling spaces.

number of edges defining the generating region D. In practice, it is very common for D to include a very large number of edges (e.g. defining “fixture details” of the corresponding moving part; see Fig. 1) necessitating use of a simplified domain D s in the extrusion. 1.1. The domain simplification problem Since Extrusion…D; LD † is replaced by Extrusion…Ds ; LD †, the CAD system can only ensure that the latter is free of interferences (e.g. in an evolving “scene” with many objects). This guarantees that the required empty volume is available only if Extrusion…D; LD † is a subset of Extrusion…Ds ; LD †, thus

Fig. 2. The initial domain D (continuous line) and the simplified domain D s (dashed line).

the simplified domain D s must be a superset of the initial domain D. It is also important that (a) D s extends, beyond the boundary of D, as little as possible, and (b) the space beyond D occupied by D s is not useful for object layout. The latter implies that D s should be obtained from D by identifying concavities on the boundary of D and eliminating them, i.e. replacing them with a straight-line edge; see Figs. 2 and 3. Indeed, this is the first of the two standard simplification

Fig. 3. The domain D (continuous line), its bounding box BD (dashed line), and the corresponding limit-points. P1P5 is a ps-edge of D. If P1P5 is a cs-edge, the corresponding cs-subpolyline is E1 ‰P1 ; P2 Š < E2 ‰P2 ; P3 Š< E3 ‰P3 ; P4 Š < E4 ‰P4 ; P5 Š. The hatched area is area A1,5 corresponding to P1 P 5 .

N.S. Sapidis, G. Theodosiou / Computer-Aided Design 31 (1999) 597–610

599

Note 2. We consider domains bounded by edges that are either line-segments or convex-arcs. This covers the overwhelming majority of virtual-solids required by applications, e.g. those involved in interior-ship design according to a recent study by the first author [9]. Yet, both the theory and the algorithm proposed here may easily be extended to the case of general spline-curves.

Fig. 4. Small complexity reduction technique: BCD is a “concave shallow” of height h. EFGH is a “chamber” of height g. JKL is a “ridge” of height q.

operations employed (in some variation) by all existing domain-simplification algorithms (a review is presented in Section 2): • Vertex–vertex simplification: if Pk and Pl are vertices of the domain D with Pk Pl not intersecting the interior of D, and the part of D‘s boundary connecting Pk to Pl is approximated satisfactorily by Pk Pl according to a given “simplification criterion”, then this is replaced by Pk Pl . • Edge–edge simplification: if Pk21 Pk , Pl Pl11 are straightline edges of the domain D, and the part of D’s boundary connecting Pk21 to Pl11 satisfies certain “simplification criterion”, then this is replaced by the two straight-line edges Pk21 Pp , Pp Pl11 , where Pp is the intersection point of Pk21 Pk and Pl Pl11 ; example: see edges EF and GH in Fig. 4. In this work, we use only the first simplification operation as this suffices to produce an efficient algorithm. Obviously, vertex–vertex simplification always limits the simplified domain to be a subset of the convex-hull of the initial domain. The above discussions lead to the following statement of the domain simplification problem pertinent to virtual-solid modeling (see also Fig. 2): Problem 1. Let D be a domain (region) in the plane, and Cr…D; Dp † a criterion ensuring that the domain D p is an acceptable approximation of D. Specify a new domain D s, such that (i) D is a subset of D s, which in turn is a subset of the convex hull of D, (ii) D s satisfies the above criterion and its vertices are also vertices of D, (iii) the edges of D s which are not edges of D are linear, and (iv) the number of edges in D s is as small as possible. Note 1 (Using the convex hull of D as a simplification of D). The convex hull of D seems to offer a reasonable simplification of D as it is produced from D by vertex– vertex simplification, and it usually has less edges than D. However, the convex hull of D is not, in general, a solution to Problem 1 as it may fail to satisfy the criterion Cr…D; Dp † and it also may have more edges than the initial domain. 2 2

We thank an anonymous referee for this remark.

2. Introduction: domain simplification in CAD/CAE Planar domain simplification is vital also in other areas of work irrelevant to “object layout”. These are briefly reviewed along with the best available simplification techniques. 2.1. Domain simplification in automatic nesting Here, the issue is to find an arrangement for cutting irregularly shaped pieces from a resource so that waste is minimal [4]. A significant proportion of the published nestingtechniques employs a “sufficiently simple” polygon (usually, a quadrilateral) approximating the exact piece-tobe-cut. Older publications assume that a human expert provides this approximate polygon; see, e.g. [3, p. 59] and the related comments in the Introduction of [10]. Newer works (see e.g. [2,13]) attempt to automate this step using heuristics based on removing “small edges”, but do not even attempt to describe any automatic or semi-automatic procedure. Very recently, the dissertation [10] and the paper [11] focused on a domain-simplification method using improved shape-reasoning heuristics based on “three sided features”. The proposed small complexity reduction (SCR) technique may be summarized as follows (see Fig. 4): (A) The given domain D is approximated by a polygonal domain DP having only straight-line edges. (B) Repeated application of shallow_rmv: for each “concave shallow” in DP: if its height is smaller than htol, this is removed. (C) Single application of chamfer_rmv: if a “chamfer” exists with height smaller than htol, this is removed. (D) Single application of ridge_rmv: if a “ridge” exists with height smaller than htol, this is removed. (E) If DP has changed go to step (B), else exit. The SCR heuristic represents indeed a significant improvement compared to existing simplification techniques yet it is far from a complete algorithm. For example, Lamousin [10] states (ibid. p. 69) “all new edges must be checked for intersection with the current profile” and (ibid. p. 70) “to prevent potential conflicts … all alterations and eliminations of edges and vertices are recorded”, but no information is given regarding algorithmic implementation of these operations. Very briefly, the disadvantages of SCR are: (a) The SCR heuristic [10,11] is not a complete algorithm.

600

N.S. Sapidis, G. Theodosiou / Computer-Aided Design 31 (1999) 597–610

Neither a proof of convergence nor any estimate of computational cost for SCR is offered in [10,11]. (b) Clearly, SCR follows the classical bottom ! top philosophy, which removes local, small features (“three sided features” in the case of SCR) in order to simplify a domain. This necessitates construction of the “current profile”, i.e. of the (intermediate) simplified domain required, e.g. by step (E). This construction usually is computationally expensive, as it requires interaction with the CAD-system’s database. Later, we employ the bounding box of the domain, to be simplified, and establish a property that allows development of a simplification algorithm operating in a top ! bottom manner, which eliminates the need to build intermediate versions of the domain. (c) The SCR simplification-heuristics (shallow_rmv, chamfer_rmv, ridge_rmv) can be applied only on domains with straight-line edges. Thus, step (A) approximates the given domain D, including N edges, with a polygonal domain DL with N L . N linear edges, on which the three heuristics are applied. This increases the simplification steps and thus the corresponding computational cost. (d) Each SCR simplification-step corresponds to a larger computational cost than any simplification-step according to the new algorithm. This is due to the fact that SCR checks for possible intersection of new edge(s) with the whole “current profile” while the new algorithm must check this only for a specific part of the domain’s boundary (see Theorems 1 and 2 in Section 4). 2.2. Domain simplification in automatic meshing for FEanalysis The fully detailed 2D/3D solid models of mechanical components, available in current CAD systems, lead to unnecessarily large FE-models, where many elements are devoted to the description of unimportant, from the FEanalysis point-of-view, details of the component. Thus, many researchers are currently focusing on robust simplification techniques for CAD models. Sheffer et al. [18] review existing simplification techniques that require “extensive interaction with the user” and propose an algorithm to automatically simplify the topology of a faceted 3D model prior to meshing. Lee and Lee [12] apply Fourier transform on digitized solid-models to assist engineers in suppressing the detail from a CAD model. Both Sheffer et al. [18] and Lee and Lee [12] recognize the work of Armstrong et al. [1,17] as the state-of-the-art in automatic detail-suppression for planar domains. The algorithm in [1,17] uses the medial axis (or “skeleton”) of a domain to identify and suppress details. Sheehy et al. [17] calculate an approximation of the medial axis (MA), using the domain Delaunay triangulation [15,16], but offer neither a complete description of the geometric model of the MA, nor a proof of convergence for the related algorithm, nor any complexity

estimates for the employed procedures. Thus, we feel we must agree with Sheffer et al. [18] concluding that the procedure in [17] “is highly complex, expensive, and not always possible”. Also, the discussion on “abnormalities involved in shape decomposition based on the MA” when “short boundary elements” are present (see [7, pp. 291–292]) raises serious doubts regarding the MA’s appropriateness for “domain simplification”. This discussion is particularly applicable to Refs. [1,17] as these works use only an approximation of the exact MA. Finally, the criteria employed in [17], to identify “short edges”, compare the length of edges to quantities related directly with the MA (e.g. the “mean touching disk diameter”), thus, they require the user to be familiar with the complex concept of MA, in order for him/ her to specify the thresholds required by the criteria.

3. Domain simplification: notation and overview of the algorithm The planar domain D, to be simplified, is a manifold 2D solid defined by a 2D boundary-representation, B-rep(D), as specified by standard solid-modeling theory [8,21]. Brep(D) gives an informationally complete description of the boundary of D, Bnd(D), that is, the exterior boundary L 0 and the interior boundaries (holes) {Li ; i ˆ 1; 2; …; M}. Each boundary is a “polyline”, i.e. a Jordan-curve consisting of a finite number of linear or convex edges. Each boundary Li of the domain is defined by its vertices {Pj ; j ˆ 0; 1; …; Ni } and edges {Ej ; j ˆ 0; 1; …; Ni }, where each edge is defined parametrically Ej ˆ Ej …t†; t [ ‰aj ; bj Š, with Ej …aj † ˆ Pj and Ej …bj † ˆ Pj11 ; the symbol Ej ‰Pj ; Pj11 Š will also be used to indicate the relation between an edge and its vertices. Vertices and edges are numbered sequentially corresponding to a counterclockwise (ccw) traversal of L i. Only consecutive edges are allowed to touch each other at their common vertex, where the tangent and the curvature may be continuous or not. For each boundary Li , every point P [ Li is associated to its neighborhood ND …P† specifying where the interior of D, Int…D†, is with respect to this particular boundary [14]. ND …P† is defined to be equal to the intersection of a disk D…P; r†, centered at P with radius r ! 0, with D. For a planar domain D, one needs to consider only two cases: (a) An edge neighborhood ND …Ei † specifying ND …P† for every P in the interior of the edge Ei ‰Pi ; Pi11 Š. Assuming that each Ej ‰Pj ; Pj11 Š is associated to a positive normal vector, perpendicular to the tangent of Ej ‰Pj ; Pj11 Š, then ND …Ei † is just an integer with value 11 or 21 indicating on which side of this edge the domain lies. (b) A vertexneighborhood ND …Pi † specifying ND …Pi † for every vertex Pi of D. As ND …Pi † is a sector bounded by the two edges Ei21 ‰Pi21 ; Pi Š, Ei ‰Pi ; Pi11 Š, its description relies on the tangent vector ni21 …Pi † to the edge Ei21 at the point Pi and the tangent vector ni …Pi † to Ei at the same point. Then, ND …Pi † is an integer with value 11 or 21 indicating

N.S. Sapidis, G. Theodosiou / Computer-Aided Design 31 (1999) 597–610

in what sense (cw or ccw) ni21 …Pi † must be rotated around Pi to span the sector ND …Pi †. We complete the notation used in this paper with E…P; Q†, where P and Q are two points on Li with P preceding Q (for a ccw traversal of Li †: E…P; Q† will denote the part, or subpolyline, of Li that starts at P and ends at Q; each one of the points P, Q may be either a vertex or an “interior point” of an edge. The domain-simplification problem, Problem 1, will be solved by appropriately simplifying the exterior and interior boundaries of the given domain. This problem is stated and solved, in Sections 4 and 5, for the case of the exterior boundary of D. Only minor modifications are required for the solution-algorithm to handle interior boundaries also; these are explained in Section 6. The detailed presentation of the new simplification algorithm is preceded by an overview (Section 3.1) emphasizing the principal ideas and tools employed by this algorithm. 3.1. Overview of the simplification method Section 4 first details a simplification criterion appropriate for virtual-solid modeling and introduces the required notation. Then, the first principal tool employed by the algorithm is presented in the form of Theorem 1. This establishes that, when one uses only vertex–vertex simplification, simplifying the (exterior) closed boundary L 0 of D is equivalent to simplifying the at-most eight open “chains of edges” (here, called “b-polylines”) into which L 0 is subdivided by its points-of-contact with the bounding box of D. Thus, the simplification algorithm (presented in Section 5) need only consider open subpolylines. The second major idea incorporated into the algorithm is answering the query “does the straight-line segment XY intersect Int…D†?”, involved in vertex–vertex simplification, by a function employing only the B-rep description of the bpolyline under consideration instead of the whole B-rep(D). This is necessary for the development of a “local” simplification procedure. Section 5.1 presents such a function based on the fact that each b-polyline and the corresponding part of the bounding box of D define a domain that includes no part of D. The third, and most important, novelty in the proposed algorithm is its top ! bottom philosophy as opposed to the bottom ! top approach of all existing algorithms. The latter approach iteratively identifies/removes “small features” and thus it faces the problem of recursive simplifiable features: a subpolyline is eliminated by vertex–vertex simplification, i.e. it is replaced by a straight-line edge, which in turn is also eliminated as part of another simplifiable subpolyline. Dealing with this situation requires building the complete B-rep of the new (simplified) domain D 0 after each simplification step, which is computationally expensive and leads to procedures of unknown complexity. The new algorithm (Section 5) operates in an opposite manner, examining

601

first “large features”, and if these are not simplifiable, it considers smaller features. This approach need not deal with recursive features and allows completion of the whole simplification process without building intermediate domains, i.e. it uses only B-rep(D). More specifically, the algorithm starts with an attempt to apply vertex–vertex simplification on the whole b-polyline in order to eliminate all l edges of it. If this fails, the algorithm attempts to eliminate l 2 1 consecutive edges (possible cases that must be considered: two), then l 2 2 consecutive edges (possible cases: three), etc. Examining all possible cases allows optimal simplification, i.e. elimination of those subpolylines best fitting the given criterion. Whenever simplification is accomplished, the remainder subpolyline is identified and processed in exactly the same manner. Section 6 discusses first the minor modification required for the above procedure to handle also interior boundaries and then proceeds to stating an important property of the algorithm (see Section 6.2): for each subpolyline simplified by the algorithm, there is no superset subpolyline that could be simplified. A direct result of this property is that the algorithm guarantees elimination of the largest possible number of edges for a given simplification criterion. Section 6.3 concludes the analysis of the algorithm establishing a O(N 3) worst-case complexity for it. 4. Simplification of the domain’s exterior boundary Development of a simplification algorithm based on vertex–vertex simplification requires introducing some notation and a criterion that ensures acceptable approximation of the initial domain: Definition 1. If Pk , Pl (with k , l) are vertices of D, the line-segment Pk Pl is called a possible simplification-edge or ps-edge of D if and only if Pk Pl does not intersect Int…D†. Regarding the criterion for acceptable approximation (see Problem 1), it is evident that, from the point-of-view of “virtual-solid modeling”, the error between Pk Pl and E…Pk ; Pl † is a generalized-cylinder Wk;l with basis defined by the closed polyline E…Pk ; Pl † < Pl Pk , defining the difference between the approximate virtual-solid Sweep…Ds ; LD † and the exact Sweep…D; LD †. Thus, Pk Pl is a satisfactory approximation of E…Pk ; Pl † if and only if the volume Vol…Wk;l † is not accessible;

…1†

or Vol…Wk;l † is accessible but too small:

…2†

The above conditions should preferably be quantified in terms of quantities related to D only. The straightforward choice is to measure Vol…Wk;l † by the area Ak;l of its basis, and its accessibility by the length of Pk Pl . Thus, we materialize the approximation criterion as follows:

602

N.S. Sapidis, G. Theodosiou / Computer-Aided Design 31 (1999) 597–610

• a cs-edge (according to Criterion 1) with end-points that are vertices of L and also of D; such an edge is called a simplification edge.

Fig. 5. Since Pk Pl does not intersect Int…D†, the neighborhood of Q0 (hatched region) lies “below” the boundary of D.

Criterion 1. Given a domain D, a ps-edge Pk Pl is considered to approximate satisfactorily D (i.e. the subpolyline E…Pk ; Pl †), if and only if primary :

Length…Pk Pl † # Lsmall

…3†

or secondary :

…3† is not true and Ak;l # Asmall ;

…4†

where Ak;l is the area defined by the closed polyline E…Pk ; Pl † < Pl Pk (see example in Fig. 3). Such a ps-edge is characterized as a candidate simplification edge or csedge—the corresponding subpolyline E…Pk ; Pl † is called a cs-subpolyline—and it may be included in a simplification of D. Furthermore, the appropriateness-for-simplification of E…Pk ; Pl † and Pl Pk is measured by the quantity sk;l : 8 Length…Pk Pl † Length…Pk Pl † > > ; if , 1; > < Lsmall Lsmall sk;l ˆ …5† > > > 1 1 Ak;l ; otherwise: : Asmall

Both limit-values Asmall and Lsmall may be automatically calculated as follows: Asmall is the ratio of the “smallest usable volume” (e.g. equal to “volume of smallest object in the scene”) over the length LD (see description in Section 1), while Lsmall could be set equal, e.g. to the largest dimension of the smallest object in the scene. The quantity sk;l may be used to differentiate between cs-edges and other edges, e.g. ps-edges, as the former correspond to sk;l # 2 and the latter to a value .2, yet, the principal purpose of sk;l is to differentiate among cs-edges: clearly, the smaller sk;l is, the better Pk Pl fits the above criterion. Next, we define the concept of “simplification” for the exterior boundary L 0 and also for any open portion (subpolyline) of it, as the proposed algorithm will operate on open subpolyline of L 0.

The following theorem (property) is vital for establishing the validity and effectiveness of the simplification algorithm we propose later. The theorem employs an arbitrary bounding box BD of D, i.e. the smallest parallelogram BD ˆ abgd (see Fig. 3) such that D # BD, where the edges of BD are parallel to the axes of any given coordinate system (xy) in the plane of D. The theorem also employs the eight limitpoints Q0, Q1 ; …; Q7 on the boundary of BD (ordered ccw and arranged as in Fig. 3) defined to be the first and last point of contact between L 0 and the boundary of BD on a b , bg , gd and d a , respectively. (The characterizations “first point” and “last point” are based on the value of the only coordinate, x or y, which varies along each particular side of BD. Also, we note that it is not required that all these points are distinct.) Theorem 1. Let D be a domain to be simplified, L0 and L as defined by Definition 2, BD an arbitrary bounding box of D, and {Q0,Q1,…,Q7} the eight limit-points defined as above. Then, there is no ps-edge PkPl of D such that any of the limit-points lies in E…Pk ; Pl † 2 {Pk ; Pl }. Proof. We establish the theorem’s claim only for the point Q0, the first point of the lower side a b of BD lying also on L 0; for the remainder seven limit-points the proof is analogous. The proof is by contradiction: Let Pk Pl be a ps-edge of L with Q0 [ E…Pk ; Pl † 2 {Pk ; Pl }, as in Fig. 5. If Pk Pl does not lie on a b , then Pk Pl lies above ab —with the possible exception of only one of Pk , Pl —and must not intersect Int…D†. This forces the neighborhood ND …Q0 † to be “below” L (Fig. 5), i.e. intersecting also the area of the (xy) plane below a b (impossible). Thus Pk Pl lies on ab: Since Q0 [ E…Pk ; Pl † 2 {Pk ; Pl }, Pk is to left of Q0 —the opposite contradicts the fact that the exterior boundary of D is a Jordan-curve—and naturally Pk is a point of contact of a b and D. This contradicts the fact that Q0 is the first point-of-contact of a b with D. A The eight limit-points defined above subdivide L 0 into atmost eight open subpolylines, called boundary-polylines or b-polylines, which are collected in the set

Definition 2. If L is the exterior boundary L 0 of D (or any open subpolyline of L 0), a simplification L s is a closed (or open, respectively) polyline each edge of which is either

S0 ˆ {E…Qi ; Qic †; 0 # i # 7} 11

• identical with an edge of L , called an unsimplified edge, or

, where j d 1 1 ; …j 1 1† mod8, and if, for some j; Qj ; Qjc 11 † is not included in S . Then, a direct then E…Qj ; Qjc 0 11

N.S. Sapidis, G. Theodosiou / Computer-Aided Design 31 (1999) 597–610

consequence of Definition 2 and Theorem 1 is that Pk Pl is a simplification-edge of L0 , Pk Pl is a simplification-edge of E…Qi ; Qic † 11

…6†

for some i [ ‰0; 7Š: This property suggests construction of a simplification of L 0 by simplifying the at-most eight b-polylines in S 0. Gluing together the simplifications Es …Qi ; Qic †; 0 # i # 11 7; must make sure that the resulting simplification has as vertices only vertices of D. This means that, for each limitpoint Qi which is not a vertex of D, i.e. Qi is an “interior point” of an edge Ej ‰Pj ; Pj11 Š of D—example: Q7 in Fig. 3 is such a limit-point—the “gluing” operation must replace the unsimplified-edge E‰Pj ; Qi Š, from Es …Qi21 ; Qi †, and the unsimplified-edge E‰Qi ; Pj11 Š, from Es …Qi ; Qi11 †, with a single unsimplified-edge Ej ‰Pj ; Pj11 Š. We call “regularized gluing” or “R-gluing” the gluing operation ensuring the above. This and (6) establish the following theorem. Theorem 2. R-gluing any simplifications of the at-most †; i ˆ 0; 1; …; 7, produces a eight b-polylines E…Qi ; Qic 11 simplification of the boundary L0, and vice versa: any simplification of the boundary L0 may be decomposed †; i ˆ 0; 1; …; 7. into simplifications of E…Qi ; Qic 11 Thus, simplifying the exterior boundary L 0 is equivalent to simplifying individually each one of its eight b-polylines †; i ˆ 0; 2; …; 7. The related algorithm is E…Qi ; Qic 11 described in the next section.

603

Function is-ps-edge (Input: L ; E…Qj ; Qjc †, Pk Pl ; 11 Output: boolean) Case A: if Pk Pl lies on the boundary of BD then return “true” Case B: if non-trivial-intersection …L; Pk Pl † ˆ “true” then return “false” else (comment: Pk Pl is either entirely inside or entirely outside D) classify Pk Pl with respect to the neighborhood ND …Pk †: if Pk Pl is directed towards “in”, then return “false” else return “true”. End_Function. Proof of Correctness (for case B). L and the corresponding portion of the boundary of BD, which starts at Qj and ends at Qjc , define a (probably disconnected) domain DL 11 where no part of Bnd…D† 2 L exists; see Fig. 3. Thus, for any two vertices of L : Pk Pl does not intersect Int…D† iff

Pk Pl is in=on DL : …7†

Classifying Pk Pl with respect to DL is straightforward as Pk Pl cannot intersect any part of Bnd…DL † 2 L. Thus, the possible cases are only two: either Pk Pl intersects, nontrivially, L , in which case Pk Pl is not a ps-edge, or, Pk Pl does not intersect, nontrivially, L , in which case Pk Pl is a ps-edge iff

Pk Pl does not intersect ND …Pk †: …8†

These are exactly the two cases considered by the above function. Thus, the function is correct. A 5. Simplifying open polylines † [ S0 be any of the b-polylines of Let L ; E…Qj ; Qjc 11 L 0 (see Fig. 3) with VL ˆ {Pl ; Pl11 ; …; Pl1l } its vertices (which are also vertices of L 0 with the possible exception of only the first and last vertex), and EL ˆ {El ; El11 ; …; El1l21 } the edges of L . The algorithm simplifying L presumes a procedure classifying straightline segments as ps-edges and cs-edges; this is described in the following section. 5.1. Classifying straight-line segments Identification of ps-edges is accomplished by the function is-ps-edge, accepting as input L and a straight-line connecting two vertices of L (and of D), Pk , Pl , and returning a boolean value (“true” or “false”) specifying that Pk Pl is a valid ps-edge or not. Although, the definition of a ps-edge is “global” as it deals with the whole domain D, an efficient local implementation is possible. This employs the function non-trivial-intersection for L and Pk Pl , which ignores trivial intersection points (points where Pk Pl only touches L without crossing it).

Note 3. The computational cost of is-ps-edge relates to intersecting L with Pk Pl , thus it is optimal, depending linearly on the number of edges in L . The function is-ps-edge and a procedure criterion-1, applying (3)–(5), are employed by the following: Procedure is-cs-edge(Input: L , Pk Pl , Lsmall, Asmall; Output: boolean, sk;l ) if is-ps-edge(Pk Pl ; L) ˆ “true” and criterion1(L; Pk Pl ; Asmall ; Lsmall ; sk;l ) ˆ “true” then return “true” else return “false” End_Procedure. 5.2. Algorithm simplify_polyline The algorithm described below accepts as input the portion of the B-rep definition of D corresponding to the l edges of L along with Lsmall, Asmall. The output of the algorithm’s main part (steps A and B) is again L , but with some of its subpolylines marked as “simplification subpolylines”. The B-rep definition of the simplification L s is built in step

604

N.S. Sapidis, G. Theodosiou / Computer-Aided Design 31 (1999) 597–610

(C), where simplification subpolylines are replaced by straight-line edges. Algorithm simplify_polyline(Input: L , Lsmall, Asmall; Output: L s) step A Mark all edges as unsimplified-edges. step B For i ˆ l; l 2 1; l 2 2; …; 2: { B.1. Consider the set UE of all subpolylines of L with i consecutive unsimplified-edges 3 B.2. If UE is empty, then goto_continue, else: B.3. For each subpolyline E…Pj ; Pj1i † in UE: If is-csedge(L , Pj Pj1i , Lsmall, Asmall; sj;j1i ) ˆ “true” then mark E…Pj ; Pj1i † as cs-subpolyline. B.4. If no cs-subpolyline is found, then goto_continue, else: B.5. (B.5a) Among all cs-subpolylines: find the cssubpolylines that best fit Criterion 1 (i.e. correspond to the smallest values of si;j † which do not overlap each other. (B.5b) Mark these subpolylines as simplificationsubpolylines. (B.5c) For all remaining cs-subpolylines: mark again their edges as unsimplified-edges and empty the set of cs-subpolylines. continue } step C Create the B-rep of the simplification L s as follows: C.1. For each unsimplified-edge Ej : transfer the B-rep description of Ej from B-rep(L ) to B-rep(L s). C.2. For each simplification-subpolyline E…Pq ; Pr †: add to B-rep(L s) the new straight-line edge Pq Pr ; define the neighborhood NDs …Pq Pr † of this new edge and correct the neighborhoods of the vertices Pq and Pr . C.3. Identify straight-line edges in B-rep(L s) that are consecutive and collinear and merge them into a single edge. End_Algorithm

Note 4. Step B.5 is performed as follows. First, all cssubpolylines are ordered in a list according to an increasing si;j value. Then, the following iterative process is performed: Consider the next cs-subpolyline E…Pq ; Pr † on the list, with sq;r # 2 (in the first iteration, this is the first item of the list). Mark E…Pq ; Pr † as a simplification-subpolyline and, 3 Comment: if all edges are unsimplified-edges (this is always true for i ˆ l), then step B.1 finds: UE ˆ {E…Pl ; Pl1i †; E…Pl11 ; Pl111i †; E…Pl12 ; Pl121i †; …; E…Pl1l2i ; Pl1l †}.

in the remainder of the list, find all cs-subpolylines partially overlapping with E…Pq ; Pr †. Unmark these subpolylines, i.e. set their si;j -value equal to a value larger than 2. Note 5. Step C.2 completes B-rep(L s) by specifying the neighborhood NDs …Pq Pr † of each new edge Pq Pr with respect to D s. This is easily accomplished using Neighborhood Information Transfer [15,16]: (a) the tangent vector and the positive normal vector of Pq Pr are defined in a manner compatible with those of Eq ‰Pq ; Pq11 Š, then (b) NDs …Pq Pr † ˆ ND …Eq ‰Pq ; Pq11 Š†; NDs …Pq † ˆ ND …Pq †; NDs …Pr † ˆ ND …Pr †:

6. Simplifying exterior and interior boundaries The method, described in the last paragraphs of Section 4, for simplifying the exterior boundary L 0 is equivalent to the following algorithm. Algorithm simplify_boundary(Input: D, L 0, Lsmall, Asmall; Output: Ls0 ) 1. calculate_bounding-box(Input: D; Output: BD) 2. identify_limit-points(Input: BD, L 0; Output: {Qi ; 0 # i # 7}). 3. identify_b-polylines(Input: L 0, {Qi }; Output: S0 ˆ {E…Qi ; Q11i ^ †; 0 # i # 7}) 4. For each non-trivial b-polyline L [ S0 (meaning that L has more than one edge): simplify_polyline(Input: L , Lsmall, Asmall; Output: L s) †; 5. r-glue_simplifications(Input: Es …Qi ; Qic 11 s i ˆ 0; 2; …; 7; Output: L0 ) End_Algorithm Establishing correctness of this algorithm is a direct result of Theorem 2. Note 6 (Using the convex hull of D instead of the bounding box of D to segment this domain prior to simplification). Clearly, Theorems 1 and 2 of Section 4 also hold when one replaces the bounding box of D with its convex hull, with the only difference that the number of limit-points as well as that of b-polylines is no longer a fixed constant. Thus, using the convex hull of D in steps 1–3 of the above algorithm will make them significantly more complex without producing any visible gain. This clearly suggests that one should use instead the bounding box of D.

6.1. Simplifying an interior boundary For all applications mentioned in Sections 1 and 2, simplification of an interior boundary (hole) Li must start with an estimation of the “size” of Li (e.g. by measuring the area defined by Li ), as Li should be completely eliminated when its “size” is found to be too small. Otherwise, Li is simplified according to Criterion 1. It is straightforward that

N.S. Sapidis, G. Theodosiou / Computer-Aided Design 31 (1999) 597–610

605

Li may be simplified also by the method of Section 4, i.e. using the algorithm simplify_boundary, provided that only one modification is incorporated into it: The bounding box BD must be now the bounding box of the domain defined by Li . This means that line 1 of the algorithm simplify_boundary must be replaced by

Theorem 4. Application of simplify_polyline on a bpolyline L, with l edges, is a local operation, i.e. it involves only the part of the B-rep of the domain D describing L. The computational cost of simplify_subpolyline is, in the worst case, O(l 3).

1a. create_domain(Input: Li ; Output: Di ) 1b. calculate_boundingbox(Input: Di ; Output: BD) 1c. delete_domain(Input: Di ).

The above worst-case analysis corresponds to the case where simplify_polyline does not simplify L at all, e.g. due to very small values of Lsmall, Asmall. In order to obtain a more realistic estimate of the algorithm’s cost we consider the “average case” where step B of simplify_polyline stops at i ˆ el, where 0 , e , 1. Iterating the above analysis produces an O……1-e†2 l3 † estimate for the average-case complexity of the algorithm. This indicates that although the complexity of simplify_polyline cannot be better than O(Cl 3), due to the exhaustive-search nature of step B, the constant C is, in the average case, a small number. Returning to the study of the main algorithm, simplify_boundary, we combine the above analyses with the observation that step 5 has a complexity of O(1), to conclude that the complexity of simplify_boundary is specified by the complexity of step 4, i.e.

6.2. Optimality of domain produced by simplify_boundary simplify_boundary produces a simplification with the minimum number of edges, since step B.1 of simplify_polyline guarantees that this algorithm eliminates the largest possible number of edges. More specifically, it is trivial to establish the following theorem. Theorem 3. Let D be a domain to be simplified according to Criterion 1, for given parameters Lsmall, Asmall. For each simplified subpolyline E…Pq ; Pr † of D, which is replaced by the straight-line edge PqPr in D s, there is no subpolyline E…Pi ; Pj † of D that satisfies Criterion 1 such that E…Pi ; Pj † . E…Pq ; Pr †.

6.3. Complexity analysis of simplify_boundary Upper bounds for the complexity of the algorithm simplify_boundary are derived, considering simplification of a single boundary of D, e.g. the exterior boundary of D, L 0. The size of the input L 0 is measured by the number N of edges it is comprised of. Since algorithm simplify_boundary is implemented in a solid-modeling environment where bounding boxes are pre-calculated and always accompany the B-rep of a 3D or 2D solid, it is reasonable to ignore the computational cost of step 1. Step 2 must intersect each edge of the bounding box with all edges of L 0. Thus, the processing cost is O(N), which is true also for step 3. To estimate the cost of step 4, we must first calculate that of algorithm simplify_polyline applied to a b-polyline L having, let us assume, l edges: step A requires visiting all edges of L , thus, its complexity is O(l). Regarding step B: the ith iteration considers, at most, l-i 1 1 subpolylines. For each subpolyline E…Pk ; Pl †, the procedure is-cs-edge is executed, requiring intersection of Pk Pl with L and calculation of the area enclosed by E…Pk ; Pl † < Pl Pk . Thus, the computational cost for step B.3 is O(l), which is true also for the cost of step B.5 (i.e. the procedure described in Note 4). This makes the worst-case estimate for the cost of the whole step B O(l 3). Finally, the cost of step C is obviously O(l). This analysis establishes the important advantages of the algorithm simplify_polyline:

Theorem 5. The computational cost of simplify_boundary is O…l3max †, where lmax represents the largest number of edges in any of the b-polylines of L0 identified in step 3 of simplify_boundary. Thus, the worst case, lmax ˆ O…N† (N is the number of edges in L0), corresponds to complexity O(KN 3), with K a small number. The average case, where lmax is independent of N, i.e. lmax ˆ O…1†, corresponds to complexity O(1).

7. Implementation, evaluation and application of simplify_ simplify_boundary in AutoCAD The simplify_boundary algorithm has been implemented in the current AutoCAD system and in particular in ObjectARX, the C11 object-oriented programming environment where also AutoCAD is developed. Implementation of the algorithms of Sections 5 and 6 requires the following functions/tools: • extracting geometric/topological information from a Brep model • calculation of bounding box (defined as a polyline) • polyline–polyline intersection • creation of a polyline from line- and curve-segments • subdivision of a polyline into subpolylines, and other processing tools for polylines • intersection of a line-segment with a polyline, and • calculation of the area defined by a closed polyline. All these tools are readily available either in core AutoCAD libraries or in ACIS, which is used by AutoCAD as its geometric-modeling kernel. The hardware platform is a

606

N.S. Sapidis, G. Theodosiou / Computer-Aided Design 31 (1999) 597–610

Fig. 6. Example A: the domain and its bounding box.

standard PC: Pentium(166 MHz) with 64 MB RAM, 256 KB Cache. Fig. 7. Example A: simplified domain for case 2 (top) and case 3 (bottom).

7.1. Test examples 7.1.1. Example A The domain D to be simplified and its bounding box BD are depicted in Fig. 6. We have chosen an arbitrary orientation of the domain with respect to the coordinate system, so that BD is different from the “natural bounding box” that would accelerate simplify_boundary. BD has width ˆ 257:5, height ˆ 183:3 and divides the boundary of D into four nontrivial b-polylines: E…Q1 ; Q2 †, E…Q3 ; Q4 †; E…Q5 ; Q6 † and E…Q7 ; Q0 † as indicated in Fig. 6. • Case 1 (“worst case”): We set both Lsmall and Asmall equal to zero, and thus we have what one might consider as the worst possible case where algorithm simplify_polyline must examine all subpolylines of each b-polyline. Naturally, no simplification is accomplished, and the corresponding processing time is recorded, for each one of the four b-polylines, in the third column of Table 1. • Case 2 (“average case”): We set Lsmall ˆ 105 and Asmall ˆ 2000. Then, simplify_boundary produces the simplified boundary shown in Fig. 7 (top) with a bold line, which is composed of only 12 edges, compared to a total of 28 edges in the original boundary. The corresponding processing times are recorded in the fourth column of Table 1. • Case 3 (“favorable case”): Here, both Lsmall and Asmall are set equal to very large values, more specifically, Lsmall ˆ p W 2 1 H 2 and Asmall ˆ W × H. Maximal simplification is accomplished producing a D s identical with the convex

hull of D (see Fig. 7 (bottom)). The required CPU times are minimal as recorded in Table 1.

7.1.2. Example B This example was copied from [10,11]. The domain D to be simplified and its bounding box BD are depicted in Fig. 8. To differentiate this example from Example A, here we align D with the coordinate system and use a “natural bounding box” BD having width W ˆ 195:5 and height H ˆ 184:3. BD identifies only two nontrivial b-polylines to be simplified, E…Q1 ; Q2 † and E…Q5 ; Q6 †; see Fig. 8. • Case 1 (“worst case”): For Lsmall ˆ 0 and Asmall ˆ 0 simplify_boundary is forced to examine all subpolylines of E…Q1 ; Q2 † and E…Q5 ; Q6 †. Here, no simplification is accomplished, and the corresponding processing times are recorded in the third column of Table 2. • Case 2 (“average case”): We set Lsmall ˆ 33 and Asmall ˆ 750. Then, simplify_boundary produces the simplified boundary shown in Fig. 9 (top) with a bold line, which is composed of only 12 edges, compared to a total of 17 edges in the original boundary. The corresponding processing times are recorded in the fourth column of Table 2. • Case 3 (“favorable case”): Here, both Lsmall and Asmall are set equal to very large values, more specifically, Lsmall ˆ p W 2 1 H 2 and Asmall ˆ W × H. Maximal simplification is accomplished producing a D s identical with the convex

Table 1 Example A: three experiments B-polyline

E…Q1 ; Q2 † E…Q3 ; Q4 † E…Q5 ; Q6 † E…Q7 ; Q0 †

Number of edges

12 2 12 2

CPU time (s) Case 1

Case 2

Case 3

0.19 0.01 0.14 0.01

0.13 0.00 0.01 0.00

0.02 0.00 0.01 0.00

Fig. 8. Example B: the domain and its bounding box.

N.S. Sapidis, G. Theodosiou / Computer-Aided Design 31 (1999) 597–610

607

Table 2 Example B: three experiments B-polyline

E…Q1 ; Q2 † E…Q5 ; Q6 †

Number of edges

8 5

CPU time (s) Case 1

Case 2

Case 3

0.07 0.02

0.12 0.02

0.01 0.00

hull of D (Fig. 9 (bottom)). The required CPU times are minimal as recorded in the last column of Table 2. 7.1.3. Example C This example is a variation of an example used in [1] to demonstrate simplification using the medial axis. The domain D to be simplified and its bounding box BD are depicted in Fig. 10. We have chosen an arbitrary orientation of the domain with respect to the coordinate system, so that BD is different from the “natural bounding box” that would accelerate simplify_boundary. BD has width W ˆ 6:54, height H ˆ 5:41, and divides the boundary of D into four nontrivial b-polylines: E…Q1 ; Q2 †, E…Q3 ; Q4 †, E…Q5 ; Q6 † and E…Q7 ; Q0 †, as indicated in Fig. 10. • Case 1 (“worst case”): We set both Lsmall and Asmall equal to zero, and thus we have what one might consider as the worst possible case where algorithm simplify_polyline must examine all subpolylines of each b-polyline. Naturally, no simplification is accomplished, and the corresponding processing times are recorded, for each one of the four b-polylines, in the third column of Table 3. • Case 2 (“average case”): We set Lsmall ˆ 0:4 and Asmall ˆ 0:2. Then, simplify_boundary produces the simplified boundary shown, with a bold line, in Fig. 11 (top), which is composed of only 18 edges, compared to a total of 46 edges in the original boundary. The corresponding processing times are recorded in the fourth column of Table 3. • Case 3 (“favorable case”): Here, both Lsmall and Asmall are set equal to very large values, more specifically, Lsmall ˆ p W 2 1 H 2 and Asmall ˆ W × H. Maximal simplification

Fig. 10. Example C: the domain and its bounding box.

is accomplished producing a D s approximating the convex hull of D (Fig. 11 (bottom)). The required CPU times are recorded in Table 3.

7.1.4. Comments on the experimental results 1. One should not assume that the required CPU time for case 1 must be always larger than the one corresponding to case 2. Surely, case 1 considers a superset of the subpolylines considered by case 2 and applies Criterion 1 a maximal number of times, but on the other hand, case 1 does not require application of step (C) of simplify_polyline. This step corresponds to a significant computational cost (as it involves interaction with AutoCAD’s main database), and it is executed, in cases 2 and 3, whenever step B succeeds in simplifying a b-polyline. 2. About Example A: The huge reduction in the processing time for E…Q5 ; Q6 † between case 1 and case 2 is due to the fact that the former required calculation of areas enclosed by polylines while the latter did not (see Criterion 1). 3. About Example B: Our experiments, with this particular example and also others copied from the thesis [10], lead to the conclusion that simplify_boundary and SCR produce similar results when the permissible error between D and D s is small, corresponding to a simplification of “high” or “medium” accuracy like, e.g. that in case 2 of Example B. For “low” accuracy, the results differ substantially as simplify_boundary produces simplifications tending to an approximation of the convex hull of D (see case 3 in the above examples), while SCR’s results tend to a quadrilateral, extending Table 3 Example C: three experiments B-polyline

Fig. 9. Example B: simplified domain for case 2 (top) and case 3 (bottom).

E…Q1 ; Q2 † E…Q3 ; Q4 † E…Q5 ; Q6 † E…Q7 ; Q0 †

Number of edges

17 4 10 16

CPU time (s) Case 1

Case 2

Case 3

0.32 0.01 0.14 0.28

0.69 0.01 0.05 0.61

0.49 0.00 0.00 0.06

608

N.S. Sapidis, G. Theodosiou / Computer-Aided Design 31 (1999) 597–610

alternators equipped with three virtual-solids, marked with “VS”, representing dismantling spaces prescribed in Fig. 1.

8. Conclusion

Fig. 11. Example C: simplified domain for case 2 (top) and case 3 (bottom).

beyond the limits of the convex hull of D; e.g. see Fig. 9 in [11].

7.2. Application of simplify_boundary in AutoCAD simplify_boundary is used by the virtual-solid modeling subsystem of an object-layout system for ship-design [9]. The system combines current solid and surface modeling tools with “accelerations techniques” based on Octree and Ray-representation models. Figs. 12 and 13 present an example demonstrating application of this system. Fig. 12 depicts a partial model of a ship’s engine room where assemblies of solids coexist with curve- and surface-models. This model includes, among others, a set of three diesel alternators modeled according to the manufacturer’s drawings like that of Fig. 1. Fig. 13 depicts one of the three

The problem of modeling “required empty-volumes” is of vital importance to object layout in mechanical design, ship design, plant design, etc. Current solid modeling technology solves the problem provided a robust algorithm is available for simplifying planar domains. Existing approaches offer reasonable heuristics, for removing details from a domain, but no complete algorithm. A simplification algorithm has been proposed for a given approximation criterion that produces an optimal simplified model—optimal in the sense that maximal sequences of edges of the initial domain are replaced by straight-line edges. To achieve this, the algorithm examines all possible sequences of edges to be simplified. A theorem has been proved that limits this search at certain parts of the domain’s boundary and leads to an efficient algorithm with O(N 3) worst-case and O(1) average-case complexity (N is the number of edges in the given domain). Completeness is the principal advantage of the proposed algorithm compared with existing techniques. Others are: optimality of the produced simplification (see above), simplicity and ease of implementation, and the fact that the simplified domain is guaranteed to be always a subset of the convex hull of the initial domain. This last property is essential for our particular application and none of the existing techniques guarantees it. Another important advantage of the new simplification algorithm is that it is independent of the “approximation criterion” used. Indeed, replacing Criterion 1 (see Section 4) with any other, implied by some particular application, does not alter the simplification algorithm. This is a property not shared by existing techniques. Current research focuses on combining the ideas

Fig. 12. AutoCAD model of a ship’s engine-room (partial).

N.S. Sapidis, G. Theodosiou / Computer-Aided Design 31 (1999) 597–610

609

Fig. 13. AutoCAD model of diesel alternator with three virtual-solids (indicated by “VS”).

presented here with “3D topology simplification” [18] towards a simplification technique for 3D B-rep models. This would be a valuable “acceleration tool” for many modeling/interrogation operations involved in object layout. Following a “pragmatic approach” we also perform a systematic analysis of the solids appearing most often in ship-design in order to identify minimal tasks that a useful 3D simplification algorithm should be able to accomplish. 9. Note added in proof While the first author was attending the 10th International Conference on Computer Applications in Shipbuilding (ICCAS ’99, MIT, June 7–11, 1999), he was informed by members of the technical staffs of Newport News Shipbuilding that a concept similar to ‘‘virtual solids’’ has been implemented in the VIVID proprietary product modelling system, developed at Newport News Shipbuilding. The VIVID approach is employing simple, primitive solids for modelling required empty-volumes. Acknowledgements This work is part of a research-project funded by the Hellenic Ministry of Development (PENED’95 research grant 880, awarded to Prof. P. Kaklis). The project aims at recording needs of ship designers and developing CADbased solutions. A full list of interviewees/consultants providing input is available in [9]. This research is also funded by the Department of Naval Architecture & Marine Engineering and the Ship Design Laboratory of the National Technical University of Athens (NTUA). We thank Prof. H. Nowacki (TU Berlin) and Profs J. Ioannidis, A. Papaniko-

laou, N. Kyrtatos, and P. Kaklis (NTUA) for their comments and suggestions. We owe special thanks to Mr. C. Ventouris (industry consultant) for his contribution and advice, to Messrs S. Buchwald, M. Zaika (Applicon, GmbH) for suggestions and industrial data (including the model of the main engine in Fig. 12), to Messrs J. Tzagarakis, Th. Papakonstantinou (Hellenic Shipyards) for advise and technical information, and to MAN B&W Diesel A/S for technical information and for allowing us to include in this paper material from their publications. Finally, we thank the editor, Dr John Woodwark, and one anonymous reviewer for their perceptive comments that led to an improvement of the original manuscript. References [1] Armstrong CG, Donaghy RJ, Bridgett SJ. Derivation of appropriate idealisations in finite element modelling. Advances in finite element technology, Civil-Comp. Press, 1996. pp. 11–20. [2] Cheok BT, Nee AYC. Algorithms for nesting of ship/offshore structural plates. Advances in design automation, DE32-2. New York: ASME, 1991. pp. 221–226. [3] Chung J, Hillman DJ. Object-oriented nesting system on two-dimensional highly irregular resources. Intelligent robots and computer vision VIII: systems and applications, 1193. SPIE, 1989. pp. 54–63. [4] Chung J, Scott D, Hillman DJ. An intelligent nesting system on 2D highly irregular resources. Applications of artificial intelligence, 1293. SPIE, 1990. pp. 472–483. [5] van Emmerik M, Rappoport A, Rossignac J. Simplifying interactive design of solid models: a hypertext approach. Vis Comput 1993;9:239–254. [6] Fujita K, Akagi S, Nakatogawa T. Hybrid approach to plant layout design using constraint-directed search and an optimization technique. J Mech Design/Trans ASME 1994;116:1026–1033. [7] Gu¨rsoy HN, Patrikalakis NM. Automated interrogation and adaptive subdivision of shape using medial axis transform. Adv Engng Software 1991;13:287–302.

610

N.S. Sapidis, G. Theodosiou / Computer-Aided Design 31 (1999) 597–610

[8] Hoffmann C. Geometric and solid modeling, Los Altos, CA: Morgan Kaufmann, 1989. [9] Kaklis P, Sapidis N. Development of a hybrid CAD system for designing surfaces and solids: application in naval architecture and mechanical design. Annual Progress Report of the PENED’95 Research Project no. 880. Department of Naval Architecture & Marine Engineering, National Technical University of Athens, 1998 (in Greek). [10] Lamousin H. Allocation of two dimensional irregular parts using a shape reasoning heuristic. PhD Thesis. Department of Mechanical Engineering, Louisiana State University, USA, 1996. [11] Lamousin H, Waggenspack Jr. WN. Nesting of two-dimensional irregular parts using a shape reasoning heuristic. Comput Aided Design 1997;29:221–238. [12] Lee YG, Lee K. Signal processing for geometric detail suppression. Proceedings of ASME Design for Manufacturing Conference, Sacramento, CA, 1997. [13] Prasad YKDV. A set of heuristic algorithms for optimal nesting of two-dimensional irregularly shaped sheet-metal blanks. Comput Ind 1994;24:55–70. [14] Requicha AAG, Voelcker HB. Boolean operations in solid modeling: boundary evaluation and merging algorithms. Proc IEEE 1985;73:30–44. [15] Sapidis N, Perucchio R. Delaunay triangulation of arbitrarily shaped planar domains. Comput Aided Geom Design 1991;8:421–437. [16] Sapidis N, Perucchio R. Domain Delaunay tetrahedrization of solid models. Int J Comput Geom Appl 1991;1:299–325. [17] Sheehy DJ, Armstrong CG, Robinson DJ. Computing the medial surface of a solid from a domain Delaunay triangulation. Proceedings of the Third ACM Symposium on Solid Modeling and Applications, 1995. pp. 201–212. [18] Sheffer T, Blacker T, Bercovier M. Clustering: automated detail suppression using virtual topology. Trends in Unstructured Mesh Generation, ASME/ASCE/SES Summer Meeting, AMD-vol 220. New York: ASME, 1997. pp. 57–64. [19] Shinya M, Forgue M-C. Laying out objects with geometric and physical constraints. Vis Comput 1995;11:188–201. [20] Sittas E. 3D design reference framework. Comput Aided Design 1991;23:380–384.

[21] Zeid I. CAD/CAM theory and practice, New York: McGraw-Hill, 1991.

Nickolas S. Sapidis is currently a Special Instructor and Principal Researcher with the Department of Naval Architecture and Marine Engineering (NAME) of the National Technical University of Athens, and a Naval Architect and Marine Engineer with the Marine Technology Development Co. Formerly, he worked at the General Motors R&D Center and the GM Design Center (1991-1993), and taught at the Hellenic Air Force Academy, the Polytechnic University of Catalunya (Spain) and Athens University. He holds degrees in NAME, Applied Mathematics and Mechanical Engineering. He received his PhD in Mechanical and Aerospace Sciences from the University of Rochester in 1993. Sapidis is the author of papers in spline-interpolation, curve and surface fairing/visualization, discrete solid models, finite-element meshing, and reverse engineering. His research has been implemented in industrial CAD/CAE systems by MIT, GM, Intergraph and KCS. He has edited books and journal special-issues and is on the Advisory Editorial Board of CAD.

Gabriel Theodosiou is a PhD student in the Department of Naval Architecture and Marine Engineering of the National Technical University of Athens (NTUA). He received his diploma in Mechanical Enginering from NTUA in 1994. He has been involved in customizing AutoCAD and designing large assemblies. Also, he has worked as an AutoCAD instructor with a Greek CAD company. Currently, he works as an application software developer for Autodesk’s mechanical products (AutoCAD and Mechanical Desktop). His research interests are in the areas of solid modelling, computational geometry and the design/modelling of complex systems.