path: root/svgbob/src/buffer/cell_buffer/cell.rs

use crate::{util, Point};
use parry2d::query::PointQuery;
use parry2d::{
    bounding_volume::AABB,
    math::Isometry,
    query::intersection_test,
    shape::{Polyline, Segment},
};
use std::{cmp, cmp::Ordering, fmt};

mod cell_grid;

pub use cell_grid::CellGrid;

/// ```ignore
///      0 1 2 3 4           B C D
///     0┌─┬─┬─┬─┐        A┌─┬─┬─┬─┐E
///     1├─┼─┼─┼─┤         │ │ │ │ │
///     2├─┼─┼─┼─┤        F├─G─H─I─┤J
///     3├─┼─┼─┼─┤         │ │ │ │ │
///     4├─┼─┼─┼─┤        K├─L─M─N─┤O
///     5├─┼─┼─┼─┤         │ │ │ │ │
///     6├─┼─┼─┼─┤        P├─Q─R─S─┤T
///     7├─┼─┼─┼─┤         │ │ │ │ │
///     8└─┴─┴─┴─┘        U└─┴─┴─┴─┘Y
/// ```                      V W X

/// A single element in the terminal that
/// can fit 1 character.
/// Describe the exact location of a point/subcell in a grid.
#[derive(Debug, PartialEq, Hash, PartialOrd, Clone, Copy)]
pub struct Cell {
    pub x: i32,
    pub y: i32,
}

impl fmt::Display for Cell {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "({},{})", self.x, self.y)
    }
}

impl Eq for Cell {}
impl Ord for Cell {
    fn cmp(&self, other: &Self) -> Ordering {
        self.y.cmp(&other.y).then(self.x.cmp(&other.x))
    }
}

macro_rules! cell_grid {
    ($($a:ident),*) => {
        /// The point at sepcific cell grid of this cell
        $(pub fn $a(&self) -> Point {
            self.top_left_most() + CellGrid::$a()
        })*
    }
}

impl Cell {
    cell_grid!(
        a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
        y
    );

    pub fn new(x: i32, y: i32) -> Self {
        Cell { x, y }
    }

    /// returns true if the other cell is at: top_left, top, top_right, left, right, bottom_left,
    /// bottom, bottom_right of self
    pub fn is_adjacent(&self, other: &Self) -> bool {
        (other.x - self.x).abs() <= 1 && (other.y - self.y).abs() <= 1
    }

    /// Derive which cell this points falls into and snap the point closes to any
    /// intersection in the cell grid.
    /// FIXME: need to find a way to snap a group of point that lies in boundaries to
    /// snap together to a common cell.
    pub fn snap_point(point: Point) -> (Self, Point) {
        let x = (point.x / Self::width()).floor();
        let y = (point.y / Self::height()).floor();
        let cell = Self::new(x as i32, y as i32);
        let snap = Self::snap(cell.localize_point(point));
        (cell, snap)
    }

    pub fn snap_group(points: &[Point]) -> Self {
        let snaps: Vec<(Self, Point)> = points
            .iter()
            .map(|point| Self::snap_point(*point))
            .collect();
        let (cells, _snap_points): (Vec<Self>, Vec<Point>) =
            snaps.into_iter().unzip();
        let min_cell: Self =
            cells.into_iter().min().expect("should have a min cell");
        min_cell
    }

    pub(in crate) fn absolute_position(&self, point: Point) -> Point {
        self.top_left_most() + point
    }

    /// The point at the top right of this cell
    pub fn top_left_most(&self) -> Point {
        let px = self.x as f32 * CellGrid::width();
        let py = self.y as f32 * CellGrid::height();
        Point::new(px, py)
    }

    pub fn bottom_right_most(&self) -> Point {
        let px = (self.x + 1) as f32 * CellGrid::width();
        let py = (self.y + 1) as f32 * CellGrid::height();
        Point::new(px, py)
    }

    /// turn point into relative distance from the top-left of this cell
    /// by simply deducting the point p with this cell's top_left_most point
    pub fn localize_point(&self, point: Point) -> Point {
        point - self.top_left_most()
    }

    pub fn localize_cell(&self, cell: Cell) -> Cell {
        Cell::new(cell.x - self.x, cell.y - self.y)
    }

    /// the bounding box of this cell
    #[inline]
    fn bounding_box(&self) -> AABB {
        let start = Point::new(
            self.x as f32 * Self::width(),
            self.y as f32 * Self::height(),
        );
        let end = Point::new(
            (self.x + 1) as f32 * Self::width(),
            (self.y + 1) as f32 * Self::height(),
        );
        AABB::new(*start, *end)
    }

    /// Convert the bounding box aabb to polyline segment
    /// the dots from top-left, top-right, bottom-right, bottom-left then closing to top-left
    /// The polyline is then used to testing for intersection with the line segment
    fn polyline(&self) -> Polyline {
        let aabb = self.bounding_box();
        let min = aabb.mins;
        let max = aabb.maxs;
        let x1 = min.x;
        let y1 = min.y;
        let x2 = max.x;
        let y2 = max.y;
        let c1 = Point::new(x1, y1); // top-left
        let c2 = Point::new(x2, y1); // top-right
        let c3 = Point::new(x2, y2); // bottom-right
        let c4 = Point::new(x1, y2); // bottom-left
        Polyline::new(vec![*c1, *c2, *c3, *c4, *c1], None)
    }

    pub fn width() -> f32 {
        CellGrid::width()
    }

    pub fn height() -> f32 {
        CellGrid::height()
    }

    pub fn unit(l: i32) -> f32 {
        CellGrid::unit_x() * l as f32
    }

    /// test whether this cell is intersected with the line segment
    /// with point `start` and `end`
    pub fn is_intersected(&self, start: Point, end: Point) -> bool {
        let pl = self.polyline();
        let segment = Segment::new(*start, *end);
        intersection_test(
            &Isometry::identity(),
            &pl,
            &Isometry::identity(),
            &segment,
        )
        .expect("must pass intersection test")
    }

    /// check if this cell is bounded by the lower bound and upper bound
    pub fn is_bounded(&self, bound1: Cell, bound2: Cell) -> bool {
        let (lower_bound, upper_bound) = Self::rearrange_bound(bound1, bound2);
        self.x >= lower_bound.x
            && self.y >= lower_bound.y
            && self.x <= upper_bound.x
            && self.y <= upper_bound.y
    }

    /// snap a point closest to any of the intersection of this cellgrid