





























Chapter_6_ Deformation and Morphing
97	Deformation and Morphing


Chapter_6_ Deformation and Morphing


6_1_Deformation and Morphing


Deformation and Morphing are among the powerful functions in the realm of 
free‐form design. By
deformations we can twist, shear, blend, … geometries and by Morphing we 
can deform geometries from one boundary condition to another.

Let’s have a look at a simple deformation. If we have an object like a 
sphere, we know that there is a bounding‐box  (cage)  around  it  and  
manipulation  of  this  bounding‐box  could  deform  the  whole geometry.




Fig.6.1. Deformation by Bounding‐box (cage).






Based  on  different  manipulations,  we  might  call  it  shear  or  blend 
 or  free  deformation.  For  any deformation function, we might need the 
whole bounding‐box, or just one of its sides as a plane or even one of the 
points to deform. If you check different deformation components in 
Grasshopper you can easily find the base geometrical constructs to perform 
the deformations.

Morphing in animation means transition from one picture to another smoothly 
or seamlessly. Here
in 3D space it means deformation from one state or boundary condition to 
another. The Morphing components in Grasshopper work in the same fashion. 
There are two <morph> components, one deform an object from a reference box 
(Bounding Box) to a target box, the other component works with a surface as 
a base on that you can deform your geometry, on the specified domains of 
the surface and height of the object.
98	Deformation and Morphing


The first one is <Box Morph> and the next one is <Surface Morph> both from 
XForm tab under the
Morph section. Since we have couple of commands that deform a box, if we 
use these deformed boxes as target boxes then we can deform any geometry in 
Grasshopper by combination with Box Morph component.

As you see in Figure.6.2 we have an object which is introduced to 
Grasshopper by a <Geometry> component.  This  object  has  a  bounding‐box  
around  it  which  I  draw  here  just  to  visualize  the situation. I 
also draw another box by manually feeding values.







Fig.6.2. Object and manually drawn box.







Fig.6.3.  The  <Box  morph>  component  (XForm  >  Morph  >  Box  morph)  
deforms  an  object  from  a reference box to a target box. Because I have 
only one geometry I attached it as a bounding box or reference box to the 
component but in other cases, you can use <Bounding box> component (Surface
>  Primitive  >  Bounding  box)  to  use  as  the  source  box.  I  
unchecked  the  preview  of  the  <Box>
component to see the morphed geometry better.
99	Deformation and Morphing



Fig.6.4. Now if you simply change the size of the target box you can see 
that the morphed geometry
would change accordingly.





Fig.6.5. here you see that instead of one box, if I produce bunch of boxes, 
we can start to morph our object  more  and  more.  As  you  see  the  
differentiated  boxes  by  the  <series>  component  in  their  Y 
dimension, show the differentiation in the morphed object as well.




6_2_On Panelization


One  of  the  most  common  applications  of  the  morphing  functions  is  
Panelization.  The  idea  of
panelization comes from the division of a free‐form surface geometry into 
small parts especially for fabrication issues. Although free‐form surfaces 
are widely being used in car industry, it is not an easy job for 
architecture to deal with them in large scales. The idea of panelization is 
to divide a surface into small parts which are easier to fabricate and 
transport and also more controllable in the final product.   Sometimes the 
reason is to divide a curve surface into small flat parts and then get the 
curvature by  the  accumulation of  the  flat geometries  which  could  be  
then  fabricated  from sheet materials. There are multiple issues regarding 
the size, curvature, adjustment, etc. that we try to discuss some of them.
100	Deformation and Morphing





Let’s start with a simple surface and a component as the module to make 
this surface.


Fig.6.6. A simple double‐curve surface for panelization.





Fig.6.7. The component that I want to proliferate on the surface……. Not 
special, just for example !!!


Fig.6.8. First of all, we need to introduce our surface and module as 
Grasshopper components. Based
on  the  possible  components  in  the  Grasshopper,  the  idea  is  to  
generate  couple  of  boxes  on  the
surface and use these boxes as target boxes and morph or module into them. 
So I used the <box
morph> and I used the geometry itself as bounding‐box. Now we need to 
generate our target boxes
to morph the component into them.
101	Deformation and Morphing





