Journal of Mechanical Working Technology, 20 (1989) 195-204 Elsevier Science Publishers B.V., Amsterdam - Printed inThe Netherlands 195

PROTOTYPING A FEATURE BASED MODELLING SYSTEM FOR AUTOMATED

PROCESS PLANNING

S.K. SIM1 and K.F. LEONG2

lSenior Lecturer, Applied Mechanics Division, School of Mechanical and Production Engineering, Nanyang Technological Institute, Nanyang Avenue (Singapore)

2Lecturer, Engineering Production Division, School of Mechanical and Production Engineering, Nanyang Technological Institute Nanyang Avenue (Singapore)

SUMMARY In recent years, there have been tremendous amount of interest in manufacturing automation

and Computer-integrated Manufacturing (CIM). To attain a high level of automation in CIM, there has been relentless effort in trying to integrate the islands of automation in manufacturing. These are often fraught with much frustrations and difficulties. The main calamity in integration is due to the mismatch of information available from the CAD system and that required by CAPP system. The geometric information generated by the solid modellers in most CAD systems are low level whilst the CAPPs will operate efficiently only at a higher level of abstraction. CAPP systems thrives on feature information but such information in CAD databases are rather implicit and at times not even available. Although there has been much research and development work in making these feature information in CAD databases more explicit through feature recognition and extraction, this is really a regressive step. A much better approach is to define features as they exist right at the start at the modelling stage and store these feature definitions in a feature database which can be assessed directly by CAPP. In this way the likelihood of making errors in interpretation is minimized as the feature information are derived at source.

This paper describes the prototyping of a feature-based modelling system in an AI logic language, Prolog. Feature hierarchy depicting the part-feature relationships can be defined by the designer when he is making the design of the part. By defining features as objects and through object oriented programming, generic and specialized feature properties can be defined or inherited through a child/parent relationship. These constituent features are composed semantically and meaningfully through a bottom-up strategy based on feature composition rules and feature primitives. The result of the parsing exercise is a solid representation of the global model depicted as a CSG tree of features. This solid model will ultimately be translated into solid modeller specific commands and further evaluated to give active boundaries representing geometric and topological information for rendering.

INTRODUCTION

Computer-aided Design (CAD), Computer-aided Manufacturing (CAM) and Computer-aided

Process Planning (CAPP) are important components in improving the overall efficiency and

performance in the automation of manufacturing. To attain a high level of automation in

computer integrated manufacturing (CIM) and widespread use in manufacturing applications, it is

desirable to integrate these islands of automation together. Process planning is that function

within a manufacturing facility that establishes which machining process and parameters are to be

0378-3804/89/$03.50 ©1989 EIsevierSciencePublishersBN.

used to convert a piece part from its initial from to a final form pre-determined from an

engineering drawing. (ref. 1) It therefore seem obvious that the key to integration is to use CAPP

as the link up between CAD and CAM. Thus much effort has been put into the development of

effective CAPP systems that will be capable of this link up. Unfortunately, even with the

application of artificial intelligence, manual intervention has not been totally eliminated thus not

achieving total automation. (ref. 2-3)

The main calamity in full integration and automation of these systems is due to the mismatch

of the information available from the CAD systems and that required by the CAPP systems.

Geometric information generated by the solid modellers in most CAD systems are low level 2-

D, 2-and-a-half-D CAD systems, wireframe systems are in even deeper predicament as far as total

integration is concerned. CAPPs operate effectively only at a higher level of abstraction where

features information are important. (ref. 4-5) To understand why this is so, it is necessary to first

understand the characteristics and limitations of the existing CAD solid modelling systems.

SOLID MODELLING SYSTEM FOR CAPP

The Solid Modelling Systems

The term geometric modelling refers to a collection of methods used to define the shape and

other geometric characteristics of an object. (ref. 6) There are three distinct aspects of geometric

modelling:

1. Representation: Computing a mathematical approximation of the physical shape of an

object.

2. Design: Creating a new shape to satisfy some operational or aesthetics objectives. The

