Forem: Jan Tschada

How We Built a Geospatial AI That Reads Satellite Images

Jan Tschada — Thu, 30 Apr 2026 04:08:27 +0000

A developer’s guide to analyze_image, analyze_text, and the future of location intelligence.

The motivation

You’re a developer. You know that satellite imagery is everywhere. But most GeoAI solutions are either:

Black‑box desktop tools with 500 buttons
Intelligence‑grade surveillance systems you’d never touch
Overhyped pixel classifiers that can’t tell a port from a parking lot

We wanted something different:

A code‑first, ethical, and actually useful geospatial AI that runs in a Jupyter notebook.

So we built it with:

arcgis.ai.analyze_image – to read satellite photos
arcgis.ai.analyze_text – to write structured reports

A few dozen lines of Python, and ArcGIS Location Platform (beta AI)

No mouse clicks. Just code.

In this post, I’ll show you exactly how it works – including real snippets from our platform.py – so you can steal the ideas (or the whole notebook) for your own projects.

The Core Idea (Super Simple)

User pans a map to any location.
We export that exact view as a georeferenced PNG.
We send the image + a strict, no‑speculation prompt to our beta AI endpoint using analyze_image.
The AI returns a natural‑language description.
We feed that description + location data into analyze_text with a report template.
Out comes a clean Markdown report (Location, Features, Patterns, Risks, Assessment).

That’s it. No complex pipelines. No training custom models. Just clever prompting and two AI functions.

The Code You Actually Care About

Our entire workflow is in platform.py. Let me walk you through the juicy parts.

Export a map image (no screenshot hacks)

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

def export_map(map_view) -> ExportedMapImage:
    bbox = f"{map_view.extent['xmin']},{map_view.extent['ymin']},{map_view.extent['xmax']},{map_view.extent['ymax']}"
    bbox_sr = map_view.extent['spatialReference']['wkid']
    map_layer = MapImageLayer("https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer")
    return ExportedMapImage(
        map_export_result=map_layer.export_map(bbox=bbox, bbox_sr=bbox_sr, image_format="png"),
        bbox=bbox, bbox_sr=bbox_sr
    )

Why this is cool:

The exported image is georeferenced, so we know exactly which coordinates each pixel covers. That means we can later tell the AI: "You’re looking at 25.02° N, 55.04° E – the Port of Jebel Ali."

Download image bytes (streaming, memory‑efficient)

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

def download_bytes(url, timeout=10):
    response = requests.get(url, stream=True, timeout=timeout)
    response.raise_for_status()
    file_bytes = io.BytesIO()
    for chunk in response.iter_content(chunk_size=8192):
        if chunk:
            file_bytes.write(chunk)
    file_bytes.seek(0)
    return file_bytes

Nothing fancy, but it’s solid. We stream the image in 8KB chunks so we don’t blow up memory on huge exports.

Reverse geocode the image center

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

gps_extent = project([exported_image.map_export_result["extent"]], in_sr=bbox_sr, out_sr=4326)[0]
[xmin, ymin, xmax, ymax] = gps_extent.coordinates()
gps_lon = xmin + 0.5 * (xmax - xmin)
gps_lat = ymin + 0.5 * (ymax - ymin)

geocoding_result = reverse_geocode({"x": gps_lon, "y": gps_lat, "spatialReference": {"wkid": 4326}}, lang_code="EN")
address = geocoding_result.get("address")

Now we have a human‑readable address (e.g., "Port of Jebel Ali, Dubai, UAE") to feed into the AI prompts.

The secret sauce: a disciplined prompt for analyze_image

This is where most people mess up. They ask, "Tell me everything about this place." Then the AI hallucinates.

We do the opposite:

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

ai_prompt = f"""
    You are a geospatial imagery analyst.
    Analyze the satellite image using only visible evidence.
    State uncertainty explicitly. Do not speculate.

    Location: {gps_lat}, {gps_lon}
    {address.get('LongLabel') if address else ''}
"""

The rules:

Only what you see
If unsure, say so
No guessing

This dramatically reduces hallucinations. The AI will say "I see what looks like a port, but I cannot confirm the exact type" instead of inventing a naval base.

Call analyze_image

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

image_base64 = f"data:image/png;base64,{base64.b64encode(image_bytes.getvalue()).decode('utf8')}"
analyze_image_result = analyze_image(image=image_base64, prompt=ai_prompt, gis=portal, to_language="EN")

That’s it. One line. The gis instance is your authenticated ArcGIS portal connection.

Generate a structured report with analyze_text

We take the image analysis output and wrap it into a report template.

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

ai_summarize_prompt = f"""
    You are a senior geospatial analyst.
    Create a professional situational analysis report.
    Output MUST be valid Markdown.
    Sections:
    ## Location
    ## Observed Features
    ## Activity & Patterns
    ## Risk & Threat Assessment
    ## Analyst Assessment
    Write concisely, analytically.
"""

intel_data = {
    "image_analysis": analyze_image_result.results,
    "location": {"latitude": gps_lat, "longitude": gps_lon, "address": address}
}

analyze_text_result = analyze_text(text=str(intel_data), prompt=ai_summarize_prompt, gis=portal, to_language="EN")

