rhythm-open-exchange 0.6.2

A try to create the ffmpeg of vsrg
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

use crate::model::{Note, RoxChart};
use std::collections::HashMap;

/// Calculate chord density (polyphony) distribution.
///
/// Returns a map where:
/// - Key = Chord size (1 = Single, 2 = Jump, 3 = Hand, 4 = Quad...)
/// - Value = Count of occurrences
pub fn polyphony(chart: &RoxChart) -> HashMap<u32, u32> {
    if chart.notes.is_empty() {
        return HashMap::new();
    }

    let mut distribution = HashMap::new();
    let mut current_time: Option<i64> = None;
    let mut current_cluster_size = 0;

    let mut refs: Vec<&Note> = chart.notes.iter().collect();
    refs.sort_by_key(|n| n.time_us);

    for note in refs {
        if note.is_mine() {
            continue;
        }

        if Some(note.time_us) != current_time {
            // New cluster, commit previous one
            if current_cluster_size > 0 {
                *distribution.entry(current_cluster_size).or_insert(0) += 1;
            }
            current_time = Some(note.time_us);
            current_cluster_size = 0;
        }
        current_cluster_size += 1;
    }

    // Commit last cluster
    if current_cluster_size > 0 {
        *distribution.entry(current_cluster_size).or_insert(0) += 1;
    }

    distribution
}

/// Calculate lane usage balance.
///
/// Returns a vector of size `key_count` where index is column and value is note count.
pub fn lane_balance(chart: &RoxChart) -> Vec<u32> {
    let mut counts = vec![0; chart.key_count() as usize];

    for note in &chart.notes {
        if note.is_mine() {
            continue;
        }
        let col = note.column as usize;
        if col < counts.len() {
            counts[col] += 1;
        }
    }

    counts
}

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

    #[test]
    fn test_lane_balance() {
        let mut chart = RoxChart::new(4);
        chart.notes.push(Note::tap(0, 0));
        chart.notes.push(Note::tap(100, 0));
        chart.notes.push(Note::tap(200, 3));

        let balance = lane_balance(&chart);
        assert_eq!(balance, vec![2, 0, 0, 1]);
    }

    #[test]
    fn test_polyphony() {
        let mut chart = RoxChart::new(4);

        // Single at 0
        chart.notes.push(Note::tap(0, 0));

        // Jump at 100
        chart.notes.push(Note::tap(100, 0));
        chart.notes.push(Note::tap(100, 1));

        // Hand at 200
        chart.notes.push(Note::tap(200, 0));
        chart.notes.push(Note::tap(200, 1));
        chart.notes.push(Note::tap(200, 2));

        // Another Single at 300
        chart.notes.push(Note::tap(300, 3));

        let dist = polyphony(&chart);

        assert_eq!(dist.get(&1), Some(&2)); // 2 Singles
        assert_eq!(dist.get(&2), Some(&1)); // 1 Jump
        assert_eq!(dist.get(&3), Some(&1)); // 1 Hand
        assert_eq!(dist.get(&4), None);
    }
}