C_4_D
Exercises : grids
A. Grid constructions:
To get you started with this series of exercises please first follow the accompanying
tutorial and related Rhino/GH files which is also on the Canvas.
#1 Grid bound by 2 points
Create a grid whose dimensions are determined by two points assigned from the
rhino workspace and two sliders that control the resolution along the X and Y
dimension. The two points will determine the bottom left and top right corners of
the grid. The code for this exercise can be lifted almost directly from the tutorial the
only trick is to figure out what are the horizontal and vertical lengths of the
bounding rectangle given the two corner points and from that you can calculate the
x and y grid steps.
#1.B Elevation functions
For this exercise we want to visualize the shape of elevation functions of the form
z=f(x,y) that is for each pair of X,Y coordinates we generate an elevation value Z that
defines the z coordinate of the grid point. You can simply use the same script from
exercise #1 and only alter the Z coordinate of each grid point.
z=cos(x)
z=cos(x)*cos(y)
z=cos(x*y*0.1)
z=(x2+y2
)*0.1
z=√𝑥
2 + 𝑦
2
z=cos (√𝑥
2 +𝑦
2)
B. connections
The connection exercises are all based on exercise #1 so you can use that as a basis.
You won’t need to change the point generation code from #1 at all just add an extra
loop that selectively creates lines between the existing points. You can think of
these exercises as starting with “given a list of points that contains columns x rows
points organized in a grid ….”.
The following exercises require you to output line segments to show the
connections. The type for a line in GH is “Line” and to output multiple lines you will
need to first create a list of line segments List
. You will also need a second
output B on your component in which to output the list of lines. So, the code needs
to have:
List
lines = new List
();
somewhere in the beginning and end with:
B = lines;
in between you need to call :
lines.Add(new Line(Start, End));
where Start and End are the points you want to connect.
They can be selected from the list points using indexing like:
lines.Add(new Line(points[k], points[k+1]));
It is up to you to calculate the indices of the points to connect to generate the
requested connectivity patterns. Look at the notes (05_grids.pdf) and especially this
diagram to figure out the indexing and addressing scheme around a point at grid
index k:
So a typical component will look like:
List
lines = new List
();
List
points = new List
();
Loop
Generate some points using a nested loop
Loop
Generate some lines using a loop and calling:
lines.Add(new Line(Start, End));
A=points;
B=lines;
#2 axis aligned connections
Generate the horizontal and vertical lines connecting all grid points. [Hint, you will
need to also add some conditional statements to avoid trying to connect for
example the rightmost point with its non-existent right-hand neighbour]
#3 diagonals
Add the diagonals to the previous connectivity pattern.
#4 periodic omissions
Try to add a few more conditional if statements to achieve the following pattern.
One way to think about it is to look at one type of connector (e.g. horizontal) and
think “how often does it need to be skipped?”. The modulo operator % is your best
friend. You don’t have to replicate the exact pattern shown below but rather
experiment and design your own periodic omission pattern using simple conditional
statements.
C. raster colour visualization
The following exercises demonstrate some simple techniques for visualizing data
over the grid as colours. This will be extremely valuable later to visually inspect
quantities as they change over such domains.
#6 distance to point
Starting with the grid from assignment #1 and given a point input “focus” that you
can move around in the viewport, output the list of distances from the point “focus”
to each of the points[k] of the grid. You need to add one more point input to your
component named “focus” . Your component needs an extra output “B”. You need
to assign a list of numbers to this output List . If your grid has 5x5=25
points then the output B should contain 25 numbers corresponding to the distances
of each of the 25 points to the input “focus” point.
To help you visualize this as colour information drag the colour gradient component
from the Params->Input tab of GH and connect it to the list of numbers. By
default this component maps any number between [0,1] to the colors in its
gradient. Therefore the points closer to the focus point will have small distances and
hence more of the left most colours. If you connect a list of N numbers to this
comonent you will get a list of 25 colors. To colorize and blend the points use the
point cloud component from the Display toolbar. Connect the points and the
colours to this components as well as an optional size slider.
In the above diagram we can see that because our grid can be large, and we only
map the range of distances [0,1] to colours of the gradient ramp, most of the
information is not visualized because it falls outside the colour range. The gradient
component has two extra inputs to address this issue, but we are going to solve this
problem differently in the next exercise:
#7
Here we want to improve the previous visualization by remapping the range of
distance values to the unit interval [0,1]. Therefore, the colours of the gradient can
cover a larger area of the grid. We are going to use exercise #6 from
02_flow_control set of exercises. You can use the function that you wrote there to
improve the colour distribution in the grid. Try to achieve something close to the
following visual:
The min/max values have the meaning of the source interval (range of distances)
that will be mapped to the unit interval (0,1). That means that distances at min will
yield 0 (and hence the leftmost colour) and distances at max or greater will yield (1+
and hence the right most colour).
D. 3 D
#8 a volumetric grid
If you have followed so far it should be easy to figure out how to extend the 2d grid
into the 3rd dimension. Try to revisit the 05_grids notes and see how we went from
a 1 dimensional grid [a row of points] to a two dimensional one. The same reasoning
can be extended to cover the 3rd dimension. The 2d grid nested loops we used in #1
generates a plane of points and you need to repeat this process in order to stack
several planes on top of each other while changing the z coordinate at each layer.
Start with assignment #1 and simply add another outer loop around the point
generation loop perhaps with an index k that ranges from 0 to the number of layers.
Then use k to calculate the z coordinate of each layer so that you cover a total given
height.
After you have the basic grid you can add skewing and colorization in the same
manner as before.