# 地理编码的基本概念示意
# 正向地理编码：地址 -> 坐标
# "北京市朝阳区望京街道" -> (116.480, 40.002)

# 逆向地理编码：坐标 -> 地址
# (121.474, 31.230) -> "上海市黄浦区南京东路"

# 安装 geopy
# pip install geopy

# 验证安装
import geopy
print(f"geopy 版本: {geopy.__version__}")

# 完整安装命令
# pip install geopandas geopy requests

# 验证所有依赖
import geopandas as gpd
import geopy
from geopy.geocoders import Nominatim

print(f"GeoPandas 版本: {gpd.__version__}")
print(f"geopy 版本: {geopy.__version__}")
print("所有依赖安装成功！")

import geopandas as gpd

# GeoPandas 地理编码接口概览
# 1. 正向地理编码
# gpd.tools.geocode(strings, provider, **kwargs)

# 2. 逆向地理编码
# gpd.tools.reverse_geocode(points, provider, **kwargs)

# 接口调用链路示意
# 用户调用 gpd.tools.geocode()
#   -> 创建 geopy geocoder 实例
#     -> 发送 HTTP 请求到服务提供商 API
#       -> 解析返回的 JSON 结果
#         -> 构建 GeoDataFrame 返回

import geopandas as gpd

# 基本地理编码示例
addresses = [
    "Beijing, China",
    "Shanghai, China",
    "Guangzhou, China"
]

# 使用 Nominatim 提供商进行地理编码
result = gpd.tools.geocode(
    addresses,
    provider="nominatim",
    user_agent="geopandas_tutorial"
)

print(type(result))
print(result)

# 函数签名
# gpd.tools.geocode(
#     strings,      # 地址列表或 Series
#     provider=None, # 服务提供商名称或 geopy geocoder 实例
#     user_agent=None, # 用户代理标识
#     timeout=None,    # 请求超时时间（秒）
#     **kwargs         # 传递给 geopy geocoder 的额外参数
# )

# 参数详解示例
addresses = ["Nanjing, China", "Hangzhou, China"]

# 使用字符串指定提供商
result1 = gpd.tools.geocode(
    strings=addresses,          # 必需：地址列表
    provider="nominatim",       # 提供商名称
    user_agent="my_application", # Nominatim 必需的用户代理
    timeout=10                  # 超时时间10秒
)
print("方式一（字符串提供商）：")
print(result1[["address"]].to_string())

# 使用 geopy geocoder 实例作为提供商
from geopy.geocoders import Nominatim

# 创建自定义 geocoder 实例
geocoder = Nominatim(
    user_agent="geopandas_tutorial",
    timeout=15,
    domain="nominatim.openstreetmap.org"
)

result2 = gpd.tools.geocode(
    strings=addresses,
    provider=geocoder  # 直接传入 geocoder 实例
)
print("方式二（geocoder 实例）：")
print(result2[["address"]].to_string())

import geopandas as gpd

addresses = ["Chengdu, China", "Wuhan, China", "Xi'an, China"]

result = gpd.tools.geocode(
    addresses,
    provider="nominatim",
    user_agent="geopandas_tutorial"
)

# 查看结果结构
print("列名:", result.columns.tolist())
print("数据类型:")
print(result.dtypes)
print(f"\nCRS: {result.crs}")
print(f"行数: {len(result)}")

# 提取坐标信息
result["longitude"] = result.geometry.x
result["latitude"] = result.geometry.y
print("\n坐标信息：")
print(result[["address", "longitude", "latitude"]].to_string())

import geopandas as gpd
from shapely.geometry import Point

# 定义坐标点（经度, 纬度）
points = [
    Point(116.397, 39.908),   # 北京天安门附近
    Point(121.474, 31.230),   # 上海外滩附近
    Point(113.264, 23.129)    # 广州市中心附近
]

# 执行逆地理编码
result = gpd.tools.reverse_geocode(
    points,
    provider="nominatim",
    user_agent="geopandas_tutorial"
)

print(result[["address"]].to_string())

import pandas as pd
import geopandas as gpd
from shapely.geometry import Point

