WIP: Plot

examples/basic-plot/main.rs

@@ -9,7 +9,7 @@ use embedded_graphics_simulator::{
     OutputSettingsBuilder
 };
 
-use embedded_plots::curve::{PlotPoint, CurvePoints};
+use embedded_plots::curve::{PlotPoint, Curve};
 
 fn main() -> Result<(), core::convert::Infallible> {
     let mut display: SimulatorDisplay<Rgb565> = SimulatorDisplay::new(Size::new(480, 272));
@@ -20,7 +20,7 @@ fn main() -> Result<(), core::convert::Infallible> {
         PlotPoint{x: 2,y: 1},
         PlotPoint{x: 3,y: 0},
     ];
-    CurvePoints::new(data.as_slice())
+    Curve::new(data.as_slice())
         .into_drawable_curve(&(0..3),&(0..1),&Point{x: 20, y: 20}, &Point{x:450,y:250},RgbColor::WHITE)
         .draw(&mut display)?;
 

src/curve.rs

@@ -9,16 +9,22 @@ pub struct PlotPoint {
     pub y: i32,
 }
 
-pub struct CurvePoints<'a>{
+pub struct Curve<'a>{
     points: &'a [PlotPoint],
 }
 
-impl<'a> CurvePoints<'a> {
+impl<'a> Curve<'a> {
-    pub fn new(points: &'a [PlotPoint]) -> CurvePoints {
+    pub fn new(points: &'a [PlotPoint]) -> Curve {
-        CurvePoints{points}
+        Curve {points}
     }
 
-    pub fn into_drawable_curve<C>(self, x_range: &'a Range<i32>, y_range: &'a Range<i32>, top_left : &'a Point, bottom_right: &'a Point, color: C) -> DrawableCurve<C,impl Iterator<Item=Point> + 'a>
+    pub fn into_drawable_curve<C>(self,
+                                  x_range: &'a Range<i32>,
+                                  y_range: &'a Range<i32>,
+                                  top_left : &'a Point,
+                                  bottom_right: &'a Point,
+                                  color: C
+    ) -> DrawableCurve<C,impl Iterator<Item=Point> + 'a>
         where C: PixelColor
     {
         assert!(top_left.x < bottom_right.x);
@@ -28,8 +34,14 @@ impl<'a> CurvePoints<'a> {
 
         let it = self.points.iter()
             .map(move |p| Point{
-                x: p.x.scale_between_ranges(x_range,&Range{start: top_left.x, end: bottom_right.x}),
+                x: p.x.scale_between_ranges(
-                y: p.y.scale_between_ranges(y_range,&Range{start: bottom_right.y, end: top_left.y}),
+                    x_range,
+                    &Range{start: top_left.x, end: bottom_right.x}
+                ),
+                y: p.y.scale_between_ranges(
+                    y_range,
+                    &Range{start: bottom_right.y, end: top_left.y}
+                ),
             });
         DrawableCurve::new(it,color)
     }

src/drawable_curve.rs

@@ -1,4 +1,4 @@
-use embedded_graphics::drawable::{Drawable, Pixel};
+use embedded_graphics::drawable::{Drawable};
 use embedded_graphics::DrawTarget;
 use embedded_graphics::geometry::Point;
 use embedded_graphics::pixelcolor::{PixelColor};
@@ -13,7 +13,7 @@ pub struct DrawableCurve<C, I>
     color: C,
 }
 
-impl<'a, C,I> DrawableCurve<C,I>
+impl<C,I> DrawableCurve<C,I>
     where
         C: PixelColor,
         I: Iterator<Item=Point>,
@@ -25,7 +25,7 @@ impl<'a, C,I> DrawableCurve<C,I>
         }
     }
 }
-impl<'a, C,I> Drawable<C> for DrawableCurve<C,I>
+impl<C,I> Drawable<C> for DrawableCurve<C,I>
     where C: PixelColor,
           I: Iterator<Item=Point>,
 {
@@ -34,7 +34,9 @@ impl<'a, C,I> Drawable<C> for DrawableCurve<C,I>
         let mut iter = self.scaled_data.into_iter();
         let mut prev = iter.next().unwrap();
         for point in iter {
-            Line::new(prev,point).into_styled(style).draw(display)?;
+            Line::new(prev,point)
+                .into_styled(style)
+                .draw(display)?;
             prev = point;
         }
         Ok(())

src/lib.rs

@@ -1,5 +1,6 @@
 #![no_std]
 pub mod curve;
-pub mod drawable_curve;
+pub mod plot;
 
+mod drawable_curve;
 mod range_conv;

src/plot.rs

@@ -0,0 +1,37 @@
+use crate::curve::Curve;
+use embedded_graphics::drawable::Drawable;
+use embedded_graphics::DrawTarget;
+use embedded_graphics::prelude::Point;
+use embedded_graphics::pixelcolor::PixelColor;
+
+struct Plot<'a, C>
+    where
+        C: PixelColor
+{
+    curves: &'a [Curve<'a>],
+    color: C,
+}
+
+impl<'a, C> Plot<'a, C> {
+    fn new(curves: &'a [Curve<'a>], color : C) -> Plot<C> {
+        Plot{curves, color}
+    }
+}
+
+impl<C> Drawable<C> for Plot<'_, C>
+    where
+        C: PixelColor
+{
+    fn draw<D: DrawTarget<C>>(self, display: &mut D) -> Result<(), <D as DrawTarget<_>>::Error> {
+        for curve in self.curves {
+            curve.into_drawable_curve(
+                &(0..50),
+                &(-10..10),
+                &Point{x: 10,y: 10},
+                &Point{x: 470, y: 270},
+                self.color
+            ).draw(display)?;
+        }
+        Ok(())
+    }
+}