rpdfium_render/

cfx_renderdevice.rs

// Derived from PDFium's fpdfsdk/fpdf_view.cpp render entry point
// Original: Copyright 2014 The PDFium Authors
// Licensed under BSD-3-Clause / Apache-2.0
// See pdfium-upstream/LICENSE for the original license.

//! Public rendering API.

use rpdfium_core::Matrix;
use rpdfium_graphics::Bitmap;
use rpdfium_page::display::{DisplayTree, walk};

use crate::cfx_defaultrenderdevice::TinySkiaBackend;
use crate::error::RenderError;
use crate::image::ImageDecoder;
use crate::page_transform::compute_page_transform;
use crate::render_defines::RenderConfig;
use crate::renderdevicedriver_iface::RenderBackend;
use crate::renderer::DisplayRenderer;

/// Render a display tree to a bitmap using the default backend.
pub fn render(tree: &DisplayTree, config: &RenderConfig) -> Result<Bitmap, RenderError> {
    render_internal(tree, config, None)
}

/// Render a display tree with image decoding support.
pub fn render_with_images(
    tree: &DisplayTree,
    config: &RenderConfig,
    decoder: &dyn ImageDecoder,
) -> Result<Bitmap, RenderError> {
    render_internal(tree, config, Some(decoder))
}

fn render_internal(
    tree: &DisplayTree,
    config: &RenderConfig,
    decoder: Option<&dyn ImageDecoder>,
) -> Result<Bitmap, RenderError> {
    let mut backend = TinySkiaBackend::new();
    if !config.antialiasing {
        backend.set_antialiasing(false);
    }

    // Use forced color scheme background when set.
    let effective_bg = config
        .forced_color_scheme
        .as_ref()
        .map_or(&config.background, |s| &s.background_color);

    let mut surface = backend.create_surface(config.width, config.height, effective_bg);

    let page_transform = if let Some(m) = config.custom_transform {
        m
    } else {
        match config.media_box {
            Some(ref mb) => {
                compute_page_transform(mb, config.width, config.height, config.rotation)
            }
            None => Matrix::identity(),
        }
    };

    {
        let mut renderer =
            DisplayRenderer::new(&mut backend, &mut surface, page_transform, decoder)
                .with_per_feature_aa(
                    config.text_antialiasing,
                    config.path_antialiasing,
                    config.image_antialiasing,
                );
        if let Some(ref scheme) = config.forced_color_scheme {
            renderer = renderer.with_forced_color_scheme(scheme.clone());
        }
        walk(tree, &mut renderer);
    }

    let mut bitmap = backend.finish(surface);

    if let Some(ref clip) = config.clip_rect {
        apply_clip_rect(&mut bitmap, clip, effective_bg);
    }

    if config.grayscale {
        apply_grayscale(&mut bitmap);
    }

    Ok(bitmap)
}

/// Mask out pixels outside the given device-space clip rectangle.
///
/// `clip.left/right` are x pixel bounds; `clip.bottom/top` are y pixel bounds
/// measured from the top of the bitmap (y=0 is the top row).  Pixels outside
/// the rectangle are replaced with `bg`.
fn apply_clip_rect(
    bitmap: &mut Bitmap,
    clip: &rpdfium_core::Rect,
    bg: &crate::color_convert::RgbaColor,
) {
    let bw = bitmap.width as usize;
    let bh = bitmap.height as usize;
    let x0 = (clip.left.max(0.0) as usize).min(bw);
    let x1 = (clip.right.max(0.0) as usize).min(bw);
    let y0 = (clip.bottom.max(0.0) as usize).min(bh);
    let y1 = (clip.top.max(0.0) as usize).min(bh);
    let stride = bw * 4;
    for y in 0..bh {
        let in_y = y >= y0 && y < y1;
        for x in 0..bw {
            if !in_y || x < x0 || x >= x1 {
                let off = y * stride + x * 4;
                bitmap.data[off] = bg.r;
                bitmap.data[off + 1] = bg.g;
                bitmap.data[off + 2] = bg.b;
                bitmap.data[off + 3] = bg.a;
            }
        }
    }
}

