In Kampala, the rhythmic hum of boda bodas (motorbike taxis) is the heartbeat of the city. In 2020 and 2021, these two-wheeled lifelines carried more than just passengers-they carried AirQo mobile sensors, silently collecting vital information about the air we breathe.

As these boda bodas weaved through traffic, neighborhoods, and market streets, they gathered real-time PM2.5 air quality data, painting a detailed picture of pollution across space and time. But raw mobile data alone tells only part of the story. To truly understand the environment, we needed context-and that’s where our stationary AirQo monitors stepped in.

We use Python to combine these two data sources-mobile and stationary air quality measurements-using exact timestamp matching and geospatial distance.

Why Use Boda Boda-Mounted Sensors?

AirQo’s mobile sensors, when mounted on Kampala’s boda bodas, provide:

High-resolution spatial coverage of air quality,
Data from hard-to-reach urban corners where stationary sensors can't be placed,
A glimpse into the actual exposure levels experienced by everyday citizens.

However, these sensors are on the move. They don’t carry weather instruments, and without context (like temperature or wind conditions), the data can be incomplete.

The Role of Stationary AirQo Sensors

Deployed across Kampala, AirQo’s stationary monitors provide:

Stable, hourly PM2.5 readings,
Meteorological data: temperature, humidity, wind speed, wind direction, and precipitation, are integrated using nearest meteorological station.
Reliable baselines for comparing pollution hotspots.

Merging the Two Worlds: The Fusion Approach

To enrich mobile readings, we built a script that:

Matches mobile readings to stationary monitor data by exact timestamp.
Calculates the distance between each boda-based reading and all available stationary sensors at that moment.
Attaches the closest stationary monitor’s data to the mobile reading—adding valuable context.

Behind the Scenes: How the Code Works

1. Distance Calculation (Haversine Formula)

To identify the nearest stationary monitor, we used the Haversine formula:

This calculates the shortest distance over the Earth’s surface between two points-ideal for finding the nearest AirQo station to each boda boda reading.

2. Timestamp Matching and Data Assignment

For every mobile reading, the code:

Finds stationary readings recorded at the same timestamp.
Calculates the distance to all of them.
Attaches data from the nearest one: PM2.5, temperature, humidity, wind, and even precipitation.

import numpy as np
import pandas as pd
from math import radians, cos, sin, sqrt, atan2
import pytz

# Haversine formula to calculate distance between two lat/lon points (in kilometers)
def haversine(lat1, lon1, lat2, lon2):
    R = 6371.0  # Earth's radius in kilometers
    lat1, lon1, lat2, lon2 = map(radians, [lat1, lon1, lat2, lon2])
    dlat = lat2 - lat1
    dlon = lon2 - lon1
    a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2
    c = 2 * atan2(sqrt(a), sqrt(1 - a))
    distance = R * c
    return distance

# Function to assign stationary data to mobile readings with exact timestamp matching
def assign_stationary_data_with_time_match(mobile_df, stationary_df):
    # Ensure timestamps are in datetime format
    mobile_df['timestamp'] = pd.to_datetime(mobile_df['timestamp'])
    stationary_df['timestamp'] = pd.to_datetime(stationary_df['timestamp'])

    # Initialize columns for new data
    mobile_df['temperature'] = np.nan
    mobile_df['wind_speed'] = np.nan
    mobile_df['wind_direction'] = np.nan
    mobile_df['stationary_calibrated_pm_25'] = np.nan
    mobile_df['stationary_raw_pm_25'] = np.nan
    mobile_df['nearest_site_name'] = None
    mobile_df['nearest_site_id'] = None
    mobile_df['distance_to_nearest_device_km'] = np.nan  # 👈 New column

    # List to track rows to keep (those with matching timestamps)
    valid_indices = []

    # Iterate over each mobile reading
    for idx, mobile_row in mobile_df.iterrows():
        mobile_lat = mobile_row['latitude']
        mobile_lon = mobile_row['longitude']
        mobile_time = mobile_row['timestamp']

        # Filter stationary monitors with exact same timestamp
        matching_stations = stationary_df[stationary_df['timestamp'] == mobile_time]

        if not matching_stations.empty:
            # Calculate distances to matching stationary monitors
            distances = matching_stations.apply(
                lambda row: haversine(mobile_lat, mobile_lon, row['site_latitude'], row['site_longitude']),
                axis=1
            )

            # Find the closest stationary monitor
            closest_idx = distances.idxmin()
            closest_distance = distances[closest_idx]

            # Assign the corresponding data
            mobile_df.at[idx, 'temperature'] = matching_stations.at[closest_idx, 'temperature']
            mobile_df.at[idx, 'humidity'] = matching_stations.at[closest_idx, 'humidity']
            mobile_df.at[idx, 'humidity'] = matching_stations.at[closest_idx, 'humidity']
            mobile_df.at[idx, 'wind_speed'] = matching_stations.at[closest_idx, 'wind_speed']
            mobile_df.at[idx, 'wind_direction'] = matching_stations.at[closest_idx, 'wind_direction']
            mobile_df.at[idx, 'precipitation'] = matching_stations.at[closest_idx, 'precipitation']
            mobile_df.at[idx, 'stationary_calibrated_pm_25'] = matching_stations.at[closest_idx, 'pm2_5_calibrated_value']
            mobile_df.at[idx, 'stationary_raw_pm_25'] = matching_stations.at[closest_idx, 'pm2_5_raw_value']
            mobile_df.at[idx, 'nearest_site_name'] = matching_stations.at[closest_idx, 'site_name']
            mobile_df.at[idx, 'nearest_site_id'] = matching_stations.at[closest_idx, 'site_id']
            mobile_df.at[idx, 'distance_to_nearest_device_km'] = closest_distance

            # Mark this row as valid
            valid_indices.append(idx)

    # Keep only rows with matching timestamps
    mobile_df = mobile_df.loc[valid_indices].reset_index(drop=True)

    return mobile_df

# Example usage
if __name__ == "__main__":
    # Mobile data
    mobile_data = pd.read_csv('/content/transformed_mobile_data.csv')

    # Stationary data
    stationary_data = pd.read_csv('/content/drive/MyDrive/DICE PROJECT: Aim 2 PIs Folder/Data Set/PM data/2020/Kampala_2020_sites_dataset.csv')
    stationary_data['timestamp'] = pd.to_datetime(stationary_data['timestamp']).dt.floor('h').dt.tz_localize(None)

    # Assign stationary data and drop non-matching rows
    result = assign_stationary_data_with_time_match(mobile_data, stationary_data)

    # Save the result
    result.to_csv("stationary_mobile_transfomed_data_2020.csv", index=False)

    # Display output summary
    print("Mobile Data with Assigned Stationary Data and Distance (Matching Timestamps Only):")
    print(result.head())

What's Next?

This is just the beginning. With this enriched dataset:

Researchers can train AI models for pollution forecasting.
Planners can target interventions in high-exposure zones.
Citizens can gain access to localized air quality information where they live, work, and move.

We’re excited about what’s next for AirQo, Kampala, and Africa’s smart cities.

Enhancing Mobile Air Quality Readings Using Stationary Sensor Data: A Distance-Aware Matching Approach in Python

Overview

Details

Enhancing Mobile Air Quality Readings Using Stationary Sensor Data: A Distance-Aware Matching Approach in Python

Overview

Details