geoplot

https://residentmario.github.io/geoplot/
Admin
geoplot is a high-level Python geospatial plotting library that extends cartopy and matplotlib to...
Tokens:140,364
Snippets:1,412
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Custom Projection Example

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

Provides an example of using a less common projection, the Azimuthal Equidistant projection. This is useful for specific visualization needs where distance from a central point is important.

```python
import geoplot.crs as gcrs
import geopandas as gpd
import geoplot
import matplotlib.pyplot as plt

data = gpd.read_file(geopandas.datasets.get_path('naturalearth_lowres'))

ax = geoplot.polyplot(data, projection=gcrs.AzimuthalEquidistant())
```

--------------------------------

### Basic Projection Example

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

Demonstrates how to set a basic projection for a geoplot map. This is useful for standard map visualizations.

```python
import geopandas as gpd
import geoplot
import matplotlib.pyplot as plt

df = gpd.read_file(geoplot.datasets.get_path('nybb'))

geoplot.polyplot(df, projection=geoplot.crs.AlbersEqualArea(), figsize=(10, 10))
plt.show()
```

--------------------------------

### Basic Projection Example

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

Demonstrates how to set a basic map projection using geoplot. This is useful for general-purpose mapping.

```python
import geoplot.crs as gcrs
geoplot.polyplot(world, projection=gcrs.PlateCarree(), figsize=(10, 5))
```

--------------------------------

### Quadtree Plotting

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Illustrates quadtree binning for visualizing point density. This example uses a sample dataset.

```python
import geopandas
import geoplot
import matplotlib.pyplot as plt

# Load a sample dataset (e.g., NYC boroughs)
nybb = geopandas.read_file(geopandas.datasets.get_path('nybb'))

# Plot using quadtree binning
geoplot.quadtreeplot(nybb, cmap='viridis', figsize=(10, 5))
plt.show()
```

--------------------------------

### Basic Projection Setup

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

Demonstrates how to set up a basic map projection. This is useful for initializing a map with a specific coordinate reference system.

```python
import geoplot.crs as gcrs
import geopandas as gpd
import geoplot
import matplotlib.pyplot as plt

data = gpd.read_file(geopandas.datasets.get_path('naturalearth_lowres'))

ax = geoplot.polyplot(data, projection=gcrs.Orthographic())
```

--------------------------------

### Plotting Quadkey

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Visualize data using a quadkey grid. This example uses sample data to create a quadkey plot.

```python
ax = geoplot.quadkey(world, cmap='Purples')
plt.show()
```

--------------------------------

### Using the Orthographic Projection

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This example shows the Orthographic projection, which gives a globe-like appearance.

```python
import geoplot.crs as gcrs
geoplot.choropleth(world, hue=world['pop_est'], projection=gcrs.Orthographic)
plt.show()
```

--------------------------------

### Loading and Plotting a Shapefile

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Demonstrates how to load a shapefile and plot it using geoplot. Ensure the 'geoplot' and 'geopandas' libraries are installed.

```python
import geopandas
import geoplot
import matplotlib.pyplot as plt

# Load a shapefile
s = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'))

# Plot the shapefile
geoplot.polyplot(s, figsize=(10, 5))
plt.show()
```

--------------------------------

### Applying the Gringorten (Generalized) projection

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This code example demonstrates the Gringorten (Generalized) projection. This is a flexible projection that can be adapted for various mapping purposes.

```python
import matplotlib.pyplot as plt
import geoplot

data = geoplot.load_dataset('world')

# Plotting with the Gringorten (Generalized) projection
ax = geoplot.polyplot(data, projection=geoplot.crs.Gringorten(), figsize=(10, 5))
plt.show()
```

--------------------------------

### Using the Stereographic Projection

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This example uses the Stereographic projection, which is conformal and useful for polar regions.

```python
import geoplot.crs as gcrs
geoplot.choropleth(world, hue=world['pop_est'], projection=gcrs.Stereographic)
plt.show()
```

--------------------------------

### Plotting Point Data

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Visualize point data on a map. This example plots cities from a GeoDataFrame.

```python
cities = gpd.read_file(gpd.datasets.get_path('naturalearth_cities'))

ax = geoplot.pointplot(cities, hue=cities['pop_est'],
                       legend=True,
                       cmap='plasma')
plt.show()
```

--------------------------------

### Using the Equirectangular Projection

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This example demonstrates how to use the `Equirectangular` projection for plotting geographical data.

```python
import geoplot
import geopandas as gpd
import matplotlib.pyplot as plt

world = gpd.read_file(geoplot.datasets.get_path('naturalearth_lowres'))

geoplot.polyplot(world, projection=geoplot.crs.Equirectangular(), figsize=(10, 10))
plt.show()
```

--------------------------------

### Applying the EuroPP projection

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This code example demonstrates the Euro PP projection, a specific projection often used for European mapping.

```python
import matplotlib.pyplot as plt
import geoplot

data = geoplot.load_dataset('world')

# Plotting with the Euro PP projection
ax = geoplot.polyplot(data, projection=geoplot.crs.EuroPP(), figsize=(10, 5))
plt.show()
```

