ArtScience Museum Continued

Choe, Jonathan. ArtScience Museum. 2021. Archigardener.

https://www.archigardener.com/2020/12/artscience-museum.html.

Architects: Moshe Safdie

Location: Singapore

Project Year: 2011

Typology: Museum

Project Design Intent

The ArtScience Museum is inspired by a Lilypad and flower. This building has round pedals that create the outer shaped mass of the building. The intent for this project is to continue the iteration process of project one and creating a more geometric building form while implementing more advanced methods of grasshopper modeling. Through the use of python scripting, we will create more solutions that can allow the user to manipulate the buildings outer shell form in a more geometric way.

Ai Imagery

Through the use of ChatGPT I was able to attempt to turn the outer pedals of the ArtScience Museum more polygonal, but the first few attempts had little success rate. Telling ChatGPT to visualize an ArtScience Museum in Singapore with more polygonal pedals resulted in this:

DALL-E Rendition Failed Attempt

The goal here is not to make the exterior skin as though it were a low poly mesh, but instead to make the curved surface of the museum more angular rather than smooth. Below is a rendering created through the use of Veras after modeling more angular exterior shell in grasshopper. This is the design intent I wished to create and in the following sections I will show you the process used to create this.

Finished Rhino Model - Veras Rendering

Modifying Existing Grasshopper Script

In project 1 we created an initial grasshopper script that allowed us to recreate the original building form with some parametric integration. It allowed us to change the pedal widths, rotation of pedals in plan and elevation, size of pedals and the base, along with the number of pedals. However, there was not much manipulation allowable in the overall shape of the pedal itself. Below is the original script and what elements we plan to get rid of or manipulate in order to reach the new desired outcome.

Original Grasshopper Script to be Modified

The new script is a more refined through the use of python scripting which allows for the overall grasshopper script to be much more condensed and use much less components. This will help to optimize and create a much more efficient parametric model. Below is the full view of the new script created.

Updated Grasshopper Script with Python Scripting to reduce the overall complexity of the file.

Understanding Python Scripting

Python scripting is a procedure that allows you to integrate what would normally take several grasshopper components into a singular python script. This python script can run many complex procedures in order to produce a single or multiple outputs. For project one the main goal was to manipulate the number of pedals and their rotations. In this case we want to keep many of the original parametric variables but introduce new variables that would allow us to change the mass of the pedals to a more geometric solution instead of the original curved pedals of the ArtScience Musem.

In order to both learn and create python scripts I started by asking Chat GPT simple questions on how to make things using python scripts then testing them out on grasshopper. Following these smaller experiments I then began to attempt to ask Chat GPT to create some scripts more related to the inputs and parameters I wanted to adjust in this project. Below are several screenshots of just a few of the conversations I had with Chat GPT to help create these scripts.

Asking Chat GPT to generate a generic code that would allow me to make polygons based on an
input of the number of sides. If the sides are less than a polygon then produce a circle.

Creating a new script that would allow Radius size manipulation

We have to make sure to be explicit in the request and ask to use the rhinoscriptsyntax
variation of the script otherwise we may not be able to implement the script into our
grasshopper/rhino modeling software.

Adding an input to designate the center points of the outputs

Again, we had to make sure to be explicit in what we ask ChatGPT. It wants to pull and
create a center point from the Rhino Viewport. However, we already have a base center point
created within our grasshopper components to pull from.

Finally some minor debugging and optimization can be done as well through Chat GPT when
working on a script.

Even though Chat GPT was used to create some of the scripting for one of the python nodes I still had to understand both what it was returning to me and what I was asking it to do. Unlike grasshopper components where we can still receive an output on occasions and see that something is not working the way we anticipated or get and error somewhere along the data tree, python is not as friendly. If there is an error in the code there is no output except an error code or message to debug. It can also make it hard when conducting multiple procedures through a single python script because many of the scripts definitions are pulled from previous lines that define values. Any of the previous values you may be referencing further down the script can result in errors that may not be easily solvable.So even though grasshopper produces a bulk of the code the debugging procedure still requires some inherent knowledge of the steps it takes to create the end result.

Below is a script created by me after understanding how scripting works. After so many back and forths with Chat GPT to create the first python script that controlled the outer shell I created an inner shell Python script that would produce a cylinder in the XZ plane. This script used some basic mathematics to manipulate its location and size in relation to the outer shell. This was very important because it needed to stay in the same location proportionate to the size and scale of the outer shell. By using the same inputs that would manipulate the outer shell we used a translational vector to manipulate its location in the XYZ position. By using the radius*1.6 in the Z direction we can make sure that no matter how large the radius changes the cylinder will always be located 1.6 times higher than the outer shell. We do the same with the X and Y values. We also do it with the radius of the cylinder. By making the radius 1.25*radius of the outer shell the inner shell will always stay proportionate to the size of the outer surface.

Modeling Process

