def coarsen$($terrain$)$:

x $=$ terrain.points$[$:$,0]$

y $=$ terrain.points$[$:$,1]$

z $=$ terrain.points$[$:$,2]$

# Reshape the coordinate arrays to match the dimensions of the terrain mesh

x $=$ x$.$reshape$($terrain$.$dimensions, order$=\text{'}$F$\text{'})$

y $=$ y$.$reshape$($terrain$.$dimensions, order$=\text{'}$F$\text{'})$

z $=$ z$.$reshape$($terrain$.$dimensions, order$=\text{'}$F$\text{'})$

# Sample every other point along each axis

x$\_$coarse $=$ x$[$::$2,$ ::$2]$

y$\_$coarse $=$ y$[$::$2,$ ::$2]$

z$\_$coarse $=$ z$[$::$2,$ ::$2]$

# Calculate the new dimensions

new$\_$dims $=(($terrain$.$dimensions$[0]//2)+1,($terrain$.$dimensions$[1]//2)+1,1)$

# Create the new coarser mesh as a StructuredGrid

coarse $=$ pv$.$StructuredGrid$($x$\_$coarse.ravel$(\text{'}$F$\text{'}),$ y$\_$coarse.ravel$(\text{'}$F$\text{'}),$ z$\_$coarse.ravel$(\text{'}$F$\text{'}))$

return x$\_$coarse, y$\_$coarse, z$\_$coarse, coarse

#grade $($write your code in this cell and DO NOT DELETE THIS LINE$)$

#NOTE: You do not need to round any values within your results.

def bilin$($x$,$ y$,$ points$)$:

# YOUR CODE HERE

# raise NotImplementedError$()$

# to keep unique x and y coordinate

x$\_$set $=$ set$()$

y$\_$set $=$ set$()$

# to be able to get value at the coordinate quickly

points$\_$dict $=\{\}$

for point in points:

# add coordinates to set and dict

x$\_$set.add$($point$[0])$

y$\_$set.add$($point$[1])$

points$\_$dict$[($point$[0],$ point$[1])]=$ point$[2]$

# turn it to list

x$\_$list $=$ list$($x$\_$set$)$

y$\_$list $=$ list$($y$\_$set$)$

# sort the list

x$\_$list.sort$()$

y$\_$list.sort$()$

# print$($x$\_$list$)$

# print$($y$\_$list$)$

# print$($points$\_$dict$)$

# calculate t ratio for x

t$\_$x $=($ x $-$ x$\_$list$[0])/($ x$\_$list$[1]-$ x$\_$list$[0])$

# print$($t$\_$x$)$

# calculate first bilinear interpolation for x axis

bilin$\_$bottom $=(1-$ t$\_$x $)*$ points$\_$dict$[($x$\_$list$[0],$ y$\_$list$[0])]+($ t$\_$x $*$ points$\_$dict$[($x$\_$list$[1],$ y$\_$list$[0])])$

bilin$\_$top $=(1-$ t$\_$x $)*$ points$\_$dict$[($x$\_$list$[0],$ y$\_$list$[1])]+($ t$\_$x $*$ points$\_$dict$[($x$\_$list$[1],$ y$\_$list$[1])])$

# print$($bilin$\_$bottom$)$

# print$($bilin$\_$top$)$

# calculate t ratio for y

t$\_$y $=($ y $-$ y$\_$list$[0])/($ y$\_$list$[1]-$ y$\_$list$[0])$

# return bilinear interpolation for y axis

return $(1-$ t$\_$y $)*$ bilin$\_$bottom $+$ t$\_$y $*$ bilin$\_$top

Now, using your bilin$()$ function, create a new mesh or StructuredGrid object named intmesh, reconstructed from coarse using bilinear interpolation, with the same dimensions as our original mesh terrain. Your new mesh should contain the interpolated z$-$values for each point in terrain.

As a starting point, we have defined some of the variables that will be helpful to you for creating your new interpolated mesh. Specifically, we will be checking the values in errz and intz, as defined below:

intz: a $3$D array with the same shape as terrain.z that will contain the bilinearly interpolated z$-$values from the coarsened mesh.

Note: intz is a $3$D M x N x $1$ array where the last dimension contains the z$-$values. You should note this when assigning elements to intz. The interpolated mesh is a $3$D M by N by $1$ array, so tests will fail if you assign values to it as if it were just a $2$D M by N array, bypassing the z$-$axis entirely. So$,$ if your code looks like intz$[$x$][$y$]=$ bilin$(...)$ the fix is to change it to something like intz$[$x$][$y$]=[$ bilin$(...)]$ or intz$[$x$][$y$][0]=$ bilin$(...).$

errz: a list of scalar values. This should contain the absolute error values between each z$-$value in the original mesh and each interpolated z$-$value in the new returned mesh

Just like how we added the attribute values to our coarse mesh in order to plot the z$-$values of the mesh, you should add an additional attribute errors to intmesh in order to plot the absolute error values between the z$-$values in the original mesh and the interpolated z$-$values in our new returned mesh.

In the code block below, complete the implementation of reconstructMesh$($terrain$,$coarse$),$ which should return a tuple containing $($intz$,$ errz, intmesh$).$