rvimage-domain 0.5.0

use image::{ImageBuffer, Luma, Pixel};
use imageproc::drawing::draw_filled_circle_mut;
use serde::{Deserialize, Serialize, ser::SerializeStruct};
use std::mem;

use crate::{OutOfBoundsMode, ShapeI, color_with_intensity, result::RvResult, rverr};

use super::{BbF, BbI, BrushLine, Point, PtF, PtI, RenderTargetOrShape, TPtF, line::render_line};

fn line_to_mask(
    line: &BrushLine,
    orig_shape: Option<ShapeI>,
    buffer: Option<Vec<u8>>,
) -> RvResult<(Vec<u8>, BbI)> {
    let bb = line.bb(orig_shape)?;
    let color = Luma([1]);
    let bbi = BbI::from_arr(&[
        bb.x as u32,
        bb.y as u32,
        bb.w.ceil() as u32,
        bb.h.ceil() as u32,
    ]);
    let is_none = buffer.is_none();
    let mut buffer = if let Some(mut buffer) =
        buffer.filter(|buffer| buffer.len() >= (bbi.w * bbi.h) as usize)
    {
        buffer.fill(0);
        ImageBuffer::from_vec(bbi.w, bbi.h, buffer)
            .unwrap_or_else(|| RenderTargetOrShape::Shape(bbi.shape()).make_buffer())
    } else {
        tracing::debug!(
            "(re-)creating buffer, buffer is {}",
            if is_none { "None" } else { "Some" }
        );
        RenderTargetOrShape::Shape(bbi.shape()).make_buffer()
    };
    let im = if line.line.points.len() == 1 {
        let center = Point {
            x: (line.line.points[0].x - bb.x) as i32,
            y: (line.line.points[0].y - bb.y) as i32,
        };

        let thickness_half = line.thickness * 0.5;
        if line.thickness <= 1.1 {
            buffer.put_pixel(center.x as u32, center.y as u32, color);
        } else {
            let r = if thickness_half.floor() == thickness_half {
                (thickness_half - 1.0) as i32
            } else {
                thickness_half as i32
            };
            draw_filled_circle_mut(&mut buffer, (center.x, center.y), r, color);
        }
        buffer
    } else {
        render_line(
            line.line
                .points_iter()
                .filter(|p| bb.contains(*p))
                .map(|p| PtF {
                    x: p.x - bb.x,
                    y: p.y - bb.y,
                }),
            1.0,
            line.thickness,
            RenderTargetOrShape::Image(buffer),
            color,
        )
    };
    Ok((im.to_vec(), bbi))
}

#[must_use]
pub fn mask_to_rle_rowmajor(mask: &[u8], mask_w: u32, mask_h: u32) -> Vec<u32> {
    let mut rle = Vec::new();
    let mut current_run = 0;
    let mut current_value = 0;
    for y in 0..mask_h {
        for x in 0..mask_w {
            let value = mask[(y * mask_w + x) as usize];
            if value == current_value {
                current_run += 1;
            } else {
                rle.push(current_run);
                current_run = 1;
                current_value = value;
            }
        }
    }
    rle.push(current_run);
    rle
}

pub fn rle_to_mask_rowmajor_inplace(rle: &[u32], mask: &mut [u8], w: u32) {
    for (i, &run) in rle.iter().enumerate() {
        let value = i % 2;
        let start = rle.iter().take(i).sum::<u32>();
        for idx in start..(start + run) {
            let x = idx % w;
            let y = idx / w;
            let idx = (y * w + x) as usize;
            if idx < mask.len() {
                mask[idx] = value as u8;
            }
        }
    }
}

#[must_use]
pub fn rle_to_mask_rowmajor(rle: &[u32], w: u32, h: u32) -> Vec<u8> {
    let mut mask = vec![0; (w * h) as usize];
    rle_to_mask_rowmajor_inplace(rle, &mut mask, w);
    mask
}

/// Column-major (Fortran order) run-length encoding of a row-major stored mask.
///
/// This is the ordering used by the Coco RLE format.
fn mask_to_rle_colmajor(mask: &[u8], w: u32, h: u32) -> Vec<u32> {
    let mut rle = Vec::new();
    let mut current_run = 0;
    let mut current_value = 0;
    for x in 0..w {
        for y in 0..h {
            let value = mask[(y * w + x) as usize];
            if value == current_value {
                current_run += 1;
            } else {
                rle.push(current_run);
                current_run = 1;
                current_value = value;
            }
        }
    }
    rle.push(current_run);
    rle
}

