siplot 0.1.0

//! Scatter mask tools, porting silx `ScatterMaskToolsWidget`.
//!
//! Unlike the image mask ([`crate::widget::mask_tools`]) which masks pixels,
//! the scatter mask selects scatter *points by index*. The mask is a 1D
//! `uint8` buffer with one entry per point: `0` is unmasked, `1..=255` are
//! mask levels. The level / invert / clear / undo semantics mirror the image
//! mask (both descend from silx `BaseMask`); only the geometric selection
//! tests differ, operating on the point coordinate arrays instead of a pixel
//! grid.
//!
//! Faithful to `silx/gui/plot/ScatterMaskToolsWidget.py` (the `ScatterMask`
//! class) and the `Polygon.is_inside` point-in-polygon test in
//! `silx/image/shapes.pyx`.

use crate::widget::mask_tools::MaskHistory;

/// A multi-level mask over scatter points, selected by point index.
///
/// Mirrors silx `ScatterMask`: a 1D `uint8` array the same length as the
/// scatter data, where `0` means unmasked and `1..=255` are the (up to 254)
/// non-overlapping mask levels.
pub struct ScatterMaskWidget {
    /// Per-point mask level: `0` is unmasked, `1..=255` is a mask level. The
    /// length equals the number of scatter points.
    pub mask: Vec<u8>,

    /// Current mask level edited by the tools (silx `levelSpinBox`,
    /// range 1..=255).
    pub level: u8,

    history: MaskHistory,
}

impl ScatterMaskWidget {
    /// Create a scatter mask for `npoints` points, all initially unmasked.
    pub fn new(npoints: usize) -> Self {
        let mask = vec![0u8; npoints];
        let history = MaskHistory::new(&mask);
        Self {
            mask,
            level: 1,
            history,
        }
    }

    /// Number of points covered by the mask.
    pub fn len(&self) -> usize {
        self.mask.len()
    }

    /// Whether the mask covers zero points.
    pub fn is_empty(&self) -> bool {
        self.mask.is_empty()
    }

    /// Reset the mask to `npoints` points and clear it.
    ///
    /// Mirrors silx `reset(shape)`: a length change resets the undo history.
    pub fn reset_len(&mut self, npoints: usize) {
        self.mask = vec![0u8; npoints];
        self.history.reset(&self.mask);
    }

    // --- Whole-mask operations (silx BaseMask) ---

    /// Set all points of the current level back to `0`.
    ///
    /// Mirrors silx `BaseMask.clear(level)`.
    pub fn clear(&mut self) {
        let level = self.level;
        for cell in &mut self.mask {
            if *cell == level {
                *cell = 0;
            }
        }
    }

    /// Clear every mask level (reset the whole mask to `0`).
    ///
    /// Mirrors silx `resetSelectionMask`.
    pub fn clear_all(&mut self) {
        self.mask.fill(0);
    }

    /// Invert the current mask level over all points.
    ///
    /// `0` points become the current level and current-level points become
    /// `0`; points at other levels are untouched. Mirrors silx
    /// `BaseMask.invert(level)`.
    pub fn invert(&mut self) {
        let level = self.level;
        for cell in &mut self.mask {
            if *cell == 0 {
                *cell = level;
            } else if *cell == level {
                *cell = 0;
            }
        }
    }

    // --- Undo / redo (silx BaseMask history) ---

    /// Commit the current mask to the undo history.
    ///
    /// Mirrors silx `BaseMask.commit`.
    pub fn commit(&mut self) {
        self.history.commit(&self.mask);
    }

    /// Restore the previous mask snapshot, if any. Returns `true` if applied.
    ///
    /// Mirrors silx `BaseMask.undo`.
    pub fn undo(&mut self) -> bool {
        if let Some(snapshot) = self.history.undo() {
            self.mask = snapshot;
            true
        } else {
            false
        }
    }

    /// Restore the most recently undone snapshot, if any. Returns `true` if
    /// applied.
    ///
    /// Mirrors silx `BaseMask.redo`.
    pub fn redo(&mut self) -> bool {
        if let Some(snapshot) = self.history.redo() {
            self.mask = snapshot;
            true
        } else {
            false
        }
    }

