def compute_geometry(self, bbox, filename=None): """ Parse OSM file (area in bbox) to retrieve information about geometry. :param Sequence[float] bbox: area to be parsed in format (min_lon, min_lat, max_lon, max_lat) :param Optional[str] filename: map file in .osm.pbf format or None (map will be downloaded) """ assert len(bbox) == 4 self.bbox_size = (fabs(bbox[2] - bbox[0]), fabs(bbox[3] - bbox[1])) if filename is None: converter = OsmConverter(bbox) filename = converter.filename osm = OSM(filename, bounding_box=bbox) multipolygons = GeoDataFrame(columns=['tag', 'geometry']) natural = osm.get_natural() if natural is not None: natural = natural.loc[:, ['natural', 'geometry']].rename( columns={'natural': 'tag'}) self.polygons = self.polygons.append( natural.loc[natural.geometry.type == 'Polygon']) multipolygons = multipolygons.append( natural.loc[natural.geometry.type == 'MultiPolygon']) natural.drop(natural.index, inplace=True) landuse = osm.get_landuse() if landuse is not None: landuse = landuse.loc[:, ['landuse', 'geometry']].rename( columns={'landuse': 'tag'}) self.polygons = self.polygons.append( landuse.loc[landuse.geometry.type == 'Polygon']) multipolygons = multipolygons.append( landuse.loc[landuse.geometry.type == 'MultiPolygon']) landuse.drop(landuse.index, inplace=True) # splitting multipolygons to polygons for i in range(multipolygons.shape[0]): tag = multipolygons.tag.iloc[i] for polygon in multipolygons.geometry.iloc[i].geoms: self.polygons = self.polygons.append( { 'tag': tag, 'geometry': polygon }, ignore_index=True) roads = osm.get_network() if roads is not None: roads = self.__dissolve(roads[["highway", "geometry"]]) self.multilinestrings = GeoDataFrame( roads.loc[roads.geometry.type == 'MultiLineString']).rename( columns={'highway': 'tag'}) self.tag_value.eval(self.polygons, self.multilinestrings, "tag")
def get_locations_at(self, t): """ Returns GeoDataFrame with trajectory locations at the specified timestamp Parameters ---------- t : datetime.datetime columns : list[string] List of column names that should be copied from the trajectory's dataframe to the output Returns ------- GeoDataFrame Trajectory locations at timestamp t """ gdf = GeoDataFrame() for traj in self: if t == 'start': x = traj.get_row_at(traj.get_start_time()) elif t == 'end': x = traj.get_row_at(traj.get_end_time()) else: if t < traj.get_start_time() or t > traj.get_end_time(): continue x = traj.get_row_at(t) gdf = gdf.append(x) return gdf
def _combine_dfs_osm(types, save_path, bbox): """Combine all dataframes from individual features into one GeoDataFrame Parameters: .. Returns: (gdf) """ print('Combining all low-value GeoDataFrames into one GeoDataFrame...') OSM_features_gdf_combined = \ GeoDataFrame(pd.DataFrame(columns=['Item', 'Name', 'Type', 'Natural_Type', 'geometry']), crs='epsg:4326', geometry='geometry') for item in types: print('adding results from %s ...' % item) OSM_features_gdf_combined = \ OSM_features_gdf_combined.append( globals()[str(item) + '_gdf_all_' + str(int(bbox[0])) + '_' + str(int(bbox[1]))], ignore_index=True) i = 0 for geom in OSM_features_gdf_combined.geometry: if geom.type == 'LineString': OSM_features_gdf_combined.geometry[i] = geom.buffer(0.000045) i += 1 OSM_features_gdf_combined.to_file( save_path.joinpath('OSM_features_' + str(int(bbox[0])) + '_' + str(int(bbox[1])) + '.shp')) return OSM_features_gdf_combined
def get_locations_at(self, t): """ Returns GeoDataFrame with trajectory locations at the specified timestamp Parameters ---------- t : datetime.datetime Returns ------- GeoDataFrame Trajectory locations at timestamp t """ gdf = GeoDataFrame() for traj in self: if t == 'start': x = traj.get_row_at(traj.get_start_time()) elif t == 'end': x = traj.get_row_at(traj.get_end_time()) else: if t < traj.get_start_time() or t > traj.get_end_time(): continue x = traj.get_row_at(t) gdf = gdf.append(x) return gdf
def get_path(self, path): edge_path = GeoDataFrame(columns=self.attributes(), crs=self.crs) for i in range(len(path) - 1): try: edge_path = edge_path.append( self._gpd_df.loc[self._from_to.index( (path[i], path[i + 1]))], ignore_index=True) except ValueError: edge_path = edge_path.append( self._gpd_df.loc[self._from_to.index( (path[i + 1], path[i]))], ignore_index=True) return edge_path
def upload_pano_base(gdf_base: gpd.GeoDataFrame): gdf_base.loc[:, "ID"] = gdf_base.index db_pano_base = load_postgis('pano_base') ori_size, new_szie = db_pano_base.shape[0], gdf_base.shape[0] tmp = gdf_base.append(db_pano_base).drop_duplicates("ID", keep='first') if ori_size == tmp.shape[0]: return True return gdf_to_postgis(tmp, 'pano_base')
def upload_pano_node(self, gdf: gpd.GeoDataFrame = None): # 经过测试,上传的 list 数据会自动序列化 gdf = gdf if gdf is not None else self.gdf_pano_node gdf.loc[:, "ID"] = gdf.index db_pano_base = load_postgis(self.pano_node_pg) ori_size, new_size = db_pano_base.shape[0], gdf.shape[0] tmp = gdf.append(db_pano_base).drop_duplicates("ID", keep='first') if ori_size == tmp.shape[0]: return True return gdf_to_postgis(tmp, self.pano_node_pg)
class TestPolygonPlotting: def setup_method(self): t1 = Polygon([(0, 0), (1, 0), (1, 1)]) t2 = Polygon([(1, 0), (2, 0), (2, 1)]) self.polys = GeoSeries([t1, t2], index=list('AB')) self.df = GeoDataFrame({'geometry': self.polys, 'values': [0, 1]}) multipoly1 = MultiPolygon([t1, t2]) multipoly2 = rotate(multipoly1, 180) self.df2 = GeoDataFrame({ 'geometry': [multipoly1, multipoly2], 'values': [0, 1] }) t3 = Polygon([(2, 0), (3, 0), (3, 1)]) df_nan = GeoDataFrame({'geometry': t3, 'values': [np.nan]}) self.df3 = self.df.append(df_nan) def test_single_color(self): ax = self.polys.plot(color='green') _check_colors(2, ax.collections[0].get_facecolors(), ['green'] * 2) # color only sets facecolor _check_colors(2, ax.collections[0].get_edgecolors(), ['k'] * 2) ax = self.df.plot(color='green') _check_colors(2, ax.collections[0].get_facecolors(), ['green'] * 2) _check_colors(2, ax.collections[0].get_edgecolors(), ['k'] * 2) with warnings.catch_warnings(record=True) as _: # don't print warning # 'color' overrides 'values' ax = self.df.plot(column='values', color='green') _check_colors(2, ax.collections[0].get_facecolors(), ['green'] * 2) def test_vmin_vmax(self): # when vmin == vmax, all polygons should be the same color # non-categorical ax = self.df.plot(column='values', categorical=False, vmin=0, vmax=0) actual_colors = ax.collections[0].get_facecolors() np.testing.assert_array_equal(actual_colors[0], actual_colors[1]) # categorical ax = self.df.plot(column='values', categorical=True, vmin=0, vmax=0) actual_colors = ax.collections[0].get_facecolors() np.testing.assert_array_equal(actual_colors[0], actual_colors[1]) # vmin vmax set correctly for array with NaN (GitHub issue 877) ax = self.df3.plot(column='values') actual_colors = ax.collections[0].get_facecolors() assert np.any(np.not_equal(actual_colors[0], actual_colors[1])) def test_style_kwargs(self): # facecolor overrides default cmap when color is not set ax = self.polys.plot(facecolor='k') _check_colors(2, ax.collections[0].get_facecolors(), ['k'] * 2) # facecolor overrides more general-purpose color when both are set ax = self.polys.plot(color='red', facecolor='k') # TODO with new implementation, color overrides facecolor # _check_colors(2, ax.collections[0], ['k']*2, alpha=0.5) # edgecolor ax = self.polys.plot(edgecolor='red') np.testing.assert_array_equal([(1, 0, 0, 1)], ax.collections[0].get_edgecolors()) ax = self.df.plot('values', edgecolor='red') np.testing.assert_array_equal([(1, 0, 0, 1)], ax.collections[0].get_edgecolors()) # alpha sets both edge and face ax = self.polys.plot(facecolor='g', edgecolor='r', alpha=0.4) _check_colors(2, ax.collections[0].get_facecolors(), ['g'] * 2, alpha=0.4) _check_colors(2, ax.collections[0].get_edgecolors(), ['r'] * 2, alpha=0.4) def test_legend_kwargs(self): ax = self.df.plot(column='values', categorical=True, legend=True, legend_kwds={'frameon': False}) assert ax.get_legend().get_frame_on() is False def test_multipolygons(self): # MultiPolygons ax = self.df2.plot() assert len(ax.collections[0].get_paths()) == 4 _check_colors(4, ax.collections[0].get_facecolors(), [MPL_DFT_COLOR] * 4) ax = self.df2.plot('values') cmap = plt.get_cmap(lut=2) # colors are repeated for all components within a MultiPolygon expected_colors = [cmap(0), cmap(0), cmap(1), cmap(1)] _check_colors(4, ax.collections[0].get_facecolors(), expected_colors)
# -*- coding: utf-8 -*- from indalsig.labs.callejero.lab03 import show_ways_with_postcodes from geopandas import GeoDataFrame from shapely.geometry import MultiPolygon, Polygon # Creamos el GeoDataFrame y definimos la columna geométrica y el código postal postcodes_gdf = GeoDataFrame(columns=['geometry', 'postcode']) # Del tutorial anterior recuperamos todos los multipolígonos del cálculo for postcode_data in show_ways_with_postcodes.gf_postcode_poly.values: postcode = dict() postcode['postcode'] = postcode_data[1] # Transformamos los polígonos en multipolígonos e ignoramos lo que no sea convertible a multipolígono if isinstance(postcode_data[0], Polygon): postcode['geometry'] = MultiPolygon([postcode_data[0]]) elif isinstance(postcode_data[0], MultiPolygon): postcode['geometry'] = MultiPolygon(postcode_data[0]) else: print postcode_data[0] continue # Añadimos nuestra fila al GeoDataFrame postcodes_gdf = postcodes_gdf.append(postcode, ignore_index=True) # Usando el driver fiona grabamos el Geopanda en formato GeoJSON postcodes_gdf.to_file('postcodes.json', 'GeoJSON')
class TestPolygonPlotting: def setup_method(self): t1 = Polygon([(0, 0), (1, 0), (1, 1)]) t2 = Polygon([(1, 0), (2, 0), (2, 1)]) self.polys = GeoSeries([t1, t2], index=list("AB")) self.df = GeoDataFrame({"geometry": self.polys, "values": [0, 1]}) multipoly1 = MultiPolygon([t1, t2]) multipoly2 = rotate(multipoly1, 180) self.df2 = GeoDataFrame({ "geometry": [multipoly1, multipoly2], "values": [0, 1] }) t3 = Polygon([(2, 0), (3, 0), (3, 1)]) df_nan = GeoDataFrame({"geometry": t3, "values": [np.nan]}) self.df3 = self.df.append(df_nan) def test_single_color(self): ax = self.polys.plot(color="green") _check_colors(2, ax.collections[0].get_facecolors(), ["green"] * 2) # color only sets facecolor _check_colors(2, ax.collections[0].get_edgecolors(), ["k"] * 2) ax = self.df.plot(color="green") _check_colors(2, ax.collections[0].get_facecolors(), ["green"] * 2) _check_colors(2, ax.collections[0].get_edgecolors(), ["k"] * 2) # check rgba tuple GH1178 ax = self.df.plot(color=(0.5, 0.5, 0.5)) _check_colors(2, ax.collections[0].get_facecolors(), [(0.5, 0.5, 0.5)] * 2) ax = self.df.plot(color=(0.5, 0.5, 0.5, 0.5)) _check_colors(2, ax.collections[0].get_facecolors(), [(0.5, 0.5, 0.5, 0.5)] * 2) with pytest.raises(TypeError): self.df.plot(color="not color") with warnings.catch_warnings(record=True) as _: # don't print warning # 'color' overrides 'values' ax = self.df.plot(column="values", color="green") _check_colors(2, ax.collections[0].get_facecolors(), ["green"] * 2) def test_vmin_vmax(self): # when vmin == vmax, all polygons should be the same color # non-categorical ax = self.df.plot(column="values", categorical=False, vmin=0, vmax=0) actual_colors = ax.collections[0].get_facecolors() np.testing.assert_array_equal(actual_colors[0], actual_colors[1]) # categorical ax = self.df.plot(column="values", categorical=True, vmin=0, vmax=0) actual_colors = ax.collections[0].get_facecolors() np.testing.assert_array_equal(actual_colors[0], actual_colors[1]) # vmin vmax set correctly for array with NaN (GitHub issue 877) ax = self.df3.plot(column="values") actual_colors = ax.collections[0].get_facecolors() assert np.any(np.not_equal(actual_colors[0], actual_colors[1])) def test_style_kwargs(self): # facecolor overrides default cmap when color is not set ax = self.polys.plot(facecolor="k") _check_colors(2, ax.collections[0].get_facecolors(), ["k"] * 2) # facecolor overrides more general-purpose color when both are set ax = self.polys.plot(color="red", facecolor="k") # TODO with new implementation, color overrides facecolor # _check_colors(2, ax.collections[0], ['k']*2, alpha=0.5) # edgecolor ax = self.polys.plot(edgecolor="red") np.testing.assert_array_equal([(1, 0, 0, 1)], ax.collections[0].get_edgecolors()) ax = self.df.plot("values", edgecolor="red") np.testing.assert_array_equal([(1, 0, 0, 1)], ax.collections[0].get_edgecolors()) # alpha sets both edge and face ax = self.polys.plot(facecolor="g", edgecolor="r", alpha=0.4) _check_colors(2, ax.collections[0].get_facecolors(), ["g"] * 2, alpha=0.4) _check_colors(2, ax.collections[0].get_edgecolors(), ["r"] * 2, alpha=0.4) # check rgba tuple GH1178 for face and edge ax = self.df.plot(facecolor=(0.5, 0.5, 0.5), edgecolor=(0.4, 0.5, 0.6)) _check_colors(2, ax.collections[0].get_facecolors(), [(0.5, 0.5, 0.5)] * 2) _check_colors(2, ax.collections[0].get_edgecolors(), [(0.4, 0.5, 0.6)] * 2) ax = self.df.plot(facecolor=(0.5, 0.5, 0.5, 0.5), edgecolor=(0.4, 0.5, 0.6, 0.5)) _check_colors(2, ax.collections[0].get_facecolors(), [(0.5, 0.5, 0.5, 0.5)] * 2) _check_colors(2, ax.collections[0].get_edgecolors(), [(0.4, 0.5, 0.6, 0.5)] * 2) def test_legend_kwargs(self): ax = self.df.plot( column="values", categorical=True, legend=True, legend_kwds={"frameon": False}, ) assert ax.get_legend().get_frame_on() is False def test_colorbar_kwargs(self): # Test if kwargs are passed to colorbar label_txt = "colorbar test" ax = self.df.plot( column="values", categorical=False, legend=True, legend_kwds={"label": label_txt}, ) assert ax.get_figure().axes[1].get_ylabel() == label_txt ax = self.df.plot( column="values", categorical=False, legend=True, legend_kwds={ "label": label_txt, "orientation": "horizontal" }, ) assert ax.get_figure().axes[1].get_xlabel() == label_txt def test_multipolygons(self): # MultiPolygons ax = self.df2.plot() assert len(ax.collections[0].get_paths()) == 4 _check_colors(4, ax.collections[0].get_facecolors(), [MPL_DFT_COLOR] * 4) ax = self.df2.plot("values") cmap = plt.get_cmap(lut=2) # colors are repeated for all components within a MultiPolygon expected_colors = [cmap(0), cmap(0), cmap(1), cmap(1)] _check_colors(4, ax.collections[0].get_facecolors(), expected_colors) ax = self.df2.plot(color=["r", "b"]) # colors are repeated for all components within a MultiPolygon _check_colors(4, ax.collections[0].get_facecolors(), ["r", "r", "b", "b"]) def test_subplots_norm(self): # colors of subplots are the same as for plot (norm is applied) cmap = matplotlib.cm.viridis_r norm = matplotlib.colors.Normalize(vmin=0, vmax=10) ax = self.df.plot(column="values", cmap=cmap, norm=norm) actual_colors_orig = ax.collections[0].get_facecolors() exp_colors = cmap(np.arange(2) / (10)) np.testing.assert_array_equal(exp_colors, actual_colors_orig) fig, ax = plt.subplots() self.df[1:].plot(column="values", ax=ax, norm=norm, cmap=cmap) actual_colors_sub = ax.collections[0].get_facecolors() np.testing.assert_array_equal(actual_colors_orig[1], actual_colors_sub[0])
class OsmParser(object): def __init__(self): self.polygons = GeoDataFrame(columns=['tag', 'geometry']) self.multilinestrings = GeoDataFrame(columns=['tag', 'geometry']) self.tag_value = TagValue() self.bbox_size = None @staticmethod def __get_first_point(line): coords = mapping(line)['coordinates'] return coords[0][0] if isinstance(coords[0][0], tuple) else coords[0] @staticmethod def __get_last_point(line): coords = mapping(line)['coordinates'] return coords[-1][1] if isinstance(coords[0][0], tuple) else coords[1] def __dissolve(self, src_roads): roads = src_roads.copy() current = 1 points = dict() for index, row in roads.iterrows(): start = self.__get_first_point(row.geometry) end = self.__get_last_point(row.geometry) for number, borders in points.items(): if start in borders: roads.at[index, "id"] = number borders.add(end) break if end in borders: roads.at[index, "id"] = number borders.add(start) break else: roads.at[index, "id"] = current points[current] = set() points[current].add(start) points[current].add(end) current += 1 return roads.dissolve(by="id").reset_index().drop(columns=["id"]) def compute_geometry(self, bbox, filename=None): """ Parse OSM file (area in bbox) to retrieve information about geometry. :param Sequence[float] bbox: area to be parsed in format (min_lon, min_lat, max_lon, max_lat) :param Optional[str] filename: map file in .osm.pbf format or None (map will be downloaded) """ assert len(bbox) == 4 self.bbox_size = (fabs(bbox[2] - bbox[0]), fabs(bbox[3] - bbox[1])) if filename is None: converter = OsmConverter(bbox) filename = converter.filename osm = OSM(filename, bounding_box=bbox) multipolygons = GeoDataFrame(columns=['tag', 'geometry']) natural = osm.get_natural() if natural is not None: natural = natural.loc[:, ['natural', 'geometry']].rename( columns={'natural': 'tag'}) self.polygons = self.polygons.append( natural.loc[natural.geometry.type == 'Polygon']) multipolygons = multipolygons.append( natural.loc[natural.geometry.type == 'MultiPolygon']) natural.drop(natural.index, inplace=True) landuse = osm.get_landuse() if landuse is not None: landuse = landuse.loc[:, ['landuse', 'geometry']].rename( columns={'landuse': 'tag'}) self.polygons = self.polygons.append( landuse.loc[landuse.geometry.type == 'Polygon']) multipolygons = multipolygons.append( landuse.loc[landuse.geometry.type == 'MultiPolygon']) landuse.drop(landuse.index, inplace=True) # splitting multipolygons to polygons for i in range(multipolygons.shape[0]): tag = multipolygons.tag.iloc[i] for polygon in multipolygons.geometry.iloc[i].geoms: self.polygons = self.polygons.append( { 'tag': tag, 'geometry': polygon }, ignore_index=True) roads = osm.get_network() if roads is not None: roads = self.__dissolve(roads[["highway", "geometry"]]) self.multilinestrings = GeoDataFrame( roads.loc[roads.geometry.type == 'MultiLineString']).rename( columns={'highway': 'tag'}) self.tag_value.eval(self.polygons, self.multilinestrings, "tag")
def append_raw_overhanging_PV_installations_to_intersected_installations( self, raw_overhanging_PV_installations: gpd.GeoDataFrame = None, raw_PV_installations_on_rooftop: gpd.GeoDataFrame = None, ) -> gpd.GeoDataFrame: """ PV polygons which do not intersect with a rooftop polygon, although they do border to a rooftop, are matched to their nearest rooftop geometry and appended to the GeoDataFrame listing all rooftop PV polygons Parameters ---------- raw_overhanging_PV_installations: GeoPandas.GeoDataFrame GeoDataFrame which specifies all the PV polygons which border to a rooftop, but are not intersected with a rooftop geometry raw_PV_installations_on_rooftop: GeoPandas.GeoDataFrame GeoDataFrame which specifies all the PV polygons which are intersected with a rooftop geometry Returns ------- GeoPandas.GeoDataFrame GeoDataFrame where overhanging PV installations have been enriched with the attributes of the closest rooftop and appended to raw_PV_installations_on_rooftop """ # IMPORTANT: if ckdnearest is used always reset_index before raw_overhanging_PV_installations = raw_overhanging_PV_installations.reset_index( drop=True) raw_overhanging_PV_installations.rename( columns={"identifier": "identifier_diff"}, inplace=True) # Extract centroid from intersected PV polygons while preserving their polygon geometry raw_PV_installations_on_rooftop[ "geometry_intersected_polygon"] = raw_PV_installations_on_rooftop[ "geometry"] raw_PV_installations_on_rooftop[ "geometry"] = raw_PV_installations_on_rooftop["geometry"].centroid raw_PV_installations_on_rooftop[ "centroid_intersect"] = raw_PV_installations_on_rooftop["geometry"] raw_overhanging_pv_installations_enriched_with_closest_rooftop_data = self.enrich_raw_overhanging_pv_installations_with_closest_rooftop_attributes( raw_overhanging_PV_installations, raw_PV_installations_on_rooftop) raw_PV_installations_on_rooftop.geometry = ( raw_PV_installations_on_rooftop.geometry_intersected_polygon) raw_PV_installations_on_rooftop = raw_PV_installations_on_rooftop[[ "raw_area", "identifier", "Area", "Azimuth", "Building_I", "City", "PostalCode", "RoofTopID", "RooftopTyp", "Street", "StreetNumb", "Tilt", "area_inter", "geometry", ]] # Append the dataframe of all raw overhanging PV installations, enriched with the # rooftop attributes of their nearest rooftop, to the dataframe of all intersected PV installations # Note 1: Attributes starting with capital letters specify rooftop attributes. # Note 2: The geometry of the overhanging PV installations is not yet dissolved with the geometry of the # intersected PV installations raw_PV_installations_on_rooftop = gpd.GeoDataFrame( raw_PV_installations_on_rooftop.append( raw_overhanging_pv_installations_enriched_with_closest_rooftop_data )).reset_index(drop=True) return raw_PV_installations_on_rooftop
def main(): parser = argparse.ArgumentParser( 'Plots shore lines using a perspective projection') parser.add_argument('--image', help="image on top of which the map is projected") parser.add_argument('--fov', type=float, help="fov in width") parser.add_argument('--width', type=int, help="image width in pixels") parser.add_argument('--height', type=int, help="image height in pixels") parser.add_argument('--lat', type=float, help="satellite latitude") parser.add_argument('--lon', type=float, help="satellite longitude") parser.add_argument('--alt', type=float, help="satellite altitude") parser.add_argument('--head', type=float, help="satellite heading: 0=north, 90=east, 180=south") parser.add_argument('--tilt', type=float, help="satellite tilt: 0=down, 90=flight direction") parser.add_argument( '--roll', type=float, help= "satellite roll: 0 = \"up\" towards north (?), 90 = \"up\" towards east (?)" ) args = parser.parse_args() # 4326 is same as cartopy.crs.PlateCarree() crs4326 = CRS.from_epsg(4326) bbox = (args.lon - 45, args.lat - 20, args.lon + 45, args.lat + 20) if False else None sc = '10m' types = OrderedDict() if 0: # from open street maps coast = gp.read_file( 'zip://./coastlines-split-4326.zip!coastlines-split-4326/lines.shp', bbox=bbox) coast.set_crs(crs4326) else: cst = cartopy.feature.NaturalEarthFeature(category='physical', name='coastline', scale=sc) coast = GeoDataFrame(geometry=list(cst.geometries()), crs=crs4326) coast['type'] = ['coast'] * len(coast) types['coast'] = dict(facecolor='none', edgecolor='black', linewidth=1, alpha=0.5) if 0: # from https://gadm.org/download_country_v3.html borders = gp.read_file('zip://./gadm36_FIN_shp.zip!gadm36_FIN_0.shp', bbox=bbox) borders.set_crs(crs4326) else: brds = cartopy.feature.NaturalEarthFeature( category='cultural', name='admin_0_boundary_lines_land', scale=sc) borders = GeoDataFrame(geometry=list(brds.geometries()), crs=crs4326) borders['type'] = ['border'] * len(borders) types['border'] = dict(facecolor='none', edgecolor='black', linewidth=1, alpha=0.5) # TODO: add horizon # TODO: add cities feats = coast.append(borders, ignore_index=True) if 0: # magnetic declination (9.67 deg east) using this: https://www.ngdc.noaa.gov/geomag/calculators/magcalc.shtml slice = get_meas_slice((78.148, 16.043, 520), 9.67, (150, 175), crs4326, dist=3e6) # (150, 170) slice['type'] = ['slice'] * len(slice) types['slice'] = dict(facecolor='none', edgecolor='white', linestyle='--', linewidth=1, alpha=0.5) feats = feats.append(slice, ignore_index=True) perspective_projection(feats, (args.lat, args.lon, args.alt), (args.head, args.tilt, args.roll + 180), args.fov, args.width, args.height) if args.image: img = plt.imread(args.image) ax = plt.imshow(img).axes else: fig, ax = plt.subplots() for type, styling in types.items(): feats.loc[feats['type'] == type].plot(ax=ax, **styling) ax.set_xlim(0, args.width) ax.set_ylim(args.height, 0) plt.show() print('finished')
class TestPolygonPlotting: def setup_method(self): t1 = Polygon([(0, 0), (1, 0), (1, 1)]) t2 = Polygon([(1, 0), (2, 0), (2, 1)]) self.polys = GeoSeries([t1, t2], index=list('AB')) self.df = GeoDataFrame({'geometry': self.polys, 'values': [0, 1]}) multipoly1 = MultiPolygon([t1, t2]) multipoly2 = rotate(multipoly1, 180) self.df2 = GeoDataFrame({'geometry': [multipoly1, multipoly2], 'values': [0, 1]}) t3 = Polygon([(2, 0), (3, 0), (3, 1)]) df_nan = GeoDataFrame({'geometry': t3, 'values': [np.nan]}) self.df3 = self.df.append(df_nan) def test_single_color(self): ax = self.polys.plot(color='green') _check_colors(2, ax.collections[0].get_facecolors(), ['green']*2) # color only sets facecolor _check_colors(2, ax.collections[0].get_edgecolors(), ['k'] * 2) ax = self.df.plot(color='green') _check_colors(2, ax.collections[0].get_facecolors(), ['green']*2) _check_colors(2, ax.collections[0].get_edgecolors(), ['k'] * 2) with warnings.catch_warnings(record=True) as _: # don't print warning # 'color' overrides 'values' ax = self.df.plot(column='values', color='green') _check_colors(2, ax.collections[0].get_facecolors(), ['green']*2) def test_vmin_vmax(self): # when vmin == vmax, all polygons should be the same color # non-categorical ax = self.df.plot(column='values', categorical=False, vmin=0, vmax=0) actual_colors = ax.collections[0].get_facecolors() np.testing.assert_array_equal(actual_colors[0], actual_colors[1]) # categorical ax = self.df.plot(column='values', categorical=True, vmin=0, vmax=0) actual_colors = ax.collections[0].get_facecolors() np.testing.assert_array_equal(actual_colors[0], actual_colors[1]) # vmin vmax set correctly for array with NaN (GitHub issue 877) ax = self.df3.plot(column='values') actual_colors = ax.collections[0].get_facecolors() assert np.any(np.not_equal(actual_colors[0], actual_colors[1])) def test_style_kwargs(self): # facecolor overrides default cmap when color is not set ax = self.polys.plot(facecolor='k') _check_colors(2, ax.collections[0].get_facecolors(), ['k']*2) # facecolor overrides more general-purpose color when both are set ax = self.polys.plot(color='red', facecolor='k') # TODO with new implementation, color overrides facecolor # _check_colors(2, ax.collections[0], ['k']*2, alpha=0.5) # edgecolor ax = self.polys.plot(edgecolor='red') np.testing.assert_array_equal([(1, 0, 0, 1)], ax.collections[0].get_edgecolors()) ax = self.df.plot('values', edgecolor='red') np.testing.assert_array_equal([(1, 0, 0, 1)], ax.collections[0].get_edgecolors()) # alpha sets both edge and face ax = self.polys.plot(facecolor='g', edgecolor='r', alpha=0.4) _check_colors(2, ax.collections[0].get_facecolors(), ['g'] * 2, alpha=0.4) _check_colors(2, ax.collections[0].get_edgecolors(), ['r'] * 2, alpha=0.4) def test_legend_kwargs(self): ax = self.df.plot(column='values', categorical=True, legend=True, legend_kwds={'frameon': False}) assert ax.get_legend().get_frame_on() is False def test_multipolygons(self): # MultiPolygons ax = self.df2.plot() assert len(ax.collections[0].get_paths()) == 4 _check_colors(4, ax.collections[0].get_facecolors(), [MPL_DFT_COLOR]*4) ax = self.df2.plot('values') cmap = plt.get_cmap(lut=2) # colors are repeated for all components within a MultiPolygon expected_colors = [cmap(0), cmap(0), cmap(1), cmap(1)] _check_colors(4, ax.collections[0].get_facecolors(), expected_colors)
postcodes_arr = gf.postcode.unique() postcodes_arr.sort() # Creación del GeoDataFrame con los poligonos de los CPs gf_postcode_poly = GeoDataFrame(columns=['geometry', 'postcode']) for postcode in postcodes_arr: points = [] for point in gf.loc[gf.postcode == postcode].geometry: points.append(point) if ALGORITHM == 'ALPHA': alpha_geometry, edge_points = alpha_shape.alpha_shape(points, 1000) gf_postcode_poly = gf_postcode_poly.append( { 'geometry': alpha_geometry, 'postcode': postcode }, ignore_index=True) elif ALGORITHM == 'CONVEX': multipoint = MultiPoint(points) gf_postcode_poly = gf_postcode_poly.append( { 'geometry': multipoint.convex_hull, 'postcode': postcode }, ignore_index=True) # Serie de colores para cada uno de los códigos postales colors = sns.hls_palette(len(postcodes_arr)) colormap = ListedColormap(colors) base = gs.plot(color='blue')
class TestSpatialJoinNYBB: def setup_method(self): nybb_filename = geopandas.datasets.get_path("nybb") self.polydf = read_file(nybb_filename) self.crs = self.polydf.crs N = 20 b = [int(x) for x in self.polydf.total_bounds] self.pointdf = GeoDataFrame( [ {"geometry": Point(x, y), "pointattr1": x + y, "pointattr2": x - y} for x, y in zip( range(b[0], b[2], int((b[2] - b[0]) / N)), range(b[1], b[3], int((b[3] - b[1]) / N)), ) ], crs=self.crs, ) def test_geometry_name(self): # test sjoin is working with other geometry name polydf_original_geom_name = self.polydf.geometry.name self.polydf = self.polydf.rename(columns={"geometry": "new_geom"}).set_geometry( "new_geom" ) assert polydf_original_geom_name != self.polydf.geometry.name res = sjoin(self.polydf, self.pointdf, how="left") assert self.polydf.geometry.name == res.geometry.name def test_sjoin_left(self): df = sjoin(self.pointdf, self.polydf, how="left") assert df.shape == (21, 8) for i, row in df.iterrows(): assert row.geometry.type == "Point" assert "pointattr1" in df.columns assert "BoroCode" in df.columns def test_sjoin_right(self): # the inverse of left df = sjoin(self.pointdf, self.polydf, how="right") df2 = sjoin(self.polydf, self.pointdf, how="left") assert df.shape == (12, 8) assert df.shape == df2.shape for i, row in df.iterrows(): assert row.geometry.type == "MultiPolygon" for i, row in df2.iterrows(): assert row.geometry.type == "MultiPolygon" def test_sjoin_inner(self): df = sjoin(self.pointdf, self.polydf, how="inner") assert df.shape == (11, 8) def test_sjoin_op(self): # points within polygons df = sjoin(self.pointdf, self.polydf, how="left", op="within") assert df.shape == (21, 8) assert df.loc[1]["BoroName"] == "Staten Island" # points contain polygons? never happens so we should have nulls df = sjoin(self.pointdf, self.polydf, how="left", op="contains") assert df.shape == (21, 8) assert np.isnan(df.loc[1]["Shape_Area"]) def test_sjoin_bad_op(self): # AttributeError: 'Point' object has no attribute 'spandex' with pytest.raises(ValueError): sjoin(self.pointdf, self.polydf, how="left", op="spandex") def test_sjoin_duplicate_column_name(self): pointdf2 = self.pointdf.rename(columns={"pointattr1": "Shape_Area"}) df = sjoin(pointdf2, self.polydf, how="left") assert "Shape_Area_left" in df.columns assert "Shape_Area_right" in df.columns @pytest.mark.parametrize("how", ["left", "right", "inner"]) def test_sjoin_named_index(self, how): # original index names should be unchanged pointdf2 = self.pointdf.copy() pointdf2.index.name = "pointid" polydf = self.polydf.copy() polydf.index.name = "polyid" res = sjoin(pointdf2, polydf, how=how) assert pointdf2.index.name == "pointid" assert polydf.index.name == "polyid" # original index name should pass through to result if how == "right": assert res.index.name == "polyid" else: # how == "left", how == "inner" assert res.index.name == "pointid" def test_sjoin_values(self): # GH190 self.polydf.index = [1, 3, 4, 5, 6] df = sjoin(self.pointdf, self.polydf, how="left") assert df.shape == (21, 8) df = sjoin(self.polydf, self.pointdf, how="left") assert df.shape == (12, 8) @pytest.mark.xfail def test_no_overlapping_geometry(self): # Note: these tests are for correctly returning GeoDataFrame # when result of the join is empty df_inner = sjoin(self.pointdf.iloc[17:], self.polydf, how="inner") df_left = sjoin(self.pointdf.iloc[17:], self.polydf, how="left") df_right = sjoin(self.pointdf.iloc[17:], self.polydf, how="right") expected_inner_df = pd.concat( [ self.pointdf.iloc[:0], pd.Series(name="index_right", dtype="int64"), self.polydf.drop("geometry", axis=1).iloc[:0], ], axis=1, ) expected_inner = GeoDataFrame(expected_inner_df, crs="epsg:4326") expected_right_df = pd.concat( [ self.pointdf.drop("geometry", axis=1).iloc[:0], pd.concat( [ pd.Series(name="index_left", dtype="int64"), pd.Series(name="index_right", dtype="int64"), ], axis=1, ), self.polydf, ], axis=1, ) expected_right = GeoDataFrame(expected_right_df, crs="epsg:4326").set_index( "index_right" ) expected_left_df = pd.concat( [ self.pointdf.iloc[17:], pd.Series(name="index_right", dtype="int64"), self.polydf.iloc[:0].drop("geometry", axis=1), ], axis=1, ) expected_left = GeoDataFrame(expected_left_df, crs="epsg:4326") assert expected_inner.equals(df_inner) assert expected_right.equals(df_right) assert expected_left.equals(df_left) @pytest.mark.skip("Not implemented") def test_sjoin_outer(self): df = sjoin(self.pointdf, self.polydf, how="outer") assert df.shape == (21, 8) def test_sjoin_empty_geometries(self): # https://github.com/geopandas/geopandas/issues/944 empty = GeoDataFrame(geometry=[GeometryCollection()] * 3) df = sjoin(self.pointdf.append(empty), self.polydf, how="left") assert df.shape == (24, 8) df2 = sjoin(self.pointdf, self.polydf.append(empty), how="left") assert df2.shape == (21, 8)
vertices = DataFrame(vertices).drop_duplicates().values x = np.mean(vertices[:,0]) new['x'] = x y = np.mean(vertices[:,1]) new['y'] = y new_poly = MultiPolygon() for poly in concat['region']: new_poly = new_poly.union(poly) new['region'] = [new_poly] new['v_area'] = new['region'][0].area new['v_larea'] = np.log(new['v_area']) new = DataFrame(new) stops = stops.append(new) print "OK" print 'calculating connectedness...' print ' building representation of subway system...' # # 2.3 calculate connectedness # # 2.3.1 generate unique routes trips = read_csv('data/indata/google_transit/stop_times.txt') ids = trips['trip_id'].unique() # find weekday ('WKD') trips starts = trips[trips['stop_sequence']==1] wkd = ['WKD' in i for i in starts['trip_id']] wkd_starts = starts[wkd]