building assembly detailing using constraint-based - researchgate

Building assembly detailing using constraint-based modeling

K. Nassara,*, W. Thabetb, Y. Beliveauc

aDepartment of Civil Engineering and Construction, Bradley University, 126 Jobst Hall, 1501 W. Bradley Avenue, Peoria, IL 61625, USAb123 D Burruss Hall, Blacksburg, VA 24061-0156 540.818.4604, USA

c122 E Burruss Hall, Virginia Tech., Blacksburg, VA 24061-0156 540.818.4602, USA

Accepted 4 September 2002

Abstract

Constraint-based geometric modeling entails specifying geometric constraints to control the locations of the components in

an assembly. Consequently, any future modifications of the components are governed by these constraints. In this paper, a set of

constraint-based assembly operations for generating 3D details of building assemblies are presented. The operations constrain

the locations and orientations of the components in a building assembly through a series of constructive steps and therefore

allow for easier modification. These operations are used in a modeling system that extends the idea of constraint-based

modeling to detailing architectural building assemblies. The system utilizes the constraint-based assembly operations, which

employ traditional geometric constraints integrated with a set of constructive assembly operations. The constraint-based

assembly operations allow for a more systematic generation of the assembly details, which can save repetitive work and reduce

mistakes resulting from copying and pasting old details. Also, the technique allows the assemblies to be studied and analyzed.

To illustrate this idea, a prototype 3D constraint-based system for assembling three-dimensional architectural details was

developed. With the proposed system, the details of building assemblies do not need to be reinvented for every project.

Examples of the proposed approach are provided and its limitations and benefits are discussed.

D 2002 Elsevier Science B.V. All rights reserved.

Keywords: Constraint-based modeling; Assemblies; Building details

1. Introduction

During the early and mid-1980s, CAD was gaining

ground and becoming an efficient alternative to the

drafting table. With the increased use of CAD, archi-

tects were continuously devising ways to automate

drafting and design tasks in order to increase their

efficiency. Repetitive tasks were automated using

predefined scripts, utilizing the various scripting lan-

guages offered in the CAD systems (e.g. AutoCAD’s

AutoLISP). Object-oriented data was added to lines,

arcs and circles, and systems began recognizing them

as doors, windows and doors. Object data was then

extended to the third dimension, so architects could

work in 2D and 3D. A number of software tools were

devised in which architects can define their designs in

3D and the complete object model is maintained by

the system. This started with simple ‘‘house model-

ing’’ software marketed to help non-architects define

their ‘‘dream house’’ (e.g. Home Architect, Home

0926-5805/02/$ - see front matter D 2002 Elsevier Science B.V. All rights reserved.

doi:10.1016/S0926-5805(02)00090-0

* Corresponding author.

E-mail addresses: [email protected] (K. Nassar),

[email protected] (W. Thabet).

www.elsevier.com/locate/autcon

Automation in Construction 12 (2003) 365–379

Designer, etc.. . .). The idea was then extended to

professional software like Triforma, Architectural

Desktop and ArchiCad.

Concurrently, in the mechanical design realm,

parametric modelers were being introduced. The con-

cept behind these modelers is that a user defines a set

of parameters that in turn drives a 3D model. This

means that changes in any parameter are propagated

to the rest of the model. Additionally, various 2D

details can be extracted from the model. In the

architecture realm, Revit [14] first introduced this

concept commercially. Revit is a parametric modeler

that acts on parametric components (e.g. doors, win-

dows and doors), and annotations (e.g. dimensions

and grids) and parametric views (e.g. plans and

sections) to ensure bidirectional association between

the elements of design. When changing the location or

size of a window in a floor plan, for example, the

change is reflected in all views like elevations and

perspectives. If a dimension measuring from the end

of a wall to the center of a window is changed, not

only will Revit move the window, but also any other

windows parametrically related to it. This parametric

model of the building, which is driven from a single

integrated database, is what makes Revit unique.

Simultaneously in the mechanical design realm,

constraint-based modelers, like Mechanical Desktop

[8], were being introduced and used. Constraint-based

geometric modeling entails specifying geometric con-

straints to control the locations of the components in

the assembly. Consequently, any future modifications

of the components are governed by these constraints.

The constraints are used to relate two components

within an assembly to control their positions and

orientation relative to one another.

Similar concepts in architecture were described in a