/// Convert all pixels in a bitmap to grayscale using the luminance formula:
/// `gray = (r*299 + g*587 + b*114) / 1000`
fn apply_grayscale(bitmap: &mut Bitmap) {
    for chunk in bitmap.data.chunks_exact_mut(4) {
        let r = chunk[0] as u32;
        let g = chunk[1] as u32;
        let b = chunk[2] as u32;
        let gray = ((r * 299 + g * 587 + b * 114) / 1000) as u8;
        chunk[0] = gray;
        chunk[1] = gray;
        chunk[2] = gray;
        // Alpha unchanged
    }
}

/// Render a display tree using tile-based progressive rendering.
///
/// If `config.tile_size` is `Some`, the page is rendered in tiles.
/// The progress callback is called after each tile completes; returning
/// `false` from the callback aborts rendering early (the returned bitmap
/// will contain only the tiles rendered so far).
///
/// If `config.tile_size` is `None`, this falls back to the normal
/// full-page render path.
pub fn render_tiled(tree: &DisplayTree, config: &RenderConfig) -> Result<Bitmap, RenderError> {
    render_tiled_internal(tree, config, None)
}

/// Render a display tree using tile-based progressive rendering with
/// image decoding support.
pub fn render_tiled_with_images(
    tree: &DisplayTree,
    config: &RenderConfig,
    decoder: &dyn ImageDecoder,
) -> Result<Bitmap, RenderError> {
    render_tiled_internal(tree, config, Some(decoder))
}

fn render_tiled_internal(
    tree: &DisplayTree,
    config: &RenderConfig,
    decoder: Option<&dyn ImageDecoder>,
) -> Result<Bitmap, RenderError> {
    let tile_size = match config.tile_size {
        Some(ts) if ts > 0 => ts,
        _ => return render_internal(tree, config, decoder),
    };

    let width = config.width;
    let height = config.height;

    let cols = width.div_ceil(tile_size);
    let rows = height.div_ceil(tile_size);
    let total_tiles = cols * rows;

    // Use forced color scheme background when set.
    let effective_bg = config
        .forced_color_scheme
        .as_ref()
        .map_or(&config.background, |s| &s.background_color);

    // Create the final bitmap filled with the background color
    let mut final_bitmap = Bitmap::new(width, height, rpdfium_graphics::BitmapFormat::Rgba32);
    // Fill with background
    for pixel in final_bitmap.data.chunks_exact_mut(4) {
        pixel[0] = effective_bg.r;
        pixel[1] = effective_bg.g;
        pixel[2] = effective_bg.b;
        pixel[3] = effective_bg.a;
    }

    let page_transform = match config.media_box {
        Some(ref mb) => compute_page_transform(mb, width, height, config.rotation),
        None => Matrix::identity(),
    };

    for row in 0..rows {
        for col in 0..cols {
            let tile_x = col * tile_size;
            let tile_y = row * tile_size;
            let tile_w = tile_size.min(width - tile_x);
            let tile_h = tile_size.min(height - tile_y);

            // Create a backend for this tile, using a clip-and-offset approach:
            // We render the full scene but offset so only this tile region is drawn.
            let mut backend = TinySkiaBackend::new();
            if !config.antialiasing {
                backend.set_antialiasing(false);
            }
            let mut surface = backend.create_surface(tile_w, tile_h, effective_bg);

            // Translate the page transform so the tile origin maps to (0,0)
            let tile_offset = Matrix::from_translation(-(tile_x as f64), -(tile_y as f64));
            let tile_transform = tile_offset.pre_concat(&page_transform);

            {
                let mut renderer =
                    DisplayRenderer::new(&mut backend, &mut surface, tile_transform, decoder)
                        .with_per_feature_aa(
                            config.text_antialiasing,
                            config.path_antialiasing,
                            config.image_antialiasing,
                        );
                if let Some(ref scheme) = config.forced_color_scheme {
                    renderer = renderer.with_forced_color_scheme(scheme.clone());
                }
                walk(tree, &mut renderer);
            }

            let tile_bitmap = backend.finish(surface);

            // Copy tile pixels into the final bitmap
            for ty in 0..tile_h {
                let dst_y = tile_y + ty;
                if dst_y >= height {
                    break;
                }
                let src_row = tile_bitmap.scanline(ty);
                let dst_start = (dst_y * final_bitmap.stride + tile_x * 4) as usize;
                let copy_len = (tile_w * 4) as usize;
                final_bitmap.data[dst_start..dst_start + copy_len]
                    .copy_from_slice(&src_row[..copy_len]);
            }

            // Call progress callback
            if let Some(ref progress) = config.progress {
                if !progress.on_tile_complete(col, row, total_tiles) {
                    return Ok(final_bitmap);
                }
            }
        }
    }

    if config.grayscale {
        apply_grayscale(&mut final_bitmap);
    }

    Ok(final_bitmap)
}

