image_renderer/

clip.rs

//! 裁剪系统
//!
//! 提供矩形和路径裁剪功能

use crate::path::Path;
use crate::point::PointF;
use crate::rect::{IRect, Rect};

/// 裁剪操作类型
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ClipOp {
    /// 交集（保留重叠部分）
    Intersect,
    /// 差集（从当前裁剪区域中减去新区域）
    Difference,
}

/// 裁剪区域类型
#[derive(Debug, Clone)]
pub enum ClipRegion {
    /// 矩形裁剪
    Rect(IRect),
    /// 路径裁剪
    Path(Path),
    /// 空裁剪（不绘制任何内容）
    Empty,
}

impl ClipRegion {
    /// 创建矩形裁剪区域
    pub fn from_rect(rect: IRect) -> Self {
        ClipRegion::Rect(rect)
    }

    /// 创建路径裁剪区域
    pub fn from_path(path: Path) -> Self {
        ClipRegion::Path(path)
    }

    /// 创建空裁剪区域
    pub fn empty() -> Self {
        ClipRegion::Empty
    }

    /// 判断点是否在裁剪区域内
    pub fn contains_point(&self, x: i32, y: i32) -> bool {
        match self {
            ClipRegion::Rect(rect) => {
                x >= rect.x
                    && x < rect.x + rect.width as i32
                    && y >= rect.y
                    && y < rect.y + rect.height as i32
            }
            ClipRegion::Path(path) => {
                // 使用射线法判断点是否在路径内
                self.point_in_path(PointF::new(x as f32, y as f32), path)
            }
            ClipRegion::Empty => false,
        }
    }

    /// 判断点是否在路径内（射线法）
    fn point_in_path(&self, point: PointF, path: &Path) -> bool {
        let commands = path.commands();
        if commands.is_empty() {
            return false;
        }

        let mut crossings = 0;
        let mut current = PointF::new(0.0, 0.0);
        let mut start = PointF::new(0.0, 0.0);

        for cmd in commands {
            match cmd {
                crate::path::PathCommand::MoveTo(p) => {
                    current = *p;
                    start = *p;
                }
                crate::path::PathCommand::LineTo(p) => {
                    if self.ray_intersects_segment(point, current, *p) {
                        crossings += 1;
                    }
                    current = *p;
                }
                crate::path::PathCommand::Close => {
                    if self.ray_intersects_segment(point, current, start) {
                        crossings += 1;
                    }
                    current = start;
                }
                crate::path::PathCommand::QuadTo { end, .. } => {
                    // 简化处理：将二次贝塞尔曲线当作直线
                    if self.ray_intersects_segment(point, current, *end) {
                        crossings += 1;
                    }
                    current = *end;
                }
                crate::path::PathCommand::CubicTo { end, .. } => {
                    // 简化处理：将三次贝塞尔曲线当作直线
                    if self.ray_intersects_segment(point, current, *end) {
                        crossings += 1;
                    }
                    current = *end;
                }
                crate::path::PathCommand::ArcTo { .. } => {
                    // 圆弧暂不处理
                }
            }
        }

        // 奇数次交叉表示在路径内
        crossings % 2 == 1
    }

    /// 判断从点发出的水平射线是否与线段相交
    fn ray_intersects_segment(&self, point: PointF, p1: PointF, p2: PointF) -> bool {
        // 射线向右延伸
        let py = point.y;
        let px = point.x;

        // 线段的 y 坐标范围
        let (y_min, y_max) = if p1.y < p2.y {
            (p1.y, p2.y)
        } else {
            (p2.y, p1.y)
        };

        // 射线的 y 坐标不在线段 y 范围内
        if py < y_min || py >= y_max {
            return false;
        }

        // 计算交点的 x 坐标
        let t = (py - p1.y) / (p2.y - p1.y);
        let x_intersect = p1.x + t * (p2.x - p1.x);

        // 交点在射线上（点的右侧）
        x_intersect >= px
    }

