leptonica 0.4.0

//! Edge detection and enhancement operations

use crate::core::{Numa, Pix, PixelDepth, pix::RgbComponent};
use crate::filter::{FilterError, FilterResult, Kernel, blockconv_gray, convolve_gray};

/// Edge detection orientation
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EdgeOrientation {
    /// Detect horizontal edges
    Horizontal,
    /// Detect vertical edges
    Vertical,
    /// Detect all edges
    All,
}

/// Apply Sobel edge detection
///
/// Applies a 3x3 Sobel gradient filter and normalizes by dividing
/// by 8 (the sum of the absolute kernel weights), matching C
/// Leptonica `pixSobelEdgeFilter()`.
///
/// # Arguments
/// * `pix` - Input 8-bit grayscale image
/// * `orientation` - Which edges to detect
pub fn sobel_edge(pix: &Pix, orientation: EdgeOrientation) -> FilterResult<Pix> {
    check_grayscale(pix)?;

    // Add 1-pixel mirrored border, matching C pixAddMirroredBorder(pixs,1,1,1,1)
    let bordered = pix.add_mirrored_border(1, 1, 1, 1)?;

    match orientation {
        EdgeOrientation::Horizontal => {
            let kernel = Kernel::sobel_horizontal();
            sobel_convolve_and_abs(&bordered, pix.width(), pix.height(), &kernel)
        }
        EdgeOrientation::Vertical => {
            let kernel = Kernel::sobel_vertical();
            sobel_convolve_and_abs(&bordered, pix.width(), pix.height(), &kernel)
        }
        EdgeOrientation::All => {
            let h_kernel = Kernel::sobel_horizontal();
            let v_kernel = Kernel::sobel_vertical();
            sobel_combined(&bordered, pix.width(), pix.height(), &h_kernel, &v_kernel)
        }
    }
}

/// Apply Laplacian edge detection
pub fn laplacian_edge(pix: &Pix) -> FilterResult<Pix> {
    check_grayscale(pix)?;
    let kernel = Kernel::laplacian();
    convolve_and_abs(pix, &kernel)
}

/// Sobel-specific convolution: convolve bordered image, take absolute
/// value, and normalize by >>3 (divide by 8).
///
/// `bordered` is the source image with 1-pixel mirrored border already added.
/// `out_w` / `out_h` are the dimensions of the original (unbordered) image.
fn sobel_convolve_and_abs(
    bordered: &Pix,
    out_w: u32,
    out_h: u32,
    kernel: &Kernel,
) -> FilterResult<Pix> {
    let kw = kernel.width();
    let kh = kernel.height();
    let kcx = kernel.center_x() as i32;
    let kcy = kernel.center_y() as i32;

    let out_pix = Pix::new(out_w, out_h, PixelDepth::Bit8)?;
    let mut out_mut = out_pix.try_into_mut().unwrap();

    // The bordered image has 1-pixel padding on each side, so pixel (x, y)
    // of the original maps to (x + 1, y + 1) in bordered.
    for y in 0..out_h {
        for x in 0..out_w {
            let mut sum = 0i32;

            for ky in 0..kh {
                for kx in 0..kw {
                    // In the bordered image, pixel (x+1, y+1) is the centre.
                    // Kernel offset from centre is (kx - kcx, ky - kcy).
                    let bx = (x as i32 + 1 + kx as i32 - kcx) as u32;
                    let by = (y as i32 + 1 + ky as i32 - kcy) as u32;

                    let pixel = bordered.get_pixel_unchecked(bx, by) as i32;
                    let k = kernel.get(kx, ky).unwrap_or(0.0) as i32;
                    sum += pixel * k;
                }
            }

            // Normalise: >>3 (divide by 8), matching C leptonica
            let result = (sum.abs() >> 3) as u32;
            out_mut.set_pixel_unchecked(x, y, result);
        }
    }

    Ok(out_mut.into())
}

