group_by and nested coord now supports the key point hint

Author: 38

src/coord/group_by.rs

@@ -1,4 +1,3 @@
-use super::numeric::RangedCoordusize;
 use super::{AsRangedCoord, DiscreteRanged, KeyPointHint, Ranged, ValueFormatter};
 use std::ops::Range;
 
@@ -64,11 +63,35 @@ impl<T: DiscreteRanged> Ranged for GroupBy<T> {
     }
     // 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();
+        let range = 0..(self.0.size() + self.1) / self.1;
+        //let logic_range: RangedCoordusize = range.into();
 
-        logic_range
-            .key_points(hint)
+        let interval =
+            ((range.end - range.start + hint.bold_points() - 1) / hint.bold_points()).max(1);
+        let count = (range.end - range.start) / interval;
+
+        let idx_iter = (0..hint.bold_points()).map(|x| x * interval);
+
+        if hint.weight().allow_light_points() && count < hint.bold_points() * 2 {
+            let outter_ticks = idx_iter;
+            let outter_tick_size = interval * self.1;
+            let inner_ticks_per_group = hint.max_num_points() / outter_ticks.len();
+            let inner_ticks =
+                (outter_tick_size + inner_ticks_per_group - 1) / inner_ticks_per_group;
+            let inner_ticks: Vec<_> = (0..(outter_tick_size / inner_ticks))
+                .map(move |x| x * inner_ticks)
+                .collect();
+            let size = self.0.size();
+            return outter_ticks
+                .into_iter()
+                .map(|base| inner_ticks.iter().map(move |&ofs| base * self.1 + ofs))
+                .flatten()
+                .take_while(|&idx| idx < size)
+                .map(|x| self.0.from_index(x).unwrap())
+                .collect();
+        }
+
+        idx_iter
             .into_iter()
             .map(|x| self.0.from_index(x * self.1).unwrap())
             .collect()

src/coord/nested.rs

@@ -89,8 +89,7 @@ impl<P: DiscreteRanged, S: Ranged> Ranged for NestedRange<P, S> {
         }
 
         let s_left = limit.0 + bucket_size * idx as i32 + residual.min(idx as i32);
-        let s_right =
-            limit.0 + s_left + bucket_size + if (residual as usize) < idx { 1 } else { 0 };
+        let s_right = s_left + bucket_size + if (residual as usize) < idx { 1 } else { 0 };
 
         if let Some(secondary_value) = value.nested_value() {
             self.secondary[idx].map(secondary_value, (s_left, s_right))
@@ -100,14 +99,31 @@ impl<P: DiscreteRanged, S: Ranged> Ranged for NestedRange<P, S> {
     }
 
     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(hint)
-            .into_iter()
-            .map(|x| NestedValue::Category(x))
-            .collect()
+        if !hint.weight().allow_light_points() || hint.max_num_points() < self.primary.size() * 2 {
+            self.primary
+                .key_points(hint)
+                .into_iter()
+                .map(|x| NestedValue::Category(x))
+                .collect()
+        } else {
+            let secondary_size =
+                (hint.max_num_points() - self.primary.size()) / self.primary.size();
+            self.primary
+                .values()
+                .enumerate()
+                .map(|(idx, val)| {
+                    std::iter::once(NestedValue::Category(val)).chain(
+                        self.secondary[idx]
+                            .key_points(secondary_size)
+                            .into_iter()
+                            .map(move |v| {
+                                NestedValue::Value(self.primary.from_index(idx).unwrap(), v)
+                            }),
+                    )
+                })
+                .flatten()
+                .collect()
+        }
     }
 }