rpdfium_graphics/

cfx_path.rs

// Derived from PDFium's core/fxge/cfx_path.h
// Original: Copyright 2014 The PDFium Authors
// Licensed under BSD-3-Clause / Apache-2.0
// See pdfium-upstream/LICENSE for the original license.

//! Path construction operations and styling.
//!
//! PDF path operations follow the PostScript model: a current path is built
//! by appending segments (move, line, curve, close), then painted with a
//! fill and/or stroke operation.

use rpdfium_core::Rect;

/// A single path construction operation.
///
/// Coordinates are in user space (pre-CTM transformation).
#[derive(Debug, Clone, PartialEq)]
pub enum PathOp {
    /// Move to a new point, starting a new subpath.
    MoveTo { x: f32, y: f32 },
    /// Draw a straight line to the given point.
    LineTo { x: f32, y: f32 },
    /// Draw a cubic Bezier curve with two control points and an endpoint.
    CurveTo {
        x1: f32,
        y1: f32,
        x2: f32,
        y2: f32,
        x3: f32,
        y3: f32,
    },
    /// Close the current subpath with a straight line back to its start.
    Close,
}

/// Fill rule for path operations (PDF spec Table 60).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum FillRule {
    /// Non-zero winding number rule (default).
    #[default]
    NonZero,
    /// Even-odd rule.
    EvenOdd,
}

/// Line cap style (PDF spec Table 54).
///
/// Specifies the shape to be used at the ends of open subpaths when stroked.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[repr(u8)]
pub enum LineCapStyle {
    /// Butt cap: stroke is squared off at the endpoint.
    #[default]
    Butt = 0,
    /// Round cap: semicircular arc at the endpoint.
    Round = 1,
    /// Projecting square cap: extends half the line width past endpoint.
    Square = 2,
}

impl LineCapStyle {
    /// Convert from a PDF integer value.
    pub fn from_i64(value: i64) -> Self {
        match value {
            0 => Self::Butt,
            1 => Self::Round,
            2 => Self::Square,
            _ => Self::Butt,
        }
    }
}

/// Line join style (PDF spec Table 55).
///
/// Specifies the shape to be used at corners of stroked paths.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[repr(u8)]
pub enum LineJoinStyle {
    /// Miter join: outer edges extended to meet at a point.
    #[default]
    Miter = 0,
    /// Round join: circular arc between outer edges.
    Round = 1,
    /// Bevel join: straight line between outer edges.
    Bevel = 2,
}

impl LineJoinStyle {
    /// Convert from a PDF integer value.
    pub fn from_i64(value: i64) -> Self {
        match value {
            0 => Self::Miter,
            1 => Self::Round,
            2 => Self::Bevel,
            _ => Self::Miter,
        }
    }
}

/// Dash pattern for stroked paths (PDF spec §8.4.3.6).
#[derive(Debug, Clone, PartialEq, Default)]
pub struct DashPattern {
    /// Alternating dash and gap lengths.
    pub array: Vec<f32>,
    /// Phase offset into the dash pattern.
    pub phase: f32,
}

/// Style for path rendering, combining fill rule, stroke, and line attributes.
///
/// Default values match the PDF initial graphics state (PDF spec §8.4.1).
#[derive(Debug, Clone, PartialEq)]
pub struct PathStyle {
    /// Fill rule, or `None` for no fill.
    pub fill: Option<FillRule>,
    /// Whether to stroke the path.
    pub stroke: bool,
    /// Line width in user space units (default: 1.0).
    pub line_width: f32,
    /// Line cap style (default: Butt).
    pub line_cap: LineCapStyle,
    /// Line join style (default: Miter).
    pub line_join: LineJoinStyle,
    /// Miter limit (default: 10.0).
    pub miter_limit: f32,
    /// Dash pattern, or `None` for solid line.
    pub dash: Option<DashPattern>,
}

impl Default for PathStyle {
    fn default() -> Self {
        Self {
            fill: None,
            stroke: false,
            line_width: 1.0,
            line_cap: LineCapStyle::default(),
            line_join: LineJoinStyle::default(),
            miter_limit: 10.0,
            dash: None,
        }
    }
}