number of research studies as early as the 1960s [4].

Gross [1] described a system where building compo-

nents can be assembled using ‘‘Lego-style’’ con-

straints that guide the placement of the components

in the building. The constraints mainly relate to the

various grids and modules used for the various sys-

tems in the building. Harfmann and Chen [5] and

Harfmann et al. [6] also proposed a system where the

various components of the building are linked

together using constraints. An integrated database that

stores all this information is maintained by the system.

Frazer [2,3] described how constraints could be used

to describe the rules of the physical and spatial

structure of architecture designs, which he called

plastic modeling. Kilkelly [7] described a comprehen-

sive approach for construction drawings. The

approach employs object-oriented entities to specify

the composition of construction drawings and details.

This paper presents a graphical modeling system

that extends the idea of constraint-based modeling to

detailing architectural building assemblies. The sys-

tem utilizes constraint-based assembly operations,

which employ traditional geometric constraints inte-

grated with a set of constructive assembly operations.

The constraint-based assembly operations allow for a

more systematic generation of the assembly details,

which can save repetitive work and reduce mistakes

resulting from copying and pasting old details. Also,

the technique allows the assemblies to be studied and

analyzed more rationally than traditional techniques.

To illustrate this idea, a prototype 3D constraint-based

system for assembling three-dimensional architectural

details was developed. In the next section, the concept

of constraint-based assembly operations is presented.

2. Constraint-based modeling for architecture

details

2.1. Overview

One of the current practices for generating the

details is to store details of the various assembly types

in a detail library (which can be in an electronic

format) and retrieve the details for each new design.

However, the possible permutations and combinations

that can be encountered are too many and oftentimes

the current detail can be different from the retrieved

library detail, resulting in design errors. The shapes,

locations or number of components in the new

selected detail can be different. Therefore, the re-

trieved detail becomes invalid and must be modified

or drawn again. This paper introduces the use of

constraint-based assembly operations to help the

designer in the generation of building assembly details

and overcoming the need to recreate the detail for

each new design. Constraint-based assembly opera-

tions are essentially a set of constructive operations

that act on components of the assembly to place them

in the correct position within the assembly.

K. Nassar et al. / Automation in Construction 12 (2003) 365–379366

In architectural practice the details are generally

drawn separately from the main plan, elevations, and

sections. In constraint-based modeling, on the other

hand, the generated detail is based on an abstract 3D

representation of the assembly. The designer provides a

3D model of the building in terms of abstract building

assemblies (such as that of Fig. 1). This is analogous to

many of the commercial CAD tools (e.g. AutoDesk’s

Architectural Desktop, Graphisoft’s ArchiCad, and

Bentely’s TriForma, and recently Revit). In this

abstract representation of the building, each assembly

is modeled as a separate 3D entity. Once the building is

modeled in 3D, the constraint-based modeling opera-

tions can be used to generate the detail for a specific

assembly (or a set of assemblies). Of course, it is

possible to generate a complete set of details for all

the building. However, this is generally not needed in

practice and would make the model undecipherable.

Architects usually concentrate and generate details of

specific assemblies that are critical or need more

explanation. Also, once the detail is generated, the

original abstract 3D representation of the building still

exists. This allows for viewing the complete 3D model

of the building at different levels of detail.

Constraint-based modeling operations can help to

cut the time it takes to modify the detail and generate

new ones and also to minimize the errors resulting

from current cut-and-paste practice of details. In order

to illustrate this concept, the properties of the abstract

3D representations of the assemblies and the compo-

nents used in the proposed building assembly detailing

system are first presented. Then, the set of constraint-

based modeling operations are described next. This is

followed by a discussion of the syntax and use of the

system along with an example. Finally, the computer

implementation is described and conclusions are

drawn.

2.2. Abstract representations and work-features

Once the building is modeled as a set of abstract

building assemblies in 3D (e.g. Fig. 1), it is possible to

Fig. 1. An example of an abstract 3D model of a house modeled in ArchiCad.

K. Nassar et al. / Automation in Construction 12 (2003) 365–379 367

concentrate on a specific assembly (or set of assem-

blies) and generate the details accordingly. In the 3D

building model, a solid model or CADREP (short for

CAD representations) represents each of the assem-

blies in the building and components in the detail.

Hence, two types of CADREPs are identified here:

assembly CADREPs and component CADREPs. Var-

ious component CADREPs are shown in Fig. 2. In

order to generate the 3D solid model of a complete

assembly detail, some constraints that describe how

these component CADREPs fit together within the

context of the whole assembly have to be added. When

two parts are constrained (which can be either two

component CADREPs, or one component CADREP

and one assembly CADREP), generally one geometric

feature of one part is related to another geometric

feature of the second part. Geometric features that

can be used to create constraints are faces (both planar

and curved), axes, points (end, mid, center, and others),

and edges. A cube, for example, has 12 edges, 6 faces,

and 16 standardized points. In this paper, these geo-

metric features are called work-features. Therefore,

work-features can either be work-points, work-axes

or work-planes (as shown on the upper right compo-

nent CADREP in Fig. 2).

These work-features are referenced in the con-

straint-based operation (discussed next) to place the

components in their correct positions. Each work-

feature can be either relative or absolute. A relative

work-feature relates to the main 3D assembly in

relative proportions only. For example, one can define

a work-axis to be in the center of the assembly

CADREP, or a work-point to mark the upper left

corner of an assembly, or a work-plane relates to the

upper surface of the assembly CADREP. These rela-

tive work-features allow the CADREP to be scaled,

rotated or transformed, and still retain these work-

features in their corresponding relative positions. The

absolute work-features on the other hand, relate to

discrete locations on the assembly of the CADREP of

the component. For example, a work-axis can be

defined so that it is 1 in. from the left edge of the

assembly.

Given the assembly and the component CADREPs

and their respective work-features, the next step then

is to place the components in their correct position

Fig. 2. Examples of component CADREPs.


within the assembly using the work-features and the

constraint-based operations.

2.3. Constraint-based assembly operations

The constraint-based operations used here are

essentially declarative constraints packaged within a

set of assembly operations. First, the declarative

constraints are discussed and then the suggested as-

sembly operations are presented.

2.3.1. Declarative constraints

Declarative constraints relate the location of two

objects together. Declarative constraints can be used

to restrict the locations or orientations of certain

objects in the model. For example a mate constraint

can be used to insure that the beam object is geo-

metrically located flush with a column as seen in Fig.

3. In this case, the mate constraint takes four param-

eters: the two objects to be constrained and two

vectors on the objects to describe how to mate them.

Once the constraint is specified, any modifications to

the assembly have to comply with the set constraints,

and a new assembly detail can be generated. The new

details reflect the correct location of the components.

So if the size of the beam in Fig. 3 changes for

example (or the column is moved or resized), the

model will be updated to reflect the new size marinat-

ing the flush constraint.

The mate constraint in Fig. 3 is only one type of

constraint. Various generic constraint sets have been

proposed in the literature. However, there are, as yet,

no standards for specifying or representing con-

straints [13]. Fig. 4 shows an example of generic

classification of declarative constraints [12]. The

constraints are divided into two main groups: ori-

entation and position. The position constraints are

used to define distances between two points as

constraints. They specify the distance measure from

a reference entity to a target entity. The orientation

constraints are divided into five types: parallel,

perpendicular, angle, coplanar and coaxial. Another

set of declarative constraints is offered in a commer-

cial constraint-based modeler, AutoCad Mechanical

Desktop. This program allows users to specify four

kinds of constraints: AMINSERT (insert), AMAN-

GLE (angle constraint), AMFLUSH (flush con-

straint), and AMMATE (mate constraint) as shown

in Table 1. Mechanical Desktop was used as the

constraint-based engine for the prototype system

developed in this research, and hence these con-

straints are used here. Next, a description of how

these declarative constraints are integrated within the

constraint-based assembly operations is presented.

2.3.2. Assembly operations

Although the discrete parameters in traditional

constraint-based modelers like Mechanical Desktop

can be changed (e.g. the length or width of an

element, a radius of cam, etc.. . .), the parameters of

the declarative constraints (the CADREPs themselves)

have to be changed manually. For example, in order to

Fig. 3. Examples of constraints.


change parameters like the shape of an element (e.g.

new brick shape), one has to manually do so and then

refine the model again.

Furthermore, when modeling building assemblies

using constraint-based modeling, one often needs to

resort to a number of steps in order to achieve the final

effect [11]. In building assemblies, for example, there

are usually repetitive objects. For example, the CMU

