image_renderer/

path.rs

//! 路径系统
//!
//! 提供类似 skia-safe 的路径绘制功能

use crate::point::PointF;
use crate::rect::Rect;

/// 路径命令
#[derive(Debug, Clone, PartialEq)]
pub enum PathCommand {
    /// 移动到指定点（不绘制）
    MoveTo(PointF),
    /// 绘制直线到指定点
    LineTo(PointF),
    /// 绘制二次贝塞尔曲线
    QuadTo {
        /// 控制点
        control: PointF,
        /// 终点
        end: PointF,
    },
    /// 绘制三次贝塞尔曲线
    CubicTo {
        /// 第一个控制点
        control1: PointF,
        /// 第二个控制点
        control2: PointF,
        /// 终点
        end: PointF,
    },
    /// 绘制圆弧
    ArcTo {
        /// 圆弧矩形
        oval: Rect,
        /// 起始角度（度）
        start_angle: f32,
        /// 扫描角度（度）
        sweep_angle: f32,
        /// 是否强制移动到起点
        force_move_to: bool,
    },
    /// 闭合路径
    Close,
}

/// 路径填充规则
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PathFillType {
    /// 非零环绕规则
    Winding,
    /// 奇偶规则
    EvenOdd,
}

impl Default for PathFillType {
    fn default() -> Self {
        PathFillType::Winding
    }
}

/// 路径方向
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PathDirection {
    /// 顺时针
    CW,
    /// 逆时针
    CCW,
}

/// 路径
///
/// 用于构建和绘制复杂的矢量图形
#[derive(Debug, Clone)]
pub struct Path {
    /// 路径命令列表
    commands: Vec<PathCommand>,
    /// 填充规则
    fill_type: PathFillType,
    /// 当前点位置
    current_point: Option<PointF>,
    /// 最后一次 MoveTo 的位置
    last_move_to: Option<PointF>,
}

impl Path {
    /// 创建新的空路径
    pub fn new() -> Self {
        Self {
            commands: Vec::new(),
            fill_type: PathFillType::default(),
            current_point: None,
            last_move_to: None,
        }
    }

    /// 移动到指定点（不绘制线条）
    pub fn move_to(&mut self, point: impl Into<PointF>) {
        let point = point.into();
        self.commands.push(PathCommand::MoveTo(point));
        self.current_point = Some(point);
        self.last_move_to = Some(point);
    }

    /// 从当前点绘制直线到指定点
    pub fn line_to(&mut self, point: impl Into<PointF>) {
        let point = point.into();
        self.commands.push(PathCommand::LineTo(point));
        self.current_point = Some(point);
    }

    /// 绘制二次贝塞尔曲线
    pub fn quad_to(&mut self, control: impl Into<PointF>, end: impl Into<PointF>) {
        let control = control.into();
        let end = end.into();
        self.commands.push(PathCommand::QuadTo { control, end });
        self.current_point = Some(end);
    }

    /// 绘制三次贝塞尔曲线
    pub fn cubic_to(
        &mut self,
        control1: impl Into<PointF>,
        control2: impl Into<PointF>,
        end: impl Into<PointF>,
    ) {
        let control1 = control1.into();
        let control2 = control2.into();
        let end = end.into();
        self.commands.push(PathCommand::CubicTo {
            control1,
            control2,
            end,
        });
        self.current_point = Some(end);
    }

    /// 绘制圆弧
    pub fn arc_to(&mut self, oval: Rect, start_angle: f32, sweep_angle: f32, force_move_to: bool) {
        self.commands.push(PathCommand::ArcTo {
            oval,
            start_angle,
            sweep_angle,
            force_move_to,
        });
    }

    /// 闭合当前路径（连接到最后一次 MoveTo 的位置）
    pub fn close(&mut self) {
        if self.last_move_to.is_some() {
            self.commands.push(PathCommand::Close);
            self.current_point = self.last_move_to;
        }
    }

    /// 添加矩形路径
    pub fn add_rect(&mut self, rect: Rect, dir: PathDirection) {
        let (x, y, w, h) = (
            rect.x as f32,
            rect.y as f32,
            rect.width as f32,
            rect.height as f32,
        );

        match dir {
            PathDirection::CW => {
                self.move_to(PointF::new(x, y));
                self.line_to(PointF::new(x + w, y));
                self.line_to(PointF::new(x + w, y + h));
                self.line_to(PointF::new(x, y + h));
            }
            PathDirection::CCW => {
                self.move_to(PointF::new(x, y));
                self.line_to(PointF::new(x, y + h));
                self.line_to(PointF::new(x + w, y + h));
                self.line_to(PointF::new(x + w, y));
            }
        }
        self.close();
    }