#[cfg(test)]
mod tests {
    use super::*;
    use rpdfium_core::Rect;
    use rpdfium_graphics::{BlendMode, Color, FillRule, PathOp, PathStyle};
    use rpdfium_page::display::DisplayNode;

    use crate::color_convert::RgbaColor;

    #[test]
    fn test_render_empty_tree() {
        let tree = DisplayTree {
            root: DisplayNode::Group {
                blend_mode: BlendMode::Normal,
                clip: None,
                opacity: 1.0,
                isolated: false,
                knockout: false,
                soft_mask: None,
                children: Vec::new(),
            },
        };
        let config = RenderConfig {
            width: 50,
            height: 50,
            background: RgbaColor::WHITE,
            ..RenderConfig::default()
        };
        let bitmap = render(&tree, &config).unwrap();
        assert_eq!(bitmap.width, 50);
        assert_eq!(bitmap.height, 50);
    }

    #[test]
    fn test_render_simple_fill() {
        let tree = DisplayTree {
            root: DisplayNode::Group {
                blend_mode: BlendMode::Normal,
                clip: None,
                opacity: 1.0,
                isolated: false,
                knockout: false,
                soft_mask: None,
                children: vec![DisplayNode::Path {
                    ops: vec![
                        PathOp::MoveTo { x: 0.0, y: 0.0 },
                        PathOp::LineTo { x: 100.0, y: 0.0 },
                        PathOp::LineTo { x: 100.0, y: 100.0 },
                        PathOp::LineTo { x: 0.0, y: 100.0 },
                        PathOp::Close,
                    ],
                    style: PathStyle {
                        fill: Some(FillRule::NonZero),
                        ..PathStyle::default()
                    },
                    matrix: Matrix::identity(),
                    fill_color: Some(Color::rgb(1.0, 0.0, 0.0)),
                    stroke_color: None,
                    fill_color_space: None,
                    stroke_color_space: None,
                    transfer_function: None,
                    overprint: false,
                    overprint_mode: 0,
                }],
            },
        };
        let config = RenderConfig {
            width: 100,
            height: 100,
            background: RgbaColor::WHITE,
            ..RenderConfig::default()
        };
        let bitmap = render(&tree, &config).unwrap();
        // The rectangle covers the entire surface, so center pixel should be red
        let idx = (50 * bitmap.stride + 50 * 4) as usize;
        assert_eq!(bitmap.data[idx], 255); // R
        assert_eq!(bitmap.data[idx + 1], 0); // G
        assert_eq!(bitmap.data[idx + 2], 0); // B
    }