units or the metal ties are repetitive objects with the

same solid model. If we were to specify these units

separately, the modeling time would increase signifi-

cantly. A solution might be to define a 3D ARRAY

operation that can used to create objects and then

constrain the final set of objects as a whole using the

traditional geometric constraints. In addition, the

sequence of the assembly process itself could be

important for further analysis of the properties of the

objects.

Fig. 4. Different kinds of constraints, adapted from Ref. [12].


Therefore, a set of constraint-based assembly oper-

ations is proposed. These operations can be used to

specify the sequence of operations to constrain the

locations and orientations of certain objects in relation

to others. The set of constraining operations are con-

structive steps that place geometric elements relative to

each other. This approach is often called constructive

specification [10,11].

The operations and the constraints associated with

them are shown in Table 2. They are a combination of

constraints and standard solid modeling operations.

Each operation takes component CADREPs of a par-

ticular type as its parameters. For example, the ‘‘LAY-

OUT’’ operation in Fig. 5 operates on CADREPs that

are to be placed at certain intervals and can take, for

example, the metal ties CADREPs.

Each operation also has a set of parameters asso-

ciated with it. The ‘‘LAYOUT’’ operation, for exam-

ple, has the spacing parameter ‘s’ to determine the

spacing between the elements. Note that in the

LAYOUT constraint, all the work-features are on

the same plane.

The ‘‘ASSEMBLE’’ operation is the operation

used to connect components together. It can also be

used to place a component or assembled components

in relation to an assembly. The ‘‘STACK’’ operation is

used for masonry type CADREPs and can take a brick

or a CMU CADREP as an input. This is a combina-

tion of a 3D ARRAY command and both an ANGLE

and FLUSH constraints. ‘‘COVER’’ is the operation

for overlaying material over a surface like tiles, ply-

roofing, etc.. . . ‘‘CUT’’ operation is used to penetrate

or trim components, e.g. wood. This is a standard 3D

SUBTRACT command followed by an ASSEMBLE

constraint.

2.4. Operations syntax

Constraints usually have a target and a reference

entity. The target entity is the entity that is to be

constrained, while the reference entity is the entity

the target is constrained to. The target and reference

entities can be component CADREPs within an assem-

bly or they can be assembly CADREPs themselves. In

order to specify the constraints in each operation, the

target and reference entities are actually the work-

features on the assembly and component CADREPs.

For example, the ‘‘ASSEMBLE’’ operation will take

two points, e.g. one on the component CADREP and

the other on the assembly CADREP (these have to

satisfy a coincide constraint along with two directions

that have to satisfy a coaxial constraint).

In effect, this constraining operation is equivalent

to combining more than one of the Mechanical Desk-

top constraints in relation to building elements. For

example, the

LAYOUT ðObject A; P1; D1; Object B; P2; D2; sÞ

This is equivalent to a standard 3D ARRAY oper-

ation followed by a MATE constraint and a FLUSH

Table 1

Constraints in mechanical desktop

Constraint Description

Mate To join points, axes, planes, or non-planar faces.

Insert To align two circles, including their center axes

and planes, use the Insert constraint.

Flush To make two planes coplanar with their faces

aligned in the same direction, use the Flush

constraint.

Angle To control an angle between two planes or two

vectors, use the Angle constraint.

Table 2

The defined constraining operations

Operation Geometric work-feature

parameters on reference

Geometric work-feature

parameters on target

Building parameters Example

Layout one point, one line one point, one line spacing metal ties, fixtures

Assemble one point, one line one point, one line – bolts, screws

Cover one point, one line one point, one line,

start point, end point

angle, spacing, overlap tiles, sheet rock

Cut one point one point, one line angle sawing wood

Stack one point, one line one point, one line,

start point, end point

vertical joint spacing,

horizontal joint spacing

masonry


constraint. The points P1 and D1 are work-features

defined on the CADREP of Object A, i.e. a work-point

and a work-axis. Similarly P2 and D2 are work-

features defined on the CADREP of object B.

The constraining operations required for the detail

shown in Fig. 6 are shown. The user of the system

would define the 3D model of the building, similar to

the simple block building shown in upper left corner of

Fig. 6. The 3D model of the building is defined using

assembly CADREPs (i.e. columns, walls, roofs,

etc.. . .), which are instanced from base CADREPs.

