framewatch 0.2.0

//! ROI ↔ tile mapping and tile masks.

use crate::config::{RoiHint, RoiKind};

/// A per-tile boolean mask (length `cols * rows`).
#[derive(Debug, Clone)]
pub struct TileMask {
    bits: Box<[bool]>,
}

impl TileMask {
    /// An all-`false` mask of `len` tiles.
    pub fn empty(len: usize) -> Self {
        Self {
            bits: vec![false; len].into_boxed_slice(),
        }
    }

    /// Whether tile `idx` is set.
    #[inline]
    pub fn get(&self, idx: usize) -> bool {
        self.bits.get(idx).copied().unwrap_or(false)
    }

    /// Set tile `idx`.
    #[inline]
    pub fn set(&mut self, idx: usize) {
        if let Some(b) = self.bits.get_mut(idx) {
            *b = true;
        }
    }

    /// Whether any tile is set.
    pub fn any(&self) -> bool {
        self.bits.iter().any(|b| *b)
    }

    /// Number of tiles in the mask.
    pub fn len(&self) -> usize {
        self.bits.len()
    }

    /// Whether the mask has zero tiles.
    pub fn is_empty(&self) -> bool {
        self.bits.is_empty()
    }
}

/// A single region resolved to tile indices.
#[derive(Debug, Clone)]
pub struct Region {
    /// Region label.
    pub label: String,
    /// Region kind.
    pub kind: RoiKind,
    /// Tile indices covered by this region.
    pub tiles: Vec<usize>,
}

/// All ROIs resolved against a tile grid, plus derived masks.
#[derive(Debug, Clone)]
pub struct RoiSet {
    cols: u16,
    rows: u16,
    regions: Vec<Region>,
    ignore: TileMask,
    /// Tiles belonging to a Spinner or Volatile region (excluded from "meaningful").
    excluded: TileMask,
    /// Tiles belonging to a Watch region (lower change threshold).
    watch: TileMask,
}

impl RoiSet {
    /// Build a resolved ROI set for a `cols × rows` grid from hints.
    pub fn build(hints: &[RoiHint], cols: u16, rows: u16) -> Self {
        let len = cols as usize * rows as usize;
        let mut ignore = TileMask::empty(len);
        let mut excluded = TileMask::empty(len);
        let mut watch = TileMask::empty(len);
        let mut regions = Vec::with_capacity(hints.len());

        for h in hints {
            let tiles = tiles_for_rect(h.rect_norm, cols, rows);
            for &t in &tiles {
                match h.kind {
                    RoiKind::Ignore => ignore.set(t),
                    RoiKind::Spinner | RoiKind::Volatile => excluded.set(t),
                    RoiKind::Watch => watch.set(t),
                }
            }
            regions.push(Region {
                label: h.label.clone(),
                kind: h.kind,
                tiles,
            });
        }

        Self {
            cols,
            rows,
            regions,
            ignore,
            excluded,
            watch,
        }
    }

    /// Grid columns.
    pub fn cols(&self) -> u16 {
        self.cols
    }

    /// Grid rows.
    pub fn rows(&self) -> u16 {
        self.rows
    }

    /// The resolved regions.
    pub fn regions(&self) -> &[Region] {
        &self.regions
    }

    /// The ignore mask (tiles excluded from diffing).
    pub fn ignore_mask(&self) -> &TileMask {
        &self.ignore
    }

    /// Whether tile `idx` belongs to a Spinner/Volatile region.
    #[inline]
    pub fn is_excluded(&self, idx: usize) -> bool {
        self.excluded.get(idx)
    }

    /// Whether tile `idx` belongs to a Watch region.
    #[inline]
    pub fn is_watch(&self, idx: usize) -> bool {
        self.watch.get(idx)
    }

    /// Regions of the given kind, by index into [`regions`](RoiSet::regions).
    pub fn region_indices_of_kind(&self, kind: RoiKind) -> impl Iterator<Item = usize> + '_ {
        self.regions
            .iter()
            .enumerate()
            .filter(move |(_, r)| r.kind == kind)
            .map(|(i, _)| i)
    }
}

/// Map a client-normalized `[x, y, w, h]` rect to the set of covered tile indices.
pub fn tiles_for_rect(rect_norm: [f32; 4], cols: u16, rows: u16) -> Vec<usize> {
    let [x, y, w, h] = rect_norm;
    let cols_f = cols as f32;
    let rows_f = rows as f32;

    let c0 = (x * cols_f).floor().clamp(0.0, cols_f) as i64;
    let c1 = ((x + w) * cols_f).ceil().clamp(0.0, cols_f) as i64;
    let r0 = (y * rows_f).floor().clamp(0.0, rows_f) as i64;
    let r1 = ((y + h) * rows_f).ceil().clamp(0.0, rows_f) as i64;

    let mut out = Vec::new();
    for r in r0..r1.max(r0) {
        for c in c0..c1.max(c0) {
            out.push((r as usize) * cols as usize + c as usize);
        }
    }
    // Guarantee at least one tile for a tiny but non-empty region.
    if out.is_empty() && w > 0.0 && h > 0.0 {
        let c = ((x * cols_f) as i64).clamp(0, cols as i64 - 1) as usize;
        let r = ((y * rows_f) as i64).clamp(0, rows as i64 - 1) as usize;
        out.push(r * cols as usize + c);
    }
    out
}