variables defining the shape is manipulated until the objectives are met.

3. Rendering: Generating the image of the model so that it can be interpreted visually.

Solid modelling centered more on the first two aspects of geometric modelling. It is a branch

of geometric modelling that emphasizes the general applicability of models, and insists on

creating only complete representation of physical solid models.

There are several approaches to achieve this goal of which two of these representation

schemes are most popular: boundary representation (B-rep) and constructive solid geometry

(CSG). (ref. 6)

a. Boundary Representation, (B-rep) : B-rep modellers store the evaluated geometry as a

redundant hierarchy of topological entities (face, edges, vertices) with pointers to

geometric entities (surfaces, curves, points). Euler-Poincar~ equations are used to

ensure the validity of the objects (ie. that they are solids). Point sets are classified as

inside, on or outside the object, using a convention for the direction of surface normals.

b. Constructive Solid Geometry. (CSG) : CSG is a modelling method that defines

complex solids as compositions of simpler solids (called primitives). Boolean

operators are used to execute the composition. CSG representations of objects are

ordered binary trees whose terminal nodes are either primitives or transformation data

197

for rigid-body motions. The nonterminal nodes are either regularized Boolean

operators (union, difference, and intersect) or rigid-body motions (translation and/or

rotation) that operate on their two subnodes. Each subtree of a node represents a solid

resulting from the combination and transformation operations indicated below it. The

root represents the final object. If valid primitives are used with Boolean operations,

then no validity check is required. A boundary evaiuator is used to determined the

active boundaries of the final object.

These two solid modellers (as well as the others) have two major deficiencies (ref.4) :

1. Insufficient product definition : Only the complete representation of the geometric

model is defined; specific precision data like tolerances and surface finishes and

technological data like material specifications and surface treatments are not

represented in the system. Such information are important and essential in process

planning.

2. Low-level product representation : Part and product representation are in low-level

details, ie. geometry and topology for B-rep and primitives and operators in CSG. The

data only become comprehensible when an image is displayed. Thus the interpretation

of the data is done by the human viewer. High level information, such as form

features, which should be available is missing.

Therefore it is very difficult to use these existing solid modelling systems alone to drive

automated applications such as process planning because the information essential to these tasks

is virtually absent from the solid modeller databases. Work has to be done to gather these

information in order to work the CAPP systems.

The Need for Feature-Based Modelling System

A feature is a set of information related to a part's description. The description could be for

design purposes, or manufacturing and inspection or even for administration purposes. It is

convenient to classify features relating to the product as follows: (ref. 4)

1. form features : functional, aesthetic, assembly aids.

2. material features : properties, specifications, treatment (materials and surfaces).

3. precision features : tolerances, surface finishes.

4. technological features : performance parameters, operating variables, design

constraints.

Since designers and engineers utilize these features for their work, it is therefore necessary

that they are supported in a fully integrated engineering system, like in CIM. The first three

categories of features are especially important in supporting process planning systems. Thus any

automated CAPP systems that is to be used with a solid modelling CAD system must have the

means to get these feature information from that CAD system. There are three fundamental

approaches which can achieve this, namely human-assisted feature recognition, automated feature

recognition and extraction, and feature based modelling.

198

Human-assisted feature recognition in CAPP is rather primitive and does not qualify for total

automation. Automated feature recognition and extraction is a step that attempts to make explicit,

usually by the application of artificial intelligence techniques, the features information that are

available in the CAD databases. This is in essence a regressive step in automation. A much

better approach is to define features as they exist right at the start at the modelling stage and store

these feature definitions in a feature database which can be assessed directly by the CAPP system.

This is a feature based modelling approach. In this way the likelihood of making errors in

interpretation is minimized as the feature information are derived at source. It also makes better

engineering sense that the designer's efforts will have to be more attuned to manufacturing needs,

thus providing the opportunity to implement simultaneous engineering. (ref. 7) Hence a feature

based modelling system is essential to the implementation of total integration of these systems.

