def plotthis(datetime, regions='Whole_East_Coast'): dat = datetime # datetostr=result.strftime("%Y%b%d%H") dt = parse(str(dat)) yr = dt.year mn = dt.month d = dt.day hr = dt.hour mi = dt.minute if hr < 10: hr = '0' + str(hr) else: d = str(d) hr = str(hr) if int(d) < 10: d = '0' + str(d) else: d = str(d) varname = 'Steepn_' + str(yr) + '0' + str(mn) + str( d) + '_' + hr + '0000' x = Xp.flatten() y = Yp.flatten() z = datamat[varname] if regions is 'Odisha': z = np.where(((Xp >= 85) & (Xp <= 88) & (Yp >= 19) & (Yp <= 22)), z, np.nan).flatten() elif regions is 'Andra_Pradesh': z = np.where(((Xp >= 79) & (Xp <= 85) & (Yp >= 13) & (Yp <= 19)), z, np.nan).flatten() elif regions is 'Tamil_Nadu': z = np.where(((Xp >= 77) & (Xp <= 83) & (Yp >= 7) & (Yp <= 14)), z, np.nan).flatten() elif regions is 'Whole_East_Coast': z = z.flatten() else: # data = get_data4region(data,**odisha) z = z.flatten() # z = z.flatten() Longitude = x Latitude = y HS = z pts = np.stack((Longitude, Latitude, HS)).T verts = pd.DataFrame(np.stack((Longitude, Latitude, HS)).T, columns=['Longitude', 'Latitude', 'HS']) # openStreet Background. tri_sub = tri_new.apply(lambda x: x - 1) ggpoints = gv.Points(verts, vdims=['HS']) ggsubraster = rasterize(gv.TriMesh((tri_sub, gv.Points(verts)))) tri = gv.TriMesh((tri_sub, gv.Points(verts))) return tri
def grid(self, tiles=False, **kwargs): x = kwargs.get("x", self._obj.SCHISM_hgrid_node_x[:].values) y = kwargs.get("y", self._obj.SCHISM_hgrid_node_y[:].values) tes = kwargs.get("tri3", self._obj.SCHISM_hgrid_face_nodes.values) width = kwargs.get("width", 800) height = kwargs.get("height", 600) opts.defaults(opts.WMTS(width=width, height=height)) tile = gv.WMTS("https://b.tile.openstreetmap.org/{Z}/{X}/{Y}.png") nodes = pd.DataFrame({"longitude": x, "latitude": y}) points = gv.operation.project_points(gv.Points(nodes)) if tes.shape[1] == 3: elems = pd.DataFrame(tes, columns=["a", "b", "c"]) trimesh = gv.TriMesh((elems, points)).edgepaths if tiles: return tile * datashade( trimesh, precompute=True, cmap=["black"]) else: return datashade(trimesh, precompute=True, cmap=["green"]).opts(width=width, height=height) else: # there are quads elems = pd.DataFrame(tes, columns=["a", "b", "c", "d"]) quads = elems.loc[~elems.d.isna()].copy() quads = quads.reset_index(drop=True) ap = nodes.loc[quads.a, ["longitude", "latitude"]] bp = nodes.loc[quads.b, ["longitude", "latitude"]] cp = nodes.loc[quads.c, ["longitude", "latitude"]] dp = nodes.loc[quads.d, ["longitude", "latitude"]] quads["ap"] = ap.values.tolist() quads["bp"] = bp.values.tolist() quads["cp"] = cp.values.tolist() quads["dp"] = dp.values.tolist() q = gv.Polygons([ quads.loc[i, ["ap", "bp", "cp", "dp"]].tolist() for i in range(quads.shape[0]) ]).options(fill_alpha=0, line_color="black") triangles = elems.loc[elems.d.isna()] trimesh = gv.TriMesh((triangles, points)).edgepaths g1 = datashade(trimesh, precompute=True, cmap=["black"]) if tiles: return tile * g1 * q else: return g1 * q
def grid(self, tiles=False, **kwargs): x = kwargs.get('x',self._obj.SCHISM_hgrid_node_x[:].values) y = kwargs.get('y',self._obj.SCHISM_hgrid_node_y[:].values) tes = kwargs.get('tri3',self._obj.SCHISM_hgrid_face_nodes.values) width = kwargs.get('width', 800) height = kwargs.get('height', 600) opts.defaults(opts.WMTS(width=width, height=height)) tile = gv.WMTS('https://b.tile.openstreetmap.org/{Z}/{X}/{Y}.png') nodes = pd.DataFrame({'longitude':x,'latitude':y}) points = gv.operation.project_points(gv.Points(nodes)) if tes.shape[1] == 3 : elems = pd.DataFrame(tes, columns=['a', 'b', 'c']) trimesh=gv.TriMesh((elems, points)).edgepaths if tiles: return tile * datashade(trimesh, precompute=True, cmap=['black']) else: return datashade(trimesh, precompute=True, cmap=['green']).opts(width=width,height=height) else: # there are quads elems = pd.DataFrame(tes, columns=['a', 'b', 'c', 'd']) quads = elems.loc[~elems.d.isna()].copy() quads = quads.reset_index(drop=True) ap = nodes.loc[quads.a,['longitude','latitude']] bp = nodes.loc[quads.b,['longitude','latitude']] cp = nodes.loc[quads.c,['longitude','latitude']] dp = nodes.loc[quads.d,['longitude','latitude']] quads['ap'] = ap.values.tolist() quads['bp'] = bp.values.tolist() quads['cp'] = cp.values.tolist() quads['dp'] = dp.values.tolist() q = gv.Polygons([quads.loc[i,['ap','bp','cp','dp']].tolist() for i in range(quads.shape[0])]).options(fill_alpha=0, line_color='black') triangles = elems.loc[elems.d.isna()] trimesh=gv.TriMesh((triangles, points)).edgepaths g1 = datashade(trimesh, precompute=True, cmap=['black']) if tiles : return tile * g1 * q else: return g1 * q
def view(self): # create the trimesh for displaying unstructured grids trimesh = gv.TriMesh((self.cells, self.vert_points)) return trimesh.edgepaths.opts( line_width=0.5, height=600, width=600, line_color='yellow') * gvts.EsriImagery
def get_trimesh( dataset: xr.Dataset, longitude_var: str, latitude_var: str, elevation_var: str, simplices_var: str, time_var: str, timestamp: str | pd.Timestamp, ) -> gv.TriMesh: simplices = dataset[simplices_var].values columns = [longitude_var, latitude_var, elevation_var] if timestamp == "MAXIMUM": points_df = dataset.max(time_var)[columns].to_dataframe() elif timestamp == "MINIMUM": points_df = dataset.min(time_var)[columns].to_dataframe() else: points_df = dataset.sel( {time_var: timestamp})[columns].to_dataframe().drop(columns=time_var) points_df = points_df.reset_index(drop=True) points_gv = gv.Points(points_df, kdims=[longitude_var, latitude_var], vdims=elevation_var) trimesh = gv.TriMesh((simplices, points_gv)) return trimesh
def plotthis(z, regions='w'): if regions is 'O': z = np.where(((x >= 2) & (x <= 3) & (y >= 51) & (y <= 52)), z, np.nan).flatten() elif regions is 'A': z = np.where(((x >= 3) & (x <= 4) & (y >= 54) & (y <= 57)), z, np.nan).flatten() elif regions is 'T': z = np.where(((x >= 0) & (x <= 3) & (y >= 51) & (y <= 57)), z, np.nan).flatten() # else: # # data = get_data4region(data,**odisha) # z=z.flatten() print("lx:", len(x), "ly:", len(y), "lz:", len(z)) print("z", z) verts = pd.DataFrame(np.stack((x, y, z)).T, columns=['X', 'Y', 'Z']) # #openStreet Background. # tri_sub = cf.apply(lambda x: x - 1) # tri_sub=tri_sub[:10] tri = gv.TriMesh((triangles, gv.Points(verts))) return tri
def contourf(self, var='depth', it=None, **kwargs): x = kwargs.get('x', self._obj.SCHISM_hgrid_node_x[:].values) y = kwargs.get('y', self._obj.SCHISM_hgrid_node_y[:].values) try: t = kwargs.get('t', self._obj.time.values) except: pass tri3 = kwargs.get( 'tri3', self._obj.SCHISM_hgrid_face_nodes.values[:, :3].astype(int)) z = kwargs.get('z', self._obj[var].values[it, :].flatten()) nodes = pd.DataFrame({ 'longitude': x, 'latitude': y, '{}'.format(var): z }) elems = pd.DataFrame(tri3, columns=['a', 'b', 'c']) opts.defaults(opts.WMTS(width=800, height=400)) tiles = gv.WMTS( 'https://maps.wikimedia.org/osm-intl/{Z}/{X}/{Y}@2x.png') points = gv.operation.project_points( gv.Points(nodes, vdims=['{}'.format(var)])) trimesh = gv.TriMesh((elems, points)) return tiles * rasterize(trimesh, aggregator='mean').opts( colorbar=True, cmap='Viridis', padding=.1, tools=['hover'])
def interpolate(self): if self.interpolation_option != 'idw': interp_object = xmsinterp.interpolate.InterpLinear( pts=self.scatter.values) if self.interpolation_option == 'natural_neighbor': interp_object.interp_to_pt( (0, 0)) # this will force triangle creation interp_object.set_use_natural_neighbor( nodal_func_type=self.nodal_function, nd_func_pt_search_opt="nearest_pts") else: interp_object = xmsinterp.interpolate.InterpIdw( pts=self.scatter.values) interp_object.set_nodal_function( nodal_func_type=self.nodal_function) if self.truncation: interp_object.set_truncation_max_min(self.truncation_range[1], self.truncation_range[0]) z = interp_object.interp_to_pts( self.adh_mod.mesh.mesh_points.data[['x', 'y']].values) self.adh_mod.mesh.mesh_points.data['z'] = z self.adh_mod.mesh.tri_mesh = gv.TriMesh( (self.adh_mod.mesh.tris[['v0', 'v1', 'v2']], self.adh_mod.mesh.mesh_points)).apply.opts(*self.opts) self.adh_mod.mesh.elevation_toggle = True
def contourf(self, var="depth", it=None, tiles=False, **kwargs): x = kwargs.get("x", self._obj.SCHISM_hgrid_node_x[:].values) y = kwargs.get("y", self._obj.SCHISM_hgrid_node_y[:].values) try: t = kwargs.get("t", self._obj.time.values) except: pass tes = kwargs.get("tri3", self._obj.SCHISM_hgrid_face_nodes.values[:, :4]) # sort out quads try: mask = np.isnan(tes)[:, 3] tr3 = tes[mask][:, :3] tr3_ = quads_to_tris(tes[~mask]) if tr3_: tri3 = np.append(tr3, tr3_, axis=0).astype(int) else: tri3 = tr3.astype(int) except: tri3 = tes.astype(int) if tri3.min() > 0: tri3 = tri3 - 1 z = kwargs.get("z", self._obj[var].values[it, :].flatten()) nodes = pd.DataFrame({ "longitude": x, "latitude": y, "{}".format(var): z }) elems = pd.DataFrame(tri3, columns=["a", "b", "c"]) width = kwargs.get("width", 800) height = kwargs.get("height", 600) opts.defaults(opts.WMTS(width=width, height=height)) tile = gv.WMTS("https://b.tile.openstreetmap.org/{Z}/{X}/{Y}.png") points = gv.operation.project_points( gv.Points(nodes, vdims=["{}".format(var)])) trimesh = gv.TriMesh((elems, points)) if tiles: return tile * rasterize(trimesh, aggregator="mean").opts( colorbar=True, cmap="Viridis", padding=0.1, tools=["hover"]) else: return rasterize(trimesh, aggregator="mean").opts( colorbar=True, cmap="Viridis", padding=0.1, tools=["hover"], width=width, height=height, )
def frames(self,var='depth', tiles=False, **kwargs): x = kwargs.get('x',self._obj.SCHISM_hgrid_node_x[:].values) y = kwargs.get('y',self._obj.SCHISM_hgrid_node_y[:].values) try: t = kwargs.get('t',self._obj.time.values) except: pass tes = kwargs.get('tri3',self._obj.SCHISM_hgrid_face_nodes.values[:,:4]) # sort out quads try: mask = np.isnan(tes)[:,3] tr3 = tes[mask][:,:3] tr3_ = quads_to_tris(tes[~mask]) if tr3_ : tri3 = np.append(tr3,tr3_,axis=0).astype(int) else: tri3 = tr3.astype(int) except: tri3 = tes.astype(int) times=kwargs.get('times',self._obj.time.values) z = kwargs.get('z',self._obj[var].values[0,:].flatten()) zmin = self._obj[var].values.min() zmax = self._obj[var].values.max() nodes = pd.DataFrame({'longitude':x,'latitude':y, '{}'.format(var):z}) elems = pd.DataFrame(tri3, columns=['a', 'b', 'c']) width = kwargs.get('width', 800) height = kwargs.get('height', 600) opts.defaults(opts.WMTS(width=width, height=height)) tile = gv.WMTS('https://b.tile.openstreetmap.org/{Z}/{X}/{Y}.png') points = gv.operation.project_points(gv.Points(nodes, vdims=['{}'.format(var)])) trimesh = gv.TriMesh((elems, points)) def time_mesh(time): points.data[var] = self._obj[var].sel(time=time).values return gv.TriMesh((elems, points))#, crs=ccrs.GOOGLE_MERCATOR) meshes = hv.DynamicMap(time_mesh, kdims=['Time']).redim.values(Time=times) imesh = rasterize(meshes, aggregator='mean').opts(cmap='viridis', colorbar=True, padding=.1, tools=['hover'], clim=(zmin, zmax)) if tiles: return hv.output(tile*imesh, holomap='scrubber', fps=1) else: return hv.output(imesh.opts(width=width,height=height), holomap='scrubber', fps=1)
def time_mesh_scalar(self): # add this time step's data as a vdim under the provided label data_points = self.adh_mod.mesh.mesh_points.add_dimension( self.selected_result, 0, self.adh_mod.mesh.current_sim.results[self.selected_result].sel( times=self.selected_times).data, vdim=True) # return a trimesh with this data return gv.TriMesh( (self.adh_mod.mesh.tris[['v0', 'v1', 'v2']], data_points), label=self.selected_result, crs=ccrs.GOOGLE_MERCATOR)
def frames(self, var='depth', **kwargs): x = kwargs.get('x', self._obj.SCHISM_hgrid_node_x[:].values) y = kwargs.get('y', self._obj.SCHISM_hgrid_node_y[:].values) try: t = kwargs.get('t', self._obj.time.values) except: pass tri3 = kwargs.get( 'tri3', self._obj.SCHISM_hgrid_face_nodes.values[:, :3].astype(int)) times = kwargs.get('times', self._obj.time.values) z = kwargs.get('z', self._obj[var].values[0, :].flatten()) nodes = pd.DataFrame({ 'longitude': x, 'latitude': y, '{}'.format(var): z }) elems = pd.DataFrame(tri3, columns=['a', 'b', 'c']) opts.defaults(opts.WMTS(width=800, height=400)) tiles = gv.WMTS( 'https://maps.wikimedia.org/osm-intl/{Z}/{X}/{Y}@2x.png') points = gv.operation.project_points( gv.Points(nodes, vdims=['{}'.format(var)])) trimesh = gv.TriMesh((elems, points)) def time_mesh(time): points.data[var] = self._obj[var].sel(time=time).values return gv.TriMesh((elems, points)) #, crs=ccrs.GOOGLE_MERCATOR) meshes = hv.DynamicMap(time_mesh, kdims=['Time']).redim.values(Time=times) imesh = rasterize(meshes, aggregator='mean').opts(cmap='viridis', colorbar=True, padding=.1, tools=['hover']) return hv.output(tiles * imesh, holomap='scrubber', fps=1)
def from_xarray(self, xarr, crs=ccrs.UTM(1)): self.name = xarr.nodes.attrs.get('MESHNAME').strip('\'').strip('"') self.verts = xarr.nodes.to_pandas() # store as one-based self.tris = xarr.E3T.to_pandas() - 1 # store as zero-based (will be paired with mesh_points which uses zero-based indices) # TODO: why don't we just store the mesh as a xarray instead of pandas? file_crs = get_crs(xarr) if crs: if crs.proj4_params != file_crs.proj4_params: log.warning('Specified crs ({}) does not match file ({}). Defaulting to file crs'.format( crs.proj4_params, file_crs.proj4_params)) self.projection.set_crs(file_crs) else: self.projection.set_crs(crs) else: self.projection.set_crs(file_crs) self.reproject_points() self.tri_mesh = gv.TriMesh((self.tris[['v0', 'v1', 'v2']], self.mesh_points))
def grid(self, **kwargs): x = kwargs.get('x', self._obj.SCHISM_hgrid_node_x[:].values) y = kwargs.get('y', self._obj.SCHISM_hgrid_node_y[:].values) tri3 = kwargs.get( 'tri3', self._obj.SCHISM_hgrid_face_nodes.values[:, :3].astype(int)) opts.defaults(opts.WMTS(width=800, height=400)) tiles = gv.WMTS( 'https://maps.wikimedia.org/osm-intl/{Z}/{X}/{Y}@2x.png') nodes = pd.DataFrame({'longitude': x, 'latitude': y}) elems = pd.DataFrame(tri3, columns=['a', 'b', 'c']) points = gv.operation.project_points(gv.Points(nodes)) trimesh = gv.TriMesh((elems, points)).edgepaths return tiles * datashade(trimesh, precompute=True, cmap=['black'])
def contourf(self, var='depth', it=None, tiles=False, **kwargs): x = kwargs.get('x',self._obj.SCHISM_hgrid_node_x[:].values) y = kwargs.get('y',self._obj.SCHISM_hgrid_node_y[:].values) try: t = kwargs.get('t',self._obj.time.values) except: pass tes = kwargs.get('tri3',self._obj.SCHISM_hgrid_face_nodes.values[:,:4]) # sort out quads try: mask = np.isnan(tes)[:,3] tr3 = tes[mask][:,:3] tr3_ = quads_to_tris(tes[~mask]) if tr3_ : tri3 = np.append(tr3,tr3_,axis=0).astype(int) else: tri3 = tr3.astype(int) except: tri3 = tes.astype(int) z = kwargs.get('z',self._obj[var].values[it,:].flatten()) nodes = pd.DataFrame({'longitude':x,'latitude':y, '{}'.format(var):z}) elems = pd.DataFrame(tri3, columns=['a', 'b', 'c']) width = kwargs.get('width', 800) height = kwargs.get('height', 600) opts.defaults(opts.WMTS(width=width, height=height)) tile = gv.WMTS('https://b.tile.openstreetmap.org/{Z}/{X}/{Y}.png') points = gv.operation.project_points(gv.Points(nodes, vdims=['{}'.format(var)])) trimesh = gv.TriMesh((elems, points)) if tiles: return tile * rasterize(trimesh, aggregator='mean').opts(colorbar=True, cmap='Viridis', padding=.1, tools=['hover']) else: return rasterize(trimesh, aggregator='mean').opts(colorbar=True, cmap='Viridis', padding=.1, tools=['hover'],width=width,height=height)
def frames(self, var="depth", tiles=False, **kwargs): x = kwargs.get("x", self._obj.SCHISM_hgrid_node_x[:].values) y = kwargs.get("y", self._obj.SCHISM_hgrid_node_y[:].values) try: t = kwargs.get("t", self._obj.time.values) except: pass tes = kwargs.get("tri3", self._obj.SCHISM_hgrid_face_nodes.values[:, :4]) # sort out quads try: mask = np.isnan(tes)[:, 3] tr3 = tes[mask][:, :3] tr3_ = quads_to_tris(tes[~mask]) if tr3_: tri3 = np.append(tr3, tr3_, axis=0).astype(int) else: tri3 = tr3.astype(int) except: tri3 = tes.astype(int) times = kwargs.get("times", self._obj.time.values) z = kwargs.get("z", self._obj[var].values[0, :].flatten()) zmin = self._obj[var].values.min() zmax = self._obj[var].values.max() nodes = pd.DataFrame({ "longitude": x, "latitude": y, "{}".format(var): z }) elems = pd.DataFrame(tri3, columns=["a", "b", "c"]) width = kwargs.get("width", 800) height = kwargs.get("height", 600) opts.defaults(opts.WMTS(width=width, height=height)) tile = gv.WMTS("https://b.tile.openstreetmap.org/{Z}/{X}/{Y}.png") points = gv.operation.project_points( gv.Points(nodes, vdims=["{}".format(var)])) trimesh = gv.TriMesh((elems, points)) def time_mesh(time): points.data[var] = self._obj[var].sel(time=time).values return gv.TriMesh((elems, points)) # , crs=ccrs.GOOGLE_MERCATOR) meshes = hv.DynamicMap(time_mesh, kdims=["Time"]).redim.values(Time=times) imesh = rasterize(meshes, aggregator="mean").opts(cmap="viridis", colorbar=True, padding=0.1, tools=["hover"], clim=(zmin, zmax)) if tiles: return hv.output(tile * imesh, holomap="scrubber", fps=1) else: return hv.output(imesh.opts(width=width, height=height), holomap="scrubber", fps=1)
def mesh(self, tiles=False, **kwargs): x = kwargs.get("x", self._obj.SCHISM_hgrid_node_x[:].values) y = kwargs.get("y", self._obj.SCHISM_hgrid_node_y[:].values) tes = kwargs.get("tri3", self._obj.SCHISM_hgrid_face_nodes.values) width = kwargs.get("width", 800) height = kwargs.get("height", 600) opts.defaults(opts.WMTS(width=width, height=height)) tile = gv.WMTS("https://b.tile.openstreetmap.org/{Z}/{X}/{Y}.png") nodes = pd.DataFrame({"longitude": x, "latitude": y}) points = gv.operation.project_points(gv.Points(nodes), projection=ccrs.PlateCarree()) if tes.shape[1] == 3: elems = pd.DataFrame(tes, columns=["a", "b", "c"]) if elems.min().min() > 0: elems = elems - 1 trimesh = gv.TriMesh((elems, points)).edgepaths if tiles: return tile * datashade( trimesh, precompute=True, cmap=["black"]) else: return datashade(trimesh, precompute=True, cmap=["green"]).opts(width=width, height=height) else: # there are quads elems = pd.DataFrame(tes, columns=["a", "b", "c", "d"]) if elems.min().min() > 0: elems = elems - 1 quads = elems.loc[~elems.d.isna()].copy() quads = quads.reset_index(drop=True) ap = nodes.loc[quads.a, ["longitude", "latitude"]] bp = nodes.loc[quads.b, ["longitude", "latitude"]] cp = nodes.loc[quads.c, ["longitude", "latitude"]] dp = nodes.loc[quads.d, ["longitude", "latitude"]] quads["ap"] = ap.values.tolist() quads["bp"] = bp.values.tolist() quads["cp"] = cp.values.tolist() quads["dp"] = dp.values.tolist() n = 2 al = quads.ap + quads.bp + quads.cp + quads.dp + quads.ap coords = [[l[i:i + n] for i in range(0, len(l), n)] for l in al] quads["coordinates"] = coords qpolys = pygeos.polygons(quads.coordinates.to_list()) df = gp.GeoDataFrame(geometry=qpolys) df_ = spatialpandas.GeoDataFrame(df) q = gv.Path(df_) qdf = dynspread( rasterize(q, precompute=True).options(cmap=["black"])) triangles = elems.loc[elems.d.isna()] trimesh = gv.TriMesh((triangles, points)).edgepaths wireframe = dynspread( rasterize(trimesh, precompute=True).opts(cmap=["black"])) if tiles: return tile * wireframe * qdf else: return wireframe.opts(cmap=["green"]) * qdf.opts( cmap=["green"])
# In[ ]: points = gv.operation.project_points(gv.Points(verts, vdims=['z'])) # In[ ]: tris = pd.DataFrame(ds['element'].values.astype('int') - 1, columns=['v0', 'v1', 'v2']) # In[ ]: tiles = gv.WMTS('https://maps.wikimedia.org/osm-intl/{Z}/{X}/{Y}@2x.png') value = 'max water level' label = '{} (m)'.format(value) trimesh = gv.TriMesh((tris, points), label=label) # In[ ]: get_ipython().run_cell_magic( 'opts', 'Image [colorbar=True] (cmap=jet)', "\nmeshes = rasterize(trimesh,aggregator=dshade.mean('z'))\ntiles * meshes" ) # ### Extract a time series at a specified lon, lat location # In[ ]: # find the indices of the points in (x,y) closest to the points in (xi,yi) def nearxy(x, y, xi, yi):
dt = parse(str(dat)) yr = dt.year mn = dt.month d = dt.day hr = dt.hour mi = dt.minute # print(y,mn,d,hr,mi) if hr < 10: # d='0'+str(d) hr = '0' + str(hr) else: d = str(d) hr = str(hr) if int(d) < 10: d = '0' + str(d) else: d = str(d) varname = 'Hsig_' + str(yr) + '0' + str(mn) + str(d) + '_' + hr + '0000' print(varname) x = xp.flatten() y = yp.flatten() z = datamat[varname] z1 = z.flatten() print(z1) tri_sub = tri_new.apply(lambda x: x - 1) print(tri_sub.shape) trimesh = gv.TriMesh((tri_sub, (x, y))) trimesh.opts(padding=0.1, width=200, height=200)
def time_mesh(time): points.data[var] = self._obj[var].sel(time=time).values return gv.TriMesh((elems, points)) # , crs=ccrs.GOOGLE_MERCATOR)
def _create(self): # print('create clicked') # todo modify to always reproject to mercator before creating the mesh self.status_bar.busy() refine_points = [] if self.adh_mod.point_stream.data and 'node_spacing' in self.adh_mod.point_stream.element.columns( ): # for item in zip(element['Longitude'], element['Latitude'], element['node_spacing']): for idx in range(len(self.adh_mod.point_stream.data['Longitude'])): refine_points.append( xmsmesh.meshing.RefinePoint( create_mesh_point=True, point=( self.adh_mod.point_stream.element['Longitude'] [idx], self.adh_mod.point_stream.element['Latitude'][idx], 0), size=float(self.adh_mod.point_stream. element['node_spacing']))) # ============== input_polygon = [] if self.adh_mod.poly_stream.data: for idx in range(len(self.adh_mod.poly_stream.data['xs'])): poly_arr = np.fromiter(zip( self.adh_mod.poly_stream.data['xs'][idx], self.adh_mod.poly_stream.data['ys'][idx], [0] * len(self.adh_mod.poly_stream.data['ys'][idx])), dtype=('float,float,float')) # if no spacing value is given, use only the existing polygon vertices # if self.adh_mod.poly_stream.data['node_spacing'][idx] == self.adh_mod.default_value: # if self.adh_mod.poly_stream.data['node_spacing'][idx] == '': # input_polygon.append(xmsmesh.meshing.PolyInput(outside_polygon=poly_arr)) # redistribute vertices based on spacing from user # else: # instantiate the redistribution class rdp = xmsmesh.meshing.PolyRedistributePts() # set the node distance node_spacing = float( self.adh_mod.poly_stream.element.dimension_values( 'node_spacing', expanded=False)[idx]) # print(node_spacing, type(node_spacing)) # rdp.set_constant_size_func(float(self.adh_mod.poly_stream.data['node_spacing'][idx])) # create_constant_size_function rdp.set_constant_size_func(node_spacing) # run the redistribution function outdata = rdp.redistribute(poly_arr) # AML CHANGE redistribute with the closed loop and then remove the duplicates # and reverse the order because the mesher expects clockwise polygons # ensure start and end node are different # if len(poly_arr) != 0: # todo - waiting on fix for moving poly edges that leave a single node poly behind # outdata = check_polygon(outdata)[::-1] # todo pretty sure this is fixed so I'm commenting it out # convert the polygon to an 'input polygon' input_polygon.append( xmsmesh.meshing.PolyInput(outside_polygon=outdata)) # add the input polygons as polygons to the mesher class self.mesh_io = xmsmesh.meshing.MultiPolyMesherIo( poly_inputs=input_polygon, refine_points=refine_points) # Generate Mesh succeded, errors = xmsmesh.meshing.mesh_utils.generate_mesh( mesh_io=self.mesh_io) if succeded: self.status_bar.set_msg('Meshing was successful') else: self.status_bar.set_msg('Meshing errors found: {}'.format(errors)) # poly_stream and point_stream are always mercator because they come from bokeh proj = Projection(crs_label='Mercator') self.adh_mod.mesh = AdhMesh(projection=proj) self.adh_mod.mesh.verts, self.adh_mod.mesh.tris = xmsmesh_to_dataframe( self.mesh_io.points, self.mesh_io.cells) self.adh_mod.mesh.reproject_points() self.adh_mod.mesh.tri_mesh = gv.TriMesh( (self.adh_mod.mesh.tris[['v0', 'v1', 'v2']], self.adh_mod.mesh.mesh_points)).opts( opts.TriMesh(edge_cmap='yellow', edge_color='yellow'))