CAD data visualization for machining simulation using the STEP standard

0 Journal of Manufacturing Systems

M Vol. zo/No. 3 l 2001

CAD Data Visualization for Machining Simulation Using the STEP Standard Arjun lyer, Graduate Research Assistant, Shiv G. Kapoor, Professor, and Richard E. LbVor, Professor, Dept. of Mechanical & Industrial Engineering, University of Illinois at Urbana-Champaign, USA

Abstract There is a need for the integration of computer-aided

design (CAD) information with manufacturing models, such as machining process simulation models, upstream with concurrent engineering activities. Because it is often difficult to interface various CAD formats with such applications, there is a need to stindardize input file formats, which then can be used by any module that has the appropriate interface. The STEP standard is a very useful standard for the neutral file format specification. The present work describes in detail the building of a STEP parser for the Application Protocol for Configuration Controlled Design of 3-D mechanical parts (AP203). Such a STEP parser is complemented with a visualization front end in the form of a Java applet, which is used to display the STEP entities in 3-D within a web browser over the Internet. The current work outlines a generic framework for a STEP parser module. Its use in the design and development of CAD-based process engineering applications is illustrated by example of a CAD interface to a machining process simulation program, which requires the workpiece CAD information, namely the surface geometry, to be machined to determine chip loads and hence cutting forces. The applicability of the STEP parser in the building of a CAD database cataloging system is also discussed.

Keywords: Neutral File, STEE Product Data Exchange, AP203, CAD, CAM, Visualization

Introduction The importance of the availability of computer-

aided design (CAD) information in product and process design and process visualization is increasing almost daily. In the concurrent design and manufacturing environment, the exchange of CAD information is essential. Due to the large number of CAD packages available, it becomes increasingly difficult

to transfer CAD information from one application to the other because the geometry information is presented in different formats specific to that CAD package. This problem is particularly difficult when research results undergoing proof-of-concept testing need to interface with CAD information.

The need to have a neutral CAD file format that is application independent was the main reason behind the development of standards such as IGES, STEP, and so on. The STEP file format can be used to store the geometry information and is supported by almost all of the CAD packages available today. The STEP standard defines a set of application protocols that relate to different areas in industry. The Application Protocol for Configuration Controlled Design (AP203) specifies the structures for the exchange of configuration-controlled, three-dimensional product definition data for mechanical parts and assemblies. The AP203 specification can be found in Gilbert (1994). The complete list of STEP application protocols under development and their status can be found at http://www.scm.org/uspm/aps.html.

Figure I shows the stages of the technology development life cycle. To the left is the basic and applied research as might be conducted in a university setting. At the extreme right is the commercial- ized technology in product form. To move research results to this point requires proof-of-concept testing, which generally requires some level of technology integration, often in the form of interfaces between the emerging technology and some existing commercial technology(ies). For the problem

EWdapplll research Pmof-ohonceptbetatestlng Pmduci design illdusmal applii

Figure 1 Technology Development Life Cycle

commercializalbn

W

198

Journal of Manufacturing Systems Vol. 2a/No. 3

2001

addressed in this paper, an emerging technology for manufacturing process analysis, namely machining process simulation programs, requires information on part geometry, generally available through existing CAD-based products such as Pro/ENGINEER@, AutoCAD@, etc. The STEP standard provides the necessary CAD-interface required in the product design stage by prescribing a neutral file format to facilitate CAD-information transfer. But, in order for this CAD information to be utilized at the proof- of-concept testing stage, an interface is required that can understand STEP information and present it to the module used for beta testing. Machining process model research in the form of a machining simulation code, such as FMSIM, can benefit from the CAD interface. FMSIM is a face milling simulation program developed at the University of Illinois at Urbana-Champaign. The program predicts cutting forces and stability and may be used in conjunction with other programs to predict part surface errors due to machining forces (Gu et al. 1997). other face milling simulation programs exist, and what is common to all is the need to import complex part feature geometries to the simulator in order to predict cutting forces during the machining of that feature. The work described here involves the development of such an interface.

Figure 2 shows how the CAD interface fits in the overall scheme. This interface should have flexible visualization capabilities and enable, for example, 2-D feature selection from the 3-D representation of the part. This interface will provide for visualization of the STEP entities as well as provide a generic parser for the STEP file that pertains to the AP203 schema.

