def __init__(self, sampling_frequency:int): # exercise settings self._sampling_frequency = sampling_frequency self._volume = None self._scale = None self._lowest_pitch = None self._highest_pitch = None self._possible_detune = None self._synthesizer = Synthesizer(sampling_frequency) self._possible_error = None # other variables self._actual_example = None self._player = Player(sampling_frequency)
def __init__(self, sampling_frequency: int): # exercise settings self._sampling_frequency = sampling_frequency self._volume = None self._play_type = None self._scale = None self._max_detuning = None self._lowest_pitch = None self._highest_pitch = None self._smallest_interval = None self._largest_interval = None self._synthesizer = Synthesizer(sampling_frequency) self._possible_error = None self._chord_size = None self._voice_length = None # other variables self._actual_example = None self._player = Player(sampling_frequency)
class DetuningExercise: def __init__(self, sampling_frequency: int): # exercise settings self._sampling_frequency = sampling_frequency self._volume = None self._play_type = None self._scale = None self._max_detuning = None self._lowest_pitch = None self._highest_pitch = None self._smallest_interval = None self._largest_interval = None self._synthesizer = Synthesizer(sampling_frequency) self._possible_error = None self._chord_size = None self._voice_length = None # other variables self._actual_example = None self._player = Player(sampling_frequency) def set_sampling_frequency(self, sampling_frequency: int): self._sampling_frequency = sampling_frequency self._synthesizer.set_sampling_frequency(sampling_frequency) self._player.set_sampling_frequency(sampling_frequency) def set_volume(self, volume: float): self._volume = volume self._synthesizer.set_volume(volume) def set_play_type(self, play_type: str): self._play_type = play_type def set_scale(self, scale: Scale): self._scale = scale def set_max_detuning(self, max_detuning: float): self._max_detuning = max_detuning def set_lowest_pitch(self, lowest_pitch: Pitch): self._lowest_pitch = lowest_pitch def set_highest_pitch(self, highest_pitch: Pitch): self._highest_pitch = highest_pitch def set_smallest_interval(self, smallest_interval: Interval): self._smallest_interval = smallest_interval def set_largest_interval(self, largest_interval: Interval): self._largest_interval = largest_interval def set_synthesizer(self, synthesizer: type): self._synthesizer = Synthesizer(self._sampling_frequency, synthesizer) def get_possible_error(self) -> float: return self._possible_error def set_possible_error(self, possible_error: float): self._possible_error = possible_error def get_chord_size(self) -> int: return self._chord_size def set_chord_size(self, chord_size: int): self._chord_size = chord_size def get_voice_length(self) -> int: return self._voice_length def set_voice_length(self, voice_length: int): self._voice_length = voice_length def generate_new_example(self): # Choose detuning actual_detuning = random.uniform( 0, min(self._max_detuning, 1200 / 2 / len(self._scale._pitches))) # Generate melody chord_generator = ChordGenerator( scale=self._scale, lowest_pitch=self._lowest_pitch, highest_pitch=self._highest_pitch, possible_detune=0, smallest_interval=self._smallest_interval, largest_interval=self._largest_interval, chord_size=self._chord_size) tuned_chords = list() for i in range(self._voice_length): tuned_chords.append(chord_generator.generate_chord()) # Create even detuning number_of_sounds = len(tuned_chords) * tuned_chords[0].get_size() if number_of_sounds < 2: raise ValueError( '[DetuningExercise::generate_new_example()] '\ + 'Cannot properly apply detuning to less than 2 sounds!' ) number_of_lowered_sounds = int(np.ceil(number_of_sounds / 3)) lowered_or_unchanged_indices = np.random.choice( np.arange(number_of_sounds), 2 * number_of_lowered_sounds, replace=False) lowered_indices = lowered_or_unchanged_indices[: number_of_lowered_sounds] unchanged_indices = lowered_or_unchanged_indices[ number_of_lowered_sounds:] highened_indices = np.setdiff1d(np.setdiff1d( np.arange(number_of_sounds), lowered_indices, assume_unique=True), unchanged_indices, assume_unique=True) # Detune chords for i in range(len(tuned_chords)): for j in range(tuned_chords[i].get_size()): if i * tuned_chords[i].get_size() + j in lowered_indices: tuned_chords[i]._pitches[j] = tuned_chords[i]._pitches[ j].copy(detune=-actual_detuning) elif i * tuned_chords[i].get_size() + j in highened_indices: tuned_chords[i]._pitches[j] = tuned_chords[i]._pitches[ j].copy(detune=actual_detuning) # Add chords to example self._actual_example = DetuningExample(actual_detuning) for i in range(len(tuned_chords)): self._actual_example.add_chord(tuned_chords[i]) def play_example(self): # Check exercise state if self._actual_example is None: raise RuntimeError( '[VoicesExercise::play_example()] No example to play!') if self._play_type is None: raise RuntimeError( '[VoicesExercise::play_example()] No play type chosen!') # Play signal = np.zeros(0) if self._play_type == 'Upwards': self._player.play( np.concatenate([ signal, self._synthesizer.generate_chords_up( self._actual_example.chords) ])) elif self._play_type == 'Downwards': self._player.play( np.concatenate([ signal, self._synthesizer.generate_chords_down( self._actual_example.chords) ])) elif self._play_type == 'Upwards with hold': self._player.play( np.concatenate([ signal, self._synthesizer.generate_chords_up_hold( self._actual_example.chords) ])) elif self._play_type == 'Downwards with hold': self._player.play( np.concatenate([ signal, self._synthesizer.generate_chords_down_hold( self._actual_example.chords) ])) elif self._play_type == 'Together': self._player.play( np.concatenate([ signal, self._synthesizer.generate_chords_together( self._actual_example.chords) ])) else: raise RuntimeError( '[VoicesExercise::play_example()] Unknown play type!') def answer_example(self, answer: float) -> (bool, float): if self._actual_example.detuning\ + self._possible_error\ >= answer\ >= self._actual_example.detuning\ - self._possible_error: return True, self._actual_example.detuning else: return False, self._actual_example.detuning
class TenOPitchesExercise: def __init__(self, sampling_frequency:int): # exercise settings self._sampling_frequency = sampling_frequency self._volume = None self._scale = None self._lowest_pitch = None self._highest_pitch = None self._possible_detune = None self._synthesizer = Synthesizer(sampling_frequency) self._possible_error = None # other variables self._actual_example = None self._player = Player(sampling_frequency) def set_sampling_frequency(self, sampling_frequency:int): self._sampling_frequency = sampling_frequency self._synthesizer.set_sampling_frequency(sampling_frequency) self._player.set_sampling_frequency(sampling_frequency) def set_volume(self, volume:float): self._volume = volume self._synthesizer.set_volume(volume) def set_scale(self, scale:Scale): self._scale = scale def set_lowest_pitch(self, lowest_pitch:Pitch): self._lowest_pitch = lowest_pitch def set_highest_pitch(self, highest_pitch:Pitch): self._highest_pitch = highest_pitch def set_possible_detune(self, possible_detune:float): self._possible_detune = possible_detune def set_synthesizer(self, synthesizer:type): self._synthesizer = Synthesizer( self._sampling_frequency, synthesizer ) def get_possible_error(self): return self._possible_error def set_possible_error(self, possible_error:float): self._possible_error = possible_error def generate_new_example(self): pitch_generator = PitchGenerator( scale=self._scale, lowest_pitch=self._lowest_pitch, highest_pitch=self._highest_pitch, possible_detune=self._possible_detune ) self._actual_example = pitch_generator.generate_pitch() def play_example(self, memory_flush=False): # Check exercise state if self._actual_example is None: raise RuntimeError( '[TenOPitchesExercise::play_example()] No example to play!' ) # Generate memory flush signal = np.zeros(0) if memory_flush: signal = np.concatenate([ signal, self._synthesizer.generate_memory_flush( lowest_pitch=self._lowest_pitch, highest_pitch=self._highest_pitch ), np.zeros(self._sampling_frequency) ]) # Play self._player.play( np.concatenate([ signal, self._synthesizer.generate_pitch( pitch=self._actual_example, time=1 ) ]) ) def answer_example(self, answer) -> (bool, float): if self._actual_example.get_cents_from_a()\ + self._possible_error\ >= answer\ >= self._actual_example.get_cents_from_a()\ - self._possible_error: return True, self._actual_example.get_cents_from_a() else: return False, self._actual_example.get_cents_from_a()
class IntervalsExercise: def __init__(self, sampling_frequency: int): # exercise settings self._sampling_frequency = sampling_frequency self._volume = None self._play_type = None self._scale = None self._lowest_pitch = None self._highest_pitch = None self._smallest_interval = None self._largest_interval = None self._possible_detune = None self._synthesizer = Synthesizer(sampling_frequency) self._possible_error = None # other variables self._actual_example = None self._player = Player(sampling_frequency) def set_sampling_frequency(self, sampling_frequency: int): self._sampling_frequency = sampling_frequency self._synthesizer.set_sampling_frequency(sampling_frequency) self._player.set_sampling_frequency(sampling_frequency) def set_volume(self, volume: float): self._volume = volume self._synthesizer.set_volume(volume) def set_play_type(self, play_type: str): self._play_type = play_type def set_scale(self, scale: Scale): self._scale = scale def set_lowest_pitch(self, lowest_pitch: Pitch): self._lowest_pitch = lowest_pitch def set_highest_pitch(self, highest_pitch: Pitch): self._highest_pitch = highest_pitch def set_smallest_interval(self, smallest_interval: Interval): self._smallest_interval = smallest_interval def set_largest_interval(self, largest_interval: Interval): self._largest_interval = largest_interval def set_possible_detune(self, possible_detune: float): self._possible_detune = possible_detune def set_synthesizer(self, synthesizer: type): self._synthesizer = Synthesizer(self._sampling_frequency, synthesizer) def get_possible_error(self): return self._possible_error def set_possible_error(self, possible_error: float): self._possible_error = possible_error def generate_new_example(self): interval_generator = IntervalGenerator( scale=self._scale, lowest_pitch=self._lowest_pitch, highest_pitch=self._highest_pitch, possible_detune=self._possible_detune, smallest_interval=self._smallest_interval, largest_interval=self._largest_interval) self._actual_example = IntervalExample( interval_generator.generate_interval()) def play_example(self): if self._actual_example is None: raise RuntimeError( '[IntervalsExercise::play_example()] No example to play!') if self._play_type is None: raise RuntimeError( '[IntervalsExercise::play_example()] No play type chosen!') elif self._play_type == 'Upwards': self._player.play( self._synthesizer.generate_interval_up( self._actual_example.lower_pitch, self._actual_example.higher_pitch)) elif self._play_type == 'Downwards': self._player.play( self._synthesizer.generate_interval_down( self._actual_example.lower_pitch, self._actual_example.higher_pitch)) elif self._play_type == 'Upwards with hold': self._player.play( self._synthesizer.generate_interval_up_hold( self._actual_example.lower_pitch, self._actual_example.higher_pitch)) elif self._play_type == 'Downwards with hold': self._player.play( self._synthesizer.generate_interval_down_hold( self._actual_example.lower_pitch, self._actual_example.higher_pitch)) elif self._play_type == 'Together': self._player.play( self._synthesizer.generate_interval_together( self._actual_example.lower_pitch, self._actual_example.higher_pitch)) else: raise RuntimeError( '[IntervalsExercise::play_example()] Unknown play type!') def answer_example(self, answer: float) -> (bool, float): if self._actual_example.interval.get_cents()\ + self._possible_error\ >= answer\ >= self._actual_example.interval.get_cents()\ - self._possible_error: return True, self._actual_example.interval.get_cents() else: return False, self._actual_example.interval.get_cents()
class VoicesExercise: def __init__(self, sampling_frequency: int): # exercise settings self._sampling_frequency = sampling_frequency self._volume = None self._play_type = None self._scale = None self._lowest_pitch = None self._highest_pitch = None self._smallest_interval = None self._largest_interval = None self._possible_detune = None self._synthesizer = Synthesizer(sampling_frequency) self._possible_error = None self._chord_size = None self._voice_length = None self._if_first_note_provided = None # other variables self._actual_example = None self._player = Player(sampling_frequency) def set_sampling_frequency(self, sampling_frequency: int): self._sampling_frequency = sampling_frequency self._synthesizer.set_sampling_frequency(sampling_frequency) self._player.set_sampling_frequency(sampling_frequency) def set_volume(self, volume: float): self._volume = volume self._synthesizer.set_volume(volume) def set_play_type(self, play_type: str): self._play_type = play_type def set_scale(self, scale: Scale): self._scale = scale def set_lowest_pitch(self, lowest_pitch: Pitch): self._lowest_pitch = lowest_pitch def set_highest_pitch(self, highest_pitch: Pitch): self._highest_pitch = highest_pitch def set_smallest_interval(self, smallest_interval: Interval): self._smallest_interval = smallest_interval def set_largest_interval(self, largest_interval: Interval): self._largest_interval = largest_interval def set_possible_detune(self, possible_detune: float): self._possible_detune = possible_detune def set_synthesizer(self, synthesizer: type): self._synthesizer = Synthesizer(self._sampling_frequency, synthesizer) def get_possible_error(self) -> float: return self._possible_error def set_possible_error(self, possible_error: float): self._possible_error = possible_error def get_chord_size(self) -> int: return self._chord_size def set_chord_size(self, chord_size: int): self._chord_size = chord_size def get_voice_length(self) -> int: return self._voice_length def set_voice_length(self, voice_length: int): self._voice_length = voice_length def set_if_first_note_provided(self, if_first_note_provided: bool): self._if_first_note_provided = if_first_note_provided def generate_new_example(self): chord_generator = ChordGenerator( scale=self._scale, lowest_pitch=self._lowest_pitch, highest_pitch=self._highest_pitch, possible_detune=self._possible_detune, smallest_interval=self._smallest_interval, largest_interval=self._largest_interval, chord_size=self._chord_size) self._actual_example = VoicesExample() for i in range(self._voice_length): self._actual_example.add_chord(chord_generator.generate_chord()) def get_first_note(self): if self._if_first_note_provided: return self._actual_example.get_pitch(0, 0) def play_example(self): # Check exercise state if self._actual_example is None: raise RuntimeError( '[VoicesExercise::play_example()] No example to play!') if self._play_type is None: raise RuntimeError( '[VoicesExercise::play_example()] No play type chosen!') # Play signal = np.zeros(0) if self._play_type == 'Upwards': self._player.play( np.concatenate([ signal, self._synthesizer.generate_chords_up( self._actual_example.chords) ])) elif self._play_type == 'Downwards': self._player.play( np.concatenate([ signal, self._synthesizer.generate_chords_down( self._actual_example.chords) ])) elif self._play_type == 'Upwards with hold': self._player.play( np.concatenate([ signal, self._synthesizer.generate_chords_up_hold( self._actual_example.chords) ])) elif self._play_type == 'Downwards with hold': self._player.play( np.concatenate([ signal, self._synthesizer.generate_chords_down_hold( self._actual_example.chords) ])) elif self._play_type == 'Together': self._player.play( np.concatenate([ signal, self._synthesizer.generate_chords_together( self._actual_example.chords) ])) else: raise RuntimeError( '[VoicesExercise::play_example()] Unknown play type!') def answer_example(self, user_answers: list) -> VoicesAnswer: # Prepare correct answers matrix correct_answers = list() for chord_id in range(self._actual_example.get_voice_length()): correct_answers.append(list()) for voice_id in range(self._actual_example.get_chord_size()): correct_answers[-1].append(False) # Add first note to user answers if self._if_first_note_provided: user_answers[0].append(self.get_first_note().get_cents_from_a()) # Set hit answers to true for chord_id in range(self._actual_example.get_voice_length()): for voice_id in range(self._actual_example.get_chord_size()): for user_answer in user_answers[chord_id]: if self._actual_example.get_pitch( chord_id, voice_id ).get_cents_from_a() + self._possible_error\ >= user_answer\ >= self._actual_example.get_pitch( chord_id, voice_id ).get_cents_from_a() - self._possible_error: correct_answers[chord_id][voice_id] = True break # Return answer object return VoicesAnswer(self._actual_example, correct_answers)