DONKEY13479/ForestFireFIghting_vision

ForestFireFighting-Vision

A vision dataset for aerial forest-fire risk assessment. Each sample pairs a top-down rendered forest-fire scene with a machine-generated, structured risk analysis: the image is decomposed into coarse rectangular risk zones, each carrying a risk level, the fire points it contains, and a natural-language justification in Chinese.

The dataset targets models that must go beyond detection — i.e. reproduce an operator-style reasoning trace: where the risk is, how severe it is, and why.

Scene content

Top-down (nadir) views of forested terrain with visible fire fronts, smoke plumes, unpaved roads and tree canopy. Scenes were rendered by a simulation engine, so lighting, terrain and fire placement are synthetic and reproducible rather than filmed — suitable for training and for closed-loop simulation, but not a substitute for real aerial imagery.

Repository Structure

.
├── image/            # 179 PNG images, 0001.png – 0179.png        (~794 MB)
├── label/            # 179 JSON annotations, one per image        (~582 KB)
├── output/           # 179 qualitative PNG visualisations         (~1075 MB)
├── metadata.jsonl    # flat per-image index (see below)           (~341 KB)
└── README.md

Image IDs are zero-padded four-digit strings and are shared across all three directories: image/0042.png ↔ label/0042.json ↔ output/0042_visualized.png.

metadata.jsonl is a convenience index with one JSON object per image. Every value is either a scalar or a flat list of strings, and the nested zone payload is carried as a JSON-encoded string in zones_json — this keeps the file trivially loadable by Arrow/datasets without schema-inference failures (several zones carry an empty fire_points list, which would otherwise be inferred as list<null> and conflict with populated rows).

Label Schema

Each label/<id>.json is a JSON array of zone objects — note, a bare array, not an object wrapping one. Each zone has exactly these six fields:

Field	Type	Description
id	string	Zone identifier, e.g. "zone_0". Unique within an image.
risk_level	string	One of "Monitor", "Low", "High".
coordinates	[[float, float], ...]	Zone polygon, normalised to [0, 1]. Almost always 4 vertices (axis-aligned rectangle); 3 zones use 6 vertices and 1 uses 8.
fire_points	[[float, float], ...]	Fire-point centres, normalised to [0, 1]. May be empty.
reason	string	Chinese rationale for the assigned risk level.
boundary_description	string	Chinese description of how the zone bounds were chosen.

Example

[
  {
    "id": "zone_0",
    "risk_level": "Monitor",
    "coordinates": [[0.0, 0.0], [0.25, 0.0], [0.25, 1.0], [0.0, 1.0]],
    "fire_points": [],
    "reason": "该区域为西部森林背景区，未检测到任何热源或烟雾，划定为安全监测区。",
    "boundary_description": "覆盖图像最左侧 25% 的垂直切片区域。"
  },
  {
    "id": "zone_2",
    "risk_level": "High",
    "coordinates": [[0.6, 0.0], [1.0, 0.0], [1.0, 1.0], [0.6, 1.0]],
    "fire_points": [[0.695, 0.135], [0.745, 0.395], [0.885, 0.375], [0.905, 0.725]],
    "reason": "检测到 4 个密集分布的高强度火点，伴随明显浓烟，且覆盖范围广，判定为核心攻坚区。",
    "boundary_description": "覆盖图像右侧 40% 区域，完整包裹东部密集火点群及烟雾扩散范围。"
  }
]

zone_0 above is rendered as: "This area is the western forest background; no heat source or smoke detected; designated a safe monitoring zone." — zone_2 as: "4 densely distributed high-intensity fire points detected, with pronounced smoke and wide coverage; designated the core attack zone."

Coordinate convention

Coordinates are normalised by image width (x) and height (y), with the origin at the top-left. The convention was verified against output/ — the zone labelled as the topmost band in the annotations is rendered at the top of the visualisation.

Statistics

Images	179
Zones	765 (2–5 per image)
Fire points	722
Zones containing ≥1 fire point	405
Total image size	~794 MB
Total visualisation size	~1075 MB

Risk level distribution (risk_level)

Level	Zones	Share
Monitor	360	47.1%
High	270	35.3%
Low	135	17.6%

⚠️ risk_level is exactly determined by fire-point count in this release. The relationship is a perfect bijection, not a tendency:

• all 360 zones with an empty fire_points list are Monitor — no exceptions;
• all 405 zones with ≥1 fire point are Low or High — no zone with a fire point is Monitor.

So risk_level == "Monitor" ⟺ len(fire_points) == 0, for all 765 zones. The risk level carries no information beyond whether a fire point was annotated, and a zone classifier trained on this data can reach 100% accuracy by counting fire points alone. Treat risk_level as a derived label, and treat the underlying fire-point annotation as the actual supervision signal. The Low vs High split within fire-bearing zones is not explained by this shortcut and is the only part of the task that requires looking at the image.

Zones per image

Zones	Images
2	2
3	16
4	92
5	69

Fire points per zone

Points	0	1	2	3	4	5	6
Zones	360	213	107	54	23	7	1

Zone layout. Zones form a coarse spatial decomposition — 119 images mix full-width horizontal bands with column splits within a band (see the 0002 example above), 52 use a pure grid, 7 are split into full-height vertical strips, and 1 uses full-width horizontal strips only.

Coverage. In 175 of 179 images the zones tile the frame exactly — complete coverage, no overlap — so they can be treated as mutually exclusive regions and rasterised into a segmentation mask directly. The 4 exceptions are listed under Caveats.