/// Convolve and take absolute value (for non-Sobel edge detection, e.g. Laplacian)
fn convolve_and_abs(pix: &Pix, kernel: &Kernel) -> FilterResult<Pix> {
    let w = pix.width();
    let h = pix.height();
    let kw = kernel.width();
    let kh = kernel.height();
    let kcx = kernel.center_x() as i32;
    let kcy = kernel.center_y() as i32;

    let out_pix = Pix::new(w, h, PixelDepth::Bit8)?;
    let mut out_mut = out_pix.try_into_mut().unwrap();

    for y in 0..h {
        for x in 0..w {
            let mut sum = 0.0f32;

            for ky in 0..kh {
                for kx in 0..kw {
                    let sx = x as i32 + (kx as i32 - kcx);
                    let sy = y as i32 + (ky as i32 - kcy);

                    let sx = sx.clamp(0, w as i32 - 1) as u32;
                    let sy = sy.clamp(0, h as i32 - 1) as u32;

                    let pixel = pix.get_pixel_unchecked(sx, sy) as f32;
                    let k = kernel.get(kx, ky).unwrap_or(0.0);
                    sum += pixel * k;
                }
            }

            let result = sum.abs().clamp(0.0, 255.0) as u32;
            out_mut.set_pixel_unchecked(x, y, result);
        }
    }

    Ok(out_mut.into())
}

/// Combined Sobel: magnitude of both gradient directions, with >>3
/// normalization on each component before summing, matching C
/// `pixSobelEdgeFilter(pixs, L_ALL_EDGES)`.
///
/// `bordered` is the source image with 1-pixel mirrored border.
/// `out_w` / `out_h` are the original (unbordered) dimensions.
fn sobel_combined(
    bordered: &Pix,
    out_w: u32,
    out_h: u32,
    h_kernel: &Kernel,
    v_kernel: &Kernel,
) -> FilterResult<Pix> {
    let kw = h_kernel.width();
    let kh = h_kernel.height();
    let kcx = h_kernel.center_x() as i32;
    let kcy = h_kernel.center_y() as i32;

    let out_pix = Pix::new(out_w, out_h, PixelDepth::Bit8)?;
    let mut out_mut = out_pix.try_into_mut().unwrap();

    for y in 0..out_h {
        for x in 0..out_w {
            let mut sum_h = 0i32;
            let mut sum_v = 0i32;

            for ky in 0..kh {
                for kx in 0..kw {
                    let bx = (x as i32 + 1 + kx as i32 - kcx) as u32;
                    let by = (y as i32 + 1 + ky as i32 - kcy) as u32;

                    let pixel = bordered.get_pixel_unchecked(bx, by) as i32;
                    sum_h += pixel * h_kernel.get(kx, ky).unwrap_or(0.0) as i32;
                    sum_v += pixel * v_kernel.get(kx, ky).unwrap_or(0.0) as i32;
                }
            }

            // Normalize each component by >>3, then sum with L_MIN(255, gx+gy)
            let gx = sum_v.abs() >> 3;
            let gy = sum_h.abs() >> 3;
            let result = (gx + gy).min(255) as u32;
            out_mut.set_pixel_unchecked(x, y, result);
        }
    }

    Ok(out_mut.into())
}

/// Apply sharpening filter
pub fn sharpen(pix: &Pix) -> FilterResult<Pix> {
    check_grayscale(pix)?;
    let kernel = Kernel::sharpen();
    convolve_gray(pix, &kernel)
}

