# Automatic RGB+IR Labeling Tool Generates per-pixel label annotations for registered RGB/IR wildfire footage (the layout of `../../Data/`, the hand-labeled data at the root of this repository). A trained YOLO detector and IR hotspot thresholding propose candidate regions, and SAM turns those proposals into per-pixel masks. You give it a dataset folder; for each RGB/IR frame pair it writes a label mask in the same format as the dataset's own `mask/` files, plus overlay images. ## What you need 1. **This folder**, unzipped anywhere. It already contains the trained models, nothing else to download: - `auto_annotate.py`: the tool - `weights/best.pt`: trained detector - `sam_vit_b_01ec64.pth`: segmentation model - `requirements.txt` Keep `auto_annotate.py` inside this folder. It finds the models by their path relative to the script, not to your working directory. If you move it, pass `--weights` and `--sam-checkpoint` explicitly. 2. **Your data** (not included), in the layout described under "Running on your own data" below. For the original dataset, point at the folder that directly contains `Canopy/` and `Graminoid/`, which in this repository is `../../Data` relative to this folder. 3. **Python 3.10+**: ```bash pip install -r requirements.txt ``` If the machine has an NVIDIA GPU, install the CUDA build of torch as well. This is about 2x faster (roughly 14 s per frame instead of 25-35 s). The `--force-reinstall` matters: without it pip sees the CPU build already installed and does nothing. ```bash pip install --force-reinstall torch torchvision --index-url https://download.pytorch.org/whl/cu126 ``` Verify it worked: the tool prints `PyTorch | CUDA: True` on startup. If it says `CUDA: False`, it is running on CPU. ## How to run You must pass exactly one of `--split`, `--clip` or `--all`. Everything in the dataset's train + test splits (775 pairs, about 3 hours on a GPU, 6-8 hours on CPU): ```bash python auto_annotate.py --dataset ../../Data --split train test --out MyAnnotations ``` One clip (`--clip` is repeatable), or specific frames of it: ```bash python auto_annotate.py --dataset path/to/dataset --clip Graminoid-08 --out MyAnnotations python auto_annotate.py --dataset path/to/dataset --clip Graminoid-08 --frames f00300 f00600 --out MyAnnotations ``` Every clip found in the folder: ```bash python auto_annotate.py --dataset path/to/dataset --all --out MyAnnotations ``` Other options: - `--split` accepts `train`, `val`, `test` (any combination). It reads the frame list from `samples_splits.csv` at the dataset root, the annotators' working file, which is not part of this release. On the released `../../Data/` use `--clip` or `--all` instead. - Interrupted run? Just run the same command again; finished frames are skipped. Use `--overwrite` to redo them. - `--no-copy-inputs` skips copying the rgb/ir frames into the output. This saves about 6 GB on a full run; the homography is still copied. - `--class-thr T1 T2 T3 T4 T5` overrides the per-class confidence thresholds. Defaults are `0.25 0.35 0.45 0.45 0.45`. Passing `0.25 0.25 0.45 0.45 0.45` lowers only class 2 (class 1 is already at 0.25); on held-out validation clips this improved class-2 detection with no measured loss on the other classes. ## What you get One folder per clip, following the dataset layout, with one addition (`mask_color/`, which the dataset does not ship) and one omission (`ir_gray/`, which this tool does not produce): ``` MyAnnotations/// mask/fNNNNN.txt the label mask (see format below) mask_overlay/fNNNNN.jpg labels blended over the RGB frame, for eyeballing mask_color/fNNNNN.png labels as a flat color image rgb/, ir/, homography/ copies of the inputs, so each output clip folder loads standalone in the dataset's own viewer.html (`../../html/viewer.html` in this repository) ``` **Mask format:** exactly 2688 x 1512 = 4,064,256 ASCII digit bytes. One digit per pixel, values 1-5, row-major, single line, no newline and no separators. Identical to the dataset's own mask files. To read one: ```python import numpy as np with open("mask/f00300.txt", "rb") as f: mask = (np.frombuffer(f.read(), dtype=np.uint8) - ord("0")).reshape(1512, 2688) ``` Classes: 1 = red, 2 = orange, 3 = yellow, 4 = green, 5 = black. Every pixel gets one of the five; there is no "unlabeled" value. **Disk space:** about 13 MB per frame with input copies (10 GB for a 775-frame run), or about 5.3 MB per frame with `--no-copy-inputs`. ## Running on your own data The tool needs, per clip: ``` ///rgb/fNNNNN.png RGB frame ///ir/fNNNNN.png IR frame, same filename as its RGB partner ///homography/homography.json ``` Two things that commonly go wrong: - **The IR frames must be the colorized IR**, not grayscale. The hotspot step thresholds red and white; grayscale IR silently yields no hotspots. - **Filenames must match exactly** between `rgb/` and `ir/`. A frame with no IR partner is reported and skipped. `homography.json` maps IR pixels to RGB pixels: ```json { "ir_size": [640, 360], "rgb_size": [2688, 1512], "maps": "IR_pixel -> RGB_pixel", "subsets": [ { "label": "f00300-f02400", "frame_start": "f00300.png", "frame_end": "f02400.png", "matrix": [[3.134, -0.049, 308.2], [-0.017, 3.044, 223.4], [-4.2e-05, -4.2e-05, 1]] } ] } ``` Use several `subsets` if the registration changes during the clip; the tool picks the one whose frame range covers each frame (nearest range if none does). ## Accuracy, please read The output is generated by the pipeline, not human ground truth. Quality varies between clips and classes. Always spot-check `mask_overlay/` before treating any output as ground truth. ## Good to know - Frames are skipped in two cases: no IR partner, or no detection survives the confidence thresholds (nothing to segment). Both are reported. - The IR-to-RGB registration is read from `homography.json`; the tool never computes or refines it. - A failed frame never aborts the run; it is reported and the run continues.