# 模拟 GPS 采集数据
gps_data = pd.DataFrame({
    "device_id": ["GPS_001", "GPS_002", "GPS_003", "GPS_004"],
    "longitude": [116.397, 121.474, 113.264, 104.066],
    "latitude": [39.908, 31.230, 23.129, 30.573],
    "timestamp": [
        "2024-01-15 08:30:00",
        "2024-01-15 09:15:00",
        "2024-01-15 10:00:00",
        "2024-01-15 11:30:00"
    ]
})

# 创建 Point 对象列表
points = [
    Point(row["longitude"], row["latitude"])
    for _, row in gps_data.iterrows()
]

# 逆地理编码获取地址
geocoded = gpd.tools.reverse_geocode(
    points,
    provider="nominatim",
    user_agent="geopandas_tutorial"
)

# 合并原始数据与地理编码结果
gps_data["address"] = geocoded["address"].values
gps_data["geometry"] = geocoded["geometry"].values

print("GPS 数据地理编码结果：")
print(gps_data[["device_id", "longitude", "latitude", "address"]].to_string())

from geopy.geocoders import Nominatim, GoogleV3, ArcGIS
import geopandas as gpd

# 1. Nominatim（免费，基于 OpenStreetMap）
nominatim_geocoder = Nominatim(
    user_agent="my_geocoding_app",
    timeout=10
)

# 2. Google Maps（需要 API Key）
# google_geocoder = GoogleV3(
#     api_key="YOUR_GOOGLE_API_KEY",
#     timeout=10
# )

# 3. ArcGIS（部分功能免费）
arcgis_geocoder = ArcGIS(
    timeout=10
)

# 使用 Nominatim 进行编码
addresses = ["Tokyo, Japan", "Seoul, South Korea"]

result = gpd.tools.geocode(
    addresses,
    provider=nominatim_geocoder
)
print("Nominatim 结果：")
print(result[["address"]].to_string())

# 配置高德地图提供商（国内地址推荐）
# from geopy.geocoders import GaoDe
#
# gaode_geocoder = GaoDe(
#     api_key="YOUR_GAODE_API_KEY",
#     timeout=10
# )
#
# # 使用高德地图进行国内地址编码
# cn_addresses = ["北京市海淀区中关村", "上海市浦东新区陆家嘴"]
# result = gpd.tools.geocode(
#     cn_addresses,
#     provider=gaode_geocoder
# )

# 配置百度地图提供商
# from geopy.geocoders import Baidu
#
# baidu_geocoder = Baidu(
#     api_key="YOUR_BAIDU_API_KEY",
#     timeout=10
# )

import pandas as pd
import geopandas as gpd
import time

# 模拟批量地址数据
address_df = pd.DataFrame({
    "id": range(1, 7),
    "name": ["总部", "分公司A", "分公司B", "仓库", "门店1", "门店2"],
    "address": [
        "Beijing, China",
        "Shanghai, China",
        "Guangzhou, China",
        "Shenzhen, China",
        "Hangzhou, China",
        "Nanjing, China"
    ]
})

# 直接批量编码
result = gpd.tools.geocode(
    address_df["address"].tolist(),
    provider="nominatim",
    user_agent="batch_geocoding_demo",
    timeout=10
)

# 合并结果
address_df["geometry"] = result["geometry"].values
address_df["geocoded_address"] = result["address"].values
address_df["lng"] = result.geometry.x.values
address_df["lat"] = result.geometry.y.values

print("批量编码结果：")
print(address_df[["name", "address", "lng", "lat"]].to_string())

import pandas as pd
import geopandas as gpd
from shapely.geometry import Point

# 批量坐标数据
coord_df = pd.DataFrame({
    "station_id": [f"S{i:03d}" for i in range(1, 6)],
    "longitude": [116.397, 121.474, 113.264, 114.058, 120.153],
    "latitude": [39.908, 31.230, 23.129, 22.543, 30.287]
})

# 创建点列表
points = [
    Point(row["longitude"], row["latitude"])
    for _, row in coord_df.iterrows()
]

# 批量逆地理编码
result = gpd.tools.reverse_geocode(
    points,
    provider="nominatim",
    user_agent="batch_reverse_demo"
)

# 合并结果
coord_df["address"] = result["address"].values
print("批量逆编码结果：")
print(coord_df.to_string())

import pandas as pd
import geopandas as gpd
from shapely.geometry import Point
import time

