[pre] add grid to output, fill grid with node ids [web] add grid to input and graph

Author: matejetz

pre/src/main.rs

@@ -15,6 +15,8 @@ use std::path::Path;
 
 // 2^18
 const COST_MULTIPLICATOR: usize = 262144;
+// First three digits of coordinates are used for the grid hashing
+const GRID_MULTIPLICATOR: usize = 100;
 
 #[derive(Serialize, Debug, Clone)]
 struct Way {
@@ -36,6 +38,7 @@ struct Output {
     nodes: Vec<Node>,
     ways: Vec<Way>,
     offset: Vec<usize>,
+    grid: HashMap<(usize, usize), Vec<usize>>
 }
 
 fn parse_speed(max_speed: &str, highway: &str) -> usize {
@@ -96,6 +99,8 @@ fn main() {
     let mut ways = Vec::<Way>::new();
     let mut nodes = Vec::<Node>::new();
     let mut offset = Vec::<usize>::new();
+    // stores node ids for a 2d grid e.g. (1,1) = [1,2,3,..]
+    let mut grid = HashMap::<(usize, usize), Vec<usize>>::new();
 
     let mut amount_nodes = 0;
 
@@ -191,9 +196,25 @@ fn main() {
                 // check if node in osm_id_mapping
                 match osm_id_mapping.get(&node.id.0) {
                     Some(our_id) => {
+                        let latitude = node.decimicro_lat as f32 / 10_000_000.0;
+                        let longitude = node.decimicro_lon as f32 / 10_000_000.0;
                         nodes[*our_id] = Node {
-                            latitude: node.decimicro_lat as f32 / 10000000.0,
-                            longitude: node.decimicro_lon as f32 / 10000000.0,
+                            // https://github.com/rust-lang/rfcs/blob/master/text/1682-field-init-shorthand.md
+                            latitude,
+                            longitude,
+                        };
+                        let lat_grid = (latitude * GRID_MULTIPLICATOR as f32) as i32;
+                        let lng_grid = (longitude * GRID_MULTIPLICATOR as f32) as i32;
+                        let current_grid = grid.get_mut(&(lat_grid as usize, lng_grid as usize));
+                        match current_grid {
+                            Some(id_list) => {
+                                id_list.push(*our_id);
+                            },
+                            None => {
+                                let mut new_id_list = Vec::<usize>::new();
+                                new_id_list.push(*our_id);
+                                grid.insert((lat_grid as usize, lng_grid as usize), new_id_list);
+                            }
                         }
                     }
                     None => continue,
@@ -233,9 +254,10 @@ fn main() {
 
     // serialize everything
     let result = Output {
-        nodes: nodes,
-        ways: ways,
-        offset: offset,
+        nodes,
+        ways,
+        offset,
+        grid
     };
 
     let output_file = format!("{}{}", filename.into_string().unwrap(), ".fmi");

web/src/graph.rs

@@ -1,19 +1,22 @@
 // based on https://rosettacode.org/wiki/Dijkstra%27s_algorithm#Rust
 use std::cmp::Ordering;
-use std::collections::BinaryHeap;
+use std::collections::{BinaryHeap, HashMap};
 use std::usize;
 
 use Node;
 use Way;
 
 // 2^18
 const COST_MULTIPLICATOR: usize = 262144;
+// First three digits of coordinates are used for the grid hashing
+const GRID_MULTIPLICATOR: usize = 100;
 
 #[derive(Clone)]
 pub struct Graph {
     nodes: Vec<Node>,
     ways: Vec<Way>,
     offset: Vec<usize>,
+    grid: HashMap<(usize, usize), Vec<usize>>
 }
 
 #[derive(Copy, Clone, Eq, PartialEq)]
@@ -34,16 +37,19 @@ impl PartialOrd for State {
 }
 
 impl Graph {
-    pub fn new(nodes: Vec<Node>, ways: Vec<Way>, offset: Vec<usize>) -> Self {
+    pub fn new(nodes: Vec<Node>, ways: Vec<Way>, offset: Vec<usize>, grid: HashMap<(usize, usize), Vec<usize>>) -> Self {
         Graph {
-            nodes: nodes,
-            ways: ways,
-            offset: offset,
+            nodes,
+            ways,
+            offset,
+            grid
         }
     }
 
     /// returns closes point of given long & lat
     pub fn get_point_id(&self, lat: f32, long: f32) -> usize {
+        let lat_grid = (lat * GRID_MULTIPLICATOR as f32) as i32;
+        let lng_grid = (long * GRID_MULTIPLICATOR as f32) as i32;
         let mut min_distance: f32 = std::f32::MAX;
         let mut min_distance_id: usize = 0;
 
@@ -75,6 +81,10 @@ impl Graph {
         }
     }
 
+    fn get_adjacent_grids(current_grid: (usize, usize), grid: &HashMap<(usize, usize), Vec<usize>>) {
+
+    }
+
     /// executes dijkstra
     pub fn find_path(
         &self,

web/src/main.rs

@@ -15,6 +15,7 @@ use std::fs::File;
 use std::io::BufReader;
 use std::path::Path;
 use std::time::Instant;
+use std::collections::HashMap;
 
 #[derive(Copy, Clone, Deserialize, Debug)]
 pub struct Way {
@@ -36,6 +37,7 @@ struct Input {
     nodes: Vec<Node>,
     ways: Vec<Way>,
     offset: Vec<usize>,
+    grid: HashMap<(usize, usize), Vec<usize>>
 }
 
 #[derive(Debug, Deserialize, Serialize)]