/// Decode a column-major (Fortran order) run-length encoding into a row-major
/// stored mask.
fn colmajor_rle_to_mask(rle: &[u32], w: u32, h: u32) -> Vec<u8> {
    let mut mask = vec![0u8; (w * h) as usize];
    let mut linear = 0u32;
    for (i, &run) in rle.iter().enumerate() {
        if i % 2 == 1 {
            for k in linear..(linear + run) {
                let x = k / h;
                let y = k % h;
                let idx = (y * w + x) as usize;
                if idx < mask.len() {
                    mask[idx] = 1;
                }
            }
        }
        linear += run;
    }
    mask
}

/// Decode a row-major (C order) run-length encoding into a row-major stored
/// mask.
///
/// This corresponds to the legacy RV Image RLE order (used by Coco files
/// exported before RV Image switched to the column-major Coco convention).
fn rowmajor_rle_to_mask(rle: &[u32], w: u32, h: u32) -> Vec<u8> {
    let mut mask = vec![0u8; (w * h) as usize];
    let mut linear = 0u32;
    for (i, &run) in rle.iter().enumerate() {
        if i % 2 == 1 {
            for k in linear..(linear + run) {
                let idx = k as usize;
                if idx < mask.len() {
                    mask[idx] = 1;
                }
            }
        }
        linear += run;
    }
    mask
}

/// Extract the bounding-box region from a full row-major image mask and encode
/// it in row-major order.
fn im_mask_to_bb_rle(im_mask: &[u8], bb: BbI, shape_im: ShapeI) -> Vec<u32> {
    let mut bb_mask = vec![0u8; (bb.w * bb.h) as usize];
    for y in 0..bb.h {
        for x in 0..bb.w {
            let ix = bb.x + x;
            let iy = bb.y + y;
            bb_mask[(y * bb.w + x) as usize] = im_mask[(iy * shape_im.w + ix) as usize];
        }
    }
    mask_to_rle_rowmajor(&bb_mask, bb.w, bb.h)
}

/// The input rle is computed with respect to the bounding box coordinates in
/// row-major order, the result is with respect to image coordinates in
/// column-major (Coco/Fortran) order.
pub fn rle_bb_to_image_colmajor(rle_bb: &[u32], bb: BbI, shape_im: ShapeI) -> RvResult<Vec<u32>> {
    if !bb.is_contained_in_image(shape_im) {
        Err(rverr!(
            "Bounding box {} is not contained in image with shape {:?}",
            bb,
            shape_im
        ))
    } else {
        // decode the row-major bounding-box rle into a row-major bb mask
        let bb_mask = rle_to_mask_rowmajor(rle_bb, bb.w, bb.h);
        // place the bb mask into a full row-major image mask
        let mut im_mask = vec![0u8; (shape_im.w * shape_im.h) as usize];
        for y in 0..bb.h {
            for x in 0..bb.w {
                if bb_mask[(y * bb.w + x) as usize] != 0 {
                    let ix = bb.x + x;
                    let iy = bb.y + y;
                    im_mask[(iy * shape_im.w + ix) as usize] = 1;
                }
            }
        }
        // encode the image mask in column-major (Coco) order
        Ok(mask_to_rle_colmajor(&im_mask, shape_im.w, shape_im.h))
    }
}
/// The input rle is computed with respect to the image coordinates in
/// column-major (Coco/Fortran) order, the result is with respect to bounding
/// box coordinates in row-major order.
pub fn rle_image_to_bb_colmajor(rle_im: &[u32], bb: BbI, shape_im: ShapeI) -> RvResult<Vec<u32>> {
    if !bb.is_contained_in_image(shape_im) {
        Err(rverr!(
            "Bounding box {} is not contained in image with shape {:?}",
            bb,
            shape_im
        ))
    } else {
        // decode the column-major image rle into a full row-major image mask
        let im_mask = colmajor_rle_to_mask(rle_im, shape_im.w, shape_im.h);
        Ok(im_mask_to_bb_rle(&im_mask, bb, shape_im))
    }
}
/// Legacy variant of [`rle_image_to_bb`] where the input rle is computed with
/// respect to the image coordinates in row-major (C) order. Used to import Coco
/// files exported by older RV Image versions.
pub fn rle_image_to_bb_rowmajor(rle_im: &[u32], bb: BbI, shape_im: ShapeI) -> RvResult<Vec<u32>> {
    if !bb.is_contained_in_image(shape_im) {
        Err(rverr!(
            "Bounding box {} is not contained in image with shape {:?}",
            bb,
            shape_im
        ))
    } else {
        // decode the row-major image rle into a full row-major image mask
        let im_mask = rowmajor_rle_to_mask(rle_im, shape_im.w, shape_im.h);
        Ok(im_mask_to_bb_rle(&im_mask, bb, shape_im))
    }
}

