





























Chapter 7_NURBS Surface and Meshes
113	NURBS Surfaces and Meshes












Chapter 7_NURBS Surface and Meshes


We have had some experiments with surfaces in the previous chapters. We 
used Loft and Pipe to
generate  some  surfaces.  We  also  used  free  form  surface  and  some  
surface  analysis  accordingly. Usually  by  surfaces,  we  mostly  mean  
Free‐Form  surfaces  which  we  generate  them  by  curves  or sometimes 
bunch of points. So usually generating surfaces depends on the curves that 
we provide
for our surface geometries. There are multiple surface components in the 
Grasshopper and if you
have a little bit of experience in working with Rhino you should know how 
to generate your surface geometries by them.

Surface geometries seems to be the final products in our design, like 
facades, walls etc. and that’s why we need lots of effort to generate the 
data like points and curves that we need as the base geometries and finally 
surfaces. Here I decided to design a very simple schematic building just to 
indicate that the multiple surface components in the Grasshopper have the 
potential to generate different design products by very simple basic 
constructs.




7_1_Parametric NURBS Surfaces


In the areas of Docklands of Thames in London, close to the Canary Wharf, 
where the London’s high
rises have the chance to live, there are some potential to build some 
towers. I assumed that we can propose one together, and this design could 
be very simple and schematic, here just to test some of the basic ideas of 
working with free‐form surfaces. Let’s have a look at the area.


Fig.7.1. Arial view, Canary Wharf, London (image: www.maps.live.com, 
Microsoft Virtual Earth).
114	NURBS Surfaces and Meshes


The site that I have chosen to design my project is in the bank of Thames, 
with a very good view to the river and close to the entrance square to the 
centeral part of Canary Wharf (Westferry Road).

I don’t want to go through the site specifics so let’s just have a look at 
where I am going to propose my tower and continue with the geometrical 
issues.



Canary Wharf






























Fig.7.2. Site of the proposed tower.




Manual drawings

There are multiple ways to start this sketch. I can draw the ground floor 
and copy it and start to add
detail like what we have done for Swiss Re. Another way is to draw some 
boundary curves for the tower and use this curves as base geometry for the 
building volume and then add more details to complete the sketch. I would 
prefer the second way since we already know about the first one.

I am going to draw the boundary curves in Rhino.  I can draw these lines in 
Grasshopper but because
I want them to match the geometry of the site so I need some data from the 
site which I can get in this way.

I have a vague idea in mind. My tower has some linear elements in façade 
which are generic, but I
also want to have some hollow spaces between the outside and inside, 
positioned on the façade.

I also want to design a public space close to the river and connected to 
the tower with the same elements as façade, continuous from tower towards 
the river bank.
115	NURBS Surfaces and Meshes



Fig.7.3. The basic lines of the tower associated with the site.

As  you  see  in  the  Figure.7.3  I  have  drawn  my  base  curves  
manually  in  Rhino.  These  curves correspond to the site specifics, 
height limitations, site’s shape and borders, etc, etc. four curves drawn  
for  the  main  building  and  another  two  curves  as  the  borders  of  
the  public  space,  which started from the earth level and then went up to 
be parallel to the tower edges. These curves are very general. You could 
draw whatever you like and go for the rest of the process.




Basic façade elements





Fig.7.4.  For  the  first  step  I  imported  these  four  corner  curves  
into  Grasshopper  by  <curve>
components and then I used <divide curve> to divide these curves into 
<N_div> parts.
116	NURBS Surfaces and Meshes





Fig.7.5. Now I have the same amount of division points on each curve and I 
draw <line> between each curve’s points and the next one, so basically I 
generated <N_div> number of quads like floor edges.







Fig.7.6.  By  connecting  these  <line>s  to  <extrude>  component  
(Surface  >  Freeform  >  Extrude)  and extrusion in Z direction, I 
generated surfaces across façade which reminds me Mies high‐rises but in a 
differentiated way!
117	NURBS Surfaces and Meshes



Fig.7.7. There are four straight lines that connect the four corners of the 
tower in plan. I introduced these  lines  by  another  four  <curve>  
components  and  I  generated  four  surfaces  as  general  façade surfaces 
 that  could  be  glass.  Here  because  I  have  the  planner  section  
