use embedded_graphics_core::{
Pixel,
draw_target::DrawTarget,
geometry::{Dimensions, OriginDimensions, Point, Size},
primitives::{PointsIter, Rectangle},
};
use crate::{ReadbackTarget, read_area_by_pixel};
#[inline]
fn translate(area: &Rectangle, offset: Point) -> Rectangle {
Rectangle::new(area.top_left + offset, area.size)
}
pub trait ReadbackTargetExt: ReadbackTarget + Sized {
#[must_use]
fn shifted(&mut self, offset: Point) -> Shifted<'_, Self>;
#[must_use]
fn windowed(&mut self, area: &Rectangle) -> Windowed<'_, Self>;
#[must_use]
fn masked(&mut self, area: &Rectangle) -> Masked<'_, Self>;
}
impl<T> ReadbackTargetExt for T
where
T: ReadbackTarget,
{
fn shifted(&mut self, offset: Point) -> Shifted<'_, Self> {
Shifted::new(self, offset)
}
fn windowed(&mut self, area: &Rectangle) -> Windowed<'_, Self> {
Windowed::new(self, area)
}
fn masked(&mut self, area: &Rectangle) -> Masked<'_, Self> {
Masked::new(self, area)
}
}
#[derive(Debug)]
pub struct Shifted<'a, T> {
parent: &'a mut T,
offset: Point,
}
impl<'a, T> Shifted<'a, T> {
#[must_use]
pub fn new(parent: &'a mut T, offset: Point) -> Self {
Self { parent, offset }
}
#[must_use]
pub fn parent(&self) -> &T {
self.parent
}
#[must_use]
pub fn offset(&self) -> Point {
self.offset
}
}
impl<T> DrawTarget for Shifted<'_, T>
where
T: DrawTarget,
{
type Color = T::Color;
type Error = T::Error;
fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
where
I: IntoIterator<Item = Pixel<Self::Color>>,
{
let offset = self.offset;
self.parent
.draw_iter(pixels.into_iter().map(|Pixel(p, c)| Pixel(p + offset, c)))
}
fn fill_contiguous<I>(&mut self, area: &Rectangle, colors: I) -> Result<(), Self::Error>
where
I: IntoIterator<Item = Self::Color>,
{
let area = translate(area, self.offset);
self.parent.fill_contiguous(&area, colors)
}
fn fill_solid(&mut self, area: &Rectangle, color: Self::Color) -> Result<(), Self::Error> {
let area = translate(area, self.offset);
self.parent.fill_solid(&area, color)
}
fn clear(&mut self, color: Self::Color) -> Result<(), Self::Error> {
self.parent.clear(color)
}
}
impl<T> Dimensions for Shifted<'_, T>
where
T: DrawTarget,
{
fn bounding_box(&self) -> Rectangle {
translate(&self.parent.bounding_box(), -self.offset)
}
}
impl<T> ReadbackTarget for Shifted<'_, T>
where
T: ReadbackTarget,
{
fn read_pixel(&self, point: Point) -> Option<Self::Color> {
self.parent.read_pixel(point + self.offset)
}
fn read_area(&self, area: &Rectangle, out: &mut [Self::Color]) -> usize {
self.parent.read_area(&translate(area, self.offset), out)
}
}
#[derive(Debug)]
pub struct Windowed<'a, T> {
parent: Shifted<'a, T>,
size: Size,
}
impl<'a, T> Windowed<'a, T>
where
T: DrawTarget,
{
#[must_use]
pub fn new(parent: &'a mut T, area: &Rectangle) -> Self {
let area = area.intersection(&parent.bounding_box());
Self {
size: area.size,
parent: Shifted::new(parent, area.top_left),
}
}
}
impl<T> Windowed<'_, T> {
#[must_use]
pub fn parent(&self) -> &T {
self.parent.parent()
}
#[must_use]
pub fn offset(&self) -> Point {
self.parent.offset()
}
}
impl<T> DrawTarget for Windowed<'_, T>
where
T: DrawTarget,
{
type Color = T::Color;
type Error = T::Error;
fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
where
I: IntoIterator<Item = Pixel<Self::Color>>,
{
self.parent.draw_iter(pixels)
}
fn fill_contiguous<I>(&mut self, area: &Rectangle, colors: I) -> Result<(), Self::Error>
where
I: IntoIterator<Item = Self::Color>,
{
self.parent.fill_contiguous(area, colors)
}
fn fill_solid(&mut self, area: &Rectangle, color: Self::Color) -> Result<(), Self::Error> {
self.parent.fill_solid(area, color)
}
}
impl<T> OriginDimensions for Windowed<'_, T>
where
T: DrawTarget,
{
fn size(&self) -> Size {
self.size
}
}
impl<T> ReadbackTarget for Windowed<'_, T>
where
T: ReadbackTarget,
{
fn read_pixel(&self, point: Point) -> Option<Self::Color> {
if self.bounding_box().contains(point) {
self.parent.read_pixel(point)
} else {
None
}
}
fn read_area(&self, area: &Rectangle, out: &mut [Self::Color]) -> usize {
if self.bounding_box().intersection(area) == *area {
self.parent.read_area(area, out)
} else {
read_area_by_pixel(self, area, out)
}
}
}
#[derive(Debug)]
pub struct Masked<'a, T> {
parent: &'a mut T,
mask_area: Rectangle,
}
impl<'a, T> Masked<'a, T>
where
T: DrawTarget,
{
#[must_use]
pub fn new(parent: &'a mut T, area: &Rectangle) -> Self {
let mask_area = area.intersection(&parent.bounding_box());
Self { parent, mask_area }
}
}
impl<T> Masked<'_, T> {
#[must_use]
pub fn parent(&self) -> &T {
self.parent
}
#[must_use]
pub fn mask_area(&self) -> Rectangle {
self.mask_area
}
}
impl<T> DrawTarget for Masked<'_, T>
where
T: DrawTarget,
{
type Color = T::Color;
type Error = T::Error;
fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
where
I: IntoIterator<Item = Pixel<Self::Color>>,
{
let mask_area = self.mask_area;
self.parent.draw_iter(
pixels
.into_iter()
.filter(|Pixel(p, _)| mask_area.contains(*p)),
)
}
fn fill_contiguous<I>(&mut self, area: &Rectangle, colors: I) -> Result<(), Self::Error>
where
I: IntoIterator<Item = Self::Color>,
{
if self.mask_area.intersection(area) == *area {
self.parent.fill_contiguous(area, colors)
} else {
self.draw_iter(area.points().zip(colors).map(|(p, c)| Pixel(p, c)))
}
}
fn fill_solid(&mut self, area: &Rectangle, color: Self::Color) -> Result<(), Self::Error> {
let area = area.intersection(&self.mask_area);
self.parent.fill_solid(&area, color)
}
}
impl<T> Dimensions for Masked<'_, T>
where
T: DrawTarget,
{
fn bounding_box(&self) -> Rectangle {
self.mask_area
}
}
impl<T> ReadbackTarget for Masked<'_, T>
where
T: ReadbackTarget,
{
fn read_pixel(&self, point: Point) -> Option<Self::Color> {
if self.mask_area.contains(point) {
self.parent.read_pixel(point)
} else {
None
}
}
fn read_area(&self, area: &Rectangle, out: &mut [Self::Color]) -> usize {
if self.mask_area.intersection(area) == *area {
self.parent.read_area(area, out)
} else {
read_area_by_pixel(self, area, out)
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use embedded_graphics::prelude::*;
use embedded_graphics_core::pixelcolor::Rgb565;
struct Fb {
pixels: [Rgb565; 64],
bulk_reads: core::cell::Cell<usize>,
}
impl Fb {
fn new() -> Self {
Self {
pixels: [Rgb565::BLACK; 64],
bulk_reads: core::cell::Cell::new(0),
}
}
fn index(p: Point) -> Option<usize> {
((0..8).contains(&p.x) && (0..8).contains(&p.y)).then(|| (p.y * 8 + p.x) as usize)
}
}
impl OriginDimensions for Fb {
fn size(&self) -> Size {
Size::new(8, 8)
}
}
impl DrawTarget for Fb {
type Color = Rgb565;
type Error = core::convert::Infallible;
fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
where
I: IntoIterator<Item = Pixel<Self::Color>>,
{
for Pixel(p, c) in pixels {
if let Some(i) = Self::index(p) {
self.pixels[i] = c;
}
}
Ok(())
}
}
impl ReadbackTarget for Fb {
fn read_pixel(&self, point: Point) -> Option<Self::Color> {
Self::index(point).map(|i| self.pixels[i])
}
fn read_area(&self, area: &Rectangle, out: &mut [Self::Color]) -> usize {
self.bulk_reads.set(self.bulk_reads.get() + 1);
read_area_by_pixel(self, area, out)
}
}
fn rect(x: i32, y: i32, w: u32, h: u32) -> Rectangle {
Rectangle::new(Point::new(x, y), Size::new(w, h))
}
#[test]
fn shifted_reads_through_the_offset() {
let mut fb = Fb::new();
Pixel(Point::new(5, 6), Rgb565::RED).draw(&mut fb).unwrap();
let layer = fb.shifted(Point::new(3, 4));
assert_eq!(layer.read_pixel(Point::new(2, 2)), Some(Rgb565::RED));
assert_eq!(layer.read_pixel(Point::new(0, 0)), Some(Rgb565::BLACK));
}
#[test]
fn shifted_round_trips_a_write_through_the_adapter() {
let mut fb = Fb::new();
let mut layer = fb.shifted(Point::new(3, 4));
Pixel(Point::new(1, 1), Rgb565::GREEN)
.draw(&mut layer)
.unwrap();
assert_eq!(layer.read_pixel(Point::new(1, 1)), Some(Rgb565::GREEN));
assert_eq!(fb.read_pixel(Point::new(4, 5)), Some(Rgb565::GREEN));
}
#[test]
fn shifted_moves_the_bounding_box() {
let mut fb = Fb::new();
let layer = fb.shifted(Point::new(3, 4));
assert_eq!(layer.bounding_box(), rect(-3, -4, 8, 8));
}
#[test]
fn shifted_read_area_keeps_the_parent_bulk_path() {
let mut fb = Fb::new();
Pixel(Point::new(3, 4), Rgb565::RED).draw(&mut fb).unwrap();
let layer = fb.shifted(Point::new(3, 4));
let mut out = [Rgb565::WHITE; 4];
let n = layer.read_area(&rect(0, 0, 2, 2), &mut out);
assert_eq!(n, 4);
assert_eq!(out[0], Rgb565::RED);
assert_eq!(layer.parent().bulk_reads.get(), 1);
}
#[test]
fn windowed_moves_the_origin_and_reports_its_size() {
let mut fb = Fb::new();
Pixel(Point::new(2, 3), Rgb565::RED).draw(&mut fb).unwrap();
let view = fb.windowed(&rect(2, 3, 4, 4));
assert_eq!(view.bounding_box(), rect(0, 0, 4, 4));
assert_eq!(view.offset(), Point::new(2, 3));
assert_eq!(view.read_pixel(Point::zero()), Some(Rgb565::RED));
}
#[test]
fn windowed_reads_are_none_outside_the_window() {
let mut fb = Fb::new();
let view = fb.windowed(&rect(2, 2, 3, 3));
assert_eq!(view.read_pixel(Point::new(3, 3)), None);
assert_eq!(view.read_pixel(Point::new(-1, 0)), None);
}
#[test]
fn windowed_clamps_to_the_parent() {
let mut fb = Fb::new();
let view = fb.windowed(&rect(6, 6, 8, 8));
assert_eq!(view.bounding_box(), rect(0, 0, 2, 2));
}
#[test]
fn windowed_read_area_straddling_the_edge_counts_only_the_window() {
let mut fb = Fb::new();
let view = fb.windowed(&rect(0, 0, 2, 2));
let mut out = [Rgb565::WHITE; 4];
let n = view.read_area(&rect(1, 1, 2, 2), &mut out);
assert_eq!(n, 1);
assert_eq!(view.parent().bulk_reads.get(), 0);
}
#[test]
fn masked_keeps_parent_coordinates() {
let mut fb = Fb::new();
Pixel(Point::new(4, 4), Rgb565::RED).draw(&mut fb).unwrap();
let view = fb.masked(&rect(2, 2, 4, 4));
assert_eq!(view.read_pixel(Point::new(4, 4)), Some(Rgb565::RED));
assert_eq!(view.bounding_box(), rect(2, 2, 4, 4));
}
#[test]
fn masked_reads_are_none_outside_the_mask() {
let mut fb = Fb::new();
let view = fb.masked(&rect(2, 2, 4, 4));
assert_eq!(view.read_pixel(Point::new(1, 1)), None);
assert_eq!(view.read_pixel(Point::new(6, 6)), None);
}
#[test]
fn masked_clamps_to_the_parent() {
let mut fb = Fb::new();
let view = fb.masked(&rect(4, 4, 100, 100));
assert_eq!(view.bounding_box(), rect(4, 4, 4, 4));
assert_eq!(view.mask_area(), rect(4, 4, 4, 4));
}
#[test]
fn masked_drops_writes_outside_the_mask() {
let mut fb = Fb::new();
let mut view = fb.masked(&rect(2, 2, 2, 2));
view.fill_solid(&rect(0, 0, 8, 8), Rgb565::RED).unwrap();
assert_eq!(fb.read_pixel(Point::new(2, 2)), Some(Rgb565::RED));
assert_eq!(fb.read_pixel(Point::new(0, 0)), Some(Rgb565::BLACK));
}
#[test]
fn masked_fill_contiguous_crops_a_straddling_run() {
let mut fb = Fb::new();
let mut view = fb.masked(&rect(0, 0, 2, 8));
view.fill_contiguous(
&rect(0, 0, 4, 1),
[Rgb565::RED, Rgb565::GREEN, Rgb565::BLUE, Rgb565::WHITE],
)
.unwrap();
assert_eq!(fb.read_pixel(Point::new(0, 0)), Some(Rgb565::RED));
assert_eq!(fb.read_pixel(Point::new(1, 0)), Some(Rgb565::GREEN));
assert_eq!(fb.read_pixel(Point::new(2, 0)), Some(Rgb565::BLACK));
assert_eq!(fb.read_pixel(Point::new(3, 0)), Some(Rgb565::BLACK));
}
#[test]
fn masked_read_area_wholly_inside_uses_the_parent_bulk_path() {
let mut fb = Fb::new();
let view = fb.masked(&rect(0, 0, 8, 8));
let mut out = [Rgb565::WHITE; 4];
assert_eq!(view.read_area(&rect(1, 1, 2, 2), &mut out), 4);
assert_eq!(view.parent().bulk_reads.get(), 1);
}
#[test]
fn adapters_chain_and_keep_readback() {
let mut fb = Fb::new();
Pixel(Point::new(2, 2), Rgb565::RED).draw(&mut fb).unwrap();
let mut layer = fb.shifted(Point::new(2, 2));
let view = layer.masked(&rect(0, 0, 3, 3));
assert_eq!(view.read_pixel(Point::zero()), Some(Rgb565::RED));
assert_eq!(view.read_pixel(Point::new(4, 4)), None);
}
#[test]
fn chained_read_area_agrees_with_read_pixel() {
let mut fb = Fb::new();
Pixel(Point::new(3, 3), Rgb565::GREEN)
.draw(&mut fb)
.unwrap();
let mut layer = fb.shifted(Point::new(2, 2));
let view = layer.windowed(&rect(0, 0, 4, 4));
let mut out = [Rgb565::WHITE; 4];
let n = view.read_area(&rect(0, 0, 2, 2), &mut out);
assert_eq!(n, 4);
let by_pixel: [Rgb565; 4] = core::array::from_fn(|i| {
view.read_pixel(Point::new(i as i32 % 2, i as i32 / 2))
.unwrap()
});
assert_eq!(out, by_pixel);
assert_eq!(out[3], Rgb565::GREEN);
}
}