zaxis 0.0.3

An event-driven immediate mode GUI for desktop tools
Documentation
use super::*;
use crate::{vec2, Context, Image, ImageFit, TextureFilter, Window};
use std::{
    io::Cursor,
    sync::{mpsc, Arc, Condvar, Mutex},
    time::{Duration, Instant},
};

fn encoded(format: image::ImageFormat) -> Vec<u8> {
    let mut out = Cursor::new(Vec::new());
    image::DynamicImage::ImageRgba8(image::RgbaImage::from_pixel(
        3,
        2,
        image::Rgba([255, 32, 0, 128]),
    ))
    .write_to(&mut out, format)
    .unwrap();
    out.into_inner()
}
fn decode_bytes(bytes: Vec<u8>) -> Result<decode::Document, ImageError> {
    decode::load(
        &source::Source::Encoded(Arc::new(bytes)),
        &ImageLimits::default(),
        &[],
        &mut Vec::new(),
    )
}
const SVG:&[u8] = br##"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 20"><defs><linearGradient id="g"><stop stop-color="red"/><stop offset="1" stop-color="blue"/></linearGradient><clipPath id="c"><circle cx="20" cy="10" r="8"/></clipPath></defs><g transform="translate(1 0)" clip-path="url(#c)"><path d="M0 0H40V20H0Z" fill="url(#g)" stroke="white"/></g></svg>"##;

