|
import random |
|
|
|
import numpy as np |
|
|
|
from configurations.read_configuration import get_conf_n_sample, get_conf_sample_rate, get_conf_max_n_notes |
|
|
|
|
|
def get_random_note_type_index(distribution): |
|
"""A helper method that randomly chooses next note type based on a distribution |
|
|
|
Parameters |
|
---------- |
|
distribution: List[float] |
|
Note type distribution. |
|
|
|
Returns |
|
------- |
|
midi: int |
|
Random type index. |
|
""" |
|
|
|
r = np.random.random() |
|
for i in range(len(distribution)): |
|
r = r - distribution[i] |
|
if r < 0: |
|
return i |
|
return len(distribution) - 1 |
|
|
|
|
|
|
|
def to_onsets_in_seconds(bpm, notes): |
|
"""A helper method that transform a list of note types into a list of note onsets (in seconds) |
|
|
|
Parameters |
|
---------- |
|
bpm: float |
|
BPM |
|
notes: List[int] |
|
|
|
|
|
Returns |
|
------- |
|
midi: int |
|
Random type index. |
|
""" |
|
|
|
full_note_length = 4 * 60 / bpm |
|
onsets = [0] |
|
for i in range(len(notes)): |
|
onsets.append(onsets[i] + full_note_length * notes[i]) |
|
return onsets |
|
|
|
|
|
class RandomRhythm: |
|
"""First component in the random midi pipeline responsible for random rhythm (note onsets) generating""" |
|
|
|
def __init__(self): |
|
self.note_types = [0, 1, 3 / 4, 0.5, 3 / 8, 0.25, 1 / 8] |
|
self.first_note_type_distribution = np.array([0, 0.2, 0.05, 0.25, 0.05, 0.3, 0.15]) |
|
self.rhythm_generation_matrix = np.array([ |
|
[0.1, 0.1, 0.25, 0.1, 0.25, 0.2], |
|
[0.05, 0.25, 0.25, 0.05, 0.3, 0.1], |
|
[0.1, 0.1, 0.3, 0.05, 0.35, 0.1], |
|
[0.05, 0.05, 0.2, 0.2, 0.25, 0.25], |
|
[0.1, 0.05, 0.1, 0.05, 0.4, 0.3], |
|
[0.1, 0.05, 0.1, 0.1, 0.3, 0.35], |
|
]) |
|
|
|
self.rhythm_duration = np.array([0, 1, 3 / 4, 0.5, 3 / 8, 0.25]) |
|
self.audio_length = get_conf_n_sample() / get_conf_sample_rate() |
|
self.bpm_range = [90, 100, 110, 120, 130, 140, 150, 160, 170] |
|
self.max_n_notes = get_conf_max_n_notes() |
|
|
|
def __call__(self, strategy: str, *args, **kwargs): |
|
"""Choose required strategy to generate random rhythm (note onsets). |
|
|
|
Parameters |
|
---------- |
|
strategy: str |
|
Strategy names for random rhythm (see Readme). |
|
|
|
Returns |
|
------- |
|
onsets: List[float] |
|
A list of floats referring to note onsets in seconds. |
|
""" |
|
if strategy == 'bpm_based_rhythm': |
|
rhythm = self.get_bpm_based_rhythm() |
|
elif strategy == 'free_rhythm': |
|
rhythm = self.get_free_rhythm() |
|
elif strategy == 'single_note_rhythm': |
|
rhythm = self.get_single_note() |
|
else: |
|
rhythm = [0.0, 1, 2, 3, 4] |
|
|
|
return rhythm[:self.max_n_notes] |
|
|
|
def get_bpm_based_rhythm(self): |
|
"""Uses "bpm_based_rhythm" strategy to generate random rhythm (see Readme).""" |
|
|
|
|
|
bpm = random.choice(self.bpm_range) |
|
|
|
first_note = get_random_note_type_index(self.first_note_type_distribution) |
|
note_type_indexes = [first_note] |
|
current_note_type = first_note |
|
while True: |
|
current_note_type = get_random_note_type_index(self.rhythm_generation_matrix[current_note_type - 1]) + 1 |
|
note_type_indexes.append(current_note_type) |
|
|
|
|
|
if np.random.random() < 9 / bpm: |
|
break |
|
|
|
notes = [self.note_types[note_type_index] for note_type_index in note_type_indexes] |
|
|
|
onsets = to_onsets_in_seconds(bpm, notes) |
|
return onsets |
|
|
|
def get_free_rhythm(self): |
|
"""Uses "free_rhythm" strategy to generate random rhythm (see Readme).""" |
|
n_notes = np.random.randint(int(self.max_n_notes * 0.6), self.max_n_notes) |
|
|
|
|
|
onsets = np.random.rand(n_notes) |
|
onsets.sort() |
|
|
|
|
|
pre = onsets[0] |
|
n_removed = 0 |
|
for i in range(len(onsets)-1): |
|
index = i - n_removed + 1 |
|
if (onsets[index] - pre) < 0.05: |
|
new_onsets = np.delete(onsets, index) |
|
onsets = new_onsets |
|
n_removed = n_removed + 1 |
|
else: |
|
pre = onsets[index] |
|
|
|
return ((onsets - onsets[0])*self.audio_length).tolist() |
|
|
|
def get_single_note(self): |
|
return [0.0] |
|
|
