rosu-pp 4.0.1

Difficulty and performance calculation for osu!
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

use std::collections::HashMap;

use crate::{taiko::difficulty::object::TaikoDifficultyObject, util::sync::Weak};

pub struct DeltaTimeNormalizer;

impl DeltaTimeNormalizer {
    pub fn normalize(
        hit_objects: &[Weak<TaikoDifficultyObject>],
        margin_of_error: f64,
    ) -> HashMap<Weak<TaikoDifficultyObject>, f64> {
        let delta_times = {
            let mut distinct_and_ordered: Vec<f64> = Vec::new();

            for h in hit_objects.iter() {
                let Some(h) = h.upgrade() else { continue };
                let delta_time = h.get().delta_time;

                if let Err(idx) =
                    distinct_and_ordered.binary_search_by(|probe| probe.total_cmp(&delta_time))
                {
                    distinct_and_ordered.insert(idx, delta_time);
                }
            }

            distinct_and_ordered
        };

        let mut sets = Vec::new();
        let mut delta_times_iter = delta_times.into_iter();

        if let Some(value) = delta_times_iter.next() {
            let mut curr = vec![value];

            for value in delta_times_iter {
                // * Add to the current group if within margin of error
                if f64::abs(value - curr[0]) <= margin_of_error {
                    curr.push(value);

                    continue;
                }

                sets.push(curr);

                // * Otherwise begin a new group
                curr = vec![value];
            }

            sets.push(curr);
        }

        // * Compute median for each group
        let mut median_lookup = HashMap::new();

        for mut set in sets {
            set.sort_by(f64::total_cmp);
            let mid = set.len() / 2;

            let median = if set.len() % 2 == 1 {
                set[mid]
            } else {
                (set[mid - 1] + set[mid]) / 2.0
            };

            for v in set {
                median_lookup.insert(v.to_bits(), median);
            }
        }

        let mut output = HashMap::with_capacity(hit_objects.len());

        let iter = hit_objects.iter().filter_map(|h| {
            let delta_time = h.upgrade()?.get().delta_time;

            let value = median_lookup
                .get(&delta_time.to_bits())
                .copied()
                .unwrap_or(delta_time);

            Some((Weak::clone(h), value))
        });

        output.extend(iter);

        output
    }
}