#[test]
fn supported_formats_sniff_content_and_first_frames() {
    let mut formats = vec![
        image::ImageFormat::Png,
        image::ImageFormat::Jpeg,
        image::ImageFormat::WebP,
        image::ImageFormat::Bmp,
    ];
    #[cfg(feature = "image-gif")]
    formats.push(image::ImageFormat::Gif);
    #[cfg(feature = "image-tiff")]
    formats.push(image::ImageFormat::Tiff);
    for format in formats {
        let mut out = Cursor::new(Vec::new());
        let image = if format == image::ImageFormat::Jpeg {
            image::DynamicImage::ImageRgb8(image::RgbImage::from_pixel(
                3,
                2,
                image::Rgb([255, 32, 0]),
            ))
        } else {
            image::DynamicImage::ImageRgba8(image::RgbaImage::from_pixel(
                3,
                2,
                image::Rgba([255, 32, 0, 128]),
            ))
        };
        image.write_to(&mut out, format).unwrap();
        let bytes = out.into_inner();
        assert_eq!(
            decode_bytes(bytes.clone()).unwrap().size(),
            [3, 2],
            "{format:?}"
        );
        assert!(
            decode_bytes(bytes[..bytes.len() / 2].to_vec()).is_err(),
            "{format:?} accepted truncated input"
        );
    }
    assert_eq!(decode_bytes(SVG.to_vec()).unwrap().size(), [40, 20]);
    assert!(decode_bytes(b"bad content".to_vec()).is_err());
}
#[test]
fn jpeg_exif_orientation_is_applied() {
    let mut out = Cursor::new(Vec::new());
    image::DynamicImage::ImageRgb8(image::RgbImage::from_pixel(3, 2, image::Rgb([255, 0, 0])))
        .write_to(&mut out, image::ImageFormat::Jpeg)
        .unwrap();
    let jpeg = out.into_inner();
    let exif = b"Exif\0\0II\x2a\0\x08\0\0\0\x01\0\x12\x01\x03\0\x01\0\0\0\x06\0\0\0\0\0\0\0";
    let mut oriented = jpeg[..2].to_vec();
    oriented.extend([0xff, 0xe1]);
    oriented.extend(((exif.len() + 2) as u16).to_be_bytes());
    oriented.extend(exif);
    oriented.extend(&jpeg[2..]);
    assert_eq!(decode_bytes(oriented).unwrap().size(), [2, 3]);
}
#[test]
fn alpha_conversion_area_reduction_and_limits() {
    let mut pixels = [128, 64, 0, 128, 20, 30, 40, 0];
    decode::unpremultiply(&mut pixels);
    assert_eq!(pixels, [255, 128, 0, 128, 0, 0, 0, 0]);
    let input = DecodedImage {
        size: [2, 2],
        pixels: Arc::new(vec![
            255, 0, 0, 255, 0, 0, 255, 0, 255, 0, 0, 255, 0, 0, 255, 0,
        ]),
    };
    let output = resize::downsample(&input, [1, 1], &ImageLimits::default()).unwrap();
    assert_eq!(&output.pixels[..], [255, 0, 0, 128]);
    let limit = ImageLimits {
        max_decoded_bytes: 12,
        ..Default::default()
    };
    assert!(limit.check_size([2, 2]).is_err());
    assert!(limit.check_size([u32::MAX, u32::MAX]).is_err());
    assert!(decode::validate_rgba([2, 2], &[0; 15], &ImageLimits::default()).is_err());
    let bytes = encoded(image::ImageFormat::Png);
    let small = ImageLimits {
        max_encoded_bytes: 8,
        ..Default::default()
    };
    assert!(decode::load(
        &source::Source::Encoded(Arc::new(bytes)),
        &small,
        &[],
        &mut Vec::new()
    )
    .is_err());
    assert!(decode_bytes(
        br#"<svg xmlns="http://www.w3.org/2000/svg"><filter id="f"/></svg>"#.to_vec()
    )
    .is_err());
}
fn context() -> (Context, mpsc::Receiver<()>) {
    let mut c = Context::new();
    c.set_viewport(crate::winit::dpi::PhysicalSize::new(800, 600), 1.0);
    let (tx, rx) = mpsc::channel();
    c.set_image_waker(move || {
        let _ = tx.send(());
    });
    (c, rx)
}
fn build(c: &mut Context, h: ImageHandle, n: usize) {
    c.run(|c| {
        Window::new("images")
            .default_size(vec2(700.0, 500.0))
            .show(c, |ui| {
                for i in 0..n {
                    ui.push_id(i, |ui| {
                        ui.add(Image::new(h).size(vec2(32.0, 32.0)).fit(ImageFit::Stretch));
                    });
                }
            });
    });
}
fn ready(c: &mut Context, rx: &mpsc::Receiver<()>, h: ImageHandle, n: usize) {
    let start = Instant::now();
    loop {
        build(c, h, n);
        match c.image_state(h) {
            ImageState::Ready { .. } => return,
            ImageState::Error(e) => panic!("{e}"),
            _ => {}
        }
        assert!(start.elapsed() < Duration::from_secs(10));
        rx.recv_timeout(Duration::from_secs(10)).unwrap();
    }
}
#[test]
fn shared_source_wakes_idle_host_and_pixels_do_not_rebuild_geometry() {
    let (mut c, rx) = context();
    let source = ImageSource::encoded(encoded(image::ImageFormat::Png));
    let h = c.load_image(&source).unwrap();
    assert_eq!(h, c.load_image(&source).unwrap());
    ready(&mut c, &rx, h, 6);
    let metrics = c.image_metrics();
    assert_eq!(metrics.decodes, 1);
    let revision = c.draw_data().revision;
    build(&mut c, h, 6);
    assert_eq!(c.draw_data().revision, revision);
    assert_eq!(c.image_metrics().decodes, 1);
    assert_eq!(c.image_metrics().pending_jobs, 0);
    assert!(!c.needs_repaint());
    assert!(c.next_repaint().is_none());
    assert_eq!(c.draw_data().texture_options.len(), 1);
    let texture_id = c
        .draw_data()
        .texture_options
        .keys()
        .next()
        .copied()
        .unwrap();
    c.update_image(h, ImageSource::rgba([3, 2], vec![0; 24]))
        .unwrap();
    ready(&mut c, &rx, h, 6);
    assert_eq!(c.draw_data().revision, revision);
    assert!(c.draw_data().texture_options.contains_key(&texture_id));
    assert!(c
        .draw_data()
        .textures
        .iter()
        .find(|t| t.id == texture_id)
        .unwrap()
        .pixels
        .iter()
        .all(|b| *b == 0));
}
#[test]
fn svg_dpi_resize_debounce_and_parsed_cache() {
    let (mut c, rx) = context();
    let h = c.load_image(SVG).unwrap();
    ready(&mut c, &rx, h, 1);
    let start = Instant::now();
    let pass = |c: &mut Context, at, size| {
        c.run_at(at, |c| {
            Window::new("svg").show(c, |ui| {
                ui.add(Image::new(h).size(size).fit(ImageFit::Stretch));
            });
        });
    };
    for i in 0..30 {
        pass(
            &mut c,
            start + Duration::from_millis(i * 3),
            vec2(70.0 + i as f32, 40.0),
        );
    }
    assert_eq!(c.image_metrics().svg_parses, 1);
    assert_eq!(c.image_metrics().rasterizations, 1);
    pass(&mut c, start + Duration::from_millis(300), vec2(99.0, 40.0));
    rx.recv_timeout(Duration::from_secs(10)).unwrap();
    pass(&mut c, start + Duration::from_millis(301), vec2(99.0, 40.0));
    assert_eq!(c.image_metrics().svg_parses, 1);
    assert_eq!(c.image_metrics().rasterizations, 2);
    let id = *c.draw_data().texture_options.keys().next().unwrap();
    assert_eq!(
        c.draw_data()
            .textures
            .iter()
            .find(|t| t.id == id)
            .unwrap()
            .size,
        [99, 40]
    );
    c.set_viewport(crate::winit::dpi::PhysicalSize::new(1600, 1200), 2.0);
    pass(&mut c, start + Duration::from_millis(302), vec2(99.0, 40.0));
    pass(&mut c, start + Duration::from_millis(500), vec2(99.0, 40.0));
    rx.recv_timeout(Duration::from_secs(10)).unwrap();
    pass(&mut c, start + Duration::from_millis(501), vec2(99.0, 40.0));
    assert_eq!(
        c.draw_data()
            .textures
            .iter()
            .find(|t| t.id == id)
            .unwrap()
            .size,
        [198, 80]
    );
}
#[test]
fn text_ids_filters_errors_retry_and_eviction_recovery() {
    let (mut c, rx) = context();
    let h = c
        .load_image(ImageSource::rgba([3, 2], vec![255; 24]))
        .unwrap();
    ready(&mut c, &rx, h, 1);
    c.run(|c| {
        Window::new("mix").show(c, |ui| {
            ui.label("glyphs");
            ui.add(Image::new(h));
            ui.add(Image::new(h).filter(TextureFilter::Nearest));
        });
    });
    let data = c.draw_data();
    let ids: std::collections::HashSet<_> = data.textures.iter().map(|t| t.id).collect();
    assert_eq!(ids.len(), data.textures.len());
    assert_eq!(data.texture_options.len(), 2);
    assert!(data
        .textures
        .iter()
        .any(|t| !data.texture_options.contains_key(&t.id)));
    c.clear_image_cache();
    ready(&mut c, &rx, h, 1);
    assert_eq!(c.image_metrics().decodes, 0);
    c.update_image(h, ImageSource::encoded(vec![1, 2, 3]))
        .unwrap();
    build(&mut c, h, 1);
    rx.recv_timeout(Duration::from_secs(10)).unwrap();
    build(&mut c, h, 1);
    assert!(matches!(c.image_state(h), ImageState::Error(_)));
    let attempts = c.image_metrics().pending_jobs;
    for _ in 0..10 {
        build(&mut c, h, 1);
    }
    assert_eq!(attempts, 0);
    assert_eq!(c.image_metrics().pending_jobs, 0);
    c.update_image(h, ImageSource::rgba([1, 1], vec![255; 4]))
        .unwrap();
    ready(&mut c, &rx, h, 1);
    c.release_image(h);
    assert!(c.load_image(h).is_err());
}
struct BlockedDecoder(Arc<(Mutex<bool>, Condvar)>);
impl ImageDecoder for BlockedDecoder {
    fn decode(&self, b: &[u8], _: &ImageLimits) -> Option<Result<DecodedImage, ImageError>> {
        if b != b"wait" {
            return None;
        }
        let (lock, wake) = &*self.0;
        let mut done = lock.lock().unwrap();
        while !*done {
            done = wake.wait(done).unwrap();
        }
        Some(Ok(DecodedImage {
            size: [1, 1],
            pixels: Arc::new(vec![255, 0, 0, 255]),
        }))
    }
}
#[test]
fn stale_completion_cannot_replace_new_generation_and_drop_does_not_wake() {
    let gate = Arc::new((Mutex::new(false), Condvar::new()));
    let (mut c, rx) = context();
    c.add_image_decoder(Arc::new(BlockedDecoder(gate.clone())));
    let h = c.load_image(ImageSource::bytes(b"wait")).unwrap();
    build(&mut c, h, 1);
    c.update_image(h, ImageSource::rgba([1, 1], vec![0, 255, 0, 255]))
        .unwrap();
    ready(&mut c, &rx, h, 1);
    *gate.0.lock().unwrap() = true;
    gate.1.notify_all();
    rx.recv_timeout(Duration::from_secs(10)).unwrap();
    build(&mut c, h, 1);
    assert_eq!(c.image_metrics().stale_completions, 1);
    let id = *c.draw_data().texture_options.keys().next().unwrap();
    assert_eq!(
        &c.draw_data()
            .textures
            .iter()
            .find(|t| t.id == id)
            .unwrap()
            .pixels[..],
        [0, 255, 0, 255]
    );
    drop(c);
}
#[test]
fn fit_crop_math() {
    let rect = crate::Rect::from_min_size(vec2(0.0, 0.0), vec2(100.0, 100.0));
    let uv = crate::Rect::from_min_size(vec2(0.0, 0.0), vec2(1.0, 1.0));
    let (r, _) = crate::components::image::fit(rect, vec2(200.0, 100.0), uv, ImageFit::Contain);
    assert_eq!(r.size(), vec2(100.0, 50.0));
    let (_, crop) = crate::components::image::fit(rect, vec2(200.0, 100.0), uv, ImageFit::Cover);
    assert_eq!(crop.min, vec2(0.25, 0.0));
    assert_eq!(crop.max, vec2(0.75, 1.0));
}