unique id for duplicate region names (#34)

AndGem · Sep 10, 2022 · 2e73d34 · 2e73d34
1 parent 1dcbf50
commit 2e73d34
Show file tree

Hide file tree

Showing 7 changed files with 75 additions and 80 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "osm_extract_polygon"
-version = "0.4.2"
+version = "0.4.3"
 authors = ["Andreas <[email protected]>"]
 edition = "2018"
 

diff --git a/src/converter.rs b/src/converter.rs
@@ -5,6 +5,7 @@ use crate::osm_reader::RelationNodes;
 pub struct Polygon {
     pub name: String,
     pub points: Vec<Vec<Point>>,
+    pub relation_id: i64,
 }
 
 #[derive(Clone)]
@@ -112,6 +113,8 @@ fn convert_to_poly(rn: RelationNodes) -> Polygon {
     let unknown_name = String::from("UNKNOWN_NAME");
     let empty_string = String::from("");
 
+    let relation_id: i64 = rn.relation.id.0;
+
     let name = rn
         .relation
         .tags
@@ -132,7 +135,11 @@ fn convert_to_poly(rn: RelationNodes) -> Polygon {
         name
     };
 
-    Polygon { name: fullname, points }
+    Polygon {
+        name: fullname,
+        points,
+        relation_id,
+    }
 }
 
 fn convert_nodes_to_points(nodes: &[Node]) -> Vec<Point> {

diff --git a/src/main.rs b/src/main.rs
@@ -134,7 +134,7 @@ fn main() {
 
     let relations = osm_reader::read_osm(in_filename, &min_admin_level, &max_admin_level);
     let polygons = converter::convert(relations);
-    let result = output::output_handler::write(&path, &polygons, output_handler_config);
+    let result = output::output_handler::write(path, &polygons, output_handler_config);
 
     match result {
         Ok(size) => println!("success! wrote {} files!", size),

diff --git a/src/osm_reader.rs b/src/osm_reader.rs
@@ -97,7 +97,11 @@ fn find_admin_boundary_relations(
         .map(|relation| (relation.id, relation))
         .collect();
 
-    println!("finished parsing {} relations! {}s", relation_id_to_relation.len(), now.elapsed().as_secs());
+    println!(
+        "finished parsing {} relations! {}s",
+        relation_id_to_relation.len(),
+        now.elapsed().as_secs()
+    );
     relation_id_to_relation
 }
 
@@ -155,8 +159,8 @@ fn find_nodes_for_node_ids(pbf: &mut OsmPbfReaderFile, node_ids: HashSet<NodeId>
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::iter::FromIterator;
     use osmpbfreader::Tags;
+    use std::iter::FromIterator;
 
     use smartstring::alias::String;
 
@@ -169,14 +173,20 @@ mod tests {
     #[test]
     fn test_admin_level_too_high_is_not_valid() {
         let max_admin_level = 8;
-        let relation = create_relation(vec![(String::from("admin_level"), String::from((max_admin_level + 1).to_string()))]);
+        let relation = create_relation(vec![(
+            String::from("admin_level"),
+            String::from((max_admin_level + 1).to_string()),
+        )]);
         assert_eq!(has_proper_admin_level(&relation, &1, &max_admin_level), false);
     }
 
     #[test]
     fn test_admin_level_is_max_level_is_valid() {
         let max_admin_level = 8;
-        let relation = create_relation(vec![(String::from("admin_level"), String::from((max_admin_level).to_string()))]);
+        let relation = create_relation(vec![(
+            String::from("admin_level"),
+            String::from((max_admin_level).to_string()),
+        )]);
         assert_eq!(has_proper_admin_level(&relation, &1, &max_admin_level), true);
     }
 
@@ -192,9 +202,18 @@ mod tests {
         let min_admin_level = 3;
         let max_admin_level = min_admin_level;
 
-        let relation_too_little = create_relation(vec![(String::from("admin_level"), String::from((min_admin_level - 1).to_string()))]);
-        let relation_exact = create_relation(vec![(String::from("admin_level"), String::from((min_admin_level).to_string()))]);
-        let relation_too_big = create_relation(vec![(String::from("admin_level"), String::from((min_admin_level + 1).to_string()))]);
+        let relation_too_little = create_relation(vec![(
+            String::from("admin_level"),
+            String::from((min_admin_level - 1).to_string()),
+        )]);
+        let relation_exact = create_relation(vec![(
+            String::from("admin_level"),
+            String::from((min_admin_level).to_string()),
+        )]);
+        let relation_too_big = create_relation(vec![(
+            String::from("admin_level"),
+            String::from((min_admin_level + 1).to_string()),
+        )]);
 
         assert_eq!(
             has_proper_admin_level(&relation_too_little, &min_admin_level, &max_admin_level),

diff --git a/src/output/file_writer_geojson.rs b/src/output/file_writer_geojson.rs
@@ -87,6 +87,7 @@ mod tests {
         let single_polygon = Polygon {
             name: "barfoo".to_string(),
             points: vec![vec![p1.clone(), p2.clone(), p3.clone()]],
+            relation_id: 1,
         };
 
         let result = convert_polygon_to_geo_polygons(&single_polygon);
@@ -121,6 +122,7 @@ mod tests {
                 vec![p21.clone(), p22.clone(), p23.clone()],
                 vec![p31.clone(), p32.clone(), p33.clone()],
             ],
+            relation_id: 1,
         };
 
         let result = convert_polygon_to_geo_polygons(&poly);
@@ -210,6 +212,7 @@ mod tests {
         let single_polygon = Polygon {
             name: poly_name.to_string(),
             points: vec![vec![]],
+            relation_id: 1,
         };
         let result = create_properties(&single_polygon);
 

diff --git a/src/output/output_handler.rs b/src/output/output_handler.rs
@@ -7,7 +7,7 @@ use crate::output::OverwriteConfiguration;
 use std::fs::File;
 use std::time::Instant;
 
-use std::collections::HashMap;
+use std::collections::HashSet;
 use std::fs::create_dir_all;
 
 pub trait FileWriter {
@@ -106,20 +106,27 @@ impl OutputHandler {
 fn pair_safe_filenames_and_polygons(polygons: &[Polygon]) -> Vec<(String, &Polygon)> {
     let safe_names: Vec<String> = polygons.iter().map(|p| make_safe(&p.name)).collect();
 
-    let mut duplicate_count: HashMap<String, usize> = count_duplicate_names(&safe_names);
+    let mut seen_names: HashSet<String> = HashSet::new();
+    let mut duplicate_names: HashSet<String> = HashSet::new();
+
+    safe_names.iter().for_each(|name| {
+        if seen_names.contains(&name.to_lowercase()) {
+            duplicate_names.insert(name.to_string().to_lowercase());
+        } else {
+            seen_names.insert(name.to_string().to_lowercase());
+        }
+    });
 
     safe_names
         .iter()
         .zip(polygons.iter())
         .map(|(name, p)| {
-            let out_name;
-            if duplicate_count.contains_key(&name.to_lowercase()) {
-                let val = duplicate_count.get_mut(&name.to_lowercase()).unwrap();
-                out_name = format!("{}_{}", name, val);
-                *val -= 1;
+            let out_name = if duplicate_names.contains(&name.to_lowercase()) {
+                format!("{}_{}", name, p.relation_id)
             } else {
-                out_name = name.to_string();
-            }
+                name.to_string()
+            };
+
             (out_name, p)
         })
         .collect()
@@ -131,15 +138,6 @@ fn make_safe(name: &str) -> String {
     s
 }
 
-fn count_duplicate_names(safe_names: &[String]) -> HashMap<String, usize> {
-    let mut m: HashMap<String, usize> = HashMap::new();
-    for x in safe_names {
-        *m.entry(x.to_string().to_lowercase()).or_default() += 1;
-    }
-
-    m.into_iter().filter(|&(_, v)| v != 1).collect()
-}
-
 // ////////////////////////////////////
 // ////////////////////////////////////
 // UNIT TESTS
@@ -170,47 +168,6 @@ mod tests {
         assert_eq!(result, expected);
     }
 
-    #[test]
-    fn test_count_duplicates_when_input_is_unique_return_empty_hashmap() {
-        let p1_name = String::from("abc123");
-        let p2_name = String::from("defgh1");
-        let p3_name = String::from("aaaddd");
-
-        let input = [p1_name, p2_name, p3_name];
-        let result = count_duplicate_names(&input);
-
-        assert_eq!(result, HashMap::new());
-    }
-
-    #[test]
-    fn test_count_duplicates_when_input_contains_duplicates_then_have_them_in_hashmap() {
-        let p1_name = String::from("random_name");
-        let p1_name_copy = p1_name.clone();
-        let p2_name = String::from("random_name2");
-
-        let expected: HashMap<String, usize> = [(p1_name.clone(), 2)].iter().cloned().collect();
-
-        let input = [p1_name, p2_name, p1_name_copy];
-
-        let result = count_duplicate_names(&input);
-
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_count_duplicates_when_input_contains_duplicates_then_have_them_in_hashmap_and_ignores_case() {
-        let p1_name = String::from("random_name");
-        let p1_name_copy = String::from("RandOm_NAme");
-        let p2_name = String::from("random_name2");
-
-        let expected: HashMap<String, usize> = [(p1_name.clone(), 2)].iter().cloned().collect();
-
-        let input = [p1_name, p2_name, p1_name_copy];
-
-        let result = count_duplicate_names(&input);
-
-        assert_eq!(result, expected);
-    }
     #[test]
     fn test_create_filenames_add_extensions_to_duplicate_regions() {
         let p1_name = String::from("spain_region");
@@ -219,31 +176,35 @@ mod tests {
         let p2_name = String::from("french_region");
 
         let expected = [
-            p1_name.clone() + "_3",
+            p1_name.clone() + "_100",
             p2_name.clone(),
-            p1_name.clone() + "_2",
-            p1_name.clone() + "_1",
+            p1_name.clone() + "_300",
+            p1_name.clone() + "_400",
         ]
         .to_vec();
 
         let p1 = Polygon {
             name: p1_name,
             points: Vec::new(),
+            relation_id: 100,
         };
 
         let p2 = Polygon {
             name: p2_name,
             points: Vec::new(),
+            relation_id: 200,
         };
 
         let p3 = Polygon {
             name: p1_name_clone,
             points: Vec::new(),
+            relation_id: 300,
         };
 
         let p4 = Polygon {
             name: p1_name_clone2,
             points: Vec::new(),
+            relation_id: 400,
         };
 
         let input = [p1, p2, p3, p4];
@@ -266,16 +227,19 @@ mod tests {
         let p1 = Polygon {
             name: p1_name,
             points: Vec::new(),
+            relation_id: 1,
         };
 
         let p2 = Polygon {
             name: p2_name,
             points: Vec::new(),
+            relation_id: 2,
         };
 
         let p3 = Polygon {
             name: p3_name,
             points: Vec::new(),
+            relation_id: 3,
         };
 
         let input = [p1, p2, p3];
@@ -292,16 +256,18 @@ mod tests {
         let p1_name = String::from("spanish_region");
         let p2_name = String::from("SPAniSh_RegION");
 
-        let expected = [p1_name.clone() + "_2", p2_name.clone() + "_1"];
+        let expected = [p1_name.clone() + "_123", p2_name.clone() + "_456"];
 
         let p1 = Polygon {
             name: p1_name,
             points: Vec::new(),
+            relation_id: 123,
         };
 
         let p2 = Polygon {
             name: p2_name,
             points: Vec::new(),
+            relation_id: 456,
         };
 
         let input = [p1, p2];