    #[test]
    fn test_render_with_page_transform() {
        // A red rectangle at PDF coordinates (0,0)-(100,100) on a 200x200pt page.
        // With page transform, PDF Y is flipped: (0,0) in PDF → (0,200) in device.
        let tree = DisplayTree {
            root: DisplayNode::Group {
                blend_mode: BlendMode::Normal,
                clip: None,
                opacity: 1.0,
                isolated: false,
                knockout: false,
                soft_mask: None,
                children: vec![DisplayNode::Path {
                    ops: vec![
                        PathOp::MoveTo { x: 0.0, y: 0.0 },
                        PathOp::LineTo { x: 200.0, y: 0.0 },
                        PathOp::LineTo { x: 200.0, y: 200.0 },
                        PathOp::LineTo { x: 0.0, y: 200.0 },
                        PathOp::Close,
                    ],
                    style: PathStyle {
                        fill: Some(FillRule::NonZero),
                        ..PathStyle::default()
                    },
                    matrix: Matrix::identity(),
                    fill_color: Some(Color::rgb(1.0, 0.0, 0.0)),
                    stroke_color: None,
                    fill_color_space: None,
                    stroke_color_space: None,
                    transfer_function: None,
                    overprint: false,
                    overprint_mode: 0,
                }],
            },
        };
        let config = RenderConfig {
            width: 200,
            height: 200,
            background: RgbaColor::WHITE,
            media_box: Some(Rect::new(0.0, 0.0, 200.0, 200.0)),
            rotation: 0,
            ..RenderConfig::default()
        };
        let bitmap = render(&tree, &config).unwrap();
        // With page transform, the full-page rectangle should still cover everything
        let idx = (100 * bitmap.stride + 100 * 4) as usize;
        assert_eq!(bitmap.data[idx], 255); // R
        assert_eq!(bitmap.data[idx + 1], 0); // G
        assert_eq!(bitmap.data[idx + 2], 0); // B
    }

    // ---- Tiled / Progressive Rendering Tests ----

    fn make_red_rect_tree() -> DisplayTree {
        DisplayTree {
            root: DisplayNode::Group {
                blend_mode: BlendMode::Normal,
                clip: None,
                opacity: 1.0,
                isolated: false,
                knockout: false,
                soft_mask: None,
                children: vec![DisplayNode::Path {
                    ops: vec![
                        PathOp::MoveTo { x: 0.0, y: 0.0 },
                        PathOp::LineTo { x: 100.0, y: 0.0 },
                        PathOp::LineTo { x: 100.0, y: 100.0 },
                        PathOp::LineTo { x: 0.0, y: 100.0 },
                        PathOp::Close,
                    ],
                    style: PathStyle {
                        fill: Some(FillRule::NonZero),
                        ..PathStyle::default()
                    },
                    matrix: Matrix::identity(),
                    fill_color: Some(Color::rgb(1.0, 0.0, 0.0)),
                    stroke_color: None,
                    fill_color_space: None,
                    stroke_color_space: None,
                    transfer_function: None,
                    overprint: false,
                    overprint_mode: 0,
                }],
            },
        }
    }

    #[test]
    fn test_tiled_render_matches_full_render() {
        use super::render_tiled;

        let tree = make_red_rect_tree();
        let config = RenderConfig {
            width: 100,
            height: 100,
            background: RgbaColor::WHITE,
            ..RenderConfig::default()
        };
        let full = render(&tree, &config).unwrap();

        let tiled_config = RenderConfig {
            width: 100,
            height: 100,
            background: RgbaColor::WHITE,
            tile_size: Some(50),
            ..RenderConfig::default()
        };
        let tiled = render_tiled(&tree, &tiled_config).unwrap();

        assert_eq!(full.width, tiled.width);
        assert_eq!(full.height, tiled.height);
        // Check center pixel matches
        let idx = (50 * full.stride + 50 * 4) as usize;
        assert_eq!(full.data[idx], tiled.data[idx]); // R
        assert_eq!(full.data[idx + 1], tiled.data[idx + 1]); // G
        assert_eq!(full.data[idx + 2], tiled.data[idx + 2]); // B
    }