def geocode_with_progress(addresses, provider="nominatim",
                          user_agent="progress_demo",
                          batch_size=5, delay=1.0):
    """
    带进度监控的批量地理编码

    参数:
        addresses: 地址列表
        provider: 服务提供商
        user_agent: 用户代理
        batch_size: 每批处理数量
        delay: 批次间延迟（秒）
    """
    all_results = []
    total = len(addresses)

    for i in range(0, total, batch_size):
        batch = addresses[i:i + batch_size]
        batch_num = i // batch_size + 1
        total_batches = (total + batch_size - 1) // batch_size

        print(f"处理第 {batch_num}/{total_batches} 批 "
              f"({i+1}-{min(i+batch_size, total)}/{total})")

        try:
            result = gpd.tools.geocode(
                batch,
                provider=provider,
                user_agent=user_agent
            )
            all_results.append(result)
            success = result["geometry"].notna().sum()
            print(f"  成功: {success}/{len(batch)}")
        except Exception as e:
            print(f"  批次编码失败: {e}")

        # 批次间延迟，避免触发限速
        if i + batch_size < total:
            time.sleep(delay)

    # 合并所有结果
    if all_results:
        final_result = pd.concat(all_results, ignore_index=True)
        return gpd.GeoDataFrame(final_result, geometry="geometry")
    return None

# 使用示例
addresses = [
    "Beijing, China", "Shanghai, China",
    "Guangzhou, China", "Shenzhen, China",
    "Chengdu, China", "Wuhan, China",
    "Hangzhou, China", "Nanjing, China"
]

result = geocode_with_progress(addresses, batch_size=3, delay=1.5)
if result is not None:
    print(f"\n总计编码: {len(result)} 条地址")
    print(f"成功率: {result['geometry'].notna().mean():.1%}")

from geopy.exc import (
    GeocoderTimedOut,
    GeocoderServiceError,
    GeocoderQuotaExceeded,
    GeocoderUnavailable
)

# 常见错误示例
print("geopy 常见异常类：")
print("- GeocoderTimedOut: 请求超时")
print("- GeocoderServiceError: 服务端错误")
print("- GeocoderQuotaExceeded: 配额超限")
print("- GeocoderUnavailable: 服务不可用")

import time
import pandas as pd
import geopandas as gpd
from shapely.geometry import Point
from geopy.exc import GeocoderTimedOut, GeocoderServiceError

def safe_geocode_single(address, geocoder, max_retries=3, delay=2.0):
    """
    安全的单条地址编码，带重试机制

    参数:
        address: 地址字符串
        geocoder: geopy geocoder 实例
        max_retries: 最大重试次数
        delay: 重试间隔（秒）

    返回:
        (location, address_str) 或 (None, None)
    """
    for attempt in range(max_retries):
        try:
            location = geocoder.geocode(address, timeout=10)
            if location:
                return (
                    Point(location.longitude, location.latitude),
                    location.address
                )
            else:
                print(f"  地址未找到: {address}")
                return (None, None)
        except GeocoderTimedOut:
            print(f"  超时（第 {attempt+1} 次）: {address}")
            if attempt < max_retries - 1:
                time.sleep(delay * (attempt + 1))  # 递增延迟
        except GeocoderServiceError as e:
            print(f"  服务错误: {e}")
            if attempt < max_retries - 1:
                time.sleep(delay * (attempt + 1))
        except Exception as e:
            print(f"  未知错误: {e}")
            return (None, None)

    print(f"  重试耗尽: {address}")
    return (None, None)


def robust_batch_geocode(addresses, user_agent="robust_demo",
                         max_retries=3):
    """
    健壮的批量地理编码函数
    """
    from geopy.geocoders import Nominatim

    geocoder = Nominatim(user_agent=user_agent, timeout=10)
    results = []

    for i, addr in enumerate(addresses):
        print(f"[{i+1}/{len(addresses)}] 编码: {addr}")
        geom, resolved_addr = safe_geocode_single(
            addr, geocoder, max_retries=max_retries
        )
        results.append({
            "input_address": addr,
            "resolved_address": resolved_addr,
            "geometry": geom,
            "success": geom is not None
        })
        time.sleep(1.1)  # 遵守 Nominatim 限速

    df = pd.DataFrame(results)
    success_count = df["success"].sum()
    print(f"\n编码完成: {success_count}/{len(addresses)} 成功")
    return df