--------------------------------

### Setting a Map Projection

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

Use the `projection` parameter to set the desired map projection. This example sets the projection to 'orthographic'.

```python
import geoplot.crs as gcrs
geoplot.polyplot(world, projection=gcrs.orthographic)
plt.show()
```

--------------------------------

### Point Plotting with Geoplot

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Visualizes point data on a map. This example plots cities from a dataset.

```python
import geopandas
import geoplot
import matplotlib.pyplot as plt

cities = geopandas.read_file(geopandas.datasets.get_path('nybb'))

geoplot.pointplot(cities, figsize=(10, 5))
plt.show()
```

--------------------------------

### Using the Azimuthal Equidistant Projection

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This example uses the Azimuthal Equidistant projection, which preserves distance from a central point.

```python
import geoplot.crs as gcrs
geoplot.choropleth(world, hue=world['pop_est'], projection=gcrs.AzimuthalEquidistant)
plt.show()
```

--------------------------------

### Using the AzimuthalEquidistant projection

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This code example shows how to apply the Azimuthal Equidistant projection. This projection is useful for showing distances from a central point.

```python
import matplotlib.pyplot as plt
import geoplot

data = geoplot.load_dataset('world')

# Plotting with the Azimuthal Equidistant projection
ax = geoplot.polyplot(data, projection=geoplot.crs.AzimuthalEquidistant(), figsize=(10, 5))
plt.show()
```

--------------------------------

### Plotting Datashader

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Utilize Datashader for efficient rendering of large geospatial datasets. This example plots cities.

```python
import datashader as ds

cvs = ds.Canvas()
tot = cvs.points(cities, 'x', 'y')
img = ds.tf.shade(tot, cmap=['lightblue', 'darkblue'])
img
```

--------------------------------

### Plotting Kernels

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Visualize data density using kernel density estimation. This example uses the 'cities' GeoDataFrame.

```python
ax = geoplot.kdeplot(cities, cmap='Oranges')
plt.show()
```

--------------------------------

### Using a Projection with Scatter Plots

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This example demonstrates applying a specific map projection to a scatter plot, ensuring consistent visualization.

```python
import geoplot
import geopandas as gpd
import matplotlib.pyplot as plt

# Load a dataset with point data
airports = gpd.read_file(geoplot.datasets.get_path('airports'))

geoplot.pointplot(airports, projection=geoplot.crs.Gnomonic(), figsize=(10, 10))
plt.show()
```

--------------------------------

### Install geoplot with Conda

Source: https://residentmario.github.io/geoplot/installation.html

Use this command to install geoplot and its dependencies using Conda. This is the recommended method for all platforms.

```bash
conda install geoplot -c conda-forge
```

--------------------------------

### Install geoplot with pip

Source: https://residentmario.github.io/geoplot/installation.html

Use this command to install geoplot using pip. Be aware that this method may not work reliably on Windows, macOS, or Linux.

```bash
pip install geoplot
```

--------------------------------

### Basic Projection Setup

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

Demonstrates how to set up a basic map projection using geoplot. This is useful for initializing maps with a specific coordinate reference system.

```python
import geoplot.crs as gcrs
import matplotlib.pyplot as plt

fig, ax = plt.subplots(subplot_kw={'projection': gcrs.PlateCarree()})

```

--------------------------------

### Create a Basic Webmap with Point Plot

Source: https://residentmario.github.io/geoplot/user_guide/Customizing_Plots.html

Renders a web map of the contiguous USA and overlays city points using the WebMercator projection. This demonstrates basic map setup and point plotting.

```python
import geoplot.crs as gcrs

ax = gplt.webmap(contiguous_usa, projection=gcrs.WebMercator())
gplt.pointplot(continental_usa_cities, ax=ax)

```

--------------------------------

### Create a Basic Webmap

Source: https://residentmario.github.io/geoplot/plot_references/plot_reference.html

Generates a static webmap using the WebMercator projection.

```python
import geoplot as gplt
import geoplot.crs as gcrs
import geopandas as gpd

boroughs = gpd.read_file(gplt.datasets.get_path('nyc_boroughs'))

gplt.webmap(boroughs, projection=gcrs.WebMercator())
```

--------------------------------

### Getting the Centroid of a GeoSeries

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Calculate the centroid for each geometry in a GeoSeries.

```python
import geopandas
from shapely.geometry import Polygon

polygons = [Polygon([(0, 0), (1, 1), (1, 0)]), Polygon([(2, 2), (3, 3), (3, 2)])]
gs = geopandas.GeoSeries(polygons)
print(gs.centroid)
```

--------------------------------

### Plotting Contours

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Generate contour plots from gridded data. This example uses sample data to create contours.

```python
import numpy as np

x = np.linspace(-1, 1, 100)
y = np.linspace(-1, 1, 100)
X, Y = np.meshgrid(x, y)

# Sample data for contour plot
Z = np.sin(X**2 + Y**2)

ax = geoplot.contourplot(Z, cmap='Greens')
plt.show()
```

--------------------------------