    #[test]
    fn test_tiled_render_progress_callback_count() {
        use super::render_tiled;
        use std::sync::Arc;
        use std::sync::atomic::{AtomicU32, Ordering};

        use crate::render_defines::RenderProgress;

        struct CountProgress {
            count: AtomicU32,
        }
        impl RenderProgress for CountProgress {
            fn on_tile_complete(&self, _tx: u32, _ty: u32, _total: u32) -> bool {
                self.count.fetch_add(1, Ordering::Relaxed);
                true
            }
        }

        let tree = make_red_rect_tree();
        let progress = Arc::new(CountProgress {
            count: AtomicU32::new(0),
        });
        let config = RenderConfig {
            width: 100,
            height: 100,
            background: RgbaColor::WHITE,
            tile_size: Some(50),
            progress: Some(progress.clone()),
            ..RenderConfig::default()
        };
        let _ = render_tiled(&tree, &config).unwrap();

        // 100x100 with 50px tiles = 2x2 = 4 tiles
        assert_eq!(progress.count.load(Ordering::Relaxed), 4);
    }

    #[test]
    fn test_tiled_render_cancellation_stops_early() {
        use super::render_tiled;
        use std::sync::Arc;
        use std::sync::atomic::{AtomicU32, Ordering};

        use crate::render_defines::RenderProgress;

        struct CancelAfterN {
            count: AtomicU32,
            cancel_after: u32,
        }
        impl RenderProgress for CancelAfterN {
            fn on_tile_complete(&self, _tx: u32, _ty: u32, _total: u32) -> bool {
                let c = self.count.fetch_add(1, Ordering::Relaxed) + 1;
                c < self.cancel_after
            }
        }

        let tree = make_red_rect_tree();
        let progress = Arc::new(CancelAfterN {
            count: AtomicU32::new(0),
            cancel_after: 2,
        });
        let config = RenderConfig {
            width: 100,
            height: 100,
            background: RgbaColor::WHITE,
            tile_size: Some(50),
            progress: Some(progress.clone()),
            ..RenderConfig::default()
        };
        let bitmap = render_tiled(&tree, &config).unwrap();
        // Should have stopped after 2 tiles
        assert_eq!(progress.count.load(Ordering::Relaxed), 2);
        // Bitmap was still returned (partially rendered)
        assert_eq!(bitmap.width, 100);
        assert_eq!(bitmap.height, 100);
    }

    #[test]
    fn test_tiled_render_none_tile_size_falls_back() {
        use super::render_tiled;

        let tree = make_red_rect_tree();
        let config = RenderConfig {
            width: 100,
            height: 100,
            background: RgbaColor::WHITE,
            tile_size: None,
            ..RenderConfig::default()
        };
        // Should work like normal render
        let bitmap = render_tiled(&tree, &config).unwrap();
        assert_eq!(bitmap.width, 100);
        assert_eq!(bitmap.height, 100);
        // Center pixel should be red
        let idx = (50 * bitmap.stride + 50 * 4) as usize;
        assert_eq!(bitmap.data[idx], 255);
    }

    #[test]
    fn test_tiled_render_config_builder() {
        use std::sync::Arc;

        use crate::render_defines::RenderProgress;

        struct NoopProgress;
        impl RenderProgress for NoopProgress {
            fn on_tile_complete(&self, _tx: u32, _ty: u32, _total: u32) -> bool {
                true
            }
        }

        let config = RenderConfig::default()
            .with_tile_size(128)
            .with_progress(Arc::new(NoopProgress));
        assert_eq!(config.tile_size, Some(128));
        assert!(config.progress.is_some());
    }

