WARNING: This text has been OCRd from the original paper and so will
contain many typographical errors. It should be useful for
searching, however. [Ash, August 2002].
Interactive geometric modelling
based on R-functions:
an agent-oriented approach
V.D. Adzhiev W.M. Beynon A.A. Pasko
Abstract
This paper describes a new approach to interactive geometric modelling, based on the application of an agent-oriented modelling technique. Our methods are conceived with exploratory modelling that involves experiment and observation particularly in mind. Our geometric modelling system is based on CSG principles and uses R-functions for implementing sets of operations over functionally defined objects. This supplies a lfigh-level symbolic description of the n-dimensional geometric model being updated during the modelling process. Our approach to building a definitive geometric language to allow incremental and extensible modelling is described. An agent-oriented notation is used to describe both the interaction of the user with the geometric modeUing system and the interactions between the principal components of the system itself. A case-study that involves exploratory modelling of morphing between two CSG objects is introduced. The future development of an agent-oriented approach to geometric modelling is discussed.
Introduction
Established applications of traditional CSG systems model a static 3-dimensional object from a limited rather low-level and incomplete set of standard primitives using built-in Boolean operators. The user can typically edit the CSG representation of an object via a graphical interface bv modifying or replacing one of the leaves or subtrees of its associated binarv tree.
2
Certain categories of users feel themselves restricted when working with such systems. Without forfeiting the well-known merits of CSG representations, they would like to use a wider and more general class of prinfitives (e.g. swept objects, blobby models, convolution surfaces etc.) and operations (e.g. blending, morphing etc.) and--moreover--would like t o i nt roduce t hem during the modelling. There is also interest in increasing the dimensionality of the modelling space, as, for instance, when developing time-dependent models of interacting objects.
Finally, such advanced users are interested in modelling environments of a different character, in which it is easy to create new geometric objects and transformations, and subsequently explore their characteristics and behaviour. In this process, the modeller applies principles similar to those used in a traditional scientific investigation of a physical phenomenon [1~. perfornfing experiments with the geometric model and observing its behaviour under changeable conditions.
To meet these requirements, it is essential that the user can establish a close and intelligible relationship between the specification of an object and its observed characteristics. This requires both a high-level "user representation" and means to develop the geometric model incrementally and interactively through observation of its visualization at every step.
R-Functions as a high-level user representation for geometric objects
"Generative Modelling" [12] is a promising new approach to unified shape representation, based on multi- dimensional parametric functions, that allows textual specification of a geometric shape using a set of symbolic operators. The approach to geometric modelling described in this paper also uses a high-level representation, but is based on using so-called "R-functions- for the description of operations over geometric objects with implicitly defined boundaries.
The set of geometric objects we specify comprises topolo~cally closed subsets of n-dimensional Euclidean space E, defined by an inequality
f(.rl.x2 ..... xn} ~- 0 ~1)
/
where f is a real continuous function of coordinates of the point in E,. We refer to f as the descriptive flmction defining a certain geometric object gobI. A descriptive function can be defined bv an analytic fornmla, by an algorithm for evaluation or by interpolation from tabulated data. Operations on geometric objects specified as in (1) are derived fl'om operations on their associated descriptive functions. For instance, set-theoretic operations over geometric objects for which the resulting object includes its boundary points correspond to 3-valued logic operations over point-membership predicates. Analytic definitions of such operations have been proposed and studied by V. Rvachev [10],[11] and are represented bv R-functions. There is a variety of systems of R-flmctions, each of which has the closure property. The most frequently used system includes the following analvtic expressions for R-functions corresponding to set-theoretic union, intersection and complementation:
f v~ g = (f + g + ~(f2 + g2 - 2c~fg))/(1 + c~)
f Ao g = (f + g - v~(f2 + g2 - 2c~fg))/(1 + c~) -..f = -f where a = a(f, g) is certain function satisfying following conditions:
-1 < a(f,g) < 1. (~(f,g) = a(g,f) = a(- f,g) = ct(f,-g).
The form most useful in practice corresponds to ~ - 0.
There is also an R-function system that provides C" continuity. As shown in [8], this representation is unified in that it is possible to specify not only the above-mentioned primary set-theoretic operations but also such operations as cartesian product, projection, bijective mapping (in particular affine mapping), some kinds of blending [9] etc. Note also that, with the help of R-functions, both algebraic and semi-algebraic geometric objects can be represented using a single descriptive function.
Computing tools for geometric modelling and visualization [7] that use R-functions in conjunction with more low-level CSG representations have already been developed. In this paper, we describe preliminary work aimed at exploiting R-function representations in
a highly flexible interactive geometric modelling system meeting the requirements set out above. To this end, we imoke a new programming paradigm that has already been successfully applied to interactive modelling and visualization with graphical images of a simpler nature [1].
R-function representations and definitive scripts
Figures 1 and 2 are specifications and images of two geometric objects. The objects are prechair--an approximation to a chair such as can readily be described using elementary CSG principles, as in the archetypal language PADL-2 [5], and chair--chosen to illustrate the complexity of object representations that can be specified using R-flmctions. The components of the chair, synthesized from superellipsoids, have themseh'es been constructed bv a process of incremental modelling with intermediate step-by-step visualization.
These specifications take the form of definitive scripts [1], in which the variables represent parametrized geometric objects within a modelling space. The algebraic expression that appears on the RHS of a formula defining a geometric object, such as gob-seat, is its associated descriptive function. The user modifies the specification of a geometric object, changes the mode of presentation, or simulates changes to its state (as in movement of the chair), by redefining variables in the script. The characteristic property of a definitive script is that such redefinition of a variable automatically affects the values of any dependent variables. For instance, redefinition of r affects the descriptive flmction that defines gob-wheels which in turn affects the value of gob-chair. Note that the specification of prechair is essentially equivalent to a traditional CSG description of an object, such as might be formulated in PADL-2. and that redefinition within such a definitive script is in essence equivalent to editing a CSG tree.
A geometric modelling system based on definitive scripts provides an interactive environment that supports a very flexible modelling process. By redefining variables in scripts, the user can
• define the modelling space in a symbolic manner, giving its di-mensionality, coordinate variable ranges, geometric types etc,
• introduce the names and descriptive functions of geometric
5
/* Built-in set-theoretic operations based on R-functions: "'1" -- union, "&'" -- intersection. "'V" -- subtraction. */
xl-min = -8.0: xl-max = 8.0; x2-min = -12.0: x2-.mmx = 12.0; x3mfin = -8.0; x3mlax = 8.0;
gob-preseat = (xl+6) & (-xl+6)) & ((x2+2) & (-x2+2))
X: ((x3+6) & (-x3+6)): gob-preback = ((xl+4) & (-x1+4)) & (x2 X: (-x2+ll))
& ((x3+7) & (-x3-3)): gob-pedestal = ((xl+7) & (-xl+7)) & ((x2+ll) & (-x2-7.5))
& ((x3+7) & (-x3+7)): gob-preleg = ((xl+2) & (-xl+2)) & ((x2+7) X: (-x2-1.5))
&: ((x3+2) & (-x3+2)): gob-prehole = (x2+1) & (-x2+1)) & ((x3+4) & (-x3+4)): gob-prechair = (gob-preseat \ gob-prehole) I gob-preback
I gob-pedestal I gob-preleg:
Figure 1. A geometric object constructed from blocks
6
gob-seat = 1-(xl/6)**4-((x2+3)/2)**4-(x3/6)**4: gob-back = 1-(xl/4)**4-((x2-5.5)/5.5)**4-((x3+5)/1.5)**4: gob-dent = 1-(x1/6)**4-((x2-6.5)/7.s)**2-((x3-1.3)/5.15)**2: gob-arlns = (((1-((xl-6.5)/O.5)**4-(x2/1.2)**4-(x3/4)**4)
t (1-((xl+6.5)/o.5)**4-(x2/1.2)**4-(x3/4)**4))
\ (1-(x2/O.S)**2-(xa/3.5)**2))
I (1-((xl-6.5)/1)**4-((x2-1.6)/O.4)**4-(x3/5.5)**2)
I (1-((xl+6.5)/1)**4-((x2-1.6)/O.4)**4-(x3/5.5)**2):
gob-props = (1-(xl/6.5)**8-((x2+5)/O.3)**8-(x3/0.5)**8)
i (1-((xl-6.5)/o.25)**s-((x2+a)/2)**S-(xa/O.5)**s) I (1-((xl+6.5)/O.25)**8-((x2+3)/2)**8-(x3/O.5)**S): gob-strut = 1-(xl/O.8)**4-((x2-4)/5.8)**4-((x3+5)/0.5)**4; gob-leg = (1-(xl/O.5)**2-(x3/0.5)**2)& (x2+9)~ (-x2-4); gob-cross = ((1-(xl/O.5)**2-((x2+8)/0.5)**2)& (x3+7)& (7-x3))
I ((1-((x2+S)/0.5)**2-(xa/0.5)**2)&: (x1+7)& (7-xl)); gob-wheels = (1-((xl-7)/r)**2-((x2-x2k)/r)**2-(x3/s)**6)
I (1-(xl/s)**6-((x2-x2k)/r)**2-((x3+ 7)/r)*'2 )
I (1-((x1+7)/s)**6-((x2-×2k)/r)**2-(x3/r)**2)
l (1-(xl/r)**2-((x2-x2k)/r)**2-((xU-7)/s)**6):
x2k=-9.4; r=0.6; s=0.4:
gob-chair = ((gob~seat I gob-back) \ gob-dent) ] gob-arms
I gob-props I gob-strut I gobleg I gob-cross I gob-wheels;
Figure 2. A geometric object synthesized from superellipsoids
T
objects using mathematical fornmlae constructed fi'om traditional algebraic functions and R-functions.
• assign numerical values to parameters.
As explained elsewhere [1], the expressive power of representations based upon definitive scripts stems from the close correspondence that can be established between vahes of variables in the script and observations of the object being modelled. As the specification of chair illustrates, the perturbation of parameters in descriptive formulae leads to subtle changes in shape of the geometric object of the kind that a designer might wish to perform. In contrast, however accurately an object is represented by a boolean combination of basic CSG objects, there is in general no easy way to perform transformations of this nature. On this basis, the variables in an R-flmction representation can reflect the components of a complex geometric object much more faithfully than those in a conventional CSG representation. Practical experience with the prototype Hypersurf system also shows that the modeller can develop insight into the wav in which the choice of parametrization and the redefinition of parameters affects the geometry of objects. The experimental process of redefinition and evaluation through inspection of the visual image is idealh" suited for modelling tasks that involve aesthetic judgements.
Agent-oriented modelling for interaction
Our geometric modelling system is being developed within a broader framework established by our previous work on interfaces for engineering design [2], [3]. We use an agent-oriented modelling technique to specify this system. The user is an agent who constructs and observes visual images of a geometric model, and who incrementally comprehends the correspondence between the abstract mathematical model and its visualization through an exploratory modelling process. The components of the modelling system are treated as agents that interact with the user and with each other. The perspective of each agent is characterized by a particular mode of observation and particular privileges to augment and modify the model. The mode of observation determines the nature of the variables in
the definitive script, whilst the protocol for redefinition reflects the privileges.
The specification method resembles extensions to object-oriented programming for concurrent execution, such as the ACTORS model [6], but adopts agents and observations rather than objects as its fundamental abstractions. Our approach differs fundamentalh from an object-oriented paradigm in that
• message passing is only one mode of agent interaction.
• direct action of one agent upon another is possible.
• single actions typically effect state changes in several agents in one indivisible transition.
The abstract characteristics of an agent are specified using a special-purpose notation called LSD [2]. An LSD specificaton is oriented towards understanding the interaction between agents in a system by applying principles intimately connected with experiments and observations.
The variables in an LSD specification represent observations of the system such as might have to be monitored in explaining the interaction between agents. The variables associated with an agent are classified according to their status as observations with respect to the agent. These classifications are:
• STATE variables that the agent owns;
• ORACLE variables to which it responds;
• HANDLE variables that are conditionally under its control;
• DERIVATE variables representing indivisibly coupled stimulus-response relations.
The same variable can be classified in different ways bv different agents. Each agent has a PROTOCOL that specifies its privileges to change the system state, subject to certain enabling conditions being met.
The nature of LSD specification can be illustrated with reference to a particular agent visualiza.tion that governs the way in which a
geometric object within our exploratory modelling system is displayed on the screen. Listing 1 is a simplified LSD specification for risualization. The period of existence of the agent visualization is specified by the special DERI~L-kTE LI~'E whose value is TRUE whilst the user is in the process of getting a visual image. The visualization agent responds to variables such as rotate-image and film as ORACLEs whose value is set by the user to determine the mode of visualization. The STATE variables include the viewing angles alpha and beta. whose very existence is indivisibly linked to visualization activity. The primary HANDLE variables are parameters alpha, beta and x-time that are manipulated bv visualization in its PROTOCOL, and these indivisibly change the image of the geometric object currently under consideration as expressed by another DER1AL~TE.
AGENT visualization {
STATE (degree)alpha=-30. beta=30. (bool)fihn ....
ORACLE rotate-image, x-time-delta, pointjnembership-value ... HANDLE
visualimage[gname-curr].
x-time
DERIV~TE
i bool)LIVE = ( mode=="get-visual-image'" ),
visualfimage[gname-curr] = Fl.-NC-visualize(...) PROTOCOL
( fihn ) ---+ FUNC-save-frame(...),
t x[i]-geom-type == "t" ) A ( xmin[i] -< x-time -< xmax[i] )
--+ x-time = Ix-timel + x-time-delta,
( rotate-image == "right" ) --+ alpha = alpha - delta-alpha, ( rotate-image == "down" ) ---, beta = beta + delta-beta,
...
}
Listing 1. Outline LSD specification for visualization
Note the use of special-purpose functions identified by the prefix "'FUNC-"; these describe computational activity associated with visualization that establishes functional relationships in a manner that is invisible at the appropriate level of abstraction. In Listing 1. as in the other listings, it is inconvenient to itemize all the
/
arguments that such functions require. For instance, the parameters upon which the value of the variable visualJmage depends include: csg-tree[gname-curr]. [x[i]-geom-type (i=1.2 ..... n)]. x-rime. alpha, beta, and cdour. Note also that the redefinitions in a PROTOCOL can refer to the current value IvI of a variable c !see for instance the action that updates x-time). In this way. redefinition is a true generalization of reassignment.
A brief review of the LSD specification
In our interactive geometric modelling system, there are two principal agents on the same level of abstraction: user (see Listing 4) and modelling (see Listings 2 and 3). At any stage, the nature of the modelling activity in progress is reflected by the variable mode. The mode variable is a STATE for modelling and simultaneously an ORACLE and a DERIVATE for user: its value is functionally determined by the user's STATE variable user-conclusion that is set through a special procedure, representing a human thought process, that cannot be formalized. Other significant STATE variables of modelling include built-in-algebraic-functions and built-in-R-functions specifying the functions that can be used in symbolic descriptive functions.
The user and modelling agents have hierarchical structures of different kinds. The following sub-agents of modelBng can be active simultaneously: point in-space, geometric-object, R-csg-conversion, point-membership-relation, and visualization.
The sub-agent point-in-space serves to represent a given point of the modelling space and to speciL" the characteristics of its coordinate variables. It includes STATE variables specifying the dimen-sionalitv n of the modelling space, values x[i] and ranges .x3nin[i], xmax[i] for the coordinate variables, and special geometric types establishing the conventions governing the semantics of coordinate variables, in particular, for visualization. The default values for coordinate variables in 4D space are: ".r", "'y", "z","t", but certain other types (for example, mapping values to colours) can also be introduced. The STATE variable x-t-delta determines the incremental interval used in animating a coordinate variable with geometric type "t". The DERIV~-TE variable point-instance is a list of val-
AGENT modelling {
STATE
( string mlode, ( string)R-model = "'a =0 2",
(list)blfilt-in-algebraic-functions = [ "sqrt","exp',"log".... ].
( list )built-in-R-functions = [ "'l"-"&"."\"-" ""." ~" ].
(list)gname-List. ( string)gname-curr.
( bool Igob-exist [,] = FALSE, (string)message
ORACLE
modelling-in-progress, point-vaLid, fun-valid[gname] .... HANDLE
gob-exist[,], csg-tree-exist[,], message ....
DERIVkIE
(bool)LIVE = modelling-in-progress.
(string)message = FUNC-message(point-valid.fun-vaLid .... ) PROTOCOL
(nlode =-- "definemew-gob" ) A -~ (gob-exist[gname-curr]) gob-ex.ist[gname-curr] = TRUE: gname list = FUNC-append(Igname-List[,gname-curr). (mode = = "'define-new-gob" ) A (gob-exist [gname-curr] ) --* csg-tree-exist[gname-curr] = FALSE,
(mode = = "eliminate-gob" ) A (gob-exist[gname-curr]) gob-ex-ist[gname-curr] = FALSE: gname list = FUNC-xemove(Igname list l.gname-curr) ....
oo,
AGENT point-in-space {
STATE
[ (real)xmin[i] = 0 (i--1,2 n)].
[ ~real)xmax[i] = 1 (i=1,2 n)].
[ Ireal)x[i] = xmin[i] (i=1,2,....n)].
(integer)n = 4,
(point-type)point instance, ( bool)point-valid, x[1]-geom-type= "x-" , x[2]-geom-tvpe. = "v',. x[3]-geom-type = "z", x[4]-geom-type = "t".
x-time = xmin[4], x-time-delt a = (xmax[4]-xmin[4])/10 DERIV-kTE
pointinstance = [ x[1], x[2] .... x[n] l,
point-valid = A ( xmin[i] -< x[i] -< xmax[i] for i=1,2 ..... n)
Listing 2. Outline LSD specification for modelling
J
AGENT geometric-object [gname] {
STATE
( symbolic-rep )gob-descr-fun[gname].
( real )gob-par-.list [gname],
(csg-tree-rep)csg-tree[gname],
( screen-picture )visua]-image[gname].
( real )gob-value[gname].
(bool)csg-tree-ex-ist[gname] = FALSE
ORACLE point-instance
DERIVATE
( bool)LIVE = gob-ex-ist [gname],
gob-value[gname] =
F U N C -desc r-fun-eval( point inst ance,csg-t ree [gname] )
AGENT R-csg-conversion {
...
DERIXl~TE
(bool)LIVE = (mode == "define-new-gob°" ).
fun-valid[gname-curr] = SUNC-test(gob-descr-fun[gname-curr]) PROTOCOL
(fun-vand[gname-curr])A ~ (csg-tree-e~st[gname-curr])
-+ csg-tree[gname-curr] =
FUNC-create-csg-tree(gob-descr-fun[gname-curr],...); csg-tree-e~st[gname] = TRUE
AGENT point-membership-relation { STATE (string)point-membership-vahe ORACLE gob-value[gname-curr] DERIXLa~TE
(bool)LIVE = ( mode == "evaluate-po-memb-rel" )
V ( mode == "'get-visualimage'" ), point-membership-value =
FUNC -predicat e-eva]( gob -value[gname-curr] )
Listing 3. Outline LSD specification for modelling sub-agents
)
ues of coordinate variables that is re-evaluated whenever any x[i] is re-defined.
Within the modelling process, many instances of the sub-agent geometric-object can exist sinmltaneouslv. Each instance is identified bv its associated gname. A geometric-object instance has STATE variables specifying various representations of it: a symbolic descriptive-function, a more low-level csg-tree, and a visualdmage whose value is a picture on the display screen.
The agent R-csg-conversion is invoked as required to create a csg-tree representation from a valid descriptive function, and the agent visualization maintains visualimage as a DERI\:~TE as explained above.
The user agent is composed of several sub-agents that correspond to the different modelling activities being performed according to the value of mode. The sub-agent user-interpretation, which is key for making observations and subsequent decisions on the part of user (see its ORACLE variables), is active at all times. and the other sub-agents can act in parallel with it. Only one such sub-agent user-define-gob is included in Listing 2 but others, such as user-set-~nodelling-space, user-assign-geometric-types. user-set-gob-parameters, and user-deleteoob, appear in our complete specification.
We illustrate how the LSD specification is to be interpreted bv following a typical sequence of processes during a geometric modelling session. If user wants to introduce a new geometric object at some stage, it reaches the corresponding user-conclusion and the DERI%'\~TE variable mode gets the value define-near-gob. At once, the sub-agent user-detlne-g, ob becomes active, and user can input the name of a new geometric object gname-curr and its symbolic descriptive function gob-descr-fun. (Note that the processes by which an actual user might convey a change of mode to the geometric modelling system--as in choosing a menu option,, or supply input--as in filling in, a dialogue boz. are hidden in FUXC... operators at this abstract level of specification.)
Further, in accordance with its PROTOCOL, modelling checks whether an object with such a gname-curr already exists. If not, the variable oob-exist[gname-curr] becomes TRUE and a new instance
)
AGENT user {
STATE
(thought)user-conclusion = "let's-start", (bool)modelling-in-progress = FALSE ORACLE mode
HANDLE modelling-in-progress, mode
DERIV~TE
mode = FUNC-user-choose-mode(user-conclusion ) PROTOCOL
(user-conclusion == "let's-start")
-~ modelling-in-progress = TRUE
AGENT userdnterpretation {
ORACLE
mode, message, pointinstance, point-membership-value, visual-image[gname-curr]. gname list. gname-curr. gob-descr-fun[*], gob-par-list,
[ xmin[i], xmax[i] ], i= 1 n,
x-time, alpha.beta
HANDLE user-conclusion.
DERWATE
LIVE -- (modelling-in-progress),
user-conclusion = FUNC-user-observe-thinking(...)
}
AGENT user-define-gob {
ORACLE
mode, built in-algebraic-functions, built-in-R-functions, gname-list, gob-descr-fun[*]
HANDLE
gname-curr, gob-desc r -fun[gname-curr]
DERIVATE
LWE = (mode = = "define-new-gob" ). gname-curr = FUNC-user-input(gname-type). gob-descr-fun[gname-curr] = FUNC-user-input(fun-type)
}
Listing 4. Outline LSD specification for the user agent
15
geometric-objec@,name-curr] is created. Agent R-csg-conversion. which is also active in this mode, simultaneously checks the validity of the gob-descr--fun introduced and sets the appropriate value of the variable fim-raBd[gname-curr]. The DEt/I~\-kTE message which appears on the display screen is set by the agent modelling according to the value of this variable. Provided that fim-ralid[oname-curr] is TRUE, the agent R-csg-con,~'ersion creates an internal representation of the geometric object csg,-tree[gname-cm-r] in accordance with its PROTOCOL. The DERIV-~TE gob-ralue[gname-curr] that is the value of the descriptive function at the point point-instance of the modelling space (the origin of the coordinate system, bv default) is sinmltaneouslv evaluated. And this is the end of the chain of actions connected with this particular mode.
In the sequel, userAnterpretation, responding to the message displayed, can set the next user-conclusion. Entering the mode g,et-xdsualAmage, for example, will invoke both visualization and point-membership-rdation, which is implicitly used in evaluating FUNC-visualize. The agent point-membership-relation can also be used directly when user wants to classiC- a particular point with respect to a particular geometric object. In this case. introduction of the coordinates of the point x[i] and the gname-curl" leads to the indivisible sequence of evaluations: pointAnstance in point-in-space. followed by gob-value[g,name-curr] in geometric-object[gname-curr]. then point-membership-~'alue in point-membership-1"dation, and finally message in modelling.
The complete LSD specification provides a clear and concise description both of the interaction between user and modelling system and of the main processes taking place through interaction between the components of the modelling system. In particular, the descriptions of the user sub-agents specie" what interface to the system is needed in each specific mode. Since the LSD specification indicates what agents act concurrently during the modelling process. it can also be viewed as a preliminary specification for a parallel implementation of the modelling system.
)
Morphing between CSG-objects as a case-study
The exploratory geometric modelling process described in this paper is illustrated bv a case-study concerned with morphing between two CSG objects. Such a morphing is considered as a 4-dimensional operation. If the geometric objects gobI, gobg have descriptive time-tions f. g respectively, the resulting geometric object is gobh. where h is defined by
h(x.g.z.t) = a(x.y,z.t)f(x,y.z,t)(1 - t) + b(x,y,z.t)g(x,g,z.t)t
and a and b are positive real-valued "modulation functions" that influence features of the visual sequence of frames. Defining these functions for particular objects is a problem that can only be solved effectively through exploratory geometric modelling.
We consider morphing between prechair and chair as a particular case-study. We develop this case-study by extending the definitive script obtained by concatenating the scripts in Figures 1 and 2, and using the default geometric types as described previously. In this context, the above formula takes the form:
gob-sculpturing-chair = al*gob-prechair * (1-x4) + a2*gob-chair*x4;
Figure 3--generated using the interactive geometric system Hyper-surf [7J--depicts corresponding visual sequences of frames generated for 4 different values of the time parameter x4.
When we define the parameters al and a2 to be 1, observation of the sequence of images shows that the morphing is unsatisfactory. Inspection of the specification shows that this is due to the different "'densities" of the objects. Vv'e accordingly choose al much larger than a2, and redefine al to be 10. This morphing is more satisfactory, but there are some undesirable features in the region of the chair arms. The form of the corresponding descriptive function and some experiments suggest the following functional form for a2:
a2 = l+95*e**(-abs(x2)):
with peak value at x2 = 0. The morphing process is now satisfactory. Of course, the process of experiment and observation can be taken further until an even better result is achieved.
17
time = 0 t/me = 1
time = 0.25
time = 0.5
al = 10
a2 = 1 + 95e-lyl
Figure 3. Four steps of the morphing process
Conclusion
In principle, R-function representations can be used to give precise and subtle specifications of complex geometric objects. The methods of exploratory modelling outlined in this paper have already made it possible to develop an impressive range of useful construction techniques. To derive the maximum benefit fl'om the approach. we propose to develop an interactive environment, based on definitive principles, that exploits an extended set of symbolic operators (such as symbolic differentiation, search for global extremum etc.). Operators of this nature have already been introduced by Snyder [12] within a procedural programming framework.
Our LSD specification can be interpreted operationally using definitive scripts to represent computational state. We are currently developing a sequential implementation in the interactive environment supplied by EDEN [3]. An alternative approach, better suited for a parallel implementation, is to exploit the concurrency in the specification in the computational fl'amework of the Abstract Definitive Machine [4].
A complementary concern is that of exploiting our exploratory modelling technique in a design context. For this purpose, we must provide a practical interface for a designer who has no specialist mathematical knowledge, and make it possible to construct R-function representations from object descriptions better suited to conceptual design. It is particularly important to make provision for references to characteristic points and special features of objects. and to enable the user to develop suitable R-function representations based on these. Issues for future research include effective methods for generating R-function representations:
• to reflect the construction of an object from a component hierarchy--as in separating a chair into the parts that would be separately manufactured,
• to capture the flmctionality of geometric objects, so that redefinition of parameters in a script can be used to represent physical operations--as in rotating or tilting the seat of a chair.
• to develop exploratory modelling techniques combining shape modelling with complex motion using a set of special time-
[1]
[2]
[3]
dependent transformations--as in investigating tile problems of moving a chair fl'om one room to another.
Much previous related work has been done on the use of definitive scripts in conjunction with agent-oriented modelling in engineering design [2]. The advantages of using such a modelling paradigm in conjunction with simple 2-dimensional visualization techniques have been demonstrated in several case-studies, and the possibility of generalizing this work to higher dimensions has already been investigated. The research described in this paper has close points of contact with the design and partial implenlentation of a definitive notation for geometric modelling CADNO as first introduced in [3]. CADNO is centralh" concerned with developing an abstract framework within which many different ways of specifying and referencing geometric objects can be unified. The versatility and homogeneity of R-flmction representations suggests that they are well-suited to complement the object representations conceived in CADNO.
Ack nowledgement s
We are grateful to Steve Russ and "t~m Pui Yung for useful discussions relating to this paper, and to Alexei Sourin and Nick Hollowav for software support. \Ve are indebted to the Royal Society for supporting Valerv Adzhiev under its Postdoctoral Fellowship scheme. and to the SERC for financial support under grant GR/J13458.
References
W.M. Beynon, Y.P. ]~ng. A.J. Cartwright. P.J. Horgan, Scientific visualization: experiments and observations. Proc. 3rd Eurographics W/S on Visualization in Scientific Computing, Viareggio, (157-173). 1992.
W.M. Beynon. I. Bridge. Y.P. Yung, Agent-oriented modelling for a vehicle cruise control system, Proc. ASME Conf. ESDA '92, Is-tanbul, (159-165), 1992.
W.-Xl. Beynon. A.J. Cartwright, A definitive programming approach to the implementation of CAD software, Intell. CAD Systems II: Implementation Issues. Springer Verlag, (126-145), 1989.
[4]
[7]
[8]
[9]
[10]
[11]
[12]
W.M. Beynon. M.D. Slade, Y.W. Yung, Parallel computation in definitive models. Proc. CONPAR '88. BCS Workshop Series. CUP. (359-367). 1989
[5]
[G]
M. Hartquist. PADL-2 User Manual. 1983.
C. Hewitt, Viewing control structures as patterns of passing messages Artificial Intelligence. 8. (323-364), 1977
A.A. Pasko. V.D. Adzhiev. I.A. Prostakov, Multivariate function visualization: the inductive approach. Proc. 3rd Eurographics W/S on Visualization in Scientific Computing. Viareggio, (303-316). 1992.
A.A. Pasko. V.V. Savchenko. V.D. Adzhiev, A.I. Sourin. Multidimensional geometric modeling and visualization based on function representation of objects. Teeh. Report 93-1-008, Dept. of Computer Software. The University of Aizu, Japan, September 1993.
A.A. Pasko. V.V. Savchenko. Blending operations for functionally based constructive geometry, ibid.
V.L. Rvachev. On the analytical description of some geometric objects. Doklady of Ukrainian Academy of Sciences, 153.4. (765-767), 1963.
V.L. Rvachev. Methods of Logic Algebra in Mathematical Physics. Naukova Dumka Publishers. Kiev, 1974.
J.M. Snyder. Generative Modeling for Computer Graphics and CAD, Academic Press. 1992.
I