This is similar to defining 3D blocks in AutoCAD that

resemble the different assembly CADREPs and then

inserting (rotating, scaling, and moving around) instan-

ces of these blocks to define 3D model of the building.

The operations required to generate different

details would then be defined, such as those required

to generate the simple Column–Metal ties–CMU

Fig. 5. The LAYOUT and ASSEMBLE operations.


assembly in Fig. 6. Alternatively, assembly operations

can be restored from a library of saved operation sets.

These saved sets would specify the operations re-

quired to generate different details. Once the opera-

tions have been specified for an assembly detail, a

user would then select a particular abstract assembly

CADREP in the model and apply the defined oper-

ations to generate the detail. Furthermore, the same

operation set can be used to generate other details with

different CMU shapes, spacing, or metal-tie shapes or

spacing by changing the parameters of the operations

and without the need to draw a new model again.

Notice that in this simple example an assembly

Fig. 6. The operations for a simple example.

Fig. 7. The sectioned 2D details.


Fig. 8. The example stair assembly.


CADREP itself (the column CADREP) is used as part

of the complete detail. The hidden lines can be

removed and the detail can be rendered with texture

if required. Once these operations are defined, the

same set of operations can be applied to different

column CADREPS in the 3D model that are instances

of the column CADREP used in the original definition

of the assembly (for example, the same detail can be

generated by selecting any of the columns in simple

block building shown in Fig. 6).

The operations relate to actual construction oper-

ations. This has the benefit of simplifying constraint

definition, since a designer can relate more easily to

these operations than abstract geometric operations

and constraints. More importantly, since the described

operations relate to building components, each com-

ponent will be associated with the same operation

regardless of the CADREP used. For example, a

‘‘Vinyl Tile’’ component will always be associated

with the ‘‘COVER’’ operation. This allows us to draw

a multitude of building assembly details in 3D with

this concise set of operations.

The created assembly detail is a solid model. This

means that the assembly can actually be sectioned in

many ways to produce different 2D details if desired.

Examples of 2D details generated from the solid

model of the detail of the developed example above

are shown in Fig. 7. To increase the robustness of the

assembly operations, the resulting ‘‘subassembly’’ of

one operation can be used as an input in the following

operation. This is demonstrated using the following

stair example.

2.5. A stair example

Consider the stair example in Fig. 8. Originally, the

stair assembly was modeled as an abstract 3D assem-

bly as shown. A set of operations is required so that

they can then be applied to the selected abstract

assembly CADREP and generate a detailed assembly

such as that shown. There are four components

represented by CADREPs (T, C, H, L). Given these

four components, the sequence of the constraining

operations is defined as shown. First, a CUT operation

is used on C to cut out the place of T and similarly for

the place of H. Then a LAYOUT operation is used to

layout C along T. Next, two ASSEMBLE operations

are used to assemble the rest of the stair assembly.

Notice that the results from one operation can be used

as input in the next.

There are several benefits from this approach. By

representing assemblies in that way, one can easily

change the size, shape or number of components or

subassemblies in an assembly and the changes can be

propagated accordingly. For example, in the previous

stair assembly, if the user decides to use two carriages

instead of three, then he or she would have to modify

the parameters of the LAYOUT operation in step 4

and a modified detail would be generated (Fig. 9). A

prototype system that incorporates most of function-

alities of constraint-based assembly operations was

developed and is described next.

3. Computer implementation

In this section a brief description of the devel-

oped prototype system is presented. The prototype,

EASYBUILD, was developed as an extension to a

popular commercial CAD package: AUTOCAD. One

of the reasons AUTOCAD is a popular package is its

ease of customization. AUTOCAD offers a multitude

of ways to develop customized applications on top of

the regular drafting interface. Different tools exist for

developing application extensions in AUTOCAD,

including AutoLisp, Visual Lisp, C++ and ADS and

Visual Basic For Applications (VBA). In this re-

search, the development tool used for implementing

EASYBUILD was VBA. The reason for choosing this

development tool is its ease of extension and compat-

ibility with several other software packages like data-

bases and spreadsheets [9]. Visual Basic was first

introduced in AutoCad Version 14. The assembly ge-

neration module of EASYBUILD consists of three

main modules, the Assembly/Component Definition

Fig. 9. The modified details of the stair assembly with two carriages.


Module (ADM), the Constraint Editor (CE), and the