THE FEATURE BASED MODELLING SYSTEM

The Feature based Modelling System contains all the necessary facilities for creating a

product database at multi-levels of abstraction. A distribution system approach is adopted where

each subsystem supports one type of feature. Essentially there are four subsystems :

1. solid modeller.

2. form feature modeller.

3. precision feature modeller.

4. material feature modeller.

The underlying knowledge representation scheme is framed-based system where generic

features such as user-defined parameters, inheritance rules and solid representation specifications

can be defined.

The Solid Modeller

The solid modeller serves the function of representing the physical solid models of the

product to be manufactured. The CSG modeller is used here because it can effectively represents

knowledge of the product at a higher level of abstraction and thus better able to support feature

modelling and extraction. It also provides the means for user interface and interpretation of the

model.

The Form Feature Modeller

The form feature modeller allows the definition of the nominal part geometry through a three

tier database. At the top level is a feature relationship graph which depicts both adjacency links

and child-parent links or primary feature-subfeature links. Primary features are major shapes

modified by subfeatures. Primary features therefore do not inherit any parameters from any other

features while subfeature inherit parameters from one or more features.

The second level in the form feature modeller database is the definition of each form feature

consisting of generic properties and instance data. The third level is the solid representation of the

199

form feature stored as a CSG tree of features producing volume of all features constructed

through Boolean operation. This is expressed in a context free grammar for CSG which is later converted to solid modeller interface. Such a form feature database can be extracted directly by a CAPP for process planning without the need for an interface for feature extraction and feature recognition.

Feature-Based }dodelling System

Solid Modeller i . ' I

Form Feature User Modeller I

Interface Precision Feature [

Modeller I

] [ Material Feature I Modeller

lntelli ent C omputer-Ai_ded Process Planning

_ ~ , Process Selection I

Machine Tools ] Selection

l Sequencing User Operations I

Interface Selection of Holding Devices

Operations and Machines Data

Process Optimization

I Cost and Time [ Analysis

Process Plan Output

1

System

I I I I

Product Database

Technological l)aLabase

Fig. 1 : Schematic diagram of the modelling system, the planning system and the databases.

200

Th.e Precision Feature Modener

The purpose of the precision feature modeller is to enable the definition of allowable

deviations from nominal form and size i.e dimensional tolerances and surface finish by creating a

library for generic precision features. These generic features can be instanced and attached to

form features and their geometric entities.

The Material Feature Modeller

The purpose of the material feature modeller is to associate material information with form

features. These information can be the material name, type, composition, physical and

mechanical properties, material processing and treatment, etc. Material features can be defined

and stored in a library. This again can be linked to a form feature.

Fig. 1 shows the main subsystems of the Feature based modelling system and the modules of the

intelligent generative process planner to be developed.

PROTOTYPE OF FEATURE BASED SYSTEM

Because of the complexities in the feature based modelling system, it is necessary to first

develop this system by prototyping with due consideration to multiple level representation (ref.9).

Several ideas for the prototype are proposed and tested. One of the most successful is discussed

in the following sections.

Part Fcalme Grammar

The part-feature structure can be described formally by a context free grammar for CSG,

G( Vn, Vt, P, S) where:

Vn denotes the set of non-terminals

= { <part>, <object>, <part-primitive>,<set operator>, <feature>, <movement> }

Vt denotes the set of terminals

= { cube, cylinder, cone, sphere, torus, wedge, union, intersect, difference,

x-translation, y-translation, z-translation, x-rotation, y-rotation, z-rotation }

S is the start symbol.

The set of P contains the following context-free productions listed as below:

<part>

<object>

<primitive>

<set-operator>

<feature>

<movement>

<sub-feature>

: := < o b j e c t >

::= <primitive> I <object> <set-operator> <object> I

<object> <set-operator> <feature> I <object> <movement>

::= cube I cylinder I cone I sphere I torus I wedge

::= union I intersect I difference

::= <primitive> I <feature> <set-operator> <sub-feature>

::= x-translation I y-translation I z-translation I