    fn make_white_rect_50() -> DisplayNode {
        DisplayNode::Path {
            ops: vec![
                PathOp::MoveTo { x: 0.0, y: 0.0 },
                PathOp::LineTo { x: 50.0, y: 0.0 },
                PathOp::LineTo { x: 50.0, y: 50.0 },
                PathOp::LineTo { x: 0.0, y: 50.0 },
                PathOp::Close,
            ],
            style: PathStyle {
                fill: Some(FillRule::NonZero),
                ..PathStyle::default()
            },
            matrix: Matrix::identity(),
            fill_color: Some(Color::rgb(1.0, 1.0, 1.0)),
            stroke_color: None,
            fill_color_space: None,
            stroke_color_space: None,
            transfer_function: None,
            overprint: false,
            overprint_mode: 0,
        }
    }

    #[test]
    fn test_render_group_opacity_transparent_bg_simple() {
        // Simple: Screen/0.6 group with white fill on transparent background.
        let tree = DisplayTree {
            root: DisplayNode::Group {
                blend_mode: BlendMode::Normal,
                clip: None,
                opacity: 1.0,
                isolated: true,
                knockout: false,
                soft_mask: None,
                children: vec![DisplayNode::Group {
                    blend_mode: BlendMode::Screen,
                    clip: None,
                    opacity: 0.6,
                    isolated: true,
                    knockout: false,
                    soft_mask: None,
                    children: vec![make_white_rect_50()],
                }],
            },
        };
        let config = RenderConfig {
            width: 50,
            height: 50,
            background: RgbaColor::new(0, 0, 0, 0),
            ..RenderConfig::default()
        };
        let bitmap = render(&tree, &config).unwrap();
        let idx = (25 * bitmap.stride + 25 * 4) as usize;
        let a = bitmap.data[idx + 3];
        eprintln!(
            "simple: RGBA=[{},{},{},{}]",
            bitmap.data[idx],
            bitmap.data[idx + 1],
            bitmap.data[idx + 2],
            a
        );
        assert!(a > 140 && a < 166, "Expected alpha ~153 but got {a}");
    }

    #[test]
    fn test_render_group_opacity_transparent_bg_with_smask() {
        // Full smask_blend structure: outer group with Alpha SMask,
        // inner Screen/0.6 group, on transparent background.
        use rpdfium_page::display::{SoftMask, SoftMaskSubtype};

        // SMask group: fully opaque white fill
        let mask_tree = DisplayTree {
            root: DisplayNode::Group {
                blend_mode: BlendMode::Normal,
                clip: None,
                opacity: 1.0,
                isolated: true,
                knockout: false,
                soft_mask: None,
                children: vec![make_white_rect_50()],
            },
        };

        let smask = SoftMask {
            subtype: SoftMaskSubtype::Alpha,
            group: mask_tree,
            backdrop_color: None,
            transfer_function: None,
        };

        let tree = DisplayTree {
            root: DisplayNode::Group {
                blend_mode: BlendMode::Normal,
                clip: None,
                opacity: 1.0,
                isolated: true,
                knockout: false,
                soft_mask: None,
                children: vec![DisplayNode::Group {
                    blend_mode: BlendMode::Normal,
                    clip: None,
                    opacity: 1.0,
                    isolated: true,
                    knockout: false,
                    soft_mask: Some(Box::new(smask)),
                    children: vec![DisplayNode::Group {
                        blend_mode: BlendMode::Normal,
                        clip: None,
                        opacity: 1.0,
                        isolated: true,
                        knockout: false,
                        soft_mask: None,
                        children: vec![DisplayNode::Group {
                            blend_mode: BlendMode::Screen,
                            clip: None,
                            opacity: 0.6,
                            isolated: true,
                            knockout: false,
                            soft_mask: None,
                            children: vec![make_white_rect_50()],
                        }],
                    }],
                }],
            },
        };
        let config = RenderConfig {
            width: 50,
            height: 50,
            background: RgbaColor::new(0, 0, 0, 0),
            ..RenderConfig::default()
        };
        let bitmap = render(&tree, &config).unwrap();
        let idx = (25 * bitmap.stride + 25 * 4) as usize;
        let a = bitmap.data[idx + 3];
        eprintln!(
            "with_smask: RGBA=[{},{},{},{}]",
            bitmap.data[idx],
            bitmap.data[idx + 1],
            bitmap.data[idx + 2],
            a
        );
        assert!(a > 140 && a < 166, "Expected alpha ~153 but got {a}");
    }