### Getting the Bounds of a GeoSeries

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Retrieve the bounding box for each geometry in a GeoSeries.

```python
import geopandas
from shapely.geometry import Polygon

polygons = [Polygon([(0, 0), (1, 1), (1, 0)]), Polygon([(2, 2), (3, 3), (3, 2)])]
gs = geopandas.GeoSeries(polygons)
print(gs.bounds)
```

--------------------------------

### datasets.get_path()

Source: https://residentmario.github.io/geoplot/api_reference.html

Returns the URL path to an example dataset suitable for reading into geopandas.

```APIDOC
## datasets.get_path()

### Description
Returns the URL path to an example dataset suitable for reading into `geopandas`.

### Method
N/A (This is a utility function, not an HTTP endpoint)

### Endpoint
N/A

### Parameters
None

### Request Example
```python
import geoplot.datasets

dataset_url = geoplot.datasets.get_path('nybb')
print(dataset_url)
```

### Response
#### Success Response
- **dataset_url** (string) - The URL path to the example dataset.
```

--------------------------------

### Getting the Centroid

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Shows how to calculate the centroid (geometric center) of each geometry in a GeoDataFrame.

```python
import geopandas as gpd

geodataframe = gpd.read_file("path/to/your/data.shp")

# Get the centroid of each geometry
centroids_gdf = geodataframe.geometry.centroid
print(centroids_gdf.head())
```

--------------------------------

### Using the Albers Equal Area Projection

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This example demonstrates the Albers Equal Area projection, suitable for visualizations where area accuracy is important.

```python
import geoplot.crs as gcrs
geoplot.choropleth(world, hue=world['pop_est'], projection=gcrs.AlbersEqualArea)
plt.show()
```

--------------------------------

### Getting the GeoJSON representation of a GeoDataFrame

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Convert an entire GeoDataFrame into a GeoJSON FeatureCollection.

```python
import geopandas

df = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'))

# Convert GeoDataFrame to GeoJSON string
gson_output = df.to_json()
print(type(gson_output)) # Should be <class 'str'>
# To load it back as a dictionary:
# import json
# gson_dict = json.loads(gson_output)
```

--------------------------------

### Using the Transverse Mercator Projection

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This example demonstrates the Transverse Mercator projection, often used for national or regional maps.

```python
import geoplot.crs as gcrs
geoplot.choropleth(world, hue=world['pop_est'], projection=gcrs.TransverseMercator)
plt.show()
```

--------------------------------

### Get the Centroid of Geometries

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Calculate the centroid (geometric center) for each geometry in a GeoDataFrame.

```python
import geopandas as gpd

geodataframe = gpd.read_file('path/to/data.shp')

centroids = geodataframe.geometry.centroid

```

--------------------------------

### Applying the Global projection with specific parameters

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This code example demonstrates the Global projection with specific parameters for central longitude and latitude. This allows for a focused view of the world map from a particular perspective.

```python
import matplotlib.pyplot as plt
import geoplot

data = geoplot.load_dataset('world')

# Plotting with the Global projection with custom center
ax = geoplot.polyplot(data, projection=geoplot.crs.Global(central_longitude=10, central_latitude=20), figsize=(10, 5))
plt.show()
```

--------------------------------

### Using the Stereographic projection

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This code example shows how to apply the Stereographic projection. It's a conformal projection often used for polar regions.

```python
import matplotlib.pyplot as plt
import geoplot

data = geoplot.load_dataset('world')

# Plotting with the Stereographic projection
ax = geoplot.polyplot(data, projection=geoplot.crs.Stereographic(), figsize=(10, 5))
plt.show()
```

--------------------------------

### Using Different Projections

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

Demonstrates how to use different map projections like 'albers usa' and 'winkel tripel'.

```python
import geoplot
import geopandas
import matplotlib.pyplot as plt

data = geopandas.read_file(geoplot.datasets.get_path('nybb'))

# Albers USA projection
ax = geoplot.polyplot(data, projection=geoplot.crs.albers_usa())
plt.show()

# Winkel Tripel projection
ax = geoplot.polyplot(data, projection=geoplot.crs.winkel_tripel())
plt.show()
```

--------------------------------

### Geoplot polyplot with projection

Source: https://residentmario.github.io/geoplot/quickstart/quickstart.html

Example of using geoplot's polyplot with the AlbersEqualArea projection.

```python
ax = gplt.polyplot(
    contiguous_usa, projection=gcrs.AlbersEqualArea(),
```

--------------------------------

### Getting the Area of a GeoSeries

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Calculate the area for each geometry in a GeoSeries. The unit depends on the CRS.

```python
import geopandas
from shapely.geometry import Polygon

polygons = [Polygon([(0, 0), (1, 1), (1, 0)]), Polygon([(2, 2), (3, 3), (3, 2)])]
gs = geopandas.GeoSeries(polygons)
print(gs.area)
```

--------------------------------

### Create an informative webmap with hue and legend

Source: https://residentmario.github.io/geoplot/quickstart/quickstart.html

Create a webmap of the contiguous USA, plotting cities and coloring them by elevation ('ELEV_IN_FT') with a legend.

