Add example and 3d surface series

38 · 38 · commit 3615b280e71d · 2020-09-02T11:19:36.000-06:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -61,7 +61,7 @@ default = [
         "image",
         "deprecated_items",  "all_series", "all_elements"
 ]
-all_series = ["area_series", "line_series", "point_series"]
+all_series = ["area_series", "line_series", "point_series", "surface_series"]
 all_elements = ["errorbar", "candlestick", "boxplot", "histogram"]
 
 # Tier 1 Backends
@@ -80,6 +80,7 @@ histogram = []
 area_series = []
 line_series = []
 point_series = []
+surface_series = []
 
 # Font implemnetation
 ttf = ["font-kit", "rusttype", "lazy_static"]
diff --git a/examples/3d-plot.rs b/examples/3d-plot.rs
@@ -0,0 +1,47 @@
+use plotters::prelude::*;
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let area = SVGBackend::new("plotters-doc-data/3d-plot.svg", (600, 400)).into_drawing_area();
+    area.fill(&WHITE)?;
+    let x_axis = (-3.0..3.0).step(0.1);
+    let z_axis = (-3.0..3.0).step(0.1);
+
+    let mut chart = ChartBuilder::on(&area)
+        .caption(format!("3D Plot Test"), ("sans", 20))
+        .build_cartesian_3d(-3.0..3.0, -3.0..3.0, -3.0..3.0)?;
+
+    chart.with_projection(|mut pb| {
+        pb.yaw = 0.5;
+        pb.scale = 0.9;
+        pb.into_matrix()
+    });
+
+    chart.configure_axes().draw()?;
+
+    let surface = SurfaceSeries::<f64, f64, f64>::new(
+        x_axis.values(),
+        z_axis.values(),
+        |&x, &z| (x * x + z * z).cos(),
+        &BLUE.mix(0.2),
+    );
+
+    chart
+        .draw_series(surface)?
+        .label("Surface")
+        .legend(|(x, y)| PathElement::new(vec![(x, y), (x + 20, y)], &BLUE));
+
+    chart
+        .draw_series(LineSeries::new(
+            (-100..100)
+                .map(|y| y as f64 / 40.0)
+                .map(|y| ((y * 10.0).sin(), y, (y * 10.0).cos())),
+            &BLACK,
+        ))?
+        .label("Line")
+        .legend(|(x, y)| PathElement::new(vec![(x, y), (x + 20, y)], &BLACK));
+
+    chart
+        .configure_series_labels()
+        .border_style(&BLACK)
+        .draw()?;
+    Ok(())
+}
diff --git a/src/chart/axes3d.rs b/src/chart/axes3d.rs
@@ -46,18 +46,18 @@ where
         self.n_labels[0] = n;
         self
     }
-    
+
     pub fn y_labels(&mut self, n: usize) -> &mut Self {
         self.n_labels[1] = n;
         self
     }
-    
+
     pub fn z_labels(&mut self, n: usize) -> &mut Self {
         self.n_labels[2] = n;
         self
     }
 
-    pub fn axis_panel_style<S: Into<ShapeStyle>>(&mut self, style: S) -> &mut Self{
+    pub fn axis_panel_style<S: Into<ShapeStyle>>(&mut self, style: S) -> &mut Self {
         self.axis_panel_style = style.into();
         self
     }
@@ -66,12 +66,12 @@ where
         self.bold_line_style = style.into();
         self
     }
-    
+
     pub fn light_grid_style<S: Into<ShapeStyle>>(&mut self, style: S) -> &mut Self {
         self.light_line_style = style.into();
         self
     }
-    
+
     pub fn label_style<S: Into<TextStyle<'b>>>(&mut self, style: S) -> &mut Self {
         self.label_style = style.into();
         self
@@ -81,12 +81,12 @@ where
         self.format_x = f;
         self
     }
-    
+
     pub fn y_formatter<F: Fn(&Y::ValueType) -> String>(&mut self, f: &'b F) -> &mut Self {
         self.format_y = f;
         self
     }
