Content uploaded by Lennert Loos
Author content
All content in this area was uploaded by Lennert Loos on Sep 21, 2023
Content may be subject to copyright.
Proceedings of the IASS Annual Symposium 2023
Integration of Design and Fabrication
10–14 July 2023, Melbourne, Australia
Y.M. Xie, J. Burry, T.U. Lee and J. Ma (eds.)
Copyright © 2023 by Lennert Loos. Published in the Proceedings of the IASS Annual Symposium 2023 with
permission.
Using Data-Rich Objects in Geometric Parametric Modelling
Lennert LOOS*
*Katholieke Universiteit Leuven
lennert.loos@kuleuven.be
Abstract
Earlier research by the author investigated how using data visualisations could be helpful to structural
designers. The research implicitly showed that the versatile handling, management and manipulation of
data is important in order to fully exploit the benefits of parametric design. This paper presents the
development of Inkbeagle Data, a new Grasshopper3d plugin that aims to facilitate data management
in parametric modelling. The paper discusses how the use of data-rich objects can help make it easier to
work with geometric objects and the custom data associated with them. The implementation of the
plugin is explained, as well as its user interface, and a small example of its use in practical applications
in the field of structural design is given.
Keywords: Computational Design, Data Management, Parametric Design
1. Introduction
The use of data visualisations to gain specific insights during the structural design process has been
extensively researched by the author [1][2][3]. The research observed the typical workflows and
processes of the structural designer and identified some of the problems they face. One of the main
problems appeared to be the difficulty of comparing design alternatives with the commonly used finite
element analysis tools. However, comparison is an important part of the design process as it allows an
understanding of how design solutions are behaving and performing in a relative way. These commonly
used analysis tools are well-suited for understanding the structural behaviour of a single design,
dimensioning the members of the structure, and performing the regular code checks. However, they do
not necessarily guide designers to better designs, nor do they allow the structural behaviour and
performance of different design options to be compared.
Based on this practical observation and the fact that a huge amount of structural data (model, loads and
results) is contained in the finite element models that engineers use during design, data visualisation has
been proposed and investigated earlier as a way to facilitate an informed structural design process by
digesting the data more efficiently. This previous research evaluated data visualisation as a way to
present complex data sets from finite element models in a compact but meaningful way. With visual
representations of the data from multiple structural design alternatives at hand, the structural designer is
assisted in an informed structural design process and is better able to understand the influence of certain
design parameters on the structural behaviour of complex structures.
To be meaningful and informative to the designer’s problem, the right visualisation should be chosen or
developed by the designer. Therefore, to facilitate informed decision-making, the choice of data and
how to visualise it must therefore lie with the designer. The research provoked an approach that forces
designers to create and develop graphs themselves that are meaningful to the current state of the design
process and the corresponding questions and interests. When designing structures in practice, the
questions and interests are often very different and context-specific. For this reason, case-dependent
approaches (in this case visualisations) need to be used. The research implicitly showed the need to be
able to handle all structural data easily. Irrespective of the specific topic of data visualisation for
Proceedings of the IASS Annual Symposium 2023
Integration of Design and Fabrication
2
structural design, the need to handle data in a versatile way is a general theme and concern in modern
digital design processes, according to the author’s experience in professional design offices.
This paper discusses a new Grasshopper plugin that has been developed to allow the use of data-rich
objects in a parametric design environment. Object-oriented elements in parametric design will be
discussed briefly. Furthermore, the implementation of the plugin is explained, as well as its user
interface and a small example showing its use for practical applications in the field of structural design.
Finally, an evaluation of the implementation is carried out to point out the strengths and weaknesses of
the developed plugin and the use of data-rich objects within the Grasshopper3d environment.
2. Problem statement and background
The idea of working with data-rich objects in a geometric parametric design environment such as
Grasshopper was initiated by the need to handle structural data more easily for the assembly of graphs
in earlier research, but also originates from practical needs in a professional design office, as observed
and experienced by the author.
2.1. Parametric design environments and its application in practice
Parametric and computational design approaches are widely used in architectural and structural design
practices. All kinds of software, scripts, algorithms and tools are provided by the community, often even
open source. In architecture and structural design practice, the last decade has seen a move away from
text-based programming in computational design towards the use of visual programming and coding
with tools like Grasshopper [4] or Dynamo [5]. One of the reasons for this is the reduced effort required
to learn visual programming languages compared to textual programming [6]. Another reason is the
speed with which designers can set up scripts to perform tasks. In addition, it can be argued that many
architects and engineers in design practices do not have the skills or time to become proficient in
developing custom software and algorithms through textual coding. It is important to note that this
makes designers often reliant on other people's implementations and third party software; as a result,
there is a risk that this software may not accurately meet their needs [7].
From personal experience as a structural designer, the author observed that Grasshopper3d in particular
is used for all sorts of tasks by both engineers and architects. Although this parametric design
environment has its main focus on parametric geometry, the tasks for which this tool is used in practice
are not limited to this purpose. Beside generating and manipulating geometries, the parametric design
environment of Grasshopper3d seems to be a well-suited framework for analysing structural models [8],
preliminary form-finding of structures [9], quickly performing geometrical operations, executing small
geometric and numerical checks on designs [10], importing, manipulating and exporting data and/or
geometries [11], or even working with remote databases [12].
In other words, when working on structural projects, Grasshopper3d is often not used to create fully
parameterised models from A to Z, but rather as a very versatile tool for a series of small, different and
unrelated operations. This allows the designer to stay within a single digital design environment without
having to switch between different interfaces which requires frequently exporting and importing data.
Often the geometry (possibly with attributes) is saved as a Rhino3d file, which serves both as a starting
point for new parametric scripts and as a snapshot of the current state of the design.
2.2. Data and BIM
Parametric design is almost exclusively geometry driven and therefore has an inherent focus on
modelling [14]. Working with related data is not impossible, but rather cumbersome in current
implementations of popular parametric design environments. However, working freely with data in
parametric interfaces is crucial if we are to make informed design decisions in a conscious way. Indeed,
preliminary analyses and checks based on numerical data are regularly performed when working with
parametric models at different stages of the design process.
Proceedings of the IASS Annual Symposium 2023
Integration of Design and Fabrication
3
Data in digital architectural and structural design is often referred to as Building Information Modelling
(BIM). The structure of current BIM software may lack support for the actual design process and is
generally used to document a more finished design [13]. BIM has however important and useful features
that can be of value in any design phase, such as a structured model with clear semantic information,
user-defined properties and data values, spatial relationships between elements, etc. Greater similarity
between parametric design and BIM approaches is desirable, but not easy to achieve [13][14].
2.3. Expressing the needs for a more object-oriented parametric design
To maximise the potential of parametric and computational tools in the digital design process, data-rich
parametric design environments will be essential. A BIM or object-oriented approach that supports the
actual design process could serve these needs well [13]. In order to make informed decisions, to react
to design data, e.g. from analyses, and to make use of (associated) data, versatile and flexible but simple
tools are needed that can be easily integrated into existing design approaches and practices [7].
Convenient data management is of utmost importance for understanding and digesting the
data/results/information generated during design.
As visual programming languages such as Grasshopper3d are often used by computational designers
with limited textual programming skills, the parametric design environment should allow working with
data without relying on textual programming. In addition, the author's experience has shown that
parametric modelling is also used in practice as a way to perform small operations (geometric parametric
modelling, import and export, data processing) quickly. For this reason too, the implementation of data-
rich objects in parametric design must be closely aligned with the existing parametric design
environment.
Recently there has been the robust development of BHoM (Buildings and Habitats object Model) [15].
BHoM aims to standardise the data and functionality that are used in the architecture, engineering and
construction industry. It proposes a central Object Model, which is a schema, therefore BHoM’s main
focus and value lies in interoperability between software tools by sharing the same schema, the central
common language. Although it shows a lot of potential to also work in a more object-oriented way in
parametric design environments, it does not actually support design processes and tasks that
computational designers do on a daily basis within parametric design environments.
Performing basic operations such as selecting, sorting, evaluating and modifying objects should be an
inseparable part of parametric geometric design. These types of operations are relatively easy to perform
in database environments (for instance BIM interfaces) and using textual programming. In parametric
design environments such as Grasshopper3d, however, it becomes very tedious to set up without the use
of third-party plugins. In the following paragraphs, the new Inkbeagle Data plugin [18] for
Grasshopper3d is introduced and discussed. It allows the creation of objects from named keys and
corresponding values, including basic data types (textual and numerical) as well as geometry. This
implementation can be seen as an attempt to facilitate object-oriented parametric design within the
Grasshopper interface.
3. Implementation and user interface
This section describes the implementation of Inkbeagle Data [18], a custom plugin written in C#
developed for Grasshopper3d. Inkbeagle Data allows to assemble data keys and corresponding values
into an InkObject on which basic operations such as list filtering, evaluating expressions and list sorting
can be performed, fully based on Grasshopper's native data types. Furthermore various methods are
included to import and export the InkObjects as a file to and from Grasshopper.
Proceedings of the IASS Annual Symposium 2023
Integration of Design and Fabrication
4
3.1. Implementation
The Inkbeagle Data plugin is based on the idea of the Objectify plugin [16]. However, the
implementation of Inkbeagle Data takes the basic idea a step further by the operations that can be
performed on the InkObjects and the methods for exporting and importing.
The main logic of an InkObject follows the idea of a dictionary that stores key-value pairs in no particular
order. The key is of type string, while the corresponding value is of type IGH_Goo, the base interface
for all data inside Grasshopper. Any data type that inherits from the IGH_Goo type can be used as data
for the InkObject assembly: e.g. GH_Curve, GH_Colour, GH_Integer, GH_Line, GH_String… As a
result, any supported data type can be assembled into an InkObject. Additionally, information about the
“bakability” and “visibility” of the geometric values is included and can be set.
Grasshopper uses the GH_InkObject class as the GH-wrapper for InkObjects and is derived from
GH_GeometricGoo<InkObject>, IGH_PreviewData, IGH_BakeAwareData and GH_ISerializable. As
a result, the InkObjects are fully serialisable and their geometric values are bakable in Rhino3d. Since
GH_InkObjects are derived from the abstract class GH_GeometricGoo, InkObjects can contain
InkObjects themselves; in other words InkObjects can be nested.
Since the implementation as described above does not allow to store a list of IGH_Goo objects as a
value in the InkObject, it is possible to wrap a List<IGH_Goo> in a custom class GH_InkList derived
from GH_GeometricGoo. This way lists can be packed, stored in an InkObject and unpacked later.
In the following paragraphs, the most important features of the plugin are shown.
3.2. User interface (UI)
3.2.1. Constructing and deconstructing InkObjects
The Construct InkObject and Deconstruct InkObject components (Figure 1) allow InkObjects with
named keys and corresponding values to respectively be assembled and to be separated into its different
values.
Figure 1. The components used to construct and deconstruct InkObjects.
Inkbeagle Data’s implementation aims to provide a seamless user experience by closely following the
native Grasshopper UI. To achieve this, the component for constructing an InkObject is implemented as
a variable parameter component, allowing dynamic input and output parameters to be created at runtime
(adding or removing input parameters). The key name can be set by right-clicking on the input parameter
label. This makes the plugin’s UI similar to native Grasshopper components, ensuring that users can
easily integrate the plugin into their existing workflows.
An InkObject is created with data attached to each named key. Adding lists of data to the Construct
InkObject component, creates a list of InkObjects with all the individual data items from the input lists
Proceedings of the IASS Annual Symposium 2023
Integration of Design and Fabrication
5
attached to the corresponding named keys. If lists of different lengths are used for different keys, the
component will be solved according to Grasshopper’s default solving routine. Also when data trees are
used, the default Grasshopper logic is maintained.
3.2.2. Working with InkObjects
The following components (Figure 2) can be used to work with associated data in InkObjects: Add Key,
Modify Value, Remove Key and Get Value. The functionalities of these components are considered as
self-explanatory.
Figure 2. The components that allow to add new key-value pairs (Add Key), modify the value of
key-value pairs (Modify Value), remove key-value pairs (Remove Key), get the values of key-value
pairs by the textual key (Get Value).
The UI of these components aims to be as consistent as possible with Grasshopper’s default UI. For
example, the values of multiple keys can be retrieved by adding and selecting multiple existing keys as
input parameters from the right-click parameter menu (Figure 3). A similar UI is provided for the other
components that are listed in Figure 3.
Figure 3. Compact UI for adding and selecting key-value pairs, similar to Grasshopper’s default UI.
3.2.3. Operations
In order to perform operations on (lists of) InkObjects, a few helpful components have been developed:
Evaluate, Filter, Sort by Key and Search by Value, each with a specific purpose.
The Evaluate component (Figure 4) allows to execute basic expressions with the same syntax as used
for the native Grasshopper components Expression and Evaluate. The Evaluate component can be used
to solve expression syntax and return numeric or string values as the result or to perform conditional
evaluations which will return a boolean value. The key names of the InkObjects are directly used as
Proceedings of the IASS Annual Symposium 2023
Integration of Design and Fabrication
6
parameters in the expression to be evaluated. If for instance an InkObject contains numerical values in
certain keys (key_a, key_b, key_c), the following logical and numerical expressions can be constructed:
• key_a > (key_b – key_c) logical expression
• key_a / (key_b^3 * sqrt(key_c)) numerical expression
If one wants to filter a list of InkObjects based on a logical expression, the Filter component (Figure 4)
can be used. It has similar functionality to Grasshopper’s native Dispatch component, but the logical
expression can be expressed based on the named keys of the InkObjects.
Figure 4. The use of components that allow to execute expressions and filter a list of InkObjects.
The Sort by Key component (Figure 5) sorts a list of InkObjects based on the value of a specified key,
while the Search by Value component (Figure 5) allows users to search for InkObjects with specific key
values.
Figure 5. The use of the components that allow to sort a list of InkObjects and to search for InkObjects in a list
that have a specific value assigned to a certain key. Note that it is important that the correct type must be used to
look up certain values: the string “6.856977” is casted to a GH_Number first. Searching by the string value
would not return any InkObjects.
Proceedings of the IASS Annual Symposium 2023
Integration of Design and Fabrication
7
3.2.4. Export-Import
A series of components have been developed to facilitate exporting and importing InkObjects. The user
is able to Bake one or more InkObjects as geometries in Rhino3d with textual or numerical attributes,
based on the non-geometric key-value pairs of the InkObject. Geometries with attributes can be
referenced from Rhino3d back into Grasshopper3d as well, where the attributes will become textual or
numerical key-value pairs of the InkObject. The Serialize component allows to save a data tree of
InkObjects as a binary file. This way one is able to work with data and Grasshopper geometries between
various files. A binary file containing the serialised data and geometry can be deserialized into the
Grasshopper3d environment. To conclude, InkObjects containing basic data type values (textual or
numerical) can be exported to csv, xml or json data files and imported from data files in corresponding
format.
4. Practical use cases
In practice, the author uses the developed plugin mostly to work more efficiently with data and FEA
results within a parametric design context.
Figure 6. The beam elements are filtered based on the following more complex logical expressions:
Expression 1: (Nx_LC1 < 0) AND (abs(My_LC1) >= 1.10) AND (id = "grid")
Expression 2: (util > 0.7) OR (util_my > 0.4)
Proceedings of the IASS Annual Symposium 2023
Integration of Design and Fabrication
8
When using for instance Karamba3d [8], all result data is available in the parametric environment and
can now be attached to structural geometries and processed further, without leaving the design interface.
For instance, the plugin can be used to filter structural elements based on the structural results. This way
the behavioural characteristics of the structural elements can be identified more easily.
Figure 6 illustrates this with a small example.
Inkbeagle Data makes filtering of objects/elements more easy. This provides users with the capability
to effectively manage and digest large volumes of structural results without leaving the parametric
design environment. In the example shown above, more complex logical expressions are used to filter
structural elements based on their internal forces, utilisation and type. These values are retrieved from
the Karamba3d plugin and assigned to line elements, representing each beam. The key names such as
Nx_LC1 or util_my can be chosen freely, according to the needs of the structural designer.
Another example where the author used Inkbeagle Data is to prepare the definition of the pretension
loadcase for a SOFiSTiK finite element model. The form-found geometry of a pretensioned cable
structure is baked in Rhino3d as snapshot of the project’s current design state. The baked geometry
contains User Attributes with information such as the form-found force (F), E-modulus (E), cable id
(cable_id), cross-sectional area (E), etc.
When the line objects in Rhino3d are referenced in Grasshopper3d, the User Attributes can be attached
to the geometry as InkObjects with the help of the Inkbeagle Data plugin (Figure 7). Based on the data
values, the shortening of each cable can easily be calculated with the help of the Evaluate component
and added as a key “shortening” to the InkObjects. The Evaluate component is then used once more to
format a specific string with variables, to match the desired SOFiSTiK Teddy syntax.
Figure 7. Without too much effort the pretension load can be formatted as a shortening of the
cables in the desired SOFiSTiK Teddy syntax, without the need to do this data processing in
another computational environment.
Proceedings of the IASS Annual Symposium 2023
Integration of Design and Fabrication
9
5. Discussion and conclusion
Based on the author’s observations and experiences of how Grasshopper3d is used in practice and that
the parametric framework is used for all kinds of tasks of different nature became clear from the practical
use cases. The presented cases show that a more object-oriented approach in parametric modelling has
some direct benefits for the workflow of architects and structural designers, especially when it comes to
supporting daily custom operations with data and geometries. This was the main reason for the
development of the plugin.
The idea of combining all kinds of Grasshopper3d data types into one “object” seems to be reasonable
as an approach. However, there is no such thing as a free lunch. The goal of supporting all possible data
types implies using the IGH_Goo type for the values of the object. While this has many advantages such
as the ability to work with Grasshopper3d’s expression syntax, it also has drawbacks. For example the
Sort by Key component must first check that all values corresponding to the given key are in fact
numeric. Other operations like casting of types can also reduce the performance of the implementation.
However, for sorting, evaluating expressions, looking up InkObjects from a list of manageable size (up
to about 50 000), the implementation seems to be competitive with a native Grasshopper3d solution
performing the same task.
Although nesting of InkObjects is possible, the current implementation is very much geared towards a
flat application. In fact, it is not possible to retrieve the values of nested InkObjects using the plugin's
components alone; instead, custom scripting is required. Also, the evaluation of the expression syntax
is not applicable to nested values either. It may be worth investigating thoroughly to what extent such
features are feasible without compromising on the UI which should remain as similar as possible to the
native Grasshopper3d UI and its user experience. The workaround method of using InkLists may be
helpful in some cases, but a more general approach is desirable.
While the plugin was being developed, Grasshopper 2.0 [17] had not yet been released. This second
major release of Grasshopper3d comes with the support for so-called metadata. This means that meta
values can be attached to any regular value, similar to the assembly of InkObjects. This provides the
ability to associate certain values with their main value, but also offers a way to control in more detail
how Grasshopper handles data. This particular feature is an important one in the development of
parametric design environments and may even suggest that object-oriented approaches are essential to
the future development of visual programming and parametric design interfaces.
7. References
[1] L. Loos, Structural Design by means of Data Visualisation , 2019.
[2] K. Verbeeck, L. Loos, L. De Laet, “How to re-open the black box in the structural design of
complex geometries” in Proceedings of the International Conference on Structures and
Architecture, Guimaraes, 2016.
[3] L. Loos, L. De Laet, “A Structurally Informed Design Process by Real-time Data Visualisations”
in Proceedings of ECAADE 2018: Computing for a Better Tomorrow, 2018.
[4] Robert McNeel & Associates, Grasshopper, https://www.grasshopper3d.com, 2007.
[5] Autodesk, Dynamo, https://www.dynamobim.org, 2011.
[6] G. Celani, C. Eduardo Verzola Vaz, “CAD scripting and visual programming languages for
implementing computational design concepts: a comparison from a pedagogical point of view” in
International Journal of Architectural Computing 10 (2012).
[7] N. C. Brown, V. Jusiega, C. T. Mueller, “Implementing data-driven parametric building design
with a flexible toolbox” in Automation in Construction 118 (2020).
[8] C. Preisinger, Karamba3d, https://www.karamba3d.com, 2014.
[9] D. Piker, Kangaroo Physics, https://www.food4rhino.com/app/kangaroo-physics, 2011.
Proceedings of the IASS Annual Symposium 2023
Integration of Design and Fabrication
10
[10] M. Pryor, Pufferfish, https://www.food4rhino.com/app/pufferfish, 2021.
[11] Thornton Tomasetti - Core Studio, TT Toolbox, https://www.food4rhino.com/app/tt-toolbox,
2013.
[12] N. Miller, Slingshot!, https://www.food4rhino.com/app/slingshot, 2012.
[13] J. Coenders, “Parametric and associative design as a strategy for conceptual and delivery to BIM”
in Proceedings of the International Association for Shell and Spatial Structures (IASS)
Symposium, Valencia, Spain, 2009.
[14] S. Boeykens, “Bridging building information modeling and parametric design” in eWork and
eBusiness in Architecture, Engineering and Construction, Taylor & Francis Group, London, 2012.
[15] BHoM, https://bhom.xyz/documentation/, 2018
[16] Ranjeeth Mahankali, Objectify, https://www.food4rhino.com/app/objectify, 2019.
[17] Robert McNeel & Associates, Grasshopper 2.0, https://discourse.mcneel.com/t/grasshopper-2-
alpha-available-for-testing/, 2022.
[18] L. Loos, Inkbeagle.io, https://www.inkbeagle.io, 2021.