curve  and  two  curves  that define  the  boundary  of  the  façade  on  
each  face,  I  used  a  <Sweep  2>  component  to  use  Rails  for making 
a surface by a section curve. So basically after I attached each <Crv_p_n> 
to the <Sweep2> component as the section curve, I attached the corner 
curves as the rails to make each face’s surface. For each section curve in 
the plan, I used two edge curves that start from its end points. So the 
order
is <crv_1> and <crv_2> for the <crv_p_1> and so on.










Fig.7.8. Using tower’s edge curves as Rails to make façade surfaces behind 
the ribs shaped façade elements that we made before.
118	NURBS Surfaces and Meshes








Fig.7.9. With the same method, I just divided another two curves that I 
have drawn for the public space and I attached them to a line component to 
generate some lines as the base geometry for extrusion. I will attach it to 
the same <extrude> component as the façade (don’t forget to hold the Shift 
key when you want to add a new component to the input of an already 
existing component).










Fig.7.10. Now you can alter the corner curves if you like, the number of 
divisions and the height of extrusion to get the best schematic design.
119	NURBS Surfaces and Meshes


Local changes

Up to this point you already know that how to design this tower with 
differentiation and gradual
changes across the façade elements. Here I designed very generic surface 
elements and the only parameters that make the global differentiations are 
edge curves of the tower. Now I want to add some elements to make some 
local changes in these generic elements to show how you can change the 
behaviour of these elements you designed.

As you see, the main element in our case is some lines that I generated 
between division points of the edge curves and then I extruded them to make 
the façade elements. There are many ways that you can change and manipulate 
these lines and then extrude them, so you can get different forms outside, 
and different spaces inside.

Here I decided to add some hollow spaces between these elements and make 
the façade with these general linear elements with locally omitted parts as 
the combination of general and local design effects.

To add these hollow spaces, I want to add them manually as solids to the 
tower and then subtract them from the already existing forms. As an example 
I want to add some very simple ellipsoids to the façade, and randomly 
distribute them alongside the its face. These ellipsoids could be added by
a certain spatial criteria but here the aim is just to explore modelling 
properties and techniques and I
don’t want to go further in design issues.


Fig.7.11. As you can see, I randomly added some ellipsoids o the tower that 
could be special hollow spaces in the building. I will do it for all 
surfaces of the tower.
120	NURBS Surfaces and Meshes



Fig.7.12.  after  distributing  all  ellipsoids  alongside  the  façade  
surfaces  now  I  import  them  to  the Grasshopper  by  <Geometry>  
components  and  for  each  side  of  the  façade  I  use  one  <geometry> 
component  and  introduce  them  as  ‘Set  multiple  Geometries’.  So  each 
 side  of  the  façade  has  one group of ellipsoid geometries.







Fig.7.13. By using a <Trim with BReps> component (Curve > Util > Trim with 
BReps) I can trim these lines across the façade by these randomly 
distributed ellipsoids. The output of the component are curves inside the 
BRep or outside it and I use the outside curves to extrude with the same 
<extrude> component  that  I  generated  before.  I  hide  all  geometries  
in  Rhino  and  uncheck  the  preview  in Grasshopper to see the result 
better. I will do it for all faces and I will connect the output curves to 
the extrude component.
121	NURBS Surfaces and Meshes



Fig.7.14. Now the facade elements are all have their trimmed ellipsoids 
inside.

The next step is to add these hollow spaces to the façade surface as well. 
The process is simple. I just need to find the difference between these 
ellipsoid geometries and façade surfaces. The only point
is that the direction of the normal of the surface affects the ‘difference’ 
command so you should be
aware of that and if needed, change this direction.


Fig.7.15.  The  <Solid  difference>  component  (Intersect  >  Boolean  >  
Solid  difference)  takes  two different solids and performs solid 
difference on them. So I attached the façade surface and hollow geometries 
to find the difference of them. As I told you here I also used <Flip> 
component (Surface > Util > Flip) to flip the Normal of the surface and 
then attach it to the <Solid difference> component otherwise the  hollow  
space  would  face  the  inside  of  the tower.  I  will  do  it  for  all  
surfaces  of  the tower.
122	NURBS Surfaces and Meshes



Fig.7.16. All trimmed façade surfaces.




Now you only need to burn your geometries, cap the tower and render it to 
complete your sketch. Again I should mention here that this was just an 
example to show that how you can generate series
of elements and differentiate them in global and local scale with surface 
components.
123	NURBS Surfaces and Meshes


















Fig.7.17.a/b. Final model.
124	NURBS Surfaces and Meshes


7_2_Mesh vs. NURBS