-    
+
     pub fn z_formatter<F: Fn(&Z::ValueType) -> String>(&mut self, f: &'b F) -> &mut Self {
         self.format_z = f;
         self
@@ -99,7 +99,7 @@ where
         Self {
             parent_size,
             tick_size,
-             n_labels: [10, 10, 10],
+            n_labels: [10, 10, 10],
             bold_line_style: Into::<ShapeStyle>::into(&BLACK.mix(0.2)),
             light_line_style: Into::<ShapeStyle>::into(&TRANSPARENT),
             axis_panel_style: Into::<ShapeStyle>::into(&BLACK.mix(0.1)),
@@ -141,26 +141,44 @@ where
         for i in 0..3 {
             let axis = chart.draw_axis(i, &panels, self.axis_style.clone())?;
             let labels: Vec<_> = match i {
-                0 => kps_bold.x_points.iter().map(|x| {
-                    let x_text = (self.format_x)(x);
-                    let mut p = axis[0].clone();
-                    p[0] = Coord3D::X(x.clone());
-                    (p, x_text)
-                }).collect(),
-                1 => kps_bold.y_points.iter().map(|y| {
-                    let y_text = (self.format_y)(y);
-                    let mut p = axis[0].clone();
-                    p[1] = Coord3D::Y(y.clone());
-                    (p, y_text)
-                }).collect(),
-                _ => kps_bold.z_points.iter().map(|z| {
-                    let z_text = (self.format_z)(z);
-                    let mut p = axis[0].clone();
-                    p[2] = Coord3D::Z(z.clone());
-                    (p, z_text)
-                }).collect(),
+                0 => kps_bold
+                    .x_points
+                    .iter()
+                    .map(|x| {
+                        let x_text = (self.format_x)(x);
+                        let mut p = axis[0].clone();
+                        p[0] = Coord3D::X(x.clone());
+                        (p, x_text)
+                    })
+                    .collect(),
+                1 => kps_bold
+                    .y_points
+                    .iter()
+                    .map(|y| {
+                        let y_text = (self.format_y)(y);
+                        let mut p = axis[0].clone();
+                        p[1] = Coord3D::Y(y.clone());
+                        (p, y_text)
+                    })
+                    .collect(),
+                _ => kps_bold
+                    .z_points
+                    .iter()
+                    .map(|z| {
+                        let z_text = (self.format_z)(z);
+                        let mut p = axis[0].clone();
+                        p[2] = Coord3D::Z(z.clone());
+                        (p, z_text)
+                    })
+                    .collect(),
             };
-            chart.draw_axis_ticks(axis, &labels[..], self.tick_size, self.axis_style.clone(), self.label_style.clone())?;
+            chart.draw_axis_ticks(
+                axis,
+                &labels[..],
+                self.tick_size,
+                self.axis_style.clone(),
+                self.label_style.clone(),
+            )?;
         }
 
         Ok(())
diff --git a/src/chart/context.rs b/src/chart/context.rs
@@ -5,12 +5,12 @@ use super::axes3d::Axes3dStyle;
 use super::{DualCoordChartContext, MeshStyle, SeriesAnno, SeriesLabelStyle};
 
 use crate::coord::cartesian::{Cartesian2d, Cartesian3d, MeshLine};
-use crate::coord::ranged3d::{ProjectionMatrix, ProjectionMatrixBuilder};
 use crate::coord::ranged1d::{AsRangedCoord, KeyPointHint, Ranged, ValueFormatter};
+use crate::coord::ranged3d::{ProjectionMatrix, ProjectionMatrixBuilder};
 use crate::coord::{CoordTranslate, ReverseCoordTranslate, Shift};
 
 use crate::drawing::{DrawingArea, DrawingAreaErrorKind};
-use crate::element::{Drawable, PathElement, PointCollection, Polygon, Text, EmptyElement};
+use crate::element::{Drawable, EmptyElement, PathElement, PointCollection, Polygon, Text};
 use crate::style::text_anchor::{HPos, Pos, VPos};
 use crate::style::{ShapeStyle, TextStyle};
 
@@ -586,12 +586,18 @@ where
 }
 impl<'a, DB, X: Ranged, Y: Ranged, Z: Ranged> ChartContext<'a, DB, Cartesian3d<X, Y, Z>>
 where
-    DB: DrawingBackend, {
-        pub fn with_projection<P: FnOnce(ProjectionMatrixBuilder) -> ProjectionMatrix>(&mut self, pf: P) -> &mut Self {
-            let (actual_x, actual_y) = self.drawing_area.get_pixel_range();
-            self.drawing_area.as_coord_spec_mut().set_projection(actual_x, actual_y, pf);
-            self
-        }
+    DB: DrawingBackend,
+{
+    pub fn with_projection<P: FnOnce(ProjectionMatrixBuilder) -> ProjectionMatrix>(
+        &mut self,
+        pf: P,
+    ) -> &mut Self {
+        let (actual_x, actual_y) = self.drawing_area.get_pixel_range();
+        self.drawing_area
+            .as_coord_spec_mut()
+            .set_projection(actual_x, actual_y, pf);
+        self
+    }
 }
 
 impl<'a, DB, X: Ranged, Y: Ranged, Z: Ranged> ChartContext<'a, DB, Cartesian3d<X, Y, Z>>
@@ -619,15 +625,26 @@ where
     }
     pub(super) fn draw_axis_ticks(
         &mut self,
-        axis: [[Coord3D<X::ValueType, Y::ValueType, Z::ValueType>;3];2],
-        labels: &[([Coord3D<X::ValueType, Y::ValueType, Z::ValueType>; 3], String)],
+        axis: [[Coord3D<X::ValueType, Y::ValueType, Z::ValueType>; 3]; 2],
+        labels: &[(
+            [Coord3D<X::ValueType, Y::ValueType, Z::ValueType>; 3],
+            String,
+        )],
         tick_size: i32,
         style: ShapeStyle,
-        font: TextStyle
+        font: TextStyle,
     ) -> Result<(), DrawingAreaErrorKind<DB::ErrorType>> {
         let coord = self.plotting_area().as_coord_spec();
-        let begin = coord.translate(&Coord3D::build_coord([&axis[0][0], &axis[0][1], &axis[0][2]]));
-        let end = coord.translate(&Coord3D::build_coord([&axis[1][0], &axis[1][1], &axis[1][2]]));
+        let begin = coord.translate(&Coord3D::build_coord([
+            &axis[0][0],
+            &axis[0][1],
+            &axis[0][2],
+        ]));
+        let end = coord.translate(&Coord3D::build_coord([
+            &axis[1][0],
+            &axis[1][1],
+            &axis[1][2],
+        ]));
         let axis_dir = (end.0 - begin.0, end.1 - begin.1);
         let (x_range, y_range) = self.plotting_area().get_pixel_range();
         let x_mid = (x_range.start + x_range.end) / 2;
@@ -648,11 +665,7 @@ where
         let x_score = (x_dir.0 * axis_dir.0 + x_dir.1 * axis_dir.1).abs();
         let y_score = (y_dir.0 * axis_dir.0 + y_dir.1 * axis_dir.1).abs();
 
-        let dir = if x_score < y_score {
-            x_dir
-        } else {
-            y_dir
-        };
+        let dir = if x_score < y_score { x_dir } else { y_dir };
 
         for (pos, text) in labels {
             let logic_pos = Coord3D::build_coord([&pos[0], &pos[1], &pos[2]]);
@@ -668,8 +681,8 @@ where
                 font.pos = Pos::new(HPos::Center, VPos::Top);
             };
             let element = EmptyElement::at(logic_pos)
-                + PathElement::new(vec![(0,0), dir], style.clone())
-                + Text::new(text.to_string(), (dir.0 * 2 , dir.1 * 2), font.clone());
+                + PathElement::new(vec![(0, 0), dir], style.clone())
+                + Text::new(text.to_string(), (dir.0 * 2, dir.1 * 2), font.clone());
             self.plotting_area().draw(&element)?;
         }
         Ok(())
@@ -679,7 +692,10 @@ where
         idx: usize,
         panels: &[[[Coord3D<X::ValueType, Y::ValueType, Z::ValueType>; 3]; 2]; 3],
         style: ShapeStyle,
-    ) -> Result<[[Coord3D<X::ValueType, Y::ValueType, Z::ValueType>;3];2], DrawingAreaErrorKind<DB::ErrorType>> {
+    ) -> Result<
+        [[Coord3D<X::ValueType, Y::ValueType, Z::ValueType>; 3]; 2],
+        DrawingAreaErrorKind<DB::ErrorType>,
+    > {
         let coord = self.plotting_area().as_coord_spec();
         let x_range = coord.logic_x.range();
         let y_range = coord.logic_y.range();
@@ -808,20 +824,21 @@ where
             n[(idx + 2) % 3] = b[(idx + 2) % 3];
 
             (
-                    vec![
-                        Coord3D::build_coord(a),
-                        Coord3D::build_coord(m),
-                        Coord3D::build_coord(b),
-                        Coord3D::build_coord(n),
-                    ],
+                vec![
+                    Coord3D::build_coord(a),
+                    Coord3D::build_coord(m),
+                    Coord3D::build_coord(b),
+                    Coord3D::build_coord(n),
+                ],
                 a,
                 b,
             )
         };