/// Apply unsharp masking
///
/// # Arguments
/// * `pix` - Input image
/// * `radius` - Blur radius
/// * `amount` - Sharpening strength (0.0-1.0 typical, can be higher)
pub fn unsharp_mask(pix: &Pix, radius: u32, amount: f32) -> FilterResult<Pix> {
    check_grayscale(pix)?;

    let w = pix.width();
    let h = pix.height();

    // 1. Create blurred version
    let size = 2 * radius + 1;
    let blur_kernel = Kernel::gaussian(size, radius as f32)?;
    let blurred = convolve_gray(pix, &blur_kernel)?;

    // 2. Compute: result = original + amount * (original - blurred)
    let out_pix = Pix::new(w, h, PixelDepth::Bit8)?;
    let mut out_mut = out_pix.try_into_mut().unwrap();

    for y in 0..h {
        for x in 0..w {
            let orig = pix.get_pixel_unchecked(x, y) as f32;
            let blur = blurred.get_pixel_unchecked(x, y) as f32;

            let diff = orig - blur;
            let result = orig + amount * diff;
            let result = result.round().clamp(0.0, 255.0) as u32;

            out_mut.set_pixel_unchecked(x, y, result);
        }
    }

    Ok(out_mut.into())
}

/// Fast unsharp masking using block convolution
///
/// Uses block convolution for faster blurring instead of Gaussian convolution.
/// Only supports halfwidth=1 (3x3) or halfwidth=2 (5x5) for speed.
///
/// # Arguments
/// * `pix` - Input image (8 bpp grayscale for grayfast, 32 bpp for color)
/// * `halfwidth` - Kernel half-width (1 or 2; kernel size = 2*halfwidth+1)
/// * `amount` - Sharpening strength (typically 0.2-0.7)
pub fn unsharp_masking_fast(pix: &Pix, halfwidth: u32, amount: f32) -> FilterResult<Pix> {
    let depth = pix.depth();

    // Check supported depths
    if depth != PixelDepth::Bit8 && depth != PixelDepth::Bit32 {
        return Err(FilterError::UnsupportedDepth {
            expected: "8 or 32 bpp",
            actual: depth.bits(),
        });
    }

    // If 8bpp, dispatch to gray_fast
    if depth == PixelDepth::Bit8 {
        return unsharp_masking_gray_fast(pix, halfwidth, amount);
    }

    // 32bpp: extract R, G, B channels, apply gray_fast to each, recombine
    let pix_r = pix.get_rgb_component(RgbComponent::Red)?;
    let pix_g = pix.get_rgb_component(RgbComponent::Green)?;
    let pix_b = pix.get_rgb_component(RgbComponent::Blue)?;

    let pix_rs = unsharp_masking_gray_fast(&pix_r, halfwidth, amount)?;
    let pix_gs = unsharp_masking_gray_fast(&pix_g, halfwidth, amount)?;
    let pix_bs = unsharp_masking_gray_fast(&pix_b, halfwidth, amount)?;

    let mut result = Pix::create_rgb_image(&pix_rs, &pix_gs, &pix_bs)?;

    // If the original had alpha channel (spp=4), copy it
    if pix.spp() == 4 {
        let pix_a = pix.get_rgb_component(RgbComponent::Alpha)?;
        let mut result_mut = result.try_into_mut().unwrap();
        result_mut.set_rgb_component(&pix_a, RgbComponent::Alpha)?;
        result = result_mut.into();
    }

    Ok(result)
}

/// Fast unsharp masking for grayscale images
///
/// Uses block convolution for faster blurring.
pub fn unsharp_masking_gray_fast(pix: &Pix, halfwidth: u32, amount: f32) -> FilterResult<Pix> {
    // Validate input
    if pix.depth() != PixelDepth::Bit8 {
        return Err(FilterError::UnsupportedDepth {
            expected: "8-bpp grayscale",
            actual: pix.depth().bits(),
        });
    }

    // If amount <= 0.0, return a clone (no sharpening)
    if amount <= 0.0 {
        return Ok(pix.clone());
    }

    // Validate halfwidth
    if halfwidth != 1 && halfwidth != 2 {
        return Err(FilterError::InvalidParameters(
            "halfwidth must be 1 or 2".to_string(),
        ));
    }

    let w = pix.width();
    let h = pix.height();

    // Use block convolution for fast blurring
    // blockconv_gray(pix, None, wc, hc) where kernel size = 2*halfwidth+1
    let blurred = blockconv_gray(pix, None, halfwidth, halfwidth)?;

    // Compute: result = original + amount * (original - blurred)
    let out_pix = Pix::new(w, h, PixelDepth::Bit8)?;
    let mut out_mut = out_pix.try_into_mut().unwrap();

    for y in 0..h {
        for x in 0..w {
            let orig = pix.get_pixel_unchecked(x, y) as f32;
            let blur = blurred.get_pixel_unchecked(x, y) as f32;

            let diff = orig - blur;
            let result = orig + amount * diff;
            let result = result.round().clamp(0.0, 255.0) as u32;

            out_mut.set_pixel_unchecked(x, y, result);
        }
    }

    Ok(out_mut.into())
}

