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 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_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 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 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_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(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 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 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_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_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 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 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 __init__(self): """ Constructor. """ self.__instrument_voices = list() # map from instrument class to the instrument voices added. self.class_map = dict() # map instrument class name to InstrumentClass self.name_class_map = dict() # HCT not utilized, TODO self.__hct = HarmonicContextTrack() self.__tempo_sequence = TempoEventSequence() self.__time_signature_sequence = TimeSignatureEventSequence()
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 __init__(self, line, harmonic_context_track=None, instrument=None, tempo_seq=None, ts_seq=None): """ LiteScore constructor. :param line: Used as the single voice of the score. :param harmonic_context_track: provides the harmony for the line. :param instrument: Optionally an Instrument for the line :param tempo_seq: Optionally, a TempoEventSequence :param ts_seq: Optionally, a TimeSignatureEventSequence """ self.__line = line self.__hct = HarmonicContextTrack( ) if harmonic_context_track is None else harmonic_context_track self.__instrument = instrument self.__tempo_sequence = tempo_seq if tempo_seq is not None else TempoEventSequence( ) self.__time_signature_sequence = ts_seq if ts_seq is not None else TimeSignatureEventSequence( )
def test_simple_setup(self): print('--- test_simple_setup') line = Line() notes = [ Note(DiatonicPitch.parse('a:4'), Duration(1, 4)), Note(DiatonicPitch.parse('b:4'), Duration(1, 4)), Note(DiatonicPitch.parse('c:4'), Duration(1, 4)), Note(DiatonicPitch.parse('d:4'), Duration(1, 4)), Note(DiatonicPitch.parse('e:4'), Duration(1, 2)), Note(DiatonicPitch.parse('f:4'), Duration(1, 2)), ] location = 0 for note in notes: line.pin(note, Offset(location)) location += note.duration.duration 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))) diatonic_tonality = Tonality.create(ModalityType.Major, DiatonicTone("C")) chord_t = TertianChordTemplate.parse('tIV') chord = chord_t.create_chord(diatonic_tonality) hc_track = HarmonicContextTrack() hc_track.append( HarmonicContext(diatonic_tonality, chord, Duration(1, 1))) hc_track.append( HarmonicContext(diatonic_tonality, chord, Duration(1, 2))) hc_track.append( HarmonicContext(diatonic_tonality, chord, Duration(1, 2))) c = InstrumentCatalog.instance() violin = c.get_instrument("violin") score = LiteScore(line, hc_track, violin, tempo_seq, ts_seq) constraints = [ OnBeatConstraint(notes[1], BeatType.Strong), StepSequenceConstraint(notes, [1, 1, 1, -1, -1]) ] solver = MelodicConstraintSolver.create(score, constraints) cheat = {notes[2]: DiatonicPitch.parse('E:5')} results = solver.solve(cheat) assert results is not None assert results.beat_results is not None assert results.pitch_results is not None print(len(results.beat_results)) print(len(results.pitch_results)) assert 1 == len(results.beat_results) assert 1 == len(results.pitch_results) new_line = results.apply(next(iter(results.beat_results)), next(iter(results.pitch_results))) assert new_line is not None print(new_line) all_notes = new_line.get_all_notes() assert 'C:5' == str(all_notes[0].diatonic_pitch) assert 'D:5' == str(all_notes[1].diatonic_pitch) assert 'E:5' == str(all_notes[2].diatonic_pitch) assert 'F:5' == str(all_notes[3].diatonic_pitch) assert 'E:5' == str(all_notes[4].diatonic_pitch) assert 'D:5' == str(all_notes[5].diatonic_pitch) assert Position(3, 4) == all_notes[1].get_absolute_position()
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