def test_add_notes_to_line(self): c = InstrumentCatalog.instance() violin = c.get_instrument("violin") note0 = Note(DiatonicPitch(4, 'a'), Duration(1, 8)) note1 = Note(DiatonicPitch(4, 'b'), Duration(1, 8)) note2 = Note(DiatonicPitch(4, 'c'), Duration(1, 8)) note3 = Note(DiatonicPitch(4, 'd'), Duration(1, 8)) line = Line() line.pin(note0, Offset(1, 4)) line.pin(note1, Offset(3, 8)) line.pin(note2, Offset(1, 2)) line.pin(note3, Offset(5, 8)) voice = Voice(violin) voice.pin(line, Offset(0)) notee0 = Note(DiatonicPitch(5, 'a'), Duration(1, 8)) notee1 = Note(DiatonicPitch(5, 'b'), Duration(1, 8)) line.pin([notee0, notee1], Offset(3, 4)) notes = voice.get_notes_starting_in_interval( Interval(Position(5, 8), Position(2, 1))) assert len(notes) == 3 assert TestVoice.has_pitch(notes, DiatonicPitch.parse('D:4')) assert TestVoice.has_pitch(notes, DiatonicPitch.parse('A:5')) assert TestVoice.has_pitch(notes, DiatonicPitch.parse('B:5'))
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_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_basic_setup(self): c = InstrumentCatalog.instance() score = Score() violin = c.get_instrument("violin") violin_instrument_voice = InstrumentVoice(violin, 5) score.add_instrument_voice(violin_instrument_voice) trumpet = c.get_instrument("trumpet") trumpet_instrument_voice = InstrumentVoice(trumpet) score.add_instrument_voice(trumpet_instrument_voice) clarinet = c.get_instrument("clarinet") clarinet_instrument_voice = InstrumentVoice(clarinet) score.add_instrument_voice(clarinet_instrument_voice) voices = score.instrument_voices assert len(voices) == 3 classes = score.instrument_classes assert len(classes) == 3 assert TestScore.has_class(classes, 'strings') assert TestScore.has_class(classes, 'woodwinds') assert TestScore.has_class(classes, 'brass') score.remove_instrument_voice(trumpet_instrument_voice) classes = score.instrument_classes assert len(classes) == 2 assert TestScore.has_class(classes, 'strings') assert TestScore.has_class(classes, 'woodwinds')
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 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_overlap_vs_start(self): c = InstrumentCatalog.instance() violin = c.get_instrument("violin") note0 = Note(DiatonicPitch(4, 'a'), Duration(1, 8)) note1 = Note(DiatonicPitch(4, 'b'), Duration(1, 8)) note2 = Note(DiatonicPitch(4, 'c'), Duration(1, 8)) note3 = Note(DiatonicPitch(4, 'd'), Duration(1, 8)) line = Line() line.pin(note0, Offset(1, 4)) line.pin(note1, Offset(3, 8)) line.pin(note2, Offset(1, 2)) line.pin(note3, Offset(5, 8)) voice = Voice(violin) voice.pin(line, Offset(0)) interval = Interval(Position(5, 16), Position(5, 8)) notes = voice.get_notes_by_interval(interval) assert len(notes) == 3 assert TestVoice.has_pitch(notes, DiatonicPitch.parse('A:4')) assert TestVoice.has_pitch(notes, DiatonicPitch.parse('B:4')) assert TestVoice.has_pitch(notes, DiatonicPitch.parse('C:4')) notes = voice.get_notes_starting_in_interval(interval) assert len(notes) == 2 assert TestVoice.has_pitch(notes, DiatonicPitch.parse('B:4')) assert TestVoice.has_pitch(notes, DiatonicPitch.parse('C:4')) notee0 = Note(DiatonicPitch(5, 'a'), Duration(1, 2)) notee1 = Note(DiatonicPitch(5, 'b'), Duration(1, 2)) line1 = Line() line1.pin([notee0, notee1], Offset(0)) voice.pin(line1, Offset(1, 4)) notes = voice.get_notes_by_interval(interval) assert len(notes) == 4 assert TestVoice.has_pitch(notes, DiatonicPitch.parse('A:4')) assert TestVoice.has_pitch(notes, DiatonicPitch.parse('B:4')) assert TestVoice.has_pitch(notes, DiatonicPitch.parse('C:4')) assert TestVoice.has_pitch(notes, DiatonicPitch.parse('A:5')) notes = voice.get_notes_by_interval(interval, line1) assert len(notes) == 1 assert TestVoice.has_pitch(notes, DiatonicPitch.parse('A:5')) notes = voice.get_notes_starting_in_interval(interval) assert len(notes) == 2 assert TestVoice.has_pitch(notes, DiatonicPitch.parse('B:4')) assert TestVoice.has_pitch(notes, DiatonicPitch.parse('C:4')) notes = voice.get_notes_starting_in_interval( Interval(Position(1, 8), Position(3, 8)), line1) assert len(notes) == 1 assert TestVoice.has_pitch(notes, DiatonicPitch.parse('A:5'))
def test_using_syntax(self): line, hct = LineGrammarExecutor().parse( '{<C-Major:I> C:4 [E:5 F [G:4 A B A] B]}') lite_score = LiteScore( line, hct, InstrumentCatalog.instance().get_instrument("violin")) print(lite_score.line)
def test_articulations(self): c = InstrumentCatalog.instance() inst = c.get_instrument("vIOlin") articulations = inst.get_articulations() for artic in articulations: print(artic.name) assert 'Arco' in [a.name for a in articulations] assert 'Legato' in [a.name for a in articulations]
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 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_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 test_transpose(self): c = InstrumentCatalog.instance() instf = c.get_instruments("Clarinet") bflatclarinet = None for inst in instf: if inst.key == 'Bb': bflatclarinet = inst break assert bflatclarinet is not None interval = Interval.create_interval(bflatclarinet.sounding_high, bflatclarinet.written_high) assert interval.interval_type == IntervalType.Major assert interval.diatonic_distance == 1
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 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 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 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_two_voices(self): print('test two voices') c = InstrumentCatalog.instance() violin = c.get_instrument("violin") note0 = Note(DiatonicPitch(4, 'a'), Duration(1, 8)) note1 = Note(DiatonicPitch(4, 'b'), Duration(1, 8)) note2 = Note(DiatonicPitch(4, 'c'), Duration(1, 8)) tuplet = Tuplet(Duration(1, 8), 2, [note0, note1, note2]) note3 = Note(DiatonicPitch(4, 'd'), Duration(1, 8)) note4 = Note(DiatonicPitch(4, 'e'), Duration(1, 8)) subbeam = Beam([note3, note4]) beam = Beam(subbeam) line1 = Line([tuplet, beam]) print(line1) notee0 = Note(DiatonicPitch(5, 'a'), Duration(1, 8)) notee1 = Note(DiatonicPitch(5, 'b'), Duration(1, 8), 1) notee2 = Note(DiatonicPitch(5, 'c'), Duration(1, 8)) notee3 = Note(DiatonicPitch(5, 'd'), Duration(1, 16)) line2 = Line([notee0, notee1, notee2]) line2.pin(notee3, Offset(1, 2)) print(line2) voice = Voice(violin) voice.pin(line1, Offset(1, 4)) voice.pin(line2, Offset(0, 1)) print(voice) interval = Interval(Position(1, 2), Position(1)) notes = voice.get_notes_by_interval(interval) assert len(notes) == 3 assert TestVoice.has_pitch(notes, DiatonicPitch.parse('D:4')) assert TestVoice.has_pitch(notes, DiatonicPitch.parse('E:4')) assert TestVoice.has_pitch(notes, DiatonicPitch.parse('D:5')) interval = Interval(Position(1, 4), Position(7, 16)) notes = voice.get_notes_by_interval(interval) assert len(notes) == 5 assert TestVoice.has_pitch(notes, DiatonicPitch.parse('A:4')) assert TestVoice.has_pitch(notes, DiatonicPitch.parse('B:4')) assert TestVoice.has_pitch(notes, DiatonicPitch.parse('C:4')) assert TestVoice.has_pitch(notes, DiatonicPitch.parse('B:5')) assert TestVoice.has_pitch(notes, DiatonicPitch.parse('C:5'))
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 test_manual_create_catalog(self): catalog = InstrumentCatalog(xml_file='') inst_class = InstrumentClass("Strings") catalog.add_instrument_class(inst_class) inst_family = InstrumentFamily("Violins") inst_class.add_family(inst_family) instrument = Instrument("My Violin", 'C', 'C:3', 'C:7', None, None) inst_family.add_instrument(instrument) catalog.print_catalog()
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 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_inst_maps(self): c = InstrumentCatalog.instance() inst = c.get_instrument("vIOlin") assert inst is not None assert inst.name.startswith('Violin') print(inst) instf = c.get_instruments("vIOLin") assert instf is not None assert len(instf) >= 1 assert instf[0].name.startswith('Violin') print('[{0}]'.format(','.join(str(s) for s in instf))) instf = c.get_instruments("Clarinet") assert instf is not None assert len(instf) > 1 assert instf[0].name.startswith('Clarinet') print('[{0}]'.format(', '.join(str(inst) for inst in instf)))
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 test_add_notes_to_tuplet(self): c = InstrumentCatalog.instance() violin = c.get_instrument("violin") note0 = Note(DiatonicPitch(4, 'a'), Duration(1, 8)) note1 = Note(DiatonicPitch(4, 'b'), Duration(1, 8)) note2 = Note(DiatonicPitch(4, 'c'), Duration(1, 8)) note3 = Note(DiatonicPitch(4, 'd'), Duration(1, 8)) beam = Beam([note0, note1]) line = Line() line.pin(beam, Offset(1, 2)) voice = Voice(violin) voice.pin(line, Offset(0)) tuplet = Tuplet(Duration(1, 8), 3, [note2, note3]) beam.append(tuplet) notee0 = Note(DiatonicPitch(5, 'a'), Duration(1, 8)) tuplet.append(notee0) print(voice) notes = voice.get_notes_starting_in_interval( Interval(Position(1, 2), Position(5, 4))) assert len(notes) == 5 assert TestVoice.has_pitch(notes, DiatonicPitch.parse('A:5')) beam_prime = beam.clone() notes = beam_prime.get_all_notes() AbstractNote.print_structure(beam_prime) assert notes[0].duration == Duration(1, 8) assert str(notes[0].diatonic_pitch) == 'A:4' line_prime = line.clone() notes = line_prime.get_all_notes() AbstractNote.print_structure(line_prime) assert notes[0].duration == Duration(1, 8) assert str(notes[0].diatonic_pitch) == 'A:4' assert notes[2].duration == Duration(1, 8) assert str(notes[2].diatonic_pitch) == 'C:4'
def test_single_voice(self): print('test single voice') note0 = Note(DiatonicPitch(4, 'c'), Duration(1, 8)) note1 = Note(DiatonicPitch(4, 'd'), Duration(1, 8), 1) note2 = Note(DiatonicPitch(4, 'e'), Duration(1, 16)) beam = Beam([note0, note1, note2]) print(beam) assert beam.cardinality() == 3 line = Line(beam) assert line.length() == Duration(3, 8) c = InstrumentCatalog.instance() violin = c.get_instrument("violin") voice = Voice(violin) voice.pin(line, Offset(3, 4)) coverage = voice.coverage() print('Coverage = {0}'.format(coverage)) assert coverage.lower == Position(3, 4) assert coverage.upper == Position(9, 8) assert voice.length() == Duration(9, 8) interval = Interval(Position(15, 16), Position(9, 8)) notes = voice.get_notes_by_interval(interval) print(', '.join([str(n) for n in notes])) for n in notes: intvl = TestVoice.compute_note_interval(n) print('{0} intersect {1} = {2}'.format( intvl, interval, intvl.intersection(interval))) assert len(notes) == 2 print(notes[0].get_absolute_position(), notes[1].get_absolute_position()) assert TestVoice.has_pitch(notes, DiatonicPitch.parse('D:4')) assert TestVoice.has_pitch(notes, DiatonicPitch.parse('E:4'))
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))
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_remove_notes(self): c = InstrumentCatalog.instance() violin = c.get_instrument("violin") note0 = Note(DiatonicPitch(4, 'a'), Duration(1, 8)) note1 = Note(DiatonicPitch(4, 'b'), Duration(1, 8)) note2 = Note(DiatonicPitch(4, 'c'), Duration(1, 8)) note3 = Note(DiatonicPitch(4, 'd'), Duration(1, 8)) line = Line() line.pin(note0, Offset(1, 4)) line.pin(note1, Offset(3, 8)) line.pin(note2, Offset(1, 2)) line.pin(note3, Offset(5, 8)) voice = Voice(violin) voice.pin(line, Offset(0)) line.unpin([note1, note2]) notes = voice.get_all_notes() assert len(notes) == 2 assert note0 in notes assert note3 in notes assert note1 not in notes assert note2 not in notes notes = voice.get_notes_starting_in_interval( Interval(Position(0), Position(2, 1))) assert len(notes) == 2 line.clear() notes = voice.get_all_notes() assert len(notes) == 0 notes = voice.get_notes_starting_in_interval( Interval(Position(0), Position(2, 1))) assert len(notes) == 0
def convert_line(line, filename, tempo=Tempo(60, Duration(1, 4)), time_signature=TimeSignature(4, Duration(1, 4)), instrument_name='piano'): """ Static method to convert a Line to a midi file Args: line: Class Line object filename: The name of the midi file, should have filetype .mid tempo: Tempo for playback, default is 60 BPM tempo beat = quarter note time_signature: TimeSiganture on playback, default is 4 quarter notes instrument_name: Name of instrument ot use for playback. """ 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() instrument = c.get_instrument(instrument_name) if instrument is None: print('Error: instrument {0} cannnot be found'.format( instrument_name)) return instrument_voice = InstrumentVoice(instrument, 1) piano_voice = instrument_voice.voice(0) piano_voice.pin(line, Offset(0)) score.add_instrument_voice(instrument_voice) ScoreToMidiConverter.convert_score(score, filename)