
            Layer::geojson_layer_with_path(
                "/Users/tsuki/Downloads/new_zhejiang.json",
                true,
                |_self, c, render, _| {
                    if let Some(json_resources) = _self.get_resources() {
                        if let Resources::GeoJson(geojson) = json_resources.deref() {
                            MapRender::test(&geojson, c, render);
                        }
                    }
                },
            ),
            Layer::new(true, None, |s, c, render, _| {
                if let Some(target) = s.render_target() {
                    if let Ok(_) = c.image_size(target.target) {
                        let (x, y) = target.size(render);
                        let (ox, oy) = target.origin(render);
                        let painter = Paint::image(target.target, ox, oy, x, y, 0.0, 1.0);
                        let mut path = Path::new();
                        path.rect(ox, oy, x, y);
                        c.fill_path(&path, &painter);
                    }
                } else {
                    let renderer = RadarEchoRenderer::new(BoundaryNorm::new(
                        vec![0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65],
                        vec![
                            Color::rgb(0, 172, 164),
                            Color::rgb(192, 192, 254),
                            Color::rgb(122, 114, 238),
                            Color::rgb(30, 38, 208),
                            Color::rgb(166, 252, 168),
                            Color::rgb(0, 234, 0),
                            Color::rgb(16, 146, 26),
                            Color::rgb(252, 244, 100),
                            Color::rgb(200, 200, 2),
                            Color::rgb(140, 140, 0),
                            Color::rgb(254, 172, 172),
                            Color::rgb(254, 100, 92),
                            Color::rgb(238, 2, 48),
                            Color::rgb(212, 142, 254),
                            Color::rgb(170, 36, 250),
                        ],
                        true,
                    ));
                    let loader = Npz;
                    let data: RadarData2d<i8, OwnedRepr<i8>> = loader
                        .load("/Users/tsuki/projects/radar-g/test2.npz")
                        .unwrap();
                    let img = renderer.render(render, c, &data);
                    if let Ok(_) = c.image_size(img.target) {
                        let (x, y) = img.size(render);
                        let (ox, oy) = img.origin(render);
                        println!("{} {} {} {}", x, y, ox, oy);
                        let painter = Paint::image(img.target, ox, oy, x, y, 0.0, 1.0);
                        let mut path = Path::new();
                        path.rect(ox, oy, x, y);
                        s.set_render_target(img);
                        c.fill_path(&path, &painter);
                        c.flush();
                    }
                }
            }),






############# TEMPLATES ###################
// Monitor::new(
        //     Render::new(
        //         Some(Mapper::new(
        //             Proj::new(Mercator::default().build().as_str()).unwrap(),
        //             (119.539..121.135).into(),
        //             (29.13..30.164).into(),
        //         )),
        //         RenderConfig { padding: [50.0;4] }
        //     )
        // )



// Layer::grid_render_layer_with_path(
        //     "/users/tsuki/projects/radar-g/test2.npz",
        //     Npz,
        //     BoundaryNorm::default(),
        // )



// fn resample(
//     &self,
//     width_rate: f64,
//     height_rate: f64,
//     filter_len: f64,
// ) -> Result<RadarData2d<T, OwnedRepr<T>>, DataError> {
//     let width_rate = width_rate.min(1.0);
//     let height_rate = height_rate.min(1.0);
//     match self.coord_type {
//         CoordType::Polar => Err(DataError::FormatError),
//         CoordType::LatLon => {
//             let width_filtered: ArrayBase<ndarray::OwnedRepr<T>, Ix2> =
//                 Self::_resample(&self.data, width_rate, filter_len);

//             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,
//             )
//             .slice(s![0, ..])
//             .to_owned();

//             let new_dim2: ArrayBase<OwnedRepr<f64>, Ix1> = Self::_resample(
//                 &Array2::from_shape_vec((1, self.dim2.len()), self.dim2.to_vec()).unwrap(),
//                 height_rate,
//                 filter_len,
//             )
//             .slice(s![0, ..])
//             .to_owned();

//             Ok(RadarData2d {
//                 dim1: new_dim1,
//                 dim2: new_dim2,
//                 data: result,
//                 coord_type: self.coord_type.to_owned(),
//             })
//         }
//     }
// }

// fn _resample<'a, V, R: ndarray::Data<Elem = V>>(
//         data: &'a ArrayBase<R, Ix2>,
//         rate: f64,
//         filter_len: f64,
//     ) -> Array2<V>
//     where
//         V: Num + Clone + AsPrimitive<f64> + FromPrimitive,
//     {
//         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));
//         (0..ori_height).into_iter().for_each(|height| {
//             for width in 0..new_width {
//                 let center_x = (width as f64 + 0.5) / new_width as f64 * ori_width as f64;
//                 let filter_start = center_x - filter_len / 2.0;
//                 let start_idx = (filter_start - 0.5).ceil() as usize;

//                 let mut value_sum = 0.0;
//                 let mut filter_sum = 0.0;

//                 for i in 0..filter_len as usize {
//                     let input_x = start_idx + i;
//                     let weight = windowed_sinc(
//                         (input_x as f64 + 0.5 - center_x) * rate,
//                         (input_x as f64 + 0.5 - filter_start) / filter_len,
//                     );
//                     value_sum += weight * data[[height, input_x.clamp(0, ori_width - 1)]].as_();
//                     filter_sum += weight;
//                 }

//                 result[[height, width]] = V::from_f64(value_sum / filter_sum).unwrap();
//             }
//         });
//         result
//     }

// pub struct LevelData<T: Num + Clone + PartialEq + PartialOrd>(
//     pub Quadtree<i64, RadarData2d<T, OwnedRepr<T>>>,
// );

// impl<T> LevelData<T>
// where
//     T: Num + Clone + AsPrimitive<f64> + FromPrimitive + Debug + PartialEq + PartialOrd,
// {
//     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 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, 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(level);

//         blocks.into_iter().for_each(|block| {
//             tree.insert(
//                 AreaBuilder::default()
//                     .anchor(quadtree_rs::point::Point {
//                         x: *block.dim1.first().unwrap() as i64,
//                         y: *block.dim2.first().unwrap() as i64,
//                     })
//                     .dimensions((block.dim1.len() as i64, block.dim2.len() as i64))
//                     .build()
//                     .unwrap(),
//                 block,
//             );
//         });

//         Self(tree)
//     }
// }

// pub fn levels<T>(data: Radar2d<T>, levels: usize) -> Vec<LevelData<T>>
// where
//     T: Num + Clone + AsPrimitive<f64> + FromPrimitive + Debug,
//     T: PartialEq + PartialOrd,
// {
//     let numerator = 1.0 / levels as f64;
//     (0..levels)
//         .into_iter()
//         .map(|level| LevelData::new(&data, level + 1, 1.0 - level as f64 * numerator))
//         .collect()
// }





#[inline]
fn windowed_sinc(x: f64, y: f64) -> f64 {
    let x = x * PI;
    let sinc = if x != 0.0 { f64::sin(x) / x } else { 1.0 };
    let window = if 0f64 <= y && y <= 1.0 {
        1.0 - (y - 0.5).abs() * 2.0
    } else {
        0f64
    };
    sinc * window
}

pub enum DownSampleMeth {
    STD,
    MEAN,
    VAR,
}

#[derive(Clone, Copy, Debug)]
pub enum CoordType {
    Polar,
    LatLon,
}