The objective of the current research is twofold: (1) to develop a generic STEP interface, using the STEP Tools Inc. library, which will facilitate the retrieval of entity information from a STEP file that is based on the AP203 schema, thereby bridging the gap between the CAD representation of the product data and the application program (see Figure 2), and (2) to develop a visualization module that can be used to display the 3-D model of the entities the STEP file represents and enable part feature selection. This will provide a graphical interface to the STEP data and will facilitate feature selection from the STEP data file, which can be forwarded to the application program, such as machining simulation, for beta testing.

Figure 2 CAD Interface to Proof-of-Concept Testing

STEP and the STEP Components STEP, the Standard for the Exchange of Product

Model Data, is a comprehensive IS0 standard (IS0 10303) that describes how to represent and exchange digital product information. Digital product data must contain enough information to cover a product’s entire life cycle, from conceptual design to engineering analysis, manufacture, process monitor- ing and quality control testing, and product support functions. To do this, STEP must cover geometry, topology, tolerances, relationships, attributes, assemblies, configuration, and more.

STEP is built on a language that can formally describe the structure and correctness conditions of any engineering information that needs to be exchanged. Industry experts use this language, called EXPRESS, to detail the information required to describe products of that industry. EXPRESS is an object-oriented information model specification language developed to write formal information models describing mechanical products. These application protocols form the bulk of the standard and are the basis for STEP product data exchange. The Application Protocol for Configuration Controlled Design (AP203) specifies the structures for the exchange of configuration-controlled three- dimensional product definition data of mechanical parts and assemblies. The AP203 specifies the following subsets:

. Configuration Management (e.g., authorization, release, etc.);

199

Journal of Manufacturing Systems Vol. ZOINO. 3 2001

l Geometric Shapes (e.g., advanced B-rep solids, faceted B-rep solids, etc.);

. Product Structure (e.g., assemblies, bill of materials, etc.);

l Specifications (e.g., surface finish, material, and so on).

The AP203 schema consists of a collection of entities each subclassing from one or more entities and thus forming a hierarchy of entities. There are many such independent hierarchy trees that present different representations of the entities involved.

A detailed explanation of the STEP standard can be found in Helpenstein ( 1993), and a brief exposure to STEP can be found in Shah and Mathew (1991). The usefulness of STEP in design for assembly (DFA) is discussed in Liu and Fisher (1995). Here the authors discuss the design of a structured code representation of part assemblies using STEP that will reduce the burden of assembly information extraction. A geometric data transfer framework similar to STEP is discussed in Kroszynski et al. (1989). The use of STEP for the purpose of extraction of product data along with the geometry information can be found in Qiao et al. (1993) and Clark and Staley (1995). This work aims at establishing a schema suited to extraction of product data for computer-aided process planning (CAPP). This schema is then converted to object-oriented classes for use in a computer-aided environment and for efficient retrieval and inspection. Most of the above work deals with the utilization of the STEP standard for a particular application at hand and, as a result, gets less generic; however, no previous effort has been made to work with the AP203, which details three- dimensional product data for mechanical parts and assemblies.

The present work exclusively concerns the AP203 schema, which will provide the required interface between the CAD information repository of mechanical parts and the module responsible for proof-of-concept testing. The schema is available in the EXPRESS language, which is object-oriented and facilitates the creation of corresponding software classes in a computer-aided setting. The EXPRESS language is explained in Schenk (1994).

Development of the STEP Parser Any application that requires CAD information

Fign~~ 3 Joint Face of Engine Cylinder Head

as input for execution can utilize the functionality of the STEP parser. Figure 3 shows a joint face of an engine cylinder head, which is a typical example of CAD geometry information that can be extracted by the STEP parser. The applications considered here are machining process simulation programs that use such workpiece CAD information for calculation of cutting forces for visualization modules that display geometrical entities in 3-D for feature selection. The STEP parser can also be employed in the construction of a STEP repository that may contain a collection of AP203 entities. The STEP parser can be used in such a system to check out STEP entities from the repository, which can then be used in an assembly configuration system. Still another application is in automatic machining process planning systems, which rely heavily on feature recognition algorithms.

The process of reading a STEP file for the purpose of extracting CAD/product information from it involves interacting with two different files, that is, the EXPRESS file describing the entities supported by the AP and how those entities are represented, and the STEP file containing the actual data in con- formance to the AI? In other words, the program must be able to parse the STEP file based on the rules described in the EXPRESS file. This is done with the help of a library of software developed by STEP Tools Inc. The library provides functions to read the STEP file into memory and handles parsing of the EXPRESS syntax. The EXPRESS Compiler is used to generate C++ classes for the entities present in the STEP file. These classes are then extended to add functionality for the specific purpose at hand. Using these extended classes4 it is possible to parse and manipulate the entities and extract information from them.

