scirs2-metrics 0.3.2

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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

//! SLAM and localization metrics
//!
//! This module provides metrics for evaluating Simultaneous Localization and Mapping (SLAM)
//! systems, including localization accuracy, mapping quality, and loop closure performance.

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

use super::core::{ErrorStatistics, DriftMetrics, RealTimePerformanceMetrics};
use crate::error::Result;
use serde::{Deserialize, Serialize};
use std::time::Duration;

/// SLAM and localization metrics
#[derive(Debug, Clone)]
pub struct SlamMetrics {
    /// Localization accuracy metrics
    pub localization_metrics: LocalizationAccuracyMetrics,
    /// Mapping quality metrics
    pub mapping_metrics: MappingQualityMetrics,
    /// Loop closure metrics
    pub loop_closure_metrics: LoopClosureMetrics,
    /// Computational efficiency
    pub computational_metrics: SlamComputationalMetrics,
}

/// Localization accuracy evaluation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LocalizationAccuracyMetrics {
    /// Absolute Trajectory Error (ATE)
    pub absolute_trajectory_error: f64,
    /// Relative Pose Error (RPE)
    pub relative_pose_error: f64,
    /// Translation error statistics
    pub translation_error: ErrorStatistics,
    /// Rotation error statistics
    pub rotation_error: ErrorStatistics,
    /// Drift analysis
    pub drift_metrics: DriftMetrics,
}

/// Mapping quality evaluation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MappingQualityMetrics {
    /// Map completeness ratio
    pub completeness: f64,
    /// Map accuracy compared to ground truth
    pub map_accuracy: f64,
    /// Feature detection rate
    pub feature_detection_rate: f64,
    /// Map consistency metrics
    pub consistency_metrics: MapConsistencyMetrics,
}

/// Map consistency evaluation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MapConsistencyMetrics {
    /// Feature matching consistency
    pub feature_consistency: f64,
    /// Geometric consistency
    pub geometric_consistency: f64,
    /// Temporal consistency
    pub temporal_consistency: f64,
    /// Global consistency score
    pub global_consistency: f64,
}

/// Loop closure detection and quality metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LoopClosureMetrics {
    /// Detection rate (true positives / total loops)
    pub detection_rate: f64,
    /// False positive rate
    pub false_positive_rate: f64,
    /// Loop closure accuracy
    pub closure_accuracy: f64,
    /// Time to detect loops
    pub detection_time: Duration,
    /// Graph optimization convergence
    pub optimization_convergence: f64,
}

/// SLAM computational performance metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SlamComputationalMetrics {
    /// Float-time performance
    pub real_time_performance: RealTimePerformanceMetrics,
    /// Memory usage for maps
    pub map_memory_usage: f64,
    /// Keyframe processing time
    pub keyframe_processing_time: Duration,
    /// Graph optimization time
    pub optimization_time: Duration,
}

impl SlamMetrics {
    /// Create new SLAM metrics
    pub fn new() -> Self {
        Self {
            localization_metrics: LocalizationAccuracyMetrics::default(),
            mapping_metrics: MappingQualityMetrics::default(),
            loop_closure_metrics: LoopClosureMetrics::default(),
            computational_metrics: SlamComputationalMetrics::default(),
        }
    }
}

// Default implementations
impl Default for LocalizationAccuracyMetrics {
    fn default() -> Self {
        Self {
            absolute_trajectory_error: 0.0,
            relative_pose_error: 0.0,
            translation_error: ErrorStatistics::default(),
            rotation_error: ErrorStatistics::default(),
            drift_metrics: DriftMetrics::default(),
        }
    }
}

impl Default for MappingQualityMetrics {
    fn default() -> Self {
        Self {
            completeness: 1.0,
            map_accuracy: 1.0,
            feature_detection_rate: 1.0,
            consistency_metrics: MapConsistencyMetrics::default(),
        }
    }
}

impl Default for MapConsistencyMetrics {
    fn default() -> Self {
        Self {
            feature_consistency: 1.0,
            geometric_consistency: 1.0,
            temporal_consistency: 1.0,
            global_consistency: 1.0,
        }
    }
}

impl Default for LoopClosureMetrics {
    fn default() -> Self {
        Self {
            detection_rate: 1.0,
            false_positive_rate: 0.0,
            closure_accuracy: 1.0,
            detection_time: Duration::from_millis(0),
            optimization_convergence: 1.0,
        }
    }
}

impl Default for SlamComputationalMetrics {
    fn default() -> Self {
        Self {
            real_time_performance: RealTimePerformanceMetrics::default(),
            map_memory_usage: 0.0,
            keyframe_processing_time: Duration::from_millis(0),
            optimization_time: Duration::from_millis(0),
        }
    }
}