/// Apply emboss effect
///
/// Output values are centered around 128 (flat regions produce ~128,
/// edges produce values above or below 128 depending on gradient direction).
/// This differs from edge detection functions which output absolute magnitudes.
pub fn emboss(pix: &Pix) -> FilterResult<Pix> {
    check_grayscale(pix)?;

    let kernel = Kernel::emboss();
    let w = pix.width();
    let h = pix.height();
    let kw = kernel.width();
    let kh = kernel.height();
    let kcx = kernel.center_x() as i32;
    let kcy = kernel.center_y() as i32;

    let out_pix = Pix::new(w, h, PixelDepth::Bit8)?;
    let mut out_mut = out_pix.try_into_mut().unwrap();

    for y in 0..h {
        for x in 0..w {
            let mut sum = 0.0f32;

            for ky in 0..kh {
                for kx in 0..kw {
                    let sx = x as i32 + (kx as i32 - kcx);
                    let sy = y as i32 + (ky as i32 - kcy);

                    let sx = sx.clamp(0, w as i32 - 1) as u32;
                    let sy = sy.clamp(0, h as i32 - 1) as u32;

                    let pixel = pix.get_pixel_unchecked(sx, sy) as f32;
                    let k = kernel.get(kx, ky).unwrap_or(0.0);
                    sum += pixel * k;
                }
            }

            // Add 128 to center the emboss effect
            let result = (sum + 128.0).round().clamp(0.0, 255.0) as u32;
            out_mut.set_pixel_unchecked(x, y, result);
        }
    }

    Ok(out_mut.into())
}

/// Side from which to measure an edge profile
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EdgeSide {
    /// Scan from the left side
    FromLeft,
    /// Scan from the right side
    FromRight,
    /// Scan from the top
    FromTop,
    /// Scan from the bottom
    FromBottom,
}