x-rotation I y-rotation I z-rotation

::= primitive

201

The def'mition of CSG in context free grammar lends itself to parsing in building a tree

structure that defines the constituents of the part. A parser uses a parsing algorithm along with the

CSG grammar and the universal primitive set to produce a CSG tree that corresponds to a given

sequence of compositions.

A bottom-up parsing strategy begins with the primitives and looks for productions rules

whose right-hand sides match sequence of adjacent objects that can be combined into a

constituent as identified by the left-hand side. Under an appropriate parsing algorithm such as the

Chart Parser, (ref. 8) the CSG tree for form feature can be derived.

BUILDING THE CSG TREE USING CHART PARSING.

For automatic process planning, the very basic geometric requirement is that the planning

system must know the type of feature as well as its dimension and orientation. By feature base

modelling approach, these features are defined by the designer at the beginning. These features

must be composed into a CSG tree so that geometric relationships between features are clearly

defined. The CSG tree is however not a unique representation scheme. A designer can arbitrary

create two or more different CSG trees to represent an identical object (ref. 9). A similar problem

also exists in the area of natural language processing (NLP) expressed in CSG notation.

Ambiguous syntactic structures do exist. In order to capture these syntactic structures, a good

parsing algorithm is necessary. Amongst the many parsing algorithms developed (ref. 8), chart

parsing offers a strategy that derives single or multiple syntactic structures without the overhead

of backtracking.

Chart Parsing

Often a parsing strategy tries to analyze a string as a constituent of a certain category in

natural language or primitive in solid modelling parlance. While doing so it recognizes the

categories of substrings. If it turns out that the whole string is not of the category hoped for, so

that the main parsing effort has to be abandoned, all the perfectly valid categories of the

substrings get forgotten too. Chart parsing tries to avoid wasting that effort. The central idea is

that all possible syntactic structures are represented in a data structure called a chart as soon as

they are found. (ref. 10)

A chart is a directed graph consisting of ordered collection of edges or arcs. Each edge has

two vertices, a starting and ending vertex and is denoted by a label. Each label depicts what the

syntactic category of the substring between the starting and ending vertex of the arc are and

comprises of two parts known as 'Found' or 'Unfound'; found part represents (parts of)

constituents already discovered and unfound part represents constituents which must still be

found to complete a partial analysis.

In general, the label of an arc is:

TotalCat = FoundCat... I UnFoundCat... in NLP or

Part -- FoundPrimitive... I UnFoundt~mitive... in Solid Modelling (SM).

202

Either FoundPrimitive... or UnFoundPrimitive... may be null as are FoundCat..+ or

UnFoundCat... in NLP. Arcs without UnFoundPrimitive in their label are said to be inactive; all

others are active.

The Parsing Process

A parse has been found when there is an inactive arc of the sought category from the

beginning to the end of the entire string.

The complete parsing process consists of iterations between two basic operations, namely

combine or fundamental event and the propose event. Before describing these operations the

following terminology are defined:

Let I, J, K ..... be integer variables over vertices in the chart.

Let X, Y, Z ..... be variables over constituents of the grammar.

Let [A], [B], [C],... be variables over (possibly null, []) strings of constituents.

The two basic operations, the fundamental event and the propose event, are discussed in the

following sections.

Fundamental Event

The fundamental event rule is stated as follows:

(i) x = [A] J Y [B] (J) (J) Y = [ C ] I [ ] (K) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

(I) X =[A]YI[B] (K)

unless the resulting edge is already present.

When an active edge from vertex I to J, looking for a constituent Y in its remainder meets a

complete edge from vertex J to K whose label bears a constituent Y then the two edges combine.

The result is a new edge from vertex I to vertex K whose remainder is the remainder of the active

edge reduced by the constituent Y.

Propose Event

The chart initially contains only inactive arcs, from the primitive elements of the sentence

that were fed in. For the fundamental event to take place there must be some active edges. An

active edge corresponds to a hypothesis about what may be present in the string. Hypothesis can