```python
ax = gplt.webmap(contiguous_usa, projection=gcrs.WebMercator())
gplt.pointplot(continental_usa_cities, ax=ax, hue='ELEV_IN_FT', legend=True)
```

--------------------------------

### Projection with Geoplot.choropleth

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

The `projection` parameter can also be used with `geoplot.choropleth`. This example uses the 'Mercator' projection.

```python
import geoplot.crs as gcrs
import geopandas as gpd

world = gpd.read_file(gpd.datasets.get_path('naturalearth_lowres'))

geoplot.choropleth(world, hue=world['pop_est'], projection=gcrs.Mercator())
```

--------------------------------

### Basic Map Projection Example

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

Demonstrates how to set a basic map projection for a geoplot. This is useful for controlling the visual representation of the Earth's surface.

```python
import geoplot.crs as gcrs
import geopandas as gpd
import geoplot

data = gpd.read_file(geoplot.datasets.get_path('nybb.shp'))

geoplot.polyplot(data, projection=gcrs.AlbersEqualArea(), figsize=(10, 10))
```

--------------------------------

### Create a static webmap

Source: https://residentmario.github.io/geoplot/quickstart/quickstart.html

Generate a static webmap of the contiguous USA using the Web Mercator projection and overlay city points.

```python
ax = gplt.webmap(contiguous_usa, projection=gcrs.WebMercator())
gplt.pointplot(continental_usa_cities, ax=ax)
```

--------------------------------

### Plotting Polyfill

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Fill polygons with a specified color. This example fills the 'world' GeoDataFrame with blue.

```python
ax = geoplot.poly_fill(world, color='blue')
plt.show()
```

--------------------------------

### Adding Contextual Maps

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Demonstrates how to add base maps or contextual layers, such as coastlines or country borders, to enhance the visualization.

```python
import geoplot
import geopandas
import cartopy.feature as cfeature

data = geopandas.read_file("data.geojson")

ax = geoplot.polyplot(data, figsize=(10, 5))
ax.add_feature(cfeature.COASTLINE)
ax.add_feature(cfeature.BORDERS, linestyle=':')
plt.show()
```

--------------------------------

### Applying the Global projection with a center

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This code example demonstrates the Global projection centered on a specific point. This allows for a focused view of the world map from a particular perspective.

```python
import matplotlib.pyplot as plt
import geoplot

data = geoplot.load_dataset('world')

# Plotting with the Global projection centered on a specific point
ax = geoplot.polyplot(data, projection=geoplot.crs.Global(central_longitude=0, central_latitude=0), figsize=(10, 5))
plt.show()
```

--------------------------------

### Create a webmap with a custom colormap

Source: https://residentmario.github.io/geoplot/quickstart/quickstart.html

Create a webmap of the contiguous USA, coloring cities by elevation ('ELEV_IN_FT') using the 'terrain' colormap and displaying a legend.

```python
ax = gplt.webmap(contiguous_usa, projection=gcrs.WebMercator())
gplt.pointplot(continental_usa_cities, ax=ax, hue='ELEV_IN_FT', cmap='terrain', legend=True)
```

--------------------------------

### Getting the WKB representation of a GeoDataFrame

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Convert all geometries in a GeoDataFrame to their Well-Known Binary (WKB) representation.

```python
import geopandas

df = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'))

# Convert geometries to WKB
df['wkb_geometry'] = df.geometry.apply(lambda geom: geom.wkb)
print(df[['name', 'wkb_geometry']].head())
```

--------------------------------

### Getting the Length of a GeoSeries

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Calculate the length for each linear geometry in a GeoSeries. The unit depends on the CRS.

```python
import geopandas
from shapely.geometry import LineString

lines = [LineString([(0, 0), (1, 1)]), LineString([(2, 2), (3, 3)])]
gs = geopandas.GeoSeries(lines)
print(gs.length)
```

--------------------------------

### Applying the Geostationary projection with specific parameters

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This code example demonstrates the Geostationary projection with specific parameters for central longitude and latitude. This is useful for mapping areas visible from a geostationary satellite positioned at a specific location.

```python
import matplotlib.pyplot as plt
import geoplot

data = geoplot.load_dataset('world')

# Plotting with the Geostationary projection with custom center
ax = geoplot.polyplot(data, projection=geoplot.crs.Geostationary(central_longitude=75, central_latitude=0), figsize=(10, 5))
plt.show()
```

--------------------------------

### Getting the Centroid of a Single Geometry

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Calculate the centroid (geometric center) of an individual geometry object.

```python
from shapely.geometry import Polygon

polygon = Polygon([(0, 0), (1, 1), (1, 0)])
centroid = polygon.centroid
print(f"Centroid: {centroid}")
```

--------------------------------

### Using the Azimuthal equidistant projection with a central point

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This example shows how to set the center of the Azimuthal Equidistant projection using the `lon_0` and `lat_0` arguments.

```python
import geoplot.crs as gcrs
geoplot.polyplot(world, projection=gcrs.AzimuthalEquidistant(lon_0=0, lat_0=0))
```

--------------------------------