/// Two-sided edge filter
///
/// Detects edges by computing directional gradients on both sides of a
/// transition.  Only registers edges where gradients have the same sign,
/// storing the minimum absolute gradient.  This suppresses single-pixel
/// noise.
///
/// # Arguments
/// * `pix` - Input 8bpp grayscale image
/// * `orientation` - `Horizontal` or `Vertical` (not `All`)
///
/// # See also
///
/// C Leptonica: `pixTwoSidedEdgeFilter()` in `edge.c`
pub fn two_sided_edge_filter(pix: &Pix, orientation: EdgeOrientation) -> FilterResult<Pix> {
    check_grayscale(pix)?;
    if orientation == EdgeOrientation::All {
        return Err(FilterError::InvalidParameters(
            "orientflag must be Horizontal or Vertical, not All".to_string(),
        ));
    }

    let w = pix.width();
    let h = pix.height();

    if orientation == EdgeOrientation::Vertical && w < 2 {
        return Err(FilterError::InvalidParameters(
            "image width must be >= 2 for vertical edge filter".to_string(),
        ));
    }
    if orientation == EdgeOrientation::Horizontal && h < 2 {
        return Err(FilterError::InvalidParameters(
            "image height must be >= 2 for horizontal edge filter".to_string(),
        ));
    }

    let out_pix = Pix::new(w, h, PixelDepth::Bit8)?;
    let mut out_mut = out_pix.try_into_mut().unwrap();

    if orientation == EdgeOrientation::Vertical {
        for y in 0..h {
            let mut cval = pix.get_pixel_unchecked(1, y) as i32;
            let mut lgrad = cval - pix.get_pixel_unchecked(0, y) as i32;
            for x in 1..w - 1 {
                let rval = pix.get_pixel_unchecked(x + 1, y) as i32;
                let rgrad = rval - cval;
                if lgrad * rgrad > 0 {
                    let val = if lgrad < 0 {
                        -lgrad.max(rgrad) // both negative: max is less negative
                    } else {
                        lgrad.min(rgrad)
                    };
                    out_mut.set_pixel_unchecked(x, y, val as u32);
                }
                lgrad = rgrad;
                cval = rval;
            }
        }
    } else {
        // Horizontal edges
        for x in 0..w {
            let mut cval = pix.get_pixel_unchecked(x, 1) as i32;
            let mut tgrad = cval - pix.get_pixel_unchecked(x, 0) as i32;
            for y in 1..h - 1 {
                let bval = pix.get_pixel_unchecked(x, y + 1) as i32;
                let bgrad = bval - cval;
                if tgrad * bgrad > 0 {
                    let val = if tgrad < 0 {
                        -tgrad.max(bgrad)
                    } else {
                        tgrad.min(bgrad)
                    };
                    out_mut.set_pixel_unchecked(x, y, val as u32);
                }
                tgrad = bgrad;
                cval = bval;
            }
        }
    }

    Ok(out_mut.into())
}

/// Get edge profile from a binary image
///
/// Extracts foreground edge pixel positions from one side of the image.
/// For left/right scans, returns a Numa of length `h` with x-positions.
/// For top/bottom scans, returns a Numa of length `w` with y-positions.
///
/// # Arguments
/// * `pix` - Input 1bpp binary image
/// * `side` - Which side to scan from
///
/// # See also
///
/// C Leptonica: `pixGetEdgeProfile()` in `edge.c`
pub fn get_edge_profile(pix: &Pix, side: EdgeSide) -> FilterResult<Numa> {
    if pix.depth() != PixelDepth::Bit1 {
        return Err(FilterError::UnsupportedDepth {
            expected: "1-bpp binary",
            actual: pix.depth().bits(),
        });
    }

    let w = pix.width();
    let h = pix.height();
    let mut na = Numa::with_capacity(
        if matches!(side, EdgeSide::FromLeft | EdgeSide::FromRight) {
            h as usize
        } else {
            w as usize
        },
    );

    match side {
        EdgeSide::FromLeft => {
            // For each row, find the leftmost ON pixel
            for y in 0..h {
                let mut loc = 0i32;
                for x in 0..w {
                    if pix.get_pixel_unchecked(x, y) == 1 {
                        loc = x as i32;
                        break;
                    }
                    if x == w - 1 {
                        loc = 0;
                    }
                }
                na.push(loc as f32);
            }
        }
        EdgeSide::FromRight => {
            // For each row, find the rightmost ON pixel
            for y in 0..h {
                let mut loc = (w - 1) as i32;
                for x in (0..w).rev() {
                    if pix.get_pixel_unchecked(x, y) == 1 {
                        loc = x as i32;
                        break;
                    }
                    if x == 0 {
                        loc = (w - 1) as i32;
                    }
                }
                na.push(loc as f32);
            }
        }
        EdgeSide::FromTop => {
            // For each column, find the topmost ON pixel
            for x in 0..w {
                let mut loc = 0i32;
                for y in 0..h {
                    if pix.get_pixel_unchecked(x, y) == 1 {
                        loc = y as i32;
                        break;
                    }
                    if y == h - 1 {
                        loc = 0;
                    }
                }
                na.push(loc as f32);
            }
        }
        EdgeSide::FromBottom => {
            // For each column, find the bottommost ON pixel
            for x in 0..w {
                let mut loc = (h - 1) as i32;
                for y in (0..h).rev() {
                    if pix.get_pixel_unchecked(x, y) == 1 {
                        loc = y as i32;
                        break;
                    }
                    if y == 0 {
                        loc = (h - 1) as i32;
                    }
                }
                na.push(loc as f32);
            }
        }
    }

    Ok(na)
}