/// Get the 1d-index inside a bounding box from image coordinates
pub fn access_bb_idx(bb: BbI, p: PtI) -> usize {
    if bb.contains(p) {
        ((p.y - bb.y) * bb.w + p.x - bb.x) as usize
    } else {
        0
    }
}

/// Access a mask with coordinates for the image containing the mask
#[must_use]
pub fn access_mask_abs(mask: &[u8], bb: BbI, p: PtI) -> u8 {
    if bb.contains(p) {
        mask[access_bb_idx(bb, p)]
    } else {
        0
    }
}
#[must_use]
pub fn access_mask_rel(mask: &[u8], x: u32, y: u32, w: u32, h: u32) -> u8 {
    if x < w && y < h {
        mask[(y * w + x) as usize]
    } else {
        0
    }
}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct Canvas {
    pub mask: Vec<u8>,
    pub bb: BbI,
    pub intensity: TPtF,
}

impl Canvas {
    pub fn from_line_extended(
        line: &BrushLine,
        orig_shape: ShapeI,
        extension_factor: f64,
        lower_buffer_bound: usize,
    ) -> RvResult<Self> {
        if extension_factor < 1.0 {
            return Err(rverr!("extension factor {extension_factor} smaller 1"));
        }
        let bb = line.bb(Some(orig_shape))?;
        let new_w = (bb.w * extension_factor).ceil() as usize;
        let new_h = (bb.h * extension_factor).ceil() as usize;
        let new_size = (new_w * new_h)
            .min(orig_shape.w as usize * orig_shape.h as usize)
            .max(lower_buffer_bound);
        let buffer = vec![0; new_size];
        Self::new(line, orig_shape, Some(buffer))
    }
    pub fn new(line: &BrushLine, orig_shape: ShapeI, buffer: Option<Vec<u8>>) -> RvResult<Self> {
        let (mask, bb) = line_to_mask(line, Some(orig_shape), buffer)?;
        Ok(Self {
            mask,
            bb,
            intensity: line.intensity,
        })
    }
    pub fn from_box(bb: BbI, intensity: TPtF) -> Self {
        Self {
            bb,
            mask: vec![1; (bb.w * bb.h) as usize],
            intensity,
        }
    }
    #[must_use]
    pub fn merge(mut self, other: &Canvas) -> Self {
        let old_self_bb = self.bb;
        self.bb = self.bb.merge(other.bb);
        self.mask.resize((self.bb.w * self.bb.h) as usize, 0);
        // move self-mask to new positions
        for y in (0..old_self_bb.h).rev() {
            for x in (0..old_self_bb.w).rev() {
                let p = PtI { x, y } + old_self_bb.min();
                let old_idx = (y * old_self_bb.w + x) as usize;
                let new_idx = access_bb_idx(self.bb, p);
                let val = self.mask[old_idx];
                self.mask[old_idx] = 0;
                self.mask[new_idx] = val;
            }
        }
        // incorporate the other mask
        for y in 0..other.bb.h {
            for x in 0..other.bb.w {
                let p = PtI { x, y } + other.bb.min();
                let val_self = access_mask_abs(&self.mask, self.bb, p);
                let val_other = other.mask[(y * other.bb.w + x) as usize];
                let val = val_self.max(val_other);
                self.mask[((p.y - self.bb.y) * self.bb.w + (p.x - self.bb.x)) as usize] = val;
            }
        }
        self.intensity = self.intensity.max(other.intensity);
        self
    }
    pub fn draw_circle(&mut self, center: PtF, thickness: TPtF, color: u8) -> RvResult<()> {
        let im = ImageBuffer::<Luma<u8>, Vec<u8>>::from_vec(
            self.bb.w,
            self.bb.h,
            mem::take(&mut self.mask),
        );
        if let Some(mut im) = im {
            let color = Luma([color]);
            let center = Point {
                x: (center.x - TPtF::from(self.bb.x)) as i32,
                y: (center.y - TPtF::from(self.bb.y)) as i32,
            };

            if thickness <= 1.1 {
                im.put_pixel(center.x as u32, center.y as u32, color);
            } else {
                draw_filled_circle_mut(
                    &mut im,
                    (center.x, center.y),
                    (thickness * 0.5) as i32,
                    color,
                );
            }
            self.mask = im.into_vec();
            Ok(())
        } else {
            Err(rverr!(
                "Could not create image buffer for canvas at {:?}",
                self.bb
            ))
        }
    }
    /// This function does check the for out of bounds. We assume valid data has been serialized.
    pub fn from_serialized_brush_line(bl: &BrushLine) -> RvResult<Self> {
        let (mask, bb) = line_to_mask(bl, None, None)?;
        Ok(Self {
            mask,
            bb,
            intensity: bl.intensity,
        })
    }
    pub fn follow_movement(&mut self, from: PtF, to: PtF, shape: ShapeI) {
        let x_shift = (to.x - from.x) as TPtF;
        let y_shift = (to.y - from.y) as TPtF;
        let bb: BbF = self.bb.into();
        let bb = bb.translate(x_shift, y_shift, shape, OutOfBoundsMode::Deny);
        if let Some(bb) = bb {
            self.bb = bb.into();
        }
    }
}