Up  to  now  we  have  used  different  components  that
mentioned  before  there  are  other  types  of  surfaces
worked  with  the  NURBS  surfaces.  But  as
hich  are  useful  in  other  contexts.  It  is  not
always the smooth beauty of the NURBS that we aimed for, but we might need 
more precise control,
easier  processing  or  simpler  equations.  Beside  the  classical  
surface  types  of  revolution,  ruled  or
pipes, we have different free form surfaces like Besier or B‐Splines. But 
here I am going to talk a little
bit about meshes which are quiet different types of surfaces.

Meshes are another type of free‐form surfaces but made up of small parts 
(faces) and accumulation
of these small parts makes the whole surface. So there is no internal, 
hidden mathematical function
that generates the shape of the surface, but these faces define the shape 
of the surface all together.

If we look at a mesh, first we see its faces. Faces could be triangle, 
quadrant or hexagon. By looking
closer we can see a grid of points which make these faces. These points are 
basic elements of the
mesh surface. Any tiny group of these points (for example any three in 
triangular mesh) make a face
with which the whole geometry become surface. These points are connected 
together by straight
lines.

There are two important issues about meshes: position of these points and 
the connectivity of these
points. The position of the points related to the geometry of the mesh and 
the connectivity of the
points related to the topology.




7_2_1_Geometry and Topology
While the geometry deals with the position of the stuff !! in the space, 
topology deals with their
relations.  Mathematically  speaking,  topology  is  a  property  of  the  
object  that  transformation  and
deformation cannot change it. So for instance circle and ellipse are 
topologically the same and they
have only geometrical difference. Have a look at Figure 7.20. As you see 
there are four points which
are connected to each other. In the first image, both A and B have the same 
topology because they
have  the  same  relation  between  their  points  (same  connection).  But 
 they  are  geometrically
different, because of the displacement of one point. But in the second 
image, the geometry of points
is the same but the connectivity is different and they are not 
topologically equivalent.















Fig.7.20. Topology and Geometry.
125	NURBS Surfaces and Meshes


The  idea  of  topology  is  very  important  in  meshes.  Any  face  in  
the  mesh object  has  some  corner points and these corner points are 
connected to each other with an order in a same way for all faces
of the mesh object. So we can apply any transformation to a mesh object and 
displace the vertices of the  mesh  in  the  space  even  non‐uniformly,  
but  the  connectivity  of  the  mesh  vertices  should  be preserved to 
remain the faces otherwise it collapses.






















A	B


Fig.7.21. A: Both red and grey surfaces are meshes with the same amount of 
faces and vertices, but
in the gray one, the vertices are just displaced, make another geometrical 
configuration of the mesh, but the connectivity of the mesh object is not 
changed and both surfaces are topologically the same.

B:  Two  Mesh  surfaces  are  geometrically  the  same  and  have  the  
same  amount  of  vertices  but connectivity of vertices are different, 
faces are triangular in the gray one but quad in the red, make different 
topology for them.






Knowing the importance of topological aspects of mesh objects, they are 
powerful geometries while we  have  bunch  of  points  and  we  need  a  
surface  type  to  represent  them  as  a  continuous  space. Different 
types of algorithms that working with points could be applied to the mesh 
geometry since we save the topology of the mesh. For instance, using finite 
element analysis or specific applications like dynamic relaxation, and 
particle systems, it is easier to work with meshes than other types of 
surfaces since the function can work with mesh vertices.

Mesh objects are simple to progress and faster to process; they are capable 
of having holes inside and discontinuity in the whole geometry. There are 
also multiple algorithms to refine meshes and make smoother surfaces by 
mesh objects. Since different faces could have different colours initially, 
mesh objects are good representations of analysis purposes (by colour) as 
well.

There are multiple components that dealing with the mesh objects in ‘mesh’ 
tab in Grasshopper. Let’s start a mesh from scratch and then try to grow 
our knowledge.
126	NURBS Surfaces and Meshes







7_3_On Particle Systems


I have a group of points and I want to make a surface by these points. In 
this example the group of
points is simplified in a grid structure. To discuss the basic concept of 
the ‘particle systems’ here I
will try to project this idea on a mesh geometry in a simple example.

I am thinking of a vertical grid of points that represent the basic 
parameters of a surface which is being affected by an imaginary wind 
pressure. I want to displace the points by this wind factor (or any force 
that has a vector) and represent the resultant deformed surface. Basically 
by changing the wind factor, we can see how the surface changes.