### Basic geoplotting with default projection

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This code snippet demonstrates a basic geoplotting operation, likely setting up a map with a default projection. It's useful for initial visualization tasks.

```python
import matplotlib.pyplot as plt
import geoplot

# Load a dataset (e.g., world countries)
data = geoplot.load_dataset('world')

# Create a basic plot with default projection
ax = geoplot.polyplot(data, figsize=(10, 5))
plt.show()
```

--------------------------------

### Getting the GeoJSON Representation

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Convert geometries to their GeoJSON representation. This is useful for web mapping and APIs.

```python
import geopandas

df = geopandas.read_file("path/to/your/data.shp")

# Get the GeoJSON representation
df['geojson'] = df.geometry.to_geojson()
print(df[['geometry', 'geojson']].head())
```

--------------------------------

### Get the Bounds of Geometries

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Retrieve the bounding box (minimum and maximum coordinates) for each geometry in a GeoDataFrame.

```python
import geopandas as gpd

geodataframe = gpd.read_file('path/to/data.shp')

bounds = geodataframe.geometry.bounds

```

--------------------------------

### Get the Convex Hull of Geometries

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Compute the smallest convex polygon that contains all geometries in a GeoDataFrame.

```python
import geopandas as gpd

geodataframe = gpd.read_file('path/to/data.shp')

convex_hulls = geodataframe.geometry.convex_hull

```

--------------------------------

### Load Boston AirBnB Data and Plot KDE

Source: https://residentmario.github.io/geoplot/_downloads/8d577650246f7424e1a0ea827a3b11b7/plot_boston_airbnb_kde.ipynb

Loads the Boston AirBnB listings dataset and generates a KDE plot with overlaid points on a web map. Requires geopandas, geoplot, and matplotlib. The plot uses the WebMercator projection and a viridis colormap.

```python
import geopandas as gpd
import geoplot as gplt
import geoplot.crs as gcrs
import matplotlib.pyplot as plt

boston_airbnb_listings = gpd.read_file(gplt.datasets.get_path('boston_airbnb_listings'))

ax = gplt.kdeplot(
    boston_airbnb_listings, cmap='viridis', projection=gcrs.WebMercator(), figsize=(12, 12),
    shade=True
)
gplt.pointplot(boston_airbnb_listings, s=1, color='black', ax=ax)
gplt.webmap(boston_airbnb_listings, ax=ax)
plt.title('Boston AirBnB Locations, 2016', fontsize=18)
```

--------------------------------

### Load GeoDataFrame from Shapefile

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Load a shapefile into a GeoDataFrame for geospatial analysis. Ensure the 'geopandas' library is installed.

```python
import geopandas as gpd

geodataframe = gpd.read_file("path/to/your/shapefile.shp")
```

--------------------------------

### Basic Subplot Setup with Geoplot

Source: https://residentmario.github.io/geoplot/user_guide/Working_with_Projections.html

Use this to create a figure with multiple axes for side-by-side map comparisons. Ensure matplotlib and geoplot are imported.

```python
import matplotlib.pyplot as plt
import geoplot as gplt

f, axarr = plt.subplots(1, 2, figsize=(12, 4))
gplt.polyplot(contiguous_usa, ax=axarr[0])
gplt.polyplot(contiguous_usa, ax=axarr[1])
```

--------------------------------

### Load GeoDataFrame from Shapefile

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Load a shapefile into a GeoDataFrame for geospatial analysis. Ensure the 'geopandas' library is installed.

```python
import geopandas as gpd

# Load a shapefile
world = gpd.read_file(gpd.datasets.get_path('naturalearth_lowres'))
```

--------------------------------

### Custom Projection with Geoplot.dots

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This example shows how to apply a custom projection, 'Winkel Tripel', when using `geoplot.dots`.

```python
import geoplot.crs as gcrs
import geopandas as gpd

world = gpd.read_file(gpd.datasets.get_path('naturalearth_lowres'))

geoplot.dots(world, projection=gcrs.WinkelTripel())
```

--------------------------------

### Using Named Projections

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

Illustrates how to use predefined named projections for common map types. This simplifies the process of applying standard projections.

```python
import geopandas as gpd
import geoplot
import matplotlib.pyplot as plt

df = gpd.read_file(geoplot.datasets.get_path('nybb'))

# Use a named projection (e.g., Mercator)
geoplot.polyplot(df, projection=geoplot.crs.Mercator(), figsize=(10, 10))
plt.show()
```

--------------------------------

### Creating a GeoDataFrame from WKB

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Load geometries from Well-Known Binary (WKB) format into a GeoDataFrame.

```python
import geopandas
from shapely.wkb import loads

# Assuming 'wkb_data' is a variable containing WKB bytes
# Example WKB for a Point(1, 1)
wkb_data = b'\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\xf0?'

geometry = loads(wkb_data)
gdf = geopandas.GeoDataFrame([1], geometry=[geometry], crs="EPSG:4326")
print(gdf)
```

--------------------------------

### Using the Gnomonic Projection

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This example utilizes the Gnomonic projection, which maps great circles to straight lines.

