# data[].attributes.body
Optimization for views : Multiple point attractor

https://www.researchgate.net/publication/310800544_Attractors_in_Architecture_Attractor-based_optimization_and_design_solutions_for_dynamical_systems_in_architecture

# data[].attributes.body
Attractor Curve: Generative Paving Landscape

https://generativelandscapes.wordpress.com/2014/08/14/curve-attractors-example-2-3/

# data[].attributes.body
https://codeofspace.files.wordpress.com/2015/10/attractors-in-architecture-2015.pdf

# data[].attributes.body
REFERENCES

Voronoi pattern facade point attractor Rhino

https://padlet.com/redirect?url=https%3A%2F%2Fcodeofspace.files.wordpress.com%2F2015%2F10%2Fattractors-in-architecture-2015.pdf

# data[].attributes.attachment_link.title
Voronoi Pattern Facade Point Attractor Rhino Grasshopper Tutorial

# data[].attributes.attachment_link.provider_name
Faculty of Civil Engineering, University of Zagreb

# data[].attributes.attachment_link.title
(PDF) Recognition of the role of nature in the formation of fractal architecture

# data[].attributes.attachment_link.description
PDF | After a long period of one-way consumerist atti­tude toward nature, there have been some alternate per­spectives on the systemic relationship... | Find, read and cite all the research you need on ResearchGate

# data[].attributes.body
Design an interactive walls to respond noises

# data[].attributes.attachment_link.readable_text
Project Overview

A few months ago I was asked to create a custom wall graphic for a project and it provided the perfect opportunity to use grasshopper at work. We design spaces for this company all over the country and they always have a custom design that expresses their key values at the reception of their office space. The design always includes the same value in text and an associated logo; so, by creating a grasshopper script we will be able to design a multitude of unique options for all of the offices around the country.

One of my favorite things to experiment with in grasshopper is attractors because the concept can be applied to many different applications to provide a unique look. For confidentiality reasons, I will be using a different logo and text.

We will be creating a grid of geometry that scales based on a curve attractor in order to get a set of geometry that responds to a central set of text.

I will be using the LunchBox for grasshopper plug-in to create the grid structure which can be downloaded from either of the websites below. Grasshopper has some built-in functionality to create grid arrays but I personally prefer the lunchbox component for this.

LunchBox For Grasshopper - Proving Ground | Lunchbox for Grasshopper - food4Rhino

Once you have lunchbox installed, open up Rhino and Grasshopper and let's get started.

Create the wall boundary and grid for the array of the logo

The first thing we want to do is to define the boundary for the graphic and create a grid that will host all of the individual shapes. Because I am designing the graphic for a defined wall size and shape, I will draw this boundary in Rhino and set the curve in grasshopper. I am using a 9′-0″ x 13′-0″ rectangle. In grasshopper, I will then create a surface from my boundary curve and apply a grid to it using the lunchbox diagonal grid component. By hovering over any of the input/output variables on a component, you can figure out what type of information the variable is asking for. We will use number sliders to define how many rows and columns (U &V divisions) that we want in our pattern. Once we have our grid we will use a point component to get a list of all of our points.

Note that any surface can be used at this stage, even 3-dimensional surfaces created in Rhino.

Remove points along the edge of the boundary curve

After creating the grid of points, you will notice that some of the points fall onto the boundary of the curve. We are creating a graphic that will be printed on a material (film in this case), so we do not want any geometry on the boundary because it will be cropped when printing. To remedy this we will create a boundary cull which will delete/ignore any of the points that intersect the boundary curve.

The boundary cull does the following:

1. Test if the points are outside the curve (0), intersecting the curve (1) or inside the curve (2) with the points in curve (incurve) component.

2. Integer divide the incurve results so we are left with only 0's & 1's. 0 will represent false, 1 will represent true. Note: you must use integer divide rather than divide so that we get a 0 instead of a 0.5 when dividing the incurve results by 2.

3. Use a cull pattern component which will assign a point to the 1 (true) values and not to the 0 (false values). This, in essence, removes/ignores any point that is intersecting our boundary curve.

Draw the logo geometry in Rhino and move a scaled copy to each point

When first getting started with Grasshopper, an important thing to remember is that you don't have to create everything in Grasshopper. For our logo, we most likely want something that is not a basic shape and is much easier to freehand draw in Rhino. This shape would take much more time to create in grasshopper and there is no reason to do so. I have drawn the bowtie shape below with a polyline but you can use any shape you'd like. When using a polyline it is easier to find the center of the geometry; however, if you need a curve or set of curves for your geometry it requires a few more steps. For this, you need to create a bounding box around your geometries and find the center point of that box for use in the next section.

Once the shape is drawn we will create a scaled copy of the geometry at each point in our grid by moving it along a vector from the center point to our list of culled points from the previous section. In the next section, we manipulate how the geometry scales to get the various sizes.

Create a curve attractor to manipulate the scaling of the geometry

Now that we have the geometry arrayed onto the grid we can use a curve attractor to manipulate how the geometry is scaled when we move it. The basic idea is that we draw a curve across the surface and the geometry will scale to be bigger or smaller depending on how close it is to the curve. We will be using domains and the ReMap component below which can get a little tricky. A domain is a range of numbers from the low point to the high point.

