DEV Community

Jan Tschada
Jan Tschada

Posted on

From Traffic Accidents to AI Agents: Building Spatial Decision Intelligence with Python

#ai #python #geospatial

How geospatial analytics, simulation, and AI come together to help us understand not just predict our cities

The Problem: AI That Doesn't Understand Space

We're in the middle of an AI agent renaissance. Models can reason, plan, invoke tools, and coordinate complex workflows. Yet when these conversations move from impressive demos to real-world operations, a different challenge emerges.

The question is no longer whether an AI agent can perform a task. The more interesting question is whether it can understand the environment in which a decision must be made.

Cities don't operate as collections of independent systems. Mobility, infrastructure, weather, energy, public transportation, construction projects, and human behavior constantly interact. Understanding these interactions requires more than access to data; it requires context. And in many cases, that context is fundamentally geographic.

This became clear while exploring an Urban Digital Twin scenario for Frankfurt am Main. What started as a straightforward investigation into how geospatial analytics, simulation, and AI could work together revealed something much broader: before an AI agent can support meaningful decisions, it must first understand the spatial relationships that shape how a city functions.

Let me walk you through the approach and the Python code that made it possible, drawn directly from the Spatial Data Science Examples repository.

Step 1: Setting Up Your GIS Environment

First, connect to your GIS portal using ArcGIS API for Python. The notebook uses environment variables to keep credentials secure:

# author: Jan Tschada
# SPDX-License-Identifer: Apache-2.0

from arcgis.gis import GIS
from arcgis.features import Feature, FeatureSet
from arcgis.geometry import Envelope, Point
from datetime import datetime
import os
import pandas as pd
from dotenv import load_dotenv

# Load environment variables
def load_vars():
    load_dotenv(dotenv_path="../../../../.env", override=True)
    return (
        os.getenv("ARCGIS_API_KEY"),
        os.getenv("TRAFFIC_ACCIDENTS_FEATURES"),
        os.getenv("TRAFFIC_DATA_FILE"),
        os.getenv("TRAFFIC_FEATURES"),
        os.getenv("NETWORK_DATASET"),
        os.getenv("ELECTRIC_CAR_FEATURES")
    )

api_key, traffic_accidents_path, traffic_data_path, traffic_features_path, network_dataset_path, electric_car_path = load_vars()

# Connect to your GIS
gis = GIS(api_key=api_key)
Enter fullscreen mode Exit fullscreen mode

Note: Make sure you have a .env file in your project root with your ARCGIS_API_KEY and other data paths.

Step 2: Visualizing the Area of Interest

Before diving into analysis, it's helpful to visualize your study area. The repository includes helper functions to create interactive maps:

# author: Jan Tschada
# SPDX-License-Identifer: Apache-2.0

from urban_traffic.utils import create_traffic_map, create_map

# Create a traffic-focused map view
traffic_map_view = create_traffic_map(gis)
traffic_map_view

# Or create a map centered on a specific location
map_view = create_map(gis, location="Frankenallee 355, Frankfurt am Main, Germany")
map_view
Enter fullscreen mode Exit fullscreen mode

Step 3: Loading and Preparing Traffic Data

The real work begins with loading traffic data. Here's how the notebook fetches and prepares traffic features:

# author: Jan Tschada
# SPDX-License-Identifer: Apache-2.0

from data_engineering.utils import (
    fetch_charging_stations,
    fetch_hotcold_features,
    fetch_hottest_features_by_extent,
    fetch_traffic_accidents,
    get_hotcold_layer,
    get_live_traffic_item
)
from urban_traffic.utils import (
    fetch_traffic_data,
    filter_commute_cars,
    generate_car_renderer,
    generate_routes_renderer,
    prepare_traffic,
    prepare_traffic_accidents,
    read_traffic_accidents_features_by_extent,
    read_traffic_features
)

# Fetch traffic features
traffic_features = read_traffic_features(gis, traffic_features_path)

# Filter for commute cars (cars used for commuting)
commute_cars = filter_commute_cars(traffic_features.copy())
commute_cars.head()
Enter fullscreen mode Exit fullscreen mode

The commute_cars DataFrame contains columns like trip, person, hour, minute, second, bike, car, and pedestrian allowing you to filter and analyze different types of road users.

Step 4: Visualizing Traffic Patterns

You can visualize the filtered traffic data directly on a map:

# author: Jan Tschada
# SPDX-License-Identifer: Apache-2.0

# Create a map and plot commute car positions
commute_map_view = create_map(gis)
commute_cars.spatial.plot(
    commute_map_view,
    renderer=generate_car_renderer()
)
commute_map_view.zoom_to_layer(commute_cars)
commute_map_view
Enter fullscreen mode Exit fullscreen mode

Step 5: Identifying Hot and Cold Spots

To understand spatial patterns, the notebook uses hot/cold spot analysis:

# author: Jan Tschada
# SPDX-License-Identifer: Apache-2.0

# Fetch hot and cold spots from the commute car data
hotcold_spots_fset, drawing_info = fetch_hotcold_features(gis, commute_cars)

# Add them to the map with transparency
commute_map_view.content.add(
    hotcold_spots_fset,
    drawing_info=drawing_info,
    options={"opacity": 0.7}
)
Enter fullscreen mode Exit fullscreen mode