Boom. The second AI reorganises the raw description into a clean, sectioned report. No manual parsing required.

Here’s what the AI actually produced for one of our test ports:

Situational Analysis Report - Date 2026-04-20T10:15:32

Location

Geocoordinates: 25.0137 N, 55.0743 E
Identified Site: Mena Jabal Ali, Dubai, United Arab Emirates
Area Overview: Situated in the Jebel Ali district of Dubai, encompassing significant coastal, urban, and artificial landforms.

Observed Features

Prominent artificial island resembling a palm tree (Palm Jebel Ali).

Urban coastal infrastructure comprising dense road networks, residential zones, and potential industrial facilities.

Multiple marinas and docks located along the shoreline, enhancing maritime accessibility.

Visible boundaries distinguishing developed urban tracts from adjacent desert areas.

Pockets of sparse vegetation and undeveloped open land interspersed throughout the region.

Activity & Patterns

Extensive urban development and engineered expansions, typified by the artificial island and substantial coastal modification, suggest large-scale planning and ongoing construction activity.

The presence of marinas and docks points to active maritime transit and probable commercial shipping or recreational boating.

The orderly distribution of residential and industrial areas implies strategic urban zoning.

Noticeable demarcations between green/open land and developed sectors reflect active land management and expansion.

Risk & Threat Assessment

The concentration of critical urban and maritime infrastructure in a narrow coastal corridor increases vulnerability to natural hazards (e.g., sea-level rise, storms) and potential deliberate disruptions.

High-profile artificial landforms may attract heightened attention and pose elevated operational and maintenance risks.

The juxtaposition of industrial, residential, and transport nodes requires robust monitoring to mitigate economic or environmental threats.

Analyst Assessment

Palm Jebel Ali and the surrounding Jebel Ali area represent a nexus of strategic urban expansion, maritime operations, and infrastructural development within Dubai. The imagery confirms sustained investment in coastal engineering and the diversification of land use.

While the overall stability of the site appears high, continued monitoring is recommended to track further urban growth, shifting coastal dynamics, and associated risk profiles, given the region’s prominence and developmental trajectory.

Further detail regarding specific facility functions, population density, or economic assets is not ascertainable from imagery alone.

What’s Coming Next (Roadmap – and we need your help)

Our current version only looks at the image. But an image doesn’t tell you everything.

We plan to integrate:

OpenStreetMap – roads, building footprints, land use, ports
Wikidata – facts about the place (population, founding year, official name)

Then we’ll feed that structured data into analyze_text alongside the image analysis. Imagine the AI saying:

"I see a large building. OSM says it’s a hospital. Wikidata tells me it was built in 1985 and has 200 beds."

That’s real context‑aware geospatial AI.

We’d love your input:

Which OSM tags are most valuable for your use cases?
How would you improve the prompt to reduce hallucinations further?
Would you use this in production? Why / why not?

We’re not building a black‑box image intelligence tool. We’re building an open, ethical, developer‑friendly geospatial AI.

If that resonates with you:

Comment below with your craziest geospatial AI idea
Share this post with one colleague who might find it useful

Let’s make geospatial intelligence accessible to every developer.

Spatial Data Science: A New Way to Solve Problems

Jan Tschada — Fri, 17 Oct 2025 06:26:41 +0000

Welcome to the world of Spatial Data Science in ArcGIS! In this section, we’re going to explore a simple but powerful idea: thinking about where things happen can help us solve some of our most complex challenges.

It All Starts with a Question

At the heart of this approach is something we call "The Geographic Approach." This is just a fancy way of saying we start with the problem itself, not with a specific tool or piece of software. It’s a mindset that encourages us to ask the right questions about location, such as:

📍 Where is it happening? (For example, where are the traffic accidents concentrated?)

⁉️ Why is it happening there? (What is it about those specific intersections that makes them dangerous?)

🗺️ What’s nearby? (Are the accidents close to schools, bars, or major highways?)

❓ How is it changing? (Is the problem getting better or worse over time?)

By starting with these simple questions, we can begin to see the world in a new way.

Spatial Analysis: The Language of Location

When we use maps and data to answer these "where" questions, we are doing spatial analysis. Think of it as learning a new language—the language of location. This language helps us uncover hidden patterns, relationships, and trends that we might completely miss if we just looked at spreadsheets or lists.

Whether we're planning a new park, monitoring the health of a forest, or figuring out the best location for a new store, geography provides the essential context. It connects the dots and tells the full story.

Keep an eye out for our next section, where we’ll share real-world examples, live demos, and step-by-step guides that show how we bring data to life using ArcGIS. You’ll see just how powerful it can be to ask, "Where?"

📍Location
🎬 Technical Session

Mapping the geospatial patterns of broadcasted news

Jan Tschada — Fri, 19 May 2023 16:53:15 +0000

Mapping the geospatial patterns of broadcasted news allows a geospatial analyst to gain insights into common and unusual geospatial patterns. We decided using one of the most comprehensive news collection named "Global Database Events of Tone and Language" (GDELT) as the ground truth.

The geography of worldwide news coverage

