?代做program、Python/C++程序代写

日期：2023-10-12 10:45

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<Line>. 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<Line> lines = new List<Line>();

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<Line> lines = new List<Line>();

List<Point3d> points = new List<Point3d>();

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<double> . 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.