/// Measure edge smoothness of a binary image
///
/// Quantifies edge smoothness by measuring jumps and reversals in the
/// edge profile.
///
/// # Arguments
/// * `pix` - Input 1bpp binary image
/// * `side` - Which side to scan from
/// * `minjump` - Minimum pixel jump to count (>= 1)
/// * `minreversal` - Minimum reversal depth to count (>= 1)
///
/// # Returns
/// `(jumps_per_length, jumpsum_per_length, reversals_per_length)`
///
/// # See also
///
/// C Leptonica: `pixMeasureEdgeSmoothness()` in `edge.c`
pub fn measure_edge_smoothness(
    pix: &Pix,
    side: EdgeSide,
    minjump: u32,
    minreversal: u32,
) -> FilterResult<(f32, f32, f32)> {
    if pix.depth() != PixelDepth::Bit1 {
        return Err(FilterError::UnsupportedDepth {
            expected: "1-bpp binary",
            actual: pix.depth().bits(),
        });
    }
    if minjump < 1 {
        return Err(FilterError::InvalidParameters(
            "minjump must be >= 1".to_string(),
        ));
    }
    if minreversal < 1 {
        return Err(FilterError::InvalidParameters(
            "minreversal must be >= 1".to_string(),
        ));
    }

    let na = get_edge_profile(pix, side)?;
    let n = na.len();
    if n < 2 {
        return Ok((0.0, 0.0, 0.0));
    }

    // Compute jumps
    let mut njumps = 0u32;
    let mut jumpsum = 0u32;
    let mut val = na.get_i32(0).unwrap_or(0);
    for i in 1..n {
        let nval = na.get_i32(i).unwrap_or(0);
        let diff = (nval - val).unsigned_abs();
        if diff >= minjump {
            njumps += 1;
            jumpsum += diff;
        }
        val = nval;
    }
    let len = (n - 1) as f32;
    let jpl = njumps as f32 / len;
    let jspl = jumpsum as f32 / len;

    // Compute reversals
    let nae = na
        .find_extrema(minreversal as f32)
        .map_err(|e| FilterError::InvalidParameters(format!("find_extrema failed: {e}")))?;
    let nreversal = if nae.len() > 1 { nae.len() - 1 } else { 0 };
    let rpl = nreversal as f32 / len;

    Ok((jpl, jspl, rpl))
}

