I stumbled across value lists and filters which allowed me to switch display of the analytics in Rhino. By choosing a new value, Grasshopper would filter geometry, display text and colour ranges to display the chosen analytic. I also made extensive use of boolean switches to control the flow of the script.

Whilst the grasshopper script was working fine – I wanted to take the system to the next level and make it more robust, efficient and extensible. I have spent the last couple of days re-writing my whole grasshopper script as a Rhino plugin in Visual Studio 2012. It has been an amazing journey – and I have now been able to integrate a custom interface and can manage the script engine seamlessly within Rhino. The plugin uses Rhino’s display conduit to visualize analytics temporarily extremely fast in a similar method to grasshopper’s preview geometry. When you load a new file, the analysis can operate instantaneously with very minimal setup (allocating geometry onto layers). In addition to this, as it operates in real time, any changes made to your design will instantly update the analytics and the display so you can get spatial performance feedback as you design!

An important part of the system design is the feedback to the designer during optimization processes. The image below shows the optimization process and the attempt to reinterpret the original design into a new design alternative whilst maintaining the initial configuration. The system uses physics based spring systems to dynamically relax the new solution into an optimized configuration.

It has been an intense 3 days so far at the Smart Geometry Conference. Here are some developments in generating and optimizing the design solutions. The spaces in the new generated designs have the same relationships as in the original high rise version with quantitative and visual feedback provided by the system. Looking forward to getting my 3D Printed versions of these tomorrow! Photos to come…

The Brief

“Starting from a design context of a complexity that is either undrawable or unsolvable by parametrics, novel and specific descriptive systems must be found. Secondly, the design will be evaluated by building a custom analysis system or linking to existing frameworks / solvers. Thirdly, in the optimization phase we explore heuristics, AI, and simulation methods to balance equilibrium between desires and affordances. By this time we will have built a system that describes, evaluates and optimises the design context. Lastly, in the systems-design phase we interrogate this set-up by testing it for sensitivity and robustness, and conclude on its ability to augment intuition.”

GENERATIVE SPATIAL PERFORMANCE DESIGN SYSTEM

My “unsolvable” task is related to architectural spatial design, which can be considered a wicked problem and can have a multitude of solutions for any given design brief. This is heightened at the conceptual stage of design, where a large number of solutions are created and need to be evaluated in a short period of time. This notion of a ‘solution driven’ design process is a common approach to solving design problems and provides expertise to resolve the complex interrelated design variables. Whilst this can be achieved, there is an argument that the repertoire of organisational patterns, design precedent knowledge and the precise criteria and computation of spatial evaluation required for generative exploration is more than what can be expected from the accumulated knowledge of an experienced architect. This project seeks to augment the designers intuition through the construction of a design support system focused on spatial performance. This Generative Spatial Performance Design System is described below:

FRAMEWORK

Given a sketch design with an initial spatial configuration, the intent of the system is to have the capability to search a corpus of design precedents for comparable designs, and utilise the precedent knowledge to generate informed variations for conceptual spatial design exploration. The system can be decomposed into a series of inter-related modules: spatial knowledge capture, design filtering, generative design exploration and evaluation.

SPATIAL KNOWLEDGE CAPTURE

A key component of the system is the structuring of precedent / sketch designs into a specific format suitable for spatial analysis. This is achieved through the construction of a Parametric Spatial Configuration Rig composed of a series of spaces and a network graph identifying the building configuration.

ANALYSIS

Once the Parametric Spatial Configuration Rig has been constructed, the building can be spatially analyzed. A series of metric are calculated including standard room measurements as well as spatial configuration analytics derived from Space Syntax techniques. These analytics can be visualised on the precedent / sketch design for immediate spatial configuration feedback.

To make the system effective, a corpus of design precedents need to be captured and stored into a custom designed spatial database. This database can be interrogated for comparable designs which in itself is a multi-objective search criteria that can be tailored by a designer’s preference.

GENERATIVE CONFIGURATIONS

Once a design precedent has been determined as a suitable target, the system should be able to generate a series of alternate informed spatial configurations. Currently the system can achieve this through two approaches. The first compares a designers initial sketch to the target precedent found on the spatial database. The two buildings are functionally mapped together to allow the formation of a hybrid network which can be biased towards the source or target design. The image below shows an equally weighted hybrid configuration.

Whilst the first approach attempts to form a new novel configuration, the second approach assumes the target precedent to be the desired configuration and uses this as the source for generating new designs. The process for generating new designs involves a parametric rig that reconfigures the network into a new building footprint. This reconfiguration seperates out the spatial components into the new domain, however connects them with “springs” to ensure they have the same configuration topology. An optimisation routine is then applied that dynamically relaxes the new layout into novel design configurations that matches the target configuration in a new context.

Focused workshops are now available in your preferred software, to upskill you and your team, ensuring that techniques do not limit your design potential.

Learn contemporary design software including Rhino, Grasshopper and Revit; digital design techniques including Parametric Design and Scripting; and software integration.

Offered for the first time in 2011, this class is an introduction to algorithmic design techniques for the generation and analysis of architectural organisations of space.  Through a series of lectures and practical examples, we will theoretically investigate recursion through l-systems and fractal growth; non-linear dynamics; and complex systems such as cellular automata, autonomous agents, self-organisation and adaption.  We will accomplish this through high level research and the development of custom software in Rhino.