To create the curve attractor:

1. Draw a curve in Rhino that intersects the surface and use the curve closest point (Crv CP) component to associate the curve with our grid of points.

2. Use the bounds component to capture the domain of the distances of the points from the curve. In other words, we capture a list of how far each point is from the curve and use the closest and farthest distance to create the domain.

3. Construct a new domain that states the range of how big to small we want the geometry to scale to. For example, we want the smallest geometry to be .125″ (1/8″) and the largest to be .5″ (1/2″) so we construct a domain with a start of .125″ and an end of .5″. We can flip these numbers to change how the geometry reacts to the curve. If the small value is plugged into the A variable of the domain component then the geometry will be smallest at the points that are closest to the curve. If we switch and plug in the smallest value into the B variable, the geometry will be largest at the points closest to the curve.

4. Remap the distances gathered from the Crv CP component to the new domain constructed in the last step. We want to create a new list of scaling factors based on how far each point is from the curve. We use the ReMap component to do this by taking the smallest distance of a point from the curve and assigning it the smallest scale factor from the newly constructed domain. Additionally, we do the same thing with the farthest point from the curve and assign it to the largest scaling factor from the new domain. All of the other point distances scale relationally between those two extremes. The output of the ReMap component is this newly constructed list of scaling factors that are directly related to how far each point is from the curve. We then take this list and plug it into the scale component.

Add text in the middle of the geometry

The last item is to incorporate the key values into the design. The idea is to have text in the middle of the pattern that the geometry radiates outwards from. To do this we will repeat the same points in curve series from the boundary cull section; however, we will invert the pattern so we remove any points within the middle area of a circle where we want to have the text. Once we have our new list of points we will replace that list with any variable that was hosting our previous points list.

To get the radiating effect, we will change the curve attractor to the new circle in the middle of the graphic so the geometry is larger at the circle and gets smaller as it moves towards the edge of the wall.

Finally, we add our text in Grasshopper and the pattern is ready to bake and export to Cad, illustrator or any other file type needed.

# data[].attributes.attachment_link.title
Design an array of geometry at various scales with curve attractors in grasshopper

# data[].attributes.attachment_link.description
Project Overview A few months ago I was asked to create a custom wall graphic for a project and it provided the perfect opportunity to use grasshopper at work. We design spaces for this company all over the country and they always have a custom design that expresses their key values at the reception of...

# data[].attributes.body
Design secondary skin that limits the view from outside in certain spaces on the building facade with attractor points

# data[].attributes.body
Interactive Eco-Cell Parametric Shading Structure Simulation by Using Parametric Environmental Tools

https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&cad=rja&uact=8&ved=2ahUKEwjzlaqHkpSCAxUNTWwGHd-oCjIQFnoECC0QAQ&url=https%3A%2F%2Fiopscience.iop.org%2Farticle%2F10.1088%2F1755-1315%2F397%2F1%2F012001%2Fpdf&usg=AOvVaw0G9gjF32ehYsCUGRocrYnM&opi=89978449

# data[].attributes.body
How Attractors can be Applicable towards the computing of a proper reservoir

# data[].attributes.attachment_link.title
An overview of reservoir computing theory by Benjamin Schrauwen David Verstraeten Jan Van Campenhout

# data[].attributes.body
Parametric Secondary Skin with multiple curve attractors

How to use multiple attractor points. https://www.youtube.com/watch?v=__fM7gL_wRw&pp=ygU1cGFyYW1ldHJpYyBhdHRyYWN0b3IgcG9pbnQgc2Vjb25kYXJ5IHNraW4gZ3Jhc3Nob3BwZXI%3D

# data[].attributes.attachment_link.title
Parametric Facade by Multiple Curve Attractors |Grasshopper For Architecture Tutorial |

# data[].attributes.body
Reference :

Curve Attarctor

https://youtu.be/mTB53k218n8?si=lKONc8H7wa_2wbsL

# data[].attributes.body
Adaptive fasade by Point Attractor

References:

https://youtu.be/ocJHPZLStmM?si=2Gk6OJLLwIWcCETn

https://youtu.be/LDorzq2Q9-Y?si=Ml56G5uY4w6_fQMd

# data[].attributes.attachment_link.title
Kinetic Facade by Point Attractor | Basic Grasshopper

# data[].attributes.body
An interactive parametric wall respond to human presence via sensors (if humans stand at a certain distance, the wall will respond by creating wave curves).

# data[].attributes.body
Adaptive roof design using natural lighting method

References:

https://www.youtube.com/watch?v=Kf_3o_Epq7c

# data[].attributes.attachment_link.title
Rhino Grasshopper Architectural Pavilion Curve Attractor Overview

# data[].attributes.body
Dynamic Facade with Sun Path Location and Attractor

https://youtu.be/ukGR98LioZA?si=Wa9eNU-8ErxzR9vi

# data[].attributes.body
rhino for geometry architecture

https://www.youtube.com/watch?v=_MsAucvR4VI

# data[].attributes.body
adaptive curtain wall

# data[].attributes.attachment_link.title
Revit Snippet: Create Adaptive Curtain Wall with Multiple Attractors