impl Serialize for Canvas {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        let mut state = serializer.serialize_struct("Canvas", 3)?;
        state.serialize_field(
            "rle",
            &mask_to_rle_rowmajor(&self.mask, self.bb.w, self.bb.h),
        )?;
        state.serialize_field("bb", &self.bb)?;
        state.serialize_field("intensity", &self.intensity)?;
        state.end()
    }
}
impl<'de> Deserialize<'de> for Canvas {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[derive(Deserialize)]
        struct CanvasDe {
            rle: Vec<u32>,
            bb: BbI,
            intensity: TPtF,
        }
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum CanvasOrBl {
            Canvas(CanvasDe),
            BrushLine(BrushLine),
        }
        let read = CanvasOrBl::deserialize(deserializer)?;
        match read {
            CanvasOrBl::Canvas(canvas_de) => {
                let mask = rle_to_mask_rowmajor(&canvas_de.rle, canvas_de.bb.w, canvas_de.bb.h);
                Ok(Self {
                    mask,
                    bb: canvas_de.bb,
                    intensity: canvas_de.intensity,
                })
            }
            CanvasOrBl::BrushLine(bl) => {
                Canvas::from_serialized_brush_line(&bl).map_err(serde::de::Error::custom)
            }
        }
    }
}

pub fn canvases_to_image<'a, CLR>(
    canvases: impl Iterator<Item = &'a Canvas>,
    image_or_shape: RenderTargetOrShape<CLR>,
    color: CLR,
) -> ImageBuffer<CLR, Vec<u8>>
where
    CLR: Pixel<Subpixel = u8>,
{
    let mut im = image_or_shape.make_buffer();
    for cv in canvases {
        let color = color_with_intensity(color, cv.intensity);
        for y in cv.bb.y_range() {
            for x in cv.bb.x_range() {
                let p_idx = PtI { x, y };
                let is_fg = access_mask_abs(&cv.mask, cv.bb, p_idx) > 0;
                if is_fg {
                    im.put_pixel(x, y, color);
                }
            }
        }
    }
    im
}

#[cfg(test)]
use super::{BB, Line};
#[test]
fn test_canvas_single() {
    let orig_shape = ShapeI::new(30, 30);
    let bl = BrushLine {
        line: Line {
            points: vec![PtF { x: 5.0, y: 5.0 }],
        },
        intensity: 0.5,
        thickness: 3.0,
    };
    let cv = Canvas::new(&bl, orig_shape, None).unwrap();
    assert!(cv.mask.iter().sum::<u8>() > 0);
    let buffer = vec![43; 100];
    let orig_shape = ShapeI::new(30, 30);
    let bl = BrushLine {
        line: Line {
            points: vec![PtF { x: 5.0, y: 5.0 }],
        },
        intensity: 0.5,
        thickness: 3.0,
    };
    let cv2 = Canvas::new(&bl, orig_shape, Some(buffer)).unwrap();
    assert_eq!(cv.mask.iter().sum::<u8>(), cv2.mask.iter().sum::<u8>());
}