Image resolution. The images are not uniform:

Subset	IDs	Count	Resolution
A	0001–0125 (except 0053)	124	1751×1196 – 2689×1509, all distinct
B	0053, 0126–0179	55	1920×1080 exactly

Every image in subset A has a unique resolution, though all sit at roughly 16:9 (aspect ratios 1.75–1.80). Subset B is exactly 1080p. Account for this if you resize or batch by resolution.

Usage

Reading the raw files

No dependency beyond Pillow and the standard library:

import json
from pathlib import Path
from PIL import Image

root = Path(".")
labels = json.loads((root / "label" / "0001.json").read_text(encoding="utf-8"))
img = Image.open(root / "image" / "0001.png")   # RGB, 2608x1458
w, h = img.size

for zone in labels:
    # normalised -> pixel space
    poly = [(x * w, y * h) for x, y in zone["coordinates"]]
    pts  = [(x * w, y * h) for x, y in zone["fire_points"]]
    print(zone["id"], zone["risk_level"], len(pts), zone["reason"])

Building a flat per-zone table

For training, one row per zone is usually more convenient than one row per image:

import json
from pathlib import Path

rows = []
for meta in map(json.loads, Path("metadata.jsonl").read_text(encoding="utf-8").splitlines()):
    for zone in json.loads(meta["zones_json"]):
        xs = [p[0] for p in zone["coordinates"]]
        ys = [p[1] for p in zone["coordinates"]]
        rows.append({
            "image_id": meta["image_id"],
            "file_name": meta["file_name"],
            "zone_id": zone["id"],
            "risk_level": zone["risk_level"],
            "x_min": min(xs), "y_min": min(ys),
            "x_max": max(xs), "y_max": max(ys),
            "num_fire_points": len(zone["fire_points"]),
            "fire_points": zone["fire_points"],      # normalised
            "reason": zone["reason"],
            "boundary_description": zone["boundary_description"],
        })
# 765 rows

Loading with 🤗 datasets

The repository holds three sibling directories, so point the loader at the image folder explicitly rather than at the repository root:

from datasets import load_dataset

ds = load_dataset("imagefolder", data_dir="image")   # split name: "image"

Visualisations

output/<id>_visualized.png renders each annotation over its scene — zone polygons filled by risk level, fire points marked as red crosses, with a title and legend.

Two things to know before using them programmatically:

• They are matplotlib figure renders, not pixel-aligned overlays. All 179 are 2850 px wide with fixed margins, and none matches the resolution of its source image. Do not use them as segmentation masks or align them by pixel coordinates; re-render from label/ instead.
• Their embedded titles still reference the pre-conversion filenames (e.g. the visualisation for image/0002.png is titled Fire Risk Analysis: 0002.jpg), because they were produced before the JPEG→PNG conversion. Titles are cosmetic only.

Caveats and Known Limitations

Read these before treating the labels as ground truth.

• Annotations are machine-generated. Zone boundaries, risk levels and the Chinese rationales were produced automatically, not by human annotators, and had no human review pass declared. reason and boundary_description are fluent and internally consistent but should be treated as model output, not verified expert judgement — validate before relying on them for safety-critical decisions.
• Zones are a near-complete partition, with 4 documented exceptions. In 175 of 179 images the rectangles tile the frame exactly (full coverage, no overlap). The exceptions are which you should special-case if you rely on disjointness:
  • 0020, 0028, 0105 — zones overlap (coverage of the frame is still complete, but some rectangles intersect, so rasterising them into a mask is order-dependent);
  • 0054 — the zones leave ~24.5% of the frame uncovered by any zone.
• risk_level is exactly determined by fire-point count (see Statistics) — the mapping is a perfect bijection across all 765 zones. A model can reach 100% zone-classification accuracy from the fire-point annotation alone, so a high score on this label does not demonstrate visual understanding of fire severity.
• Class imbalance: Low is under-represented at 17.6%, and 47% of zones are the trivially identifiable Monitor class.
• Mixed resolutions (two subsets, 124 distinct sizes) and one image with an alpha channel: image/0053.png is RGBA; the other 178 are RGB. Normalise to RGB on load if your pipeline requires a single mode.
• Chinese-only text fields. No translation is provided in this release.
• One scene family. All 179 images come from the same simulation setup, so background, lighting and terrain style are highly correlated across the dataset. Expect a domain gap on real aerial imagery.
• Single-turn, single-scene. No video, no temporal sequences, no multi-spectral or thermal bands despite the fire-monitoring domain.

Provenance

Images are rendered by a simulation engine for forest-fire cyber-physical-system research; they are not photographs and contain no real-world location data. Annotations were generated over those renders by a large vision-language model. No personal data is included. The dataset is released under Apache-2.0.

Citation

If you use this dataset, please cite it via the repository metadata. A CITATION.cff or BibTeX entry is not yet included in this release.

@misc{forestfirefighting_vision,
  title  = {ForestFireFighting-Vision: Aerial Forest-Fire Risk Assessment Dataset},
  author = {Intelligent Cyber-Physical Systems Group},
  year   = {2026},
  note   = {Simulation-rendered aerial scenes with machine-generated risk-zone annotations},
  howpublished = {\url{https://huggingface.co/datasets/<your-org>/<your-repo>}}
}

Replace <your-org>/<your-repo> with the final Hub repository ID before publishing.