tsuki/radar-g
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

common update

Browse Source
This commit is contained in:
sleptworld 2023-06-09 18:35:53 +08:00
parent d6f1341b17
commit c30f183a38
5 changed files with 78 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.lock generated
View File

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

1
Cargo.toml
View File

@ -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"

12
p.py Normal file
View File

@ -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)

101
src/data.rs
View File

@ -1,16 +1,10 @@
use ndarray::{
arr2, array, s, Array, Array1, Array2, Array3, ArrayBase, ArrayView2, Axis, Ix2, OwnedRepr,
RawDataClone, Slice, ViewRepr,
};
use npyz::{npz::NpzArchive, DType, Deserialize, TypeChar};
use num_traits::{AsPrimitive, FromPrimitive, Num, ToPrimitive};
use ndarray::{s, Array1, Array2, Array3, ArrayBase, Ix1, Ix2, OwnedRepr, RawDataClone};
use npyz::{npz::NpzArchive, Deserialize};
use num_traits::{AsPrimitive, FromPrimitive, Num};
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_height = if reverse { data.ncols() } else { data.nrows() };
let ori_width = data.ncols();
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 {
let rate = 1.0 / level as f64;
fn new(data: &RadarData2d<T, OwnedRepr<T>>, level: usize, rate: f64) -> Self {
// 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 bytes_num = type_str.num_bytes().unwrap();
match type_str.type_char() {
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")?;
let dim1 = self.load_1d::<f64>(&mut data, "lon")?;
let dim2 = self.load_1d::<f64>(&mut data, "lat")?;
let value = self.load_2d::<T>(&mut data, "value")?;
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)?))
}
}

12
src/main.rs
View File

@ -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()
}