pelorus 0.1.0

A high-performance GPS map-matching library for geospatial road network processing
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use super::types::{RoadNetwork, SpatialSegment};
use crate::types::{CandidatePoint, RoadSegment, SegmentId};
use geo::{algorithm::euclidean_distance::EuclideanDistance, Point};
use rstar::PointDistance;

pub struct ProjectionResult {
    pub projected_point: Point<f64>,
    pub distance: f64,
}

impl RoadNetwork {
    pub fn query_segments_near(
        &self,
        point: Point<f64>,
        radius: f64,
    ) -> Vec<&RoadSegment> {
        let query_point = [point.x(), point.y()];

        let nearby_spatial_segments: Vec<&SpatialSegment> = self
            .spatial_index
            .locate_within_distance(query_point, radius * radius) // rstar uses squared distance
            .collect();

        nearby_spatial_segments
            .into_iter()
            .filter_map(|spatial_segment| {
                self.segments.get(&spatial_segment.segment_id)
            })
            .collect()
    }

    pub fn project_point_to_segment(
        &self,
        segment_id: SegmentId,
        point: Point<f64>,
    ) -> Option<ProjectionResult> {
        let segment = self.segments.get(&segment_id)?;

        // Create a temporary CandidatePoint to use existing projection logic
        let candidate = CandidatePoint {
            segment_id,
            segment,
            gps_point: point,
        };

        match candidate.projected_point() {
            Ok(projected) => {
                let distance = candidate.distance_to_gps();
                Some(ProjectionResult {
                    projected_point: projected,
                    distance,
                })
            }
            Err(_) => None,
        }
    }
}

impl PointDistance for SpatialSegment {
    fn distance_2(&self, point: &[f64; 2]) -> f64 {
        let query_point = Point::new(point[0], point[1]);
        let center_coord = self.bounding_box.center();
        let center_point = Point::from(center_coord);
        center_point.euclidean_distance(&query_point).powi(2)
    }
}