#[test]
fn test_rle() {
    fn test(
        bb: BbI,
        shape: ShapeI,
        rle_bb: &[u32],
        rle_im_ref_col: &[u32],
        rle_im_ref_row: &[u32],
        skip_rec: bool,
    ) {
        // column-major (Coco) export + import round-trip
        let rle_im = rle_bb_to_image_colmajor(rle_bb, bb, shape).unwrap();
        assert_eq!(rle_im, rle_im_ref_col);
        assert_eq!(rle_im.iter().sum::<u32>(), shape.w * shape.h);
        let rle_bb_rec = rle_image_to_bb_colmajor(&rle_im, bb, shape).unwrap();
        if !skip_rec {
            assert_eq!(rle_bb_rec, rle_bb);
        }
        // legacy row-major import: decode the independent row-major image rle
        // of the same mask and check it reconstructs the bb rle
        assert_eq!(rle_im_ref_row.iter().sum::<u32>(), shape.w * shape.h);
        let rle_bb_rec_row = rle_image_to_bb_rowmajor(rle_im_ref_row, bb, shape).unwrap();
        if !skip_rec {
            assert_eq!(rle_bb_rec_row, rle_bb);
        }
    }
    let rle_bb = [1, 1, 4, 1, 1];
    let bb = BbI::from_arr(&[1, 1, 2, 4]);
    let shape = ShapeI::new(4, 6);
    let rle_im_col = [10, 1, 2, 1, 10];
    let rle_im_row = [6, 1, 10, 1, 6];
    test(bb, shape, &rle_bb, &rle_im_col, &rle_im_row, false);

    let rle_bb = [0, 3, 1, 2];
    let bb = BbI::from_arr(&[3, 2, 2, 3]);
    let shape = ShapeI::new(6, 6);
    let rle_im_col = [20, 3, 3, 1, 1, 1, 7];
    let rle_im_row = [15, 2, 4, 1, 5, 2, 7];
    test(bb, shape, &rle_bb, &rle_im_col, &rle_im_row, false);

    let rle_bb = [0, 1, 3];
    let bb = BbI::from_arr(&[2, 2, 2, 2]);
    let shape = ShapeI::new(6, 6);
    let rle_im_col = [14, 1, 21];
    let rle_im_row = [14, 1, 21];
    test(bb, shape, &rle_bb, &rle_im_col, &rle_im_row, true);

    let rle_bb = [1, 2, 1];
    let bb = BbI::from_arr(&[1, 1, 2, 2]);
    let shape = ShapeI::new(6, 4);
    let rle_im_col = [6, 1, 2, 1, 14];
    let rle_im_row = [8, 1, 4, 1, 10];
    test(bb, shape, &rle_bb, &rle_im_col, &rle_im_row, false);

    let rle_bb = vec![0, 2, 2, 2];
    let bb = BbI::from_arr(&[3, 2, 2, 3]);
    let shape = ShapeI::new(6, 6);
    let rle_im_col = vec![20, 1, 1, 1, 3, 1, 1, 1, 7];
    let rle_im_row = vec![15, 2, 10, 2, 7];
    test(bb, shape, &rle_bb, &rle_im_col, &rle_im_row, false);

    let rle_bb = vec![3, 1];
    let bb = BbI::from_arr(&[1, 1, 2, 2]);
    let shape = ShapeI::new(6, 6);
    let rle_im_col = vec![14, 1, 21];
    let rle_im_row = vec![14, 1, 21];
    test(bb, shape, &rle_bb, &rle_im_col, &rle_im_row, true);

    let rle_bb = vec![6];
    let bb = BbI::from_arr(&[2, 1, 2, 3]);
    let shape = ShapeI::new(6, 6);
    let rle_im_col = vec![36];
    let rle_im_row = vec![36];
    test(bb, shape, &rle_bb, &rle_im_col, &rle_im_row, false);

    let rle_bb = vec![0, 6];
    let bb = BbI::from_arr(&[2, 1, 2, 3]);
    let shape = ShapeI::new(6, 6);
    let rle_im_col = vec![13, 3, 3, 3, 14];
    let rle_im_row = vec![8, 2, 4, 2, 4, 2, 14];
    test(bb, shape, &rle_bb, &rle_im_col, &rle_im_row, false);

    let rle_bb = vec![0, 1, 2, 1];
    let bb = BbI::from_arr(&[1, 1, 2, 2]);
    let shape = ShapeI::new(6, 8);
    let rle_im_col = vec![9, 1, 8, 1, 29];
    let rle_im_row = vec![7, 1, 6, 1, 33];
    test(bb, shape, &rle_bb, &rle_im_col, &rle_im_row, false);

    let rle_bb = vec![1, 4, 1];
    let bb = BbI::from_arr(&[1, 1, 2, 3]);
    let shape = ShapeI::new(6, 6);
    let rle_im_col = vec![8, 2, 3, 2, 21];
    let rle_im_row = vec![8, 1, 4, 2, 4, 1, 16];
    test(bb, shape, &rle_bb, &rle_im_col, &rle_im_row, false);

    let mask = vec![0, 1, 0, 0, 0, 0, 1, 0];
    let rle = mask_to_rle_rowmajor(&mask, 2, 4);
    assert_eq!(rle, vec![1, 1, 4, 1, 1]);

    let mask = vec![0, 0, 0, 0, 0, 0, 0, 0, 0];
    let rle = mask_to_rle_rowmajor(&mask, 3, 3);
    assert_eq!(rle, vec![9]);
    let mask2 = rle_to_mask_rowmajor(&rle, 3, 3);
    assert_eq!(mask, mask2);

    let mask = vec![1, 1, 1, 1, 1, 1, 1, 1, 1];
    let rle = mask_to_rle_rowmajor(&mask, 3, 3);
    assert_eq!(rle, vec![0, 9]);
    let mask2 = rle_to_mask_rowmajor(&rle, 3, 3);
    assert_eq!(mask, mask2);

    let mask = vec![1, 0, 0, 1, 1, 1, 0, 0, 0];
    let rle = mask_to_rle_rowmajor(&mask, 3, 3);
    assert_eq!(rle, vec![0, 1, 2, 3, 3]);
    let mask2 = rle_to_mask_rowmajor(&rle, 3, 3);
    assert_eq!(mask, mask2);
}

