improve inspector

Author: Yatekii

src/bin/drawing/ui/views/inspector.rs

@@ -29,30 +29,24 @@ fn selected_object(ui: &mut Ui, app_state: &mut AppState) {
         let selector = object.selector().clone();
         let tags = object.tags();
 
-        ui.separator();
         ui.label(RichText::from("Tags").strong());
         ui.separator();
 
-        ui.label(format!("{tags:#?}"));
         let data = tags
             .iter()
             .map(|(k, v)| (k.as_str(), v.clone()))
             .collect::<Vec<_>>();
         widget_key_value_table(ui, &data);
-
-        ui.separator();
-        ui.label("Applying rules");
         ui.separator();
 
         let mut rules = app_state.css_cache.get_matching_rules_mut(&selector);
         for rule in rules.iter_mut() {
-            ui.collapsing(format!("{}", rule.selector), |ui| {
-                add_color_picker(ui, rule, "background-color");
-                add_color_picker(ui, rule, "border-color");
-                add_slider_float(ui, rule, "border-width");
-                add_slider_float(ui, rule, "line-width");
-                add_display_none(ui, rule, "display");
-            });
+            ui.label(format!("{}", rule.selector));
+            add_color_picker(ui, rule, "background-color");
+            add_color_picker(ui, rule, "border-color");
+            add_slider_float(ui, rule, "border-width");
+            add_slider_float(ui, rule, "line-width");
+            add_display_none(ui, rule, "display");
         }
     } else {
         ui.label("No Object selected");

src/bin/drawing/ui/views/stats.rs

@@ -1,23 +1,36 @@
 use egui::{Frame, Ui};
+use human_bytes::human_bytes;
+use lyon::geom::point;
+use nalgebra_glm::vec4;
+use osm::math::{num2deg, world_to_tile_space};
 
 use crate::{app_state::AppState, drawing::ui::widgets::key_value_table::widget_key_value_table};
 
 pub fn view_stats(ui: &mut Ui, app_state: &mut AppState) {
     Frame::default().outer_margin(5.0).show(ui, |ui| {
         let tile_stats = app_state.tile_cache.get_stats();
+        let z = app_state.zoom;
+        let screen_to_global = app_state.screen.pixel_to_world(z);
+        let p = screen_to_global
+            * vec4(
+                app_state.cursor().x * 2.0,
+                app_state.cursor().y * 2.0,
+                0.0,
+                0.0,
+            );
+        let latlon = num2deg(world_to_tile_space(&point(p.x, p.y), z.floor() as u32));
         let data = [
             ("mouse x", app_state.cursor().x.to_string()),
-            ("mouse y", app_state.cursor().x.to_string()),
-            ("cached tiles", format!("{}", tile_stats.cached_tiles)),
-            ("loading tiles", format!("{}", tile_stats.loading_tiles)),
-            ("objects", format!("{}", tile_stats.tile_stats.objects)),
-            ("features", format!("{}", tile_stats.tile_stats.features)),
-            ("vertices", format!("{}", tile_stats.tile_stats.vertices)),
-            ("indices", format!("{}", tile_stats.tile_stats.indices)),
-            (
-                "size",
-                human_bytes::human_bytes(tile_stats.tile_stats.size as f64),
-            ),
+            ("mouse y", app_state.cursor().y.to_string()),
+            ("mouse lat", latlon.y.to_string()),
+            ("mouse lon", latlon.x.to_string()),
+            ("cached tiles", tile_stats.cached_tiles.to_string()),
+            ("loading tiles", tile_stats.loading_tiles.to_string()),
+            ("objects", tile_stats.tile_stats.objects.to_string()),
+            ("features", tile_stats.tile_stats.features.to_string()),
+            ("vertices", tile_stats.tile_stats.vertices.to_string()),
+            ("indices", tile_stats.tile_stats.indices.to_string()),
+            ("size", human_bytes(tile_stats.tile_stats.size as f64)),
         ];
         widget_key_value_table(ui, &data);
     });

src/lib/math/mod.rs

@@ -3,7 +3,7 @@ mod tile_field;
 mod tile_id;
 
 use lyon::math::{point, vector, Point};
-use std::f32::consts::PI;
+use std::f32::consts::{E, PI};
 
 pub use screen::*;
 pub use tile_field::*;
@@ -42,6 +42,11 @@ impl EuclidVsNalgebra for Vector2 {
     }
 }
 
+/// Converts radians to degrees.
+const fn rad2deg(rad: f32) -> f32 {
+    rad * 360.0 / (2.0 * PI)
+}
+
 /// Converts degrees to radians.
 const fn deg2rad(deg: f32) -> f32 {
     2.0 * PI * deg / 360.0
@@ -56,11 +61,24 @@ pub fn deg2num(lat_deg: f32, lon_deg: f32, zoom: u32) -> TileCoordinate {
     let lat_rad = deg2rad(lat_deg);
     let n = f32::powi(2.0, zoom as i32);
     let xtile = (lon_deg + 180.0) / 360.0 * n;
-    let ytile = (1.0 - (f32::tan(lat_rad) + 1.0 / f32::ln(f32::cos(lat_rad))) / PI) / 2.0 * n;
+    let ytile = (1.0 - (PI / 4.0 + lat_rad / 2.0).tan().ln() / PI) / 2.0 * n;
 
     TileCoordinate::new(zoom, xtile, ytile)
 }
 
+/// Converts euclidian x and y coordinates into latitude and longitude.
+///
+/// This is the Mercator projection and the inverse of [`deg2num`].
+pub fn num2deg(tile: TileCoordinate) -> Point {
+    let n = f32::powi(2.0, tile.z as i32);
+
+    let lon_deg = tile.x * 360.0 / n - 180.0;
+    let lat_rad = 2.0 * (E.powf(1.0 - tile.y * 2.0 / n).atan() * PI - PI / 4.0);
+    let lat_deg = rad2deg(lat_rad);
+
+    point(lon_deg, lat_deg)
+}
+
 pub fn tile_to_world_space(coordinate: &TileCoordinate) -> Point {
     point(0.0, 0.0) + vector(coordinate.x, coordinate.y) * f32::powi(2.0, -(coordinate.z as i32))
 }