    /// Reset the undo history to the current mask as the only baseline.
    ///
    /// Mirrors silx `BaseMask.resetHistory`.
    pub fn reset_history(&mut self) {
        self.history.reset(&self.mask);
    }

    /// Whether an undo is currently possible (silx `sigUndoable`).
    pub fn can_undo(&self) -> bool {
        self.history.can_undo()
    }

    /// Whether a redo is currently possible (silx `sigRedoable`).
    pub fn can_redo(&self) -> bool {
        self.history.can_redo()
    }

    // --- Selection operations on point arrays ---

    /// Mask or unmask the points at the given `indices` at `level`.
    ///
    /// Mirrors silx `ScatterMask.updatePoints` (ScatterMaskToolsWidget.py:89):
    /// when `mask` is true the points are set to `level`; otherwise only
    /// points already at `level` and in `indices` are cleared. Indices outside
    /// the buffer are ignored.
    pub fn update_points(&mut self, level: u8, indices: &[usize], mask: bool) {
        for &idx in indices {
            if idx < self.mask.len() {
                if mask {
                    self.mask[idx] = level;
                } else if self.mask[idx] == level {
                    self.mask[idx] = 0;
                }
            }
        }
    }

    /// Mask or unmask points selected by a per-point boolean stencil at
    /// `level`.
    ///
    /// Mirrors silx `BaseMask.updateStencil` (_BaseMaskToolsWidget.py:249):
    /// when `mask` is true the stencil-true points are set to `level`,
    /// otherwise only points already at `level` and stencil-true are cleared.
    /// `stencil` must be the same length as the mask.
    pub fn update_stencil(&mut self, level: u8, stencil: &[bool], mask: bool) {
        for (idx, &selected) in stencil.iter().enumerate() {
            if selected && idx < self.mask.len() {
                if mask {
                    self.mask[idx] = level;
                } else if self.mask[idx] == level {
                    self.mask[idx] = 0;
                }
            }
        }
    }

    /// Mask points inside a disk of the given radius centered at
    /// `center = (cx, cy)`.
    ///
    /// Mirrors silx `ScatterMask.updateDisk` (ScatterMaskToolsWidget.py:137):
    /// the stencil is `(y - cy)^2 + (x - cx)^2 < radius^2` (strict). `x` and
    /// `y` are the point coordinate arrays (same length as the mask).
    pub fn update_disk(
        &mut self,
        level: u8,
        center: (f32, f32),
        radius: f32,
        x: &[f32],
        y: &[f32],
    ) {
        self.update_disk_with_mask(level, center, radius, x, y, true);
    }

    /// [`update_disk`] with an explicit mask/unmask flag. `center = (cx, cy)`.
    ///
    /// [`update_disk`]: Self::update_disk
    pub fn update_disk_with_mask(
        &mut self,
        level: u8,
        center: (f32, f32),
        radius: f32,
        x: &[f32],
        y: &[f32],
        mask: bool,
    ) {
        let (cx, cy) = center;
        let r2 = radius * radius;
        let stencil: Vec<bool> = x
            .iter()
            .zip(y.iter())
            .map(|(&px, &py)| {
                let dy = py - cy;
                let dx = px - cx;
                dy * dy + dx * dx < r2
            })
            .collect();
        self.update_stencil(level, &stencil, mask);
    }

    /// Mask or unmask points inside a polygon at `level`.
    ///
    /// Mirrors silx `ScatterMask.updatePolygon` (ScatterMaskToolsWidget.py:107):
    /// a `Polygon.is_inside(y, x)` test per point. `vertices` are `(y, x)`
    /// corners (matching the silx call site, which passes plot `(y, x)`); `x`
    /// and `y` are the point coordinate arrays.
    pub fn update_polygon(
        &mut self,
        level: u8,
        vertices: &[(f32, f32)],
        x: &[f32],
        y: &[f32],
        mask: bool,
    ) {
        let n = x.len().min(y.len());
        let indices: Vec<usize> = (0..n)
            .filter(|&idx| point_in_polygon(vertices, y[idx], x[idx]))
            .collect();
        self.update_points(level, &indices, mask);
    }

