refactor

src/coords/mapper.rs

@@ -71,9 +71,10 @@ impl Mapper {
 
     pub fn ring_map(&self, ring: &LineString) -> Result<LineString, ProjError> {
         let mut result = Vec::new();
-        for l in ring.lines() {
-            let start_projected: (f64, f64) = l.start.into();
-            let end_projected: (f64, f64) = l.end.into();
+        let projed = self.map_line(ring)?;
+        for (l, p) in ring.lines().zip(projed.lines()) {
+            let start_projected: (f64, f64) = p.start.into();
+            let end_projected: (f64, f64) = p.end.into();
             let cartesian_start = self.cartesian(l.start.x, l.start.y);
             let cartesian_end = self.cartesian(l.end.x, l.end.y);
 
@@ -100,6 +101,13 @@ impl Mapper {
         Ok(LineString::new(result))
     }
 
+    pub fn map_line(&self, line: &LineString) -> Result<LineString, ProjError> {
+        let result: Result<LineString, ProjError> =
+            line.points().map(|p| self.map((p.x(), p.y()))).collect();
+
+        Ok(result?)
+    }
+
     #[inline]
     fn cartesian(&self, lambda: f64, phi: f64) -> (f64, f64, f64) {
         let cos_phi = phi.cosh();

src/render/foreground/imp.rs

@@ -1,6 +1,7 @@
 use crate::render::{imp, WindowCoord};
-use femtovg::Paint;
+use femtovg::{ImageId, Paint};
 use geo_macros::Prj;
+use geo_types::LineString;
 use gtk::glib;
 use gtk::subclass::prelude::*;
 use ndarray::Array2;
@@ -26,7 +27,8 @@ pub struct ForegroundWidget {
     pub(super) config: RefCell<ForegroundConfig>,
     pub(super) dim1: RefCell<Option<Array2<f64>>>,
     pub(super) dim2: RefCell<Option<Array2<f64>>>,
-    pub(super) image: RefCell<Option<Vec<u8>>>,
+    pub(super) image: RefCell<Option<ImageId>>,
+    pub(super) data: RefCell<Option<Array2<LineString>>>,
 }
 
 #[glib::object_subclass]

src/render/foreground/mod.rs

@@ -34,6 +34,32 @@ impl ForegroundWidget {
         let canvas_height = canvas.height();
         let config = self.imp().config.borrow();
 
+        println!("Resize: {} {}", canvas.width(), canvas.height());
+
+        let mut img = self.imp().image.borrow_mut();
+
+        if img.is_none() {
+            let mut img_id = canvas
+                .create_image_empty(
+                    canvas_width as usize,
+                    canvas_height as usize,
+                    femtovg::PixelFormat::Rgb8,
+                    ImageFlags::empty(),
+                )
+                .unwrap();
+            canvas.save();
+            canvas.reset();
+            if let Ok(size) = canvas.image_size(img_id) {
+                // canvas.set_render_target(femtovg::RenderTarget::Image(img_id));
+                canvas.clear_rect(0, 0, size.0 as u32, size.1 as u32, Color::rgb(255, 255, 0));
+
+                img.replace(img_id);
+            }
+
+            canvas.restore();
+            canvas.reset();
+        }
+
         let img = canvas
             .load_image_file("test.png", ImageFlags::NEAREST)
             .unwrap();
@@ -54,8 +80,12 @@ impl ForegroundWidget {
         self.imp().dim2.replace(Some(dims.1));
     }
 
-    pub(super) fn set_image(&mut self, image: Vec<u8>) {
-        self.imp().image.replace(Some(image));
+    // pub(super) fn set_image(&mut self, image: Vec<u8>) {
+    //     self.imp().image.replace(Some(image));
+    // }
+
+    pub(super) fn set_data(&mut self, data: Array2<LineString>) {
+        self.imp().data.replace(Some(data));
     }
 }
 

src/render/imp.rs

@@ -26,6 +26,8 @@ pub struct Render {
     pub config: RefCell<RenderConfig>,
     pub mapper: RefCell<Mapper>,
     canvas: RefCell<Option<femtovg::Canvas<femtovg::renderer::OpenGl>>>,
+    canvas_width: RefCell<f32>,
+    canvas_height: RefCell<f32>,
 }
 
 impl Default for Render {
@@ -36,6 +38,8 @@ impl Default for Render {
             config: RefCell::new(RenderConfig::default()),
             mapper: RefCell::new(Mercator::new().into()),
             canvas: RefCell::new(None),
+            canvas_height: RefCell::new(0.0),
+            canvas_width: RefCell::new(0.0),
         }
     }
 }
@@ -73,14 +77,12 @@ impl GLAreaImpl for Render {
 
     fn render(&self, context: &gtk::gdk::GLContext) -> bool {
         self.ensure_canvas();
-
         let mut canvas = self.canvas.borrow_mut();
         let canvas = canvas.as_mut().unwrap();
 
         let dpi = self.obj().scale_factor();
         let w = self.obj().width();
         let h = self.obj().width();
-
         let configs = self.config.borrow();
 
         canvas.clear_rect(
@@ -91,7 +93,7 @@ impl GLAreaImpl for Render {
             Color::rgba(0, 0, 0, 255),
         );
 
-        self.background.borrow().draw(canvas, configs.scale, dpi);
+        // self.background.borrow().draw(canvas, configs.scale, dpi);
 
         self.foreground
             .borrow()