/// Computes the axis-aligned bounding box of a path.
///
/// Corresponds to `CFX_Path::GetBoundingBox()` in upstream PDFium.
/// All coordinates including Bézier control points are included (conservative
/// bound — the true tight bound for curves may be smaller, but this matches
/// upstream behaviour).
///
/// Returns `None` if `ops` is empty or contains only [`PathOp::Close`].
pub fn bounding_box(ops: &[PathOp]) -> Option<Rect> {
    let mut min_x = f32::INFINITY;
    let mut min_y = f32::INFINITY;
    let mut max_x = f32::NEG_INFINITY;
    let mut max_y = f32::NEG_INFINITY;
    let mut found = false;

    for op in ops {
        match op {
            PathOp::MoveTo { x, y } | PathOp::LineTo { x, y } => {
                min_x = min_x.min(*x);
                min_y = min_y.min(*y);
                max_x = max_x.max(*x);
                max_y = max_y.max(*y);
                found = true;
            }
            PathOp::CurveTo {
                x1,
                y1,
                x2,
                y2,
                x3,
                y3,
            } => {
                min_x = min_x.min(*x1).min(*x2).min(*x3);
                min_y = min_y.min(*y1).min(*y2).min(*y3);
                max_x = max_x.max(*x1).max(*x2).max(*x3);
                max_y = max_y.max(*y1).max(*y2).max(*y3);
                found = true;
            }
            PathOp::Close => {}
        }
    }

    if found {
        Some(Rect::new(
            min_x as f64,
            min_y as f64,
            max_x as f64,
            max_y as f64,
        ))
    } else {
        None
    }
}

/// Upstream-aligned alias for [`bounding_box`].
///
/// Corresponds to `CFX_Path::GetBoundingBox()` in upstream PDFium.
#[inline]
pub fn get_bounding_box(ops: &[PathOp]) -> Option<Rect> {
    bounding_box(ops)
}

/// Computes a conservative axis-aligned bounding box for a stroked path.
///
/// Corresponds to `CFX_Path::GetBoundingBoxForStrokePath()` in upstream PDFium.
///
/// The returned box is the path bounding box inflated by the maximum possible
/// stroke outset:
/// - At line caps: extends `line_width / 2` past the endpoint.
/// - At miter corners: extends up to `miter_limit * line_width / 2`.
///
/// The inflation is therefore `max(line_width / 2, miter_limit * line_width / 2)`.
/// Since `miter_limit` is normally ≥ 1, this simplifies to `miter_limit * line_width / 2`.
///
/// Returns `None` if the path is empty.
pub fn bounding_box_for_stroke_path(
    ops: &[PathOp],
    line_width: f32,
    miter_limit: f32,
) -> Option<Rect> {
    let inner = bounding_box(ops)?;
    let half_lw = line_width / 2.0;
    let inflate = (miter_limit * half_lw).max(half_lw) as f64;
    Some(Rect::new(
        inner.left - inflate,
        inner.bottom - inflate,
        inner.right + inflate,
        inner.top + inflate,
    ))
}

/// Upstream-aligned alias for [`bounding_box_for_stroke_path`].
///
/// Corresponds to `CFX_Path::GetBoundingBoxForStrokePath()` in upstream PDFium.
#[inline]
pub fn get_bounding_box_for_stroke_path(
    ops: &[PathOp],
    line_width: f32,
    miter_limit: f32,
) -> Option<Rect> {
    bounding_box_for_stroke_path(ops, line_width, miter_limit)
}

/// Returns `true` if the path ops describe a simple axis-aligned rectangle.
///
/// Corresponds to `CFX_Path::IsRect()` in upstream PDFium.
/// A path qualifies if it has exactly 4 `LineTo` ops preceded by a `MoveTo` (and optional
/// `Close`), forming a closed axis-aligned rectangle.
pub fn is_rect(ops: &[PathOp]) -> bool {
    rect_if_axis_aligned(ops).is_some()
}

