def test_score_book_example(self): score = Score() catalogue = InstrumentCatalog.instance() score.add_instrument_voice( InstrumentVoice(catalogue.get_instrument("violin"))) score.tempo_sequence.add(TempoEvent(Tempo(60), Position(0))) score.time_signature_sequence.add( TimeSignatureEvent(TimeSignature(4, Duration(1, 4)), Position(0))) violin_voice = score.get_instrument_voice("violin")[0] note_1 = Note(DiatonicPitch(4, 'A'), Duration(1, 4)) note_2 = Note(DiatonicPitch(5, 'C'), Duration(1, 8)) note_3 = Note(DiatonicPitch(5, 'B'), Duration(1, 8)) note_4 = Note(DiatonicPitch(5, 'D'), Duration(1, 4)) note_5 = Note(DiatonicPitch(5, 'E'), Duration(1, 8)) note_6 = Note(DiatonicPitch(5, 'D'), Duration(1, 8)) note_7 = Note(DiatonicPitch(4, 'G'), Duration(1, 4)) note_8 = Note(DiatonicPitch(4, 'C'), Duration(1, 4)) line = Line( [note_1, note_2, note_3, note_4, note_5, note_6, note_7, note_8]) violin_voice.voice(0).pin(line) smc = ScoreToMidiConverter(score) smc.create('book_example_midi_file.mid', True) ScoreToMidiConverter.convert_line(line, 'line_example_midi_file.mid', Tempo(90, Duration(1, 8)), instrument_name='violin')
def test_tempo(self): tempo = Tempo(34) self.assertTrue(tempo.tempo == 34) tempo = Tempo(TempoType.Adagio) r = TempoType.get_range_for(TempoType.Adagio) self.assertTrue(r.end_index >= tempo.tempo >= r.start_index)
def test_basic_sequence(self): settings = [ Tempo(TempoType.Grave), Tempo(TempoType.Allegrissimo), Tempo(TempoType.Moderato), Tempo(TempoType.Largo), Tempo(TempoType.Vivace), ] events = [ TempoFunctionEvent(settings[0], Position(0)), TempoFunctionEvent(settings[1], Position(10)), TempoFunctionEvent(settings[2], Position(20)), TempoFunctionEvent(settings[3], Position(40)), TempoFunctionEvent(settings[4], Position(60)) ] tes = TempoEventSequence(events) print(tes) assert tes.tempo(Position(0)) == settings[0].tempo assert tes.tempo(Position(10)) == settings[1].tempo assert tes.tempo(Position(20)) == settings[2].tempo assert tes.tempo(Position(40)) == settings[3].tempo assert tes.tempo(Position(60)) == settings[4].tempo assert tes.tempo(Position(15)) == settings[1].tempo assert tes.tempo(Position(45)) == settings[3].tempo
def test_tempo_change(self): c = InstrumentCatalog.instance() score = Score() score.time_signature_sequence.add( TimeSignatureEvent(TimeSignature(3, Duration(1, 4)), Position(0))) score.tempo_sequence.add( TempoEvent(Tempo(120, Duration(1, 4)), Position(0))) score.tempo_sequence.add( TempoEvent(Tempo(60, Duration(1, 4)), Position(1))) score.tempo_sequence.add( TempoEvent(Tempo(30, Duration(1, 4)), Position(2))) violin = c.get_instrument("violin") violin_instrument_voice = InstrumentVoice(violin, 1) violin_voice_0 = violin_instrument_voice.voice(0) assert violin_voice_0 score.add_instrument_voice(violin_instrument_voice) violin_voice_0.dynamics_sequence.add( DynamicsEvent(Dynamics(Dynamics.F), Position(0))) # Add notes to the score vnote0 = Note(DiatonicPitch(4, 'a'), Duration(1, 4)) vnote1 = Note(DiatonicPitch(4, 'b'), Duration(1, 4)) vnote2 = Note(DiatonicPitch(5, 'c'), Duration(1, 4)) vnote3 = Note(DiatonicPitch(5, 'd'), Duration(1, 4)) vnote4 = Note(DiatonicPitch(4, 'a'), Duration(1, 4)) vnote5 = Note(DiatonicPitch(4, 'b'), Duration(1, 4)) vnote6 = Note(DiatonicPitch(5, 'c'), Duration(1, 4)) vnote7 = Note(DiatonicPitch(5, 'd'), Duration(1, 4)) vnote8 = Note(DiatonicPitch(4, 'a'), Duration(1, 4)) vnote9 = Note(DiatonicPitch(4, 'b'), Duration(1, 4)) vnote10 = Note(DiatonicPitch(5, 'c'), Duration(1, 4)) vnote11 = Note(DiatonicPitch(5, 'd'), Duration(1, 4)) # Set up a violin voice with 6 8th notes vline_0 = Line([ vnote0, vnote1, vnote2, vnote3, vnote4, vnote5, vnote6, vnote7, vnote8, vnote9, vnote10, vnote11 ]) violin_voice_0.pin(vline_0) # Set up a violin voice with 6 8th notes vline_1 = Line([vnote0, vnote1, vnote2, vnote3]) violin_voice_0.pin(vline_1) smc = ScoreToMidiConverter(score) smc.create('score_tempo_change_file.mid') TestScoreToMidiConverter.read_midi_file('score_tempo_change_file.mid')
def test_book_tempo_sequence(self): print('----- test_book_tempo_sequence -----') seq = TempoEventSequence() seq.add(TempoEvent(Tempo(TempoType.Grave), Position(0))) seq.add(TempoEvent(Tempo(TempoType.Moderato), Position(10))) seq.add(TempoEvent(Tempo(TempoType.Vivace), Position(25))) seq.add(TempoEvent(Tempo(TempoType.Largo), Position(50))) event = seq.first while event is not None: print(event) event = seq.successor(event) print('----- End test_book_tempo_sequence -----')
def test_accel_decel_sequence(self): t_low = Tempo(TempoType.Moderato) event0 = TempoFunctionEvent(t_low, Position(0)) t_hi = Tempo(TempoType.Vivace) array = [(Position(10), t_low.tempo), (Position(30), t_hi.tempo)] f = PiecewiseLinearFunction(array) event1 = TempoFunctionEvent(f, Position(10)) event2 = TempoFunctionEvent(t_hi, Position(40)) tes = TempoEventSequence([event0, event1, event2]) print(tes) assert tes.tempo(Position(0)) == t_low.tempo assert tes.tempo(Position(10)) == t_low.tempo assert tes.tempo(Position(40)) == t_hi.tempo assert tes.tempo(Position(25)) == (t_low.tempo + t_hi.tempo) / 2.0 assert tes.tempo( Position(30)) == t_low.tempo + (2 * (t_hi.tempo - t_low.tempo) / 3.0) assert tes.tempo(Position(50)) == t_hi.tempo t_hi = Tempo(TempoType.Vivace) t_low = Tempo(TempoType.Moderato) event0 = TempoFunctionEvent(t_hi, Position(0)) array = [(Position(10), t_hi.tempo), (Position(30), t_low.tempo)] f = PiecewiseLinearFunction(array) event1 = TempoFunctionEvent(f, Position(10)) event2 = TempoFunctionEvent(t_low, Position(40)) tes = TempoEventSequence([event0, event1, event2]) print(tes) assert tes.tempo(Position(0)) == t_hi.tempo assert tes.tempo(Position(10)) == t_hi.tempo assert tes.tempo(Position(40)) == t_low.tempo assert tes.tempo(Position(25)) == (t_low.tempo + t_hi.tempo) / 2.0 assert tes.tempo( Position(30)) == t_hi.tempo - (2 * (t_hi.tempo - t_low.tempo) / 3.0) assert tes.tempo(Position(50)) == t_low.tempo
def convert_line(line, tempo=Tempo(60, Duration(1, 4)), time_signature=TimeSignature(4, Duration(1, 4)), channel_assignments=None, fps=42100): """ Static method to convert a Line to a midi file Args: :param line: Class Line object :param tempo: Tempo for playback, default is 60 BPM tempo beat = quarter note :param time_signature: TimeSiganture on playback, default is 4 quarter notes :param channel_assignments: :param fps: frames per second setting """ score = Score() tempo_sequence = score.tempo_sequence tempo_sequence.add(TempoEvent(tempo, Position(0))) ts_sequence = score.time_signature_sequence ts_sequence.add(TimeSignatureEvent(time_signature, Position(0))) c = InstrumentCatalog.instance() piano = c.get_instrument("piano") piano_instrument_voice = InstrumentVoice(piano, 1) piano_voice = piano_instrument_voice.voice(0) piano_voice.pin(line, Offset(0)) score.add_instrument_voice(piano_instrument_voice) return ScoreToVstMidiConverter.convert_score(score, channel_assignments, fps)
def test_adding_notes(self): score = Score() # set up 3 instrument voices: 2 violins, 1 trumpet, 1 clarinet catalogue = InstrumentCatalog.instance() score.add_instrument_voice( InstrumentVoice(catalogue.get_instrument("violin"), 2)) # 1 beat == 1 sec, 3/4 TS + 60 beats per minute, score.tempo_sequence.add(TempoEvent(Tempo(60), Position(0))) score.time_signature_sequence.add( TimeSignatureEvent(TimeSignature(3, Duration(1, 4)), Position(0))) violin_voice = score.get_instrument_voice("violin")[0] line = Line([Note(DiatonicPitch(4, y), Duration(1, 8)) for y in 'afd']) violin_voice.voice(0).pin(line) notes = violin_voice.get_all_notes() for n in notes: print(n) line.append(Note(DiatonicPitch(4, 'g'), Duration(1, 8))) notes = violin_voice.get_all_notes() for n in notes: print(n)
def test_book_example(self): score = Score() # set up 3 instrument voices: 2 violins, 1 trumpet, 1 clarinet catalogue = InstrumentCatalog.instance() score.add_instrument_voice( InstrumentVoice(catalogue.get_instrument("violin"), 2)) score.add_instrument_voice( InstrumentVoice(catalogue.get_instrument("trumpet"))) score.add_instrument_voice( InstrumentVoice(catalogue.get_instrument("clarinet"))) # 1 beat == 1 sec, 3/4 TS + 60 beats per minute, score.tempo_sequence.add(TempoEvent(Tempo(60), Position(0))) score.time_signature_sequence.add( TimeSignatureEvent(TimeSignature(3, Duration(1, 4)), Position(0))) # set up some notes in the two violins violin_voice = score.get_instrument_voice("violin")[0] violin_voice.voice(0).pin( Line([Note(DiatonicPitch(4, y), Duration(1, 8)) for y in 'afdecd'])) violin_voice.voice(0).pin( Line([Note(DiatonicPitch(4, y), Duration(1, 4)) for y in 'cdc']))
def get_time_in_ms(self): event_list = self.score.tempo_sequence.sequence_list score_len = self.score.length() fine_tempo_sequence = TempoEventSequence() for event in event_list: if isinstance(event, TempoEvent): fine_tempo_sequence.add(TempoEvent(event.object, event.time)) elif isinstance(event, TempoFunctionEvent): t1 = event.time beat_duration = event.beat_duration if event.beat_duration is None else \ ScoreToVstMidiConverter.DEFAULT_BEAT_DURATION next_event = self.score.tempo_sequence.successor(event) t2 = next_event.time if next_event is not None else Position( score_len.duration) while t1 < t2: tempo = int( event.tempo( t1, next_event.time if next_event is not None else Position(score_len))) delta_wnt = (tempo * ScoreToVstMidiConverter.TEMPO_EVENT_DURATION_MS * beat_duration.duration) / \ (60.0 * 1000.0) fine_tempo_sequence.add( TempoEvent(Tempo(tempo, beat_duration), t1)) t1 += delta_wnt conversion = TimeConversion(fine_tempo_sequence, self.score.time_signature_sequence, Position(score_len)) actual_time = conversion.position_to_actual_time( Position(self.score.duration)) return actual_time
def _build_default_time_sig_tempo(): tempo_seq = TempoEventSequence() ts_seq = EventSequence() tempo_seq.add(TempoEvent(Tempo(60, Duration(1, 4)), Position(0))) ts_seq.add( TimeSignatureEvent(TimeSignature(3, Duration(1, 4), 'sww'), Position(0))) return ts_seq, tempo_seq
def test_step_wise_tempo(self): t_lo_steady = Tempo(TempoType.Grave) event0 = TempoEvent(t_lo_steady, Position(0)) settings = [ Tempo(TempoType.Grave), Tempo(TempoType.Allegrissimo), Tempo(TempoType.Moderato), Tempo(TempoType.Largo), Tempo(TempoType.Vivace) ] steps = [(Position(0), settings[0].tempo), (Position(10), settings[1].tempo), (Position(20), settings[2].tempo), (Position(30), settings[3].tempo), (Position(40), settings[4].tempo)] f = StepwiseFunction(steps) event1 = TempoFunctionEvent(f, Position(10)) t_hi_steady = Tempo(TempoType(TempoType.Vivace)) event2 = TempoEvent(t_hi_steady, Position(50)) tes = TempoEventSequence([event0, event1, event2]) assert tes.tempo(Position(0)) == t_lo_steady.tempo assert tes.tempo(Position(5)) == t_lo_steady.tempo assert tes.tempo(Position(10)) == settings[0].tempo assert tes.tempo(Position(20)) == settings[1].tempo assert tes.tempo(Position(30)) == settings[2].tempo assert tes.tempo(Position(40)) == settings[3].tempo assert tes.tempo(Position(50)) == settings[4].tempo assert tes.tempo(Position(60)) == t_hi_steady.tempo
def test_variable_tempo_change(self): c = InstrumentCatalog.instance() score = Score() violin = c.get_instrument("violin") violin_instrument_voice = InstrumentVoice(violin, 1) violin_voice = violin_instrument_voice.voice(0) assert violin_voice score.add_instrument_voice(violin_instrument_voice) score.time_signature_sequence.add( TimeSignatureEvent(TimeSignature(3, Duration(1, 4)), Position(0))) score.tempo_sequence.add( TempoEvent(Tempo(60, Duration(1, 4)), Position(0))) t_low = 60 t_hi = 250 array = [(Position(0), t_low), (Position(1), t_hi), (Position(2), t_hi), (Position(3), t_low)] f = PiecewiseLinearFunction(array) event1 = TempoFunctionEvent(f, Position(1)) score.tempo_sequence.add(event1) score.tempo_sequence.add( TempoEvent(Tempo(t_low, Duration(1, 4)), Position(4))) # create notes notes = [] for _ in range(0, 6): notes.append(Note(DiatonicPitch(4, 'c'), Duration(1, 4))) notes.append(Note(DiatonicPitch(4, 'd'), Duration(1, 4))) notes.append(Note(DiatonicPitch(4, 'e'), Duration(1, 4))) notes.append(Note(DiatonicPitch(4, 'f'), Duration(1, 4))) vline = Line(notes) violin_voice.pin(vline) smc = ScoreToMidiConverter(score) smc.create('score_var_tempo_change_file.mid') TestScoreToMidiConverter.read_midi_file( 'score_var_tempo_change_file.mid')
def create_score_1(line, hct, instrument, ts): tempo_seq = TempoEventSequence() ts_seq = EventSequence() tempo_seq.add(TempoEvent(Tempo(60, Duration(1, 4)), Position(0))) ts_seq.add(TimeSignatureEvent(TimeSignature(ts[0], Duration(1, ts[1]), ts[2]), Position(0))) c = InstrumentCatalog.instance() instrument = c.get_instrument(instrument) return LiteScore(line, hct, instrument, tempo_seq, ts_seq)
def build_vst_midi_list(): """ :return: """ c = InstrumentCatalog.instance() # Add notes to the score vnote0 = Note(DiatonicPitch(4, 'a'), Duration(1, 8)) vnote1 = Note(DiatonicPitch(4, 'b'), Duration(1, 8)) vnote2 = Note(DiatonicPitch(4, 'c'), Duration(1, 8)) vnote3 = Note(DiatonicPitch(4, 'd'), Duration(1, 8)) vnote4 = Note(DiatonicPitch(4, 'e'), Duration(1, 8)) vnote5 = Note(DiatonicPitch(4, 'f'), Duration(1, 8)) # Set up a violin voice with 6 8th notes vline = Line([vnote0, vnote1, vnote2, vnote3, vnote4, vnote5]) tempo_seq = TempoEventSequence() ts_seq = EventSequence() tempo_seq.add(TempoEvent(Tempo(60), Position(0))) ts_seq.add( TimeSignatureEvent(TimeSignature(3, Duration(1, 4), 'sww'), Position(0))) hc_track = HarmonicContextTrack() diatonic_tonality = Tonality.create(ModalityType.Major, DiatonicTone("C")) chord_t = TertianChordTemplate.parse('tIV') chord = chord_t.create_chord(diatonic_tonality) hc_track.append(HarmonicContext(diatonic_tonality, chord, Duration(2))) score = Score() score.tempo_sequence.add(TempoEvent(Tempo(60), Position(0))) score.time_signature_sequence.add( TimeSignatureEvent(TimeSignature(3, Duration(1, 4)), Position(0))) violin = c.get_instrument("violin") violin_instrument_voice = InstrumentVoice(violin, 1) score.add_instrument_voice(violin_instrument_voice) violin_instrument_voice.voice(0).pin(vline) return ScoreToVstMidiConverter.convert_score(score, {0: 0}), score
def test_basic_setup(self): c = InstrumentCatalog.instance() violin = c.get_instrument("violin") # Add notes to the score vnote0 = Note(DiatonicPitch(4, 'a'), Duration(1, 8)) vnote1 = Note(DiatonicPitch(4, 'b'), Duration(1, 8)) vnote2 = Note(DiatonicPitch(4, 'c'), Duration(1, 8)) vnote3 = Note(DiatonicPitch(4, 'd'), Duration(1, 8)) vnote4 = Note(DiatonicPitch(4, 'e'), Duration(1, 8)) vnote5 = Note(DiatonicPitch(4, 'f'), Duration(1, 8)) # Set up a violin voice with 6 8th notes vline = Line([vnote0, vnote1, vnote2, vnote3, vnote4, vnote5]) tempo_seq = TempoEventSequence() ts_seq = EventSequence() tempo_seq.add(TempoEvent(Tempo(60), Position(0))) ts_seq.add( TimeSignatureEvent(TimeSignature(3, Duration(1, 4), 'sww'), Position(0))) hc_track = HarmonicContextTrack() diatonic_tonality = Tonality.create(ModalityType.Major, DiatonicTone("C")) chord_t = TertianChordTemplate.parse('tIV') chord = chord_t.create_chord(diatonic_tonality) hc_track.append(HarmonicContext(diatonic_tonality, chord, Duration(2))) score = LiteScore(vline, hc_track, violin, tempo_seq, ts_seq) bp = score.beat_position(Position(0)) print(bp) assert bp.beat_number == 0 bp = score.beat_position(Position(5, 8)) print(bp) assert bp.measure_number == 0 assert bp.beat_number == Fraction(5, 2) assert int(bp.beat_number) == 2 assert bp.beat_number - bp.beat == Fraction(1, 2) tse = score.time_signature_sequence.floor_event(Position(5, 8)) assert tse is not None print(tse.object.beat_type(bp.beat)) assert tse.object.beat_type(bp.beat) == BeatType.Weak assert bp.beat_fraction == Fraction(1, 2) bp = score.beat_position(Position(1, 16)) print(bp) tse = score.time_signature_sequence.floor_event(Position(1, 16)) print(tse.object.beat_type(bp.beat)) assert tse.object.beat_type(bp.beat) == BeatType.Strong
def build_simple_constraint(v_note, f, modality_type, key_str, chord_str): lower_policy_context = TestFitPitchToFunctionConstraint.policy_creator( modality_type, DiatonicTone(key_str), chord_str, 'C:2', 'C:8') tempo_seq = TempoEventSequence() ts_seq = EventSequence() tempo_seq.add(TempoEvent(Tempo(60, Duration(1, 4)), Position(0))) ts_seq.add( TimeSignatureEvent(TimeSignature(3, Duration(1, 4), 'sww'), Position(0))) return FitPitchToFunctionConstraint(v_note, f, tempo_seq, ts_seq), lower_policy_context
def create_score(line_expression, instrument, ts): lge = LineGrammarExecutor() source_instance_line, source_instance_hct = lge.parse(line_expression) tempo_seq = TempoEventSequence() ts_seq = EventSequence() tempo_seq.add(TempoEvent(Tempo(60, Duration(1, 4)), Position(0))) ts_seq.add(TimeSignatureEvent(TimeSignature(ts[0], Duration(1, ts[1]), ts[2]), Position(0))) c = InstrumentCatalog.instance() instrument = c.get_instrument(instrument) return LiteScore(source_instance_line, source_instance_hct, instrument, tempo_seq, ts_seq)
def create_score(s_notes, modality, key_tone, chords, instrument, ts): diatonic_tonality = Tonality.create(modality, DiatonicToneCache.get_tone(key_tone)) hc_track = TestTReshape.create_track(chords, diatonic_tonality) tempo_seq = TempoEventSequence() ts_seq = EventSequence() tempo_seq.add(TempoEvent(Tempo(60, Duration(1, 4)), Position(0))) ts_seq.add(TimeSignatureEvent(TimeSignature(ts[0], Duration(1, ts[1]), ts[2]), Position(0))) c = InstrumentCatalog.instance() violin = c.get_instrument(instrument) return LiteScore(TestTReshape.create_line(s_notes), hc_track, violin, tempo_seq, ts_seq)
def test_time_conversion_simple(self): tempo_line = EventSequence([TempoEvent(Tempo(60), Position(0))]) ts_line = EventSequence([ TimeSignatureEvent(TimeSignature(3, Duration(1, 4)), Position(0)) ]) conversion = TimeConversion(tempo_line, ts_line, Position(1, 1)) actual_time = conversion.position_to_actual_time(Position(3, 4)) print(actual_time) self.assertTrue(actual_time == 3000, 'actual time = {0} should be 3000'.format(actual_time)) position = conversion.actual_time_to_position(3000) print(position) self.assertTrue(position, Position(3, 4))
def test_multi_track(self): c = InstrumentCatalog.instance() score = Score() score.time_signature_sequence.add( TimeSignatureEvent(TimeSignature(3, Duration(1, 4)), Position(0))) score.tempo_sequence.add( TempoEvent(Tempo(60, Duration(1, 4)), Position(0))) violin = c.get_instrument("violin") piano = c.get_instrument("piano") note0 = Note(DiatonicPitch(4, 'a'), Duration(1, 4)) note1 = Note(DiatonicPitch(4, 'b'), Duration(1, 4)) note2 = Note(DiatonicPitch(4, 'c'), Duration(1, 4)) note3 = Note(DiatonicPitch(4, 'd'), Duration(1, 4)) note4 = Note(DiatonicPitch(5, 'g'), Duration(1, 4)) note5 = Note(DiatonicPitch(5, 'f'), Duration(1, 4)) note6 = Note(DiatonicPitch(5, 'e'), Duration(1, 4)) note7 = Note(DiatonicPitch(5, 'd'), Duration(1, 4)) violin_instrument_voice = InstrumentVoice(violin, 1) violin_voice = violin_instrument_voice.voice(0) assert violin_voice vline = Line([note0, note1, note2, note3]) violin_voice.pin(vline) score.add_instrument_voice(violin_instrument_voice) piano_instrument_voice = InstrumentVoice(piano, 1) piano_voice = piano_instrument_voice.voice(0) assert piano_voice pline = Line([note4, note5, note6, note7]) piano_voice.pin(pline, Offset(1, 8)) score.add_instrument_voice(piano_instrument_voice) violin_voice.dynamics_sequence.add( DynamicsEvent(Dynamics(Dynamics.F), Position(0))) piano_voice.dynamics_sequence.add( DynamicsEvent(Dynamics(Dynamics.P), Position(0))) smc = ScoreToMidiConverter(score) smc.create('score_multi_trackoutput_file.mid') TestScoreToMidiConverter.read_midi_file( 'score_multi_trackoutput_file.mid')
def test_position_to_actual_time(self): tempo_line = EventSequence([ TempoEvent(Tempo(60), Position(0)), TempoEvent(Tempo(20), Position(4, 4)) ]) ts_line = EventSequence([ TimeSignatureEvent(TimeSignature(3, Duration(1, 4)), Position(0)), TimeSignatureEvent(TimeSignature(2, Duration(1, 8)), Position(5, 4)) ]) conversion = TimeConversion(tempo_line, ts_line, Position(2, 1)) actual_time = conversion.position_to_actual_time(Position(6, 4)) print(actual_time) # 4 quarter notes @ 60 with 1/4 beat = 4000 # 1 quarter note @ 20 with 1/4 beat = 3000 # 2 eighth notes @ 20 (effective 40) with 1/8 beat = 3000 self.assertTrue( actual_time == 10000, 'actual time = {0} should be 10000'.format(actual_time)) position = conversion.actual_time_to_position(10000) print(position) self.assertEquals(position, Position(6, 4))
def create_score_artifacts(modality, key_tone, chords, ts): diatonic_tonality = Tonality.create( modality, DiatonicToneCache.get_tone(key_tone)) hc_track = TestPitchFitFunction.create_track(chords, diatonic_tonality) tempo_seq = TempoEventSequence() ts_seq = EventSequence() tempo_seq.add(TempoEvent(Tempo(60, Duration(1, 4)), Position(0))) ts_seq.add( TimeSignatureEvent(TimeSignature(ts[0], Duration(1, ts[1]), ts[2]), Position(0))) return hc_track, tempo_seq, ts_seq
def create_score(grammar_str, instrument, ts): lge = LineGrammarExecutor() target_line, target_hct = lge.parse(grammar_str) tempo_seq = TempoEventSequence() ts_seq = EventSequence() tempo_seq.add(TempoEvent(Tempo(60, Duration(1, 4)), Position(0))) ts_seq.add( TimeSignatureEvent(TimeSignature(ts[0], Duration(1, ts[1]), ts[2]), Position(0))) c = InstrumentCatalog.instance() violin = c.get_instrument(instrument) return LiteScore(target_line, target_hct, violin, tempo_seq, ts_seq)
def test_score_convert(self): c = InstrumentCatalog.instance() score = Score() score.time_signature_sequence.add( TimeSignatureEvent(TimeSignature(3, Duration(1, 4)), Position(0))) score.tempo_sequence.add( TempoEvent(Tempo(60, Duration(1, 4)), Position(0))) violin = c.get_instrument("violin") violin_instrument_voice = InstrumentVoice(violin, 2) violin_voice_0 = violin_instrument_voice.voice(0) violin_voice_1 = violin_instrument_voice.voice(1) assert violin_voice_0 assert violin_voice_1 score.add_instrument_voice(violin_instrument_voice) violin_voice_0.dynamics_sequence.add( DynamicsEvent(Dynamics(Dynamics.P), Position(0))) violin_voice_0.dynamics_sequence.add( DynamicsEvent(Dynamics(Dynamics.FFF), Position(1, 4))) violin_voice_1.dynamics_sequence.add( DynamicsEvent(Dynamics(Dynamics.P), Position(0))) violin_voice_1.dynamics_sequence.add( DynamicsEvent(Dynamics(Dynamics.FFF), Position(1, 4))) # Add notes to the score vnote0 = Note(DiatonicPitch(4, 'a'), Duration(1, 8)) vnote1 = Note(DiatonicPitch(4, 'b'), Duration(1, 8)) vnote2 = Note(DiatonicPitch(5, 'c'), Duration(1, 8)) vnote3 = Note(DiatonicPitch(4, 'd'), Duration(1, 8)) vnote4 = Note(DiatonicPitch(4, 'e'), Duration(1, 8)) vnote5 = Note(DiatonicPitch(4, 'f'), Duration(1, 8)) # Set up a violin voice with 6 8th notes vline_0 = Line([vnote0, vnote1, vnote2]) violin_voice_0.pin(vline_0) # Set up a violin voice with 6 8th notes vline_1 = Line([vnote3, vnote4, vnote5]) violin_voice_1.pin(vline_1) smc = ScoreToMidiConverter(score) smc.create('score_output_file.mid') TestScoreToMidiConverter.read_midi_file('score_output_file.mid')
def dilate_tempo_sequence(self, tempo_event_sequence): if tempo_event_sequence is None: return None new_tes = TempoEventSequence() tempi_events = tempo_event_sequence.sequence_list for tempo_event in tempi_events: tempo = tempo_event.object t = Tempo( tempo.tempo / self.dilation_factor if self.apply_to_bpm else tempo.tempo, tempo.beat_duration if not self.apply_to_notes else tempo.beat_duration * self.dilation_factor) new_te = TempoEvent( t, tempo_event.time * self.dilation_factor if self.apply_to_notes else tempo_event.time) new_tes.add(new_te) return new_tes
def test_dynamic_volume(self): c = InstrumentCatalog.instance() score = Score() score.time_signature_sequence.add( TimeSignatureEvent(TimeSignature(3, Duration(1, 4)), Position(0))) score.tempo_sequence.add( TempoEvent(Tempo(60, Duration(1, 4)), Position(0))) violin = c.get_instrument("violin") note0 = Note(DiatonicPitch(4, 'a'), Duration(3, 2)) note1 = Note(DiatonicPitch(4, 'b'), Duration(1, 2)) note2 = Note(DiatonicPitch(5, 'c'), Duration(1, 2)) note3 = Note(DiatonicPitch(5, 'd'), Duration(1, 4)) note4 = Note(DiatonicPitch(5, 'g'), Duration(1, 4)) note5 = Note(DiatonicPitch(5, 'f'), Duration(1, 4)) note6 = Note(DiatonicPitch(5, 'e'), Duration(1, 4)) note7 = Note(DiatonicPitch(5, 'd'), Duration(1, 4)) violin_instrument_voice = InstrumentVoice(violin, 1) violin_voice = violin_instrument_voice.voice(0) assert violin_voice vline = Line([note0, note1, note2, note3, note4, note5, note6, note7]) violin_voice.pin(vline) score.add_instrument_voice(violin_instrument_voice) # create a crescendo v_low = Dynamics.PPP.velocity v_hi = Dynamics.FFFF.velocity array = [(Position(0), v_low), (Position(3, 2), v_hi)] f = PiecewiseLinearFunction(array) event1 = DynamicsFunctionEvent(f, Position(0)) violin_voice.dynamics_sequence.add(event1) smc = ScoreToMidiConverter(score) smc.create('score_vary_volume_file.mid') TestScoreToMidiConverter.read_midi_file('score_vary_volume_file.mid')
def __init__(self, coverage_node_list, tempo_seq, ts_seq, hct, line): """ Constructor :param coverage_node_list: List of note structures that are affected by on beat constraints. :param tempo_seq: TempoEventSequence :param ts_seq: EventSequence of TimeSignatures :param hct: HarmonicContextTrack :param line: Line """ self.__coverage_node_list = coverage_node_list self.__coverage_node_aggregates = dict() self.__coverage_node_deltas = dict() # duplicate time signature event sequence new_ts_list = [] for e in ts_seq.sequence_list: new_ts_list.append( TimeSignatureEvent( TimeSignature(e.object.beats_per_measure, e.object.beat_duration, e.object.beat_pattern), e.time)) self.__ts_event_sequence = EventSequence(new_ts_list) # duplicate tempo event sequence new_tempo_list = [] for e in tempo_seq.sequence_list: new_tempo_list.append( TempoEvent(Tempo(e.object.tempo, e.object.beat_duration), e.time)) self.__tempo_event_sequence = TempoEventSequence(new_tempo_list) self.__line = line self.__hct = HarmonicContextTrack() for hc in hct.hc_list(): self.__hct.append( HarmonicContext(hc.tonality, hc.chord, Duration(hc.duration), Position(hc.position))) for n in self.coverage_node_list: self.__coverage_node_aggregates[n] = 0 self.__coverage_node_deltas[n] = 0
def create_score(line_text, instrument, tmpo, ts): """ :param line_text: :param instrument: :param tmpo: (bpm, tempo beat duration) :param ts: (num beats, ts beat duration) :return: """ lge = LineGrammarExecutor() source_instance_line, source_instance_hct = lge.parse(line_text) tempo_seq = TempoEventSequence() ts_seq = EventSequence() tempo_seq.add(TempoEvent(Tempo(tmpo[0], tmpo[1]), Position(0))) ts_seq.add(TimeSignatureEvent(TimeSignature(ts[0], ts[1]), Position(0))) c = InstrumentCatalog.instance() instrument = c.get_instrument(instrument) return LiteScore(source_instance_line, source_instance_hct, instrument, tempo_seq, ts_seq)
def test_add_notes_to_two_level_line(self): score = Score() catalogue = InstrumentCatalog.instance() score.add_instrument_voice( InstrumentVoice(catalogue.get_instrument("violin"))) # 1 beat == 1 sec, 3/4 TS + 60 beats per minute, score.tempo_sequence.add(TempoEvent(Tempo(60), Position(0))) score.time_signature_sequence.add( TimeSignatureEvent(TimeSignature(3, Duration(1, 4)), Position(0))) violin_voice = score.get_instrument_voice("violin")[0] top_line = Line( [Note(DiatonicPitch(4, y), Duration(1, 8)) for y in 'afdecd']) violin_voice.voice(0).pin(top_line, Offset(0)) level1_line = Line( [Note(DiatonicPitch(5, y), Duration(1, 8)) for y in 'af']) top_line.pin(level1_line, Offset(2)) level2_line = Line( [Note(DiatonicPitch(6, y), Duration(1, 8)) for y in 'de']) level1_line.pin(level2_line, Offset(1))