# 使用示例（包含一些可能失败的地址）
test_addresses = [
    "Beijing, China",
    "InvalidAddressXYZ12345",   # 无效地址
    "Shanghai, China"
]

result_df = robust_batch_geocode(test_addresses)
print(result_df[["input_address", "success"]].to_string())

import pandas as pd
import geopandas as gpd
from shapely.geometry import Point, box

def validate_geocoding_results(gdf, expected_bounds=None,
                                address_col="address"):
    """
    验证地理编码结果质量

    参数:
        gdf: 编码结果 GeoDataFrame
        expected_bounds: 预期边界 (minx, miny, maxx, maxy)
        address_col: 地址列名
    """
    report = {}

    # 1. 检查空值
    null_geom = gdf["geometry"].isna().sum()
    report["空几何数量"] = null_geom
    report["编码成功率"] = f"{(1 - null_geom / len(gdf)):.1%}"

    # 2. 检查坐标范围
    valid = gdf[gdf["geometry"].notna()].copy()
    if len(valid) > 0:
        report["经度范围"] = f"[{valid.geometry.x.min():.3f}, {valid.geometry.x.max():.3f}]"
        report["纬度范围"] = f"[{valid.geometry.y.min():.3f}, {valid.geometry.y.max():.3f}]"

    # 3. 边界检查
    if expected_bounds and len(valid) > 0:
        bounds_box = box(*expected_bounds)
        within_bounds = valid.geometry.within(bounds_box).sum()
        report["边界内数量"] = f"{within_bounds}/{len(valid)}"

    # 4. 重复坐标检查（可能表示多个地址解析到同一位置）
    if len(valid) > 0:
        coords = valid.geometry.apply(lambda p: (round(p.x, 5), round(p.y, 5)))
        duplicates = coords.duplicated().sum()
        report["重复坐标数"] = duplicates

    return report

# 使用示例
sample_data = gpd.GeoDataFrame({
    "address": ["Beijing", "Shanghai", "Guangzhou", "Unknown Place"],
    "geometry": [
        Point(116.397, 39.908),
        Point(121.474, 31.230),
        Point(113.264, 23.129),
        None  # 编码失败
    ]
}, crs="EPSG:4326")

# 中国大陆边界范围
china_bounds = (73.0, 18.0, 135.0, 54.0)

report = validate_geocoding_results(sample_data, expected_bounds=china_bounds)
print("编码质量报告：")
for key, value in report.items():
    print(f"  {key}: {value}")

from geopy.geocoders import Nominatim
from geopy.extra.rate_limiter import RateLimiter

# 创建 geocoder 实例
geocoder = Nominatim(user_agent="ratelimit_demo")

# 使用 RateLimiter 包装 geocode 方法
# min_delay_seconds: 每次请求间的最小间隔
geocode_with_limit = RateLimiter(
    geocoder.geocode,
    min_delay_seconds=1.0,    # 最小延迟1秒
    max_retries=3,            # 最大重试次数
    error_wait_seconds=5.0    # 错误后等待时间
)

# 同样适用于逆地理编码
reverse_with_limit = RateLimiter(
    geocoder.reverse,
    min_delay_seconds=1.0,
    max_retries=3,
    error_wait_seconds=5.0
)

# 批量使用 RateLimiter
addresses = ["Beijing, China", "Shanghai, China", "Guangzhou, China"]

results = []
for addr in addresses:
    location = geocode_with_limit(addr)
    if location:
        results.append({
            "address": addr,
            "lat": location.latitude,
            "lng": location.longitude
        })
        print(f"  已编码: {addr} -> ({location.latitude:.3f}, {location.longitude:.3f})")

print(f"\n成功编码 {len(results)}/{len(addresses)} 条")

# 在 pandas apply 中使用 RateLimiter
import pandas as pd

df = pd.DataFrame({
    "city": ["Beijing, China", "Shanghai, China",
             "Shenzhen, China", "Chengdu, China"]
})

# 利用 apply 结合 RateLimiter 进行批量编码
df["location"] = df["city"].apply(geocode_with_limit)
df["lat"] = df["location"].apply(
    lambda loc: loc.latitude if loc else None
)
df["lng"] = df["location"].apply(
    lambda loc: loc.longitude if loc else None
)

print(df[["city", "lat", "lng"]].to_string())