be formed either top-down or bottom-up. For natural language processing either strategy can be

used. But for composing mechanical parts, the bottom-up strategy of defining what the primitives

are and composing them by the composition grammar is more appropriate.

Formally, the bottom-up propose rule is stated as follows:

(I) X = [ A ] I [ ] (J) Y ::=X [C]

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

(I) Y = [ ] I X [ C ] (I)

unless the resulting edge is already present.

203

IMPLEMENTATION

The chart parsing strategy has been implemented in Pmlog. From the definition of the solid

modelling primitives, a CSG tree of the mechanical part is derived through the parsing process.

The CSG tree defines hierarchically the composition of the mechanical part. The details of each

primitive is spelled out by the set-up mode in which feature class/name is defined together with

geometrical properties and orientation with respect the world coordinates. The expert system for

automatic process planning can directly access the feature set-up database and generate process

plans from these feature definitions.

The sample consultation in the attached appendix illustrates the derivation a CSG tree for a

mechanical part as defined by the following CSG phrase: cube union cylinder intersect wedge.

The spanning arc from the starting vertex to the end vertex is given by the fourth argument of the

edge predicate. It defines in Prolog list notation the final CSG tree that is being built from the

primitives according to the CSG phrase.

CONCLUSION

The use of a chart parser in developing CSG tree is elegant. However the work done towards

the building of a feature based modelling system for automatic process planning is still somewhat

incomplete. In order that ambiguities that arises from the parsing effort can be resolved, the

system has m be supported by a geometric reasoner which checks the geometric relationships of

the various primitives. The features defined in the set-up model can then successfully drives the

automated process planning system.

REFERENCES

1 T.C. Chang, R.A. Wysk, An Introduction to Automated Process Planning System, Prentice- Hall, Englewood, NJ, 1985.

2 H.P. Wang, R.A. Wysk, Intelligent Reasoning for Process Planning, Computers in Industries, 8(1987), pp 293-309.

3 S. Joshi, N.N. Vissa, T.C. Chang, Expert Process Planning Systems with Solid Model Interface, International Journal of Production Research, 1988, Vo126 No 5, pp 863-885.

4 J.J. Shah, M.T. Rogers, Functional Requirements and Conceptual Design of Feature-Based Modelling System, Computer-Aided Engineering Design Journal, Feb. 1988, pp 9-15.

5 S.K. Sim, K.F. Leong, The Role of Solid Modelling in the Development of a Generative Process Planning System, MANUTECH 88, NTI Symposium on Manufacturing Technology, 1988, ppl 1-20.

6 M.E. Mortensen, Geometric Modelling, John Wiley & Sons, NY, 1985. 7 J.M. Martin, The Final Piece to the Puzzle, Special Report, Manufacturing Engineering, Sept

1988, pp 46-51. 8 T. Winograd, Language as a Cognitive Process, Vol 1, Addison Wesley Publishing Co.,

1983. 9 Y.C. Ime, K.S. Fu, Machine Understanding of CSG: Extraction and Unification of

Manufacturing Features, IEEE Computer Graphics & Applications, 1987, Vol 7 No 1, pp 20- 31.

10 S. Steel, A. De Roeck, Bidirectional Chart Parsing, Cognitive Science Centre, Department of Computer Science, University of Essex, Colchester CO4 3SQ, UK, 1986.

Quintus

Prclog

Release

1.5

{VAX/VM.S)

Copyright

(C)

1986

, Quintus

Computer

Systems,

Inc.

All

rights

reserved•

I ?-

[chartl,comprule,prim].