Step 1: Building Base + Center Point

Create a cylinder for the base in order to manipulate the base height. The deconstruct brep
allows us to to use the list item to select the upper surface where we will use the center
point to manipulate rotations and pedal location for the rest of the modeling process.

Step 2: Creating Outer Shell Via Python

By using Python Scripting we can create a component that allows us to use the original center
point of the cylinder to manipulate where the extruded shape is located. In order to make this
script there needs to be several inputs; Pedal Width, Radius, and Center Point. We then create
a conditional statement format to manipulate what kind of shape is created. We also want
to keep the ability to return to the original form, so to do that we make sure that any number
below a 5 sided polygon returns a circle. This lets us keep the curved form of the original
building. If it is more than five it creates a polygon with that many sides based on the
size of the radius. From there whatever number of sides we select we rotate the result
so that the shape is in the XZ plane and then move is 1/2 of the pedal length in the
negative direction so that when we give the actual size of the pedal it stays centered
because the other half will be in the positive direction. We then cap the result to make
sure it is a closed Brep that can be boolean divided or subtracted from.

Step 3: Creating Inner Shell Via Python

We use the same inputs as the outer shell except for the fact that the number of sides has
no affect on the inner surface. Since the goal was only to manipulate the outer shape, a
more curved form similar to the original was retained. This also makes it keep a more
water friendly surface as the water would collect in the center much more efficiently
without the continuous angled surfaces on the interior. We use the same pedal with to
manipulate the width so that the two shapes can be booleaned afterwards. We do the
same rotation to the XZ plane and offset the shape negating 1/2 the distance of the pedal
in the Y direction so that when the width is chosen the it stays centered.

Step 4: Outer Shell - Inner Shell

Then after the two outputs are generated we subtract what is considered the inner shell
from the outer shell using the difference component.

Step 5: Series of Rotation in XZ - Plane

In order to select the number of pedals and how much change in rotation occurs in the
XZ plane we use a series component that is plugged into the rotation in the XZ plane
this allows us to create a list of multiple pedals all rotated based on the previous pedal.

Step 6: Series of Rotations XY - Plane

Next the same is used again, but the same input for the number of pedals is used here to
keep the lists the same length. This ensures we will have no errors as they rotate. However,
this rotation will be rotating in the XY plane allowing us to radially set the degree difference
in plan between pedals.

Step 7: Creating Hollow Core

Lastly, we create the hollow core in the center by creating a cylinder to difference with. The
cylinder is tied to the size of the radius of the pedals divided by an integer making them
connected so that as the size of the pedals change the proportion of the center does as well.

Step 8: Creating Base Diagrid Select Upper Curve

By deconstructing the original base we can select the upper curve with the list item.

Step 9: Series of Circles

We select the upper curve and use a series component to create multiple concentric
circles at a fixed distance between one another.

Step 10: Divide Circles Into Points

We then divide the cirve into points and use a list and rotate component to manipulate the
points on the 2nd and 4th curve offsetting them so that they are halfway between the upper
points.

Step 11: Interpolate Curve Between Points

Next we shift the list so that each "next" point on the following curve creates a continuous
line through the interpolated curve.

Step 12: Reverse List and Interpolate Curve

In order to make sure the diagrid curves in the other direction is exactly mirrored we must
reverse the points in the list and do the same process as step 11.

Step 13: Pipe Result For Diagrid Structure

Next we pipe the diagrid structure.

Step 14: Scale Upper Curve to Create Angular Columns

We then select the upper curve of the cylinder and scale its size. By connecting it to the outer
shell radius and dividing it by a set number the outer shell radius and the angled columns
stay proportionate.

Step 15: Divide Lower and Upper Curves

We then divide and rotate the points so that the start aligns with the bas points of the diagrid.

Step 16: Connect Base Points to Upper Points

Then we use a line component to connect the upper and lower points and graft them.
The grafting is so that the piping reads each line as its own branch and does not attempt to
connect them or have an error when multiple inputs in the same branch are connected.

Step 17: Pipe Resulted Curves to Create Angled Columns

Finally we pipe the columns.

Step 18: Turn Both Base and Pedals on

Then we turn on both halves of the model.

Model Iterations + AI Renderings (Veras)

Below are some of the different iterations produced through the manipulation of the different parameters. I have also tried to test the AI software Veras for rhino in attempts to visualize what these different iterations may look like in a more photorealistic setting. By giving it the prompt and adding as much descriptive information about the location, background, building name, type of sky, how realistic the render should be, and the color of the building we were able to get some images based on the 3D model provided. It uses the rhino viewport and 3D model information to compose an image where you can then adjust how much you would like for the image to be manipulated from the original rhino viewport. In all the cases below I kept the same values and prompt. I wanted little to no geometric manipulation from the original model and I wanted the AI to have free range in manipulating all the materials in the view port along with providing that each of these images are considered to be aerial images.