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'))
