routee-compass-core 0.3.0

The core routing algorithms and data structures of the RouteE-Compass energy-aware routing engine
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
67
68

use crate::model::traversal::traversal_result::TraversalResult;
use crate::model::{
    cost::cost::Cost,
    property::{edge::Edge, vertex::Vertex},
    traversal::{
        state::{state_variable::StateVar, traversal_state::TraversalState},
        traversal_model::TraversalModel,
        traversal_model_error::TraversalModelError,
    },
};
use crate::util::geo::haversine::coord_distance;
use crate::util::unit::DistanceUnit;
use crate::util::unit::BASE_DISTANCE_UNIT;

/// A simple traversal model that uses the edge distance as the cost of traversal.
pub struct DistanceModel {
    distance_unit: DistanceUnit,
}

impl DistanceModel {
    pub fn new(distance_unit: DistanceUnit) -> DistanceModel {
        DistanceModel { distance_unit }
    }
}

impl TraversalModel for DistanceModel {
    fn initial_state(&self) -> TraversalState {
        vec![StateVar(0.0)]
    }
    fn traversal_cost(
        &self,
        _src: &Vertex,
        edge: &Edge,
        _dst: &Vertex,
        state: &Vec<StateVar>,
    ) -> Result<TraversalResult, TraversalModelError> {
        let distance = BASE_DISTANCE_UNIT.convert(edge.distance, self.distance_unit.clone());
        let mut updated_state = state.clone();
        updated_state[0] = state[0] + StateVar::from(distance);
        let result = TraversalResult {
            total_cost: Cost::from(distance),
            updated_state,
        };
        Ok(result)
    }
    fn cost_estimate(
        &self,
        src: &Vertex,
        dst: &Vertex,
        _state: &TraversalState,
    ) -> Result<Cost, TraversalModelError> {
        return coord_distance(src.coordinate, dst.coordinate, self.distance_unit.clone())
            .map(|d| Cost::from(d))
            .map_err(TraversalModelError::NumericError);
    }
    fn serialize_state(&self, state: &TraversalState) -> serde_json::Value {
        let total_distance = state[0].0;
        serde_json::json!({
            "distance": total_distance
        })
    }

    fn serialize_state_info(&self, _state: &TraversalState) -> serde_json::Value {
        serde_json::json!({
            "distance_unit": self.distance_unit
        })
    }
}