Introduction to AutoCAD Architecture

In the Autodesk product line, in addition to the basic AutoCAD, there are many specialized products optimized for various design areas. One such product is AutoCAD Architecture. As with AutoCAD, AutoCAD Architecture can write .NET plugins. In addition to libraries from Autodesk for working with AutoCAD Architecture objects, you can use the Teigha for Architecture C ++ library, which allows you to load, draw, and manipulate such objects.

Initially, I wanted to write a series of tutorials demonstrating how to work with architectural objects using .NET and Teigha for Architecture, but the introduction to the series of these tutorials has grown into a separate article, which is available under the cat.

There is nothing about programming in the article below. It was written to give a superficial idea of ​​what AutoCAD Architecture is, what objects are implemented in it and what are their features.



AutoCAD Architecture (abbreviation ACA) is a specialized application based on AutoCAD, Autodesk's flagship product, designed for architectural design needs. The first version of ACA was released in 1998 and has since been updated approximately once a year. Currently, the latest version of ACA is called AutoCAD Architecture 2016.

Why did you need to create such a product?

Consider several architectural drawings made using ACA:

Typically, architectural drawings contain buildings or parts of buildings that consist of parts such as walls, windows, doors, roofs, stairs, etc.

In AutoCAD (AutoDesk's core product), drawing primitives are lines, polylines, blocks, circles, arches, callouts, text, etc. The door to AutoCAD had to be drawn in lines and saved in a separate file (for reuse).

If the object has different geometry in 2D and 3D representations (or generally depends on the view direction), then all these options had to be drawn manually and placed in the right one. Looking at the first drawing, we can assume how laborious it is to draw each representation of the object.

In addition, in real-life tasks, drawings are often modified. For example, if in drawing # 1 when using AutoCAD there was a need to move the window, then it would be necessary to change both 2D and 3D views in a consistent manner.

To move the window on the plan, you need to move the window itself, restore the wall in its place, and on the new one - draw an opening. And then do the same for the 3D model. If there are more types, then you will have to make edits in each form. With such changes, it is easy to make mistakes or inconsistencies between species.

ACA implements special tools and object libraries that facilitate and accelerate architectural design. In AutoCAD Architecture, “window” and “wall” are objects that have relationships and behavior. The window “knows” that it is attached to the wall, and the wall knows about the existence of the window. When the window moves, the wall will automatically change its geometry, creating a hole in the new position of the door and removing the hole in the old position. When the wall moves, the door will move with the wall. If you remove the wall, then all the windows and doors that were in this wall will also be deleted:

The drawing model is one. To make a two-dimensional plan view, you only need to switch the view. Editing any view, the whole model is edited:

All sections and floor plans associated with this model are automatically updated when the model changes, which reduces the possibility of errors and inconsistencies in the architectural drawings, and also significantly speeds up their creation.

ACA objects communicate with design documentation. Changes in the drawing automatically change the documentation, which avoids errors in it:

Types of primitives in ACA

In addition to the standard AutoCAD primitives, ACA has the following basic primitives (English):

1) Walls

2) Stained-glass windows (Curtain walls). Stained glass windows consist of one or more nets. Each grid in the stained glass window is divided into cells horizontally or vertically, but the grids can be combined by the method of attachment in order to obtain a variety of combinations, from the simplest to the most complex.

3) Doors, windows, openings, door and window assemblies (Doors, Windows, Openings, DWA):

4) Stairs and railings (

5) Roofs, ceilings and roof slopes (Roofs, Slabs and Roof Slabs):

6) Bearing elements (Structural Members). A load-bearing element is an object that can be a beam, a brace or a column in the drawing. All created beams, braces and columns are subtypes of the same object - the bearing element.

7) Auxiliary primitives: AD polygons, mass elements, 2D profiles

What are ACA primitives?

ACA objects are AutoCAD custom objects implemented in a group of separate libraries called ACA enablers. The DWG format is used to save and load ACA objects, but these libraries are required for displaying and working with such objects.

In essence, an ACA object is a C ++ class. The geometry of the object is calculated during rendering and depends on its settings (and not predefined).
For example, in the screenshot below you can see some parameters of the doors in the dialog box: width, height, rise, alignment, style, etc. The doors in the screenshot differ only in width and opening angle, but based on these data the difference in geometry is significant.

Key Features of ACA Objects

Without delving into the interconnections and details, we consider the main features related to ACA objects:
1. ACA objects are assigned a style that determines the appearance (and partially the behavior).
2. ACA objects are viewport dependent. They draw a different view of themselves in different views. By representation is meant geometry. For example, a wall in isometry is usually rendered as a 3D model, and in a top-view as a rectangle.
3. The geometry of ACA objects consists of individual components. Each representation of an object has its own set of components.

ACA objects assigned a style that defines the appearance of the object

For example, two doors are shown below. They behave like doors in the sense that they can be inserted into the wall, added to the documentation, and when the wall moves, they will also move. But they look different, as they are assigned a different style.

Styles of objects can be very complex. For example, below are also doors (and windows).

The style needs to be created only once, and then you can add any number of doors of this style. Changing the style will entail changing all the doors that have this style.

ACA feature geometry is view dependent

The figure below shows the same model. Only view changes - the direction under which the camera "looks" at the object. Depending on the settings and direction of the camera, ACA objects render different geometry. The geometry of the object in each view reflects the logic of the given view and is not related to the geometry in other views.

AutoCAD had to draw each view manually. Moreover, if there are several types of doors in the building, then each of them had to be drawn for all use cases.

ACA Architectural Libraries already contain a wide range of predefined styles. For example, the drawing below shows some types of doors with styles from the library:

ACA feature geometry is composed of components

The geometry of an ACA object consists of several separate components. Geometry is usually divided into components according to the logic of the physical world. So the window components can be a frame, glass, sashes and so on.

For example, consider a door in 3D. The components that make up the drawn door are visible in the open list. For each component, you can change its properties (color, type of lines, etc.), and also show or make it invisible.

In different representations, an object has different components. The door in top view (plan representation) has a different geometry and, accordingly, a different set of components of which it consists.

Documentation Objects

The following “primitives” exist for creating documentation in ASA:
• 2d sections
• Dimensions
• Schedule tables
• Spaces

Documentation objects are also designed to work with architectural objects and have additional logic. As an example, consider dimension lines:

When working with ACA-dimensions, there is no need to manually draw the dimensions of each object. When we attach a dimension object to a wall, the dimensions of windows, doors, and openings are set automatically. When the openings move, dimension lines are automatically redrawn to reflect the current state of the drawing. If we move the wall, the dimension lines will automatically move behind the wall. When objects are deleted, parts of the dimension lines that belong to these objects will also be deleted.


Above, I tried to give a superficial idea of ​​the ASA and the objects that are “primitives” in it. Working with the architectural drawing in the ASA is that we draw the building not with low-level AutoCAD primitives (lines, circles, arches, etc.), but with the help of higher-level primitives, such as walls, windows, doors, roofs. When the model is created, based on it, you can automatically generate documentation, 2D projections, floor plans, sections. The presence of behavior in objects facilitates the task of further modifying the drawing and allows maintaining the documentation up to date.

Also popular now: