LAR-ABC, a Representation of Architectural Geometry from Concept of Spaces, to Design of Building Fabric, to Construction Simulation

Abstract

This paper discusses the application of LAR (Linear Algebraic Representation) scheme to the architectural design process. LAR is a novel representation scheme for geometric design of curves, surfaces and solids, using simple, general and well founded concepts from algebraic topology (Dicarlo et al., Comput Aided Des 46:269–274, 2014). LAR supports all topological incidence structures, including enumerative (images), decompositive (meshes) and boundary (CAD) representations. It is dimension-independent, and not restricted to regular complexes. Furthermore, LAR enjoys a neat mathematical format, being based on chains, the domains of discrete integration, and cochains, the discrete prototype of differential forms, so naturally integrating the geometric shape with the supported physical properties. The LAR representation find his roots in the design language PLaSM (Paoluzzi et al., ACM Trans. Graph 14(3):266–306, 1995; Paoluzzi, Geometric programming for computer aided design. Wiley, Chichester 2003), and is being embedded in Python and Javascript, providing the designer with powerful and simple tools for a geometric calculus of shapes. In this paper we introduce the motivation of this approach, discussing how it compares to other mixed-dimensionality representations of geometry and is supported by open-source software projects. We also discuss simple examples of use.

Appendix: Implementation Example

In this appendix we discuss a straightforward implementation of the LAR scheme, and discuss step by step the generation of geometric models in Fig. 11. They should be considered as simple BIM (Building Information Modeling) applications in the AEC (Architecture, Engineering, Construction) domain. The coding is in Python, which exhibits its full power in rapid prototyping developments. The Pyplasm package for geometric programming (see Paoluzzi 2003) is used, with higher-level functionals from FL (Backus 1978; Backus et al. 1989, 1990). Pyplasm operators are written all-caps.

1.1 Shape Input

The model data were entered through an editor for SVG (simple vector graphics), the W3C standard for vector graphics on the web. Several tools exist for interactively editing a SVG shape. We used the free web application svg-edit within a browser. Once parsed the input file, the points were scaled by a 1∕10 factor and snapped to a grid of integers, to compensate for low precision of the free input tool, that did not provides any snap, finally generating a list of points, given as a list of pairs of floats, named V, and two lists of lists of point indices.

Edges and faces describe the 2D and 1D cells partitioning the geometry, and are named here according to their meaning, i.e. FV (faces-by-vertices) and EV (edges-by-vertices), respectively. Edges and faces are given as lists of control points indices. Edge lists are ordered and will be rendered as Bézier curves.

A canonical (numerically ordered) description of 2-cells is used here, without any ‘topological’ ordering. Conversely, the control points of Bézier curves must be ordered according to the geometric shape of edges (point-valued polynomials of various degrees). Of course, this ordering does not affect the topological computations, but determines the geometric embedding of the shape. Notice, from Fig. 11, that the 2-cells are non convex, and that one of them is even non contractible to a point.

1.2 Kernel Functions

Only a few simple functionalities are required to implement the LAR scheme. As discussed in the paper, FV and EV are a CSR representation of binary matrices. In particular, kernel functions are needed to: (a) set-up the internal representation of CSR matrix format; (b) display the matrices in a readable way; (c) execute matrix transposition and matrix product operations; (d) update the value of non-zero matrix elements.

1.2.1 Conversion to Standard CSR Format

We use the sparse subpackage, provided by the Scipy package for scientific computing in Python, to handle sparse matrices efficiently. Faster implementations in OpenCL and WebCL for use from $C ^{++}$ and JavaScript, respectively, will be available soon. Presently, the matrix conversion to the internal format is executed by the csr function.

1.2.2 Display of Binary CSR Matrices

The display of a binary matrix starting from the CSR format is provided by the csr2mat function.

1.2.3 CSR Matrix Transposition and Product

Only two basic computational linear algebra operators are used, namely (a) to transpose a CSR matrix and (b) to multiply two CSR matrices. The computation of the EF: C ₂ → C ₁ operator is just implemented as follows. It is transposed below to FE for the sake of space. Notice that the product of binary matrices is an integer matrix, whose entry (i, j) denotes the number of vertices connoting the incidence of the edge j upon the face i. For instance, the first column below tell us that the (curved) edge 0 has 5 control vertices belonging to the face 0, whereas only 1 vertex belongs to face 1.

1.2.4 Computation of (Co)boundary Operators

The function maxFilter is used to get either the matrix [∂ ₂] from EF or the matrix [δ ₁] from FE. Of course, a boundary edge belongs to a face iff all edge vertices belong to (or generate a curved edge of) the face. Hence we search each row of the boundary matrix (column of the coboundary matrix) for its relative maxima element. The reader should compare columnwise the FE matrix above with the coboundary matrix below.

1.3 Making Solid Cells from b-Reps

The coordinate representation of boundary 1-chains of 2-cells is given by the rows of [δ ₁], i.e. by the rows of the coboundary matrix. Let first compute the boundary 1-chain of _2cells (from rows of the coboundary matrix). Here numbers denote edge numerals.

Notice that _2cells is a list representation of boundary 1-chains, whereas cells2D below is a list of geometric values, whose “exploded” value is shown in Fig. 2a.

A solid representation of 2-cells is computed by applying the SOLIDIFY algorithm⁴ to the piecewise-linear approximation of 1D edges (generated by the bezier function) of the face boundary. An exploded view of the ‘solid 2-cells’ is shown in Fig. 2b.

1.4 Boundary and Interior Computation

The boundary and interior 1-cells of the complex are computed in this section. The CSR rep of the total 2-chain (the set of all 2-cells) is put in _2chain as a column matrix.

Then the boundary 1-chain, as a list of triples (row, column, 1), is computed by the csrFilter(1, 0)(csrProd(boundary, _2chain)) expression, and the 1-chain _1boundarycells is constructed. A boundary1D piecewise-linear approximation of the boundary is generated and displayed in Fig. 2c.

Finally, the chain _1interiorcells is computed as the complement to _1boundarycells and displayed in color in Fig. 2d.

1.5 Assembling the 3D Model

The extruded 3D models of Fig. 3 are computed in this section. A 0-complex and an 1-complex, both embedded in $\mathrm{e}^{1}$, are needed in order to perform the extrusion of the 2D model as a Cartesian product of pointsets of dimension 2, 1, and 0.

1.5.1 Computation of the 0-Complex

A list V_0 of five 1D points gives the z-elevation heights. The CSR binary matrix VV_0 provides the description of the highest dimensional cells (vertices), by vertices itself. Of course, it coincides with the identity matrix 5 × 5. The complex floors2D generated by Cartesian product $\Lambda _{2}(X) \times \Lambda _{0}(Y )$ cell pairs is shown in Fig. 3a.

1.5.2 Computation of the 1-Complex

Analogously, EV_1 describes the edges by means of vertices. The matrix of boundary operator boundary1: = [∂ ₁] equates by definition the matrix [VE_1], since the max() value of each [VE_1]’s row is 1.

The function format is from Scipy’s sparse package, and transforms a set of (row,column,value) triples into its internal format ("csr"). The .tocoo().col.tolist() method composition extracts the columns (edge indices) of each unit 1-chain.

1.5.3 Cartesian Products

Finally, the sets of cells of various dimensions are generated and variously assembled by the below script, using the Pyplasm’s Cartesian product of pointsets. The various complexes (implemented as lists of Pyplasm’s geometric values) are displayed exploded in Fig. 10c, d, respectively.