scirs2-metrics 0.3.0

Machine Learning evaluation metrics module for SciRS2 (scirs2-metrics)
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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! Navigation and path planning metrics
//!
//! This module provides metrics for evaluating robotic navigation systems,
//! including path planning, obstacle avoidance, and goal-reaching performance.

#![allow(clippy::too_many_arguments)]
#![allow(dead_code)]

use super::core::{TrajectoryPoint, Pose, BoundingBox};
use crate::error::Result;
use serde::{Deserialize, Serialize};
use std::time::Duration;

/// Navigation system evaluation metrics
#[derive(Debug, Clone)]
pub struct NavigationMetrics {
    /// Path planning performance
    pub path_planning: PathPlanningMetrics,
    /// Obstacle avoidance metrics
    pub obstacle_avoidance: ObstacleAvoidanceMetrics,
    /// Goal reaching performance
    pub goal_reaching: GoalReachingMetrics,
    /// Dynamic adaptation capabilities
    pub dynamic_adaptation: DynamicAdaptationMetrics,
}

/// Path planning evaluation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PathPlanningMetrics {
    /// Planning success rate
    pub success_rate: f64,
    /// Planning time
    pub planning_time: Duration,
    /// Path optimality (length ratio to optimal)
    pub path_optimality: f64,
    /// Path smoothness score
    pub smoothness: f64,
    /// Computational efficiency
    pub computational_efficiency: f64,
}

/// Obstacle avoidance performance
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ObstacleAvoidanceMetrics {
    /// Collision avoidance success rate
    pub collision_avoidance_rate: f64,
    /// Minimum clearance distance
    pub min_clearance: f64,
    /// Average clearance distance
    pub avg_clearance: f64,
    /// Reaction time to new obstacles
    pub reaction_time: Duration,
    /// Path deviation due to avoidance
    pub path_deviation: f64,
}

/// Goal reaching performance
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GoalReachingMetrics {
    /// Success rate
    pub success_rate: f64,
    /// Final position accuracy
    pub position_accuracy: f64,
    /// Final orientation accuracy
    pub orientation_accuracy: f64,
    /// Time to reach goal
    pub completion_time: Duration,
    /// Energy efficiency
    pub energy_efficiency: f64,
}

/// Dynamic adaptation capabilities
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DynamicAdaptationMetrics {
    /// Response time to environmental changes
    pub adaptation_time: Duration,
    /// Replanning frequency
    pub replanning_frequency: f64,
    /// Adaptation success rate
    pub adaptation_success_rate: f64,
    /// Robustness to disturbances
    pub disturbance_robustness: f64,
}

impl NavigationMetrics {
    /// Create new navigation metrics
    pub fn new() -> Self {
        Self {
            path_planning: PathPlanningMetrics::default(),
            obstacle_avoidance: ObstacleAvoidanceMetrics::default(),
            goal_reaching: GoalReachingMetrics::default(),
            dynamic_adaptation: DynamicAdaptationMetrics::default(),
        }
    }
}

// Default implementations
impl Default for PathPlanningMetrics {
    fn default() -> Self {
        Self {
            success_rate: 1.0,
            planning_time: Duration::from_millis(0),
            path_optimality: 1.0,
            smoothness: 1.0,
            computational_efficiency: 1.0,
        }
    }
}

impl Default for ObstacleAvoidanceMetrics {
    fn default() -> Self {
        Self {
            collision_avoidance_rate: 1.0,
            min_clearance: 0.0,
            avg_clearance: 0.0,
            reaction_time: Duration::from_millis(0),
            path_deviation: 0.0,
        }
    }
}

impl Default for GoalReachingMetrics {
    fn default() -> Self {
        Self {
            success_rate: 1.0,
            position_accuracy: 0.0,
            orientation_accuracy: 0.0,
            completion_time: Duration::from_secs(0),
            energy_efficiency: 1.0,
        }
    }
}

impl Default for DynamicAdaptationMetrics {
    fn default() -> Self {
        Self {
            adaptation_time: Duration::from_millis(0),
            replanning_frequency: 0.0,
            adaptation_success_rate: 1.0,
            disturbance_robustness: 1.0,
        }
    }
}