```python
import geoplot.crs as gcrs
geoplot.choropleth(world, hue=world['pop_est'], projection=gcrs.Gnomonic)
plt.show()
```

--------------------------------

### Applying the Geostationary projection with a center

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This code example demonstrates the Geostationary projection centered on a specific point. This is useful for mapping areas visible from a geostationary satellite.

```python
import matplotlib.pyplot as plt
import geoplot

data = geoplot.load_dataset('world')

# Plotting with the Geostationary projection centered on a specific point
ax = geoplot.polyplot(data, projection=geoplot.crs.Geostationary(central_longitude=0, central_latitude=0), figsize=(10, 5))
plt.show()
```

--------------------------------

### Cartogram with Colormap, Scheme, and Outline

Source: https://residentmario.github.io/geoplot/_sources/plot_references/plot_reference.rst.txt

Add a colormap using `hue` and `cmap`, specify a classification scheme with `scheme`, and overlay original state shapes for context. This example uses Quantiles classification and a 'Greens' colormap.

```python
import mapclassify as mc

scheme = mc.Quantiles(contiguous_usa['population'], k=5)
ax = gplt.cartogram(
    contiguous_usa, scale='population', projection=gcrs.AlbersEqualArea(),
    legend=True, legend_kwargs={'bbox_to_anchor': (1, 0.9)}, legend_var='hue',
    hue='population', scheme=scheme, cmap='Greens'
)
gplt.polyplot(contiguous_usa, facecolor='lightgray', edgecolor='white', ax=ax)
```

--------------------------------

### Plotting Weaver

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Create a weaver plot to visualize connections between points. This example uses sample data.

```python
ax = geoplot.weaver(world, cmap='OrRd')
plt.show()
```

--------------------------------

### KDEPlot and Pointplot of Boston AirBnB Locations

Source: https://residentmario.github.io/geoplot/gallery/plot_boston_airbnb_kde.html

Generates a Kernel Density Estimation plot overlaid with point plots for Boston AirBnB listings. The plot is then rendered as a webmap. Imports necessary libraries and loads the dataset.

```python
import geopandas as gpd
import geoplot as gplt
import geoplot.crs as gcrs
import matplotlib.pyplot as plt

boston_airbnb_listings = gpd.read_file(gplt.datasets.get_path('boston_airbnb_listings'))

ax = gplt.kdeplot(
    boston_airbnb_listings, cmap='viridis', projection=gcrs.WebMercator(), figsize=(12, 12),
    shade=True
)
gplt.pointplot(boston_airbnb_listings, s=1, color='black', ax=ax)
gplt.webmap(boston_airbnb_listings, ax=ax)
plt.title('Boston AirBnB Locations, 2016', fontsize=18)

```

--------------------------------

### Plotting Contours with GeoPandas

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Create contour plots directly from GeoDataFrames. This example uses the 'world' GeoDataFrame.

```python
ax = geoplot.contour(world, cmap='Reds')
plt.show()
```

--------------------------------

### Cartesian Plotting

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Generates a standard Cartesian plot of geospatial data. This example plots points from a GeoDataFrame.

```python
import geopandas
import geoplot
import matplotlib.pyplot as plt

# Load a sample dataset
s = geopandas.read_file(geopandas.datasets.get_path('nybb'))

# Plot using cartesian coordinates
geoplot.cartoplot(s, figsize=(10, 5))
plt.show()
```

--------------------------------

### Hexbin Plotting

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Uses hexbinning to visualize the density of point data. This example plots points from a GeoDataFrame.

```python
import geopandas
import geoplot
import matplotlib.pyplot as plt

# Load a sample dataset
s = geopandas.read_file(geopandas.datasets.get_path('nybb'))

# Plot using hexbinning
geoplot.hexbinplot(s, cmap='viridis', figsize=(10, 5))
plt.show()
```

--------------------------------

### Using Different Projection Instances

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

Demonstrates creating and using different projection instances from `geopy.crs` for specific plotting needs. This allows for fine-grained control over map distortions and representations.

```python
import geoplot
import matplotlib.pyplot as plt
from geopy.crs import AlbersEqualArea, Mercator

# Set a global projection
geoplot.set_geometry("mercator")

# Create a figure and axes
fig, ax = plt.subplots(1, 2, figsize=(12, 6))

# Plot using the global projection (Mercator)
geoplot.polyplot(world, ax=ax[0], edgecolor="white")
ax[0].set_title("Global Mercator Projection")

# Plot using a different projection (Albers Equal Area)
geoplot.polyplot(world, ax=ax[1], projection=AlbersEqualArea(), edgecolor="white")
ax[1].set_title("Albers Equal Area Projection")

plt.show()
```

--------------------------------

### Creating a GeoDataFrame from Coordinates

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Shows how to create a GeoDataFrame from a list of coordinates and a Coordinate Reference System (CRS).

```python
import geopandas
from shapely.geometry import Point

# List of coordinates (longitude, latitude)
coords = [(-74.0060, 40.7128), (-73.9352, 40.7306)]

# Create Point objects
geometry = [Point(xy) for xy in coords]

# Create a GeoDataFrame
gdf = geopandas.GeoDataFrame(geometry, crs="EPSG:4326")

print(gdf)
```