(Actually I want to deal with a surface geometry and an extra force that 
applies to this surface, with each point as a particle separately, and 
observe the result with changes of the main force)







Fig.7.22. The first step is simple. By using a <series> component with 
controlled number of points
<N_pt>, and distance between them <distance_pt> I generated a grid of cross 
referenced <point>s.






The pressure of the imaginary wind force, affects all points in the grid 
but I assumed that the force of the wind increases when goes up, so the 
wind pressure become higher in the higher Z values of the surfaces. And at 
the same time, the force affects the inner points more than the points 
close to the edges. The points on the edges in the plan section do not move 
at all (fix points). In particle system there is a relation between 
particles as well, and we should define another set of rules for them, but 
here I just set the external forces just to show how we can work with 
points as particles.
127	NURBS Surfaces and Meshes

























Fig.7.23. Diagram of the wind force affected the surface. A: section; the 
vertical effect of the force, B:
plan; the horizontal effect.




Basically I need two different mechanisms to model these effects, one for 
the section diagram and another for the plan. I simplified the mechanism to 
an equation just to show the way we want the force affects points. For the 
first mechanism, to produce points displacements by using (X^2) while X
is the Z value of the point being affected by the force. So for each point 
I need to extract the Z
coordinate of the point.

To make everything simple, I just assumed that the force direction is in 
the Y direction of the world coordinate system. So for each point on the 
grid, I need to generate a vector in Y direction and I set
its force by the number that I receive from the first equation. For the 
second diagram we need a bit more of an equation to do. Let’s have a look 
at part one first.


Fig.7.24. The Z coordinate of the point extracted by a <decompose> 
component and then powered by
(x^2) and then divided by a given <number slider> just to control the 
movement generaly. The result
is  a  factor  to  <multiply>  the vector  (Vector  >  Vector  >  Multiply) 
 which  is  simply  a  world  <unit  Y>
vector as force. So basically I generated force vectors for each point in 
the grid.
128	NURBS Surfaces and Meshes



Fig.7.25. If I displace the points by these vectors you can see the 
resultant grid of points that satisfy the first step of this modelling.






Now if we look at the second part of the force modelling, as I said, I 
assumed that in the planner section, the points on the edge are fixed and 
the points on the middle displaced the most. Figure
7.26 show this displacement for each row of the point grid.







Fig.7.26. Displacement of points in rows (planner view).




Since I have the force vectors for each point, I need to control them and 
set a value again, to make sure that their displacement in the planner 
section is also met the second criteria. So for each row of the points in 
the grid, I want to generate a factor to control the force vector’s 
magnitude. Here I assumed that for the points in the middle, the force 
vector’s power are maximum that means what they are, and for the points on 
the edges, it become zero means no displacement and for the other points a 
range in between.
129	NURBS Surfaces and Meshes



Fig.7.27. For the second mechanism, I need a <range> of numbers between 0 
and 1 to apply to each point; 0 for the edge, 1 for the middle. I need a 
range from 0 to 1 from one edge to the middle and then from 1 to 0 to go 
from the middle to the other edge. I need this <range> component generates 
values as half of the numbers of points in each row. I set the <N_pt> to 
the even numbers, and I divided it by 2, then minus 1 (because the <range> 
component takes the number of divisions and not number of values). You see 
the first <panel> shows four numbers from 0 to 1 for the first half of the 
points. then I <reverse>d the list and I merge these two list together and 
as you see in the second
<panel> I generated a list from 0 to 1 to 0 and the number of values in the 
list is the same as number
of points in each row.

The final step is to generate these factors for all points in the grid. So 
I <duplicate>d the points as much as <N_pt> (number of rows and columns are 
the same). Now I have a factor for all points in the grid based on their 
positions in their rows.






Fig.7.28. Now I need to <multiply> the force vector again by the new 
factors. If I displace the points
by these new vectors, we can see how two different mechanisms affected the 
whole point grid.
130	NURBS Surfaces and Meshes


Actually this part of the example needed a little bit of analytical 
thinking. In reality, methods like Particle spring systems or Finite 
Element Analysis use this concept that multiple vectors affecting the whole 
points in the set and points affecting each other also. So when you apply a 
force, it affects the whole points and points affecting each other 
simultaneously. These processes should be calculated
in iterative loops to find the resting position of the whole system. Here I 
just make a simple example
without these effects of particle systems and I just want to show a very 
simple representation of such a system dealing with multiple forces which 
in real subjects are a bit more complicated!