[LMPE:[MSKSIM~CHARTI.PL

consulted

(1.040

sec

6052 bytes))

[LMP

E: [MSKSIM)COMPRULE.PL

consulted

(0.080

sec 576 bytes)]

[LMP

E: [MSKSIM]PKIM.PL

consulted

(0.130

sec 74

8 bytes))

let •

parse (up) ,

CHART

PA~S ~ NG

Parse the following

CSG phrase

cube u

cylinder

n wedge,

Bottom up parse

FINAL CHART

edge (

l,pr

im,

[] , (prim(cube) ] ,2)

edge (

2, operator, [ ]

, [operator (u)) .

3)

edge (3~ prl

m. [] , [pr~m(cylinder[

I . 4

) edge (4, operator, [) ~ ]operator(n) ] . 5)

edge (

5, pri

m, [ ]

. [prim (

wedg

e) ] . 6)

edge ( 1,

feature. [p

rim[

, ] ]

, 1 )

edge (

I, feature, [ )

, [feature ( [prim (

cube

) ) ) ] , 2

)

edge (

i. Object. [p

rim]

. [] , I )

edge (

I, object, [ )

, [object ( [prim (

cube

) ] ) ) , 2)

edge (

3, feature. [p

rim}

. [ ]

, 3)

edge [3, feat=re. [I , [feature( [prim (

cylinder) ] ) ] . 4)

edge (

3, object, [p

rim]

, [[ . 3)

edge (3, obj

ect.

[ ]

, [ object ( [p

rim

( cy I inde r ) ) ) ] . 4 )

edge (5, feature. [p

rim]

. [ ] , 5

) edge (

5, feature, [] , [ feature [ ]prim]wedge) ] ) ] . 6)

edge (5, Object, [p

rim}

, [) , 5)

edge (

5, object, [ ]

, [ob

ject

( [p

rim

(wedge)) ) ] , 6 )

edge (

I, feature, [feature,0perator,

sub feature) , [) , i)

edge (

I, feature, [o

pera

tOr,

sub feature~,

[ I f

eature ( [prim (

cube

) ] ) ] ] , 2

) edge (

i, feature, [ s

ub feature ) , [ [ [ f

eature ( [prim (

cube

) 1 )

] , operator (u) ~

, edge (

1,pa

rt,

[obj

ectY

, [), i)

edge (

I, par

t. [ ]

. [pa

rt (

[ object ( [p

r im

(cu

be))

) ) I ~ , 2

) edge (

l,ob

ject

, {object,movement

1 , [] , i)

edge (

I, obj

ect,

[movement) , [ [object ( [prim (

cube

) I ) I ] ~ 2)

edge (

1, object ,

I object, movement, ob j oct ] , [ ] , 1 )

edge (

1, obj

ect,

[m

ovem

ent,

object ] , [ [object ( [prim (

cube

) ~ ) ] ] , 2

) edge (

1, obj

ect,

[O

bjec

t, operator, object ) , [ ] , 1 )

edge (

1, obj

ect,

[operator, ~bject ]

, [ [object ( [p

rim

(cub

e) ] ) ] ] , 2

) edge (

i, obj

ect,

[o

bjec

t) , [ [ [o

bjec

t ( [prim (

cube

) ]) ] , operator (u) [ ) , 3)

edge (

I, obj

ect,

[ ]

, [ob

ject

( [ [ [object ( [prim (

cube

) ] ) ] , o

perator (u) [ , o

bject ( [p

ri~

(c5'i

inde

r) ])

)) ]

,4)

edge (

I, par

t, [ ~

, [pa

rt ( [o

bjec

t ( [ [ [object ( [prim (c

ubel

] ) ] , o

perator (u) i , o

bject < [p

rim

(cyl

inde

r) 1 )

] ) ] ) ] , 4)

edge(l,object,

(object,operator,

feature], [3

,i)

edge (i, obj

mct,

[o

pera

tor,

featurel , I 1 o

bject ( Iprim (

cube

)) ) ] ] , 2)

edge (

i, obj

ect,

[f

eatu

re[

, [ [ [o

bjec

t ( [prim (

cube

[ ] ) ] , o

perator (u) ] ] ~ 3

) edge (

1, object , [ 1

, [ob

ject

( [ [ [object ( [prim (

cube

)) ) ] , o

perator (u) I . feature ( !p

rzm

(cy

find

er)

]) ]) 1,

4)

edge

(l,

part

, [ )

, [pa

rt (

[ob

ject

( [ [ [object ( [prim (

cube

) ] ) ) , o

perator (u) ] , ~

eatuze ( [

pri

m (c

ylin

der)

] ) ) ) ] ) ] , 4)

edge

(3,

feat

ure,

(feature.operate(,

sub

featurel, ~I, Z)

edge (

3, fea

ture

, [o

pera

tor,

su

b featu~e~. [ I f

eature ~ [p

r~m

Icyl

~nde

r! ~) ! ~ ~ ~)

edge(3,feature,

(sub

feature[

[~ feature{

pri~

c},li~e~l}

~cpe;at:~

: i

~ eJge!3~p~rt

ioD~ect~

[~ ~3}

edge(3,part,[],[part([object([prim(cylinder}])])],4}

~w~

edge(3,object,[object,movement],[],3)

edge(3,object,[movement],[[object([prim(cylinder)])]],4)

edge(3,object,

lobject,movement,object],[],3)

edge(3,object,[movement,object],[[object([prim(cylinder)])]],4)

edge{3,object,[objeet,operator,object],[],3)

edge(3,object,[operator,object],(Iobject([prim(cylinder)])]],4)

edge(3,obJect,[ebJect],[[[object([prim(cylinder)])),operator(n)]];5)

edge(3,object,[],[object([[[object([prim(cylinder)))],operator(n)],object([prim

(wedge)[)[)],6]

> edge(l,obJect,[),[object([[[object([prim(cube)])],operator(u)],object([[[object

([pri~(cyllnder)])],operatoz(n)),obj~ct(~primlwedge)])])])],6)

edge(l,part,[],[part([object([[[object([prim(cube)])),operator(u)],object{[[[ob

ject([prim[cylinder]])],operator(n)],object([prim(wedge)])))])])],6)

edge(3,object,[object,operator,

feature],[],3)

edge(3,object,[operator,

feature],[[object([prim(cylinder)])]],4)

edgQ(3,obJect,[feature],[[[object([prim(cylinder)))],operator(n)]],5)

edge(3,obJect,[[,[dbject([[[object([prim(cylinder)])~,operator(nll,~e~ture{[pr~

O m(.edge)][])[,~)

edge(1,object,[],[object([[[object([prim(cube)))].operator(u)].object([[[ob~ect

([prim(cylinder)])),operator(n)],feature[[prim(wedge)))))])],6)

edge(l,part,[[,[part([object([[[object([prim(cube)])],operator(u)],object([[[ob

Ject([prim(cylinder)])].operator(n)].feature([prim(wedge)])])])])).6)

edge(5.feature,[feature,operator,

sub feature[.]).5)

e~Q(5.foature,~operator,eubfeature~,[[feature([prim(wedge)])]].6)

> edge(5,part,[obJect],[],5)

edge(5,part,[],[part([object([prim(wedge

)])]

6)

edge(5,obJect,[obJect.movement].[],5)

edge[5,obJect,[movement],[[object([prim(wedge)])]],6)

edge (5,ob~ect. [object, movement,object).

[).5

) e~e(5,ob~ect,(movement,obJect],[~object([prim(wedge)~))[,6)

edgi(5,obj~ct,[obJectroperator,object],[],5)

edge(5,object,

(operator,object),

[[object([prim(wedge)))iB,6)

edge(5,obJect,[object,operator,feature],[],5)

edge(5,obJect,[operator,

feature],[[object([prim(wedge)~l]].6!

>

Spanning

Arc

edge(l,part,[],[part([object([[[ob3ect([prim(cube)]}],operatcr[ui,~,ch~eqti[c!

ject([prim(cylinder)])],operator(n)],object([prim(wedgel]}])!l]l~,6!

edge(l,part,[),[part([ob3ecti[[[object([prim(cube)!)]

o~er

atc~

r~u

i,chject

[[~t

ject([pri~(cylinder) il~cperatcr{n)],feature[[prir~;wedge)!i))~!~;~,~)

~#~

O >

yes

i ?-