How to change color?

[karimpanacci]

It seems that tinybmp automatically decides the color of the image, how do I change it?
I'm using BinaryColor and I'd like to reverse the colors

[rfuest]

I don't know what you mean by "automatically decides",tinybmp should display the image like it is stored inside the BMP file. Do you experience a random selection of colors (like some images are inverted and some are not)? There have been some bugs related to this in the past, but I think they should be fixed in current releases.

BinaryColor is a bit of a special case, because BinaryColor::On can be a light pixel (e.g. on an OLED) or a dark pixel (on a LCD). tinybmp maps white pixels to BinaryColor::On and black pixels to BinaryColor::Off.

If you can give me a few more details about your application, like the type of display you are using, and an example BMP file, that isn't drawn like you expect, I will be able to give you a better answer.

[karimpanacci]

@rfuest Yes I was referring only to BinaryColor. I’m using an e-paper display and have set the “On” color to black.

So when I view images with tinybmp, the colors appear reversed.

It would be convenient to be able to choose this behavior.

[rfuest]

I see what you mean and I agree that being able to invert the image for LCDs and EPDs is a useful feature. But I need to think about if I want to include this feature in tinybmp itself.

In the meantime you can use an embedded-graphics DrawTarget adapter to invert all embedded-graphics operations:

pub struct InvertedDrawTarget<'a, T: DrawTarget<Color = BinaryColor>> {
    target: &'a mut T,
}

impl<'a, T: DrawTarget<Color = BinaryColor>> InvertedDrawTarget<'a, T> {
    pub fn new(target: &'a mut T) -> Self {
        Self { target }
    }
}

impl<T: DrawTarget<Color = BinaryColor> + OriginDimensions> DrawTarget
    for InvertedDrawTarget<'_, T>
{
    type Color = BinaryColor;
    type Error = T::Error;

    fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
    where
        I: IntoIterator<Item = Pixel<Self::Color>>,
    {
        self.target
            .draw_iter(pixels.into_iter().map(|Pixel(p, c)| Pixel(p, c.invert())))
    }

    fn fill_contiguous<I>(
        &mut self,
        area: &embedded_graphics::primitives::Rectangle,
        colors: I,
    ) -> Result<(), Self::Error>
    where
        I: IntoIterator<Item = Self::Color>,
    {
        self.target
            .fill_contiguous(area, colors.into_iter().map(|c| c.invert()))
    }

    fn fill_solid(
        &mut self,
        area: &embedded_graphics::primitives::Rectangle,
        color: Self::Color,
    ) -> Result<(), Self::Error> {
        self.target.fill_solid(area, color.invert())
    }

    fn clear(&mut self, color: Self::Color) -> Result<(), Self::Error> {
        self.target.clear(color.invert())
    }
}

impl<T: DrawTarget<Color = BinaryColor> + OriginDimensions> OriginDimensions
    for InvertedDrawTarget<'_, T>
{
    fn size(&self) -> Size {
        self.target.size()
    }
}

It can be used like this:

let mut display = SomeDisplay::new(...);

let bmp = Bmp::from_slice(&BMP_DATA).unwrap();
Image::new(&bmp, Point::zero()).draw(&mut InvertedDrawTarget::new(&mut display)).unwrap();