    // ---- T5: Transparency group + opacity (additional pixel-level tests) ----

    #[test]
    fn test_render_group_half_opacity_on_opaque_bg() {
        // Normal blend mode, opacity=0.5, white fill on solid red background.
        // Expected centre pixel: ~(255, 128, 128, 255) — halfway between red and white.
        let tree = DisplayTree {
            root: DisplayNode::Group {
                blend_mode: BlendMode::Normal,
                clip: None,
                opacity: 1.0,
                isolated: true,
                knockout: false,
                soft_mask: None,
                children: vec![DisplayNode::Group {
                    blend_mode: BlendMode::Normal,
                    clip: None,
                    opacity: 0.5,
                    isolated: true,
                    knockout: false,
                    soft_mask: None,
                    children: vec![make_white_rect_50()],
                }],
            },
        };
        let config = RenderConfig {
            width: 50,
            height: 50,
            background: RgbaColor::new(255, 0, 0, 255), // solid red
            ..RenderConfig::default()
        };
        let bitmap = render(&tree, &config).unwrap();
        let idx = (25 * bitmap.stride + 25 * 4) as usize;
        let r = bitmap.data[idx];
        let g = bitmap.data[idx + 1];
        let b = bitmap.data[idx + 2];
        let a = bitmap.data[idx + 3];
        // Full opacity output on opaque bg
        assert_eq!(a, 255, "alpha should be 255 on opaque bg");
        // R stays near 255; G and B rise to ~128 from 0
        assert!(r > 200, "R={r}: red component should stay high");
        assert!(g > 100 && g < 160, "G={g}: green should be ~128");
        assert!(b > 100 && b < 160, "B={b}: blue should be ~128");
    }

    #[test]
    fn test_render_group_multiply_blend_mode() {
        // Multiply blend: grey (0.5) fill on white background → should darken to ~grey.
        // Multiply(src=0.5, dst=1.0) = 0.5 → RGB ~128.
        let grey_rect = DisplayNode::Path {
            ops: vec![
                PathOp::MoveTo { x: 0.0, y: 0.0 },
                PathOp::LineTo { x: 50.0, y: 0.0 },
                PathOp::LineTo { x: 50.0, y: 50.0 },
                PathOp::LineTo { x: 0.0, y: 50.0 },
                PathOp::Close,
            ],
            style: PathStyle {
                fill: Some(FillRule::NonZero),
                ..PathStyle::default()
            },
            matrix: rpdfium_core::Matrix::identity(),
            fill_color: Some(Color::rgb(0.5, 0.5, 0.5)),
            stroke_color: None,
            fill_color_space: None,
            stroke_color_space: None,
            transfer_function: None,
            overprint: false,
            overprint_mode: 0,
        };
        let tree = DisplayTree {
            root: DisplayNode::Group {
                blend_mode: BlendMode::Normal,
                clip: None,
                opacity: 1.0,
                isolated: true,
                knockout: false,
                soft_mask: None,
                children: vec![DisplayNode::Group {
                    blend_mode: BlendMode::Multiply,
                    clip: None,
                    opacity: 1.0,
                    isolated: true,
                    knockout: false,
                    soft_mask: None,
                    children: vec![grey_rect],
                }],
            },
        };
        let config = RenderConfig {
            width: 50,
            height: 50,
            background: RgbaColor::new(255, 255, 255, 255), // white
            ..RenderConfig::default()
        };
        let bitmap = render(&tree, &config).unwrap();
        let idx = (25 * bitmap.stride + 25 * 4) as usize;
        let r = bitmap.data[idx];
        let g = bitmap.data[idx + 1];
        let b = bitmap.data[idx + 2];
        // Multiply(0.5 * 1.0) = 0.5 → ~128.  Tolerance ±15.
        assert!(r > 113 && r < 143, "R={r}: expected ~128");
        assert!(g > 113 && g < 143, "G={g}: expected ~128");
        assert!(b > 113 && b < 143, "B={b}: expected ~128");
    }