What we found: Major transportation corridors exhibited elevated densities; exactly as expected. But other locations repeatedly appeared despite not being particularly prominent within the network. Only after examining additional context surrounding land use, infrastructure layouts, and transit interactions did plausible explanations emerge.

Step 6: Advanced Spatial Analysis: Closest Facility Routing

The notebook demonstrates a powerful use case: finding the closest charging station for electric vehicles. This same logic applies to any "closest facility" problem finding the nearest hospital, police car, or fire station:

# author: Jan Tschada
# SPDX-License-Identifer: Apache-2.0

import arcpy
from arcpy.management import CopyFeatures
from arcpy.na import AddLocations, GetNAClassNames, Solve

arcpy.env.overwriteOutput = True

def create_analysis_layer(charging_stations: pd.DataFrame, car_positions: pd.DataFrame):
    """Create a closest facility analysis layer using a local routing network."""
    analysis_layer_name = "ClosestChargingStation"
    layer_result = arcpy.na.MakeClosestFacilityAnalysisLayer(
        network_dataset_path,
        analysis_layer_name
    )

    # Get the analysis class names ("Facilities", "Incidents", ...)
    analysis_layer = layer_result.getOutput(0)
    analysis_class_names = GetNAClassNames(analysis_layer)

    # Charging stations as facilities
    input_facilities = "memory/facilities"
    charging_stations.spatial.to_featureclass(input_facilities)
    AddLocations(analysis_layer, analysis_class_names["Facilities"], input_facilities)

    # Car positions as incidents
    input_incidents = "memory/incidents"
    car_positions.spatial.to_featureclass(input_incidents)
    AddLocations(analysis_layer, analysis_class_names["Incidents"], input_incidents)

    return analysis_layer

def solve_routing_problem(analysis_layer, nogo_areas: pd.DataFrame = None) -> pd.DataFrame:
    """Solve the routing problem and return the results as a DataFrame."""
    analysis_class_names = GetNAClassNames(analysis_layer)

    if nogo_areas is not None:
        # Add no-go areas as polygon barriers
        input_barriers = "memory/barriers"
        nogo_areas.spatial.to_featureclass(input_barriers)
        AddLocations(analysis_layer, analysis_class_names["PolygonBarriers"], input_barriers)

    # Solve the routing problem
    solve_result = Solve(analysis_layer)

    # Extract the solved routes
    output_routes = "memory/routes"
    CopyFeatures(analysis_class_names["CFRoutes"], output_routes)
    return pd.DataFrame.spatial.from_featureclass(output_routes)
Enter fullscreen mode Exit fullscreen mode

This approach can be adapted to:

  • Find the closest hospital to an accident
  • Dispatch the two closest police cars to a crime scene
  • Find the three closest fire stations within a five-minute drive time

Step 7: The Critical Insight Multi-Indicator Overlay

When you overlay simulated congestion patterns with historical accident hotspots, a crucial pattern emerges: the areas of greatest operational interest are not necessarily the locations with the highest traffic volumes or the highest accident densities.

More significant are locations where multiple indicators begin reinforcing one another. A corridor with increasing traffic pressure may not represent a major concern on its own. An area with elevated accident rates may not require immediate intervention. When both conditions coexist, however, the situation changes. The combination creates a level of operational risk that neither dataset reveals independently.

Here's how you might combine multiple spatial datasets:

# author: Jan Tschada
# SPDX-License-Identifer: Apache-2.0

# Assuming you have accident hotspots and congestion layers
# (These would come from your analysis or simulation)

# Spatial join to find overlap between hotspots and congestion
overlap = gpd.overlay(hotspots, congestion, how="intersection")

# Calculate a composite risk score
overlap['risk_score'] = (
    overlap['accident_density'] * 0.6 + 
    overlap['congestion_level'] * 0.4
)

# Identify high-risk areas
high_risk = overlap[overlap['risk_score'] > overlap['risk_score'].quantile(0.90)]
Enter fullscreen mode Exit fullscreen mode

The "Why" Problem: Explainability in GeoAI

Throughout workshops and discussions, one question appeared repeatedly:

"Why?"

  • Why is this location being highlighted?
  • Why was this corridor identified as critical?
  • Why does this recommendation deserve attention?

The quality of the recommendation was important, but the explanation behind it was often more valuable. Trust depends less on automation than on understanding. Decision-makers need to see the evidence, understand the assumptions, and follow the reasoning process that led to a particular conclusion.

For this reason, the future of GeoAI may have less to do with autonomy than with comprehension.

The most successful systems will not necessarily be those that make decisions on behalf of people. More likely, they will be the systems that help people understand complex situations more quickly, evaluate possible consequences more effectively, and make better informed decisions under uncertainty.

The Takeaway

In a city such as Frankfurt, where every operational challenge ultimately unfolds somewhere, affects someone, and influences something nearby, location becomes far more than another attribute in a dataset.

It becomes the foundation for understanding consequence.

The code snippets above come directly from the Spatial Data Science Examples repository a working implementation of the Urban Digital Twin concept. They illustrate a workflow that moves from raw data to spatial understanding to decision intelligence. And that's exactly the kind of spatial reasoning our AI agents will need if they're going to be truly useful in the real world.

Resources

What's your experience with building spatial reasoning into AI systems? Drop a comment below I'd love to hear how you're approaching this challenge.

Top comments (0)