/// Detects whether a sequence of path ops describes a simple axis-aligned rectangle.
///
/// Corresponds to the `CFX_Path::IsRect()` / `CFX_Path::GetRect()` pattern in upstream PDFium.
/// A path qualifies if it has exactly 4 `LineTo` ops preceded by a `MoveTo` (and optional
/// `Close`), forming a closed axis-aligned rectangle.
///
/// Returns the detected rectangle if the path is axis-aligned, or `None` otherwise.
pub fn rect_if_axis_aligned(ops: &[PathOp]) -> Option<Rect> {
    // Normalise: ignore trailing Close
    let effective: Vec<&PathOp> = ops
        .iter()
        .filter(|op| !matches!(op, PathOp::Close))
        .collect();
    // Expect: MoveTo, LineTo, LineTo, LineTo, LineTo (rectangle = 5 ops)
    if effective.len() != 5 {
        return None;
    }
    let (mx, my) = match effective[0] {
        PathOp::MoveTo { x, y } => (*x, *y),
        _ => return None,
    };
    let pts: Option<Vec<(f32, f32)>> = effective[1..]
        .iter()
        .map(|op| match op {
            PathOp::LineTo { x, y } => Some((*x, *y)),
            _ => None,
        })
        .collect();
    let pts = pts?;
    // Collect all x and y values; require exactly 2 distinct values each
    let all_x = [mx, pts[0].0, pts[1].0, pts[2].0, pts[3].0];
    let all_y = [my, pts[0].1, pts[1].1, pts[2].1, pts[3].1];
    let mut xs: Vec<f32> = all_x.to_vec();
    let mut ys: Vec<f32> = all_y.to_vec();
    xs.dedup();
    ys.dedup();
    // After dedup on sorted values, 2 distinct means axis-aligned rectangle
    xs.sort_by(f32::total_cmp);
    ys.sort_by(f32::total_cmp);
    xs.dedup();
    ys.dedup();
    if xs.len() == 2 && ys.len() == 2 {
        Some(Rect::new(
            xs[0] as f64,
            ys[0] as f64,
            xs[1] as f64,
            ys[1] as f64,
        ))
    } else {
        None
    }
}