    #[test]
    fn test_render_group_isolated_contains_content_within_boundary() {
        // An isolated group painted at half-opacity over transparent background.
        // The area outside the 50×50 fill should stay transparent.
        let tree = DisplayTree {
            root: DisplayNode::Group {
                blend_mode: BlendMode::Normal,
                clip: None,
                opacity: 1.0,
                isolated: true,
                knockout: false,
                soft_mask: None,
                children: vec![DisplayNode::Group {
                    blend_mode: BlendMode::Normal,
                    clip: None,
                    opacity: 0.8,
                    isolated: true,
                    knockout: false,
                    soft_mask: None,
                    children: vec![make_white_rect_50()],
                }],
            },
        };
        let config = RenderConfig {
            width: 100,
            height: 100,
            background: RgbaColor::new(0, 0, 0, 0), // transparent
            ..RenderConfig::default()
        };
        let bitmap = render(&tree, &config).unwrap();
        // Inside 50×50 area: alpha > 0
        let inside_idx = (25 * bitmap.stride + 25 * 4) as usize;
        let inside_a = bitmap.data[inside_idx + 3];
        assert!(
            inside_a > 0,
            "inside area should have alpha > 0, got {inside_a}"
        );
        // Outside 50×50 area (bottom-right corner): should be transparent
        let outside_idx = (80 * bitmap.stride + 80 * 4) as usize;
        let outside_a = bitmap.data[outside_idx + 3];
        assert_eq!(
            outside_a, 0,
            "outside area should be transparent, got {outside_a}"
        );
    }

    #[test]
    fn test_forced_color_overrides_fill() {
        // A red rectangle rendered with forced green text color on blue background.
        let tree = make_red_rect_tree();
        let config = RenderConfig {
            width: 100,
            height: 100,
            ..RenderConfig::default()
        }
        .with_forced_colors(
            RgbaColor::new(0, 255, 0, 255), // green foreground
            RgbaColor::new(0, 0, 255, 255), // blue background
        );
        let bitmap = render(&tree, &config).unwrap();

        // The rectangle covers 0..100 x 0..100, so center pixel should be green (forced).
        let idx = (50 * bitmap.stride + 50 * 4) as usize;
        assert_eq!(bitmap.data[idx], 0, "R should be 0 (forced green)");
        assert_eq!(bitmap.data[idx + 1], 255, "G should be 255 (forced green)");
        assert_eq!(bitmap.data[idx + 2], 0, "B should be 0 (forced green)");
    }

    #[test]
    fn test_forced_color_background_applied() {
        // Empty tree with forced color scheme — background should be blue.
        let tree = DisplayTree {
            root: DisplayNode::Group {
                blend_mode: BlendMode::Normal,
                clip: None,
                opacity: 1.0,
                isolated: false,
                knockout: false,
                soft_mask: None,
                children: Vec::new(),
            },
        };
        let config = RenderConfig {
            width: 10,
            height: 10,
            ..RenderConfig::default()
        }
        .with_forced_colors(
            RgbaColor::new(0, 0, 0, 255),
            RgbaColor::new(0, 0, 255, 255), // blue background
        );
        let bitmap = render(&tree, &config).unwrap();
        // Every pixel should be blue
        let idx = (5 * bitmap.stride + 5 * 4) as usize;
        assert_eq!(bitmap.data[idx], 0, "R");
        assert_eq!(bitmap.data[idx + 1], 0, "G");
        assert_eq!(bitmap.data[idx + 2], 255, "B");
        assert_eq!(bitmap.data[idx + 3], 255, "A");
    }
}