    /// Mask or unmask points inside a rectangle at `level`.
    ///
    /// Mirrors silx `ScatterMask.updateRectangle` (ScatterMaskToolsWidget.py:124):
    /// the rectangle is built as the 4-vertex polygon
    /// `[(y, x), (y+height, x), (y+height, x+width), (y, x+width)]` then the
    /// polygon test is applied. `anchor = (y, x)` is the bottom-left corner and
    /// `size = (height, width)`; `px`/`py` are the point coordinate arrays.
    pub fn update_rectangle(
        &mut self,
        level: u8,
        anchor: (f32, f32),
        size: (f32, f32),
        px: &[f32],
        py: &[f32],
        mask: bool,
    ) {
        let (y, x) = anchor;
        let (height, width) = size;
        let vertices = [
            (y, x),
            (y + height, x),
            (y + height, x + width),
            (y, x + width),
        ];
        self.update_polygon(level, &vertices, px, py, mask);
    }

    // --- Threshold / not-finite over the point value array ---

    /// Mask or unmask points whose value is below `threshold` at `level`.
    ///
    /// Mirrors silx `BaseMask.updateBelowThreshold` over the scatter value
    /// array (`values < threshold`).
    pub fn update_below_threshold(
        &mut self,
        level: u8,
        values: &[f32],
        threshold: f32,
        mask: bool,
    ) {
        let stencil: Vec<bool> = values.iter().map(|&v| v < threshold).collect();
        self.update_stencil(level, &stencil, mask);
    }

    /// Mask or unmask points whose value is within `[min, max]` at `level`.
    ///
    /// Mirrors silx `BaseMask.updateBetweenThresholds`
    /// (`min <= value <= max`, inclusive).
    pub fn update_between_thresholds(
        &mut self,
        level: u8,
        values: &[f32],
        min: f32,
        max: f32,
        mask: bool,
    ) {
        let stencil: Vec<bool> = values.iter().map(|&v| min <= v && v <= max).collect();
        self.update_stencil(level, &stencil, mask);
    }

    /// Mask or unmask points whose value is above `threshold` at `level`.
    ///
    /// Mirrors silx `BaseMask.updateAboveThreshold` (`value > threshold`).
    pub fn update_above_threshold(
        &mut self,
        level: u8,
        values: &[f32],
        threshold: f32,
        mask: bool,
    ) {
        let stencil: Vec<bool> = values.iter().map(|&v| v > threshold).collect();
        self.update_stencil(level, &stencil, mask);
    }

    /// Mask every point whose value is not finite (NaN or +/-infinity) at the
    /// current level.
    ///
    /// Mirrors silx `_BaseMaskToolsWidget.updateNotFinite` over the scatter
    /// value array (`~numpy.isfinite(values)`).
    pub fn mask_not_finite(&mut self, values: &[f32]) {
        let stencil: Vec<bool> = values.iter().map(|&v| !v.is_finite()).collect();
        self.update_stencil(self.level, &stencil, true);
    }
}