/// Upstream-aligned alias for [`rect_if_axis_aligned`].
///
/// Corresponds to `CFX_Path::GetRect()` in upstream PDFium.
#[inline]
pub fn get_rect(ops: &[PathOp]) -> Option<Rect> {
    rect_if_axis_aligned(ops)
}

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

    #[test]
    fn test_line_cap_from_i64() {
        assert_eq!(LineCapStyle::from_i64(0), LineCapStyle::Butt);
        assert_eq!(LineCapStyle::from_i64(1), LineCapStyle::Round);
        assert_eq!(LineCapStyle::from_i64(2), LineCapStyle::Square);
        assert_eq!(LineCapStyle::from_i64(99), LineCapStyle::Butt); // invalid → default
    }

    #[test]
    fn test_line_join_from_i64() {
        assert_eq!(LineJoinStyle::from_i64(0), LineJoinStyle::Miter);
        assert_eq!(LineJoinStyle::from_i64(1), LineJoinStyle::Round);
        assert_eq!(LineJoinStyle::from_i64(2), LineJoinStyle::Bevel);
        assert_eq!(LineJoinStyle::from_i64(-1), LineJoinStyle::Miter); // invalid → default
    }

    #[test]
    fn test_path_style_default() {
        let style = PathStyle::default();
        assert!(style.fill.is_none());
        assert!(!style.stroke);
        assert_eq!(style.line_width, 1.0);
        assert_eq!(style.line_cap, LineCapStyle::Butt);
        assert_eq!(style.line_join, LineJoinStyle::Miter);
        assert_eq!(style.miter_limit, 10.0);
        assert!(style.dash.is_none());
    }

    #[test]
    fn test_dash_pattern_default() {
        let dash = DashPattern::default();
        assert!(dash.array.is_empty());
        assert_eq!(dash.phase, 0.0);
    }

    #[test]
    fn test_path_op_clone() {
        let op = PathOp::CurveTo {
            x1: 1.0,
            y1: 2.0,
            x2: 3.0,
            y2: 4.0,
            x3: 5.0,
            y3: 6.0,
        };
        let op2 = op.clone();
        assert_eq!(op, op2);
    }

    #[test]
    fn test_fill_rule_default() {
        assert_eq!(FillRule::default(), FillRule::NonZero);
    }

    #[test]
    fn test_bounding_box_empty() {
        assert_eq!(bounding_box(&[]), None);
        assert_eq!(bounding_box(&[PathOp::Close]), None);
    }

    #[test]
    fn test_bounding_box_line() {
        let ops = vec![
            PathOp::MoveTo { x: 10.0, y: 20.0 },
            PathOp::LineTo { x: 50.0, y: 80.0 },
        ];
        let bb = bounding_box(&ops).unwrap();
        assert_eq!(bb.left, 10.0);
        assert_eq!(bb.bottom, 20.0);
        assert_eq!(bb.right, 50.0);
        assert_eq!(bb.top, 80.0);
    }

    #[test]
    fn test_bounding_box_rect_path() {
        let ops = vec![
            PathOp::MoveTo { x: 0.0, y: 0.0 },
            PathOp::LineTo { x: 100.0, y: 0.0 },
            PathOp::LineTo { x: 100.0, y: 200.0 },
            PathOp::LineTo { x: 0.0, y: 200.0 },
            PathOp::Close,
        ];
        let bb = bounding_box(&ops).unwrap();
        assert_eq!(bb.left, 0.0);
        assert_eq!(bb.bottom, 0.0);
        assert_eq!(bb.right, 100.0);
        assert_eq!(bb.top, 200.0);
    }

    #[test]
    fn test_bounding_box_curve_includes_control_points() {
        let ops = vec![PathOp::CurveTo {
            x1: -5.0,
            y1: 30.0,
            x2: 60.0,
            y2: -10.0,
            x3: 40.0,
            y3: 50.0,
        }];
        let bb = bounding_box(&ops).unwrap();
        assert_eq!(bb.left as f32, -5.0_f32);
        assert_eq!(bb.bottom as f32, -10.0_f32);
        assert_eq!(bb.right as f32, 60.0_f32);
        assert_eq!(bb.top as f32, 50.0_f32);
    }

    #[test]
    fn test_bounding_box_negative_coords() {
        let ops = vec![
            PathOp::MoveTo {
                x: -100.0,
                y: -200.0,
            },
            PathOp::LineTo { x: -10.0, y: -5.0 },
        ];
        let bb = bounding_box(&ops).unwrap();
        assert_eq!(bb.left as f32, -100.0_f32);
        assert_eq!(bb.bottom as f32, -200.0_f32);
        assert_eq!(bb.right as f32, -10.0_f32);
        assert_eq!(bb.top as f32, -5.0_f32);
    }

    #[test]
    fn test_stroke_bounding_box_inflates_by_half_line_width() {
        let ops = vec![
            PathOp::MoveTo { x: 10.0, y: 10.0 },
            PathOp::LineTo { x: 50.0, y: 10.0 },
        ];
        // miter_limit=10.0, line_width=4.0 → inflate = max(10*2, 2) = 20
        let bb = bounding_box_for_stroke_path(&ops, 4.0, 10.0).unwrap();
        assert!((bb.left - (10.0 - 20.0)).abs() < 0.01);
        assert!((bb.right - (50.0 + 20.0)).abs() < 0.01);
        assert!((bb.bottom - (10.0 - 20.0)).abs() < 0.01);
        assert!((bb.top - (10.0 + 20.0)).abs() < 0.01);
    }

    #[test]
    fn test_stroke_bounding_box_min_inflate_is_half_lw() {
        // miter_limit=0.5 < 1.0 → inflate capped to half_lw = 1.0
        let ops = vec![
            PathOp::MoveTo { x: 0.0, y: 0.0 },
            PathOp::LineTo { x: 10.0, y: 0.0 },
        ];
        let bb = bounding_box_for_stroke_path(&ops, 2.0, 0.5).unwrap();
        assert!((bb.left - (-1.0)).abs() < 0.01);
        assert!((bb.right - 11.0).abs() < 0.01);
    }

    #[test]
    fn test_stroke_bounding_box_empty_path() {
        assert_eq!(bounding_box_for_stroke_path(&[], 1.0, 10.0), None);
    }

    #[test]
    fn test_get_rect_detects_axis_aligned_rect() {
        let ops = vec![
            PathOp::MoveTo { x: 10.0, y: 20.0 },
            PathOp::LineTo { x: 50.0, y: 20.0 },
            PathOp::LineTo { x: 50.0, y: 80.0 },
            PathOp::LineTo { x: 10.0, y: 80.0 },
            PathOp::LineTo { x: 10.0, y: 20.0 },
            PathOp::Close,
        ];
        let r = rect_if_axis_aligned(&ops).unwrap();
        assert!((r.left - 10.0).abs() < 0.01);
        assert!((r.bottom - 20.0).abs() < 0.01);
        assert!((r.right - 50.0).abs() < 0.01);
        assert!((r.top - 80.0).abs() < 0.01);
    }

    #[test]
    fn test_get_rect_rejects_non_rect_path() {
        // Diagonal line — not a rect
        let ops = vec![
            PathOp::MoveTo { x: 0.0, y: 0.0 },
            PathOp::LineTo { x: 10.0, y: 5.0 },
            PathOp::LineTo { x: 20.0, y: 0.0 },
            PathOp::LineTo { x: 10.0, y: -5.0 },
            PathOp::LineTo { x: 0.0, y: 0.0 },
        ];
        assert_eq!(rect_if_axis_aligned(&ops), None);
    }

    #[test]
    fn test_get_rect_rejects_triangle() {
        let ops = vec![
            PathOp::MoveTo { x: 0.0, y: 0.0 },
            PathOp::LineTo { x: 10.0, y: 0.0 },
            PathOp::LineTo { x: 5.0, y: 10.0 },
            PathOp::Close,
        ];
        assert_eq!(rect_if_axis_aligned(&ops), None);
    }

    // --- Upstream ports ---

    /// Upstream: TEST(CFXPath, BasicTest)
    #[test]
    fn test_basic_path_operations() {
        // AppendRect equivalent: 5 points (MoveTo + 3 LineTo + closing LineTo)
        let ops = vec![
            PathOp::MoveTo { x: 1.0, y: 2.0 },
            PathOp::LineTo { x: 3.0, y: 2.0 },
            PathOp::LineTo { x: 3.0, y: 5.0 },
            PathOp::LineTo { x: 1.0, y: 5.0 },
            PathOp::LineTo { x: 1.0, y: 2.0 },
        ];
        assert!(is_rect(&ops));
        let rect = rect_if_axis_aligned(&ops).unwrap();
        assert_eq!(
            (
                rect.left as f32,
                rect.bottom as f32,
                rect.right as f32,
                rect.top as f32
            ),
            (1.0, 2.0, 3.0, 5.0)
        );
        let bb = bounding_box(&ops).unwrap();
        assert_eq!(
            (
                bb.left as f32,
                bb.bottom as f32,
                bb.right as f32,
                bb.top as f32
            ),
            (1.0, 2.0, 3.0, 5.0)
        );

        // Empty path
        let empty: Vec<PathOp> = vec![];
        assert!(!is_rect(&empty));
        assert_eq!(bounding_box(&empty), None);

        // 4 points without close makes a rect
        let ops = vec![
            PathOp::MoveTo { x: 0.0, y: 0.0 },
            PathOp::LineTo { x: 0.0, y: 1.0 },
            PathOp::LineTo { x: 1.0, y: 1.0 },
            PathOp::LineTo { x: 1.0, y: 0.0 },
            PathOp::LineTo { x: 0.0, y: 0.0 },
        ];
        assert!(is_rect(&ops));
        let rect = rect_if_axis_aligned(&ops).unwrap();
        assert_eq!(
            (
                rect.left as f32,
                rect.bottom as f32,
                rect.right as f32,
                rect.top as f32
            ),
            (0.0, 0.0, 1.0, 1.0)
        );

        // 4 points with close also a rect
        let ops = vec![
            PathOp::MoveTo { x: 0.0, y: 0.0 },
            PathOp::LineTo { x: 0.0, y: 1.0 },
            PathOp::LineTo { x: 1.0, y: 1.0 },
            PathOp::LineTo { x: 1.0, y: 0.0 },
            PathOp::LineTo { x: 0.0, y: 0.0 },
            PathOp::Close,
        ];
        assert!(is_rect(&ops));
    }

    /// Upstream: TEST(CFXPath, ShearTransform)
    ///
    /// Tests that a sheared rectangle is no longer detected as a rect.
    /// rpdfium doesn't have an in-place Transform method on paths, so we
    /// apply the shear matrix manually and verify bounding box behavior.
    #[test]
    fn test_shear_transform_breaks_rect() {
        // Original rect
        let ops = vec![
            PathOp::MoveTo { x: 1.0, y: 2.0 },
            PathOp::LineTo { x: 3.0, y: 2.0 },
            PathOp::LineTo { x: 3.0, y: 5.0 },
            PathOp::LineTo { x: 1.0, y: 5.0 },
            PathOp::LineTo { x: 1.0, y: 2.0 },
        ];
        assert!(is_rect(&ops));

        // Apply shear matrix (1, 2, 0, 1, 0, 0): x' = x, y' = 2x + y
        let sheared: Vec<PathOp> = ops
            .iter()
            .map(|op| match op {
                PathOp::MoveTo { x, y } => PathOp::MoveTo {
                    x: *x,
                    y: 2.0 * x + y,
                },
                PathOp::LineTo { x, y } => PathOp::LineTo {
                    x: *x,
                    y: 2.0 * x + y,
                },
                _ => op.clone(),
            })
            .collect();

        // Sheared rect is no longer axis-aligned
        assert!(!is_rect(&sheared));
        assert!(rect_if_axis_aligned(&sheared).is_none());

        // Bounding box of sheared path
        let bb = bounding_box(&sheared).unwrap();
        assert_eq!(
            (
                bb.left as f32,
                bb.bottom as f32,
                bb.right as f32,
                bb.top as f32
            ),
            (1.0, 4.0, 3.0, 11.0)
        );
    }

    /// Upstream: TEST(CFXPath, Hexagon)
    #[test]
    fn test_hexagon_not_rect() {
        let ops = vec![
            PathOp::MoveTo { x: 1.0, y: 0.0 },
            PathOp::LineTo { x: 2.0, y: 0.0 },
            PathOp::LineTo { x: 3.0, y: 1.0 },
            PathOp::LineTo { x: 2.0, y: 2.0 },
            PathOp::LineTo { x: 1.0, y: 2.0 },
            PathOp::LineTo { x: 0.0, y: 1.0 },
        ];
        assert!(!is_rect(&ops));
        assert!(rect_if_axis_aligned(&ops).is_none());
        let bb = bounding_box(&ops).unwrap();
        assert_eq!(
            (
                bb.left as f32,
                bb.bottom as f32,
                bb.right as f32,
                bb.top as f32
            ),
            (0.0, 0.0, 3.0, 2.0)
        );

        // With Close -- still not a rect
        let mut ops_closed = ops.clone();
        ops_closed.push(PathOp::Close);
        assert!(!is_rect(&ops_closed));

        // Close is idempotent for bounding box
        let bb2 = bounding_box(&ops_closed).unwrap();
        assert_eq!((bb2.left as f32, bb2.bottom as f32), (0.0, 0.0));
        assert_eq!((bb2.right as f32, bb2.top as f32), (3.0, 2.0));

        // Hexagon with same start/end point is still not a rect
        let ops_loop = vec![
            PathOp::MoveTo { x: 1.0, y: 0.0 },
            PathOp::LineTo { x: 2.0, y: 0.0 },
            PathOp::LineTo { x: 3.0, y: 1.0 },
            PathOp::LineTo { x: 2.0, y: 2.0 },
            PathOp::LineTo { x: 1.0, y: 2.0 },
            PathOp::LineTo { x: 0.0, y: 1.0 },
            PathOp::LineTo { x: 1.0, y: 0.0 },
        ];
        assert!(!is_rect(&ops_loop));
    }

    /// Upstream: TEST(CFXPath, Append)
    ///
    /// Tests appending paths. rpdfium uses Vec<PathOp> rather than a Path
    /// object, so append is just Vec::extend.
    #[test]
    fn test_path_append() {
        let mut path = vec![PathOp::MoveTo { x: 5.0, y: 6.0 }];
        assert_eq!(path.len(), 1);

        // Append empty path
        let empty: Vec<PathOp> = vec![];
        path.extend(empty.iter().cloned());
        assert_eq!(path.len(), 1);

        // Append self (clone first to avoid borrow conflict)
        let snapshot = path.clone();
        path.extend(snapshot);
        assert_eq!(path.len(), 2);
        assert_eq!(path[0], PathOp::MoveTo { x: 5.0, y: 6.0 });
        assert_eq!(path[1], PathOp::MoveTo { x: 5.0, y: 6.0 });

        // Append with transform: apply scale matrix (1,0,0,2,60,70)
        let transformed: Vec<PathOp> = path
            .iter()
            .map(|op| match op {
                PathOp::MoveTo { x, y } => PathOp::MoveTo {
                    x: 1.0 * x + 60.0,
                    y: 2.0 * y + 70.0,
                },
                PathOp::LineTo { x, y } => PathOp::LineTo {
                    x: 1.0 * x + 60.0,
                    y: 2.0 * y + 70.0,
                },
                other => other.clone(),
            })
            .collect();
        path.extend(transformed);
        assert_eq!(path.len(), 4);
        assert_eq!(path[2], PathOp::MoveTo { x: 65.0, y: 82.0 });
        assert_eq!(path[3], PathOp::MoveTo { x: 65.0, y: 82.0 });
    }
}