Inturodce the keypoint hint

38 · 38 · commit 0b6310a1d7ce · 2020-05-28T15:40:11.000-06:00
diff --git a/src/chart/context.rs b/src/chart/context.rs
@@ -8,8 +8,8 @@ use super::mesh::MeshStyle;
 use super::series::SeriesLabelStyle;
 
 use crate::coord::{
-    AsRangedCoord, CoordTranslate, MeshLine, Ranged, RangedCoord, ReverseCoordTranslate, Shift,
-    ValueFormatter,
+    AsRangedCoord, CoordTranslate, KeyPointHint, MeshLine, Ranged, RangedCoord,
+    ReverseCoordTranslate, Shift, ValueFormatter,
 };
 use crate::drawing::{DrawingArea, DrawingAreaErrorKind};
 use crate::element::{Drawable, DynElement, IntoDynElement, PathElement, PointCollection};
@@ -394,9 +394,9 @@ impl<'a, DB: DrawingBackend, X: Ranged, Y: Ranged> ChartContext<'a, DB, RangedCo
     /// The actual function that draws the mesh lines.
     /// It also returns the label that suppose to be there.
     #[allow(clippy::type_complexity)]
-    fn draw_mesh_lines<FmtLabel>(
+    fn draw_mesh_lines<FmtLabel, YH: KeyPointHint, XH: KeyPointHint>(
         &mut self,
-        (r, c): (usize, usize),
+        (r, c): (YH, XH),
         (x_mesh, y_mesh): (bool, bool),
         mesh_line_style: &ShapeStyle,
         mut fmt_label: FmtLabel,
@@ -693,9 +693,9 @@ impl<'a, DB: DrawingBackend, X: Ranged, Y: Ranged> ChartContext<'a, DB, RangedCo
     }
 
     #[allow(clippy::too_many_arguments)]
-    pub(super) fn draw_mesh<FmtLabel>(
+    pub(super) fn draw_mesh<FmtLabel, YH: KeyPointHint, XH: KeyPointHint>(
         &mut self,
-        (r, c): (usize, usize),
+        (r, c): (YH, XH),
         mesh_line_style: &ShapeStyle,
         x_label_style: &TextStyle,
         y_label_style: &TextStyle,
diff --git a/src/chart/mesh.rs b/src/chart/mesh.rs
@@ -2,7 +2,7 @@ use std::marker::PhantomData;
 
 use super::builder::LabelAreaPosition;
 use super::context::ChartContext;
-use crate::coord::{MeshLine, Ranged, RangedCoord, ValueFormatter};
+use crate::coord::{BoldPoints, MeshLine, Ranged, RangedCoord, ValueFormatter};
 use crate::drawing::DrawingAreaErrorKind;
 use crate::style::{
     AsRelative, Color, FontDesc, FontFamily, FontStyle, IntoTextStyle, RGBColor, ShapeStyle,
@@ -411,7 +411,7 @@ where
         )?;
 
         target.draw_mesh(
-            (self.n_y_labels, self.n_x_labels),
+            (BoldPoints(self.n_y_labels), BoldPoints(self.n_x_labels)),
             &mesh_style_1,
             &x_label_style,
             &y_label_style,
diff --git a/src/coord/datetime.rs b/src/coord/datetime.rs
@@ -2,7 +2,7 @@
 use chrono::{Date, DateTime, Datelike, Duration, NaiveDate, NaiveDateTime, TimeZone, Timelike};
 use std::ops::{Add, Range, Sub};
 
-use super::{AsRangedCoord, DiscreteRanged, Ranged, ValueFormatter};
+use super::{AsRangedCoord, DiscreteRanged, KeyPointHint, Ranged, ValueFormatter};
 
 /// The trait that describe some time value. This is the uniformed abstraction that works
 /// for both Date, DateTime and Duration, etc.
@@ -176,7 +176,8 @@ where
         TimeValue::map_coord(value, &self.0, &self.1, limit)
     }
 
-    fn key_points(&self, max_points: usize) -> Vec<Self::ValueType> {
+    fn key_points<HintType: KeyPointHint>(&self, hint: HintType) -> Vec<Self::ValueType> {
+        let max_points = hint.max_num_points();
         let mut ret = vec![];
 
         let total_days = (self.1.clone() - self.0.clone()).num_days();
@@ -263,7 +264,8 @@ impl<T: TimeValue + Clone> Ranged for Monthly<T> {
         T::map_coord(value, &self.0.start, &self.0.end, limit)
     }
 
-    fn key_points(&self, max_points: usize) -> Vec<Self::ValueType> {
+    fn key_points<HintType: KeyPointHint>(&self, hint: HintType) -> Vec<Self::ValueType> {
+        let max_points = hint.max_num_points();
         let start_date = self.0.start.date_ceil();
         let end_date = self.0.end.date_floor();
 
@@ -465,7 +467,8 @@ impl<T: TimeValue + Clone> Ranged for Yearly<T> {
         T::map_coord(value, &self.0.start, &self.0.end, limit)
     }
 
-    fn key_points(&self, max_points: usize) -> Vec<Self::ValueType> {
+    fn key_points<HintType: KeyPointHint>(&self, hint: HintType) -> Vec<Self::ValueType> {
+        let max_points = hint.max_num_points();
         let start_date = self.0.start.date_ceil();
         let end_date = self.0.end.date_floor();
 
@@ -583,7 +586,8 @@ where
         TimeValue::map_coord(value, &self.0, &self.1, limit)
     }
 
-    fn key_points(&self, max_points: usize) -> Vec<Self::ValueType> {
+    fn key_points<HintType: KeyPointHint>(&self, hint: HintType) -> Vec<Self::ValueType> {
+        let max_points = hint.max_num_points();
         let total_span = self.1.clone() - self.0.clone();
 
         if let Some(total_ns) = total_span.num_nanoseconds() {
@@ -665,7 +669,8 @@ impl Ranged for RangedDuration {
             + (f64::from(limit.1 - limit.0) * value_days as f64 / total_days as f64 + 1e-10) as i32
     }
 
-    fn key_points(&self, max_points: usize) -> Vec<Self::ValueType> {
+    fn key_points<HintType: KeyPointHint>(&self, hint: HintType) -> Vec<Self::ValueType> {
+        let max_points = hint.max_num_points();
         let total_span = self.1 - self.0;
 
         if let Some(total_ns) = total_span.num_nanoseconds() {
diff --git a/src/coord/discrete.rs b/src/coord/discrete.rs
@@ -1,4 +1,4 @@
-use super::{AsRangedCoord, Ranged, ReversibleRanged, ValueFormatter};
+use super::{AsRangedCoord, KeyPointHint, Ranged, ReversibleRanged, ValueFormatter};
 use std::ops::Range;
 
 /// The trait indicates the coordinate is discrete
@@ -161,9 +161,9 @@ impl<D: DiscreteRanged> Ranged for SegmentedCoord<D> {
         }
     }
 
-    fn key_points(&self, max_points: usize) -> Vec<Self::ValueType> {
+    fn key_points<HintType: KeyPointHint>(&self, hint: HintType) -> Vec<Self::ValueType> {
         self.0
-            .key_points(max_points)
+            .key_points(hint)
             .into_iter()
             .map(SegmentValue::CenterOf)
             .collect()
diff --git a/src/coord/group_by.rs b/src/coord/group_by.rs
@@ -1,5 +1,5 @@
 use super::numeric::RangedCoordusize;
-use super::{AsRangedCoord, DiscreteRanged, Ranged, ValueFormatter};
+use super::{AsRangedCoord, DiscreteRanged, KeyPointHint, Ranged, ValueFormatter};
 use std::ops::Range;
 
 /// The ranged value spec that needs to be grouped.
@@ -62,13 +62,13 @@ impl<T: DiscreteRanged> Ranged for GroupBy<T> {
     fn range(&self) -> Range<T::ValueType> {
         self.0.range()
     }
-    // TODO: See issue #88
-    fn key_points(&self, max_points: usize) -> Vec<T::ValueType> {
+    // TODO: See issue issue #88
+    fn key_points<HintType: KeyPointHint>(&self, hint: HintType) -> Vec<T::ValueType> {
         let range = 0..(self.0.size() + self.1 - 1) / self.1;
         let logic_range: RangedCoordusize = range.into();
 
         logic_range
-            .key_points(max_points)
+            .key_points(hint)
             .into_iter()
             .map(|x| self.0.from_index(x * self.1).unwrap())
             .collect()
diff --git a/src/coord/linspace.rs b/src/coord/linspace.rs
@@ -1,4 +1,6 @@
-use super::{numeric::RangedCoordusize, AsRangedCoord, DiscreteRanged, Ranged, ValueFormatter};
+use super::{
+    numeric::RangedCoordusize, AsRangedCoord, DiscreteRanged, KeyPointHint, Ranged, ValueFormatter,
+};
 use std::cmp::{Ordering, PartialOrd};
 use std::marker::PhantomData;
 use std::ops::{Add, Range, Sub};
@@ -284,14 +286,14 @@ where
         self.inner.map(value, limit)
     }
 
-    fn key_points(&self, n: usize) -> Vec<T::ValueType> {
+    fn key_points<Hint: KeyPointHint>(&self, hint: Hint) -> Vec<T::ValueType> {
         if self.grid_value.len() == 0 {
             return vec![];
         }
         let idx_range: RangedCoordusize = (0..(self.grid_value.len() - 1)).into();
 
         idx_range
-            .key_points(n)
+            .key_points(hint)
             .into_iter()
             .map(|x| self.grid_value[x].clone())
             .collect()
diff --git a/src/coord/logarithmic.rs b/src/coord/logarithmic.rs
@@ -1,4 +1,4 @@
-use super::{AsRangedCoord, Ranged, RangedCoordf64};
+use super::{AsRangedCoord, KeyPointHint, Ranged, RangedCoordf64};
 use std::marker::PhantomData;
 use std::ops::Range;
 
@@ -90,7 +90,8 @@ impl<V: LogScalable> Ranged for LogCoord<V> {
         self.linear.map(&value, limit)
     }
 
-    fn key_points(&self, max_points: usize) -> Vec<Self::ValueType> {
+    fn key_points<Hint: KeyPointHint>(&self, hint: Hint) -> Vec<Self::ValueType> {
+        let max_points = hint.max_num_points();
         let tier_1 = (self.logic.end.as_f64() / self.logic.start.as_f64())
             .log10()
             .abs()
diff --git a/src/coord/mod.rs b/src/coord/mod.rs
@@ -44,8 +44,8 @@ pub use numeric::{
     RangedCoordu128, RangedCoordu32, RangedCoordu64,
 };
 pub use ranged::{
-    AsRangedCoord, DefaultFormatting, MeshLine, NoDefaultFormatting, Ranged, RangedCoord,
-    ReversibleRanged, ValueFormatter,
+    AsRangedCoord, BoldPoints, DefaultFormatting, KeyPointHint, KeyPointWeight, MeshLine,
+    NoDefaultFormatting, Ranged, RangedCoord, ReversibleRanged, ValueFormatter,
 };
 
 pub use partial_axis::{make_partial_axis, IntoPartialAxis};
diff --git a/src/coord/nested.rs b/src/coord/nested.rs
@@ -1,4 +1,4 @@
-use super::{AsRangedCoord, DiscreteRanged, Ranged, ValueFormatter};
+use super::{AsRangedCoord, DiscreteRanged, KeyPointHint, Ranged, ValueFormatter};
 use std::ops::Range;
 
 /// Describe a value for a nested coordinate
@@ -99,12 +99,12 @@ impl<P: DiscreteRanged, S: Ranged> Ranged for NestedRange<P, S> {
         }
     }
 
-    fn key_points(&self, max_points: usize) -> Vec<Self::ValueType> {
+    fn key_points<Hint: KeyPointHint>(&self, hint: Hint) -> Vec<Self::ValueType> {
         // TODO: Currently it's tricky to control the labels.
         // The problem is if we need to emit the nested keypoint in this vector?
         // Once we introduce the additional metadata on the key points, we probably have better way to handle this.
         self.primary
-            .key_points(max_points)
+            .key_points(hint)
             .into_iter()
             .map(|x| NestedValue::Category(x))
             .collect()
diff --git a/src/coord/numeric.rs b/src/coord/numeric.rs
@@ -1,7 +1,7 @@
 use std::convert::TryFrom;
 use std::ops::Range;
 
-use super::{AsRangedCoord, DiscreteRanged, Ranged, ReversibleRanged};
+use super::{AsRangedCoord, DiscreteRanged, KeyPointHint, Ranged, ReversibleRanged};
 
 macro_rules! impl_discrete_trait {
     ($name:ident) => {
@@ -85,8 +85,8 @@ macro_rules! make_numeric_coord {
 
                 return limit.0 + (actual_length as f64 * logic_length + 1e-3).floor() as i32;
             }
-            fn key_points(&self, max_points: usize) -> Vec<$type> {
-                $key_points((self.0, self.1), max_points)
+            fn key_points<Hint: KeyPointHint>(&self, hint: Hint) -> Vec<$type> {
+                $key_points((self.0, self.1), hint.max_num_points())
             }
             fn range(&self) -> Range<$type> {
                 return self.0..self.1;
diff --git a/src/coord/partial_axis.rs b/src/coord/partial_axis.rs
@@ -1,4 +1,4 @@
-use super::{AsRangedCoord, DiscreteRanged, Ranged};
+use super::{AsRangedCoord, DiscreteRanged, KeyPointHint, Ranged};
 use std::ops::Range;
 
 /// This axis decorator will make the axis partially display on the axis.
@@ -42,8 +42,8 @@ where
         self.0.map(value, limit)
     }
 
-    fn key_points(&self, max_points: usize) -> Vec<Self::ValueType> {
-        self.0.key_points(max_points)
+    fn key_points<Hint: KeyPointHint>(&self, hint: Hint) -> Vec<Self::ValueType> {
+        self.0.key_points(hint)
     }
 
     fn range(&self) -> Range<Self::ValueType> {
diff --git a/src/coord/ranged.rs b/src/coord/ranged.rs
@@ -34,6 +34,41 @@ where
     }
 }
 
+/// Specify the weight of key points.
+pub enum KeyPointWeight {
+    // Allows only bold key points
+    Bold,
+    // Allows any key points
+    Any,
+}
+
+pub trait KeyPointHint {
+    fn max_num_points(&self) -> usize;
+    fn weight(&self) -> KeyPointWeight;
+}
+
+impl KeyPointHint for usize {
+    fn max_num_points(&self) -> usize {
+        *self
+    }
+
+    fn weight(&self) -> KeyPointWeight {
+        KeyPointWeight::Any
+    }
+}
+
+pub struct BoldPoints(pub usize);
+
+impl KeyPointHint for BoldPoints {
+    fn max_num_points(&self) -> usize {
+        self.0
+    }
+
+    fn weight(&self) -> KeyPointWeight {
+        KeyPointWeight::Bold
+    }
+}
+
 /// The trait that indicates we have a ordered and ranged value
 /// Which is used to describe the axis
 pub trait Ranged {
@@ -46,7 +81,7 @@ pub trait Ranged {
     fn map(&self, value: &Self::ValueType, limit: (i32, i32)) -> i32;
 
     /// This function gives the key points that we can draw a grid based on this
-    fn key_points(&self, max_points: usize) -> Vec<Self::ValueType>;
+    fn key_points<Hint: KeyPointHint>(&self, hint: Hint) -> Vec<Self::ValueType>;
 
     /// Get the range of this value
     fn range(&self) -> Range<Self::ValueType>;
@@ -104,10 +139,15 @@ impl<X: Ranged, Y: Ranged> RangedCoord<X, Y> {
     }
 
     /// Draw the mesh for the coordinate system
-    pub fn draw_mesh<E, DrawMesh: FnMut(MeshLine<X, Y>) -> Result<(), E>>(
+    pub fn draw_mesh<
+        E,
+        DrawMesh: FnMut(MeshLine<X, Y>) -> Result<(), E>,
+        XH: KeyPointHint,
+        YH: KeyPointHint,
+    >(
         &self,
-        h_limit: usize,
-        v_limit: usize,
+        h_limit: YH,
+        v_limit: XH,
         mut draw_mesh: DrawMesh,
     ) -> Result<(), E> {
         let (xkp, ykp) = (
diff --git a/src/coord/slice.rs b/src/coord/slice.rs
@@ -1,4 +1,4 @@
-use super::{AsRangedCoord, DiscreteRanged, Ranged};
+use super::{AsRangedCoord, DiscreteRanged, KeyPointHint, Ranged};
 use std::ops::Range;
 
 /// A range that is defined by a slice of values.
@@ -30,7 +30,8 @@ impl<'a, T: PartialEq> Ranged for RangedSlice<'a, T> {
         }
     }
 
-    fn key_points(&self, max_points: usize) -> Vec<Self::ValueType> {
+    fn key_points<Hint: KeyPointHint>(&self, hint: Hint) -> Vec<Self::ValueType> {
+        let max_points = hint.max_num_points();
         let mut ret = vec![];
         let intervals = (self.0.len() - 1) as f64;
         let step = (intervals / max_points as f64 + 1.0) as usize;
diff --git a/src/drawing/area.rs b/src/drawing/area.rs
@@ -1,7 +1,8 @@
-use crate::coord::{CoordTranslate, MeshLine, Ranged, RangedCoord, Shift};
+use crate::coord::{CoordTranslate, KeyPointHint, MeshLine, Ranged, RangedCoord, Shift};
 use crate::element::{Drawable, PointCollection};
 use crate::style::text_anchor::{HPos, Pos, VPos};
 use crate::style::{Color, SizeDesc, TextStyle};
+
 /// The abstraction of a drawing area
 use plotters_backend::{BackendCoord, DrawingBackend, DrawingErrorKind};
 
@@ -183,11 +184,11 @@ impl<T: DrawingBackend> IntoDrawingArea for T {
 
 impl<DB: DrawingBackend, X: Ranged, Y: Ranged> DrawingArea<DB, RangedCoord<X, Y>> {
     /// Draw the mesh on a area
-    pub fn draw_mesh<DrawFunc>(
+    pub fn draw_mesh<DrawFunc, YH: KeyPointHint, XH: KeyPointHint>(
         &self,
         mut draw_func: DrawFunc,
-        y_count_max: usize,
-        x_count_max: usize,
+        y_count_max: YH,
+        x_count_max: XH,
     ) -> Result<(), DrawingAreaErrorKind<DB::ErrorType>>
     where
         DrawFunc: FnMut(&mut DB, MeshLine<X, Y>) -> Result<(), DrawingErrorKind<DB::ErrorType>>,
