oximedia-mir 0.1.8

Music Information Retrieval (MIR) system for OxiMedia
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

//! Rhythm pattern extraction.

use crate::types::RhythmPattern as RhythmPatternType;

/// Rhythm pattern extractor.
pub struct RhythmPattern;

impl RhythmPattern {
    /// Create a new rhythm pattern extractor.
    #[must_use]
    pub fn new() -> Self {
        Self
    }

    /// Extract rhythm patterns from onset times.
    #[must_use]
    pub fn extract(&self, onset_times: &[f32]) -> Vec<RhythmPatternType> {
        let mut patterns = Vec::new();

        // Find repeating interval patterns
        for window_size in [4, 8, 16] {
            if onset_times.len() < window_size {
                continue;
            }

            for i in 0..onset_times.len().saturating_sub(window_size) {
                let window = &onset_times[i..i + window_size];
                let pattern = self.analyze_window(window);

                if pattern.strength > 0.5 {
                    patterns.push(pattern);
                }
            }
        }

        patterns
    }

    /// Analyze a window of onsets for patterns.
    fn analyze_window(&self, window: &[f32]) -> RhythmPatternType {
        if window.len() < 2 {
            return RhythmPatternType {
                start: 0.0,
                duration: 0.0,
                description: "none".to_string(),
                strength: 0.0,
            };
        }

        let start = window[0];
        let duration = window[window.len() - 1] - window[0];

        // Compute interval regularity
        let mut intervals = Vec::new();
        for i in 1..window.len() {
            intervals.push(window[i] - window[i - 1]);
        }

        let mean_interval = crate::utils::mean(&intervals);
        let std_dev = crate::utils::std_dev(&intervals);

        // Pattern strength based on regularity
        let strength = if mean_interval > 0.0 {
            1.0 - (std_dev / mean_interval).min(1.0)
        } else {
            0.0
        };

        let description = if strength > 0.7 {
            "regular".to_string()
        } else if strength > 0.4 {
            "semi-regular".to_string()
        } else {
            "irregular".to_string()
        };

        RhythmPatternType {
            start,
            duration,
            description,
            strength,
        }
    }
}

impl Default for RhythmPattern {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_rhythm_pattern_creation() {
        let _pattern = RhythmPattern::new();
    }

    #[test]
    fn test_extract_patterns() {
        let pattern = RhythmPattern::new();
        let onset_times = vec![0.0, 0.5, 1.0, 1.5, 2.0];
        let patterns = pattern.extract(&onset_times);
        assert!(!patterns.is_empty());
    }
}