    /// 添加圆形路径
    pub fn add_circle(&mut self, center: impl Into<PointF>, radius: f32, dir: PathDirection) {
        let center = center.into();
        let rect = Rect::new(
            (center.x - radius) as i32,
            (center.y - radius) as i32,
            (radius * 2.0) as u32,
            (radius * 2.0) as u32,
        );
        self.add_oval(rect, dir);
    }

    /// 添加椭圆路径
    pub fn add_oval(&mut self, oval: Rect, dir: PathDirection) {
        let (cx, cy) = (
            oval.x as f32 + oval.width as f32 / 2.0,
            oval.y as f32 + oval.height as f32 / 2.0,
        );
        let (rx, ry) = (oval.width as f32 / 2.0, oval.height as f32 / 2.0);

        // 使用四段三次贝塞尔曲线近似椭圆
        let kappa = 0.5522847498; // 4/3 * (sqrt(2) - 1)
        let ox = rx * kappa;
        let oy = ry * kappa;

        match dir {
            PathDirection::CW => {
                self.move_to(PointF::new(cx - rx, cy));
                self.cubic_to(
                    PointF::new(cx - rx, cy - oy),
                    PointF::new(cx - ox, cy - ry),
                    PointF::new(cx, cy - ry),
                );
                self.cubic_to(
                    PointF::new(cx + ox, cy - ry),
                    PointF::new(cx + rx, cy - oy),
                    PointF::new(cx + rx, cy),
                );
                self.cubic_to(
                    PointF::new(cx + rx, cy + oy),
                    PointF::new(cx + ox, cy + ry),
                    PointF::new(cx, cy + ry),
                );
                self.cubic_to(
                    PointF::new(cx - ox, cy + ry),
                    PointF::new(cx - rx, cy + oy),
                    PointF::new(cx - rx, cy),
                );
            }
            PathDirection::CCW => {
                self.move_to(PointF::new(cx - rx, cy));
                self.cubic_to(
                    PointF::new(cx - rx, cy + oy),
                    PointF::new(cx - ox, cy + ry),
                    PointF::new(cx, cy + ry),
                );
                self.cubic_to(
                    PointF::new(cx + ox, cy + ry),
                    PointF::new(cx + rx, cy + oy),
                    PointF::new(cx + rx, cy),
                );
                self.cubic_to(
                    PointF::new(cx + rx, cy - oy),
                    PointF::new(cx + ox, cy - ry),
                    PointF::new(cx, cy - ry),
                );
                self.cubic_to(
                    PointF::new(cx - ox, cy - ry),
                    PointF::new(cx - rx, cy - oy),
                    PointF::new(cx - rx, cy),
                );
            }
        }
        self.close();
    }

    /// 添加圆角矩形路径
    pub fn add_rounded_rect(&mut self, rect: Rect, radius: f32, dir: PathDirection) {
        let (x, y, w, h) = (
            rect.x as f32,
            rect.y as f32,
            rect.width as f32,
            rect.height as f32,
        );
        let r = radius.min(w / 2.0).min(h / 2.0);

        if r <= 0.0 {
            self.add_rect(rect, dir);
            return;
        }

        let kappa = 0.5522847498;
        let o = r * kappa;

        match dir {
            PathDirection::CW => {
                self.move_to(PointF::new(x + r, y));
                self.line_to(PointF::new(x + w - r, y));
                self.cubic_to(
                    PointF::new(x + w - r + o, y),
                    PointF::new(x + w, y + r - o),
                    PointF::new(x + w, y + r),
                );
                self.line_to(PointF::new(x + w, y + h - r));
                self.cubic_to(
                    PointF::new(x + w, y + h - r + o),
                    PointF::new(x + w - r + o, y + h),
                    PointF::new(x + w - r, y + h),
                );
                self.line_to(PointF::new(x + r, y + h));
                self.cubic_to(
                    PointF::new(x + r - o, y + h),
                    PointF::new(x, y + h - r + o),
                    PointF::new(x, y + h - r),
                );
                self.line_to(PointF::new(x, y + r));
                self.cubic_to(
                    PointF::new(x, y + r - o),
                    PointF::new(x + r - o, y),
                    PointF::new(x + r, y),
                );
            }
            PathDirection::CCW => {
                self.move_to(PointF::new(x + r, y));
                self.cubic_to(
                    PointF::new(x + r - o, y),
                    PointF::new(x, y + r - o),
                    PointF::new(x, y + r),
                );
                self.line_to(PointF::new(x, y + h - r));
                self.cubic_to(
                    PointF::new(x, y + h - r + o),
                    PointF::new(x + r - o, y + h),
                    PointF::new(x + r, y + h),
                );
                self.line_to(PointF::new(x + w - r, y + h));
                self.cubic_to(
                    PointF::new(x + w - r + o, y + h),
                    PointF::new(x + w, y + h - r + o),
                    PointF::new(x + w, y + h - r),
                );
                self.line_to(PointF::new(x + w, y + r));
                self.cubic_to(
                    PointF::new(x + w, y + r - o),
                    PointF::new(x + w - r + o, y),
                    PointF::new(x + w - r, y),
                );
            }
        }
        self.close();
    }

