Add more control to log scales

Author: 38

examples/tick_control.rs

@@ -3,16 +3,12 @@ use plotters::prelude::*;
 use std::fs::File;
 use std::io::BufReader;
 
-use chrono::NaiveDate;
-use std::str::FromStr;
-
 #[derive(serde_derive::Deserialize)]
 struct DailyData {
-    date: String,
     #[serde(default)]
-    new_cases_smoothed_per_million: f64,
+    new_cases: f64,
     #[serde(default)]
-    total_cases_per_million: f64,
+    total_cases: f64,
 }
 
 #[derive(serde_derive::Deserialize)]
@@ -22,68 +18,65 @@ struct CountryData {
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let root =
-        BitMapBackend::gif("/tmp/tick_control.gif", (800, 600), 100)?.into_drawing_area();
-
-    for a in 0..200 {
-
-        root.fill(&WHITE)?;
-
+        SVGBackend::new("plotters-doc-data/tick_control.svg", (1024, 768)).into_drawing_area();
 
-        let mut chart = ChartBuilder::on(&root)
-            .set_label_area_size(LabelAreaPosition::Left, (8).percent())
-            .set_label_area_size(LabelAreaPosition::Bottom, (6).percent())
-            .margin((1).percent())
-            .build_cartesian_3d(
-                (20u32..10_0000u32)
-                    .log_scale()
-                    .with_key_points(vec![50, 100, 200, 500, 1000, 10000]),
-                (0u32..1000u32)
-                    .log_scale()
-                    .with_key_points(vec![2, 5, 10, 20, 50, 100, 200]),
-                NaiveDate::from_ymd(2020, 1, 1)..NaiveDate::from_ymd(2020, 9, 5),
-            )?;
+    root.fill(&WHITE)?;
 
-        chart.with_projection(|mut pb| {
-            pb.yaw = (1.57 - a as f64 / 100.0 * 1.57).abs();
-            pb.into_matrix()
-        });
+    let (upper, lower) = root.split_vertically(750);
 
-        chart
-            .configure_axes()
-            .draw()?;
+    lower.titled(
+        "Data Source: https://covid.ourworldindata.org/data/owid-covid-data.json",
+        ("sans-serif", 10).into_font().color(&BLACK.mix(0.5)),
+    )?;
 
-        let data: std::collections::HashMap<String, CountryData> = serde_json::from_reader(
-            BufReader::new(File::open("plotters-doc-data/covid-data.json")?),
+    let mut chart = ChartBuilder::on(&upper)
+        .caption("World COVID-19 Cases", ("sans-serif", (5).percent_height()))
+        .set_label_area_size(LabelAreaPosition::Left, (8).percent())
+        .set_label_area_size(LabelAreaPosition::Bottom, (4).percent())
+        .margin((1).percent())
+        .build_cartesian_2d(
+            (20u32..5000_0000u32)
+                .log_scale()
+                .with_key_points(vec![50, 100, 1000, 10000, 100000, 1000000, 10000000]),
+            (0u32..50_0000u32)
+                .log_scale()
+                .with_key_points(vec![10, 50, 100, 1000, 10000, 100000, 200000]),
         )?;
 
-        for (idx, &series) in ["USA", "CHN"]
-            .iter()
-            .enumerate()
-        {
-            let color = Palette99::pick(idx).mix(1.0);
-            chart
-                .draw_series(LineSeries::new(
-                    data[series].data.iter().map(
-                        |DailyData {
-                             date,
-                             new_cases_smoothed_per_million,
-                             total_cases_per_million,
-                             ..
-                         }| (*total_cases_per_million as u32, *new_cases_smoothed_per_million as u32, chrono::NaiveDate::from_str(date).unwrap(),),
-                    ),
-                    color.stroke_width(1),
-                ))?
-                .label(series)
-                .legend(move |(x, y)| Rectangle::new([(x, y - 5), (x + 10, y + 5)], color.filled()));
-        }
+    chart
+        .configure_mesh()
+        .x_desc("Total Cases")
+        .y_desc("New Cases")
+        .draw()?;
 
-        chart
-            .configure_series_labels()
-            .border_style(&BLACK)
-            .draw()?;
+    let data: std::collections::HashMap<String, CountryData> = serde_json::from_reader(
+        BufReader::new(File::open("plotters-doc-data/covid-data.json")?),
+    )?;
 
-        root.present()?;
+    for (idx, &series) in ["CHN", "USA", "RUS", "JPN", "DEU", "IND", "OWID_WRL"]
+        .iter()
+        .enumerate()
+    {
+        let color = Palette99::pick(idx).mix(0.9);
+        chart
+            .draw_series(LineSeries::new(
+                data[series].data.iter().map(
+                    |&DailyData {
+                         new_cases,
+                         total_cases,
+                         ..
+                     }| (total_cases as u32, new_cases as u32),
+                ),
+                color.stroke_width(3),
+            ))?
+            .label(series)
+            .legend(move |(x, y)| Rectangle::new([(x, y - 5), (x + 10, y + 5)], color.filled()));
     }
 
+    chart
+        .configure_series_labels()
+        .border_style(&BLACK)
+        .draw()?;
+
     Ok(())
 }

src/coord/ranged1d/combinators/logarithmic.rs

@@ -46,18 +46,23 @@ impl_log_scalable!(i, u8);
 impl_log_scalable!(i, u16);
 impl_log_scalable!(i, u32);
 impl_log_scalable!(i, u64);
+
 impl_log_scalable!(f, f32);
 impl_log_scalable!(f, f64);
 
 pub trait IntoLogRange {
     type ValueType: LogScalable;
-    fn log_scale(self) -> LogRange<Self::ValueType>;
+    fn log_scale(self) -> LogRangeExt<Self::ValueType>;
 }
 
 impl<T: LogScalable> IntoLogRange for Range<T> {
     type ValueType = T;
-    fn log_scale(self) -> LogRange<T> {
-        LogRange(self)
+    fn log_scale(self) -> LogRangeExt<T> {
+        LogRangeExt {
+            range: self,
+            zero: 0.0,
+            base: 10.0,
+        }
     }
 }
 
@@ -66,11 +71,70 @@ impl<T: LogScalable> IntoLogRange for Range<T> {
 #[derive(Clone)]
 pub struct LogRange<V: LogScalable>(pub Range<V>);
 
+#[derive(Clone)]
+pub struct LogRangeExt<V: LogScalable> {
+    range: Range<V>,
+    zero: f64,
+    base: f64,
+}
+
+impl<V: LogScalable> LogRangeExt<V> {
+    pub fn zero_point(mut self, value: V) -> Self
+    where
+        V: PartialEq,
+    {
+        self.zero = if V::from_f64(0.0) == value {
+            0.0
+        } else {
+            value.as_f64()
+        };
+
+        self
+    }
+
+    pub fn base(mut self, base: f64) -> Self {
+        if self.base > 1.0 {
+            self.base = base;
+        }
+        self
+    }
+}
+
 impl<V: LogScalable> From<LogRange<V>> for LogCoord<V> {
     fn from(range: LogRange<V>) -> LogCoord<V> {
+        range.0.log_scale().into()
+    }
+}
+
+impl<V: LogScalable> From<LogRangeExt<V>> for LogCoord<V> {
+    fn from(spec: LogRangeExt<V>) -> LogCoord<V> {
+        let zero_point = spec.zero;
+        let mut start = spec.range.start.as_f64() - zero_point;
+        let mut end = spec.range.end.as_f64() - zero_point;
+        let negative = if start < 0.0 || end < 0.0 {
+            start = -start;
+            end = -end;
+            true
+        } else {
+            false
+        };
+
+        if start < end {
+            if start == 0.0 {
+                start = start.max(end * 1e-5);
+            }
+        } else {
+            if end == 0.0 {
+                end = end.max(start * 1e-5);
+            }
+        }
         LogCoord {
-            linear: (range.0.start.as_f64().ln()..range.0.end.as_f64().ln()).into(),
-            logic: range.0,
+            linear: (start.ln()..end.ln()).into(),
+            logic: spec.range,
+            normalized: start..end,
+            base: spec.base,
+            zero_point,
+            negative,
             marker: PhantomData,
         }
     }
@@ -81,62 +145,107 @@ impl<V: LogScalable> AsRangedCoord for LogRange<V> {
     type Value = V;
 }
 
+impl<V: LogScalable> AsRangedCoord for LogRangeExt<V> {
+    type CoordDescType = LogCoord<V>;
+    type Value = V;
+}
+
 /// A log scaled coordinate axis
 pub struct LogCoord<V: LogScalable> {
     linear: RangedCoordf64,
     logic: Range<V>,
+    normalized: Range<f64>,
+    base: f64,
+    zero_point: f64,
+    negative: bool,
     marker: PhantomData<V>,
 }
 
+impl<V: LogScalable> LogCoord<V> {
+    fn value_to_f64(&self, value: &V) -> f64 {
+        let fv = value.as_f64() - self.zero_point;
+        if self.negative {
+            -fv
+        } else {
+            fv
+        }
+    }
+
+    fn f64_to_value(&self, fv: f64) -> V {
+        let fv = if self.negative { -fv } else { fv };
+        V::from_f64(fv + self.zero_point)
+    }
+
+    fn is_inf(&self, fv: f64) -> bool {
+        let fv = if self.negative { -fv } else { fv };
+        let a = V::from_f64(fv + self.zero_point);
+        let b = V::from_f64(self.zero_point);
+
+        V::as_f64(&a) == V::as_f64(&b)
+    }
+}
+
 impl<V: LogScalable> Ranged for LogCoord<V> {
     type FormatOption = DefaultFormatting;
     type ValueType = V;
 
     fn map(&self, value: &V, limit: (i32, i32)) -> i32 {
-        let value = value.as_f64();
-        let value = value.max(self.logic.start.as_f64()).ln();
-        self.linear.map(&value, limit)
+        let fv = self.value_to_f64(value);
+        let value_ln = fv.ln();
+        self.linear.map(&value_ln, limit)
     }
 
     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()
-            .floor()
-            .max(1.0) as usize;
 
-        let tier_2_density = if max_points < tier_1 {
+        let base = self.base;
+        let base_ln = base.ln();
+
+        /*let mut start = self.//self.value_to_f64(&self.logic.start);
+        let mut end = self.value_to_f64(&self.logic.end);*/
+        let Range { mut start, mut end } = self.normalized;
+
+        if start > end {
+            std::mem::swap(&mut start, &mut end);
+        }
+
+        let bold_count = ((end / start).ln().abs() / base_ln).floor().max(1.0) as usize;
+
+        let light_density = if max_points < bold_count {
             0
         } else {
-            let density = 1 + (max_points - tier_1) / tier_1;
+            let density = 1 + (max_points - bold_count) / bold_count;
             let mut exp = 1;
             while exp * 10 <= density {
                 exp *= 10;
             }
             exp - 1
         };
 
-        let mut multiplier = 10.0;
+        let mut multiplier = base;
         let mut cnt = 1;
-        while max_points < tier_1 / cnt {
-            multiplier *= 10.0;
+        while max_points < bold_count / cnt {
+            multiplier *= base;
             cnt += 1;
         }
 
         let mut ret = vec![];
-        let mut val = (10f64).powf(self.logic.start.as_f64().log10().ceil());
+        let mut val = (base).powf((start.ln() / base_ln).ceil());
 
-        while val <= self.logic.end.as_f64() {
-            ret.push(V::from_f64(val));
-            for i in 1..=tier_2_density {
+        while val <= end {
+            if !self.is_inf(val) {
+                ret.push(self.f64_to_value(val));
+            }
+            for i in 1..=light_density {
                 let v = val
                     * (1.0
-                        + multiplier / f64::from(tier_2_density as u32 + 1) * f64::from(i as u32));
-                if v > self.logic.end.as_f64() {
+                        + multiplier / f64::from(light_density as u32 + 1) * f64::from(i as u32));
+                if v > end {
                     break;
                 }
-                ret.push(V::from_f64(v));
+                if !self.is_inf(val) {
+                    ret.push(self.f64_to_value(v));
+                }
             }
             val *= multiplier;
         }

src/coord/ranged1d/types/numeric.rs

@@ -79,7 +79,8 @@ macro_rules! make_numeric_coord {
                     return (limit.1 - limit.0) / 2;
                 }
 
-                let logic_length = (*v - self.0) as f64 / (self.1 - self.0) as f64;
+
+                let logic_length = (*v as f64 - self.0 as f64) / (self.1 as f64 - self.0 as f64);
 
                 let actual_length = limit.1 - limit.0;
 

src/data/float.rs

@@ -64,8 +64,8 @@ pub struct FloatPrettyPrinter {
 
 impl FloatPrettyPrinter {
     pub fn print(&self, n: f64) -> String {
-        let (n, p) = find_minimal_repr(n, (10f64).powi(-self.max_decimal));
-        let d_repr = float_to_string(n, p, self.min_decimal as usize);
+        let (tn, p) = find_minimal_repr(n, (10f64).powi(-self.max_decimal));
+        let d_repr = float_to_string(tn, p, self.min_decimal as usize);
         if !self.allow_scientific {
             d_repr
         } else {
@@ -91,7 +91,7 @@ impl FloatPrettyPrinter {
                 float_to_string(sn, sp, self.min_decimal as usize),
                 float_to_string(idx, 0, 0)
             );
-            if s_repr.len() + 1 < d_repr.len() {
+            if s_repr.len() + 1 < d_repr.len() || (tn == 0.0 && n != 0.0) {
                 s_repr
             } else {
                 d_repr