def polygons(gdf, label='', geometry='geometry', col=None, agg=ds.any):
"""Return a holoviews plot.
Multiple holoviews plots can be collected in a list and plotted with
hv.Layout(list_of_plots).cols(3).
Parameters
----------
gdf : geopandas.GeoDataFrame
label : str
geometry : geometry column
col : str
Column on which the datashader data aggregation will be done.
The default is `None`.
agg : datashader aggregation function
The default is `ds.any`.
Returns
-------
shd : holoviews plot
"""
hv.output(backend="matplotlib")
sgdf = spd.GeoDataFrame(gdf)
cvs = ds.Canvas()
if col is not None:
agg = cvs.polygons(sgdf, geometry, agg=agg(col))
else:
agg = cvs.polygons(sgdf, geometry, agg=agg())
shd = hd.shade(hv.Image(agg, label=label))
return shd
def test_dask_registration():
ddf = dd.from_pandas(sp.GeoDataFrame({
'geom':
pd.array([[0, 0], [0, 1, 1, 1], [0, 2, 1, 2, 2, 2]],
dtype='MultiPoint[float64]'),
'v': [1, 2, 3]
}),
npartitions=3)
assert isinstance(ddf, sp.dask.DaskGeoDataFrame)
def test_import_geopandas_preserves_geometry_column():
gp_points = gp.array.from_shapely([sg.Point([0, 0]), sg.Point(1, 1)])
gp_lines = gp.array.from_shapely(
[sg.LineString([(0, 0), (1, 1)]),
sg.LineString([(1, 1), (2, 2)])])
gpdf = gp.GeoDataFrame({
'a': [1, 2],
'point': gp_points,
'b': [3, 4],
'line': gp_lines
})
# Import with no geometry column set
spdf = sp.GeoDataFrame(gpdf)
assert spdf.geometry.name == 'point'
# Import with geometry column set
for geom_name in ['point', 'line']:
gpdf = gpdf.set_geometry(geom_name)
spdf = sp.GeoDataFrame(gpdf)
assert spdf.geometry.name == geom_name
def nybb_source():
data = gpd.datasets.get_path('nybb')
gdf = gpd.read_file(data)
gdf = reproject_vector(gdf)
spgdf = spatialpandas.GeoDataFrame(gdf, geometry='geometry')
return MapSource(name='NYC Admin',
df=spgdf,
xfield='geometry',
yfield='geometry',
zfield='BoroCode',
agg_func='max',
span='min/max',
dynspread=None,
shade_how='linear',
geometry_type='polygon',
key='nybb',
text='NYC Admin')
def world_cities_source():
data = gpd.datasets.get_path('naturalearth_cities')
gdf = gpd.read_file(data)
gdf = reproject_vector(gdf)
gdf['X'] = gdf.geometry.apply(lambda p: p.x)
gdf['Y'] = gdf.geometry.apply(lambda p: p.y)
spgdf = spatialpandas.GeoDataFrame(gdf, geometry='geometry')
return MapSource(name='World Cities',
geometry_type='point',
cmap=['black', 'black'],
df=spgdf,
xfield='X',
yfield='Y',
dynspread=2,
shade_how='linear',
key='world-cities',
text='World Cities')
def test_points_geometry():
axis = ds.core.LinearAxis()
lincoords = axis.compute_index(axis.compute_scale_and_translate((0., 2.), 3), 3)
ddf = dd.from_pandas(sp.GeoDataFrame({
'geom': pd.array(
[[0, 0], [0, 1, 1, 1], [0, 2, 1, 2, 2, 2]], dtype='MultiPoint[float64]'),
'v': [1, 2, 3]
}), npartitions=3)
cvs = ds.Canvas(plot_width=3, plot_height=3)
agg = cvs.points(ddf, geometry='geom', agg=ds.sum('v'))
sol = np.array([[1, nan, nan],
[2, 2, nan],
[3, 3, 3]], dtype='float64')
out = xr.DataArray(sol, coords=[lincoords, lincoords],
dims=['y', 'x'])
assert_eq_xr(agg, out)
def world_countries_source():
data = gpd.datasets.get_path('naturalearth_lowres')
world = gpd.read_file(data)
world = world[(world.name != "Antarctica")
& (world.name != "Fr. S. Antarctic Lands")]
world = reproject_vector(world)
spgdf = spatialpandas.GeoDataFrame(world, geometry='geometry')
return MapSource(name='World Countries',
geometry_type='polygon',
df=spgdf,
span='min/max',
xfield='geometry',
yfield='geometry',
zfield='pop_est',
agg_func='sum',
dynspread=None,
shade_how='linear',
key='world-countries',
text='World Countries')
def test_drop_geometry_column():
gp_points = gp.array.from_shapely([sg.Point([0, 0]), sg.Point(1, 1)])
gp_lines = gp.array.from_shapely(
[sg.LineString([(0, 0), (1, 1)]),
sg.LineString([(1, 1), (2, 2)])])
gpdf = gp.GeoDataFrame(
{
'a': [1, 2],
'point': gp_points,
'b': [3, 4],
'line1': gp_lines,
'line2': gp_lines
},
geometry='line2')
# Import with no geometry column set
spdf = sp.GeoDataFrame(gpdf)
assert spdf.geometry.name == 'line2'
# Active geometry column preserved when dropping a different non-geometry column
df = spdf.drop('b', axis=1)
assert df.geometry.name == 'line2'
# Active geometry column preserved when dropping a different geometry column
df = spdf.drop('line1', axis=1)
assert df.geometry.name == 'line2'
# Dropping active geometry column results in GeoDataFrame with no active geometry
df = spdf.drop(['point', 'line2'], axis=1)
assert df._has_valid_geometry() is False
# Dropping all geometry columns results in pandas DataFrame
pdf = spdf.drop(['point', 'line1', 'line2'], axis=1)
assert type(pdf) is pd.DataFrame
def split_device_trajectories(
file: str,
output: str,
study: gpd.GeoDataFrame,
split_opts: Dict[str, Any],
min_length: float,
min_duration: float,
) -> None:
"""Split device trajectories."""
out = f"{output}/device_{file.split('.')[-2]}.parquet"
if exists(out):
return None
df = read_parquet(file)[[
"device_id", "latitude", "longitude", "timestamp"
]]
if len(df) < 2:
return None
tc = split_trajectories(df, **split_opts)
gdf = extract_traj_info(tc)
gdf = gdf[(gdf["length"] >= min_length)
& (gdf["duration"] >= min_duration)]
gdf = gpd.sjoin(gdf, study).drop(columns=["index_right"])
sdf = spd.GeoDataFrame(gdf)
to_parquet(sdf, out)
def test_import_geopandas_with_none():
# Construct geopandas dataframe with column for each geometry type that includes
# Nones
gp_points = gp.array.from_shapely([sg.Point([0, 0]), sg.Point(1, 1), None])
gp_lines = gp.array.from_shapely([
sg.LineString([(0, 0), (1, 1)]), None,
sg.LineString([(1, 1), (2, 2)])
])
gp_rings = gp.array.from_shapely([
sg.LineString([(0, 0), (1, 1), (0, 0)]),
None,
sg.LineString([(1, 1), (2, 2), (1, 1)]),
])
gp_multilines = gp.array.from_shapely([
None,
sg.MultiLineString([[(0, 0), (1, 1)]]),
sg.MultiLineString([[(1, 1), (2, 2)]])
])
gp_polygons = gp.array.from_shapely([
None,
sg.Polygon([(0, 0), (1, 1), (0, 1)]),
sg.Polygon([(1, 1), (2, 2), (1, 0)])
])
gp_multipolygons = gp.array.from_shapely([
sg.MultiPolygon([sg.Polygon([(0, 0), (1, 1), (0, 1)])]),
sg.MultiPolygon([sg.Polygon([(1, 1), (2, 2), (1, 0)])]), None
])
gpdf = gp.GeoDataFrame({
'a': [1, 2, 3],
'point': gp_points,
'b': [3, 4, 5],
'line': gp_lines,
'ring': gp_rings,
'multiline': gp_multilines,
'polygon': gp_polygons,
'multipolygon': gp_multipolygons,
})
# Construct spatialpandas GeoDataFrame
spdf = sp.GeoDataFrame(gpdf)
# Check that expected entries are NA
pd.testing.assert_frame_equal(
spdf.isna(),
pd.DataFrame(
{
'a': [0, 0, 0],
'point': [0, 0, 1],
'b': [0, 0, 0],
'line': [0, 1, 0],
'ring': [0, 1, 0],
'multiline': [1, 0, 0],
'polygon': [1, 0, 0],
'multipolygon': [0, 0, 1]
},
dtype='bool'))
def dask_DataFrame(*args, **kwargs):
if kwargs.pop("geo", False):
df = sp.GeoDataFrame(*args, **kwargs)
else:
df = pd.DataFrame(*args, **kwargs)
return dd.from_pandas(df, npartitions=2)
def to_spatialpandas(gdf: gpd.GeoDataFrame, geometry_field='geometry'):
return spatialpandas.GeoDataFrame(gdf, geometry=geometry_field)
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"])
def pd_DataFrame(*args, **kwargs):
if kwargs.pop("geo", False):
return sp.GeoDataFrame(*args, **kwargs)
else:
return pd.DataFrame(*args, **kwargs)
