- Email: [email protected]
Constraint resolution using optimisation techniques
Computers & Graphics 25 (2001) 483–492
Technical Section
Constraint resolution using optimisation techniques Glen Mullineux* Department of Mechanical Engineering, Faculty of Engineering and Design, University of Bath, Bath BA2 7AY, UK
Abstract Constraint-based CAD systems are useful for handling design applications in which the precise rules are not known beforehand. The designer can introduce new constraints as these become apparent as the design task proceeds. A variety of ways for resolving constraints currently exist. This paper considers the use of a direct search optimisation approach. It is shown that this has the advantage of being able to handle a variety of different applications and that problems of under- or over-constrained systems no longer exist. A software system using this approach is introduced and its application to a number of areas is illustrated, including typical problems from computer-aided sketching, assembling modelling and mechanism simulation. # 2001 Elsevier Science Ltd. All rights reserved. Keywords: Constraint modelling; Constraint solving; Optimisation; Assembly modelling; Mechanisms
1. Introduction Computer aided design (CAD) systems have found uses in a large number of application areas. Since commercial systems tend to be general purpose engines, there have been a number of attempts to tailor them to more specific applications. Many of these have relied on the underlying user language of the system and the use of parametrics is one such case [1,2]. When the application area is well understood, rule-based expert systems provide a means for capturing that information for the less experienced user [3,4]. These can be used to control the CAD system via its user language. In the more general design situation, a designer is often meeting a task for the first time. In such cases the precise rules which apply are not immediately obvious. What are clear are some of the constraints which bound what can be done. These might include limitations on weight or size or allowable forces. As the design proceeds more and more constraints emerge. These are often in conflict and the designer’s skill is in deciding which can be comprised with reasonable safety. The use of constraint-based systems has emerged recently [5–8]. Often these systems underlie sketching *Tel.: +44-1225-826159. E-mail address: [email protected] (G. Mullineux).
software and the constraints relate to the geometry involved particularly in relation to the underlying cartesian coordinates of points. A range of solution techniques exist. It is generally acknowledged that there is a range of constraints that need to be considered, ranging from the purely geometric to more complex engineering considerations. However, the constraint resolvers employed do not generally seem designed to handle this range satisfactorily. This paper proposes that resolution techniques based upon mathematical optimisation provide a means for handling all the various different types of constraint within a single unified approach. While more sophisticated means of solution certainly exist, they depend upon specific forms of constraint. Optimisation strategies, particularly those based on direct search techniques, require only the ability to be able to evaluate the imposed constraints. Problems of too many or too few constraints are not a problem and indeed the optimisation approach allows best compromise solutions to be obtained when constraints are in conflict. Furthermore, as the speed of computing equipment increases, numerical methods can afford to be less efficient in speed and cruder but more robust techniques become acceptable. The approach using optimisation is demonstrated using a constraint modelling system called SWORDS.
0097-8493/01/$ - see front matter # 2001 Elsevier Science Ltd. All rights reserved. PII: S 0 0 9 7 - 8 4 9 3 ( 0 1 ) 0 0 0 7 0 - X
484
G. Mullineux / Computers & Graphics 25 (2001) 483–492
In the next section, related research in the area of constraint-based systems is reviewed and this is followed with some background from optimisation theory. The structure of the SWORDS system is described and is then applied as an example to a typical problem arising in sketching systems. In the following sections, techniques for addressing applications in assembly and mechanisms are discussed including the use of solid models. Finally conclusions are presented.
2. Background There have been a variety of strategies used to try to make computer aided design (CAD) systems more helpful to the human designer. Many stem from the use of an underlying language for the CAD system. Via the language geometry for standard parts can be generated more or less automatically. This leads on to the idea of parametric design [1,2]. Here a generic part is described via the language in terms of a number of parameters, often specific dimensions, which the user is asked to supply. This allows families of parts to be created easily. Coupling an expert system with the parametric approach enables some decision making to be carried out based on a set of underlying rules [3,4]. However such applications tend to be successful only when the set of rules is well understood and the range of possible design solutions is small. Inherently the rule base is fixed for the particular application. While this is advantageous as a means for capturing known design rules, it offers little help when a designer is encountering a new design and the rules are not fully known. Some researchers have looked at applying more general rules and constraints within CAD software. A lot of this work has been carried out in relation to sketching systems. Here the interest is in trying to interpret a designer’s intention from what is essentially a free-hand sketch performed with the CAD environment [9,10]. Thus there is interest in determining the constraints, such as perpendicularity and parallelism, implied upon the geometry. These could be specified directly by the user or inferred from the form of the sketch. The constraints are relations between the cartesian coordinates of the points within the sketch. Once the constraints have been established there is then the need to solve them. There are two main approaches [3]: symbolic and numerical. The symbolic approach is one of manipulating the constraints so that they can be solved directly and all solutions found. This is facilitated in the case of sketching systems in that the constraints are often those derived from ruler and compass constructions and hence reduce to quadratic equations in the underlying cartesian coordinates. Methods such as Grobner bases can be applied in their
full solution. The symbolic approach usually also requires the constraints to be reordered so that they are solved sequentially with each new constraint being used to determine the value or values of one new variable. The numerical approach regards each constraint as being an equation in a number of variables. Iterative techniques such as Newton’s method [11] can then be applied to look for a solution. A number of drawbacks with both these methods have been noted [3]. The symbolic approach is limited in the range of constraints with which it can deal. The numerical approach typically generates only one solution to the constraints, that is the one nearest (in some sense) to the starting point for the iteration. Depending on the precise method used, both approaches can require there to be the same number of constraint equations as there are variables. This leads to problems of under- or over-constrained sketches and the requirement to identify such situations and deal with them appropriately. Additionally the area of sketching is but one part of the overall design process. There is a need to put individual parts of a design together and to invoke constraints between those parts. There is a need to apply other engineering constraints, such as strength, weight and kinematics, which are not purely geometry based. The aim in this paper is to show how optimisation techniques provide a viable means for resolving constraints within a CAD environment. In particular they do not require limitations on the numbers of variables and constraints. Hence they can cope even when conflict between the constraints is present. Essentially a best compromise solution can be presented to the human designer. It is argued that this is of greater benefit than a system which attempts to do all the decision making itself. Only by recognising the existence of conflict does the human designer begin to learn about the design task that is being undertaken.
3. Optimisation The typical mathematical optimisation problem [12] is one of finding an extremum of an objective function of several variables subject to certain constraints between the variables which must be satisfied. The constraints can be equality or inequality relations. There are several methods for dealing with such problems. One is the use of penalty functions in which the constraint relations are effectively added into the objective function to reduce the problem to one of unconstrained optimisation. It is essentially this approach which is adopted here. Specifically, suppose there are n variables x1 ; x2 ; . . . ; xn involved in m constraints. These are denoted as follows. fj ðx1 ; x2 ; . . . ; xn Þ ¼ 0 for 15j5m:
G. Mullineux / Computers & Graphics 25 (2001) 483–492
There is no loss of generality in assuming that these are equality relations. Inequalities can be written in this form by use of a ramp function. The objective function is then formed by taking the sum of the squares of these constraints. Fðx1 ; x2 ; . . . ; xn Þ ¼ f12 þ f22 þ þ fm2 : This function is certainly non-negative. If values for the variables can be found which make F zero, then it is clear that all the constraint relations have been satisfied. If a (local) minimum can be found which is not zero then this may suggest that the constraints are in conflict and that the solution found represents a best compromise. Again there are many well known methods for dealing with unconstrained optimisation. The one used here is a direct search method based upon Powell’s method [12]. The objective functions F is evaluated at the start point for the search and then as the first variable changes. This allows a local search in the direction implied by this variable to be made and its value updated. Similar searches for the other variables are then carried out. This completes the first step in the iteration. At this stage the individual search directions are updated for the next iteration, and the process repeated. The approach adopted here is certainly not sophisticated. However its simplicity has a number of attractions. The form of the objective function enables the user to understand what is happening as the constraints are resolved and this is particularly helpful when the constraints prove to be in conflict. Gradient methods have been avoided in the solution process as the intention is that the form of the constraints is determined by the user (and not by the system) and so is not known a priori. In common with other numerical methods there are disadvantages. The search may settle on a local minimum which is non-zero. It is then not clear (from the mathematics alone) whether no overall solution exists or whether the search has simply missed it. Here reliance is placed upon the human user to intervene and if necessary start the search process from a new start point. The search looks only for a single solution. So if multiple ones exist the others are ignored unless the user takes action. This is deliberate; in the under constrained situation, there are potentially infinitely many solutions. Both these disadvantages could be overcome (partially at least) by using search techniques based on genetic algorithms [13] or simulated annealing [14]. These aim to find all possible solutions. Experience [15] suggests that these work well in finding the general area of a solution but not in finding it to any great accuracy. Perhaps a combined strategy is appropriate, using techniques such as Powell’s method to perform the final refinement once a good starting position has been determined.
485
4. Software environment A software environment called SWORDS has been created to investigate the use of constraints within engineering design. Underlying the system is a user language within which design parameters can be defined and constraints between them specified and resolved [16]. The aim in this section is to introduce the elements of the language and then in subsequent sections to discuss extensions and to show how it can be applied to problems of current interest in the literature. The language is similar to BASIC and is currently implemented in an interpreted mode. The usual types of entities are supported such as reals, integers and character strings. Expressions can be formed between these in the usual programming way. Functions (procedures) for handling specific operations can be created. Variables can be global or local to specific functions. In these respects, the language is no different from the user language supported by many commercial CAD systems. The main different lies in the ability to define constraint rules. This is done via user defined functions. As an example, consider the case of wishing to solve the following pair of simultaneous equations. x þ 2y ¼ 4; x þ 3y ¼ 5: The variables x and y can be defined globally in the language with the following declaration statement. dec real x, y; The equations themselves are set up as constraint rules using the rule statement. Each rule statement is associated with an expression involving the variables which is deemed to be true when it is zero. This then ties in with the resolution approach described in the previous section. Constraint rules have to appear within functions and the following defines a function for the simultaneous equations above. function solve { var x, y; rule x þ 2 * y 4; rule x þ 3 * y 5; } When the function is invoked with the command solve( ); the system automatically starts the resolution process, adjusting the values of the parameters given in the var
486
G. Mullineux / Computers & Graphics 25 (2001) 483–492
statement to try to minimise the sum of the squares of the rule values. In this case, the expressions are linear and the resolution process quickly converges to the correct solution. The language also supports graphical entities and provided a means for grouping geometric items together. These ideas are described in the following sections. They are essentially formed as structured types within the language. The user also has the ability to define new types built from existing types within the language and previously declared user types. The language itself is certainly required when new design tasks are undertaken. However it is possible to create specific tools using the language for well understood applications. For this a system of menu options can be created so that the novice user does not have to become involved in the details of the language itself. This is essentially the parametric approach but with the ability to resolve constraints once specific parameter values have been supplied by the user.
and to facilitate the specification of constraints. For example, the functions pnt and lin generate points and lines from the appropriate coordinate values. A binary function, perpendicular, is used in constraints to specify that lines should be a right angles. This uses the scalar product to form the cosine c of the angle between the lines. Of course this is zero when the constraint is satisfied. However to avoid the false extremum when the lines are parallel, the following modified value is one actually returned by the function. 10jcj : 1:1 jcj Another binary function, parallel, is used to check if two lines are in the same direction. With these ingredients, an example is now given of applying constraints to geometry. Four lines are to be arranged into a unit square whose sides are parallel to the main cartesian axes with one corner at ð1; 1Þ in the xy-plane [7]. The lines are denoted by l1; l2; l3 and l4, and these are assumed to have been declared as global variables. The function specifying the constraints is as follows.
5. Geometry A number of simple three dimensional geometric entities are supported by the SWORDS environment itself. These include points, lines and circular arcs. These are created as structures with a colon used to separate fields. For example, if p represents a point, then p : x is its x coordinate, and the y and z coordinates are obtained similarly. A line l is composed of two points representing its ends, and these are referred to as l:e1 and l:e2. An additional geometric type is the model space [17]. Essentially this is a transformation matrix which determines how a geometric entity is mapped into world space. By embedding several entities into the same space, they can be moved together by modifying the parameters of the transformation. These parameters include three translation components parallel to the cartesian axes, and three rotation components around these axes. A scale factor is also incorporated, although this is often kept fixed. A number of functions are built into the system to allow definition and manipulation of geometric entities
function square1 { var x1, y1, x2, y2, x3, y3, x4, y4, d1, d2; l1 ¼ lin(x1,y1,0,x2,y2,0); l2 ¼ lin(x2,y2,0,x3,y3,0); l3 ¼ lin(x3,y3,0,x4,y4,0); l4 ¼ lin(x4,y4,0,x1,y1,0); rule l2 parallel l4; rule l1 parallel l3; rule l1 perpendicular l4; rule length(l1) d1; rule length(l4) d2; rule d1 1; rule d1 d2; rule y1 1; rule x1 1; rule y2 y1; } Here d1 and d2 are global real variables giving the lengths of the sides. Part (a) of Fig. 1 shows the notation
Fig. 1. Assembly of a square [7].
G. Mullineux / Computers & Graphics 25 (2001) 483–492
and indicates the constraints. Once these have been satisfied using the optimisation process, the final result shown in part (b) of Fig. 1 is obtained. Here there are 10 free variables (given in the var statement) and ten constraint rules. However because the optimisation strategy is used it is not necessary to have the same numbers. For example, the problem could (apparently) be over-constrained by adding the extra constraint rule l1 perpendicular l2; and the required solution is still found successfully. The above function has been set up basically in terms of the underlying coordinates [7]. From these the geometric objects are recreated each time the constraints are evaluated. This has the advantage of ensuring the ends of the lines join together correctly. However, it is more natural to work with the geometric objects themselves. An alternative formulation of the constraints is as follows. function square2 { var m1, m2, m3, m4; rule l2:e1 on l1:e2; rule l3:e1 on l2:e2; rule l4:e1 on l3:e2; rule l1:e1 on l4:e2; rule l2 parallel l4; rule l1 parallel l3; rule l1 perpendicular l4; rule length(l1) 1; rule rule rule rule
length(l4) length(l1); l1:e1:y 1; l1:e1:x 1; l1:e1:y l1:e2:y;
} In the var statement here, m1; m2; m3 and m4 are model spaces into which the individual lines are embedded. As the main geometry is two dimensional only the two translations in the plane and the one rotation within the plane are allowed. The scale factor associated with each space is allowed to vary. Thus each model space represents four degrees of freedom. Four new constraints involving the on function have been introduced to ensure that the lines join correctly. The on function returns the cartesian distance between two points, which naturally is zero when they coincide. Note that lines themselves are now the free variables. Each has six degrees of freedom arising from the three coordinates representing its end points. As the construction lies entirely in the xy-plane, the z coordinates can all be fixed leaving 16 degrees of freedom.
487
Part (c) of Fig. 1 shows the lines in an initial configuration, now as distinct non-touching entities. When the constraints are applied, they again form into the required square. It is interesting to notice that in the second formulation, there are 12 constraint rules. There are four variables given explicitly in the var statement. So apparently the problem is over-constrained. However as has been seen, there are actually 16 degrees of freedom which would suggest that the problem is underconstrained. An alternative view is that each of the constraints involving the on function effectively represents two constraints, one on each coordinate in the plane. This implies 16 constraints and means that the problem is exactly constrained. The point here is that whether a problem is over- or under-constrained depends heavily upon how it is formulated and on how the degrees of freedom are interpreted. Information on the degrees of freedom could be obtained by a software system by examining the underlying structures of objects that are allowed to vary. This is not too difficult if the objects are built into the system, but becomes more difficult once user-defined structures become involved. However all such problems disappear once the optimisation approach to constraint resolution is adopted. This makes no distinction between over- and under-constrained problems.
6. Assembly modelling There has been recent interest [18–21] in the use of CAD techniques in modelling the assembly of parts. Again constraint based procedures can be used. Since the objects to be assembled are generally composed of many geometric entities, it is useful to group these in model spaces. As well as simply mapping geometry into world coordinates, a model space can also map into another model space. Indeed a hierarchy of spaces can be created in which each embeds into another, thus forming a tree structure. The root of the tree is world space, and the branches represent transforms. To find the position of an object in world, its local coordinates must be modified by the transforms along all the branches between its model space and the world. In the SWORDS system, the model space forms a predefined type. As far as the user in concerned, it has nine fields: three represent translations along the three main cartesian axes; three represent angles of rotation about these axes; and three represent scale factors. The scale factors are normally fixed and set to unity. For example, a cuboid can be created in wire frame by defining its 12 edges as lines. If these are all embedded in the same model space, then the cuboid can be moved as
488
G. Mullineux / Computers & Graphics 25 (2001) 483–492
a single object by adjusting the values in the fields of the model space. In assembly operations, constraints such as touching of faces and alignment of axes are important. These often relate to features within a part. It is useful to work in terms of marker points [21,22] created within an object. For SWORDS a marker is essentially the origin of a model space; usually it is convenient to define a point here so that the position can be visualised. The local z-axis of the space can then refer to such concepts as the normal to a face or the axis of a feature. Operations can then be applied to markers. A binary function, coplanar, determines if the local xy-planes of two spaces are coplanar. Specifically,
rule( rule( rule( rule( rule( rule( rule( rule( rule( rule( rule( rule(
mark05 mark05 mark05 mark05 mark05 mark05 mark05 mark05 mark01 mark01 mark01 mark01
06 06 07 07 08 08 09 09 10 10 11 11
contraaligned mark06 05 coplanar mark06 05 ); contraaligned mark07 05 coplanar mark07 05 ); contraaligned mark08 05 coplanar mark08 05 ); contraaligned mark09 05 coplanar mark09 05 ); coaligned mark10 01 ); coplanar mark10 01 ); coaligned mark11 01 ); coplanar mark11 01 );
); ); ); );
}
m1 coplanar m2 7. Solid models transforms the xy-planes of the two spaces into world space. The above expression then returns ðjd1 j þ jd2 j þ jsjÞ where d1 is the distance of the origin of m1 from the xy-plane of m2; d2 is similarly defined, and s is the sine of the angle between the normals to the planes. The expression of course is zero when the xy-planes are the same. Two more binary functions, coaligned and contraaligned, check if the z axes associated with markers are aligned. The former returns zero (true) when the axes are aligned and point in the same direction; the second is true when they are aligned but in opposite directions. These ideas can be used in the assembly of a box and lid arrangement [21,23] involving 11 parts. The parts are shown separately in part(a) of Fig. 2. Each is embedded in its own model space. Twenty markers have been introduced, one on each parts at each assembly point. Each pair of markers is used to specify coplanar and alignment constraints. For simplicity, the parts are assumed to be oriented correctly so that the rotation fields of the model spaces can be fixed as well as the scale factors. The main box component is also held fixed, leaving 30 degrees of freedom for the optimisation process to handle. The following SWORDS function provides the constraints for the assembly and the result is shown in part(b) of Fig. 2. function box { var m02, m03, m04, m05, m06, m07, m08, m09, m10, m11; rule( mark01 02 coaligned mark02 01 ); rule( mark01 02 coplanar mark02 01 ); rule( mark02 03 coaligned mark03 02 ); rule( mark02 03 coplanar mark03 02 ); rule( mark01 04 contraaligned mark04 01 ); rule( mark01 04 coplanar mark04 01 ); rule( mark04 05 contraaligned mark05 04 ); rule( mark04 05 coplanar mark05 04 );
Model spaces are useful ways of handling solid objects. These have been incorporated into the SWORDS system by means of the ACIS library of procedures [24] which is built into the system. Solid objects are created via the ACIS procedures in response to commands given via the SWORDS user language. They can then be manipulated via that language. For example, the arithmetic operations of addition, subtraction and multiplication are interpreted as the Boolean operations of union, difference and intersection when solids are involved. The structure of the combined SWORDS-ACIS system is shown in Fig. 3. Below the user interface is the language interpreter which creates and manipulates the user variables. These include ACIS objects which are accessed by the system either via the API or via low-level procedures. Expressions involving the variables (including solid objects) can be evaluated. This included evaluation of constraint rules. The constraint resolver works directly with the evaluator to try to optimise the constraints expressions to be zero. Solid objects can be assigned to model spaces so that they can move with other geometry including wire frame entities. (Internally this requires interaction with the transformations supplied with ACIS so that geometry is displayed correctly; however this is transparent to the user.) In particular marker points can be associated with solid objects to control their assembly. Fig. 4 shows the assembly of the box and lid example [21,23] given in the previous section, but now using solid objects for the various parts.
8. Mechanisms The previous examples have all involved assembly of geometry into a form which is intended to be static. However it is equally possible to create assemblies which
G. Mullineux / Computers & Graphics 25 (2001) 483–492
489
Fig. 2. Assembly of a box and lid [21,23].
move. In this section, simulation of the motion of planar mechanisms is considered. To perform such a simulation all that is required is to be able to assemble the parts of the mechanisms at different positions of the operating cycle. For this purpose, a loop statement exists within the SWORDS language. This allows the drive link to be moved repeatedly to each new position and then the assembly of the other links can take place. Model spaces can be used to reduce the number of constraint rules that need to be applied. If each link of a mechanism are represented as a single line joining its pivot points, then normally a constraint for each end would be expected. However, if the line is embedded in a
model space m which is itself embedded in space of one of the adjacent links, then the translation fields of m can be adjusted so that one end of the line (a joint) lies at the correct point with respect to the next space. The translations can then be fixed, and by allowing only the rotation about the z-axis to vary the correct motion is obtained. Within SWORDS this type of construction is carried out via the pivot function. Because the graph of the connections between model spaces must form a tree, there is a limit to how much of the assembly can be carried by pivoting alone. There is still a need to apply constraint rules, but the number of these is reduced as are the degrees of freedom.
490
G. Mullineux / Computers & Graphics 25 (2001) 483–492
The loop to generate the simulation of the motion is provided within a second function as follows. function cycle { dec int i; loop( i,0,36 ) { m1:az¼i*10; assemble( ); rpnt(0); } } Fig. 3. Structure of combined SWORDS-ACIS system.
Part (c) of Fig. 5 shows the initial assembly of the mechanism with more detailed two dimensional wire frame geometry. Part (d) shows one cycle of the motion.
9. Discussion and conclusions
Fig. 4. Solid model of box–lid assembly.
Part (a) of Fig. 5 shows the ‘‘stick diagram’’ representing a six bar mechanism [25]. The hierarchy of model spaces used in show in part (b) of the figure. The following function gives the constraint rules to perform the assembly, given the position of the drive link, represented by line l1; the pivoting of the spaces is not given, it is accomplished outside this function. function assemble { var m2, m3, m4, m5; rule( l3 l01:e2 on l2 l01:e2 ); rule( l5 l01:e2 on l2 l01:e2 ); }
The ideas behind a modelling system called SWORDS have been presented. The system allows variables and geometric entities to be defined and constraints imposed upon these. An optimisation scheme is used in the resolution of these constraints. It has been shown that the system is applicable to the types of problem encountered in constraint-based sketching systems, assembly modelling systems and mechanism simulation. Solid objects can be defined via the ACIS system and manipulated alongside other variables. The use of optimisation in the constraint resolution process has many advantages over other numerical and symbolic approaches. It does not require the imposed constraints to be in any particular form. All that is required is the ability to evaluate the constraint expression so that the direct search optimisation can proceed. It neatly avoids any requirements for the software (or user) to decide if a problem is under- or over-constrained. In the latter case, a form of best compromise solution can be presented which may help the user decide how to proceed. Indeed it has been shown that the ideas of under- and over-constraint depend heavily upon the formulation of a problem and this brings into question whether they really are useful concepts. The situation can be further confused if user-defined structured types are allowed within constraint-based systems. Finally it is suggested that a constraint-based description is a good way of archiving information about a design or parts of a design in a form that could be accessed again for future work. The need for a suitable means for doing this has been identified [7] and a language structure along the lines of that used by SWORDS seems one potentially viable direction. This
G. Mullineux / Computers & Graphics 25 (2001) 483–492
491
Fig. 5. Simulation of a six bar mechanism.
could also lead on to constraint-based procedures for the exchange of product data [26].
Acknowledgements The ideas discussed in this paper have resulted from research carried out under projects funded by the LINK Programmes supported by EPSRC=DTI and by MAFF. The financial support and help provided by all the participants is gratefully acknowledged.
References [1] Kondo K. PIGMOD}parametric and interactive geometric modeller for mechanical design. Computer-Aided Design 1990;22(10):633–44. [2] Verroust A, Schonek F, Roller D. Rule oriented method for parameterized computer-aided design. ComputerAided Design 1992;24(10):531–40. [3] Marcus S, Stout J, McDermott J. VT: an expert elevator designer that uses knowledge based backtracking. AI Magazine 1987;8(4):41–58. [4] Mittal S, Dym CL, Morjaria M. PRIDE: an expert system for the design of paper handling systems. IEEE Computer 1986;19(7):102–14. [5] Nelson G. Juno, a constraint-based graphics system. Computer Graphics 1985;19:235–43. [6] Suzuki H, Ando H, Kimura F. Geometric constraints and reasoning for geometric CAD systems. Computers and Graphics 1990;14:211–24.
[7] Anderl R, Mendgen R. Modelling with constraints: theoretical foundation and application. Computer-Aided Design 1996;28(3):155–68. [8] Mullineux G. The introduction of constraints into a graphics system. Engineering with Computers 1988;3(4):201–5. [9] Pavlidis T, van Wyk C. An automatic beautifier for drawings and illustrations. ACM Computer Graphics 1985;19:227–34. [10] Latham RS, Middleditch AE. Connectivity analysis}a tool for processing geometric constraints. Computer-Aided Design 1996;28(11):917–28. [11] Burden RL, Faires JD, Reynolds AC. Numerical analysis, 2nd ed. Boston, MA: Prindle, Weber and Schmidt, 1981. [12] Walsh GR. Methods of optimization. London: Wiley, 1975. [13] Goldberg DE. Genetic algorithms in search, optimization and machine learning. Reading, MA: Addison-Wesley, 1989. [14] van Laarhoven PJM, Aarts EHL. Simulated annealing: theory and applications. Dordrecht: Reidel Publishing Company, 1987. [15] Loucaides A, Medland AJ, Mullineux G. Optimisation techniques in constraint modelling. In: Parmee IC, editor. Proceedings of Adaptive Computing in Engineering Design and Control 94, Plymouth, 1994. p. 50–5. [16] Mullineux G. Optimization scheme for assembling components. Computer-Aided Design 1987;19(1):35–40. [17] Leigh RD, Medland AJ, Mullineux G, Potts IRB. Model spaces and their use in mechanism simulation. Proceedings Institution of Mechanical Engineers}Part B: Journal of Engineering Manufacture 1989;203:167–74. [18] Lee K, Gossard DC. A hierarchical data structure for representing assemblies: part 1. Computer-Aided Design 1985;17(1):15–9.
492
G. Mullineux / Computers & Graphics 25 (2001) 483–492
[19] Lee K, Gossard DC. Inference of the positions of components in an assembly: part 2. Computer-Aided Design 1985;17(1):20–4. [20] Srikanth S, Turner J. Towards a unified representations of mechanical assemblies. Engineering with Computers 1990;6:103–12. [21] Anantha R, Kramer GA, Crawford RH. Assembly modelling by geometric constraint satisfaction. Computer-Aided Design 1996;28(9):707–22. [22] Anon. ADAMS user manual. Ann Arbor, MI: MDI, 1987.
[23] Boothroyd G, Poli C, Murch LE. Automatic assembly. New York: Dekker, 1982. p. 310–11. [24] Anon. ACIS geometric modeler programmers reference. Boulder, CO: Spatial Technology, 1995. [25] McLarnan CW. Synthesis of six-link planar mechanisms by numerical analysis. Transactions of the ASME: Journal of Engineering for Industry 1963;85:5–10. [26] Medland AJ. A proposed structure for a rule-based description of parametric forms. Engineering with Computers 1993;10:155–61.
Technical Section
Constraint resolution using optimisation techniques Glen Mullineux* Department of Mechanical Engineering, Faculty of Engineering and Design, University of Bath, Bath BA2 7AY, UK
Abstract Constraint-based CAD systems are useful for handling design applications in which the precise rules are not known beforehand. The designer can introduce new constraints as these become apparent as the design task proceeds. A variety of ways for resolving constraints currently exist. This paper considers the use of a direct search optimisation approach. It is shown that this has the advantage of being able to handle a variety of different applications and that problems of under- or over-constrained systems no longer exist. A software system using this approach is introduced and its application to a number of areas is illustrated, including typical problems from computer-aided sketching, assembling modelling and mechanism simulation. # 2001 Elsevier Science Ltd. All rights reserved. Keywords: Constraint modelling; Constraint solving; Optimisation; Assembly modelling; Mechanisms
1. Introduction Computer aided design (CAD) systems have found uses in a large number of application areas. Since commercial systems tend to be general purpose engines, there have been a number of attempts to tailor them to more specific applications. Many of these have relied on the underlying user language of the system and the use of parametrics is one such case [1,2]. When the application area is well understood, rule-based expert systems provide a means for capturing that information for the less experienced user [3,4]. These can be used to control the CAD system via its user language. In the more general design situation, a designer is often meeting a task for the first time. In such cases the precise rules which apply are not immediately obvious. What are clear are some of the constraints which bound what can be done. These might include limitations on weight or size or allowable forces. As the design proceeds more and more constraints emerge. These are often in conflict and the designer’s skill is in deciding which can be comprised with reasonable safety. The use of constraint-based systems has emerged recently [5–8]. Often these systems underlie sketching *Tel.: +44-1225-826159. E-mail address: [email protected] (G. Mullineux).
software and the constraints relate to the geometry involved particularly in relation to the underlying cartesian coordinates of points. A range of solution techniques exist. It is generally acknowledged that there is a range of constraints that need to be considered, ranging from the purely geometric to more complex engineering considerations. However, the constraint resolvers employed do not generally seem designed to handle this range satisfactorily. This paper proposes that resolution techniques based upon mathematical optimisation provide a means for handling all the various different types of constraint within a single unified approach. While more sophisticated means of solution certainly exist, they depend upon specific forms of constraint. Optimisation strategies, particularly those based on direct search techniques, require only the ability to be able to evaluate the imposed constraints. Problems of too many or too few constraints are not a problem and indeed the optimisation approach allows best compromise solutions to be obtained when constraints are in conflict. Furthermore, as the speed of computing equipment increases, numerical methods can afford to be less efficient in speed and cruder but more robust techniques become acceptable. The approach using optimisation is demonstrated using a constraint modelling system called SWORDS.
0097-8493/01/$ - see front matter # 2001 Elsevier Science Ltd. All rights reserved. PII: S 0 0 9 7 - 8 4 9 3 ( 0 1 ) 0 0 0 7 0 - X
484
G. Mullineux / Computers & Graphics 25 (2001) 483–492
In the next section, related research in the area of constraint-based systems is reviewed and this is followed with some background from optimisation theory. The structure of the SWORDS system is described and is then applied as an example to a typical problem arising in sketching systems. In the following sections, techniques for addressing applications in assembly and mechanisms are discussed including the use of solid models. Finally conclusions are presented.
2. Background There have been a variety of strategies used to try to make computer aided design (CAD) systems more helpful to the human designer. Many stem from the use of an underlying language for the CAD system. Via the language geometry for standard parts can be generated more or less automatically. This leads on to the idea of parametric design [1,2]. Here a generic part is described via the language in terms of a number of parameters, often specific dimensions, which the user is asked to supply. This allows families of parts to be created easily. Coupling an expert system with the parametric approach enables some decision making to be carried out based on a set of underlying rules [3,4]. However such applications tend to be successful only when the set of rules is well understood and the range of possible design solutions is small. Inherently the rule base is fixed for the particular application. While this is advantageous as a means for capturing known design rules, it offers little help when a designer is encountering a new design and the rules are not fully known. Some researchers have looked at applying more general rules and constraints within CAD software. A lot of this work has been carried out in relation to sketching systems. Here the interest is in trying to interpret a designer’s intention from what is essentially a free-hand sketch performed with the CAD environment [9,10]. Thus there is interest in determining the constraints, such as perpendicularity and parallelism, implied upon the geometry. These could be specified directly by the user or inferred from the form of the sketch. The constraints are relations between the cartesian coordinates of the points within the sketch. Once the constraints have been established there is then the need to solve them. There are two main approaches [3]: symbolic and numerical. The symbolic approach is one of manipulating the constraints so that they can be solved directly and all solutions found. This is facilitated in the case of sketching systems in that the constraints are often those derived from ruler and compass constructions and hence reduce to quadratic equations in the underlying cartesian coordinates. Methods such as Grobner bases can be applied in their
full solution. The symbolic approach usually also requires the constraints to be reordered so that they are solved sequentially with each new constraint being used to determine the value or values of one new variable. The numerical approach regards each constraint as being an equation in a number of variables. Iterative techniques such as Newton’s method [11] can then be applied to look for a solution. A number of drawbacks with both these methods have been noted [3]. The symbolic approach is limited in the range of constraints with which it can deal. The numerical approach typically generates only one solution to the constraints, that is the one nearest (in some sense) to the starting point for the iteration. Depending on the precise method used, both approaches can require there to be the same number of constraint equations as there are variables. This leads to problems of under- or over-constrained sketches and the requirement to identify such situations and deal with them appropriately. Additionally the area of sketching is but one part of the overall design process. There is a need to put individual parts of a design together and to invoke constraints between those parts. There is a need to apply other engineering constraints, such as strength, weight and kinematics, which are not purely geometry based. The aim in this paper is to show how optimisation techniques provide a viable means for resolving constraints within a CAD environment. In particular they do not require limitations on the numbers of variables and constraints. Hence they can cope even when conflict between the constraints is present. Essentially a best compromise solution can be presented to the human designer. It is argued that this is of greater benefit than a system which attempts to do all the decision making itself. Only by recognising the existence of conflict does the human designer begin to learn about the design task that is being undertaken.
3. Optimisation The typical mathematical optimisation problem [12] is one of finding an extremum of an objective function of several variables subject to certain constraints between the variables which must be satisfied. The constraints can be equality or inequality relations. There are several methods for dealing with such problems. One is the use of penalty functions in which the constraint relations are effectively added into the objective function to reduce the problem to one of unconstrained optimisation. It is essentially this approach which is adopted here. Specifically, suppose there are n variables x1 ; x2 ; . . . ; xn involved in m constraints. These are denoted as follows. fj ðx1 ; x2 ; . . . ; xn Þ ¼ 0 for 15j5m:
G. Mullineux / Computers & Graphics 25 (2001) 483–492
There is no loss of generality in assuming that these are equality relations. Inequalities can be written in this form by use of a ramp function. The objective function is then formed by taking the sum of the squares of these constraints. Fðx1 ; x2 ; . . . ; xn Þ ¼ f12 þ f22 þ þ fm2 : This function is certainly non-negative. If values for the variables can be found which make F zero, then it is clear that all the constraint relations have been satisfied. If a (local) minimum can be found which is not zero then this may suggest that the constraints are in conflict and that the solution found represents a best compromise. Again there are many well known methods for dealing with unconstrained optimisation. The one used here is a direct search method based upon Powell’s method [12]. The objective functions F is evaluated at the start point for the search and then as the first variable changes. This allows a local search in the direction implied by this variable to be made and its value updated. Similar searches for the other variables are then carried out. This completes the first step in the iteration. At this stage the individual search directions are updated for the next iteration, and the process repeated. The approach adopted here is certainly not sophisticated. However its simplicity has a number of attractions. The form of the objective function enables the user to understand what is happening as the constraints are resolved and this is particularly helpful when the constraints prove to be in conflict. Gradient methods have been avoided in the solution process as the intention is that the form of the constraints is determined by the user (and not by the system) and so is not known a priori. In common with other numerical methods there are disadvantages. The search may settle on a local minimum which is non-zero. It is then not clear (from the mathematics alone) whether no overall solution exists or whether the search has simply missed it. Here reliance is placed upon the human user to intervene and if necessary start the search process from a new start point. The search looks only for a single solution. So if multiple ones exist the others are ignored unless the user takes action. This is deliberate; in the under constrained situation, there are potentially infinitely many solutions. Both these disadvantages could be overcome (partially at least) by using search techniques based on genetic algorithms [13] or simulated annealing [14]. These aim to find all possible solutions. Experience [15] suggests that these work well in finding the general area of a solution but not in finding it to any great accuracy. Perhaps a combined strategy is appropriate, using techniques such as Powell’s method to perform the final refinement once a good starting position has been determined.
485
4. Software environment A software environment called SWORDS has been created to investigate the use of constraints within engineering design. Underlying the system is a user language within which design parameters can be defined and constraints between them specified and resolved [16]. The aim in this section is to introduce the elements of the language and then in subsequent sections to discuss extensions and to show how it can be applied to problems of current interest in the literature. The language is similar to BASIC and is currently implemented in an interpreted mode. The usual types of entities are supported such as reals, integers and character strings. Expressions can be formed between these in the usual programming way. Functions (procedures) for handling specific operations can be created. Variables can be global or local to specific functions. In these respects, the language is no different from the user language supported by many commercial CAD systems. The main different lies in the ability to define constraint rules. This is done via user defined functions. As an example, consider the case of wishing to solve the following pair of simultaneous equations. x þ 2y ¼ 4; x þ 3y ¼ 5: The variables x and y can be defined globally in the language with the following declaration statement. dec real x, y; The equations themselves are set up as constraint rules using the rule statement. Each rule statement is associated with an expression involving the variables which is deemed to be true when it is zero. This then ties in with the resolution approach described in the previous section. Constraint rules have to appear within functions and the following defines a function for the simultaneous equations above. function solve { var x, y; rule x þ 2 * y 4; rule x þ 3 * y 5; } When the function is invoked with the command solve( ); the system automatically starts the resolution process, adjusting the values of the parameters given in the var
486
G. Mullineux / Computers & Graphics 25 (2001) 483–492
statement to try to minimise the sum of the squares of the rule values. In this case, the expressions are linear and the resolution process quickly converges to the correct solution. The language also supports graphical entities and provided a means for grouping geometric items together. These ideas are described in the following sections. They are essentially formed as structured types within the language. The user also has the ability to define new types built from existing types within the language and previously declared user types. The language itself is certainly required when new design tasks are undertaken. However it is possible to create specific tools using the language for well understood applications. For this a system of menu options can be created so that the novice user does not have to become involved in the details of the language itself. This is essentially the parametric approach but with the ability to resolve constraints once specific parameter values have been supplied by the user.
and to facilitate the specification of constraints. For example, the functions pnt and lin generate points and lines from the appropriate coordinate values. A binary function, perpendicular, is used in constraints to specify that lines should be a right angles. This uses the scalar product to form the cosine c of the angle between the lines. Of course this is zero when the constraint is satisfied. However to avoid the false extremum when the lines are parallel, the following modified value is one actually returned by the function. 10jcj : 1:1 jcj Another binary function, parallel, is used to check if two lines are in the same direction. With these ingredients, an example is now given of applying constraints to geometry. Four lines are to be arranged into a unit square whose sides are parallel to the main cartesian axes with one corner at ð1; 1Þ in the xy-plane [7]. The lines are denoted by l1; l2; l3 and l4, and these are assumed to have been declared as global variables. The function specifying the constraints is as follows.
5. Geometry A number of simple three dimensional geometric entities are supported by the SWORDS environment itself. These include points, lines and circular arcs. These are created as structures with a colon used to separate fields. For example, if p represents a point, then p : x is its x coordinate, and the y and z coordinates are obtained similarly. A line l is composed of two points representing its ends, and these are referred to as l:e1 and l:e2. An additional geometric type is the model space [17]. Essentially this is a transformation matrix which determines how a geometric entity is mapped into world space. By embedding several entities into the same space, they can be moved together by modifying the parameters of the transformation. These parameters include three translation components parallel to the cartesian axes, and three rotation components around these axes. A scale factor is also incorporated, although this is often kept fixed. A number of functions are built into the system to allow definition and manipulation of geometric entities
function square1 { var x1, y1, x2, y2, x3, y3, x4, y4, d1, d2; l1 ¼ lin(x1,y1,0,x2,y2,0); l2 ¼ lin(x2,y2,0,x3,y3,0); l3 ¼ lin(x3,y3,0,x4,y4,0); l4 ¼ lin(x4,y4,0,x1,y1,0); rule l2 parallel l4; rule l1 parallel l3; rule l1 perpendicular l4; rule length(l1) d1; rule length(l4) d2; rule d1 1; rule d1 d2; rule y1 1; rule x1 1; rule y2 y1; } Here d1 and d2 are global real variables giving the lengths of the sides. Part (a) of Fig. 1 shows the notation
Fig. 1. Assembly of a square [7].
G. Mullineux / Computers & Graphics 25 (2001) 483–492
and indicates the constraints. Once these have been satisfied using the optimisation process, the final result shown in part (b) of Fig. 1 is obtained. Here there are 10 free variables (given in the var statement) and ten constraint rules. However because the optimisation strategy is used it is not necessary to have the same numbers. For example, the problem could (apparently) be over-constrained by adding the extra constraint rule l1 perpendicular l2; and the required solution is still found successfully. The above function has been set up basically in terms of the underlying coordinates [7]. From these the geometric objects are recreated each time the constraints are evaluated. This has the advantage of ensuring the ends of the lines join together correctly. However, it is more natural to work with the geometric objects themselves. An alternative formulation of the constraints is as follows. function square2 { var m1, m2, m3, m4; rule l2:e1 on l1:e2; rule l3:e1 on l2:e2; rule l4:e1 on l3:e2; rule l1:e1 on l4:e2; rule l2 parallel l4; rule l1 parallel l3; rule l1 perpendicular l4; rule length(l1) 1; rule rule rule rule
length(l4) length(l1); l1:e1:y 1; l1:e1:x 1; l1:e1:y l1:e2:y;
} In the var statement here, m1; m2; m3 and m4 are model spaces into which the individual lines are embedded. As the main geometry is two dimensional only the two translations in the plane and the one rotation within the plane are allowed. The scale factor associated with each space is allowed to vary. Thus each model space represents four degrees of freedom. Four new constraints involving the on function have been introduced to ensure that the lines join correctly. The on function returns the cartesian distance between two points, which naturally is zero when they coincide. Note that lines themselves are now the free variables. Each has six degrees of freedom arising from the three coordinates representing its end points. As the construction lies entirely in the xy-plane, the z coordinates can all be fixed leaving 16 degrees of freedom.
487
Part (c) of Fig. 1 shows the lines in an initial configuration, now as distinct non-touching entities. When the constraints are applied, they again form into the required square. It is interesting to notice that in the second formulation, there are 12 constraint rules. There are four variables given explicitly in the var statement. So apparently the problem is over-constrained. However as has been seen, there are actually 16 degrees of freedom which would suggest that the problem is underconstrained. An alternative view is that each of the constraints involving the on function effectively represents two constraints, one on each coordinate in the plane. This implies 16 constraints and means that the problem is exactly constrained. The point here is that whether a problem is over- or under-constrained depends heavily upon how it is formulated and on how the degrees of freedom are interpreted. Information on the degrees of freedom could be obtained by a software system by examining the underlying structures of objects that are allowed to vary. This is not too difficult if the objects are built into the system, but becomes more difficult once user-defined structures become involved. However all such problems disappear once the optimisation approach to constraint resolution is adopted. This makes no distinction between over- and under-constrained problems.
6. Assembly modelling There has been recent interest [18–21] in the use of CAD techniques in modelling the assembly of parts. Again constraint based procedures can be used. Since the objects to be assembled are generally composed of many geometric entities, it is useful to group these in model spaces. As well as simply mapping geometry into world coordinates, a model space can also map into another model space. Indeed a hierarchy of spaces can be created in which each embeds into another, thus forming a tree structure. The root of the tree is world space, and the branches represent transforms. To find the position of an object in world, its local coordinates must be modified by the transforms along all the branches between its model space and the world. In the SWORDS system, the model space forms a predefined type. As far as the user in concerned, it has nine fields: three represent translations along the three main cartesian axes; three represent angles of rotation about these axes; and three represent scale factors. The scale factors are normally fixed and set to unity. For example, a cuboid can be created in wire frame by defining its 12 edges as lines. If these are all embedded in the same model space, then the cuboid can be moved as
488
G. Mullineux / Computers & Graphics 25 (2001) 483–492
a single object by adjusting the values in the fields of the model space. In assembly operations, constraints such as touching of faces and alignment of axes are important. These often relate to features within a part. It is useful to work in terms of marker points [21,22] created within an object. For SWORDS a marker is essentially the origin of a model space; usually it is convenient to define a point here so that the position can be visualised. The local z-axis of the space can then refer to such concepts as the normal to a face or the axis of a feature. Operations can then be applied to markers. A binary function, coplanar, determines if the local xy-planes of two spaces are coplanar. Specifically,
rule( rule( rule( rule( rule( rule( rule( rule( rule( rule( rule( rule(
mark05 mark05 mark05 mark05 mark05 mark05 mark05 mark05 mark01 mark01 mark01 mark01
06 06 07 07 08 08 09 09 10 10 11 11
contraaligned mark06 05 coplanar mark06 05 ); contraaligned mark07 05 coplanar mark07 05 ); contraaligned mark08 05 coplanar mark08 05 ); contraaligned mark09 05 coplanar mark09 05 ); coaligned mark10 01 ); coplanar mark10 01 ); coaligned mark11 01 ); coplanar mark11 01 );
); ); ); );
}
m1 coplanar m2 7. Solid models transforms the xy-planes of the two spaces into world space. The above expression then returns ðjd1 j þ jd2 j þ jsjÞ where d1 is the distance of the origin of m1 from the xy-plane of m2; d2 is similarly defined, and s is the sine of the angle between the normals to the planes. The expression of course is zero when the xy-planes are the same. Two more binary functions, coaligned and contraaligned, check if the z axes associated with markers are aligned. The former returns zero (true) when the axes are aligned and point in the same direction; the second is true when they are aligned but in opposite directions. These ideas can be used in the assembly of a box and lid arrangement [21,23] involving 11 parts. The parts are shown separately in part(a) of Fig. 2. Each is embedded in its own model space. Twenty markers have been introduced, one on each parts at each assembly point. Each pair of markers is used to specify coplanar and alignment constraints. For simplicity, the parts are assumed to be oriented correctly so that the rotation fields of the model spaces can be fixed as well as the scale factors. The main box component is also held fixed, leaving 30 degrees of freedom for the optimisation process to handle. The following SWORDS function provides the constraints for the assembly and the result is shown in part(b) of Fig. 2. function box { var m02, m03, m04, m05, m06, m07, m08, m09, m10, m11; rule( mark01 02 coaligned mark02 01 ); rule( mark01 02 coplanar mark02 01 ); rule( mark02 03 coaligned mark03 02 ); rule( mark02 03 coplanar mark03 02 ); rule( mark01 04 contraaligned mark04 01 ); rule( mark01 04 coplanar mark04 01 ); rule( mark04 05 contraaligned mark05 04 ); rule( mark04 05 coplanar mark05 04 );
Model spaces are useful ways of handling solid objects. These have been incorporated into the SWORDS system by means of the ACIS library of procedures [24] which is built into the system. Solid objects are created via the ACIS procedures in response to commands given via the SWORDS user language. They can then be manipulated via that language. For example, the arithmetic operations of addition, subtraction and multiplication are interpreted as the Boolean operations of union, difference and intersection when solids are involved. The structure of the combined SWORDS-ACIS system is shown in Fig. 3. Below the user interface is the language interpreter which creates and manipulates the user variables. These include ACIS objects which are accessed by the system either via the API or via low-level procedures. Expressions involving the variables (including solid objects) can be evaluated. This included evaluation of constraint rules. The constraint resolver works directly with the evaluator to try to optimise the constraints expressions to be zero. Solid objects can be assigned to model spaces so that they can move with other geometry including wire frame entities. (Internally this requires interaction with the transformations supplied with ACIS so that geometry is displayed correctly; however this is transparent to the user.) In particular marker points can be associated with solid objects to control their assembly. Fig. 4 shows the assembly of the box and lid example [21,23] given in the previous section, but now using solid objects for the various parts.
8. Mechanisms The previous examples have all involved assembly of geometry into a form which is intended to be static. However it is equally possible to create assemblies which
G. Mullineux / Computers & Graphics 25 (2001) 483–492
489
Fig. 2. Assembly of a box and lid [21,23].
move. In this section, simulation of the motion of planar mechanisms is considered. To perform such a simulation all that is required is to be able to assemble the parts of the mechanisms at different positions of the operating cycle. For this purpose, a loop statement exists within the SWORDS language. This allows the drive link to be moved repeatedly to each new position and then the assembly of the other links can take place. Model spaces can be used to reduce the number of constraint rules that need to be applied. If each link of a mechanism are represented as a single line joining its pivot points, then normally a constraint for each end would be expected. However, if the line is embedded in a
model space m which is itself embedded in space of one of the adjacent links, then the translation fields of m can be adjusted so that one end of the line (a joint) lies at the correct point with respect to the next space. The translations can then be fixed, and by allowing only the rotation about the z-axis to vary the correct motion is obtained. Within SWORDS this type of construction is carried out via the pivot function. Because the graph of the connections between model spaces must form a tree, there is a limit to how much of the assembly can be carried by pivoting alone. There is still a need to apply constraint rules, but the number of these is reduced as are the degrees of freedom.
490
G. Mullineux / Computers & Graphics 25 (2001) 483–492
The loop to generate the simulation of the motion is provided within a second function as follows. function cycle { dec int i; loop( i,0,36 ) { m1:az¼i*10; assemble( ); rpnt(0); } } Fig. 3. Structure of combined SWORDS-ACIS system.
Part (c) of Fig. 5 shows the initial assembly of the mechanism with more detailed two dimensional wire frame geometry. Part (d) shows one cycle of the motion.
9. Discussion and conclusions
Fig. 4. Solid model of box–lid assembly.
Part (a) of Fig. 5 shows the ‘‘stick diagram’’ representing a six bar mechanism [25]. The hierarchy of model spaces used in show in part (b) of the figure. The following function gives the constraint rules to perform the assembly, given the position of the drive link, represented by line l1; the pivoting of the spaces is not given, it is accomplished outside this function. function assemble { var m2, m3, m4, m5; rule( l3 l01:e2 on l2 l01:e2 ); rule( l5 l01:e2 on l2 l01:e2 ); }
The ideas behind a modelling system called SWORDS have been presented. The system allows variables and geometric entities to be defined and constraints imposed upon these. An optimisation scheme is used in the resolution of these constraints. It has been shown that the system is applicable to the types of problem encountered in constraint-based sketching systems, assembly modelling systems and mechanism simulation. Solid objects can be defined via the ACIS system and manipulated alongside other variables. The use of optimisation in the constraint resolution process has many advantages over other numerical and symbolic approaches. It does not require the imposed constraints to be in any particular form. All that is required is the ability to evaluate the constraint expression so that the direct search optimisation can proceed. It neatly avoids any requirements for the software (or user) to decide if a problem is under- or over-constrained. In the latter case, a form of best compromise solution can be presented which may help the user decide how to proceed. Indeed it has been shown that the ideas of under- and over-constraint depend heavily upon the formulation of a problem and this brings into question whether they really are useful concepts. The situation can be further confused if user-defined structured types are allowed within constraint-based systems. Finally it is suggested that a constraint-based description is a good way of archiving information about a design or parts of a design in a form that could be accessed again for future work. The need for a suitable means for doing this has been identified [7] and a language structure along the lines of that used by SWORDS seems one potentially viable direction. This
G. Mullineux / Computers & Graphics 25 (2001) 483–492
491
Fig. 5. Simulation of a six bar mechanism.
could also lead on to constraint-based procedures for the exchange of product data [26].
Acknowledgements The ideas discussed in this paper have resulted from research carried out under projects funded by the LINK Programmes supported by EPSRC=DTI and by MAFF. The financial support and help provided by all the participants is gratefully acknowledged.
References [1] Kondo K. PIGMOD}parametric and interactive geometric modeller for mechanical design. Computer-Aided Design 1990;22(10):633–44. [2] Verroust A, Schonek F, Roller D. Rule oriented method for parameterized computer-aided design. ComputerAided Design 1992;24(10):531–40. [3] Marcus S, Stout J, McDermott J. VT: an expert elevator designer that uses knowledge based backtracking. AI Magazine 1987;8(4):41–58. [4] Mittal S, Dym CL, Morjaria M. PRIDE: an expert system for the design of paper handling systems. IEEE Computer 1986;19(7):102–14. [5] Nelson G. Juno, a constraint-based graphics system. Computer Graphics 1985;19:235–43. [6] Suzuki H, Ando H, Kimura F. Geometric constraints and reasoning for geometric CAD systems. Computers and Graphics 1990;14:211–24.
[7] Anderl R, Mendgen R. Modelling with constraints: theoretical foundation and application. Computer-Aided Design 1996;28(3):155–68. [8] Mullineux G. The introduction of constraints into a graphics system. Engineering with Computers 1988;3(4):201–5. [9] Pavlidis T, van Wyk C. An automatic beautifier for drawings and illustrations. ACM Computer Graphics 1985;19:227–34. [10] Latham RS, Middleditch AE. Connectivity analysis}a tool for processing geometric constraints. Computer-Aided Design 1996;28(11):917–28. [11] Burden RL, Faires JD, Reynolds AC. Numerical analysis, 2nd ed. Boston, MA: Prindle, Weber and Schmidt, 1981. [12] Walsh GR. Methods of optimization. London: Wiley, 1975. [13] Goldberg DE. Genetic algorithms in search, optimization and machine learning. Reading, MA: Addison-Wesley, 1989. [14] van Laarhoven PJM, Aarts EHL. Simulated annealing: theory and applications. Dordrecht: Reidel Publishing Company, 1987. [15] Loucaides A, Medland AJ, Mullineux G. Optimisation techniques in constraint modelling. In: Parmee IC, editor. Proceedings of Adaptive Computing in Engineering Design and Control 94, Plymouth, 1994. p. 50–5. [16] Mullineux G. Optimization scheme for assembling components. Computer-Aided Design 1987;19(1):35–40. [17] Leigh RD, Medland AJ, Mullineux G, Potts IRB. Model spaces and their use in mechanism simulation. Proceedings Institution of Mechanical Engineers}Part B: Journal of Engineering Manufacture 1989;203:167–74. [18] Lee K, Gossard DC. A hierarchical data structure for representing assemblies: part 1. Computer-Aided Design 1985;17(1):15–9.
492
G. Mullineux / Computers & Graphics 25 (2001) 483–492
[19] Lee K, Gossard DC. Inference of the positions of components in an assembly: part 2. Computer-Aided Design 1985;17(1):20–4. [20] Srikanth S, Turner J. Towards a unified representations of mechanical assemblies. Engineering with Computers 1990;6:103–12. [21] Anantha R, Kramer GA, Crawford RH. Assembly modelling by geometric constraint satisfaction. Computer-Aided Design 1996;28(9):707–22. [22] Anon. ADAMS user manual. Ann Arbor, MI: MDI, 1987.
[23] Boothroyd G, Poli C, Murch LE. Automatic assembly. New York: Dekker, 1982. p. 310–11. [24] Anon. ACIS geometric modeler programmers reference. Boulder, CO: Spatial Technology, 1995. [25] McLarnan CW. Synthesis of six-link planar mechanisms by numerical analysis. Transactions of the ASME: Journal of Engineering for Industry 1963;85:5–10. [26] Medland AJ. A proposed structure for a rule-based description of parametric forms. Engineering with Computers 1993;10:155–61.