/// Point-in-polygon test, faithful to `silx.image.shapes.Polygon.is_inside`
/// (image/shapes.pyx:64-102).
///
/// `vertices` are `(row, col)` (equivalently `(y, x)`) corners stored as the
/// silx `Polygon` does, in `f32`. A horizontal ray crossing count (xor) gives
/// the inside test; the closing segment from the last vertex to the first is
/// included by seeding the previous point with the last vertex. Returns
/// `false` for fewer than 1 vertex.
pub fn point_in_polygon(vertices: &[(f32, f32)], row: f32, col: f32) -> bool {
    let nvert = vertices.len();
    if nvert == 0 {
        return false;
    }

    let mut is_inside = false;
    // Start the previous point at the last vertex so the closing segment is
    // visited (silx: pt1 = vertices[nvert - 1]).
    let (mut pt1y, mut pt1x) = vertices[nvert - 1];
    for &(pt2y, pt2x) in vertices {
        if ((pt1y <= row && row < pt2y) || (pt2y <= row && row < pt1y))
            // Extra (optional) condition matching silx to skip work.
            && (col <= pt1x || col <= pt2x)
        {
            let xinters = (row - pt1y) * (pt2x - pt1x) / (pt2y - pt1y) + pt1x;
            if col < xinters {
                is_inside = !is_inside;
            }
        }
        pt1y = pt2y;
        pt1x = pt2x;
    }
    is_inside
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn disk_selects_points_within_radius() {
        // silx updateDisk stencil: (y-cy)^2 + (x-cx)^2 < r^2, strict.
        // Center (0,0), radius 2. Points at distance 0, 1, 2 (on boundary), 3.
        let x = [0.0_f32, 1.0, 2.0, 3.0];
        let y = [0.0_f32, 0.0, 0.0, 0.0];
        let mut m = ScatterMaskWidget::new(4);
        m.update_disk(1, (0.0, 0.0), 2.0, &x, &y);
        // dist^2 = 0, 1, 4, 9; r^2 = 4. Strict <: 0 and 1 selected, 2 (==4) not.
        assert_eq!(m.mask, vec![1, 1, 0, 0]);
    }

    #[test]
    fn disk_radius_boundary_is_strict() {
        // A point exactly on the disk boundary is excluded (strict <).
        let x = [2.0_f32];
        let y = [0.0_f32];
        let mut m = ScatterMaskWidget::new(1);
        m.update_disk(1, (0.0, 0.0), 2.0, &x, &y);
        assert_eq!(m.mask, vec![0]);
    }

    #[test]
    fn polygon_selects_interior_points() {
        // Unit square with corners (y, x): (0,0),(0,4),(4,4),(4,0).
        // Interior point (2,2) inside; (5,5) outside; (0,0) on a corner edge.
        let square = [(0.0_f32, 0.0), (0.0, 4.0), (4.0, 4.0), (4.0, 0.0)];
        // points: x, y arrays
        let x = [2.0_f32, 5.0, 1.0];
        let y = [2.0_f32, 5.0, 3.0];
        let mut m = ScatterMaskWidget::new(3);
        m.update_polygon(1, &square, &x, &y, true);
        // (2,2) inside, (5,5) outside, (3,1) inside.
        assert_eq!(m.mask, vec![1, 0, 1]);
    }

    #[test]
    fn point_in_polygon_triangle_inside_vs_outside() {
        // Triangle (y, x): (0,0), (0,4), (4,0).
        let tri = [(0.0_f32, 0.0), (0.0, 4.0), (4.0, 0.0)];
        // (1,1) is inside; (3,3) is outside (beyond the hypotenuse).
        assert!(point_in_polygon(&tri, 1.0, 1.0));
        assert!(!point_in_polygon(&tri, 3.0, 3.0));
    }

    #[test]
    fn rectangle_selects_points_inside() {
        // Rectangle anchored at (y=1, x=1) with height=2, width=2 -> covers
        // y in [1,3], x in [1,3]. Build via polygon corners as silx does.
        let x = [2.0_f32, 0.0, 5.0];
        let y = [2.0_f32, 0.0, 5.0];
        let mut m = ScatterMaskWidget::new(3);
        m.update_rectangle(1, (1.0, 1.0), (2.0, 2.0), &x, &y, true);
        // (2,2) inside; (0,0) and (5,5) outside.
        assert_eq!(m.mask, vec![1, 0, 0]);
    }

    #[test]
    fn update_points_masks_and_unmasks_by_index() {
        let mut m = ScatterMaskWidget::new(4);
        m.update_points(1, &[0, 2], true);
        assert_eq!(m.mask, vec![1, 0, 1, 0]);
        // Unmask only level-1 points among the given indices.
        m.mask[2] = 2; // change index 2 to a different level
        m.update_points(1, &[0, 2], false);
        // index 0 (level 1) cleared, index 2 (level 2) untouched.
        assert_eq!(m.mask, vec![0, 0, 2, 0]);
    }

    #[test]
    fn update_points_ignores_out_of_range_indices() {
        let mut m = ScatterMaskWidget::new(2);
        m.update_points(1, &[0, 5, 99], true);
        assert_eq!(m.mask, vec![1, 0]);
    }

    #[test]
    fn clear_only_affects_current_level() {
        // silx BaseMask.clear(level): only `level` points go to 0.
        let mut m = ScatterMaskWidget::new(4);
        m.mask = vec![1, 2, 1, 0];
        m.level = 1;
        m.clear();
        assert_eq!(m.mask, vec![0, 2, 0, 0]);
    }

    #[test]
    fn clear_all_resets_every_level() {
        let mut m = ScatterMaskWidget::new(4);
        m.mask = vec![1, 2, 255, 0];
        m.clear_all();
        assert_eq!(m.mask, vec![0, 0, 0, 0]);
    }

    #[test]
    fn invert_swaps_zero_and_current_level_only() {
        // silx BaseMask.invert(level): 0 <-> level, other levels untouched.
        let mut m = ScatterMaskWidget::new(4);
        m.mask = vec![0, 1, 2, 0];
        m.level = 1;
        m.invert();
        assert_eq!(m.mask, vec![1, 0, 2, 1]);
    }

    #[test]
    fn undo_then_redo_round_trips_one_change() {
        let mut m = ScatterMaskWidget::new(4);
        m.mask = vec![1, 0, 0, 0];
        m.commit();
        assert!(m.can_undo());

        assert!(m.undo());
        assert_eq!(m.mask, vec![0, 0, 0, 0]); // back to baseline
        assert!(!m.can_undo());
        assert!(m.can_redo());

        assert!(m.redo());
        assert_eq!(m.mask, vec![1, 0, 0, 0]);
        assert!(!m.can_redo());
    }

    #[test]
    fn undo_is_noop_with_only_baseline() {
        let mut m = ScatterMaskWidget::new(4);
        assert!(!m.can_undo());
        assert!(!m.undo());
    }

    #[test]
    fn threshold_below_is_strict() {
        let mut m = ScatterMaskWidget::new(4);
        let values = [0.0_f32, 1.0, 2.0, 3.0];
        m.update_below_threshold(1, &values, 2.0, true);
        assert_eq!(m.mask, vec![1, 1, 0, 0]);
    }

    #[test]
    fn threshold_between_is_inclusive() {
        let mut m = ScatterMaskWidget::new(5);
        let values = [0.0_f32, 1.0, 2.0, 3.0, 4.0];
        m.update_between_thresholds(1, &values, 1.0, 3.0, true);
        assert_eq!(m.mask, vec![0, 1, 1, 1, 0]);
    }

    #[test]
    fn threshold_above_is_strict() {
        let mut m = ScatterMaskWidget::new(4);
        let values = [0.0_f32, 1.0, 2.0, 3.0];
        m.update_above_threshold(1, &values, 2.0, true);
        assert_eq!(m.mask, vec![0, 0, 0, 1]);
    }

    #[test]
    fn mask_not_finite_masks_nan_and_infinities_only() {
        let mut m = ScatterMaskWidget::new(5);
        m.level = 1;
        let values = [0.0_f32, f32::NAN, f32::INFINITY, f32::NEG_INFINITY, 7.0];
        m.mask_not_finite(&values);
        assert_eq!(m.mask, vec![0, 1, 1, 1, 0]);
    }

    #[test]
    fn empty_mask_selection_is_noop() {
        // Boundary: zero points. Every selection op leaves an empty buffer.
        let mut m = ScatterMaskWidget::new(0);
        assert!(m.is_empty());
        m.update_disk(1, (0.0, 0.0), 1.0, &[], &[]);
        m.update_polygon(1, &[(0.0, 0.0), (1.0, 1.0), (0.0, 1.0)], &[], &[], true);
        m.mask_not_finite(&[]);
        assert!(m.mask.is_empty());
    }

    #[test]
    fn point_in_polygon_empty_vertices_is_false() {
        assert!(!point_in_polygon(&[], 0.0, 0.0));
    }
}