import json
import hashlib
from geopy.geocoders import Nominatim
from geopy.extra.rate_limiter import RateLimiter

class GeocodingCache:
    """简单的内存缓存地理编码器"""

    def __init__(self, user_agent="cache_demo"):
        self.geocoder = Nominatim(user_agent=user_agent, timeout=10)
        self.geocode_fn = RateLimiter(
            self.geocoder.geocode,
            min_delay_seconds=1.0
        )
        self.cache = {}
        self.stats = {"hits": 0, "misses": 0}

    def _make_key(self, address):
        """生成缓存键"""
        normalized = address.strip().lower()
        return hashlib.md5(normalized.encode()).hexdigest()

    def geocode(self, address):
        """带缓存的地理编码"""
        key = self._make_key(address)

        if key in self.cache:
            self.stats["hits"] += 1
            return self.cache[key]

        self.stats["misses"] += 1
        location = self.geocode_fn(address)

        if location:
            result = {
                "lat": location.latitude,
                "lng": location.longitude,
                "address": location.address
            }
        else:
            result = None

        self.cache[key] = result
        return result

    def get_stats(self):
        """获取缓存统计"""
        total = self.stats["hits"] + self.stats["misses"]
        hit_rate = self.stats["hits"] / total if total > 0 else 0
        return {
            "总请求": total,
            "缓存命中": self.stats["hits"],
            "缓存未命中": self.stats["misses"],
            "命中率": f"{hit_rate:.1%}"
        }

# 使用示例
cache = GeocodingCache()

# 第一次查询（缓存未命中，发送 API 请求）
addresses = ["Beijing, China", "Shanghai, China", "Beijing, China"]
for addr in addresses:
    result = cache.geocode(addr)
    if result:
        print(f"{addr} -> ({result['lat']:.3f}, {result['lng']:.3f})")

# 查看缓存统计
print("\n缓存统计：")
for k, v in cache.get_stats().items():
    print(f"  {k}: {v}")

import asyncio
from geopy.geocoders import Nominatim
from geopy.adapters import AioHTTPAdapter

async def async_geocode_batch(addresses, user_agent="async_demo"):
    """
    异步批量地理编码（适用于支持高并发的付费服务）

    注意: Nominatim 限制为 1次/秒，此方法更适合付费服务
    """
    async with Nominatim(
        user_agent=user_agent,
        adapter_factory=AioHTTPAdapter,
        timeout=10
    ) as geocoder:
        results = []
        for addr in addresses:
            try:
                location = await geocoder.geocode(addr)
                if location:
                    results.append({
                        "address": addr,
                        "lat": location.latitude,
                        "lng": location.longitude,
                        "status": "success"
                    })
                else:
                    results.append({
                        "address": addr,
                        "lat": None,
                        "lng": None,
                        "status": "not_found"
                    })
            except Exception as e:
                results.append({
                    "address": addr,
                    "lat": None,
                    "lng": None,
                    "status": f"error: {str(e)}"
                })
            # 遵守 Nominatim 限速
            await asyncio.sleep(1.1)

        return results

# 使用示例
# 注意：在 Jupyter 中使用 await，在脚本中使用 asyncio.run()
addresses = ["Beijing, China", "Shanghai, China"]

# results = asyncio.run(async_geocode_batch(addresses))
# for r in results:
#     print(f"{r['address']}: ({r['lat']}, {r['lng']}) [{r['status']}]")

print("异步编码适用于付费高并发服务（如 Google Maps）")
print("Nominatim 因限速限制，异步优势不明显")

import pandas as pd
import geopandas as gpd
from geopy.geocoders import Nominatim
from geopy.extra.rate_limiter import RateLimiter

# 模拟不规范的地址数据
raw_addresses = pd.DataFrame({
    "id": range(1, 6),
    "raw_address": [
        "Beijing China",         # 缺少标点
        "shanghai, CN",          # 小写，缩写
        "Guangzhou Guangdong",   # 不完整
        "ShenZhen",              # 大小写混合
        "Chengdu, Sichuan, China"  # 完整地址
    ]
})

print("原始地址数据：")
print(raw_addresses.to_string())

# 使用地理编码进行地址标准化
result = gpd.tools.geocode(
    raw_addresses["raw_address"].tolist(),
    provider="nominatim",
    user_agent="address_cleaning_demo"
)