    /// 获取裁剪区域的边界矩形
    pub fn bounds(&self) -> Option<IRect> {
        match self {
            ClipRegion::Rect(rect) => Some(*rect),
            ClipRegion::Path(path) => path
                .bounds()
                .map(|r| IRect::new(r.x, r.y, r.width, r.height)),
            ClipRegion::Empty => None,
        }
    }

    /// 判断裁剪区域是否为空
    pub fn is_empty(&self) -> bool {
        matches!(self, ClipRegion::Empty)
    }

    /// 与另一个裁剪区域求交集
    pub fn intersect(&self, other: &ClipRegion) -> ClipRegion {
        match (self, other) {
            (ClipRegion::Empty, _) | (_, ClipRegion::Empty) => ClipRegion::Empty,
            (ClipRegion::Rect(r1), ClipRegion::Rect(r2)) => {
                // 计算两个矩形的交集
                let x1 = r1.x.max(r2.x);
                let y1 = r1.y.max(r2.y);
                let x2 = (r1.x + r1.width as i32).min(r2.x + r2.width as i32);
                let y2 = (r1.y + r1.height as i32).min(r2.y + r2.height as i32);

                if x1 < x2 && y1 < y2 {
                    ClipRegion::Rect(IRect::new(x1, y1, (x2 - x1) as u32, (y2 - y1) as u32))
                } else {
                    ClipRegion::Empty
                }
            }
            (ClipRegion::Rect(rect), ClipRegion::Path(path))
            | (ClipRegion::Path(path), ClipRegion::Rect(rect)) => {
                // 简化处理：使用路径的边界矩形与矩形求交集
                if let Some(path_bounds) = path.bounds() {
                    let path_irect = IRect::new(
                        path_bounds.x,
                        path_bounds.y,
                        path_bounds.width,
                        path_bounds.height,
                    );
                    ClipRegion::Rect(path_irect).intersect(&ClipRegion::Rect(*rect))
                } else {
                    ClipRegion::Empty
                }
            }
            (ClipRegion::Path(_), ClipRegion::Path(_)) => {
                // 路径与路径的交集较复杂，这里简化处理
                // 实际应用中可以使用更复杂的算法
                self.clone()
            }
        }
    }

    /// 从当前裁剪区域中减去另一个区域
    pub fn difference(&self, other: &ClipRegion) -> ClipRegion {
        match (self, other) {
            (ClipRegion::Empty, _) => ClipRegion::Empty,
            (_, ClipRegion::Empty) => self.clone(),
            // 差集操作较复杂，这里简化处理
            // 实际应用中需要更复杂的算法
            _ => self.clone(),
        }
    }
}

/// 裁剪栈
///
/// 用于管理多层裁剪区域
#[derive(Debug, Clone)]
pub struct ClipStack {
    /// 裁剪区域栈
    stack: Vec<ClipRegion>,
}

impl ClipStack {
    /// 创建新的裁剪栈
    pub fn new() -> Self {
        Self { stack: Vec::new() }
    }

    /// 创建带初始裁剪区域的栈
    pub fn with_rect(rect: IRect) -> Self {
        let mut stack = Self::new();
        stack.push(ClipRegion::Rect(rect));
        stack
    }

    /// 压入新的裁剪区域
    pub fn push(&mut self, region: ClipRegion) {
        self.stack.push(region);
    }

    /// 弹出裁剪区域
    pub fn pop(&mut self) -> Option<ClipRegion> {
        self.stack.pop()
    }

    /// 获取当前有效的裁剪区域
    pub fn current(&self) -> Option<&ClipRegion> {
        self.stack.last()
    }

    /// 应用裁剪操作
    pub fn clip(&mut self, region: ClipRegion, op: ClipOp) {
        if let Some(current) = self.stack.last() {
            let new_region = match op {
                ClipOp::Intersect => current.intersect(&region),
                ClipOp::Difference => current.difference(&region),
            };
            self.stack.push(new_region);
        } else {
            // 如果栈为空，直接压入新区域
            self.stack.push(region);
        }
    }

    /// 裁剪矩形
    pub fn clip_rect(&mut self, rect: IRect, op: ClipOp) {
        self.clip(ClipRegion::Rect(rect), op);
    }