The development of the STEP parser involves the following stages:

200

Journal of Manufacturing Systems Vol. 2a/No. 3

2001

1. Creation of corresponding C++ classes from the EXPRESS AP203 schema. This is done using the EXPRESS Compiler that comes as a part of the STEP Tools library;

2. Extending these C++ classes to add specific functionalities, such as printing itself out, which allows them to output the entity information in a desired format;

3. Parsing the entities in the STEP file that are arranged in a hierarchy based on the specifications and interrelations defined in the AP203 schema. For complex entities, the parsing entails performing local geometric transformations and interpolations, to simplify the output representation, and storing the output information in a desired (B-rep) format.

The following subsections describe each task.

EXPRESS-to-Ctk Mapping Using the EXPRESS Compiler

The EXPRESS Compiler (called expes.s2c++), which is shipped with the STEP Tools library, first reads the EXPRESS file and converts the various entities described into equivalent C++ classes using certain rules. The classes thus generated are called ROSE++ classes in the software library. This is possible because the EXPRESS language is also object- oriented and is built on the same concepts as C++. The EXPRESS syntax defines a schema called pic- ture using the Point, Line, Circle, and Text entities. Access methods are automatically added to the attributes of the class that aid in data retrieval.

Extending the C* Classes Code generators such as the EXPRESS Compiler

are effective, productivity-enhancing tools for software development. However, they are often subject to one weakness, that is, the generated code might be manually extended and extensions might be lost if the code was regenerated. However, the extclass tool (supplied with the STEP Tools library) makes it possible to add your own extensions to a generated C++ class. As shown in Figure 4, the express 2c++ tool generates the .h and .c files, whereas the .hi, .hx, and .cx files are generated by the extckzss tool. All the new header files needed to support the extension are placed in the .hi file. The new method declarations go into the .hx file, and the actual implementation of the methods added is placed in the .cx file. In this

201

Fignm 4 Extension of EXPREXWC++ Classes

manner, the generated C++ code can be extended to include application-specific data and functions without modifying the generated C++ code. The C++ classes can then be regenerated without worry should the EXPRESS schema change. All the new methods that were added were print methods that would output all the data present in the entity concerned in a certain format. Thus, by defining the print method as a virtual in C++ terminology, one can overload the method in the subclasses to handle data retrieval from the entire hierarchy of entities.

Descending the AP203 Hierarchy Any solid model part can be saved in the STEP

format in four different subformats. These include the solid, wirefiame, surjke, and shell formats. Each one of these subformats descends the AP203 hierarchy along different paths, and the STEP parser thus has to be a “generic” parser that will deal with these differences in a transparent manner. Figure 5 depicts the different formats and the corresponding class traversal path down the AP203 hierarchy up to the surfaces (Chang 1990). As shown in the figure, the traversal tree is rooted at shape_defy- nition_representation and then proceeds down depending on the format used to save the STEP entities. Thus, a part saved as a STEP file in the Surface format will have a set of curve_bounded_surjizce entities as the surfaces, whereas a STEP file saved as Solid will have the corresponding surface information as a set of advanced*ce.

Figure 6 shows a portion of a STEP file saved in the Surface format. As shown in the figure, the entity hierarchy is rooted at shape-definition-representation, which refers toproduct_defznition_shape and geometrically_bounded_sur$ace_shape_representa- tion through the #I131 and #2123 reference num- bers. These classes referred to hold references to other classes. The class hierarchy that this set corre-

Journal of Manufacturing Systems Vol. 2a/No. 3 2001

shape_deflnitlon_mp

1 GSOlllSlliWlly_bWlldSd_SUd_surfaca_shapa_repr

1 Gacnlstrk_sst

1 Cutva_hcunded_stsface

#1132=SHAPE_DEFINITION_REPRESENTATION(#1131,#1l23);

#113 l=PRODUCT_DEFlNITION_SHAPE( “,‘SHAPE FOR

PRTOOO1.‘,#1130);

# 1 l23=GEOMETRlCALLY_BOUNDED_SURFACE_SHAPE_REPRE-

