scan_core/

image_utils.rs

use image::{GrayImage, Luma};
use crate::transform::perspective::PerspectiveTransform;

/// Apply perspective transform to the entire image.
/// Maps `src_img` to a destination image of size `width` x `height`
/// using the transform `pt` (which maps Src -> Dst).
/// We iterate Dst pixels, map backwards to Src using `transform_inverse` (coeff_inv), and sample.
pub fn warp_perspective(src_img: &GrayImage, pt: &PerspectiveTransform, width: u32, height: u32) -> GrayImage {
    let mut dst = GrayImage::new(width, height);
    let src_w = src_img.width() as f32;
    let src_h = src_img.height() as f32;

    for y in 0..height {
        for x in 0..width {
            let src_pt = pt.transform_inverse(x as f32, y as f32);
            let sx = src_pt.x;
            let sy = src_pt.y;
            
            if sx >= 0.0 && sx < src_w - 1.0 && sy >= 0.0 && sy < src_h - 1.0 {
                // Bilinear interpolation
                let x0 = sx.floor() as u32;
                let y0 = sy.floor() as u32;
                
                let dx = sx - x0 as f32;
                let dy = sy - y0 as f32;
                
                let p00 = src_img.get_pixel(x0, y0)[0] as f32;
                let p10 = src_img.get_pixel(x0 + 1, y0)[0] as f32;
                let p01 = src_img.get_pixel(x0, y0 + 1)[0] as f32;
                let p11 = src_img.get_pixel(x0 + 1, y0 + 1)[0] as f32;
                
                let val = (1.0 - dy) * ((1.0 - dx) * p00 + dx * p10) 
                        + dy * ((1.0 - dx) * p01 + dx * p11);
                
                dst.put_pixel(x, y, Luma([val as u8]));
            }
        }
    }

    dst
}

/// Convert a GrayImage to a Base64 JPEG with a quadrilateral and optional anchors drawn on it.
/// If `transform` is provided, anchors are projected from template space (relative to width=100) to image space.
pub fn generate_marked_image(
    gray: &image::GrayImage, 
    quad: &[crate::Point], 
    anchors: Option<&[crate::AnchorConfig]>,
    marker_outlines: Option<&[Vec<crate::Point>]>,
    transform: Option<&crate::transform::perspective::PerspectiveTransform>
) -> String {
    use imageproc::drawing::draw_line_segment_mut;
    use image::Rgb;
    use base64::Engine as _;

    let (w, h) = gray.dimensions();
    let mut rgb = image::RgbImage::new(w, h);
    for y in 0..h {
        for x in 0..w {
            let v = gray.get_pixel(x, y)[0];
            rgb.put_pixel(x, y, Rgb([v, v, v]));
        }
    }

    let red = Rgb([255u8, 0, 0]);
    let thickness = (w as f32 * 0.003).max(3.0) as i32;

    for t in -(thickness / 2)..(thickness / 2) {
        let offset = t as f32;
        for i in 0..4 {
            let p1 = quad[i];
            let p2 = quad[(i + 1) % 4];
            draw_line_segment_mut(&mut rgb, (p1.x + offset, p1.y), (p2.x + offset, p2.y), red);
            draw_line_segment_mut(&mut rgb, (p1.x, p1.y + offset), (p2.x, p2.y + offset), red);
        }
    }

    // Draw anchors if provided
    if let Some(anchs) = anchors {
        let purple = Rgb([200u8, 0, 200]); // Brighter purple
        use imageproc::drawing::{draw_hollow_rect_mut, draw_line_segment_mut};
        use imageproc::rect::Rect;

        for anchor in anchs {
            if let Some(pt) = transform {
                // Project 4 corners of the anchor
                let p_tl = pt.transform_inverse(anchor.x, anchor.y);
                let p_tr = pt.transform_inverse(anchor.x + anchor.width, anchor.y);
                let p_br = pt.transform_inverse(anchor.x + anchor.width, anchor.y + anchor.height);
                let p_bl = pt.transform_inverse(anchor.x, anchor.y + anchor.height);
                
                let pts = [p_tl, p_tr, p_br, p_bl];
                for t in -(thickness / 2)..(thickness / 2) {
                    let offset = t as f32;
                    for i in 0..4 {
                        let p1 = pts[i];
                        let p2 = pts[(i + 1) % 4];
                        draw_line_segment_mut(&mut rgb, (p1.x + offset, p1.y), (p2.x + offset, p2.y), purple);
                        draw_line_segment_mut(&mut rgb, (p1.x, p1.y + offset), (p2.x, p2.y + offset), purple);
                    }
                }
            } else {
                // Fallback: simple scaling (no perspective projection)
                let scale = w as f32 / 100.0;
                let ax = anchor.x * scale;
                let ay = anchor.y * scale;
                let aw = anchor.width * scale;
                let ah = anchor.height * scale;

                for t in 0..thickness {
                    let rect = Rect::at((ax - t as f32/2.0) as i32, (ay - t as f32/2.0) as i32)
                        .of_size((aw + t as f32) as u32, (ah + t as f32) as u32);
                    draw_hollow_rect_mut(&mut rgb, rect, purple);
                }
            }
        }
    }

    // Draw marker outlines if provided (usually in ArUco mode)
    if let Some(outlines) = marker_outlines {
        let green = Rgb([0u8, 255, 0]);
        for outline in outlines {
            for i in 0..outline.len() {
                let p1 = outline[i];
                let p2 = outline[(i + 1) % outline.len()];
                draw_line_segment_mut(&mut rgb, (p1.x, p1.y), (p2.x, p2.y), green);
            }
        }
    }

    let mut buffer = std::io::Cursor::new(Vec::new());
    let encoder = image::codecs::jpeg::JpegEncoder::new_with_quality(&mut buffer, 85);
    image::ImageEncoder::write_image(
        encoder, rgb.as_raw(), w, h, image::ExtendedColorType::Rgb8
    ).ok();

    base64::engine::general_purpose::STANDARD.encode(buffer.get_ref())
}

pub fn to_png_bytes(img: &GrayImage) -> anyhow::Result<Vec<u8>> {
    let mut buffer = std::io::Cursor::new(Vec::new());
    img.write_to(&mut buffer, image::ImageFormat::Png)?;
    Ok(buffer.into_inner())
}

pub fn encode_debug_image(img: &GrayImage) -> Option<String> {
    use base64::Engine as _;
    to_png_bytes(img).ok().map(|b| base64::engine::general_purpose::STANDARD.encode(b))
}