common update

Cargo.lock

@@ -214,6 +214,7 @@ dependencies = [
  "npyz",
  "num-traits",
  "proj",
+ "proj-sys",
  "quadtree_rs",
  "shapefile",
  "thiserror",

Cargo.toml

@@ -21,6 +21,7 @@ num-traits = "0.2.15"
 npyz = { version = "0.8.0", features = ["npz"] }
 ndarray = "0.15.6"
 quadtree_rs = "0.1.2"
+proj-sys = "0.23.1"
 
 [build-dependencies]
 glib-build-tools = "0.17.0"

p.py

@@ -0,0 +1,12 @@
+import numpy as np
+
+a = np.load("/home/ruomu/Desktop/test.npz")
+
+b = a['value']
+lon = a['lon']
+lat = a['lat']
+
+a = np.load("/home/ruomu/Desktop/test2.npz")['value']
+
+
+np.savez("/home/ruomu/Desktop/test2.npz", value=np.max(b,axis=0), lon=lon, lat=lat)

src/data.rs

@@ -1,16 +1,10 @@
-use ndarray::{
+use ndarray::{s, Array1, Array2, Array3, ArrayBase, Ix1, Ix2, OwnedRepr, RawDataClone};
-    arr2, array, s, Array, Array1, Array2, Array3, ArrayBase, ArrayView2, Axis, Ix2, OwnedRepr,
+use npyz::{npz::NpzArchive, Deserialize};
-    RawDataClone, Slice, ViewRepr,
+use num_traits::{AsPrimitive, FromPrimitive, Num};
-};
-use npyz::{npz::NpzArchive, DType, Deserialize, TypeChar};
-use num_traits::{AsPrimitive, FromPrimitive, Num, ToPrimitive};
 use quadtree_rs::{area::AreaBuilder, Quadtree};
-use std::{self, borrow::Borrow, f64::consts::PI, io::BufReader, path::Path};
+use std::{self, f64::consts::PI, fmt::Debug, io::BufReader, path::Path};
 use thiserror::Error;
 
-type Lon = f64;
-type Lat = f64;
-
 #[derive(Error, Debug)]
 pub enum DataError {
     #[error("value")]
@@ -42,7 +36,7 @@ where
     pub coord_type: CoorType,
 }
 
-pub struct RadarData3d<T, X = f64, Y = f64, Z = f64>
+struct RadarData3d<T, X = f64, Y = f64, Z = f64>
 where
     T: Num,
     X: Num,
@@ -59,7 +53,7 @@ trait MultiDimensionData {}
 
 impl<T, Raw> RadarData2d<T, Raw>
 where
-    T: Num + AsPrimitive<f64> + FromPrimitive + Clone,
+    T: Num + AsPrimitive<f64> + FromPrimitive + Clone + Debug,
     Raw: ndarray::Data<Elem = T> + Clone + ndarray::RawDataClone,
 {
     fn value_to_owned(self) -> RadarData2d<T, OwnedRepr<T>> {
@@ -83,22 +77,25 @@ where
             CoorType::Polar => Err(DataError::FormatError),
             CoorType::LatLon => {
                 let width_filtered: ArrayBase<ndarray::OwnedRepr<T>, Ix2> =
-                    Self::_resample(&self.data, width_rate, filter_len, false);
+                    Self::_resample(&self.data, width_rate, filter_len);
 
-                let new_dim1 = Self::_resample(
+                let result: ArrayBase<OwnedRepr<T>, Ix2> =
+                    Self::_resample(&width_filtered.t(), height_rate, filter_len)
+                        .t()
+                        .to_owned();
+
+                let new_dim1: ArrayBase<OwnedRepr<f64>, Ix1> = Self::_resample(
                     &Array2::from_shape_vec((1, self.dim1.len()), self.dim1.to_vec()).unwrap(),
                     width_rate,
                     filter_len,
-                    false,
                 )
                 .slice(s![0, ..])
                 .to_owned();
 
-                let new_dim2 = Self::_resample(
+                let new_dim2: ArrayBase<OwnedRepr<f64>, Ix1> = Self::_resample(
                     &Array2::from_shape_vec((1, self.dim2.len()), self.dim2.to_vec()).unwrap(),
-                    width_rate,
+                    height_rate,
                     filter_len,
-                    false,
                 )
                 .slice(s![0, ..])
                 .to_owned();
@@ -106,7 +103,7 @@ where
                 Ok(RadarData2d {
                     dim1: new_dim1,
                     dim2: new_dim2,
-                    data: Self::_resample(&width_filtered, height_rate, filter_len, true),
+                    data: result,
                     coord_type: self.coord_type.to_owned(),
                 })
             }
@@ -154,13 +151,12 @@ where
         data: &'a ArrayBase<R, Ix2>,
         rate: f64,
         filter_len: f64,
-        reverse: bool,
     ) -> Array2<V>
     where
         V: Num + Clone + AsPrimitive<f64> + FromPrimitive,
     {
-        let ori_width = if reverse { data.nrows() } else { data.ncols() };
+        let ori_width = data.ncols();
-        let ori_height = if reverse { data.ncols() } else { data.nrows() };
+        let ori_height = data.nrows();
 
         let new_width = (ori_width as f64 * rate).ceil() as usize;
         let mut result: Array2<V> = Array2::zeros((ori_height, new_width));
@@ -202,11 +198,11 @@ fn windowed_sinc(x: f64, y: f64) -> f64 {
     sinc * window
 }
 
-pub struct LevelData<T: Num + Clone>(Quadtree<i64, RadarData2d<T, OwnedRepr<T>>>);
+pub struct LevelData<T: Num + Clone>(pub Quadtree<i64, RadarData2d<T, OwnedRepr<T>>>);
 
 impl<T> LevelData<T>
 where
-    T: Num + Clone + AsPrimitive<f64> + FromPrimitive,
+    T: Num + Clone + AsPrimitive<f64> + FromPrimitive + Debug,
 {
     fn value(
         level_data: Vec<RadarData2d<T, OwnedRepr<T>>>,
@@ -218,19 +214,22 @@ where
 
         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()));
+        let results = level_data
+            .iter()
+            .flat_map(|v| v.split().into_iter().map(|x| x.value_to_owned()));
+
+        result.extend(results);
 
         return Self::value(result, level_num - 1);
     }
 
-    fn new(data: RadarData2d<T, OwnedRepr<T>>, level: usize) -> Self {
+    fn new(data: &RadarData2d<T, OwnedRepr<T>>, level: usize, rate: f64) -> Self {
-        let rate = 1.0 / level as f64;
+        // let rate = 1.0 / level as f64;
         let resampled = data.resample(rate, rate, 2.0).unwrap();
         let blocks = Self::value(vec![resampled], level);
         let mut tree: Quadtree<i64, RadarData2d<T, OwnedRepr<T>>> =
-            quadtree_rs::Quadtree::new(blocks.len());
+            quadtree_rs::Quadtree::new(level);
 
         blocks.into_iter().for_each(|block| {
             tree.insert(
@@ -250,13 +249,14 @@ where
     }
 }
 
-pub fn levels<T>(data: RadarData2d<T, OwnedRepr<T>>, levels: usize) -> Vec<LevelData<T>>
+pub fn levels<T>(data: Radar2d<T>, levels: usize) -> Vec<LevelData<T>>
 where
-    T: Num + Clone + AsPrimitive<f64> + FromPrimitive,
+    T: Num + Clone + AsPrimitive<f64> + FromPrimitive + Debug,
 {
+    let numerator = 1.0 / levels as f64;
     (0..levels)
         .into_iter()
-        .map(|level| LevelData::new(data.clone(), level))
+        .map(|level| LevelData::new(&data.0, level + 1, 1.0 - level as f64 * numerator))
         .collect()
 }
 
@@ -311,23 +311,9 @@ where
 {
     fn load<P: AsRef<Path>>(&self, path: P) -> Result<RadarData2d<T, OwnedRepr<T>>, DataError> {
         let mut data: NpzArchive<BufReader<std::fs::File>> = npyz::npz::NpzArchive::open(path)?;
-        if let DType::Plain(type_str) = data.by_name("val")?.unwrap().dtype() {
+        let dim1 = self.load_1d::<f64>(&mut data, "lon")?;
-            let bytes_num = type_str.num_bytes().unwrap();
+        let dim2 = self.load_1d::<f64>(&mut data, "lat")?;
-            match type_str.type_char() {
+        let value = self.load_2d::<T>(&mut data, "value")?;
-                TypeChar::Float => match bytes_num {
-                    4 => self.load_2d::<f32>(&mut data, "val")?,
-                    8 => self.load_2d::<f64>(&mut data, "val")?,
-                    _ => {}
-                },
-
-                TypeChar::Int => {}
-
-                _ => {}
-            }
-        }
-        let dim1 = self.load_1d::<f64>(&mut data, "dim1")?;
-        let dim2 = self.load_1d::<f64>(&mut data, "dim2")?;
-        let value = self.load_2d::<T>(&mut data, "val")?;
 
         Ok(RadarData2d {
             dim1: dim1,
@@ -337,3 +323,20 @@ where
         })
     }
 }
+
+impl<T: Num + Clone> RadarData2d<T, OwnedRepr<T>> {
+    pub fn load<P: AsRef<Path>, M: DataLoader<Self>>(p: P, meth: M) -> Self {
+        meth.load(p).unwrap()
+    }
+}
+
+pub struct Radar2d<T: Num + Clone>(RadarData2d<T, OwnedRepr<T>>);
+
+impl<T: Num + Clone> Radar2d<T> {
+    pub fn load(
+        path: impl AsRef<Path>,
+        meth: impl DataLoader<RadarData2d<T, OwnedRepr<T>>>,
+    ) -> Result<Self, DataError> {
+        Ok(Radar2d(meth.load(path)?))
+    }
+}

src/main.rs

@@ -14,6 +14,8 @@ mod data;
 // mod trees;
 mod window;
 
+use data::{Npz,Radar2d, levels};
+
 const APP_ID: &str = "org.gtk_rs.HelloWorld2";
 
 fn main() -> glib::ExitCode {
@@ -26,6 +28,16 @@ fn main() -> glib::ExitCode {
     // Connect to "activate" signal of `app`
     app.connect_activate(build_ui);
 
+    let path = "/home/ruomu/Desktop/test.npz";
+
+    let data = Radar2d::<i8>::load(path, Npz).unwrap();
+
+    let result = levels(data, 3);
+
+    for i in result.iter(){
+        println!("{:?}", i.0.depth());
+    }
+
     // Run the application
     app.run()
 }