Use more specific don/ka types when writing to fumen (ド, コ, ドン, カッ, カ)

[vivaria]

Since TJA files use only a single number to represent dons and kas (1 and 2 respectively), I have only been writing a single type of don/ka to the converted .bin file.

However, official fumens actually have 3 types of dons and 2 types of kas. And, different types will be used depending on how the dons and kas are grouped together:

Theoretically, my converter could track if a note is part of a triplet/quad/etc. and write the different notes accordingly. But, it might be quite tricky to programmatically detect groupings of notes.

Maybe what I could do is track "time since last note". If the time decreases (i.e. notes are closer together), we enter a "grouping". If the time stays the same, then we're still within the grouping. If the time increases (i.e. notes are further apart), we have exited the grouping. But, I don't know how foolproof that is if we consider BPMCHANGE commands, etc. 🤔

[vivaria]

I assume that the logic goes like this:

This was mostly wrong -- see PR for the real logic

• Single notes just use ド (do) and カ (ka)
• Groupings of 2 or more will always end on ドン (don) and カッ (ka~tsu)
• If there are multiple don notes in a row in a grouping, they'll alternate between ド (do) and コ (ko)

For example:

• DD -> ドドン -> Do-don
• DDD -> ドコドン -> Do-ko-don
• DDDDD -> ドコドコドン -> Do-ko-do-ko-don
• KDK -> Is this カドカッ (Ka-do-katsu) or カドカッ (Ka-ko-katsu)? Presumably the former, right?
• DDK -> Actually this is ドドカッ (Do-do-katsu)! Surprising! (It seems like コ is only used in groups of 3+ dons that end on a ドン)
• DDDDK -> ドドドドカッ -> Do-do-do-do-katsu

Groupings seem to include any set of notes with identical durations between them, e.g.:

(Note the katsu at the end, even when notes are spaced out)

I will have to be quite careful when keeping track of note groupings (tracking between-measure groupings, making sure to properly identify when a grouping ends, etc.).

[vivaria]

It looks like there are a handful of approaches for clustering in 1D (see this SO answer). Many of them are using numpy / scipy, though, whereas ideally I would want to implement something in pure Python to keep the distributed binary size small.

I do think that the 1D clustering problem here is quite a bit simpler than the cases described on SO:

• All of the ms timings of the notes are A) monotonically increasing and B) unique (i.e. no duplicate notes)
• The spacing between ms timings is predictable and consistent
• The smallest spacings (48th notes, 24th notes, 16th notes, 8th notes, etc.) are pretty much guaranteed to be grouped.

So, maybe I can come up with some sort of simplified algorithm to group the notes, given some assumptions. For example:

• Group the notes with the smallest gaps between timings (i.e. 48th notes)
• Of the remaining ungrouped notes, group the notes with the next-smallest gaps (i.e. 24th notes)
• Repeat until there are no grouped notes.