With the release of Rhino 5.0, we now have access to the Python programming language within Rhino.  Python is a modular, object-oriented language with the potential to move beyond scripting into developing custom-written software for architectural design and development.  It is cross-platform and software independent.

Instructor: Rob Beson

I have been recently working on a number of website designs including the new UTS Architecture website. This has become a portal for allowing staff and students to upload the latest work and news happening within the School of Architecture at UTS. This website will continue to evolve and content is being published daily, so be sure to keep your eye on it.

Now that the input data is quite flexible through image maps, we focused on the base geometry – as this was still limited as a 2D plane. We wanted to improve the versatility of this by allowing the importing of geometry from Rhino. In addition to this, we added code to check if the file has been updated to allow for a realtime update as we progressed.

Development of User Interface in Visual Studio C++ w/ Open Cascade and QT Designer

Porosity

Texture

Banding

Ridges

Decay

We began with a series of introduction lectures from Mark and Jane which introduced the background to the project, essentially identifying the opportunity for further research into the acoustical properties of doubly ruled surfaces. This research was introduced in response to the feedback being received from the Sagrada Familia regarding the positive acoustic behaviour leading to the hypothesis that the complex surface detail may lead to sound scattering, essentially reducing the effect of echo’s in the space. From my understanding, plaster is typically a hard material that reflects sounds readily. The task of this workshop would be to explore the possibilities of introducing variation into a flat surface in an attempt to understand if this contributes positively to the sound scattering – something that is quite difficult to measure typically.

We were then introduced to the sound testing equipment by Tobias which in turn partly setup the strategy for how we were to proceed with the workshop. We have access to an acoustical chamber that will measure the scattering coefficient of sound through a series of calculations. The type of analysis for sound scattering is quite limited in comparison with those available for absorption. With this in mind, we were set the task of designing options to test in this chamber.

This led onto the start of the design process. We were introduced by Alex to the software we would be using. Basically we combined the Open Cascade geometry library with QT interface tools through the C++ programming language. Open Cascade allows the construction of complex geometry and calculates intersections and booleans very accurately. We were provided a template that allowed an initial experimentation into setting out a grid of hyperboloid revolutions onto a surface. The controls allowed the manipulation of spacing, count and angles. These were linked into an attractor which allowed to distribute variable parameters across the surface.

As with any parametric setup, the constraints and relationships allow you to manipulate the design which allows flexibility, however it is also constraining and forces the designer into a certain mode of operation. Part of the workshop is focused around exploring the software interface and allowing the construction of new parametric rigs to control the surface apertures.

An initial way to modify the parametric structure would involve modifying the positions of the hyperbolas. The demo rig sets up a grid topology and instantiates geometry based on that. I attempted to modify this system in two ways:

• The first approach was to open up a new method that would allow the placement of points on the surface via UV coordinates rather than a grid. Essentially this would open the option to construct grids or point placement through various algorithms rather than be limited to a grid. I constructed a test rig that would divide the surface evenly in one direction with a variable division in the other direction. This sets up a grid that has a variety of bands. The spacing could be used to determine the radius of the hyperbolas and hence add banding variation into the wall apertures.
• The second approach was to control the radius variation graphically rather than algorithmically. This idea was suggested by Ralf and involved reading the gray values from an image and encoding that into values. Basically this allows the control of the system to be understood graphically through the construction of grayscale maps. This makes it quite easy to gradient patterns and even combine multiple logics through layering up logics in photoshop.

The final development was a technical improvement on the code. Basically the original demo code would generate the complex hyperbola surfaces when any slider was moved. As the model became more detailed, this would create a strain on the computer and often crash. In order to resolve this, I developed a method that would only display a graphical representation of the surface (a basic circle with a changing radius) that would indicate the behaviour of the system. The system can then be explored and a search for a solution is not limited to computational power. Once the solution is determined, this can then be exported into the IGES format which is then taken into Digital Project for further refinement.

The refinement in Digital Project involves thickening each surface and splitting it with its neighbour. This is completed using a macro developed by Alex and allows for the quick propogation of booleans to construct a solid ready for 3D Printing. The model is then split into four quadrants to meet the manufacturing limits of the 3D Printer.

This is a two part tutorial on how to read values from Excel into Grasshopper.

Part 1 will describe a technique for reading excel data through a CSV file and extracting the various values into data lists for you to work with.
Part 2 will apply this to a parametric bench example that has variables to control several profiles.

I have attached a grasshopper file and a CSV file for this demonstration. In the second part, I will demonstrate a method of having a user friendly interface in Excel.

Download source files.

The basic process:

1. Read CSV files and extract each variable set as a branch
2. Graft the variable lists to allow each profile to use its related variables
3. Construct profiles based on moving points and variable values
4. Loft to form bench
5. Update Excel > Save as CSV > See changes

I have included two grasshopper rigs – The parametric bench with sliders and the parametric bench with excel link.

With the Sliders, you can link in to Galapagos if you have a fitness function. You can also tweak and sculpt the bench on the spot.
With the Excel, you may apply macros and functions to provide mathematical control over your profile shapes. Also a slight tweaking of the grasshopper file will allow the number of profiles to be dependent on how many entries there are in Excel. (Calculate number of rows in Excel, bring that in as a value, divide a line by that number to get your profile origin points).