def test_gridPointsInPolygon(self): # # Make a polygon, check the grid points exist where we need them # Simple example -- no points on the trial grid are excluded myPoly = [[0., 10.], [10., 10.], [10., 0.], [0., 0.]] pip = su.gridPointsInPolygon(myPoly, approx_grid_spacing=[1., 1.]) # There should be 121 points in total assert(pip.shape[0] == 121) # The min/max x and y should be inside assert(min(pip[:, 0]) > 0.) assert(max(pip[:, 0]) < 10.) assert(min(pip[:, 1]) > 0.) assert(max(pip[:, 1]) < 10.) # Example where some points on the trial grid would be excluded myPoly = [[0., 10.], [10., 10.], [10., 0.]] pip = su.gridPointsInPolygon(myPoly, approx_grid_spacing=[1., 1.]) # The min/max x and y should be inside assert(min(pip[:, 0]) > 0.) assert(max(pip[:, 0]) < 10.) assert(min(pip[:, 1]) > 0.) assert(max(pip[:, 1]) < 10.) # x+y should always be >= 10, since the line connecting [0,10] and # [10,0] is x+y=10 assert(all(pip[:, 0]+pip[:, 1] >= 10.))
def test_gridPointsInPolygon(self): # # Make a polygon, check the grid points exist where we need them ## Simple example -- no points on the trial grid are excluded myPoly=[[0., 10.], [10., 10.], [10., 0.], [0., 0.]] pip=su.gridPointsInPolygon(myPoly, approx_grid_spacing=[1.,1.]) # There should be 121 points in total assert(pip.shape[0]==121) # The min/max x and y should be inside assert(min(pip[:,0])>0.) assert(max(pip[:,0])<10.) assert(min(pip[:,1])>0.) assert(max(pip[:,1])<10.) ## Example where some points on the trial grid would be excluded myPoly=[[0., 10.], [10., 10.], [10., 0.]] pip=su.gridPointsInPolygon(myPoly, approx_grid_spacing=[1.,1.]) # The min/max x and y should be inside assert(min(pip[:,0])>0.) assert(max(pip[:,0])<10.) assert(min(pip[:,1])>0.) assert(max(pip[:,1])<10.) # x+y should always be >= 10, since the line connecting [0,10] and # [10,0] is x+y=10 assert(all(pip[:,0]+pip[:,1]>=10.))
def elevation_setter(xc, yc): # Return scipy array of values out = xc * 0. # Get multiple elevation values in each triangle. # Process triangles in chunks to reduce function call overhead lx = len(xc) lx_div_cs = scipy.ceil(lx * 1. / (1. * chunk_size)).astype(int) # Crude check that xc/yc are the centroid values # erMess = ' Result of make_meanFun can ONLY be applied to a vector' +\ ' of ALL centroid coordinates\n' +\ ' (since mesh triangles are used to spatially average)' assert scipy.all(xc == domain.centroid_coordinates[:, 0]), erMess assert scipy.all(yc == domain.centroid_coordinates[:, 1]), erMess # Find triangles in which we want to average if polygons_for_averaging is not None: averaging_flag = 0 * xc # Need georeferenced centroid coordinates to find which # are in the polygon xll = domain.geo_reference.xllcorner yll = domain.geo_reference.yllcorner centroid_coordinates_georef = scipy.vstack([xc + xll, yc + yll]).transpose() for j in range(len(polygons_for_averaging)): poly_j = polygons_for_averaging[j] # poly_j can either be a polygon, or a filename if type(poly_j) is str: poly_j = su.read_polygon(poly_j) points_in_poly_j = inside_polygon(centroid_coordinates_georef, poly_j) averaging_flag[points_in_poly_j] = 1 else: averaging_flag = 1 + 0 * xc for i in range(lx_div_cs): # Evaluate in triangles lb:ub lb = i * chunk_size ub = min((i + 1) * chunk_size, lx) if verbose: print 'Averaging in triangles ', lb, '-', ub - 1 # Store x,y,triangleIndex px = scipy.array([]) py = scipy.array([]) p_indices = scipy.array([]) for j in range(lb, ub): # If we average this cell, then get a grid # of points in it. Otherwise just get the centroid # coordinates. if averaging_flag[j] == 1: mesh_tri = \ domain.mesh.vertex_coordinates[ range(3 * j, 3 * j + 3), :].tolist() pts = su.gridPointsInPolygon( mesh_tri, approx_grid_spacing=approx_grid_spacing) else: # Careful to keep this a 2D array pts = domain.centroid_coordinates[j, :, None].transpose() px = scipy.hstack([px, pts[:, 0]]) py = scipy.hstack([py, pts[:, 1]]) p_indices = scipy.hstack( [p_indices, scipy.repeat(j, len(pts[:, 0]))]) # Get function values at all px,py if verbose: print ' Evaluating function at ', len(px), ' points' allTopo = q_function(px, py) # Set output values in lb:ub for j in range(lb, ub): out_indices = (p_indices == j).nonzero()[0] assert len(out_indices) > 0 if (averaging == 'mean'): out[j] = allTopo[out_indices].mean() elif (averaging == 'min'): out[j] = allTopo[out_indices].min() elif (averaging == 'max'): out[j] = allTopo[out_indices].max() else: raise Exception('Unknown value of averaging') return (out)
def elevation_setter(xc, yc): # Return scipy array of values out = xc * 0. # Get multiple elevation values in each triangle. # Process triangles in chunks to reduce function call overhead lx = len(xc) lx_div_cs = scipy.ceil(lx * 1. / (1. * chunk_size)).astype(int) # Crude check that xc/yc are the centroid values # erMess = ' Result of make_meanFun can ONLY be applied to a vector' +\ ' of ALL centroid coordinates\n' +\ ' (since mesh triangles are used to spatially average)' assert scipy.all(xc == domain.centroid_coordinates[:, 0]), erMess assert scipy.all(yc == domain.centroid_coordinates[:, 1]), erMess for i in range(lx_div_cs): # Evaluate in triangles lb:ub lb = i * chunk_size ub = min((i + 1) * chunk_size, lx) if verbose: print 'Averaging in triangles ', lb, '-', ub - 1 # Store x,y,triangleIndex px = scipy.array([]) py = scipy.array([]) p_indices = scipy.array([]) for j in range(lb, ub): mesh_tri = \ domain.mesh.vertex_coordinates[ range(3 * j, 3 * j + 3), :].tolist() pts = su.gridPointsInPolygon( mesh_tri, approx_grid_spacing=approx_grid_spacing) px = scipy.hstack([px, pts[:, 0]]) py = scipy.hstack([py, pts[:, 1]]) p_indices = scipy.hstack( [p_indices, scipy.repeat(j, len(pts[:, 0]))]) # Get function values at all px,py if verbose: print ' Evaluating function at ', len(px), ' points' allTopo = q_function(px, py) # Set output values in lb:ub for j in range(lb, ub): out_indices = (p_indices == j).nonzero()[0] assert len(out_indices) > 0 if (averaging == 'mean'): out[j] = allTopo[out_indices].mean() elif (averaging == 'min'): out[j] = allTopo[out_indices].min() elif (averaging == 'max'): out[j] = allTopo[out_indices].max() elif (averaging == 'harmonic_mean'): out[j] = 1.0 / (1.0 / allTopo[out_indices]).mean() else: raise Exception, 'Unknown value of averaging' return (out)
def elevation_setter(xc, yc): # Return scipy array of values out = xc * 0. # Get multiple elevation values in each triangle. # Process triangles in chunks to reduce function call overhead lx = len(xc) lx_div_cs = scipy.ceil(lx * 1. / (1. * chunk_size)).astype(int) # Crude check that xc/yc are the centroid values # erMess = ' Result of make_meanFun can ONLY be applied to a vector' +\ ' of ALL centroid coordinates\n' +\ ' (since mesh triangles are used to spatially average)' assert scipy.all(xc == domain.centroid_coordinates[:, 0]), erMess assert scipy.all(yc == domain.centroid_coordinates[:, 1]), erMess # Find triangles in which we want to average if polygons_for_averaging is not None: averaging_flag = 0*xc # Need georeferenced centroid coordinates to find which # are in the polygon xll = domain.geo_reference.xllcorner yll = domain.geo_reference.yllcorner centroid_coordinates_georef = scipy.vstack([xc + xll, yc + yll]).transpose() for j in range(len(polygons_for_averaging)): poly_j = polygons_for_averaging[j] # poly_j can either be a polygon, or a filename if type(poly_j) is str: poly_j = su.read_polygon(poly_j) points_in_poly_j = inside_polygon(centroid_coordinates_georef, poly_j) averaging_flag[points_in_poly_j] = 1 else: averaging_flag = 1 + 0*xc for i in range(lx_div_cs): # Evaluate in triangles lb:ub lb = i * chunk_size ub = min((i + 1) * chunk_size, lx) if verbose: print 'Averaging in triangles ', lb, '-', ub - 1 # Store x,y,triangleIndex px = scipy.array([]) py = scipy.array([]) p_indices = scipy.array([]) for j in range(lb, ub): # If we average this cell, then get a grid # of points in it. Otherwise just get the centroid # coordinates. if averaging_flag[j] == 1: mesh_tri = \ domain.mesh.vertex_coordinates[ range(3 * j, 3 * j + 3), :].tolist() pts = su.gridPointsInPolygon( mesh_tri, approx_grid_spacing=approx_grid_spacing) else: # Careful to keep this a 2D array pts = domain.centroid_coordinates[j,:, None].transpose() px = scipy.hstack([px, pts[:, 0]]) py = scipy.hstack([py, pts[:, 1]]) p_indices = scipy.hstack([p_indices, scipy.repeat(j, len(pts[:, 0]))]) # Get function values at all px,py if verbose: print ' Evaluating function at ', len(px), ' points' allTopo = q_function(px, py) # Set output values in lb:ub for j in range(lb, ub): out_indices = (p_indices == j).nonzero()[0] assert len(out_indices) > 0 if(averaging == 'mean'): out[j] = allTopo[out_indices].mean() elif(averaging == 'min'): out[j] = allTopo[out_indices].min() elif(averaging == 'max'): out[j] = allTopo[out_indices].max() else: raise Exception('Unknown value of averaging') return(out)
def elevation_setter(xc, yc): # Return scipy array of values out = xc * 0. # Get multiple elevation values in each triangle. # Process triangles in chunks to reduce function call overhead lx = len(xc) lx_div_cs = scipy.ceil(lx * 1. / (1. * chunk_size)).astype(int) # Crude check that xc/yc are the centroid values # erMess = ' Result of make_meanFun can ONLY be applied to a vector' +\ ' of ALL centroid coordinates\n' +\ ' (since mesh triangles are used to spatially average)' assert scipy.all(xc == domain.centroid_coordinates[:, 0]), erMess assert scipy.all(yc == domain.centroid_coordinates[:, 1]), erMess for i in range(lx_div_cs): # Evaluate in triangles lb:ub lb = i * chunk_size ub = min((i + 1) * chunk_size, lx) if verbose: print 'Averaging in triangles ', lb, '-', ub - 1 # Store x,y,triangleIndex px = scipy.array([]) py = scipy.array([]) p_indices = scipy.array([]) for j in range(lb, ub): mesh_tri = \ domain.mesh.vertex_coordinates[ range(3 * j, 3 * j + 3), :].tolist() pts = su.gridPointsInPolygon( mesh_tri, approx_grid_spacing=approx_grid_spacing) px = scipy.hstack([px, pts[:, 0]]) py = scipy.hstack([py, pts[:, 1]]) p_indices = scipy.hstack([p_indices, scipy.repeat(j, len(pts[:, 0]))]) # Get function values at all px,py if verbose: print ' Evaluating function at ', len(px), ' points' allTopo = q_function(px, py) # Set output values in lb:ub for j in range(lb, ub): out_indices = (p_indices == j).nonzero()[0] assert len(out_indices) > 0 if(averaging == 'mean'): out[j] = allTopo[out_indices].mean() elif(averaging == 'min'): out[j] = allTopo[out_indices].min() elif(averaging == 'max'): out[j] = allTopo[out_indices].max() elif(averaging == 'harmonic_mean'): out[j] = 1.0 / (1.0 / allTopo[out_indices]).mean() else: raise Exception, 'Unknown value of averaging' return(out)