Understanding the geospatial patterns of such a massive knowledge graph is often difficult for non geospatial experts. The machine learning algorithms extract articles and features from websites in real-time. The geocoding engine matches extracted locations against over eleven million well-known place names. An article mentioning a place like "New York" leads to an extracted feature location. But, the article does not have to be specific about the named location. For instance, an article regarding "The impact of the COVID pandemic on capital markets." — mentioning "New York is no exception" — leads to a location match. We should expect some false positives, but the sum of all extracted locations should reflect a geospatial pattern and give us a coarse-grained overview.

Accessing the geospatial features using the geoprotests API

The geoprotests API offer ready-to-use geospatial features representing broadcasted news related to protests and demonstrations. You can use these geospatial features to build various mapping and geospatial applications.

Every geospatial result support the GeoJSON and Esri FeatureSet format out of the box. All endpoints support an optional date parameter for filtering the results. For best performance, the serverless cloud-backend calculate the geospatial aggregations of the last 24 hours between midnight and 1 AM. The serverless functions save these geospatial features and yesterday should be the latest available date. Without specifying a date, we calculate the geospatial features of the last 24 hours on-the-fly.

Ramp up your development environment

You need to activate your Rapid API account. Please, check out the RapidAPI Account Creation and Management Guide for more details.

Setup your Python based development environment using your weapon of choice. Using pip creating a virtual environment is one simple approach.

python -m venv geoint

# Linux
source geoint/bin/activate

# Windows
geoint/Scripts/activate

The Python module requests offers easy and elegant access to http functions. You need to install this module using pip.

pip install requests

Accessing the broadcasted news of 31th December 2022

The hotspot endpoint offers access to statistically significant named locations. The count of news mentioning these locations define the degree of significance.

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

url = 'https://geoprotests.p.rapidapi.com/hotspots'

querystring = {
  'date': '2022-12-31',
  'format': 'geojson'
}

# Authenticate: https://rapidapi.com/auth
api_key = '<SIGN-UP-FOR-KEY>'
headers = {
  'x-rapidapi-host': 'geoprotests.p.rapidapi.com',
  'x-rapidapi-key': api_key
}

geojson_response = requests.request('GET', url, headers=headers, params=querystring)
geojson_response.raise_for_status()
features = geojson_response.json()

The features dictionary represents the named locations in GeoJSON format.

{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "id": 41415,
      "geometry": {
        "type": "Point",
        "coordinates": [
          37.6156,
          55.7522
        ]
      },
      "properties": {
        "OBJECTID": 41415,
        "name": "Moscow, Moskva, Russia",
        "timestamp": "2022-12-31T00:00:00",
        "count": 77
      }
    }
  ]
}

Accessing the aggregated broadcasted news

The spatial aggregations are hexagonal geospatial features having a specific property representing the count of the news mentioning a location being within a hexagonal grid cell. Spatial analyst's use mapping capabilities visualizing hot and cold spots of these spatial aggregations.

Let us use the powerful mapping capabilities of ArcGIS and visualize the aggregated broadcasted news as a feature set. You need to specify the output format to esri.

# author: Jan Tschada
# SPDX-License-Identifer: Apache-2.0
url = 'https://geoprotests.p.rapidapi.com/aggregate'

querystring = {
  'date': '2022-12-31',
  'format': 'esri'
}

headers = {
  'x-rapidapi-host': 'geoprotests.p.rapidapi.com',
  'x-rapidapi-key': api_key
}

esri_response = requests.request('GET', url, headers=headers, params=querystring)
esri_response.raise_for_status()
aggregated_features = esri_response.json()

The aggregated features represent the corresponding hexagonal grid cells as a Python dictionary. You need to setup the arcgis Python Module into your development environment. The contained map widget offers powerful mapping capabilities for your Jupyter Notebook environment. Follow the Install and Setup Guide.

# author: Jan Tschada
# SPDX-License-Identifer: Apache-2.0
from arcgis.gis import GIS
from arcgis.features import FeatureSet

# Create a FeatureSet from the features
aggregated_featureset = FeatureSet.from_dict(aggregated_features)

# Anonousmly connect to ArcGIS Online
gis = GIS()

# Create a simple map view
map_view = gis.map('Europe')

# Add the FeatureSet as a layer
map_view.add_layer(aggregated_featureset)

You should tweak the rendering of the features using a dedicated renderer instance. The renderer is an optional parameter of the add_layer method. But, you could also use a different approach for mapping the aggregated features. The spatial-enabled dataframe offers plotting capabilities in combination with the map view. So that you can easily define rendering supporting natural class breaks.

# Create a simple map view
map_view = gis.map('Europe')

# Add the FeatureSet as a layer
aggregated_featureset.sdf.spatial.plot(map_view, 
                                      renderer_type='c',
                                      method='esriClassifyNaturalBreaks',
                                      class_count=5, 
                                      col='count', 
                                      cmap='YlOrRd',
                                      alpha=0.35)

The produced map shows the hotspot in red being Moscow, Russia with a mention count of 77, as we expected.

Any feedback is welcome, keep on mapping!

Feel free to try it out: geoprotests API.