values

src/data.rs

@@ -1,6 +1,8 @@
-use ndarray::{array, s, Array, Array1, Array2, Array3, ArrayBase, ArrayView2, Ix2};
+use ndarray::{
+    array, s, Array, Array1, Array2, Array3, ArrayBase, ArrayView2, Ix2, OwnedRepr, ViewRepr,
+};
 use num_traits::{AsPrimitive, FromPrimitive, Num, ToPrimitive};
-use quadtree_rs::Quadtree;
+use quadtree_rs::{area::AreaBuilder, Quadtree};
 use std::{self, borrow::Borrow, f64::consts::PI};
 use thiserror::Error;
 
@@ -24,10 +26,11 @@ pub enum CoorType {
     LatLon,
 }
 
+#[derive(Clone)]
 pub struct RadarData2d<T, Raw, X = f64, Y = f64>
 where
     T: Num + Clone,
-    Raw: ndarray::Data<Elem = T>,
+    Raw: ndarray::Data<Elem = T> + Clone + ndarray::RawDataClone,
     X: Num,
     Y: Num,
 {
@@ -57,8 +60,17 @@ trait MultiDimensionData<T: Num> {
 impl<T, Raw> RadarData2d<T, Raw>
 where
     T: Num + AsPrimitive<f64> + FromPrimitive + Clone,
-    Raw: ndarray::Data<Elem = T>,
+    Raw: ndarray::Data<Elem = T> + Clone + ndarray::RawDataClone,
 {
+    fn value_to_owned(self) -> RadarData2d<T, OwnedRepr<T>> {
+        RadarData2d {
+            dim1: self.dim1,
+            dim2: self.dim2,
+            data: self.data.to_owned(),
+            coord_type: self.coord_type,
+        }
+    }
+
     fn resample(
         &self,
         width_rate: f64,
@@ -85,6 +97,7 @@ where
     fn split(&self) -> [RadarData2d<T, ndarray::ViewRepr<&T>>; 4] {
         let middle_dim1 = self.dim1.len() / 2;
         let middle_dim2 = self.dim2.len() / 2;
+
         let lt = self.data.slice(s![..middle_dim1, ..middle_dim2]);
         let rt = self.data.slice(s![middle_dim1.., ..middle_dim2]);
         let lb = self.data.slice(s![..middle_dim1, middle_dim2..]);
@@ -167,22 +180,42 @@ fn windowed_sinc(x: f64, y: f64) -> f64 {
     sinc * window
 }
 
-// pub struct LevelData<T: Num> {
+pub struct LevelData<'a, T>
-//     levels: Vec<RadarData2d<T>>,
+where
-// }
+    T: Num + Clone,
+{
+    tree: Quadtree<i64, RadarData2d<T, ViewRepr<&'a T>>>,
+}
 
-// impl<T: Num> LevelData<T> {
+impl<'a, T> LevelData<'a, T>
-//     fn new(levels: Vec<RadarData2d<T>>) -> Self {
+where
-//         let mut qt = Quadtree::<i32, RadarData2d<T>>::new(levels.len());
+    T: Num + Clone + AsPrimitive<f64> + FromPrimitive,
-//         Self { levels }
+{
-//     }
+    fn value(
-// }
+        level_data: Vec<RadarData2d<T, OwnedRepr<T>>>,
+        level_num: usize,
+    ) -> Vec<RadarData2d<T, OwnedRepr<T>>> {
+
+        if level_num == 0 {
+            return level_data;
+        }
+
+        let mut result: Vec<RadarData2d<T, OwnedRepr<T>>> =
+            Vec::with_capacity(level_data.len() * 4);
+        let a = level_data.first().unwrap().split();
+
+        result.extend(a.into_iter().map(|x| x.value_to_owned()));
+
+        return Self::value(result, level_num - 1);
+    }
+    
+}
 
 // impl<T: Num + AsPrimitive<f64> + FromPrimitive> MultiDimensionData<T> for RadarData2d<T> {
-//     // fn levels(&self, levels: usize) -> Self {
+//     fn levels(&self, levels: usize) -> Self {
-//     //     let a: Vec<_> = Array1::linspace(0.0, 1.0, levels)
+//         let a: Vec<_> = Array1::linspace(0.0, 1.0, levels)
-//     //         .into_iter()
+//             .into_iter()
-//     //         .map(|scale| self.resample(scale, scale, 3.0))
+//             .map(|scale| self.resample(scale, scale, 3.0))
-//     //         .collect();
+//             .collect();
-//     // }
+//     }
 // }