Global Disease Outbreak (June 2024)

[nimisha-18]

Authors

Nimisha Singh

Links

[GitHub] (https://github.com/nimisha-18), [LinkedIn] (www.linkedin.com/in/nimisha-singh-859015244)

Full description

Plotnine Contest 2024

This project visualizes global disease outbreaks using Plotnine (R's visualization grammar for Python), GeoPandas, and Contextily. The map plots the locations of various disease outbreaks with color-coded points indicating the type of disease and the size representing the severity rating. The addition of a basemap from OpenStreetMap enhances the geographical context. This repository includes the code and dataset used to create the visualization, demonstrating techniques in geospatial data handling and visualization.

Code repository

https://github.com/nimisha-18/Plotnine_contest_2024

[has2k1]

NOTE: The final figure in the submission uses matplotlib plus basemap. The first try with plotnine did not go all the way.

This is the plotnine part with the resulting figure.

import pandas as pd
import geopandas as gpd
import contextily as ctx
import matplotlib.pyplot as plt
from plotnine import ggplot, aes, geom_point, theme_minimal, labs, scale_color_brewer, scale_size

# Load the data
data = pd.read_csv('world_disease_data.csv')

df = pd.DataFrame(data)

# Convert to GeoDataFrame
gdf = gpd.GeoDataFrame(df, geometry=gpd.points_from_xy(df['Lng'], df['Lat']))

# Set the coordinate reference system (CRS) to EPSG:4326 (WGS 84)
gdf.set_crs(epsg=4326, inplace=True)

# Reproject to EPSG:3857
gdf = gdf.to_crs(epsg=3857)

# Convert GeoDataFrame to Pandas DataFrame for Plotnine
gdf['x'] = gdf.geometry.x
gdf['y'] = gdf.geometry.y

# Create a 'Plotnine' plot for visualization
plot = (
    ggplot(gdf) +
    aes(x='x', y='y', color='Disease', size='Rating') +
    geom_point(alpha=0.6) +
    theme_minimal() +
    labs(title='Disease Outbreaks', x='Longitude', y='Latitude', color='Disease', size='Rating') +
    scale_color_brewer(type='qual', palette='Dark2') +
    scale_size(range=(2, 10))
    
)
plot

It was possible to continue using plotnine plus basemap.

from plotnine import *

plot2 = (
    plot # from above
    + guides(
        color=guide_legend(
            theme=theme(
                legend_position=(0.965, 0.97),
            )
        ),
        size=guide_legend(
            theme=theme(
                legend_position=(0.03, 0.03),
            )
        )
    )
    + theme(
        figure_size=(15, 10),
        plot_background=element_rect(fill="white"),
        panel_border=element_rect(color="black"),
        legend_margin=5,
        legend_background=element_rect(fill="#FFFFFFBB", color="#00000022"),
        axis_ticks=element_blank(),
        axis_text=element_blank(),
        axis_title=element_blank(),
        plot_margin_top=0.2,
    )
    
)
fig = plot2.draw()
ax = fig.get_axes()[0]
ctx.add_basemap(ax, crs=gdf.crs.to_string(), source=ctx.providers.OpenStreetMap.Mapnik)
fig

[aaraney]

Ive not checked if this is a version issue (I suspect that is the case) but I was not able to reproduce the figure using the code above. The figure was shown, just without the basemap.

Im using:

python==3.10.10
contextily==1.6.2
plotnine==0.14.5
matplotlib==3.9.2

I was able to hackily (not recommended) work around after peering into the internals of plotnine.ggplot's draw method and inserting the contextily base map draw step after plotnine draws to the axis. Below is a proof of concept to work around this.

from __future__ import annotations
import contextily as ctx
import plotnine as p

def show_with_basemap(plt: p.ggplot):
    # copied from plotnine.ggplot.draw method
    from plotnine._mpl.layout_engine import PlotnineLayoutEngine
    from plotnine._utils.context import plot_context
    from copy import deepcopy

    plt = deepcopy(plt)
    with plot_context(plt, show=True):
        plt._build()

        # setup
        plt.figure, plt.axs = plt.facet.setup(plt)
        plt.guides._setup(plt)
        plt.theme.setup(plt)

        # Drawing
        plt._draw_layers()

        # Draw the base map
        ax = plt.axs[0]
        ctx.add_basemap(
            ax, crs=plt.data.crs.to_string(), source=ctx.providers.OpenStreetMap.Mapnik
        )

        plt._draw_panel_borders()
        plt._draw_breaks_and_labels()
        plt.guides.draw()
        plt._draw_figure_texts()
        plt._draw_watermarks()

        # Artist object theming
        plt.theme.apply()
        plt.figure.set_layout_engine(PlotnineLayoutEngine(plt))
    return plt.figure

[nimisha-18]

As far as I can see, this, really, is a version comparability issue.

If your data is not in Web Mercator (EPSG:3857 or I don't remember), you might need to reproduce it before adding the basemap.

OR

You can try another version for matplotlib or Plotnine.

[aaraney]

Maybe we are facing different issues, @nimisha-18? It sounds like the crs issue you are talking about was reported in #900? I was having issues with the basemap being drawn at all (it sounds like you may have also had that issue too).

I need to confirm this but I think the basemap draw issue stems from the plot_context context manager which is used in the ggplot.draw() method. plot_context will either show the plot (e.g. plt.show()) or close the matplotlib.pyplot.Figure (see below). So, if you have some ggplot instance plot and call plot.draw(show=True) or plot.show() the plot will be drawn and shown to the screen. But, if you call plot.draw() you get back a matplotlib.pyplot.Figure that has already been closed because the context manager will have already exited in draw().

    def __exit__(self, exc_type, exc_value, exc_traceback):
        """
        Exit matplotlib & pandas environments
        """
        import matplotlib.pyplot as plt

        if exc_type is None:
            if self.show:
                plt.show()
            else:
                plt.close(self.plot.figure) # <--- culprit
        else:
            # There is an exception, close any figure
            if hasattr(self.plot, "figure"):
                plt.close(self.plot.figure)

        self.rc_context.__exit__(exc_type, exc_value, exc_traceback)
        self.pd_option_context.__exit__(exc_type, exc_value, exc_traceback)

So, in the example provided by @has2k1 I think the following portion of that snippet that is adding a basemap to a matplotlib.pyplot.Axes that is attached to a matplotlib.pyplot.Figure has already closed.

fig = plot2.draw()
ax = fig.get_axes()[0]
ctx.add_basemap(ax, crs=gdf.crs.to_string(), source=ctx.providers.OpenStreetMap.Mapnik)
fig

I suspect this is likely is a change in matplotlib's plt.close() behavior that is causing this issue. In either case, I think we need ctx.add_basemap to be called by ggplot.draw() so it is drawn to the plot "in the scope of" plot_context(). It seems there are a few ways to do this but I haven't gotten around to implementing a proof of concept yet.

[aaraney]

@nimisha-18, I was able to add a basemap by implementing a custom geom subtype that adds the basemap during plotnine.ggplot's draw phase:

from __future__ import annotations

import typing

import pandas as pd
from plotnine.geoms.geom import geom
import contextily as ctx

if typing.TYPE_CHECKING:
    from typing import Any

    import pandas as pd
    from matplotlib.axes import Axes

    from plotnine.coords.coord import coord
    from plotnine.iapi import panel_view


class geom_basemap(geom):
    DEFAULT_PARAMS = {
        "stat": "identity",
        "position": "identity",
        "na_rm": False,
        "crs": "EPSG:3857",
        "source": ctx.providers.OpenStreetMap.Mapnik,
    }

    def draw_panel(
        self,
        data: pd.DataFrame,
        panel_params: panel_view,
        coord: coord,
        ax: Axes,
        **params: Any,
    ):
        crs = params["crs"]
        source = params["source"]
        ctx.add_basemap(ax, crs=crs, source=source)

To use it in your example, you would just add it like any other layer:

plot3 = plot2 + geom_basemap(source=ctx.providers.OpenStreetMap.Mapnik)
plot3.show()

Aside, the geom_basemap concept as a geom, at least to me, doesn't fit well with the ideas outlines in The Grammar of Graphics. Im not sure what category a basemap falls within so calling this a geom is likely conceptually incorrect. Just something to think about.

[has2k1]

@aaraney You are right about geom_basemap. A better solution may be adding parameters to geom_map that turnon basemap. Something like.

geom_map(
    basemap={
        "source": ctx.providers.OpenStreetMap.Mapnik,
         "crs": "EPSG:3857", # if None, the default is a value from the geodataframe
        ...
    }
)

I hope to work on the mapping projections (supported by cartopy) later this year and I will be in a better position to think about how to add basemap support.

[EconomiCurtis]

Ahoy @nimisha-18,
I am one of the contest organizers.
If you'd like, we'd be happy to send you a little Plotnine and Posit care package of hex-shaped stickers. Just a small thanks for taking part. https://forms.gle/M8QmM286MSHbkDRd7

[has2k1]

@nimisha-18, The winning submission has been announced here. Thank you for taking part in the contest.