Merge pull request #7 from NREL/rjf/cleanup

Rjf/cleanup

Author: robfitzgerald

rust/bambam-osm/src/algorithm/buffer.rs

@@ -1,14 +1,9 @@
-use std::borrow::Cow;
-
-use geo::line_measures::LengthMeasurable;
 use geo::{
-    line_string, Centroid, Convert, Coord, CoordFloat, Destination, Distance, GeoFloat, Geometry,
-    Haversine, KNearestConcaveHull, Length, LineString, Point, Polygon, Scale, TryConvert,
+    line_string, Centroid, Coord, CoordFloat, Destination, GeoFloat, Geometry, Haversine,
+    KNearestConcaveHull, Length, LineString, Point, Polygon, Scale,
 };
 use itertools::Itertools;
 use num_traits::FromPrimitive;
-use routee_compass_core::model::unit;
-use routee_compass_core::model::unit::AsF64;
 
 pub trait Buffer<F: CoordFloat + FromPrimitive> {
     /// buffer a geometry up to some distance. GEOS uses a fancier method to determine

rust/bambam-osm/src/algorithm/clustering/clustering_rtree.rs

@@ -1,24 +1,13 @@
-use super::ClusteredGeometry;
-use crate::algorithm::bfs_undirected;
-use crate::model::osm::graph::OsmGraph;
 use crate::model::osm::graph::OsmNodeId;
-use crate::model::osm::OsmError;
-use geo::{BooleanOps, BoundingRect, Geometry, Intersects, Polygon, RemoveRepeatedPoints};
-use geo::{Coord, MultiPolygon};
+
+use super::ClusteredGeometry;
+use geo::{BoundingRect, Coord, Polygon};
 use itertools::Itertools;
-use kdam::{tqdm, Bar, BarExt};
-use rayon::prelude::*;
-use routee_compass_core::model::unit::AsF64;
-use routee_compass_core::model::unit::DistanceUnit;
+use kdam::tqdm;
 use rstar::primitives::{GeomWithData, Rectangle};
 use rstar::{RTree, RTreeObject};
-use std::collections::HashSet;
-use std::collections::{BinaryHeap, HashMap};
-use std::sync::Arc;
-use std::sync::Mutex;
 use wkt::ToWkt;
 
-pub type ClusterLabel = usize;
 pub type ClusteredIntersections = GeomWithData<Rectangle<(f32, f32)>, ClusteredGeometry>;
 
 /// build an undirected graph of node geometries that intersect spatially.
@@ -75,197 +64,6 @@ pub fn build(
     Ok(rtree)
 }
 
-// /// merges two geometries by Union that should be either Polygon or MultiPolygon geometries.
-// fn merge_areal_geometries(a: &Geometry, b: &Geometry) -> Result<Geometry, String> {
-//     let unioned: MultiPolygon = match (a, b) {
-//         (Geometry::Polygon(a), Geometry::Polygon(b)) => Ok(a.union(b)),
-//         (Geometry::Polygon(p), Geometry::MultiPolygon(mp)) => Ok(p.union(mp)),
-//         (Geometry::MultiPolygon(mp), Geometry::Polygon(p)) => Ok(mp.union(p)),
-//         (Geometry::MultiPolygon(a), Geometry::MultiPolygon(b)) => Ok(a.union(b)),
-//         _ => Err(format!(
-//             "invalid geometry types \n{} \n{}",
-//             a.to_wkt(),
-//             b.to_wkt()
-//         )),
-//     }?;
-//     // Ok(geo::Geometry::MultiPolygon(unioned))
-//     // let cleaned = unioned.union(&geo::MultiPolygon::new(vec![]));
-
-//     let exteriors = unioned
-//         .remove_repeated_points()
-//         .iter()
-//         .map(|p| Polygon::new(p.exterior().clone(), vec![]))
-//         .collect_vec();
-//     let no_holes = MultiPolygon::new(exteriors);
-//     Ok(geo::Geometry::MultiPolygon(no_holes))
-// }
-
-// /// in order to simplify the graph, we have to identify nodes that are within
-// /// some distance threshold of each other and then also confirm that they are
-// /// connected in the graph space (for example, a bridge may not be connected to
-// /// the roads beneath it).
-// ///
-// /// # Arguments
-// /// * `indices` - a collection of entity indices that should correspond to
-// ///               the indices of the undirected graph. can be the complete
-// ///               collection of indices to find all components, or a subset
-// ///               in order to identify the disjoint union of sub-subsets that
-// ///               are connected through the undirected graph.
-// /// * `undirected_graph` - all valid indices and their connections. in the
-// ///                        context of OSM import, this may be the graph of
-// ///                        spatial intersections or the graph of network
-// ///                        connections.
-// ///
-// /// # Returns
-// ///
-// /// A vector of components, each represented as a set of indices.
-// pub fn connected_components_clustering(
-//     indices: &[OsmNodeId],
-//     undirected_graph: &[Vec<OsmNodeId>],
-// ) -> Result<Vec<HashSet<OsmNodeId>>, OsmError> {
-//     // handle base cases
-//     match *indices {
-//         [] => return Ok(vec![]),
-//         [singleton] => return Ok(vec![HashSet::from([singleton])]),
-//         _ => {}
-//     };
-//     // connected components (undirected graph)
-//     // run breadth-first searches from indices that have not yet been assigned a label.
-//     // labels found in the search become part of the next cluster.
-//     let mut clusters: Vec<HashSet<OsmNodeId>> = vec![];
-//     let mut unassigned = indices
-//         .iter()
-//         .map(|idx| (*idx, true))
-//         .collect::<HashMap<_, _>>();
-
-//     let valid_set = indices.iter().collect::<HashSet<_>>();
-
-//     let cc_iter = tqdm!(
-//         indices.iter(),
-//         total = unassigned.len(),
-//         desc = "connected components"
-//     );
-//     for label in cc_iter {
-//         if unassigned[label] {
-//             // found a label that is unassigned. begin the next cluster.
-//             let next_cluster: HashSet<usize> =
-//                 bfs_undirected(*label, undirected_graph, &Some(valid_set)).map_err(|e| {
-//                     OsmError::GraphConsolidationError(format!(
-//                         "failure executing graph search for connected components: {}",
-//                         e
-//                     ))
-//                 })?;
-
-//             // for each clustered geometry index, label it assigned and add it to this cluster
-//             for index in next_cluster.iter() {
-//                 unassigned.entry(*index).and_modify(|val| {
-//                     *val = false;
-//                 });
-//             }
-
-//             clusters.push(next_cluster);
-//         }
-//     }
-//     eprintln!();
-//     Ok(clusters)
-// }
-
-// /// a succession of intersection tests, in increasing order of computational complexity,
-// /// for finding geometric intersections.
-// fn geometries_intersect(
-//     a: (usize, &Geometry),
-//     b: (usize, &Geometry),
-//     // ns: &Vec<HashSet<usize>>,  // todo!: reintroduce this argument, respecting Arc<Mutex<T>>
-// ) -> bool {
-//     let (a_label, a_geom) = a;
-//     let (b_label, b_geom) = b;
-
-//     // simple identifier test. dismiss when row == column on the matrix.
-//     if a_label == b_label {
-//         log::debug!(
-//             "geometries {},{} intersect? TRUE - matching label",
-//             a_label,
-//             b_label
-//         );
-//         return false;
-//     }
-
-//     // // did we already find a from b?
-//     // let a_has_already_found_b = ns
-//     //     .get(a_label)
-//     //     .ok_or_else(|| out_of_index_err(b_label, ns))?
-//     //     .contains(&b_label);
-//     // if a_has_already_found_b {
-//     //     return false;
-//     // }
-
-//     // first geometric test, only using bounding boxes.
-//     if bbox_intersects(a_geom, b_geom) {
-//         log::debug!(
-//             "geometries {},{} intersect? TRUE - bboxes intersect",
-//             a_label,
-//             b_label
-//         );
-//         return true;
-//     }
-
-//     // final test is a true geometric intersection test (expensive).
-//     let geometries_intersect = a_geom.intersects(b_geom);
-//     if geometries_intersect {
-//         log::debug!(
-//             "geometries {},{} intersect? TRUE - matching label",
-//             a_label,
-//             b_label
-//         );
-//         return true;
-//     } else {
-//         log::debug!("geometries {},{} intersect? FALSE", a_label, b_label);
-//         return false;
-//     }
-// }
-
-// fn bbox_intersects(a: &Geometry, b: &Geometry) -> bool {
-//     let a_box = match a.bounding_rect() {
-//         Some(bbox) => bbox,
-//         None => return false,
-//     };
-//     let b_box = match b.bounding_rect() {
-//         Some(bbox) => bbox,
-//         None => return false,
-//     };
-//     a_box.intersects(&b_box)
-// }
-
-// fn out_of_index_err(label: usize, ns: &[Vec<usize>]) -> String {
-//     format!(
-//         "neighbors expected to have index {} but only has {} elements",
-//         label,
-//         ns.len()
-//     )
-// }
-
-// /// finds the set of indices that are part of the same geometry cluster
-// /// using a breadth-first search over an undirected graph of geometry
-// /// intersection relations.
-// fn bfs(src: usize, ns: &[Vec<usize>]) -> Result<HashSet<usize>, String> {
-//     let mut visited: HashSet<usize> = HashSet::new();
-//     visited.insert(src);
-//     let mut frontier: BinaryHeap<(usize, i32)> = BinaryHeap::new();
-//     frontier.push((src, 0));
-//     while let Some((next_id, next_depth)) = frontier.pop() {
-//         visited.insert(next_id);
-//         let next_neighbors = ns
-//             .get(next_id)
-//             .ok_or_else(|| out_of_index_err(next_id, ns))?;
-//         for neighbor in next_neighbors.iter() {
-//             if !visited.contains(neighbor) {
-//                 frontier.push((*neighbor, next_depth - 1)); // max heap
-//             }
-//         }
-//     }
-//     Ok(visited)
-// }
-
 /// helper function to create a rectangular rtree envelope for a given geometry
 fn rect_from_geometries(ps: &[&Polygon<f32>]) -> Result<Rectangle<(f32, f32)>, String> {
     if ps.is_empty() {

rust/bambam-osm/src/algorithm/clustering/mod.rs

@@ -2,4 +2,4 @@ mod clustered_geometry;
 mod clustering_rtree;
 
 pub use clustered_geometry::ClusteredGeometry;
-pub use clustering_rtree::{build, ClusterLabel, ClusteredIntersections};
+pub use clustering_rtree::{build, ClusteredIntersections};

rust/bambam-osm/src/algorithm/connected_components.rs

@@ -1,18 +1,11 @@
 use crate::model::osm::{
-    graph::{
-        AdjacencyDirection, AdjacencyList, AdjacencyListDeprecated, OsmGraph, OsmNodeId, OsmNodes,
-    },
+    graph::{OsmGraph, OsmNodeId},
     OsmError,
 };
 use itertools::Itertools;
 use kdam::{tqdm, Bar, BarExt};
-use std::{
-    collections::{HashMap, HashSet, VecDeque},
-    io::Write,
-    time::Duration,
-};
+use std::collections::{HashMap, HashSet, VecDeque};
 
-const PROGRESS_BAR_MIN_SIZE: usize = 1000;
 pub type UndirectedAdjacencyList = HashMap<OsmNodeId, HashSet<OsmNodeId>>;
 
 pub fn to_undirected(graph: &OsmGraph) -> UndirectedAdjacencyList {
@@ -83,7 +76,7 @@ pub fn weakly_connected_components(
             }
             solution.push(cluster);
         }
-        bar.update(1);
+        let _ = bar.update(1);
     }
     eprintln!();
     log::info!("found {} weakly-connected components", solution.len());
@@ -133,11 +126,7 @@ pub fn bfs_undirected(
 
 #[cfg(test)]
 mod tests {
-    use crate::model::osm::graph::{
-        osm_segment::OsmSegment, AdjacencyDirection, AdjacencyList, AdjacencyList3,
-        AdjacencyListDeprecated, OsmGraph, OsmNodeData, OsmNodeId, OsmWayData, OsmWayId,
-        OsmWaysByOd,
-    };
+    use crate::model::osm::graph::{OsmGraph, OsmNodeData, OsmNodeId, OsmWayData, OsmWayId};
     use std::collections::HashMap;
 
     #[test]
@@ -182,7 +171,7 @@ mod tests {
     fn test_bfs_complete_graph_5() {
         let source = OsmNodeId(0);
         let n_connected_nodes: usize = 5;
-        let mut nodes = create_nodes_in_circle(n_connected_nodes);
+        let nodes = create_nodes_in_circle(n_connected_nodes);
         let mut ways: HashMap<OsmWayId, OsmWayData> = HashMap::new();
 
         let n_iters = n_connected_nodes as i64;

rust/bambam-osm/src/algorithm/consolidation/consolidation_ops.rs

@@ -3,28 +3,20 @@ use crate::algorithm::*;
 use crate::model::osm::graph::AdjacencyDirection;
 use crate::model::osm::graph::OsmNodeData;
 use crate::model::osm::graph::OsmWayData;
-use crate::model::osm::graph::{fill_value_lookup::FillValueLookup, OsmGraph, OsmNodeId};
-use crate::model::osm::graph::{AdjacencyListDeprecated, OsmWayId};
+use crate::model::osm::graph::OsmWayId;
+use crate::model::osm::graph::{OsmGraph, OsmNodeId};
 use crate::model::osm::OsmError;
 use clustering::ClusteredIntersections;
-use geo::{BooleanOps, BoundingRect, Intersects, Polygon, RemoveRepeatedPoints};
-use geo::{Coord, Geometry, Haversine, Length, LineString, MultiPolygon};
+use geo::Polygon;
+use geo::{Coord, Geometry};
 use itertools::Itertools;
 use kdam::{term, tqdm, Bar, BarExt};
 use rayon::prelude::*;
-use routee_compass_core::model::{
-    network::{Edge, Vertex},
-    unit::{AsF64, DistanceUnit, SpeedUnit},
-};
-use rstar::primitives::{GeomWithData, Rectangle};
-use rstar::{RTree, RTreeObject};
+use rstar::RTree;
+use std::collections::HashMap;
 use std::collections::HashSet;
-use std::collections::LinkedList;
-use std::collections::{BinaryHeap, HashMap};
-use std::fs::File;
 use std::sync::Arc;
 use std::sync::Mutex;
-use wkt::ToWkt;
 
 /// implements osmnx.simplification.consolidate_intersections with dead_ends=False, rebuild_graph=True,
 /// reconnect_edges=True for the given distance tolerance.
@@ -41,7 +33,6 @@ use wkt::ToWkt;
 pub fn consolidate_graph(
     graph: &mut OsmGraph,
     tolerance: uom::si::f64::Length,
-    ignore_osm_parsing_errors: bool,
 ) -> Result<(), OsmError> {
     // STEP 1
     // buffer nodes to passed-in distance and merge overlaps. turn merged nodes
@@ -171,17 +162,17 @@ pub fn buffer_nodes(
     result
 }
 
-fn get_fill_value(
-    way: &OsmWayData,
-    maxspeeds_fill_lookup: &FillValueLookup,
-) -> Result<uom::si::f64::Velocity, OsmError> {
-    let highway_class = way
-        .get_string_at_field("highway")
-        .map_err(OsmError::GraphConsolidationError)?;
-    let avg_speed = maxspeeds_fill_lookup.get(&highway_class);
-    let result = uom::si::f64::Velocity::new::<uom::si::velocity::kilometer_per_hour>(avg_speed);
-    Ok(result)
-}
+// fn get_fill_value(
+//     way: &OsmWayData,
+//     maxspeeds_fill_lookup: &FillValueLookup,
+// ) -> Result<uom::si::f64::Velocity, OsmError> {
+//     let highway_class = way
+//         .get_string_at_field("highway")
+//         .map_err(OsmError::GraphConsolidationError)?;
+//     let avg_speed = maxspeeds_fill_lookup.get(&highway_class);
+//     let result = uom::si::f64::Velocity::new::<uom::si::velocity::kilometer_per_hour>(avg_speed);
+//     Ok(result)
+// }
 
 /// with knowledge of which geometry indices contain spatially-similar nodes,
 /// constructs new merged node data for the connected sub-clusters, assigning

rust/bambam-osm/src/algorithm/consolidation/way_consolidation.rs

@@ -1,10 +1,4 @@
-use crate::model::osm::{
-    graph::{AdjacencyDirection, OsmGraph, OsmNodeId, OsmWayData},
-    OsmError,
-};
-use itertools::Itertools;
-use serde_json::value::Index;
-use std::collections::HashSet;
+use crate::model::osm::graph::{AdjacencyDirection, OsmNodeId, OsmWayData};
 
 /// tracks a way that will be impacted by node consolidation along with the
 /// source or destination node attached to it.

rust/bambam-osm/src/algorithm/search.rs

@@ -1,5 +1,5 @@
 use crate::model::osm::{
-    graph::{AdjacencyDirection, OsmGraph, OsmNodeId},
+    graph::{OsmGraph, OsmNodeId},
     OsmError,
 };
 use itertools::Itertools;