-        self.plotting_area().draw(&Polygon::new(panel.clone(), panel_style.clone()))?;
+        self.plotting_area()
+            .draw(&Polygon::new(panel.clone(), panel_style.clone()))?;
         panel.push(panel[0].clone());
-        self.plotting_area().draw(&PathElement::new(panel, bold_grid_style.clone()))?;
-
+        self.plotting_area()
+            .draw(&PathElement::new(panel, bold_grid_style.clone()))?;
 
         for (kps, style) in vec![
             (light_points, light_grid_style),
diff --git a/src/coord/ranged3d/cartesian3d.rs b/src/coord/ranged3d/cartesian3d.rs
@@ -17,7 +17,11 @@ impl<X: Ranged, Y: Ranged, Z: Ranged> Cartesian3d<X, Y, Z> {
     fn compute_default_size(actual_x: Range<i32>, actual_y: Range<i32>) -> i32 {
         (actual_x.end - actual_x.start).min(actual_y.end - actual_y.start) * 4 / 5
     }
-    fn create_projection<F: FnOnce(ProjectionMatrixBuilder) -> ProjectionMatrix>(actual_x: Range<i32>, actual_y: Range<i32>, f: F) -> ProjectionMatrix {
+    fn create_projection<F: FnOnce(ProjectionMatrixBuilder) -> ProjectionMatrix>(
+        actual_x: Range<i32>,
+        actual_y: Range<i32>,
+        f: F,
+    ) -> ProjectionMatrix {
         let default_size = Self::compute_default_size(actual_x.clone(), actual_y.clone());
         let center_3d = (default_size / 2, default_size / 2, default_size / 2);
         let center_2d = (
@@ -28,7 +32,12 @@ impl<X: Ranged, Y: Ranged, Z: Ranged> Cartesian3d<X, Y, Z> {
         pb.set_pivot(center_3d, center_2d);
         f(pb)
     }
-    pub fn with_projection<SX: Into<X>, SY: Into<Y>, SZ: Into<Z>, F: FnOnce(ProjectionMatrixBuilder)-> ProjectionMatrix>(
+    pub fn with_projection<
+        SX: Into<X>,
+        SY: Into<Y>,
+        SZ: Into<Z>,
+        F: FnOnce(ProjectionMatrixBuilder) -> ProjectionMatrix,
+    >(
         logic_x: SX,
         logic_y: SY,
         logic_z: SZ,
@@ -44,7 +53,12 @@ impl<X: Ranged, Y: Ranged, Z: Ranged> Cartesian3d<X, Y, Z> {
             projection: Self::create_projection(actual_x, actual_y, build_projection_matrix),
         }
     }
-    pub fn set_projection<F:FnOnce(ProjectionMatrixBuilder) -> ProjectionMatrix>(&mut self, actual_x: Range<i32>, actual_y: Range<i32>, f: F) -> &mut Self {
+    pub fn set_projection<F: FnOnce(ProjectionMatrixBuilder) -> ProjectionMatrix>(
+        &mut self,
+        actual_x: Range<i32>,
+        actual_y: Range<i32>,
+        f: F,
+    ) -> &mut Self {
         self.projection = Self::create_projection(actual_x, actual_y, f);
         self
     }
@@ -55,7 +69,9 @@ impl<X: Ranged, Y: Ranged, Z: Ranged> Cartesian3d<X, Y, Z> {
         logic_z: SZ,
         (actual_x, actual_y): (Range<i32>, Range<i32>),
     ) -> Self {
-        Self::with_projection(logic_x, logic_y, logic_z, (actual_x, actual_y), |pb| pb.into_matrix())
+        Self::with_projection(logic_x, logic_y, logic_z, (actual_x, actual_y), |pb| {
+            pb.into_matrix()
+        })
     }
     pub fn projection(&self) -> &ProjectionMatrix {
         &self.projection
diff --git a/src/lib.rs b/src/lib.rs
@@ -738,6 +738,8 @@ pub mod prelude {
     pub use crate::series::LineSeries;
     #[cfg(feature = "point_series")]
     pub use crate::series::PointSeries;
+    #[cfg(feature = "surface_series")]
+    pub use crate::series::SurfaceSeries;
 
     // Styles
     pub use crate::style::{
diff --git a/src/series/mod.rs b/src/series/mod.rs
diff --git a/src/series/surface.rs b/src/series/surface.rs
