Update the bitmap backend not to relies on image, only the image encoding part relies on it

38 · 38 · commit 603b7f441f90 · 2019-10-28T17:39:41.000-06:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -10,6 +10,7 @@
 
 - Font description is greatly improved, general font family is supported: `serif`, `serif-sans`, `monospace` (Thanks to @Tatrix)
 - Tested the font loading on Linux, OSX and Windowns. Make font loading more reliable.
+- `BitMapBackend` isn't depdends on `image` crate now. Only the image encoding part relies on the `image` crate
 
 ## Plotters 0.2.10 (2019-10-23)
 
diff --git a/Cargo.toml b/Cargo.toml
@@ -40,10 +40,10 @@ version = "0.3.29"
 features = ['Document', 'Element', 'HtmlElement', 'Node', 'Window', 'HtmlCanvasElement', 'CanvasRenderingContext2d']
 
 [features]
-default = ["bitmap", "svg", "chrono", "palette_ext", "make_partial_axis", "gif_backend"]
+default = ["image_encoder", "svg", "chrono", "palette_ext", "make_partial_axis", "gif_backend"]
+image_encoder = ["image"]
 palette_ext = ["palette", "num-traits"]
-bitmap = ["image"]
-gif_backend = ["bitmap", "gif"]
+gif_backend = ["gif"]
 datetime = ["chrono"]
 evcxr = ["svg"]
 piston = ["piston_window"]
diff --git a/README.md b/README.md
@@ -1,4 +1,4 @@
-# Plotters - A Rust drawing library focus on data plotting for both WASM and native applications  🦀📈🚀 
+# Plotters - A Rust drawing library focus on data plotting for both WASM and native applications  🦀📈🚀
 
 <a href="https://crates.io/crates/plotters">
     <img style="display: inline!important" src="https://img.shields.io/crates/v/plotters.svg"></img>
@@ -479,11 +479,12 @@ This is the full list of features that is defined by `Plotters` crate. Use `defa
 
 | Name    |  Description | Additional Dependency |Default?|
 |---------|--------------|--------|------------|
-| bitmap  | Enable `BitMapBackend` Support| image | Yes |
+| image\_encoder  | Allow `BitMapBackend` save the result to bitmap files | image | Yes |
 | svg     | Enable `SVGBackend` Support | svg | Yes |
 | datetime| Enable Date and Time Coordinate Support| chrono | Yes |
 | gif\_backend| Opt-in GIF animation Rendering support for `BitMapBackend`, implies `bitmap` enabled | gif | Yes |
 | piston | Enable `PistonWindowBackend` | piston\_window | No |
+| cairo | Enable `CairoBackend` | cairo-rs | No |
 | palette\_ext | Use crate `palette` for color expression| palette | Yes |
 | evcxr | Enable Evcxr support, which allows use `Plotters` in Jupyter Note Book | None | No |
 | make\_partial\_axis | Support for API `make_partial_axis`, which allows configuring partial axis from visible portion. | num-trait| Yes |
diff --git a/doc-template/readme.template.md b/doc-template/readme.template.md
@@ -249,11 +249,12 @@ This is the full list of features that is defined by `Plotters` crate. Use `defa
 
 | Name    |  Description | Additional Dependency |Default?|
 |---------|--------------|--------|------------|
-| bitmap  | Enable `BitMapBackend` Support| image | Yes |
+| image\_encoder  | Allow `BitMapBackend` save the result to bitmap files | image | Yes |
 | svg     | Enable `SVGBackend` Support | svg | Yes |
 | datetime| Enable Date and Time Coordinate Support| chrono | Yes |
 | gif\_backend| Opt-in GIF animation Rendering support for `BitMapBackend`, implies `bitmap` enabled | gif | Yes |
 | piston | Enable `PistonWindowBackend` | piston\_window | No |
+| cairo | Enable `CairoBackend` | cairo-rs | No |
 | palette\_ext | Use crate `palette` for color expression| palette | Yes |
 | evcxr | Enable Evcxr support, which allows use `Plotters` in Jupyter Note Book | None | No |
 | make\_partial\_axis | Support for API `make_partial_axis`, which allows configuring partial axis from visible portion. | num-trait| Yes |
diff --git a/doc-template/update_readme.sh b/doc-template/update_readme.sh
@@ -22,4 +22,4 @@ NR != FNR{
 }' <(${REPO_BASE}/doc-template/render_readme.sh ${REPO_BASE}/doc-template/readme.template.md ${REPO_BASE}/doc-template/rustdoc) ${REPO_BASE}/src/lib.rs > ${REPO_BASE}/src/lib.rs.tmp
 
 mv ${REPO_BASE}/src/lib.rs.tmp ${REPO_BASE}/src/lib.rs