    /// 裁剪路径
    pub fn clip_path(&mut self, path: Path, op: ClipOp) {
        self.clip(ClipRegion::Path(path), op);
    }

    /// 判断点是否在当前裁剪区域内
    pub fn contains_point(&self, x: i32, y: i32) -> bool {
        if let Some(region) = self.current() {
            region.contains_point(x, y)
        } else {
            true // 没有裁剪区域时，所有点都可见
        }
    }

    /// 获取当前裁剪区域的边界
    pub fn bounds(&self) -> Option<IRect> {
        self.current().and_then(|r| r.bounds())
    }

    /// 判断栈是否为空
    pub fn is_empty(&self) -> bool {
        self.stack.is_empty()
    }

    /// 获取栈的深度
    pub fn depth(&self) -> usize {
        self.stack.len()
    }

    /// 清空裁剪栈
    pub fn clear(&mut self) {
        self.stack.clear();
    }

    /// 保存当前裁剪状态（用于状态栈）
    pub fn save(&mut self) {
        // 复制当前裁剪区域到栈顶
        if let Some(current) = self.current() {
            self.stack.push(current.clone());
        }
    }

    /// 恢复之前的裁剪状态
    pub fn restore(&mut self) {
        self.pop();
    }

    /// 获取当前裁剪区域的边界（别名方法）
    pub fn get_bounds(&self) -> Option<Rect> {
        self.bounds()
            .map(|r| Rect::new(r.x, r.y, r.width, r.height))
    }
}

impl Default for ClipStack {
    fn default() -> Self {
        Self::new()
    }
}

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

    #[test]
    fn test_clip_region_rect() {
        let rect = IRect::new(10, 10, 100, 100);
        let region = ClipRegion::from_rect(rect);

        assert!(region.contains_point(50, 50));
        assert!(!region.contains_point(5, 5));
        assert!(!region.contains_point(150, 150));
    }

    #[test]
    fn test_clip_region_intersect() {
        let rect1 = IRect::new(0, 0, 100, 100);
        let rect2 = IRect::new(50, 50, 100, 100);

        let region1 = ClipRegion::from_rect(rect1);
        let region2 = ClipRegion::from_rect(rect2);

        let intersection = region1.intersect(&region2);

        if let ClipRegion::Rect(result) = intersection {
            assert_eq!(result.x, 50);
            assert_eq!(result.y, 50);
            assert_eq!(result.width, 50);
            assert_eq!(result.height, 50);
        } else {
            panic!("Expected Rect region");
        }
    }

    #[test]
    fn test_clip_stack() {
        let mut stack = ClipStack::new();
        assert!(stack.is_empty());

        let rect = IRect::new(0, 0, 100, 100);
        stack.push(ClipRegion::from_rect(rect));
        assert_eq!(stack.depth(), 1);

        assert!(stack.contains_point(50, 50));
        assert!(!stack.contains_point(150, 150));

        stack.pop();
        assert!(stack.is_empty());
    }

    #[test]
    fn test_clip_stack_intersect() {
        let mut stack = ClipStack::new();

        let rect1 = IRect::new(0, 0, 100, 100);
        stack.clip_rect(rect1, ClipOp::Intersect);

        let rect2 = IRect::new(50, 50, 100, 100);
        stack.clip_rect(rect2, ClipOp::Intersect);

        // 交集应该是 (50, 50, 50, 50)
        assert!(stack.contains_point(75, 75));
        assert!(!stack.contains_point(25, 25));
        assert!(!stack.contains_point(125, 125));
    }

    #[test]
    fn test_clip_region_bounds() {
        let rect = IRect::new(10, 20, 100, 50);
        let region = ClipRegion::from_rect(rect);
        let bounds = region.bounds().unwrap();

        assert_eq!(bounds.x, 10);
        assert_eq!(bounds.y, 20);
        assert_eq!(bounds.width, 100);
        assert_eq!(bounds.height, 50);
    }

    #[test]
    fn test_empty_clip_region() {
        let region = ClipRegion::empty();
        assert!(region.is_empty());
        assert!(!region.contains_point(0, 0));
        assert!(region.bounds().is_none());
    }
}