Fig.6.9. The component that we need to make our target boxes is <surface 
box> (XForm > Morph >
Surface box). This component generates multiple boxes over a surface based 
on the intervals on the surface domain and height of the box. So I just 
attached the surface to it and the result would be the target boxes for the 
<box morph> component. Here I need to define the domain interval of the 
boxes,
or actually number of boxes in each U and V direction of the surface.





Fig.6.10. Now I connected <divide interval2> which tells the <surface box> 
that how many divisions in
U and V directions we need. Another <number slider> defines the height of 
the target boxes which means height of the morphed components.






So  basically  the  whole  idea  is  simple.  We  produce  a  module  (a  
component)  and  we  design  our surface. Then we make certain amount of 
boxes over this surface (as target boxes) and then we morph the module into 
these boxes. After all we can change the number of elements in both U and
V direction and also change the module which updates automatically on the 
surface.
102	Deformation and Morphing



Fig.6.11. Final surface made up of our base module






6_3_Micro Level Manipulations


Although it is great to proliferate a module over a surface, it still seems 
a very generic way of design.
It is just a ‘bumpy’ surface. We know that we can change the number of 
modules, or change the module  by  itself,  but  still  the  result  is  a  
generic  surface  and  we  don’t  have  local  control  of  our system.

Now I am thinking of making a component based system that we could apply 
more local control over the system and avoid designing generic surfaces 
which are not responding to any local, micro scale criteria.

In order to introduce the concept, let’s start with a simple example and 
proceed towards a more practical one. We used the idea of attractors to 
apply local manipulations to a group of objects. Now
I  am  thinking  to  apply  the  same  method  to  design  a  component  
based  system  with  local
manipulations. The idea is to change the components size (in this case, 
their height) based on the effect of a (point) attractor.
103	Deformation and Morphing



Fig.6.12.  A  double‐curve  surface  introduced  as  <Base_Srf>  and  a  
cone  which  is  introduced  as
<component> to the Grasshopper, a <divide interval2> for surface divisions, 
and a <bounding box> as the reference box of the <component>. Here I used a 
<scale> component for my bounding box. Now if
I change the size of the bounding box, I can change the size of all 
components on the <base_srf>
because the reference box has changed.




As you have seen, the <surface box> component has the height input which 
asks for the height of the  boxes  in  the  given  intervals.  The  idea  
is  to  use  relative  heights  instead  of  constant  one.  So instead of 
a constant number as height, we can make a relation between the position of 
each box in relation to the attractor’s position.

What I need is to measure the distance between each box and the attractor. 
Since there is no box yet, I need a point on surface at the center of each 
box to measure the distance.


Fig.6.13.  Here  I  used  the  same  <divide  interval2>  for  an  
<Isotrim>  component  (Surface  >  Util  > Isotrim).  This  component  
divides  the  surface  into  sub‐surfaces.  By  these  sub‐surfaces  I  can 
 use another component which is <BRep Area> (Surface > Analysis > BRep 
area) to actually use the by‐ product of this component that is ‘Area 
Centroid’ for each sub‐surface. I measured the distance of these points 
(area centroids) from the <attractor> to use it as the reference for the 
height of the target boxes in <surface box> component.
104	Deformation and Morphing










Fig.6.14. I just divided the distances by a given number to control the 
effect of the attractor and I
used  the  result  as  ‘height’  to  generate  target  boxes  with  
<surface  box>  component.  The  surface comes from the <base_srf>, the 
<divide interval2> used as surface domain and heights coming from the 
relation of box position and the attractor. As you see, the height of boxes 
now differ, based on the position of the point attractor.










Fig.6.15. The only remaining part, connecting the <component>, <scale>d 
bounding box and <surface box> to a <morph box> component and generate the 
components over the surface. By changing the scale  factor,  you  can  
change  the  size  of  the  all  components  and  like  always,  the  
position  of  the attractor is also manually controllable.
105	Deformation and Morphing













Fig.6.16. Final model.











As  you  see,  the  size  of  components  started  to  accept  local  
manipulations,  based  on  an  external property which is here a point 
attractor. Although the idea is a simple attractor, the result could be 
interesting and you could differentiate your reference boxes in so many 
other ways as well. Now we know that the morphing concept and panelization 
is not always generic. Having tested the concept, let’s go for another 
practical experiment.
106	Deformation and Morphing