    /// 重置路径（清空所有命令）
    pub fn reset(&mut self) {
        self.commands.clear();
        self.current_point = None;
        self.last_move_to = None;
    }

    /// 设置填充规则
    pub fn set_fill_type(&mut self, fill_type: PathFillType) {
        self.fill_type = fill_type;
    }

    /// 获取填充规则
    pub fn fill_type(&self) -> PathFillType {
        self.fill_type
    }

    /// 获取路径命令列表
    pub fn commands(&self) -> &[PathCommand] {
        &self.commands
    }

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

    /// 获取路径命令数量
    pub fn count_points(&self) -> usize {
        self.commands.len()
    }

    /// 获取当前点位置
    pub fn current_point(&self) -> Option<PointF> {
        self.current_point
    }

    /// 获取路径的边界框
    pub fn bounds(&self) -> Option<Rect> {
        if self.commands.is_empty() {
            return None;
        }

        let mut min_x = f32::MAX;
        let mut min_y = f32::MAX;
        let mut max_x = f32::MIN;
        let mut max_y = f32::MIN;

        for cmd in &self.commands {
            match cmd {
                PathCommand::MoveTo(p) | PathCommand::LineTo(p) => {
                    min_x = min_x.min(p.x);
                    min_y = min_y.min(p.y);
                    max_x = max_x.max(p.x);
                    max_y = max_y.max(p.y);
                }
                PathCommand::QuadTo { control, end } => {
                    min_x = min_x.min(control.x).min(end.x);
                    min_y = min_y.min(control.y).min(end.y);
                    max_x = max_x.max(control.x).max(end.x);
                    max_y = max_y.max(control.y).max(end.y);
                }
                PathCommand::CubicTo {
                    control1,
                    control2,
                    end,
                } => {
                    min_x = min_x.min(control1.x).min(control2.x).min(end.x);
                    min_y = min_y.min(control1.y).min(control2.y).min(end.y);
                    max_x = max_x.max(control1.x).max(control2.x).max(end.x);
                    max_y = max_y.max(control1.y).max(control2.y).max(end.y);
                }
                PathCommand::ArcTo { oval, .. } => {
                    min_x = min_x.min(oval.x as f32);
                    min_y = min_y.min(oval.y as f32);
                    max_x = max_x.max((oval.x + oval.width as i32) as f32);
                    max_y = max_y.max((oval.y + oval.height as i32) as f32);
                }
                PathCommand::Close => {}
            }
        }

        if min_x <= max_x && min_y <= max_y {
            Some(Rect::new(
                min_x as i32,
                min_y as i32,
                (max_x - min_x) as u32,
                (max_y - min_y) as u32,
            ))
        } else {
            None
        }
    }

    /// 应用变换矩阵到路径
    pub fn transform(&self, matrix: &crate::matrix::Matrix) -> Path {
        let mut new_path = Path {
            commands: Vec::new(),
            fill_type: self.fill_type,
            current_point: None,
            last_move_to: None,
        };

        for cmd in &self.commands {
            match cmd {
                PathCommand::MoveTo(p) => {
                    let (x, y) = matrix.map_point(p.x, p.y);
                    let new_point = PointF { x, y };
                    new_path.commands.push(PathCommand::MoveTo(new_point));
                    new_path.current_point = Some(new_point);
                    new_path.last_move_to = Some(new_point);
                }
                PathCommand::LineTo(p) => {
                    let (x, y) = matrix.map_point(p.x, p.y);
                    let new_point = PointF { x, y };
                    new_path.commands.push(PathCommand::LineTo(new_point));
                    new_path.current_point = Some(new_point);
                }
                PathCommand::QuadTo { control, end } => {
                    let (cx, cy) = matrix.map_point(control.x, control.y);
                    let (ex, ey) = matrix.map_point(end.x, end.y);
                    new_path.commands.push(PathCommand::QuadTo {
                        control: PointF { x: cx, y: cy },
                        end: PointF { x: ex, y: ey },
                    });
                    new_path.current_point = Some(PointF { x: ex, y: ey });
                }
                PathCommand::CubicTo {
                    control1,
                    control2,
                    end,
                } => {
                    let (c1x, c1y) = matrix.map_point(control1.x, control1.y);
                    let (c2x, c2y) = matrix.map_point(control2.x, control2.y);
                    let (ex, ey) = matrix.map_point(end.x, end.y);
                    new_path.commands.push(PathCommand::CubicTo {
                        control1: PointF { x: c1x, y: c1y },
                        control2: PointF { x: c2x, y: c2y },
                        end: PointF { x: ex, y: ey },
                    });
                    new_path.current_point = Some(PointF { x: ex, y: ey });
                }
                PathCommand::ArcTo {
                    oval,
                    start_angle,
                    sweep_angle,
                    force_move_to,
                } => {
                    // 对于圆弧，我们需要变换矩形
                    let (x1, y1) = matrix.map_point(oval.x as f32, oval.y as f32);
                    let (x2, y2) = matrix.map_point(
                        (oval.x + oval.width as i32) as f32,
                        (oval.y + oval.height as i32) as f32,
                    );
                    let new_oval = crate::rect::Rect::new(
                        x1 as i32,
                        y1 as i32,
                        (x2 - x1).abs() as u32,
                        (y2 - y1).abs() as u32,
                    );
                    new_path.commands.push(PathCommand::ArcTo {
                        oval: new_oval,
                        start_angle: *start_angle,
                        sweep_angle: *sweep_angle,
                        force_move_to: *force_move_to,
                    });
                }
                PathCommand::Close => {
                    new_path.commands.push(PathCommand::Close);
                    new_path.current_point = new_path.last_move_to;
                }
            }
        }

        new_path
    }