#[test]
fn test_rle_image_order() {
    // non-square image: width w=4, height h=3
    let shape = ShapeI::new(4, 3);
    let bb = BbI::from_arr(&[0, 0, 4, 3]); // full image
    // mask (row-major, w=4, h=3): fg at (x=1,y=0), (x=2,y=1), (x=0,y=2)
    #[rustfmt::skip]
    let mask = vec![
        0, 1, 0, 0,
        0, 0, 1, 0,
        1, 0, 0, 0,
    ];
    // the bb spans the whole image, so the bb rle equals the row-major image rle
    let bb_rle = mask_to_rle_rowmajor(&mask, 4, 3);
    assert_eq!(bb_rle, vec![1, 1, 4, 1, 1, 1, 3]);

    // legacy row-major image rle (== bb rle here) decodes back to the bb rle
    let rle_im_row = vec![1, 1, 4, 1, 1, 1, 3];
    assert_eq!(
        rle_image_to_bb_rowmajor(&rle_im_row, bb, shape).unwrap(),
        bb_rle
    );

    // column-major (Coco) image rle of the same mask decodes to the same bb rle
    let rle_im_col = vec![2, 2, 3, 1, 4];
    assert_eq!(rle_im_col.iter().sum::<u32>(), shape.w * shape.h);
    assert_eq!(
        rle_image_to_bb_colmajor(&rle_im_col, bb, shape).unwrap(),
        bb_rle
    );

    // the two image-level encodings genuinely differ (order matters)
    assert_ne!(rle_im_row, rle_im_col);
}

#[test]
fn test_canvas_serde() {
    let orig_shape = ShapeI::new(30, 30);
    let bl = BrushLine {
        line: Line {
            points: vec![PtF { x: 5.0, y: 5.0 }],
        },
        intensity: 0.5,
        thickness: 3.0,
    };
    let cv = Canvas::new(&bl, orig_shape, None).unwrap();
    let s = serde_json::to_string(&cv).unwrap();
    let cv_read: Canvas = serde_json::from_str(&s).unwrap();
    assert_eq!(cv, cv_read);
}