Mesh


Fig.7.29. Mesh generation. Now if you simply add a <mesh> component (Mesh > 
Primitive > Mesh) to
the canvas and connect the displaced points to it as vertices, you will see 
that nothing happening in the scene. We need to define the faces of the 
mesh geometry to generate it. Faces of the mesh are actually a series of 
numbers who just defines the way these points are connected together to 
make the  faces  of  the  surface.  So  here  vertices  are  the  
geometrical  part  of  the  mesh  but  we  need  the topological definition 
of the mesh to generate it.






Every four corner point of the grid, define a quadrant face for the mesh 
object. If we look at the point grid, we see that there is an index number 
for each point in the grid. We know each point by
its index number instead of coordinates in order to deal with its topology.
131	NURBS Surfaces and Meshes



Fig.7.30. Index number of points in the grid.




To define the mesh faces, we need to call every four corners that we 
assumed to be a face and put them together and give them to the <mesh> 
component to be able to make the mesh surface. The order of this points in 
each face is the same for all faces.


Fig.7.31.  In  a  given  point  grid,  a  simple  quadrant  face  defined  
by  the  order  of  points  that  if  you connect them by a polyline, you 
can make the face. This polyline starts from a point in the grid, goes
to the next point, then goes to the same point of the next row and then 
goes to the back column
point of that row, and by closing this polyline, you will see the first 
face of the mesh finds its shape. Here the first face has points [0,1,6,5] 
in its face definition. The second face has [1,2,7,6] and so on.
132	NURBS Surfaces and Meshes


To  define  all  mesh  faces,  we  should  find  the  relation  between  
these  points  and  then  make  an algorithm that generates these face 
matrices for us.

If we look at the face matrix, we see that for any first point, the second 
point is the next in the grid.
So basically for each point (n) in the grid, the next point of the face is 
(n+1). Simple!

For the next point of the grid, we know that it is always shifts one row, 
so if we add the number of columns (c) to the point (n) we should get the 
point at the next row (n+c). So for instance in the above example we have 5 
columns so c=5 and for the point (1) the next point of the mesh face is 
point (n+c) means point (6). So for each point (n) as the first point, 
while the second points is (n+1), the third point would be (n+1+c). That’s 
it.

For the last point, it is always stated in one column back of the third 
point. So basically for each point
(n+1+c) as the third point, the next point is (n+1+c‐1) which means (n+c). 
So for instance for the point (6) as the third point, the next point 
becomes point (5).

All together for any point (n) in the grid, the face that starts from that 
single point has this points
as the ordered list of vertices: [n, n+1, n+1+c, n+c] while (c) is the 
number of columns in the grid.





Fig.7.32. After defining all mesh faces, the mesh can be generated.




Looking  at  the  mesh  vertices,  there  is  a  bit  more  to  deal  with. 
 If  you  remember  the  ‘Triangle’ example of chapter_3, there was an 
issue to select the points that could be the first points in the grid.  If  
you  look  at  the  grid  of  points  in  the  above  example,  you  see  
that  the  points  on  the  last column and last row could not be the start 
points of any face. So beside the fact that we need an algorithm to 
generate the faces of the mesh object, we need a bit of data management to 
generate the first points of the whole grid and pass these first points to 
the algorithm and generate mesh faces.
133	NURBS Surfaces and Meshes


So basically in the list of points, we need to omit the points of the last 
row and last column and then start to generate face matrices. To generate 
the list of faces, we need to generate a list of numbers
as the index of points.





Fig.7.33. Generating the index number of the first points in the grid with 
a <series> component. The number of values in the series comes from the 
<N_pt> as the number of columns (same as rows) and
by using a function of < x * (x‐1)> I want to generate a series of numbers 
as <columns*(rows‐1)> to generate the index for all points in the grid and 
omit the last row. The next step is to <cull> the index
list by the number of columns (<N_pt>) to omit the index of the last 
columns as well.







Fig.7.34. Final index number of the possible first points of the mesh faces 
in the grid (with 8 points in each column).
134	NURBS Surfaces and Meshes



Fig.7.35. A <Mesh quad> component (Mesh > Primitive > Mesh quad) is in 
charge of generating quad faces in Grasshopper. I just attached the list of 
first numbers to the first point of the <quad>.






Now this is the time to generate the list of indices for the faces:





Fig.7.36. While (x) is the index of the first point (<cull> list) and (y) 
is the number of the columns(from
<N_pt> number slider), the second point is (x+1), the third point is 
((x+1)+y) (the index of second point
+ number of columns), and the last point is ((x+1+y)‐1)  (the index of the 
third point ‐1).
135	NURBS Surfaces and Meshes



Fig.7.37. The resultant mesh.







Fig.7.38. Changing the parameters, related to the force and manipulating 
the mesh.









7_4_On Colour Analysis


To finish this example, let’s have a look at how we can represent our final 
mesh with colours as a
medium for analysis purposes. There are different components in the 
Grasshopper that provide us colour representations and these colours are 
suitable for our analysis purpose.

Here in this example, again to bring a concept, I simply assumed that at 
the end, we want to see the amount of deviation of our final surface from 
the initial position (vertical surface). I want to apply a gradient of 
colours start from the points which remained fix with bottom colour up to 
the points which has the maximum amount of deviation from the vertical 
position with the higher colour of the gradient.
136	NURBS Surfaces and Meshes


Simply, to find the amount of deviation, I need to measure the final state 
of each point to its original state. Then I can use these values to assign 
colour to the mesh faces base on these distances.





Fig.7.39. If I simply go back, I have the initial point grid that we 
generated in the first step and I have also the final displaced point grid 
that I used to generate the mesh vertices. I can use a <distance> component 
to measure the distance between the initial position of the point and its 
final position to see the deviation of the points.







Fig.7.40.  For  our  analysis  purpose  I  want  to  use  a  <Gradient>  
component  (Params  >  Special  > Gradient)  to  assign  gradient  of  
colours  to  the  mesh.  I  attached  my  <distance>  values  to  the 
parameter part (t) of the <Gradient> and I attached it to the Colour input 
of the <mesh> component.




But to complete the process I need to define the lower limit and upper 
limit of gradient range (L0 and L1). Lower limit is the minimum value in 
the list and upper limit is maximum value in the list and other values are 
being divided in the gradient in between.

To get the lower and upper limit of the list of deviations I need to simply 
sort the data and get the first and last values in that numerical range.
137	NURBS Surfaces and Meshes








Fig.7.41. By using a <sort> component to sort the distances, I get the 
first item of the data list (index=
0) as lower limit and the last one (index= <list length> ‐ 1) as the upper 
limit of the data set (deviation values) to connect to the <gradient> 
component to assign colours based on this range.










Fig.7.42.  By  clicking  on  the  small  colour  icon  on  the  corner  of  
the  <gradient>  component  we  can change the colours of the gradient.
138	NURBS Surfaces and Meshes



Fig.7.43. Right‐click on the component and on the context pop‐up menu you 
have more options to manipulate   your   resultant   colours.   Different   
types   of   colour   gradient   to   suit   the   graphical representation 
of your analysis purpose.













Fig.7.44.a/b. Different gradient thresholds.
139	NURBS Surfaces and Meshes


7_5_Manipulating Mesh objects as a way of Design


Depends on the object and purpose of the modelling, I personally prefer to 
get my mesh object by
manipulating a simple mesh geometry instead of generating a mesh from 
scratch since defining the point set and face matrices are not always 
simple and easy to construct. By manipulating, I mean that  we  can  use  a 
 simple  mesh  object,  extract  its  components  and  change  them  and  
then  again make a mesh with varied vertices and faces. So I do not need to 
generate points as vertices and matrices of faces. Let’s have a look at a 
simple example.


Modifying Geometry








Modifying Topology


Fig.7.45. In this example, I simply used a <mesh plane> component and I 
extracted its data by using a
<mesh  components>  to  have  access  to  its  vertices  and  faces.  Then  
I  displaced  vertices  along  Z direction by random values powered by a 
<number slider> and again attached them to a <mesh> component to generate 
another mesh. Here I also used a <cull pattern> component and I omitted 
some of the faces of original mesh and then I used them as new faces for 
making another mesh. The resultant mesh has both geometrical and 
topological difference wih its initial mesh and can be used
for any design purpose.




This  idea  of  geometrically  manipulating  the  vertices  and  
topologically  changing  the  faces  has  so many different possibilities 
that you can use in your design experiments. Since mesh objects have the  
potential  to  omit  some  of  their  faces  and  still  remain  as  
surface,  different  design  ideas  like porous surfaces could be pursued 
by them.


Fig.7.46. Resultant manipulated mesh (just a random case).
140	NURBS Surfaces and Meshes














Fig.7.47.a/b. Final model.