fn check_grayscale(pix: &Pix) -> FilterResult<()> {
    if pix.depth() != PixelDepth::Bit8 {
        return Err(FilterError::UnsupportedDepth {
            expected: "8-bpp grayscale",
            actual: pix.depth().bits(),
        });
    }
    Ok(())
}

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

    fn create_test_image() -> Pix {
        let pix = Pix::new(10, 10, PixelDepth::Bit8).unwrap();
        let mut pix_mut = pix.try_into_mut().unwrap();

        // Create a pattern with edges
        for y in 0..10 {
            for x in 0..10 {
                let val = if x < 5 { 50 } else { 200 };
                pix_mut.set_pixel_unchecked(x, y, val);
            }
        }

        pix_mut.into()
    }

    #[test]
    fn test_sobel_vertical() {
        let pix = create_test_image();
        let edges = sobel_edge(&pix, EdgeOrientation::Vertical).unwrap();

        // Vertical edge at x=4-5 should be detected
        let edge_val = edges.get_pixel_unchecked(4, 5);
        let non_edge_val = edges.get_pixel_unchecked(1, 5);

        assert!(edge_val > non_edge_val);
    }

    #[test]
    fn test_sobel_all() {
        let pix = create_test_image();
        let edges = sobel_edge(&pix, EdgeOrientation::All).unwrap();

        assert_eq!(edges.width(), pix.width());
        assert_eq!(edges.height(), pix.height());
    }

    #[test]
    fn test_laplacian() {
        let pix = create_test_image();
        let edges = laplacian_edge(&pix).unwrap();

        assert_eq!(edges.width(), pix.width());
    }

    #[test]
    fn test_sharpen() {
        let pix = create_test_image();
        let sharpened = sharpen(&pix).unwrap();

        assert_eq!(sharpened.width(), pix.width());
    }

    #[test]
    fn test_unsharp_mask() {
        let pix = create_test_image();
        let sharpened = unsharp_mask(&pix, 1, 0.5).unwrap();

        assert_eq!(sharpened.width(), pix.width());
    }

    #[test]
    fn test_emboss() {
        let pix = create_test_image();
        let embossed = emboss(&pix).unwrap();

        assert_eq!(embossed.width(), pix.width());
    }

    #[test]
    fn test_unsharp_masking_gray_fast_basic() {
        let pix = create_test_image();

        // Test with halfwidth=1, amount=0.5
        let result = unsharp_masking_gray_fast(&pix, 1, 0.5).unwrap();

        assert_eq!(result.width(), pix.width());
        assert_eq!(result.height(), pix.height());
        assert_eq!(result.depth(), PixelDepth::Bit8);
    }

    #[test]
    fn test_unsharp_masking_gray_fast_halfwidth2() {
        let pix = create_test_image();

        // Test with halfwidth=2, amount=0.7
        let result = unsharp_masking_gray_fast(&pix, 2, 0.7).unwrap();

        assert_eq!(result.width(), pix.width());
        assert_eq!(result.height(), pix.height());
    }

    #[test]
    fn test_unsharp_masking_gray_fast_no_op() {
        let pix = create_test_image();

        // Test with amount=0.0 (should return clone)
        let result = unsharp_masking_gray_fast(&pix, 1, 0.0).unwrap();

        // Should be a clone of original
        assert_eq!(result.width(), pix.width());
        assert_eq!(result.height(), pix.height());
    }

    #[test]
    fn test_unsharp_masking_gray_fast_rejects_non_8bpp() {
        let pix = Pix::new(10, 10, PixelDepth::Bit32).unwrap();

        let result = unsharp_masking_gray_fast(&pix, 1, 0.5);

        assert!(result.is_err());
    }

    #[test]
    fn test_unsharp_masking_fast_8bpp() {
        let pix = create_test_image();

        // Test with 8bpp image
        let result = unsharp_masking_fast(&pix, 1, 0.5).unwrap();

        assert_eq!(result.width(), pix.width());
        assert_eq!(result.height(), pix.height());
        assert_eq!(result.depth(), PixelDepth::Bit8);
    }

    #[test]
    fn test_unsharp_masking_fast_32bpp_rgb() {
        // Create a 32bpp RGB test image
        let pix = Pix::new(10, 10, PixelDepth::Bit32).unwrap();
        let mut pix_mut = pix.try_into_mut().unwrap();

        for y in 0..10 {
            for x in 0..10 {
                // Create RGB pattern
                let r = if x < 5 { 50 } else { 200 };
                let g = if y < 5 { 60 } else { 180 };
                let b = 128;
                let pixel = (r << 24) | (g << 16) | (b << 8) | 0xFF;
                pix_mut.set_pixel_unchecked(x, y, pixel);
            }
        }
        let pix = pix_mut.into();

        // Test with 32bpp image
        let result = unsharp_masking_fast(&pix, 1, 0.5).unwrap();

        assert_eq!(result.width(), pix.width());
        assert_eq!(result.height(), pix.height());
        assert_eq!(result.depth(), PixelDepth::Bit32);
    }
}