--------------------------------

### Customizing Projection Parameters

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

Illustrates how to customize projection parameters for more specific map visualizations. This allows fine-tuning the map's center and other attributes.

```python
import geoplot.crs as gcrs
import geopandas
import matplotlib.pyplot as plt

data = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'))

fig, ax = plt.subplots(figsize=(10, 5), subplot_kw={'projection': gcrs.Mercator(central_longitude=0, min_latitude=20, max_latitude=85)})

geoplot.polyplot(data, ax=ax, projection=gcrs.Mercator(central_longitude=0, min_latitude=20, max_latitude=85), edgecolor='white', facecolor='lightgray')

plt.show()
```

--------------------------------

### Getting the GeoJSON Representation of a Single Geometry

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Convert a single Shapely geometry object to its GeoJSON representation.

```python
from shapely.geometry import Point

point = Point(1, 2)
geojson_repr = geopandas.GeoSeries([point]).to_geojson()[0]
print(geojson_repr)
```

--------------------------------

### Getting the Area of a Single Geometry

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Calculate the area of an individual geometry object. The unit depends on the CRS.

```python
from shapely.geometry import Polygon

polygon = Polygon([(0, 0), (1, 1), (1, 0)])
area = polygon.area
print(f"Area: {area}")
```

--------------------------------

### Using the Global projection

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This snippet shows how to apply the Global projection. This is a general projection suitable for world maps.

```python
import matplotlib.pyplot as plt
import geoplot

data = geoplot.load_dataset('world')

# Plotting with the Global projection
ax = geoplot.polyplot(data, projection=geoplot.crs.Global(), figsize=(10, 5))
plt.show()
```

--------------------------------

### Custom Projection with Parameters

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

Shows how to define a custom projection using specific parameters. This allows for fine-grained control over the map's appearance.

```python
import geopandas as gpd
import geoplot
import matplotlib.pyplot as plt

df = gpd.read_file(geoplot.datasets.get_path('nybb'))

# Define a custom projection with specific parameters
custom_proj = geoplot.crs.Projection(
    "+proj=lcc +lat_1=40.4167 +lat_2=42.75 +lat_0=39.5 +lon_0=-97.5"
)
geoplot.polyplot(df, projection=custom_proj, figsize=(10, 10))
plt.show()
```

--------------------------------

### Getting the Number of Points

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Count the number of points that define each geometry. This can give an indication of geometric complexity.

```python
import geopandas

df = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'))

# Get the number of points for each geometry
df['num_points'] = df.geometry.npoints
print(df[['name', 'num_points']].head())
```

--------------------------------

### Create a Basic Pointplot

Source: https://residentmario.github.io/geoplot/plot_references/plot_reference.html

Generates a simple geospatial scatter plot. Requires at least point data.

```python
import geoplot as gplt
import geoplot.crs as gcrs
import geopandas as gpd

cities = gpd.read_file(gplt.datasets.get_path('usa_cities'))
gplt.pointplot(cities)
```

--------------------------------

### Getting the Length of a GeoDataFrame

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Calculate the total length of all linear geometries in a GeoDataFrame. The result is in the units of the CRS.

```python
import geopandas

df = geopandas.read_file(geopandas.datasets.get_path('nybb')) # Example with polygons

# To calculate length, we need lines. Let's use a different dataset or extract lines.
# For demonstration, assume we have a GeoDataFrame of lines:
# lines_df = geopandas.read_file("path/to/lines.shp")
# total_length = lines_df.geometry.length.sum()
# print(f"Total length: {total_length}")

# Example using a dataset that might have lines or can be converted:
# For simplicity, let's use a dataset and pretend we are calculating line lengths
# In a real scenario, ensure your GeoDataFrame contains LineString or MultiLineString geometries.
print("This example demonstrates the concept. Ensure your GeoDataFrame contains linear geometries.")
```

--------------------------------

### Applying the Azimuthal equidistant projection centered on a point

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This code example demonstrates the Azimuthal Equidistant projection centered on a specific point. This is useful for visualizing distances from a particular location.

```python
import matplotlib.pyplot as plt
import geoplot

data = geoplot.load_dataset('world')

# Plotting with the Azimuthal Equidistant projection centered on London
ax = geoplot.polyplot(data, projection=geoplot.crs.AzimuthalEquidistant(central_longitude=0, central_latitude=51.5), figsize=(10, 5))
plt.show()
```

--------------------------------

### Getting the Area of a GeoDataFrame

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Calculate the total area covered by all geometries in a GeoDataFrame. The result is in the units of the CRS.

```python
import geopandas

df = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'))

# Ensure CRS is suitable for area calculation (e.g., projected)
df_proj = df.to_crs('EPSG:3395') # World Mercator
total_area = df_proj.geometry.area.sum()
print(f"Total area: {total_area:.2f} square meters")
```

--------------------------------

### Load GeoJSON Data

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Load geospatial data from a GeoJSON file into a GeoDataFrame. Ensure the 'geopandas' library is installed.