SEN’IATION(“,(#21 1),#1122);

#21 l=GEOMETRIC_SET(“,(#210,#274,#337,#400,#463,#672,#735,#798,

#861,#924,#1019,#1114));

#1122=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_

UNCERTAINTKASSIGNED_CONTEXT((#l lZl))GLOBAL_

UNIT_ASSIGNED_CONTEXT((#1l18,#1l19,#1 lZO))REPRE-

SENTATION_CONTEXT(‘ID2’,‘3’));

#21O=CURVI_B0UNDED_SURFACE(“,#85,(#123,#160,#209),.E);

Shape_.deiinilion_rep

1 Figure 6

~ced_~P_StW_Wesanepe_represen$tion

1 llWllfdd_solM_brep 1

clcsed_shell

1 advan&_face

STEP File in Sorface Format

Shape_deflnii_ra+wenbkm

Shape_.definitkm_~

1 manifold_wface_shaPe_mPrewtaUon

1 shell_based_sutface_model

1 chwd_shsWopen_shell

1 faE_.dace

Figum 5 Fignw 7

AP203 STEP Hierarchy Surfwe Hierarchy in AP203

sponds to is shown in Figure 7. Thus, the shape_def- inition_representation holds a reference to a representation that in turn refers to a representation-item. The representation-item has two subclasses, that is, geometric-representation-item and topological_ represen ta tion_item , The geometrical_represen ta- tion_item further has surface and geometric-set as its subclasses. Each geometric-set refers to a set of geometric_set_select that can be a plane, curve, or surface. For the case shown, it is a curve-bounded-surface that is a subclass of surjke.

entities depends on the representation of the entity within the STEP file. The interpolation of a B-spline curve is obtained by iterating over the curve using the parameterized function for a nonuniform rational B-spline curve (NURBS). A NURB is represented as follows:

Interpolation of Coordinate Points While Parsing Nonlinear Entities

The final output from the STEP parser consists of discretized linear segments representing any nonlinear entity such as a B-spline curve or a circular arc. In parsing the various nonlinear entities in the STEP file, interpolation of points along the boundary of

(1)

where C(t) is a point on the curve, p is the order, A&, are the B-spline basis functions, P, are control points, and the weight wi of Pi is the last ordinate of the homogeneous point pi” .

The interpolation of a circle oriented along an arbitrary plane, however, involves rotation about an arbitrary axis in 3-D space. Because the technique for rotation about a coordinate axis is known, the

202

Figure 8 Rotations Required to Make Unit Vector OP Coincident with z-Axis

underlying procedural idea is to make the arbitrary rotation axis coincident with one of the coordinate axes.

To make the arbitrary axis coincident with the z- axis, first rotate about the x-axis (by an angle a) and then about the y-axis (by an angle p). These angles are given by (see Figure 8):

cosp = d; sii$=c,.

The complete transformation matrix is given by:

where [7”l denotes the translation matrix to the origin, [RX] denotes rotation about the n-axis, and so on.

Representation of Output from STEP Parser A boundary representation (B-rep) is used to

store the geometric information contained in the STEP file locally. A B-rep consists of a hierarchy of entities, which together represent the boundary of the model in consideration. The hierarchy tree is rooted at the object and each object has a set of surfaces, which in turn have sets of external and inter- nal boundaries. These boundaries are composed of edges. Edges can be linear or parametric and are constructed from end points or control points in the case of B-spline curves. B-rep is used because a B- rep can support a variety of mathematical surfaces, including the most versatile one, that is, nonuniform rational B-spline (NURBS). Also, in the B-rep data structure, faces and edges are readily available, together with a wealth of algorithms and functions,

Journal of Manufacturing Systems Vol. 2OMo. 3

2001

to either extract required geometric information or modify the 3-D model of the workpiece.

Development of Java Applet The applet uses the output file created by the

STEP parser to display the part in 3-D within the browser context. It uses a B-rep of the part and dis- plays the part as a collection of surfaces having exte- rior and interior boundaries. A hierarchical data structure is used within the Java applet that allows storing all the surfaces parsed from the STEP file. At the time of drawing the wireframe representation of the object, this data structure is traversed top to bottom, which essentially entails drawing the boundary lines that enclose the object. In addition to the wireframe representation, there is provision for rotation, scaling, and translation of the object along the three axes. The object manipulations such as rotation, translation, and scaling are accomplished by the use of appropriate transformation matrices.

Rendering the Model Once all the surfaces are parsed, they are sorted in

the order of increasing depth (z-coordinate). However, here the standard sorting algorithms such as quick sort cannot be employed. Because the tran- sitive property does not hold good here, two surfaces have to be compared at a time, and this leads to a higher order in terms of efficiency. These surfaces are then painted (rendered) in the reverse order of depth (farthest rendered first) according to Painter’s algorithm.

In case of surfaces having interior boundaries, the rendering procedure is slightly modified as Java does not support a flood-fill function for such surfaces. Here each of these surfaces is triangulated, and each of these triangulations is, in turn, rendered. A standard triangulation algorithm is used here that partitions each surface (with interior boundaries) into several triangles that can then be flood-filled.

Shading of the model is completed by calculating the angle between the surface normal and the direction of light source. The cosine of this angle will then relate to the gradation from the foreground to the background color.

The use of Java greatly eases the software development process because the same module can be used on any operating system platform and can provide a seamless interface to the client in the form of

203

Journal of Manuf~turing Systems Vol. 2otNo. 3 2001

a web browser. Java also makes the interaction between the web browser and the server process more streamlined because Java does support program execution on the web server by the use of CGI (common gateway interface) protocol. This not only makes it highly convenient for the end user but also simplifies the developer’s task by making the framework web-centric rather than PC-centric. Con- sequently, the utilization of the software is increased by several orders of magnitude due to the sheer expanse of the World Wide Web.

For the end user, this translates to no installation of any software in the local environment. With the use of a web browser, the end user can upload the STEP file to the web site, select the desired surface of the object, pass on the surface information to the simulation process residing on the web server, and thereafter view the results of the simulation in a graphical format within the context of a web browser.

Applications of STEP Parser Framework

The objective of the present work is twofold. First, the development of the STEP parser will elim- inate the need for a special accommodation when interfacing with specific CAD packages whenever some geometric input is required within an application. Second, the process of CAD information selection becomes more interactive with the visualization module, which is closely coupled with the STEP parser. Some of the examples described below eluci- date the applicability of the present work in an automated manufacturing planning environment.

STEP Interface

Figure 2 finds immense applicability in providing a CAD interface to simulation programs that require CAD input for execution. The machining process simulation program (FMSIM) for face milling requires the workpiece geometry information for calculation of workpiece-tool intersections in pur- suit of chip load and hence, cutting forces. In auto- motive powertrain applications, an engine block, cylinder head (see Figure 3), or transmission casing are all examples of parts that produce complex, mul- tifeatured CAD models with surface geometry information that must be transferred to a program like FMSIM. To facilitate the CAD information transfer

to the FMSIM, the STEP parser module can interact with the STEP file of the workpiece, allow feature selection via the front-end user interface (Java applet), and then pass on the required surface information to the simulation program.

The STEP Viewer software testbed illustrates the working of the STEP parser and the Java applet over the World Wide Web (h ttp://mtamri. me. uiuc. edu/ testbeds/modeZLhtml). Any user can upload a STEP file to a web server and view it as a three-dimensional solid within the applet context of the web browser. This software testbed presents the rendered as well as the wireframe representation of the STEP part that the user uploads. The applet allows the selection of a surface, which is then passed on to the simulation program.

Once the part is shown within the web browser, the user can:

l Rotate the part along the axes; l Toggle a and wireframe

put; l Select any particular surface of

surface information can then be passed to a simulation testbed such as FMSIM,

needs as input.

Design software testbed, shown

and a server-side module. The interface HTML JavaScript, whereas the

C++. display applet is coded entirely The communication between the and server modules is established via the

protocol. when user uploads a STEP the file the server program for pars-

ing. All the entities the STEP file are and stored locally, and the output the parser (which is a local the part) is taken as input to Java applet, the model within the applet context of browser. the speed of overall execution, most of interpolation is done the server end. Interpolation

most of entities (for example, are stored form

within the file. Computation the client end for rendering and

the model.

204

Journal of Manufacturing Systems Vol. 20Mo. 3

2001

Schematic of OwrnU STEP Viewer Software Teatbed Design Surface Selectton Using MINIBLOCK Case Study

Figure 10 shows, using a MINIBLOCK test part, how an end user can upload a STEP file, view it in 3-D within the web browser context, select the desired surface, and view the 2-D representation of the surface. This surface can thereafter be passed as an input to the FMSIM program. FMSIM is a simulation testbed for the face milling process and can be used to predict forces, vibrations, surface finish, and flatness when a workpiece is flat milled. It can also be used to study the stability of the face milling process by means of stability charts and vibration- level diagrams. Thus, by using FMSIM, the design process can be pushed upstream because one can get a good estimate of the cutting process (force, vibrations, surface finish, and so on) even before actual- ly machining the part. FMSIM can be used as a tool by process planners to determine the best possible cutting conditions for a particular face milling operation. In addition, the effect of fixturing on the cutting forces and surface flatness errors can be inves- tigated to determine the best locations for clamping.

Figure II X-Force Plot from FMSIM

The FMSIM software application simulates the face milling machining operation for a given set of tool geometries and cutting conditions. The outputs from FMSIM include the cutting forces and given workpiece compliance information as could be obtained from a finite element analysis, workpiece flatness predictions.

Figure II shows the force plot for the MINIBLOCK surface selected in Figure 10 now imported into FMSIM. As the simulation progress- es, the cutter moves across the surface at a constant feed rate, stopping every o” of rotation to determine the cutting insert intersections with the surface. Thereafter, the cutting coefficients calibrated for the given combination of workpiece and tool material are used to convert the chip-load values into cutting

forces. As such, it is a semi-empirical method because only the cutting coefficients are calculated empirically, whereas the chip loads are obtained during the simulation by calculating actual workpiece- tool intersections. The X-direction (feed direction) forces shown in Figure II are an average force for each cutter revolution. Subsequently, the force data are transferred to a finite element model for the part, which meshes the workpiece surface and outputs the desired surface error and flatness properties at each node in the mesh. This is done by calculating the force values at each node of the mesh and using the modal displacement values to calculate the surface properties (finish/flatness) at each node. Inter- polation within nodal elements is used to construct a contour plot for flatness and finish, as shown in Figure 12. The entire process can be summarized as follows:

1. The user creates the STEP file of the part from a CAD application, for example, Pro/ENGINEER@‘.

205

Journal ofManufacturing Systems Vol. 2OMo. 3 2001

1 File Plot 1

Face Milling Simulation Interface Universi

.x of Illinois at U-C

Copyng t 1993,1994,1995

I 5.17WWE-W 2.04QwoEm

-1 .DW804Eo5

4232lWEo3

-7.900533E43

-1.-a

-1.9MlZ8EU2

-1.677703E~

-l.WlWU?

-z--m

-2.618(m-W

Zoom

I In

I out

Rotitaan

*,

I-4

IIScale lY%irlm

r-l Help

Figure 12 Surface Error Contour Plot from FMSIM

This file is uploaded to the web server by using HTML forms and JavaScript;

2. The STEP parser is run and it parses the uploaded file, and a local file is created that has all the entities retrieved in a B-rep format;

3. The Java applet then reads this local file and dis- plays the 3-D view of the part within the web browser;

6. FMSIM uses the surface information to calculate the cutting forces and passes the cutting force and surface information to a finite element package for analysis;

7. The mesh information generated from the finite element analysis is used to construct the surface error/finish contour plots as shown in Figure 12.

4. The part can be seen as a wireframe representa- Cataloging Database of STEP Entities tion or as a shaded solid. The user then rotates the part as needed and selects the desired surface whose dimensions are to be further used as input to a simulation program such as the face milling simulation program (FMSIM). This could be generalized to include selection of any arbitrary feature from the part shown;

5. The surface (feature) selected is then passed to the appropriate program using JavaScript and CGI function calls;

The STEP parser can be used to develop a catalog of the entities defined in the AP203 schema. This database can be used to store commonly accessed AP203 parts for later retrieval. Thus, by developing a suitable front end to view/manipulate the parts, the database can be changed to hold desired designs of the parts concerned. This could prove to be immensely useful in an assembly design effort; the database could be searched for the assembly components and, using the front end provided, changes

206

Journal of Manufacturing Systems Vol. 2omo. 3

2001

could be made to the dimensions and the assembly could then stored back in the database for later use. An initial effort is made to model most of the mechanical parts to be included in the database. Once this has been achieved, assembly attribute manipulation can be achieved using the STEP interface that has been developed.

The front-end visualization module has to provide interfaces for entity manipulation, such as for dimensioning, which has to be propagated to the STEP file via the STEP parser module. Thus, the STEP parser would have to include support for writ- ing to STEP files as well. This can easily be achieved by adding suitable methods to the C+t- classes for entity manipulation apart from retrieval. Thus, the extended classes could contain appropriate write methods, which will expose changeable attributes of the entity.

Application of STEP Parser in CAPP Process planning is that function within a manu-

facturing environment that establishes which processes and parameters are to be used to convert materials from an initial form to a predetermined final form. Process planning may be defined as the act of preparing detailed work instructions to produce a part. Computerized process planning systems can help reduce process planning time and increase plan consistency and efficiency (Chang 1990, Maropoulos 1995). The STEP interface can also be used to aid process planning systems wherein the process plan for a new part is automatically synthesized.

There are two major computer-aided process planning (CAPP) techniques: variant and generative. Variant process planning implements an indexing scheme by which a process plan for a previously planned part is retrieved based on the planned part’s similarity to the new part. In a generative process planning system, a part model (usually feature based) is utilized to build up a process plan from scratch. From the fully described geometry, parameters are derived to determine applicable processes and resources, which constitute the product model data. Generative systems make use of current resource data and manufacturing knowledge and base plans on an electronic part model (possibly feature based) rather than on an existing plan. Generative systems inherently allow a high level of flexibility, making them particularly well suited to

Exl8lldsdsTEPpersec ~__.____.____._.__._.--.--------- ,-

l-----l mlduct mod.81 dsts

Application of STEP Parser in a CAPP System

function across many classifications of parts and under varying resource conditions.

Generative CAPP systems create the process plan from information available in a manufacturing database without human intervention. The STEP parser can be used to convert CAD data into product model data, which then can be directly used in a CAPP system (Zhang, Hou, and Wang 1995). For the planning process, a detailed and precise model of the part is necessary. Engineering drawings are not only represented by geometry elements but also are supplemented with drafting symbols (hatch, tolerances, roughness symbol, etc.) and text. As STEP covers all these attributes, it proves to be an ideal standard for establishing a CAD interface to a CAPP system. The STEP parser can be used for the transformation of a graphics model of a part into the product model, which is probably the most important and most difficult interface task in process planning. This would require the addition of an automated feature recognition module in the framework. Transformation of the graphics design model of part into a product model is achieved by the following steps (see Figure 13):

1.

2.

Identification (recognition) of overall shape: This requires some expert system built into the system that will compare the features with those stored in the database of STEP entities. The expert system will use the capabilities of the STEP parser for its working and thus will have an interface to the STEP parser. Decomposition of overall shape: This is achieved through the feature-recognition module, which also interfaces with the STEP parser. The features present in the local STEP file are extracted by the STEP parser by traversing the

207

Journal of Manufacturing Systems Vol. 2a/No. 3 2001

hierarchy of entities and recognizing the groups that form a feature. The grouping information is stored in the feature recognition module, which also interfaces with the STEP database.

3. Identification of surface properties: The surface properties may include geometric properties such as surface normals or properties that are needed for planning a sequence of operations that need to be undertaken to create the surface. These include surface finish, tolerances, and so on. These are obtained from the STEP file itself via the STEP parser.

4. Transformation into product model: This is triv- ial when using STEP entities because the information is stored as part of the model.

This transformation task is called geometric emsing or CAD interjke refinement (Chang 1990). As shown in Figure 13, the STEP parser can be used to form the kernel of the CAPP system, with other needed modules built around it. Definitely there is a need to carefully study the requirements of the CAPP system and thereafter design the additional interfaces that the STEP parser would need to expose. Once this is done, more specific layers can be built on top of the generic kernel to achieve the desired objective, such as feature recognition or any other function.

Conclusion A generic STEP parser for AP203, which is the

application protocol for configuration-controlled design of mechanical parts and assemblies, along with the visualization module as a Java applet has been successfully built. More specifically, the following were accomplished:

l The STEP parser was built by using the application procedure interface provided by the STEP Tools library.

l The output of the STEP parser is a B-rep of the entities present in the STEP file in a local format, which can ease interfacing with other modules that need a simpler interface to the CAD data contained in the STEP file.

l A Java applet was built as a visualization module, which depicts the entities in the STEP file in 3-D within the context of a web browser. The

applet uses the output of the STEP parser to ren- der the model.

l The Java applet supports simple geometric operations such as rotation, translation, and scaling and also supports shading for simple models.

l Various applications of the STEP parser were mentioned, including machining process simulation, building STEP repositories, and computer- aided process planning (CAPP).

The present work will be greatly beneficial in applications where a standard interface to CAD information described in the AP203 schema is required. The STEP parser is useful to support R&D work on machining process simulation and computer-aided process planning in a proof-of-concept testbed environment. Also, the utilization of the output of the STEP parser can be generalized and appropriate 3-D display routines coded so as to allow selection of arbitrary features from the model.

Acknowledgments The authors gratefully acknowledge the Machine

Tool Agile Manufacturing Institute (MTAMRI), the National Science Foundation (NSF), and STEP Tools Inc. for financial support and help.

References Chang, T.C. (1990). Expert Prveess Planning for Manufacturing. Reading,

MA: Addison-Wesley. Clark, A. and Staley, A. (1995). “STEP AP203 data exchange study.” 3rd

Symp. on Solid Modeling and Application. New York: ACM. Gilbert, M. (1994). “Conftgumtion controlled 3D designs of mechanical

parts and assemblies.” Technical Report IS0 TC 184/SC4/*WG4 N60 1 (P6-1). Grumman Data Systems.

Gu, F., Kapoor, S.G., DeVor, R.E., and Bandyopadhyay, P. (1997). “‘An enhanced cutting force model for face milling with variable cutter feed motion and complex workpiece geometries.” Journal of Mf. Science and Engg. (vllg), ~~467-475.

Helpenstein, H.J. (1993). CAD Geometry Data Exchange Using STEP Springer-Verlag.

Rroszynski, U.I., Palstroem, B., Trostmann, E., and Schlechtendahl, E. (1989). “Geometric data transfer between CAD systems: solid models.” IEEE Computer Gmphics & Applications (~9, n5, Sept. 1989), ~~56-71.

Liu, T.H. and Fisher, G.W. (1995). “An assembly code classification and coding scheme based on a STEP mechanical product model.” ASME i’kns. (~8, Mar. 1995), ~~33-46.

Maropoulos, PG. (1995). “Review of research in tooling technology, process modeling and process planning. Part II: Process planning.” Computer Zntegmted Mfg. Systems (~8, nl), ~~12-20.

Qiao, L.-H., Zhang, C., Liu, T-H., Wang, P.B., and Fisher, G.W. (1993). “A PDES/STEP-based product data preparation for computer-aided process planning.” Computers in Industry (Aug. 1993), ppl l-22.

Schenk, D.A. (1994). Information Modeling: The EXPRESS Way. Oxford Univ. Press.

Shah, J.J. and Mathew, A. (199 1). “Experimental investigation of the STEP form-feature.” Journal of Computer-Aided Design (~23, May 1991), pp282-296.

208

Journal of Manufacturing Systems Vol. 2OMo. 3

2001

Zhang, S., Hou, X., and Wang, Z. (1995). “STEP application protocol inter- operability for CADKAPP integration:’ In Computers in Engg.-1995 and Pmt. of 1995 Da&base Symp. (New York: ASME), pp687-90. Presented at 15th Annual Int’l Computers in Engg. Conf. of 9th Annual ASME Engg. Database Symp.

http://www.scra.org/uspro/aps.html. Application Protocols.

Authors’ Biographies Arjun Iyer received his B.Tech degree in 1996 from the Indian Institute

of Technology, Rharagpur, India. After completing a master’s in mechanical engineering at the University of Illinois, he moved on to another degree in computer science. During his tenure in the mechanical engineering department, he worked on sofhvare testbeds, applicability of STEP as a viable CAD exchange format, and application of CAD in ball-end milling of freeform surfaces. His main areas of interests include CAD/CAM and object-oriented programming.

S.G. Kapoor is the James W. Bayne Professor in the mechanical and industrial engineering department at the University of Illinois at Urbana- Champaign. He is the dimctor of the NSF IndustryAJniversity Cooperative Research Center of Machine Tool Systems at the University of Illinois. He is also an editor of the ASME Journal of Manufacturing Science and Engineering. His research interests include modeling of machining and machine tool systems, CAD/CAM, and engineering statistics.

R.E. DcVor is a Distinguished Professor of Manufacturing at the University of Illinois at Urbana-Champaign. He serves as the director of the NSF/ARPA Machine-Tool Agile Manufacturing Research Institute (MTAMRI), a multi-university collaborative research and graduate educa- tion program. Dr. DeVor has numeTous publications in the areas of mecha- nistic modeling for metalcutting processes such as drilling, end milling, boring, and so on. His research interests include ma&ii and machine tool systems, quality control, and industrial statistics.

209

Documents

CAD data visualization for machining simulation using the STEP standard