# 合并标准化结果
raw_addresses["standardized_address"] = result["address"].values
raw_addresses["longitude"] = result.geometry.x.values
raw_addresses["latitude"] = result.geometry.y.values
raw_addresses["is_valid"] = result.geometry.notna().values

print("\n标准化后：")
print(raw_addresses[["raw_address", "standardized_address", "is_valid"]].to_string())

# 地址去重：识别指向同一位置的不同地址表述
import numpy as np

def find_duplicate_locations(gdf, distance_threshold=100):
    """
    查找指向同一位置的重复地址（距离阈值内视为同一位置）

    参数:
        gdf: 含 geometry 的 GeoDataFrame
        distance_threshold: 距离阈值（米）
    """
    # 投影到 UTM 坐标系进行距离计算
    projected = gdf.to_crs(epsg=3857)

    duplicates = []
    for i in range(len(projected)):
        for j in range(i + 1, len(projected)):
            if projected.geometry.iloc[i] is None or projected.geometry.iloc[j] is None:
                continue
            dist = projected.geometry.iloc[i].distance(projected.geometry.iloc[j])
            if dist < distance_threshold:
                duplicates.append((i, j, dist))

    return duplicates

# 示例：检查是否有地址指向同一位置
print("重复位置检测功能已准备就绪")
print("可用于识别数据中的重复地址记录")

import pandas as pd
import geopandas as gpd
from shapely.geometry import Point
import numpy as np

# 模拟客户数据（假设已经过地理编码）
np.random.seed(42)
n_customers = 20

customers = gpd.GeoDataFrame({
    "customer_id": [f"C{i:03d}" for i in range(1, n_customers + 1)],
    "city": np.random.choice(
        ["Beijing", "Shanghai", "Guangzhou", "Shenzhen", "Hangzhou"],
        n_customers
    ),
    "revenue": np.random.uniform(1000, 50000, n_customers).round(2),
    "geometry": [
        Point(
            np.random.uniform(113, 122),
            np.random.uniform(22, 40)
        ) for _ in range(n_customers)
    ]
}, crs="EPSG:4326")

# 1. 按城市汇总客户统计
city_stats = customers.groupby("city").agg(
    客户数=("customer_id", "count"),
    总收入=("revenue", "sum"),
    平均收入=("revenue", "mean")
).round(2)

print("城市客户统计：")
print(city_stats.to_string())

# 2. 计算客户分布的中心点
center = customers.geometry.unary_union.centroid
print(f"\n客户分布中心点: ({center.x:.3f}, {center.y:.3f})")

# 3. 计算各客户到中心点的距离
customers_proj = customers.to_crs(epsg=3857)
center_proj = customers_proj.geometry.unary_union.centroid
customers["dist_to_center_km"] = (
    customers_proj.geometry.distance(center_proj) / 1000
).round(1)

print("\n距离中心最远的5个客户：")
print(
    customers.nlargest(5, "dist_to_center_km")[
        ["customer_id", "city", "revenue", "dist_to_center_km"]
    ].to_string()
)

# 4. 创建客户密度热力图数据
from shapely.geometry import box

def create_grid_density(gdf, grid_size=1.0):
    """
    创建网格化的客户密度数据

    参数:
        gdf: 客户 GeoDataFrame
        grid_size: 网格大小（度）
    """
    bounds = gdf.total_bounds  # (minx, miny, maxx, maxy)

    # 创建网格
    grids = []
    x = bounds[0]
    while x < bounds[2]:
        y = bounds[1]
        while y < bounds[3]:
            cell = box(x, y, x + grid_size, y + grid_size)
            count = gdf.geometry.within(cell).sum()
            if count > 0:
                grids.append({
                    "geometry": cell,
                    "customer_count": count,
                    "total_revenue": gdf[gdf.geometry.within(cell)]["revenue"].sum()
                })
            y += grid_size
        x += grid_size

    return gpd.GeoDataFrame(grids, crs=gdf.crs)

# 创建密度网格
density_grid = create_grid_density(customers, grid_size=2.0)
print("客户密度网格：")
print(f"  网格数量: {len(density_grid)}")
if len(density_grid) > 0:
    print(f"  最大客户密度: {density_grid['customer_count'].max()} 人/网格")
    print(f"  最高区域收入: {density_grid['total_revenue'].max():.2f}")