#[test]
fn test_line_to_mask() {
    fn test(mask_zeros: &[u8], mask_sum: u8, bb: BbI, bl: &BrushLine) {
        let (mask2, bb2) = line_to_mask(bl, None, None).unwrap();

        assert_eq!(bb, bb2);
        assert_eq!(mask2.iter().sum::<u8>(), mask_sum);
        for i in mask_zeros {
            assert_eq!(mask2[*i as usize], 0);
        }
    }

    let bl = BrushLine {
        line: Line {
            points: vec![PtF { x: 4.7, y: 4.7 }],
        },
        intensity: 0.5,
        thickness: 3.0,
    };
    test(&[0, 2, 6, 8], 5, BB::from_arr(&[3, 3, 3, 3]), &bl);

    let bl = BrushLine {
        line: Line {
            points: vec![PtF { x: 5.3, y: 5.3 }],
        },
        intensity: 0.5,
        thickness: 3.0,
    };
    test(&[0, 2, 6, 8], 5, BB::from_arr(&[3, 3, 3, 3]), &bl);
    let bl = BrushLine {
        line: Line {
            points: vec![PtF { x: 5.0, y: 5.0 }],
        },
        intensity: 0.5,
        thickness: 3.0,
    };
    test(&[0, 2, 6, 8], 5, BB::from_arr(&[3, 3, 3, 3]), &bl);
    let center = PtF { x: 5.0, y: 5.0 };
    let bl = BrushLine {
        line: Line {
            points: vec![center],
        },
        intensity: 0.5,
        thickness: 5.0,
    };
    test(&[], 21, BB::from_arr(&[2, 2, 5, 5]), &bl);
    let mut canvas = Canvas::new(&bl, ShapeI::new(30, 30), None).unwrap();
    canvas.draw_circle(center, 5.0, 0).unwrap();
    // maybe we didn't delete all but a significant portion due to rounding errors
    assert!(canvas.mask.iter().sum::<u8>() < 21 / 2);
}

#[test]
fn test_merge() {
    let c1 = Canvas {
        bb: BbI::from_arr(&[0, 0, 2, 2]),
        mask: vec![1, 0, 0, 1],
        intensity: 0.5,
    };
    let c2 = Canvas {
        bb: BbI::from_arr(&[0, 0, 2, 2]),
        mask: vec![1, 0, 0, 1],
        intensity: 0.7,
    };
    let merged = c1.clone().merge(&c2);
    assert_eq!(merged.mask, c1.mask);
    assert_eq!(merged.bb, c1.bb);
    assert_eq!(merged.intensity, c2.intensity);
    let c1 = Canvas {
        bb: BbI::from_arr(&[0, 0, 2, 2]),
        mask: vec![0, 1, 1, 0],
        intensity: 0.5,
    };
    let c2 = Canvas {
        bb: BbI::from_arr(&[0, 0, 2, 2]),
        mask: vec![1, 0, 0, 1],
        intensity: 0.7,
    };
    let merged = c1.merge(&c2);
    assert_eq!(merged.mask, vec![1, 1, 1, 1]);

    let c1 = Canvas {
        bb: BbI::from_arr(&[0, 0, 3, 2]),
        mask: vec![1, 0, 0, 0, 1, 0],
        intensity: 0.5,
    };
    let c2 = Canvas {
        bb: BbI::from_arr(&[2, 2, 2, 2]),
        mask: vec![1, 1, 1, 1],
        intensity: 0.7,
    };
    let merged = c1.merge(&c2);
    assert_eq!(c2.intensity, merged.intensity);
    assert_eq!(merged.mask.len(), 16);
    assert_eq!(merged.bb, BbI::from_arr(&[0, 0, 4, 4]));
    let mask_reference = vec![1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1];
    assert_eq!(merged.mask, mask_reference);

    let c1 = Canvas {
        bb: BbI::from_arr(&[1, 1, 3, 2]),
        mask: vec![1, 0, 0, 0, 1, 0],
        intensity: 0.5,
    };
    let c2 = Canvas {
        bb: BbI::from_arr(&[3, 3, 2, 2]),
        mask: vec![1, 1, 1, 1],
        intensity: 0.7,
    };
    let merged = c1.merge(&c2);
    assert_eq!(c2.intensity, merged.intensity);
    assert_eq!(merged.mask.len(), 16);
    assert_eq!(merged.bb, BbI::from_arr(&[1, 1, 4, 4]));
    let mask_reference = vec![1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1];
    assert_eq!(merged.mask, mask_reference);
}

#[test]
fn test_from_box() {
    let bb = BbI::from_arr(&[7, 8, 2, 2]);
    let i = 1.0;
    let c = Canvas::from_box(bb, i);
    assert_eq!(c.mask.len(), (bb.w * bb.h) as usize);
    assert_eq!(c.bb, bb);
    assert_eq!(c.intensity, i);
}