Modeling Module (MM).

3.1. The Assembly/Component Definition Module

(ADM)

The ADMhas twomain functions. Firstly, the ADM

is the module that allows the user to define the

CADREPs of the different components and assemblies

as solid models. These are stored as blocks in AUTO-

CAD so that they can be retrieved and instanced when

drawing the building in the modeling module. Sec-

ondly, the ADM is where the users can model the

different components and specify the various work-

features for component CADREPs and assembly

CADREPs to be used in the constraint-based opera-

tions. This is accomplished by attaching Xdata to the

solid model of the component CADREP. Xdata is a

method in AUTOCAD for attaching geometric and

textual data to models so that they can be retrieved or

altered later. The user can specify various work-fea-

tures, like work-points or work-directions on the model

of the component as needed. (Fig. 10) shows the

interface of the ADM. The components and their

work-features defined in the ADM are stored in a

library in order to be retrieved when evaluating the

constraint-based operations. EASYBUILD also allows

the user to specify dummy geometries to be used in the

generation of the assembly detail.

3.2. The Modeling Module (MM)

The MM allows a user to model the 3D representa-

tion of the building using the various CADREPs of the

building assemblies. The building is modeled by

instancing the blocks of the assembly CADREPs

defined earlier in the ADM. These blocks can then be

rotated, transformed or scaled to define the building.

The system is currently limited to four assembly

CADREP types: walls, flat roofs, columns, and isolated

footings. Once the building is modeled, the next step

becomes to select one of the assembly CADREPs in the

Fig. 10. Defining work features in the Assembly/Component Definition Module (ADM).


model and apply the appropriate set of constraint-based

operations to generate the 3D detail of that assembly.

Currently, the MM cannot import 3D models from

other architectural modeling software (i.e. Architec-

tural Desktop or ArchiCad) and therefore, the building

currently must be modeled in the ADM. However, the

ability to import 3D building models would be a

useful addition to increase the versatility of the

system, and can be accomplished by using recently

developed universal standards such as the Industry

Foundation Classes (IFCs).

3.3. The Constraint Editor (CE)

This module is where the constraint-based opera-

tions are defined. The definition of the operations

required to generate the 3D building detail is carried

out in a text-editor interface. This interface allows the

user to specify the operations needed for a particular

assembly detail in the form of a set of sequential

commands. These commands are then parsed and

evaluated for each new design. Alternatively, the user

can retrieve a predefined set of operations saved

earlier or save the current set of operations to be used

later. The user would then select an assembly

CADREP and apply the loaded set of operations to

the selected assembly CADREP in order to generate

the 3D building detail. The system retrieves the

components from the predefined library of compo-