```python
import geopandas as gpd

geodataframe = gpd.read_file("path/to/your/data.geojson")
print(geodataframe.head())
```

--------------------------------

### Applying the Winkel Tripel projection

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This code example demonstrates the Winkel Tripel projection. It's a compromise projection that offers a good balance of area, shape, and distance distortions, commonly used for world maps.

```python
import matplotlib.pyplot as plt
import geoplot

data = geoplot.load_dataset('world')

# Plotting with the Winkel Tripel projection
ax = geoplot.polyplot(data, projection=geoplot.crs.WinkelTripel(), figsize=(10, 5))
plt.show()
```

--------------------------------

### Using Azimuthal Equidistant Projection with Custom Center

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

Demonstrates setting a custom center for the Azimuthal Equidistant projection. This allows accurate distance measurements from a specific location.

```python
import geoplot.crs as gcrs
import geopandas
import matplotlib.pyplot as plt

data = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'))

fig, ax = plt.subplots(figsize=(10, 5), subplot_kw={'projection': gcrs.AzimuthalEquidistant(central_longitude=75, central_latitude=45)})

data.plot(ax=ax, color='lightgray', edgecolor='black')

plt.show()
```

--------------------------------

### Create a GeoJSON layer with a projection

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This snippet demonstrates how to create a GeoJSON layer and assign a specific projection to it. Ensure the 'pyproj' library is installed for projection handling.

```python
import geopandas as gpd
import geodatasets

df = gpd.read_file(geodatasets.get_path('nybb.zip'))

df.crs = "EPSG:4326"
df.to_file("nybb_proj.geojson", driver="GeoJSON")
```

--------------------------------

### Basic Projection with Geoplot

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

Demonstrates how to set a basic map projection using geoplot. This is useful for standard map visualizations.

```python
import geoplot.crs as gcrs
import geopandas
import matplotlib.pyplot as plt

data = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'))

fig, ax = plt.subplots(figsize=(10, 5), subplot_kw={'projection': gcrs.Orthographic()})

geoplot.polyplot(data, ax=ax, projection=gcrs.Orthographic(), edgecolor='white', facecolor='lightgray')

plt.show()
```

--------------------------------

### Setting Projection Scale

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

Adjust the scale of the projection using the `scale` parameter. This example uses a scale of 0.5.

```python
import geoplot.crs as gcrs
geoplot.choropleth(world, hue=world['pop_est'], projection=gcrs.Mercator(scale=0.5))
plt.show()
```

--------------------------------

### Plotting Datashader with GeoPandas

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Integrate Datashader with GeoPandas for interactive geospatial visualizations. This example plots world population.

```python
cvs = ds.Canvas()
tot = cvs.geodataframe(world, 'geometry')
img = ds.tf.shade(tot, cmap=['lightgreen', 'darkgreen'])
img
```

--------------------------------

### Applying the WGS84 projection with specific parameters

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

This code example demonstrates the WGS84 projection with specific parameters for central longitude and latitude. This is useful for focusing the map on a particular geographic location within the WGS84 coordinate system.

```python
import matplotlib.pyplot as plt
import geoplot

data = geoplot.load_dataset('world')

# Plotting with the WGS84 projection with custom center
ax = geoplot.polyplot(data, projection=geoplot.crs.WGS84(central_longitude=10, central_latitude=20), figsize=(10, 5))
plt.show()
```

--------------------------------

### Plotting Tagged Data

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Visualize tagged data points on a map. This example uses sample data with tags.

```python
ax = geoplot.tagplot(world, cmap='Greens')
plt.show()
```

--------------------------------

### Using Orthographic Projection with Custom Center

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Projections.ipynb.txt

Demonstrates how to set a custom center for the Orthographic projection. This allows focusing on a specific region of the globe.

```python
import geoplot.crs as gcrs
import geopandas
import matplotlib.pyplot as plt

data = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'))

fig, ax = plt.subplots(figsize=(10, 5), subplot_kw={'projection': gcrs.Orthographic(central_longitude=0, central_latitude=30)})

data.plot(ax=ax, color='lightgray', edgecolor='black')

plt.show()
```

--------------------------------

### Plotting Cartograms

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Create a cartogram where the area of regions is proportional to a specific variable. This example uses population data.

```python
ax = geoplot.cartogram(world, scale=world['pop_est'], cmap='Blues')
plt.show()
```

--------------------------------

### Loading a Shapefile

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Shows how to load a shapefile into a GeoDataFrame. This is a common format for storing vector geospatial data.

```python
import geopandas as gpd

geodataframe = gpd.read_file("path/to/your/data.shp")
print(geodataframe.head())
```

--------------------------------

### Plotting Raster Data

Source: https://residentmario.github.io/geoplot/_sources/user_guide/Working_with_Geospatial_Data.ipynb.txt

Display raster data on a map. This example loads and plots a sample raster image.

```python
raster_path = gpd.datasets.get_path('lima_elevation')

ax = geoplot.rasterplot(raster_path, cmap='Greys')
plt.show()
```
Tokens:
Raw