    /// 判断点是否在路径内
    pub fn contains(&self, x: f32, y: f32) -> bool {
        // 使用射线法判断点是否在路径内
        let mut crossings = 0;
        let mut current_point = PointF { x: 0.0, y: 0.0 };
        let mut start_point = PointF { x: 0.0, y: 0.0 };

        for cmd in &self.commands {
            match cmd {
                PathCommand::MoveTo(p) => {
                    current_point = *p;
                    start_point = *p;
                }
                PathCommand::LineTo(p) => {
                    if self.line_crosses_ray(current_point, *p, x, y) {
                        crossings += 1;
                    }
                    current_point = *p;
                }
                PathCommand::Close => {
                    if self.line_crosses_ray(current_point, start_point, x, y) {
                        crossings += 1;
                    }
                    current_point = start_point;
                }
                _ => {
                    // 对于曲线，简化处理：将其视为直线
                    // 实际应用中应该使用更精确的算法
                }
            }
        }

        // 根据填充规则判断
        match self.fill_type {
            PathFillType::Winding => crossings != 0,
            PathFillType::EvenOdd => crossings % 2 != 0,
        }
    }

    /// 辅助方法：判断线段是否与从点 (x, y) 向右的射线相交
    fn line_crosses_ray(&self, p1: PointF, p2: PointF, x: f32, y: f32) -> bool {
        // 如果线段完全在点的上方或下方，不相交
        if (p1.y > y && p2.y > y) || (p1.y < y && p2.y < y) {
            return false;
        }

        // 如果线段是水平的且在点的高度上，特殊处理
        if (p1.y - p2.y).abs() < 1e-6 {
            return false;
        }

        // 计算射线与线段的交点的 x 坐标
        let t = (y - p1.y) / (p2.y - p1.y);
        let intersection_x = p1.x + t * (p2.x - p1.x);

        // 如果交点在点的右侧，则相交
        intersection_x > x
    }
}

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

// 实现 From trait 以支持 Point 到 PointF 的转换

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

    #[test]
    fn test_path_creation() {
        let path = Path::new();
        assert!(path.is_empty());
        assert_eq!(path.count_points(), 0);
    }

    #[test]
    fn test_path_move_to() {
        let mut path = Path::new();
        path.move_to(PointF::new(10.0, 20.0));
        assert_eq!(path.count_points(), 1);
        assert_eq!(path.current_point(), Some(PointF::new(10.0, 20.0)));
    }

    #[test]
    fn test_path_line_to() {
        let mut path = Path::new();
        path.move_to(PointF::new(0.0, 0.0));
        path.line_to(PointF::new(10.0, 10.0));
        assert_eq!(path.count_points(), 2);
    }

    #[test]
    fn test_path_rect() {
        let mut path = Path::new();
        path.add_rect(Rect::new(10, 10, 100, 50), PathDirection::CW);
        assert!(!path.is_empty());
    }

    #[test]
    fn test_path_circle() {
        let mut path = Path::new();
        path.add_circle(PointF::new(50.0, 50.0), 25.0, PathDirection::CW);
        assert!(!path.is_empty());
    }

    #[test]
    fn test_path_bounds() {
        let mut path = Path::new();
        path.move_to(PointF::new(10.0, 20.0));
        path.line_to(PointF::new(100.0, 80.0));
        let bounds = path.bounds().unwrap();
        assert_eq!(bounds.x, 10);
        assert_eq!(bounds.y, 20);
    }
}