nents (defined in the ADM and applies the set of

operations, automatically generating the 3D detail.

Fig. 11 shows the interface CE. Currently, only the

ASSEMBLE, LAYOUT, and CUT operations are

functional.

Although the modeling succession can be different

from the actual construction operations, the designer

can visualize the assembly sequentially, in a system-

atic way. Assembly composition can be analyzed and

examined critically, by changing different component

shapes and sizes. This helps in analyzing the aes-

thetics and functionality of the assembly. More of the

benefits and limitations of this approach are discussed

below.

4. Benefits and limitations

The set of defined operation here is only prelimi-

nary. Nevertheless, using the limited defined set, one

can model a fair number of assembly details. How-

Fig. 11. The Constraint Editor (CE).


ever, one of the limitations of the system as it stands,

is the lack of error checks during the assembly

operations. For example, in the stair example above,

a CUT operation can be defined initially to ensure

that the length of the ledger component (L) is similar

to the width of the stair. However, if the length of

the ledger component CADREP used in the assem-

bly detail is smaller than the width of the stair, a

problem will arise. Adding conditional statements in

conjunction with the assembly operations can solve

this problem. Conditional statement can be used to

evaluate the different situations and guarantee a more

accurate detail. Conditional statement can also be

used for further analysis and decision-making about

the detail.

Another limitation of the current system relates to

the number of subassemblies that the system can

handle. The system can currently handle only up to

five levels of subassemblies. Although five levels of

subassemblies are sufficient for most details, this

limitation can be easily extended with appropriate

modifications to the system.

An important feature of this method is that the

designer modeling the assembly is concerned with

coordinating at most two components at any one time.

This is useful when modeling complex assemblies in

3D. Due to the fact that the designer can reuse the

solid models of the components and the subassem-

blies, shorter initial development modeling time over

both the traditional solid modeling approach and the

constraint-based approach results after a comprehen-

sive library of components and subassemblies has

been developed. Furthermore, this method offers an

increased ease of modification especially for complex

assemblies.

Benefits of the constraint-based approach also

include the ability to generate an animated sequence

of how assemblies are put together. Although the user

of this system is mainly the architect, suppliers,

contractors, or the construction manager who want

to study how these assemblies will be built can also

utilize this system. Architects do not always think in

terms of the construction sequence. However, if the

sequencing is considered in collaboration with the

construction manager, many on-site sequencing prob-

lems can be avoided. The system can be used before

construction to verify and test any sequencing prob-

lems before construction starts.

5. Conclusion and recommendations for future

research

Constraint-based modeling offers an efficient

method for generating building assembly details. A

set of constraint-based assembly operations was

defined. These operations can be used to specify

and constrain the components in an assembly through

a series of constructive steps. The constraint-based

assembly operations described here offer a systematic

method to create building assembly details. The

described method allows for more efficient modifica-

tion of 3D assembly details to fit a specific design.

With the proposed detailing system, architects do not

need to reinvent the details for every project. Instead,

they can concentrate their efforts and budget on the

overall design and on gradual refinement of the

details. With time, a library of details could be built

and details from the library could be modified for each

project as well as building new project-specific de-

tails. Moreover, the progression of the operations can

be a useful tool to consider different composition

options with real-time visualization. A prototype sys-

tem was developed and examples to demonstrate the

idea were presented.

Future work includes refinement of the selected

operations to remove redundancy and arrive at the

most efficient set of operations to simplify the process

of constraint definition. Also, a closer binding

between these operations and actual construction

sequence needs to be investigated. An integration of

the modeling sequence with the construction sequence

results in a kind of a 4D model that adds the time

dimension. This provides a visual representation of

how to actually build the assembly, which in turn can

be used for demonstration or educational purposes

also.

References

[1] M.D. Gross, Why can’t CAD be more like Lego? CKB, a

program for building construction kits, Automation in Con-

struction 5 (4) (1996) 285–300.

[2] J. Frazer, An Evolutionary Architecture, Architecture Associ-

ation Publications, 1995. ISBN 1-870890-47-7.

[3] J. Frazer, Plastic modelling—the flexible modeling of the log-

ic of structure and spaces, CAAD Futures ’87, Proceedings of

The Second Conference On Computer Aided Architecture

Design Futures, 1987, pp. 199–208.


[4] I.E. Sutherland, Sketchpad, A man–machine graphical com-

munication system, PhD Dissertation, MIT (1963).

[5] A.C. Harfmann, S.S. Chen, Component-based building repre-

sentation for design and construction, Automation in Con-

struction 1 (339–350) (1993).

[6] A.C. Harfmann, B. Majkowski, S.S. Chen, A Component-

Based Approach to Building Product Representation and De-

sign Development, CAAD Futures 1993, Pittsburg, 1993.

[7] M. Kilkelly, Off the page: object oriented construction draw-

ings, ACADIA 2000, October. Catholic University, Washing-

ton (DC), 2000.

[8] AutoDesk, Mechanical Desktop Users Manual (2000).

[9] B. Kramer, J. Gibb, AutoCAD VBA Programming Tools &

Techniques, Miller Freeman, San Francisco (CA), 1999.

[10] K. Nassar, A framework for the selection and generation of

building assemblies, PhD Thesis, Department of Building

Construction, Virginia Tech., Blacksburg, VA (1999).

[11] K. Nassar, Y. Beliveau, Integrating Parametric Modeling and

Construction Simulation, CIB ’99, Vancouver, Canada, 1999.

[12] J. Shah, M. Mantyla, Parametric and Feature Based CAD/

CAM; Concepts Techniques and Applications, Wiley, New

York, 1995.

[13] W. Hower, H. Graf, A bibliographical survey of constraint-

based approaches to CAD, graphics, layout, visualization, and

related topics, Knowledge-Based Systems 9 (1996) 449–464.

[14] Revit Technology Corporation, Revit’s Users Manual (2000).


building assembly detailing using constraint-based - researchgate

Documents