6_4_On Responsive Modulation


The idea for the next step is to modulate a given surface with control over 
each module, means any
module of this system, has to be responsible for some certain criteria. So 
even more than regional
differentiation of the modules, here I want to have a more specific control 
over my system by given
criteria. These could be environmental, functional, visual or any other 
associative behaviour that we
want our module be responsible for.

In  the
next  example,  in  order  to  make
a  building’s  envelope
more  responsive  to
the  host
environment, I just wanted the system be responsive to the sun light. In 
your experiments it could
be wind, rain or internal functions or any other criteria that you are 
looking for.

Here I have a surface, simply as the envelope of a building which I want to 
cover with two different
types of components. One which is closed and does not allow the penetration 
of the sun light and
the other has opening. These components should be proliferated over my 
envelope based on the
main direction of the sun light at the site. I set a user defined angle to 
say the algorithm that for the
certain degrees of sun light we should have closed components and for the 
others, open ones.

The Grasshopper definition does not have anything new, but it is the 
concept that allows us to make
variation over the envelope instead of making a generic surface. Basically 
when the surface is free‐
form and it turns around and has different orientations, it also has 
different angles with the main
sun light at each part. So based on the angle differentiation between the 
surface and the sun light,
this variation in the components happens to the system.





Fig.6.17.First sketches of responsive modules on façade system.
107	Deformation and Morphing





Fig.6.18. Surface of the building as envelope.










Fig.6.19. Two different types of components for building envelope.
108	Deformation and Morphing





Fig.6.20.  The  first  step  is  similar  to  the  previous  experiments.  
I  introduces  <surface>  and  I  used
<divide interval2> to divide it in U and V directions and I generated 
target boxes by <surface box>. I also used the <isotrim> with the same 
intervals and I used <BRep area> to find the centroid of each area (which 
is selected in green). At the same time I used a <curve> component to 
introduce the main sun‐light angle of the site and whit its <end points> I 
made a <vector 2pt> which specify the direction
of the sun light. You can manipulate and change this curve to see the 
effect of sun light in different directions on components later on.







Fig.6.21. in order to evaluate the angle between the sun‐light and the 
surface, I want to measure this angle  between  sun  light  and  normals  
of  the  surface  at  the  position  of  each  component.  So  I  can 
decide for each range of angles what sort of component would be useful. So 
after generating the center points, I need normals of the surface at those 
points. that’s why I used a <surface CP> to find the  closest  point  of  
each  center  point  on  the  surface  to  get  its  UV  parameters  and  
use  these parameters to <evaluate> the surface at that points to actually 
get the normals of surface at that points.
109	Deformation and Morphing



Fig.6.22. I used an <angle> component (Vector > Vector > Angle) to evaluate 
the angle between the
sun direction and the façade. Then I converted this angle to degree and I 
used a <function> to see whether the angle is bigger than the <max_angle> 
or not. This function (x>y) gives me Boolean data, True for smaller angles 
and False for bigger angles.





Fig.6.23. Based on the Boolean data comes from the angle comparison, I 
<dispatch> the data which are  target  boxes  (I  have  the  same  amount  
of  target  box  as  the  center  points  and  normals).  So basically I 
divided my target boxes in two different groups whose difference is the 
angle they receive the sun light.
110	Deformation and Morphing





The rest of the algorithm is simple and like what we have done before. I 
just need to morph my
components into the target boxes, here for two different ones.


Fig.6.24. Here I introduced two different components as single geometries 
and I used two <morph box> components each one associated with one part of 
the <dispatched> data to generate <C_close>
or <C_open> components over the façade.





6.25. Now if you look closer, you can see that in different parts of the 
façade, based on its curvature and direction, different types of components 
are generated.
111	Deformation and Morphing








Fig.6.26. Final model. The bifurcation of the target boxes (and the 
components) could be more than
two in the algorithm. It depends on the design and the criteria that we 
use.









We can think about a component based façade, in which some components are 
closed, and some of them are open, in which open ones have adjustable parts 
that orientate towards external forces, and have apertures that adjust 
themselves to the internal functions of the building and so on and so 
forth.  You  see  that  the  idea  is  to  have  module  based  control  
over  the  system.  We  still  have  the global control (form) and regional 
control (affecting components height or scale regionally) over the system 
as well.