-rustfmt ${REPO_BASE}/src/lib.rs
+cargo fmt
diff --git a/src/drawing/backend.rs b/src/drawing/backend.rs
@@ -219,15 +219,14 @@ pub trait DrawingBackend: Sized {
     ///
     /// - `text`: pos the left upper conner of the bitmap to blit
     /// - `src`: The source of the image
-    #[cfg(all(not(target_arch = "wasm32"), feature = "image"))]
     fn blit_bitmap<'a>(
         &mut self,
         pos: BackendCoord,
-        src: &'a image::ImageBuffer<image::Rgb<u8>, &'a [u8]>,
+        (iw, ih): (u32, u32),
+        src: &'a [u8],
     ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
         let (w, h) = self.get_size();
 
-        let (iw, ih) = src.dimensions();
         for dx in 0..iw {
             if pos.0 + dx as i32 >= w as i32 {
                 break;
@@ -236,8 +235,10 @@ pub trait DrawingBackend: Sized {
                 if pos.1 + dy as i32 >= h as i32 {
                     break;
                 }
-                let pixel = src.get_pixel(dx, dy);
-                let color = crate::style::RGBColor(pixel.0[0], pixel.0[1], pixel.0[2]);
+                let r = src[(dx + dy * w) as usize * 3 + 0];
+                let g = src[(dx + dy * w) as usize * 3 + 1];
+                let b = src[(dx + dy * w) as usize * 3 + 2];
+                let color = crate::style::RGBColor(r, g, b);
                 let result =
                     self.draw_pixel((pos.0 + dx as i32, pos.1 + dy as i32), &color.to_rgba());
                 if result.is_err() {
diff --git a/src/drawing/backend_impl/bitmap.rs b/src/drawing/backend_impl/bitmap.rs
@@ -1,17 +1,38 @@
 use crate::drawing::backend::{BackendCoord, BackendStyle, DrawingBackend, DrawingErrorKind};
 use crate::style::{Color, RGBAColor};
+use std::marker::PhantomData;
 
-use image::{ImageBuffer, ImageError, Rgb};
+#[cfg(all(not(target_arch = "wasm32"), feature = "image"))]
+mod image_encoding_support {
+    pub(super) use image::{ImageBuffer, ImageError, Rgb};
+    pub(super) use std::path::Path;
+    pub(super) type BorrowedImage<'a> = ImageBuffer<Rgb<u8>, &'a mut [u8]>;
+}
+
+#[cfg(all(not(target_arch = "wasm32"), feature = "image"))]
+use image_encoding_support::*;
+
+#[derive(Debug)]
+pub enum BitMapBackendError {
+    InvalidBuffer,
+    IOError(std::io::Error),
+    #[cfg(all(not(target_arch = "wasm32"), feature = "image"))]
+    ImageError(ImageError),
+}
 
-use std::path::Path;
+impl std::fmt::Display for BitMapBackendError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
 
-pub type BorrowedImage<'a> = ImageBuffer<Rgb<u8>, &'a mut [u8]>;
+impl std::error::Error for BitMapBackendError {}
 
 fn blend(prev: &mut u8, new: u8, a: f64) {
     *prev = ((f64::from(*prev)) * (1.0 - a) + a * f64::from(new)).min(255.0) as u8;
 }
 
-#[cfg(feature = "gif")]
+#[cfg(all(feature = "gif", not(target_arch = "wasm32"), feature = "image"))]
 mod gif_support {
     use super::*;
     use gif::{Encoder as GifEncoder, Frame as GifFrame, Repeat, SetParameter};
@@ -29,15 +50,18 @@ mod gif_support {
             path: T,
             dim: (u32, u32),
             delay: u32,
-        ) -> Result<Self, ImageError> {
+        ) -> Result<Self, BitMapBackendError> {
             let mut encoder = GifEncoder::new(
-                File::create(path.as_ref()).map_err(ImageError::IoError)?,
+                File::create(path.as_ref()).map_err(BitMapBackendError::IOError)?,
                 dim.0 as u16,
                 dim.1 as u16,
                 &[],
-            )?;
+            )
+            .map_err(BitMapBackendError::IOError)?;
 
-            encoder.set(Repeat::Infinite)?;
+            encoder
+                .set(Repeat::Infinite)
+                .map_err(BitMapBackendError::IOError)?;
 
             Ok(Self {
                 encoder,
@@ -47,34 +71,39 @@ mod gif_support {
             })
         }
 
-        pub(super) fn flush_frame(&mut self, buffer: &[u8]) -> Result<(), ImageError> {
+        pub(super) fn flush_frame(&mut self, buffer: &[u8]) -> Result<(), BitMapBackendError> {
             let mut frame =
                 GifFrame::from_rgb_speed(self.width as u16, self.height as u16, buffer, 10);
 
             frame.delay = self.delay as u16;
 
-            self.encoder.write_frame(&frame)?;
+            self.encoder
+                .write_frame(&frame)
+                .map_err(BitMapBackendError::IOError)?;
 
             Ok(())
         }
     }
 }
 
 enum Target<'a> {
+    #[cfg(all(not(target_arch = "wasm32"), feature = "image"))]
     File(&'a Path),
-    Buffer,
-    #[cfg(feature = "gif")]
+    Buffer(PhantomData<&'a u32>),
+    #[cfg(all(feature = "gif", not(target_arch = "wasm32"), feature = "image"))]
     Gif(Box<gif_support::GifFile>),
 }
 
 enum Buffer<'a> {
+    #[cfg(all(not(target_arch = "wasm32"), feature = "image"))]
     Owned(Vec<u8>),
     Borrowed(&'a mut [u8]),
 }
 
 impl<'a> Buffer<'a> {
     fn borrow_buffer(&mut self) -> &mut [u8] {
         match self {
+            #[cfg(all(not(target_arch = "wasm32"), feature = "image"))]
             Buffer::Owned(buf) => &mut buf[..],
             Buffer::Borrowed(buf) => *buf,
         }
@@ -84,20 +113,19 @@ impl<'a> Buffer<'a> {
 /// The backend that drawing a bitmap
 pub struct BitMapBackend<'a> {
     /// The path to the image
+    #[allow(dead_code)]
     target: Target<'a>,
-
     /// The size of the image
     size: (u32, u32),
-
     /// The data buffer of the image
     buffer: Buffer<'a>,
-
     /// Flag indicates if the bitmap has been saved
     saved: bool,
 }
 
 impl<'a> BitMapBackend<'a> {
     /// Create a new bitmap backend
+    #[cfg(all(not(target_arch = "wasm32"), feature = "image"))]
     pub fn new<T: AsRef<Path> + ?Sized>(path: &'a T, (w, h): (u32, u32)) -> Self {
         Self {
             target: Target::File(path.as_ref()),
@@ -116,12 +144,12 @@ impl<'a> BitMapBackend<'a> {
     /// - `path`: The path to the GIF file to create
     /// - `dimension`: The size of the GIF image
     /// - `speed`: The amount of time for each frame to display
-    #[cfg(feature = "gif")]
+    #[cfg(all(feature = "gif", not(target_arch = "wasm32"), feature = "image"))]
     pub fn gif<T: AsRef<Path>>(
         path: T,
         (w, h): (u32, u32),
         frame_delay: u32,
-    ) -> Result<Self, ImageError> {
+    ) -> Result<Self, BitMapBackendError> {
         Ok(Self {
             target: Target::Gif(Box::new(gif_support::GifFile::new(
                 path,
@@ -153,7 +181,7 @@ impl<'a> BitMapBackend<'a> {
         }
 
         Self {
-            target: Target::Buffer,
+            target: Target::Buffer(PhantomData),
             size: (w, h),
             buffer: Buffer::Borrowed(buf),
             saved: false,
@@ -331,33 +359,41 @@ impl<'a> BitMapBackend<'a> {
 }
 
 impl<'a> DrawingBackend for BitMapBackend<'a> {
-    type ErrorType = ImageError;
+    type ErrorType = BitMapBackendError;
 
     fn get_size(&self) -> (u32, u32) {
         self.size
     }
 
-    fn ensure_prepared(&mut self) -> Result<(), DrawingErrorKind<ImageError>> {
+    fn ensure_prepared(&mut self) -> Result<(), DrawingErrorKind<BitMapBackendError>> {
         self.saved = false;
         Ok(())
     }
 
-    fn present(&mut self) -> Result<(), DrawingErrorKind<ImageError>> {
+    #[cfg(any(target_arch = "wasm32", not(feature = "image")))]
+    fn present(&mut self) -> Result<(), DrawingErrorKind<BitMapBackendError>> {
+        Ok(())
+    }
+
+    #[cfg(all(not(target_arch = "wasm32"), feature = "image"))]
+    fn present(&mut self) -> Result<(), DrawingErrorKind<BitMapBackendError>> {
         let (w, h) = self.get_size();
         match &mut self.target {
             Target::File(path) => {
                 if let Some(img) = BorrowedImage::from_raw(w, h, self.buffer.borrow_buffer()) {
-                    img.save(&path)
-                        .map_err(|x| DrawingErrorKind::DrawingError(ImageError::IoError(x)))?;
+                    img.save(&path).map_err(|x| {
+                        DrawingErrorKind::DrawingError(BitMapBackendError::IOError(x))
+                    })?;
                     self.saved = true;
                     Ok(())
                 } else {
-                    Err(DrawingErrorKind::DrawingError(ImageError::DimensionError))
+                    Err(DrawingErrorKind::DrawingError(
+                        BitMapBackendError::InvalidBuffer,
+                    ))
                 }
             }
-            Target::Buffer => Ok(()),
+            Target::Buffer(_) => Ok(()),
 
-            #[cfg(feature = "gif")]
             Target::Gif(target) => {
                 target
                     .flush_frame(self.buffer.borrow_buffer())
@@ -372,7 +408,7 @@ impl<'a> DrawingBackend for BitMapBackend<'a> {
         &mut self,
         point: BackendCoord,
         color: &RGBAColor,
-    ) -> Result<(), DrawingErrorKind<ImageError>> {
+    ) -> Result<(), DrawingErrorKind<BitMapBackendError>> {
         if point.0 < 0 || point.1 < 0 {
             return Ok(());
         }
@@ -474,10 +510,10 @@ impl<'a> DrawingBackend for BitMapBackend<'a> {
     fn blit_bitmap<'b>(
         &mut self,
         pos: BackendCoord,
-        src: &'b image::ImageBuffer<image::Rgb<u8>, &'b [u8]>,
+        (sw, sh): (u32, u32),
+        src: &'b [u8],
     ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
         let (dw, dh) = self.get_size();
-        let (sw, sh) = src.dimensions();
 
         let (x0, y0) = pos;
         let (x1, y1) = (x0 + sw as i32, y0 + sh as i32);
@@ -498,7 +534,7 @@ impl<'a> DrawingBackend for BitMapBackend<'a> {
         let mut dst = &mut self.get_raw_pixel_buffer()[dst_start..];
 
         let src_start = 3 * ((sh as i32 + y0 - y1) * sw as i32 + (sw as i32 + x0 - x1)) as usize;
-        let mut src = &(**src)[src_start..];
+        let mut src = &src[src_start..];
 
         if src_gap == 0 && dst_gap == 0 {
             chunk_size *= num_chunks;
diff --git a/src/drawing/backend_impl/mod.rs b/src/drawing/backend_impl/mod.rs
@@ -3,9 +3,7 @@ mod svg;
 #[cfg(feature = "svg")]
 pub use self::svg::{svg_types, SVGBackend};
 
-#[cfg(all(not(target_arch = "wasm32"), feature = "image"))]
 mod bitmap;
-#[cfg(all(not(target_arch = "wasm32"), feature = "image"))]
 pub use bitmap::BitMapBackend;
 
 #[cfg(target_arch = "wasm32")]
diff --git a/src/drawing/backend_impl/svg.rs b/src/drawing/backend_impl/svg.rs
@@ -288,13 +288,13 @@ impl<'a> DrawingBackend for SVGBackend<'a> {
     fn blit_bitmap<'b>(
         &mut self,
         pos: BackendCoord,
-        src: &'b image::ImageBuffer<image::Rgb<u8>, &'b [u8]>,
+        (w, h): (u32, u32),
+        src: &'b [u8],
     ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
         use image::png::PNGEncoder;
         use svg::node::element::Image;
 
         let mut data = vec![0; 0];
-        let (w, h) = src.dimensions();
 
         {
             let cursor = Cursor::new(&mut data);
@@ -303,7 +303,7 @@ impl<'a> DrawingBackend for SVGBackend<'a> {
 
             let color = image::ColorType::RGB(8);
 
-            encoder.encode(&(**src)[..], w, h, color).map_err(|e| {
+            encoder.encode(src, w, h, color).map_err(|e| {
                 DrawingErrorKind::DrawingError(Error::new(
                     std::io::ErrorKind::Other,
                     format!("Image error: {}", e),
diff --git a/src/element/image.rs b/src/element/image.rs
diff --git a/src/element/mod.rs b/src/element/mod.rs
diff --git a/src/lib.rs b/src/lib.rs
