Dataset Properties

| Column | Description | | -------------- | ------------------------------------------ | | region_code | Integer-based FIPS-style region identifier | | region_name | Full name of the state (e.g., California) | | cases | Total case count | | population | Total population | | case_density | Precomputed cases per 100,000 people |

</details> ## Creating a Comparable Metric and Join Key

Before mapping, you need two key components:

1. A metric that adjusts for population size
2. A key that matches the GeoJSON file’s feature.id values

Metric: Use case_density = cases / population * 100000 to normalize case counts per 100,000 people. This makes comparisons between regions meaningful.

Join key: The state_code in your DataFrame must be in string format to match the GeoJSON features. This ensures regions display correctly on the map.

Example

df["case_density"] = (df["cases"] / df["population"]) * 100000
df["state_code"] = df["state_code"].astype(str)
``` ## Centering the Map with Folium

To build your choropleth, you'll first create a base map using `folium.Map()`. This initializes a map centered at a given location with a set zoom level, acting as the background for your data layers.

### Key Concepts

* Use `folium.Map(location=[latitude, longitude], zoom_start=value)` to define where your map starts and how zoomed in it is.
* `location` takes a list of two numbers: `[latitude, longitude]`
* Assign the result to a variable (like `map_object`) so you can add layers later

### Example

import folium

map_object = folium.Map(location=[00.0, -00.0], zoom_start=5)

This creates a blank interactive map centered at `[0.0, 0.0]` with a medium zoom level.
 ## Drawing a Basic Choropleth

Now that your map is centered, it's time to shade each region based on Covid-19 case density. A **choropleth** visually represents data values by coloring geographic areas.

To do this, you'll use `folium.Choropleth()`, which joins your data with a GeoJSON and renders regions using a color scale.

### Key Concepts

* `geo_data`: the GeoJSON file containing region shapes
* `data`: the DataFrame with the metric you want to visualize
* `columns`: two columns — the join key and the metric column
* `key_on`: the GeoJSON property to match (typically `"feature.id"`)

This task uses **default styling**. You’ll customize the colors and interactivity later.

### Example

folium.Choropleth( geo_data=geojson_object, data=dataframe, columns=["id_column", "value_column"], key_on="feature.id" ).add_to(map_object)

Dataset Properties

| Column | Description | | -------------- | ------------------------------------------ | | region_code | Integer-based FIPS-style region identifier | | region_name | Full name of the state (e.g., California) | | cases | Total case count | | population | Total population | | case_density | Precomputed cases per 100,000 people |

</details> ## Applying a Custom Color Scale and Bins

Your initial choropleth works, but the default styling may not clearly communicate value differences. You can improve clarity by setting a color palette and value bins using additional parameters in folium.Choropleth().

Key Concepts

• fill_color: sets the color scheme (e.g., "YlOrRd", "Blues", "Greens"). These are based on ColorBrewer palettes.
• threshold_scale: lets you define value ranges (bins) for coloring. For example, [0, 1000, 2000, 3000] would group values into 3+ ranges.

When you define bins, each region’s color reflects which range its value falls into.

Example

folium.Choropleth(
    geo_data=geojson_object,
    data=dataframe,
    columns=["id_column", "value_column"],
    key_on="feature.id",
    fill_color="Blues",
    threshold_scale=[0, 10, 20, 30, 40]
).add_to(map_object)

This assigns color shades based on defined value bins. ## Adding a Basic Map Legend

Choropleth maps use color to communicate data, but without a legend, your audience won’t know what those colors mean. Since Folium doesn’t automatically generate legends, we’ll add a simple HTML-based legend manually.

This legend doesn’t need to be styled elaborately, just enough to show what each color represents in terms of case density ranges.

Key Concepts

• Create an HTML <div> with labels that match the threshold_scale bins.
• Use folium.Element() to turn the HTML into something you can add to the map.
• Use map_object.get_root().html.add_child(...) to attach it.

This introduces the concept of custom elements without requiring deep CSS or DOM knowledge.

Example

legend_html = """
<div style="position: fixed; bottom: 30px; left: 30px; background-color: white; padding: 10px; border:1px solid black;">
  <strong>Cases per 100k</strong><br>
  22000–26000<br>
  26000–30000<br>
  ...
</div>
"""

map_object.get_root().html.add_child(folium.Element(legend_html))

Dataset Properties

| Column | Description | | -------------- | ------------------------------------------ | | region_code | Integer-based FIPS-style region identifier | | region_name | Full name of the state (e.g., California) | | cases | Total case count | | population | Total population | | case_density | Precomputed cases per 100,000 people |

</details> ## Adding Hover Tooltips with Folium

Tooltips appear when the user hovers over a region on the map. Folium allows you to attach tooltips using folium.GeoJsonTooltip, but only for fields that exist within your GeoJSON file — not your DataFrame.

In your case, the GeoJSON contains a single property named "name" for each region.

Key Concepts

• folium.GeoJson: renders a set of geographic shapes from a GeoJSON file
• tooltip: used to attach a GeoJsonTooltip, showing property values from the GeoJSON
• You can only reference fields that exist in the "properties" of the GeoJSON

Example

folium.GeoJson(
    data=geojson_object,
    tooltip=folium.GeoJsonTooltip(
        fields=["name"],
        aliases=["Region:"]
    )
).add_to(map_object)

Adding Clickable Pop-ups with Region Metrics

You’ve already added hoverable tooltips based on GeoJSON fields. Now you’ll make your map interactive on click — by showing actual Covid-19 metrics from your dataset.

To do this, you’ll inject your DataFrame values into each region’s GeoJSON entry, so they can be accessed by Folium’s pop-up system.

What You’re Doing in This Task

• Match each region in your GeoJSON ("name") to your dataset’s region_name
• Copy over values from your DataFrame: cases, population, case_density
• Add those values to the "properties" section of each region
• Display those values with folium.GeoJsonPopup

{
  "properties": {
    "name": "Alabama"
  }
}

feature["properties"]["name"] == row["region_name"]

Your map now shows values like case count and population when a region is clicked. But the numbers might look raw or overwhelming — especially large values with no commas or unclear labels.

This task helps you polish the output using simple formatting options built into folium.GeoJsonPopup.

Key Concepts

• localize=True adds thousands separators to large numbers
• labels=True makes the output look like a labeled key-value table
• style allows you to apply inline CSS (like font size or width)

These changes make the pop-up easier to scan and more professional in appearance.

Example

popup = folium.GeoJsonPopup(
    fields=["cases", "population", "case_density"],
    aliases=["Total cases:", "Population:", "Case Density:"],
    localize=True,
    labels=True,
    style="font-size: 14px;"
)

Dataset Properties

| Column | Description | | -------------- | ------------------------------------------ | | region_code | Integer-based FIPS-style region identifier | | region_name | Full name of the state (e.g., California) | | cases | Total case count | | population | Total population | | case_density | Precomputed cases per 100,000 people |

</details> ## Creating Custom Bins and Color Scales

You now have a working choropleth, but it still uses automatic binning — which can make your data appear skewed or flatten important patterns. In this task, you'll apply custom bin edges and a color palette that you choose, using values derived from your actual case density range.

This gives you full control over how your data is grouped and represented visually.

Key Concepts

• threshold_scale lets you set manual bins for data classification.
• fill_color controls the color palette.
• The highest bin should be greater than the maximum value in your data.
• Your data’s join key must match the GeoJSON’s feature.id.

columns=["state_code", "case_density"]

[22000, 26000, 30000, 34000, 38000, 42000, 46000]

The color gradient bar Folium generates isn’t always easy to interpret — especially when you’ve created your own bins. Instead, you can create a custom HTML-based legend that clearly shows each bin range and ties it to the color scale you used.

This improves readability and makes your map feel more complete and professional.

Key Concepts

• Folium doesn’t automatically create labeled bin legends
• You can manually create a legend_html string with HTML
• Use folium.Element(...) and .get_root().html.add_child(...) to add the legend to the map
• Make sure the bin ranges in the legend match your threshold_scale

Dataset Properties

| Column | Description | | -------------- | ------------------------------------------ | | region_code | Integer-based FIPS-style region identifier | | region_name | Full name of the state (e.g., California) | | cases | Total case count | | population | Total population | | case_density | Precomputed cases per 100,000 people |

</details> ## Adding a Title to the Map with HTML

Maps are much more effective when they’re clearly labeled. In this task, you’ll add a title directly to your map using a small HTML snippet.

While Folium doesn’t have a built-in method for titles, you can inject any HTML using folium.Element and attach it to the map’s root.

Key Concepts

• The Folium map object supports raw HTML injection
• You can create a string with basic HTML (e.g., <h3>...</h3>)
• Use covid_map.get_root().html.add_child(...) to attach it
• Style the element with CSS if desired — or keep it simple

Example

title_html = "<h3>Covid-19 Case Density by State</h3>"
covid_map.get_root().html.add_child(folium.Element(title_html))

This will insert the title into the rendered HTML just above the map. ## Highlighting Groups of Regions Using Statistical Filters

Now that you’ve computed the mean and median case densities, you can use those values to identify groups of regions and create new visual layers on the map.

This lets users explore patterns by toggling overlays like:

• States close to the average case rate
• The exact median state
• Other groupings based on thresholds or rankings (coming next)

How to Filter a DataFrame by Value

You can use conditional logic to return only certain rows from a DataFrame.

Filter for exact values

median_density = df["case_density"].median()
subset = df[df["case_density"] == median_density]

This returns rows where case_density is exactly equal to the median.

Filter for a value range

You can also create a range using greater-than and less-than conditions combined with &:

mean_density = df["case_density"].mean()
subset = df[
    (df["case_density"] >= mean_density - 500) &
    (df["case_density"] <= mean_density + 500)
]

This returns states whose case densities fall within ±500 of the mean.

How to Create a Layer Group for Filtered States

Once you’ve identified the group of states you want to show, use their state_code to match against your GeoJSON data.

Then, create a folium.FeatureGroup, add a GeoJson layer to it, and use a custom style_function that highlights only those states:

highlighted = set(filtered_df["state_code"])

folium.FeatureGroup(name="Group Name")
folium.GeoJson(
    geo_data,
    style_function=lambda feature: {
        "fillColor": "blue" if feature["id"] in highlighted else "transparent",
        "color": "blue" if feature["id"] in highlighted else "transparent",
        "fillOpacity": 0.5 if feature["id"] in highlighted else 0,
        "weight": 2
    }
)
``` ## Find and Display the Top and Bottom 5 States by Case Density

To understand which regions are most and least affected, you’ll extract the top and bottom five states based on their case density values.

This task uses two useful pandas methods:

### `.nlargest(n, "column")`

Returns the top `n` rows sorted by the specified column in **descending** order:

```python
df.nlargest(5, "case_density")

This gives you the 5 states with the highest case rates.

.nsmallest(n, "column")

Returns the bottom n rows sorted in ascending order:

df.nsmallest(5, "case_density")

This gives you the 5 states with the lowest case rates.

Each returns a new DataFrame — so you can inspect, display, or use them in further filtering and mapping.