def test_get_complement_interval(self):
intervals = Interval.names()
expected = Interval.names()
expected.reverse()
for i in range(len(intervals)):
interval = Interval(intervals[i])
complement = interval.get_complement_interval()
self.assertEqual(expected[i], complement.name)
def set_interval_probability(self, interval: str, probability: int):
"""
Ustaw prawdopodobieństwo wystąpienia dla konkretnego interwału. Wartości prawdopodobieństw mają sumować się
do 100, więc wartość tego prawdopodobieństwa też powinna być wybrana w taki sposób.
Args:
interval: Nazwa interwału
probability: Prawdopodobieństwo wystąpienia
"""
if interval in Interval.names():
idx = Interval.names().index(interval)
self.intervals_probability[idx] = probability
else:
raise IntervalNotSupported(interval)
return self
def test_sub_interval(self):
note = Note('c')
intervals = Interval.names()
expected = [
'c', 'b', 'bes', 'a', 'aes', 'g', 'ges', 'fis', 'f', 'e', 'ees',
'd', 'des', 'c'
]
for i in range(len(expected)):
new_note: Note = note - Interval(intervals[i])
self.assertEqual(expected[i], new_note.note)
note = Note('f')
expected = [
'f', 'e', 'ees', 'd', 'des', 'c', 'ces', 'b', 'bes', 'a', 'aes',
'g', 'ges', 'f'
]
for i in range(len(expected)):
new_note: Note = note - Interval(intervals[i])
self.assertEqual(expected[i], new_note.note)
def test_add_interval(self):
notes = ['c', 'f', 'fes', 'feses', 'fis', 'eisis']
expected = [[
'c', 'des', 'd', 'ees', 'e', 'f', 'fis', 'ges', 'g', 'aes', 'a',
'bes', 'b', 'c'
],
[
'f', 'ges', 'g', 'aes', 'a', 'bes', 'b', 'ces', 'c',
'des', 'd', 'ees', 'e', 'f'
],
[
'fes', 'geses', 'ges', 'aeses', 'aes', 'beses', 'bes',
'ceses', 'ces', 'deses', 'des', 'eeses', 'ees', 'fes'
],
[
'feses', 'fes', 'geses', 'ges', 'aeses', 'aes',
'beses', 'beses', 'ceses', 'ces', 'deses', 'des',
'eeses', 'feses'
],
[
'fis', 'g', 'gis', 'a', 'ais', 'b', 'bis', 'c', 'cis',
'd', 'dis', 'e', 'eis', 'fis'
],
[
'eisis', 'fisis', 'gis', 'gisis', 'ais', 'aisis',
'bis', 'bis', 'bisis', 'cisis', 'dis', 'disis', 'eis',
'eisis'
]]
intervals = Interval.names()
for i in range(len(notes)):
note = Note(notes[i])
for j in range(len(expected[i])):
new_note = note + Interval(intervals[j])
self.assertEqual(expected[i][j], new_note.note)
def set_intervals_probability(self, probabilities: List[int]):
"""
Ustaw wartości prawdopodobieństwa wystąpienia dla wszystkich interwałów. Wartości muszą sumować się do 100.
Args:
probabilities: Lista prawdopodobieństw
Raises:
ValueError: Jeśli prawdopodobieństwa nie sumują się do 100, lub jeśli długość listy nie odpowiada
ilości wszystkich dostępnych interwałów
"""
if len(probabilities) != len(Interval.names()):
raise ValueError(
'You have not specified probabilities for all intervals')
if sum(probabilities) != 100:
raise ValueError('Probabilities does not sum to 100')
self.intervals_probability = probabilities
return self
def get_next_writeable(self, longest_duration: int) -> Writeable:
"""
Wygeneruj losowy element (nutę lub pauzę) ograniczony poprzez maksymalną wartość rytmiczną,
która może wystąpić.
UWAGA: Ta metoda będzie działać poprawnie tylko wtedy jeśli w kontenerze self.generated_data
znajduje się co najmniej jedna nuta!
Args:
longest_duration: Najkrótsza możliwa do wystąpienia wartość rytmiczna, podana w ilości
shortest_note_duration
Raises:
TypeError: Gdy ostatnim elementem nie jest nuta
"""
generate_rest = np.random.choice(
[True, False],
p=[self.rest_probability, 1 - self.rest_probability])
if generate_rest and self._consecutive_rests < self.max_consecutive_rests:
self._consecutive_rests += 1
return self.get_random_rest(longest_duration=longest_duration)
else:
self._consecutive_rests = 0
last_note_idx = self.get_last_note_idx()
last_note = self.generated_data[last_note_idx]
assert isinstance(last_note, Note)
# Losujemy do momentu, aż któraś z nut nie będzie się mieścić w naszym przedziale
while True:
# Wybieramy losowy interwał i tworzymy dwie nuty, jedną w górę drugą w dół o wylosowany interwał
interval = np.random.choice(
Interval.names(),
p=self.get_normalized_intervals_probability())
next_note_up = last_note + Interval(interval)
next_note_down = last_note - Interval(interval)
# Sprawdzamy czy nuty się mieszczą się w zadanym przez użytkownika
up_in_ambitus = next_note_up.between(self.ambitus['lowest'],
self.ambitus['highest'])
down_in_ambitus = next_note_down.between(
self.ambitus['lowest'], self.ambitus['highest'])
if up_in_ambitus and down_in_ambitus:
# Jeśli obie z nut które zostały wygenerowane mieszczą się w ambitusie to korzystamy z
# prawdopodobieństw wystąpienia dźwięków w ramach oktawy
up_probability = self.notes_probability[
next_note_up.get_id() % 12]
down_probability = self.notes_probability[
next_note_down.get_id() % 12]
up_normalized_probability = up_probability / (
up_probability + down_probability)
probabilities = [
up_normalized_probability,
1 - up_normalized_probability
]
elem = np.random.choice([next_note_up, next_note_down],
p=probabilities)
break
elif up_in_ambitus:
elem = next_note_up
break
elif down_in_ambitus:
elem = next_note_down
break
note_template = self.get_random_note(
longest_duration=longest_duration)
note_template.note = elem.note
note_template.octave = elem.octave
return note_template
def test_init(self):
interval = Interval('4zw')
self.assertEqual('4zw', interval.name)
self.assertEqual(4, interval.degrees)
self.assertEqual('zw', interval.quality)
def test_repr(self):
interval = Interval('4zw')
self.assertEqual('Interval <4zw>', repr(interval))
def test_str(self):
interval = Interval('4zw')
self.assertEqual('4zw', str(interval))
def test_init_invalid_interval(self):
with self.assertRaises(KeyError):
Interval('4b')
def test_set_intervals_probability_more_than_one_hundred(self):
probabilities = [5 for _ in Interval.names()]
with self.assertRaises(ValueError):
self.generator.set_intervals_probability(probabilities)
def test_set_interval_probability(self):
self.generator.set_interval_probability('1cz', 10)
idx = Interval.names().index('1cz')
self.assertEqual(10, self.generator.intervals_probability[idx])