HeatCast

Per-city Landsat-derived land-surface-temperature time-series cubes for 124 U.S. cities, stored as Zarr v3 with sharding. Repacked from the original tiled-GeoTIFF release of JesseGuerreroML/US-UrbanLST so the whole dataset is 7,436 files instead of 14.5M, while staying fully cloud-readable.

Layout

isaaccorley/HeatCast/
├── <City_ST>.zarr/          # one Zarr v3 store per city (124 total)
│   ├── zarr.json
│   ├── LST/                 # 3-D array  (T, Y, X)  int16
│   ├── albedo/
│   ├── blue/  green/  red/
│   ├── ndvi/  ndwi/  ndbi/
│   └── ...

Each city store carries:

attr	description
city	city name
timestamps	ISO-8601 list, length T (one per Landsat acquisition)
bands	list of band names present in the store
tile_size	[h, w] of one source tile
grid_shape	[rows, cols] of the per-city tile grid
full_shape	[H, W] of the assembled raster
transforms	{timestamp: affine} for the sample band

Per-band arrays use chunk = one source tile (1 × tile_h × tile_w), packed into shards covering a 4 × 4 tile region across the full time axis. Compression is Blosc(Zstd-9, byte-shuffle). Missing tiles encode as the per-band fill value (0 for ints, NaN for floats — same as the upstream GeoTIFFs).

Quick start — stream from the Hub

No clone, no caching, pure HTTPS range-reads:

pip install "zarr>=3" obstore pandas matplotlib seaborn

import os
from datetime import timedelta

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
import seaborn as sns
import obstore
import zarr
from zarr.storage import ObjectStore

sns.set_theme(context="notebook", style="whitegrid", palette="deep")

REPO = "isaaccorley/HeatCast"
CITY = "Hollywood_FL"
BASE = f"https://huggingface.co/datasets/{REPO}/resolve/main"

# Use an HF token to bypass anonymous IP rate limits on shared networks.
headers = {}
token = os.environ.get("HF_TOKEN")
if token:
    headers["Authorization"] = f"Bearer {token}"

http = obstore.store.HTTPStore.from_url(
    f"{BASE}/{CITY}.zarr",
    client_options={"default_headers": headers} if headers else None,
    retry_config={
        "max_retries": 2,
        "backoff": {"init_backoff": timedelta(seconds=2),
                    "max_backoff": timedelta(seconds=10), "base": 2},
        "retry_timeout": timedelta(seconds=30),
    },
)
grp = zarr.open_group(ObjectStore(http, read_only=True), mode="r")

timestamps = list(grp.attrs["timestamps"])
print(grp.attrs["city"], "T=", len(timestamps), "bands=", grp.attrs["bands"])

Tip — read whole cubes, not per-timestamp

Per-pixel and per-timestamp slicing each issues several range-reads. HF rate-limits at 5,000 resolve/ requests per 5 minutes for free accounts, so for any analysis touching most timestamps just pull the whole array in one sweep:

lst = grp["LST"]
raw = lst[:]                                    # one sweep across all shards
mask = (raw == lst.fill_value) | (raw <= 0)     # filter both fill and OOS padding
cube = np.where(mask, np.nan, raw.astype(np.float32))

# Drop whole scenes whose 5th-percentile LST is implausibly low. A handful of
# upstream scenes were stored with the wrong scaling factor (e.g. Hollywood_FL
# 2022-02-09 has scene-wide values of 1–41 vs neighbouring dates near 70–125).
LST_FLOOR = 50
frame_p5 = np.nanpercentile(cube.reshape(cube.shape[0], -1), 5, axis=1)
cube[frame_p5 < LST_FLOOR] = np.nan
print(cube.shape, "valid_pct=", 100 * (~np.isnan(cube)).mean())

Data-quality caveat. A small number of source scenes carry an anomalous per-scene scaling factor — their entire grid is off by roughly 10× compared to neighbouring dates. The repack is byte-exact with the upstream GeoTIFFs, so the artifact is preserved here. The LST_FLOOR filter above is the simplest defensible mask; tune the threshold per city / per unit if you need something stricter.

Example 1 — center-pixel LST time series

dt = pd.to_datetime(timestamps, utc=True)
py, px = cube.shape[1] // 2, cube.shape[2] // 2
ts = pd.Series(cube[:, py, px], index=dt).dropna()

fig, ax = plt.subplots(figsize=(11, 4.2))
sns.lineplot(x=ts.index, y=ts.values, ax=ax, marker="o", markersize=5,
             linewidth=1.2, color=sns.color_palette("rocket", 6)[2])
ax.set(title=f"{CITY} — LST at pixel ({py}, {px})", xlabel="date", ylabel="LST")
ax.xaxis.set_major_locator(mdates.YearLocator())
ax.xaxis.set_major_formatter(mdates.DateFormatter("%Y"))
sns.despine(ax=ax); fig.autofmt_xdate(); fig.tight_layout()

Example 2 — best-coverage scene as a heat map

valid_t = (~np.isnan(cube)).reshape(cube.shape[0], -1).sum(axis=1).argmax()
frame = cube[valid_t]
vmin, vmax = np.nanpercentile(frame, [2, 98])

fig, ax = plt.subplots(figsize=(8.5, 6.5))
im = ax.imshow(frame, cmap="rocket_r", vmin=vmin, vmax=vmax, interpolation="nearest")
fig.colorbar(im, ax=ax, shrink=0.85, pad=0.02).set_label("LST", rotation=270, labelpad=15)
ax.set(title=f"{CITY} — LST on {dt[valid_t].date()}", xlabel="x (px)", ylabel="y (px)")
fig.tight_layout()

Example 3 — city-mean LST trajectory with seasonal hue

means = np.nanmean(cube.reshape(cube.shape[0], -1), axis=1)
ok = ~np.isnan(means)
df = pd.DataFrame({"date": dt[ok], "LST": means[ok]})
df["month"] = df["date"].dt.month

fig, ax = plt.subplots(figsize=(11, 4.2))
sns.scatterplot(data=df, x="date", y="LST", hue="month", palette="rocket",
                s=45, edgecolor="white", linewidth=0.5, legend=False, ax=ax)
trend = df.set_index("date")["LST"].resample("3MS").mean().dropna()
ax.plot(trend.index, trend.values, color="#444", lw=1.2, alpha=0.7,
        label="3-month rolling mean")
ax.legend(loc="upper left", frameon=True)
ax.set(title=f"{CITY} — city-mean LST (colored by month)",
       xlabel="date", ylabel="mean LST")
ax.xaxis.set_major_locator(mdates.YearLocator())
ax.xaxis.set_major_formatter(mdates.DateFormatter("%Y"))
sns.despine(ax=ax); fig.autofmt_xdate(); fig.tight_layout()

File-count comparison

layout	files	total size
upstream tiled GeoTIFFs (inside 7z + inner zip)	14,490,624	269 GB
HeatCast Zarr v3	7,436	170 GB

Provenance

• Source: JesseGuerreroML/US-UrbanLST — Landsat-derived LST + reflectance/index tiles for 124 U.S. cities.
• Repack pipeline: 7z → zip → per-city tile inventory → Zarr v3 with shard-aligned writes. Round-trip checked bit-exact against source GeoTIFFs (mean-abs-diff = 0 per band on validation samples).
• Compression: Blosc-Zstd-9 with byte shuffle.

License

MIT. Cite the upstream dataset if you publish results derived from it.