def test_book_example(self): print('----- book_example -----') voice_line = Line() melody_line = Line() melody_1 = Line( [Note(DiatonicPitch(4, y), Duration(1, 8)) for y in 'aceg']) melody_2 = Line( [Note(DiatonicPitch(4, y), Duration(1, 8)) for y in 'cadg']) base_line = Line( [Note(DiatonicPitch(4, y), Duration(1, 4)) for y in 'dddddddd']) melody_line.pin(melody_1, Offset(1, 8)) melody_line.pin(melody_2, Offset(1, 4)) voice_line.pin(melody_line) voice_line.pin(base_line) print(voice_line) all_notes = voice_line.get_all_notes() print('... pinned notes ...') for n in all_notes: print('({0}) : {1}'.format(n.get_absolute_position(), n.diatonic_pitch)) print('... end pinned notes ...') print('End test_pin')
def test_simple_fixed_pitch(self): logging.debug('Start test_simple_fixed_pitch') note = Note(DiatonicPitch.parse("C:5"), Duration(1, 4)) select_notes = {'A:5', 'C:4', 'Eb:2', 'F#:6'} constraint = FixedPitchSelectSetConstraint( note, {DiatonicPitch.parse(p) for p in select_notes}) policy_context = TestFixedPitchSelectSetConstraint.policy_creator( ModalityType.Major, DiatonicTone('C'), 'tIV', 'C:2', 'C:8') lower_contextual = ContextualNote(policy_context) p_map = PMap() p_map[note] = lower_contextual v_results = constraint.values(p_map, note) assert v_results is not None assert len(v_results) == len(select_notes) for result in v_results: print(str(result)) assert select_notes == {str(n.diatonic_pitch) for n in v_results} assert not constraint.verify(p_map) lower_contextual.note = Note(DiatonicPitch.parse('Eb:2'), Duration(1, 4)) assert constraint.verify(p_map)
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 test_book_example(self): # Creating a beam with 1/8, 3/8, and 1/16 notes 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)
def test_add_note_at_lower_level(self): print('start test_add_note_at_lower_level') sub_beam = Beam([ Note(DiatonicPitch(2, 'c'), Duration(1, 8)), Note(DiatonicPitch(2, 'd'), Duration(1, 8)) ]) beam = Beam([ Note(DiatonicPitch(3, 'c'), Duration(1, 8)), sub_beam, Note(DiatonicPitch(3, 'd'), Duration(1, 8)) ]) AbstractNote.print_structure(beam) notes = beam.get_all_notes() assert len(notes) == 4 assert beam.sub_notes[1].duration == Duration(1, 8) assert beam.sub_notes[1].relative_position == Offset(1, 8) assert beam.sub_notes[1].sub_notes[1].duration == Duration(1, 16) assert beam.sub_notes[1].sub_notes[1].relative_position == Offset( 1, 16) sub_beam.add(Note(DiatonicPitch(2, 'c'), Duration(1, 8)), 1) AbstractNote.print_structure(beam) assert beam.sub_notes[1].duration == Duration(3, 16) assert beam.sub_notes[1].relative_position == Offset(1, 8) assert beam.sub_notes[1].sub_notes[1].duration == Duration(1, 16) assert beam.sub_notes[1].sub_notes[1].relative_position == Offset( 1, 16)
def test_from_book(self): # Quarter note at C:4 note = Note(DiatonicPitch(4, 'c'), Duration(1, 4)) print('{0} duration={1}'.format(note.diatonic_pitch, note.duration)) # Double dotted quarter not at F#:5 note = Note(DiatonicPitch(5, 'f#'), 'Q', 2) print('{0} duration={1}'.format(note.diatonic_pitch, note.duration))
def test_basic_policy(self): logging.debug('Start test_basic_policy') lower_policy_context = TestRelativeScalarStepConstraint.policy_creator( ModalityType.Major, DiatonicTone('G'), 'tV', 'C:2', 'C:8') note1 = Note(DiatonicPitch.parse('C:5'), Duration(1, 8)) note2 = Note(DiatonicPitch.parse('D:5'), Duration(1, 8)) lower_note_1 = ContextualNote( lower_policy_context, Note(DiatonicPitch.parse('F#:5'), Duration(1, 8))) lower_note_2 = ContextualNote(lower_policy_context) p_map = dict([(note1, lower_note_1), (note2, lower_note_2)]) # F#:5 --> G Major two below and 3 above policy = RelativeScalarStepConstraint(note1, note2, -2, 3) v_result = policy.values(p_map, note2) pitches = [n.diatonic_pitch for n in v_result] assert len(pitches) == 6 for s in ['D:5', 'E:5', 'F#:5', 'G:5', 'A:5', 'B:5']: assert DiatonicPitch.parse(s) in pitches for note in v_result: logging.debug(note) # Check verify for each answer for n in v_result: lower_note_2.note = n assert policy.verify(p_map) logging.debug('End test_basic_policy')
def test_basic_construction(self): note = Note(DiatonicPitch(4, 'c'), Duration(1, 4)) print(note) assert note.base_duration == Duration(1, 4) assert note.duration == Duration(1, 4) assert str(note.diatonic_pitch) == 'C:4' assert not note.is_rest # quarter rest note = Note(None, Duration(1, 4)) print(note) assert note.base_duration == Duration(1, 4) assert note.duration == Duration(1, 4) assert note.diatonic_pitch is None assert note.is_rest note = Note(DiatonicPitch(4, 'c'), Duration(1, 4), 2) print(note) assert note.base_duration == Duration(1, 4) assert note.duration == Duration(7, 16) assert str(note.diatonic_pitch) == 'C:4' assert not note.is_rest note = Note(DiatonicPitch(5, 'f#'), 'Q', 2) print(note) assert note.base_duration == Duration(1, 4) assert note.duration == Duration(7, 16) assert str(note.diatonic_pitch) == 'F#:5' assert not note.is_rest
def test_reversal_on_policy(self): logging.debug('Start test_reversal_on_policy') lower_policy_context = TestRelativeScalarStepConstraint.policy_creator( ModalityType.Major, DiatonicTone('G'), 'tV', 'C:2', 'C:8') note1 = Note(DiatonicPitch.parse('C:5'), Duration(1, 8)) note2 = Note(DiatonicPitch.parse('D:5'), Duration(1, 8)) lower_note_1 = ContextualNote(lower_policy_context) lower_note_2 = ContextualNote( lower_policy_context, Note(DiatonicPitch.parse('C:5'), Duration(1, 8))) p_map = dict([(note1, lower_note_1), (note2, lower_note_2)]) # F#:5 --> G Major two below and 3 above policy = RelativeScalarStepConstraint(note1, note2, -2, 3) result = policy.values(p_map, note1) pitches = [n.diatonic_pitch for n in result] for pitch in pitches: logging.debug(pitch) # Check that each returned verifies for n in result: lower_note_1.note = n assert policy.verify(p_map) logging.debug('End test_reversal_on_policy')
def test_across_tonalities(self): logging.debug('Start test_across_tonalities.') lower_policy_context_1 = TestRelativeDiatonicConstraint.policy_creator( ModalityType.Major, DiatonicTone('G'), 'tV', 'C:2', 'C:8') lower_policy_context_2 = TestRelativeDiatonicConstraint.policy_creator( ModalityType.Major, DiatonicTone('Ab'), 'tI', 'C:2', 'C:8') upper_note_1 = Note(DiatonicPitch.parse('C:5'), Duration(1, 8)) upper_note_2 = Note(DiatonicPitch.parse('D:5'), Duration(1, 8)) lower_note_1 = ContextualNote( lower_policy_context_1, Note(DiatonicPitch.parse('F#:5'), Duration(1, 8))) lower_note_2 = ContextualNote(lower_policy_context_2) p_map = dict([(upper_note_1, lower_note_1), (upper_note_2, lower_note_2)]) policy = RelativeDiatonicConstraint(upper_note_1, upper_note_2, Interval(3, IntervalType.Minor), Interval(3, IntervalType.Major)) v_result = policy.values(p_map, upper_note_2) for note in v_result: logging.debug(note) pitches = [note.diatonic_pitch for note in v_result] assert {str(p) for p in pitches} == {'Eb:5', 'F:5', 'G:5', 'Ab:5'} logging.debug('End test_across_tonalities.')
def test_simple_tuplet_reverse(self): print('test simple tuplet reverse') a = Note(DiatonicPitch(3, 'a'), Duration(1, 8)) b = Note(DiatonicPitch(3, 'b'), Duration(1, 8)) c = Note(DiatonicPitch(3, 'c'), Duration(1, 8)) d = Note(DiatonicPitch(3, 'd'), Duration(1, 8)) tuplet = Tuplet(Duration(1, 8), 3, [a, b, c, d]) print(tuplet) tuplet.reverse() print(tuplet) notes = tuplet.get_all_notes() assert notes is not None assert len(notes) == 4 assert notes[0].diatonic_pitch == DiatonicPitch(3, 'd') assert notes[1].diatonic_pitch == DiatonicPitch(3, 'c') assert notes[2].diatonic_pitch == DiatonicPitch(3, 'b') assert notes[3].diatonic_pitch == DiatonicPitch(3, 'a') assert notes[0].relative_position == Offset(0) assert notes[1].relative_position == Offset(3, 32) assert notes[2].relative_position == Offset(3, 16) assert notes[3].relative_position == Offset(9, 32)
def test_simple_beam_reverse(self): print('test simple beam reverse') a = Note(DiatonicPitch(3, 'a'), Duration(1, 8)) b = Note(DiatonicPitch(3, 'b'), Duration(1, 8)) c = Note(DiatonicPitch(3, 'c'), Duration(1, 8)) d = Note(DiatonicPitch(3, 'd'), Duration(1, 8)) beam = Beam([a, b, c, d]) print(beam) beam.reverse() print(beam) notes = beam.get_all_notes() assert notes is not None assert len(notes) == 4 assert notes[0].diatonic_pitch == DiatonicPitch(3, 'd') assert notes[1].diatonic_pitch == DiatonicPitch(3, 'c') assert notes[2].diatonic_pitch == DiatonicPitch(3, 'b') assert notes[3].diatonic_pitch == DiatonicPitch(3, 'a') assert notes[0].relative_position == Offset(0) assert notes[1].relative_position == Offset(1, 8) assert notes[2].relative_position == Offset(1, 4) assert notes[3].relative_position == Offset(3, 8)
def test_is_equal(self): logging.debug('Start test_is_equal') note1 = Note(DiatonicPitch.parse('C:5'), Duration(1, 8)) note2 = Note(DiatonicPitch.parse('C:5'), Duration(1, 8)) lower_policy_context = TestEqualPitchConstraint.policy_creator( ModalityType.Major, DiatonicTone('G'), 'tV', 'C:2', 'C:8') lower_context_note_a = ContextualNote( lower_policy_context, Note(DiatonicPitch.parse('F#:6'), Duration(1, 8))) lower_context_note_b = ContextualNote(lower_policy_context) parameter_map = dict([(note1, lower_context_note_a), (note2, lower_context_note_b)]) parameter_map = PMap(parameter_map) policy = EqualPitchConstraint([note1, note2]) result = policy.values(parameter_map, note2) actual_note = next(iter(result)) print('test_is_equal; note = {0}'.format(actual_note)) assert actual_note.diatonic_pitch == DiatonicPitch.parse("F#:6") assert actual_note.base_duration == Duration(1, 8) parameter_map[note2].note = actual_note assert policy.verify(parameter_map) is True logging.debug('End test_is_equal')
def test_simple_major_scale_descent_two_steps(self): logging.debug('Start test_simple_major_scale_descent_two_steps') upper_context_notes = list() for s in ['C:6', 'A:5', 'F:5', 'D:5', 'B:4']: upper_context_notes.append(Note(DiatonicPitch.parse(s), Duration(1, 8))) lower_policy_context = TestPitchStepConstraint.policy_creator(ModalityType.Major, DiatonicTone('G'), 'tV', 'C:2', 'C:8') lower_context_notes = list() for s in range(0, len(upper_context_notes)): lower_context_notes.append(ContextualNote(lower_policy_context)) lower_context_notes[0].note = Note(DiatonicPitch.parse("E:5"), Duration(1, 8)) parameter_map = dict() policies = [] for s, sp in zip(upper_context_notes, lower_context_notes): parameter_map[s] = sp for i in range(0, len(upper_context_notes) - 1): policies.append(PitchStepConstraint(upper_context_notes[i], upper_context_notes[i + 1], 2, PitchStepConstraint.Down)) answers = ['C:5', 'A:4', 'F#:4', 'D:4'] for policy, answer in zip(policies, answers): result = policy.values(parameter_map, policy.note_two) note = next(iter(result)) print(note) assert str(note.diatonic_pitch) == answer parameter_map[policy.note_two].note = note assert policy.verify(parameter_map) logging.debug('End test_simple_major_scale_descent_two_steps')
def test_another_book_example(self): # Creating a simple line of 2 eighth notes a quarter note and a half note. vnote0 = Note(DiatonicPitch(4, 'a'), Duration(1, 8)) vnote1 = Note(DiatonicPitch(4, 'b'), Duration(1, 8)) vnote2 = Note(DiatonicPitch(4, 'c'), Duration(1, 4)) vnote3 = Note(DiatonicPitch(4, 'd'), Duration(1, 2)) line = Line([vnote0, vnote1, vnote2, vnote3]) AbstractNote.print_structure(line)
def test_nested_notes(self): note1 = Note(DiatonicPitch(4, 'c'), Duration(1, 8)) note2 = Note(DiatonicPitch(4, 'd'), Duration(1, 8)) note3 = Note(DiatonicPitch(4, 'e'), Duration(1, 16)) sub_beam = Beam([note1, note2, note3]) beam = Beam() beam.append(Note(DiatonicPitch(4, 'f'), Duration(1, 8))) beam.append(sub_beam) beam.append(Note(DiatonicPitch(4, 'g'), Duration(1, 8))) print(beam) notes = beam.get_all_notes() assert len(notes) == 5 assert notes[0].diatonic_pitch == DiatonicPitch(4, 'f') assert notes[1].diatonic_pitch == DiatonicPitch(4, 'c') assert notes[2].diatonic_pitch == DiatonicPitch(4, 'd') assert notes[3].diatonic_pitch == DiatonicPitch(4, 'e') assert notes[4].diatonic_pitch == DiatonicPitch(4, 'g') assert notes[0].relative_position == Offset(0) assert notes[1].relative_position == Offset(0) assert notes[2].relative_position == Offset(1, 16) assert notes[3].relative_position == Offset(1, 8) assert notes[4].relative_position == Offset(9, 32) TestBeam.print_all_notes(notes) notes = sub_beam.get_all_notes() TestBeam.print_all_notes(notes) b = Beam() b.append(beam) notes = sub_beam.get_all_notes() TestBeam.print_all_notes(notes) assert notes[0].duration == Duration(1, 32) assert str(notes[0].diatonic_pitch) == 'C:4' sub_beam_prime = sub_beam.clone() notes = sub_beam_prime.get_all_notes() TestBeam.print_all_notes(notes) assert notes[0].duration == Duration(1, 8) assert str(notes[0].diatonic_pitch) == 'C:4' beam_prime = beam.clone() notes = beam_prime.get_all_notes() TestBeam.print_all_notes(notes) assert notes[0].duration == Duration(1, 8) assert str(notes[0].diatonic_pitch) == 'F:4' b_prime = b.clone() notes = b_prime.get_all_notes() TestBeam.print_all_notes(notes) assert notes[0].duration == Duration(1, 16) assert str(notes[0].diatonic_pitch) == 'F:4'
def test_simple_cross_tonality(self): logging.debug('Start test_simple_cross_tonality') # upper_policy_context = TestStepSequenceConstraint.policy_creator(ModalityType.Major, DiatonicTone('C'), 'tIV', # 'C:2', 'C:8') lower_policy_context_1 = TestStepSequenceConstraint.policy_creator(ModalityType.Major, DiatonicTone('G'), 'tV', 'C:2', 'C:8') lower_policy_context_2 = TestStepSequenceConstraint.policy_creator(ModalityType.Major, DiatonicTone('B'), 'tV', 'C:2', 'C:8') upper_pitch_txts = ['C:5', 'D:5', 'E:5', 'F:5'] tonalities = [lower_policy_context_1, lower_policy_context_1, lower_policy_context_2, lower_policy_context_2] differentials = [1, 1, 1] actors = list() p_map = dict() for i in range(0, len(upper_pitch_txts)): upper_note = Note(DiatonicPitch.parse(upper_pitch_txts[i]), Duration(1, 8)) lower_note = ContextualNote(tonalities[i]) actors.append(upper_note) p_map[upper_note] = lower_note policy = StepSequenceConstraint(actors, differentials) p_map[actors[0]].note = Note(DiatonicPitch.parse('B:5'), Duration(1, 8)) answers = ['B:6', 'C:6', 'C#:6', 'D#:6'] for i in range(1, len(actors)): notes = policy.values(p_map, actors[i]) for note in notes: print(note.diatonic_pitch) assert str(next(iter(notes)).diatonic_pitch) == answers[i] print("------") upper_pitch_txts = ['F#:5', 'E:5', 'D:5', 'C:5'] tonalities = [lower_policy_context_1, lower_policy_context_1, lower_policy_context_2, lower_policy_context_2] differentials = [-1, -1, -1] actors = list() p_map = dict() for i in range(0, len(upper_pitch_txts)): upper_note = Note(DiatonicPitch.parse(upper_pitch_txts[i]), Duration(1, 8)) lower_note = ContextualNote(tonalities[i]) actors.append(upper_note) p_map[upper_note] = lower_note policy = StepSequenceConstraint(actors, differentials) p_map[actors[0]].note = Note(DiatonicPitch.parse('F#:6'), Duration(1, 8)) answers = ['F#:6', 'E:6', 'D#:6', 'C#:6'] for i in range(1, len(actors)): notes = policy.values(p_map, actors[i]) for note in notes: print(note.diatonic_pitch) assert str(next(iter(notes)).diatonic_pitch) == answers[i] print("------") logging.debug('End test_simple_cross_tonality')
def test_line_convert(self): note1 = Note(DiatonicPitch(4, 'c'), Duration(1, 16)) note2 = Note(DiatonicPitch(4, 'd'), Duration(1, 16)) note3 = Note(DiatonicPitch(4, 'e'), Duration(1, 16)) note4 = Note(DiatonicPitch(4, 'f'), Duration(1, 16)) beam = Beam([note1, note2, note3, note4]) line = Line(beam) ScoreToMidiConverter.convert_line(line, 'line_output_file.mid') TestScoreToMidiConverter.read_midi_file('line_output_file.mid')
def test_odd_structure(self): print('test odd structure') n1 = Note(DiatonicPitch(4, 'c'), Duration(1, 12)) n2 = Note(DiatonicPitch(4, 'c'), Duration(1, 12)) from structure.tuplet import Tuplet tuplet = Tuplet(Duration(1, 12), 1, [n1, n2]) n3 = Note(DiatonicPitch(4, 'd'), Duration(1, 8)) beam = Beam([tuplet, n3]) AbstractNote.print_structure(beam)
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_motif_book_example(self): s = Beam() s.append(Note(DiatonicPitch.parse('C:4'), Duration(1, 8))) s.append(Note(DiatonicPitch.parse('D:4'), Duration(1, 8))) s.append(Note(DiatonicPitch.parse('C:4'), Duration(1, 8))) s.append(Note(DiatonicPitch.parse('F#:4'), Duration(1, 8))) notes = s.get_all_notes() c = [ EqualPitchConstraint([notes[0], notes[2]]), NotEqualPitchConstraint([notes[1], notes[3]]) ] m = Motif(s, c, 'A') cs = Beam() cs.append(Note(DiatonicPitch.parse('C:5'), Duration(1, 8))) cs.append(Note(DiatonicPitch.parse('D:5'), Duration(1, 8))) cs.append(Note(DiatonicPitch.parse('C:5'), Duration(1, 8))) cs.append(Note(DiatonicPitch.parse('F#:5'), Duration(1, 8))) c_motif = m.copy_to(cs.get_all_notes()[0]) assert 'A' == c_motif.name assert len(c_motif.actors) == len(notes) assert len(c_motif.constraints) == len(c) assert isinstance(c_motif.constraints[0], EqualPitchConstraint) assert c_motif.constraints[0].actors[0] == c_motif.actors[0] assert c_motif.constraints[0].actors[1] == c_motif.actors[2] assert isinstance(c_motif.constraints[1], NotEqualPitchConstraint) assert c_motif.constraints[1].actors[0] == c_motif.actors[1] assert c_motif.constraints[1].actors[1] == c_motif.actors[3]
def recursive_dilate(self, strct, new_to_old_map): if isinstance(strct, Note): d = strct.base_duration.duration / strct.contextual_reduction_factor n = Note(strct.diatonic_pitch, Duration(d * self.dilation_factor), strct.num_dots) new_to_old_map[n] = strct return n else: collect = list() for s in strct.sub_notes: collect.append(self.recursive_dilate(s, new_to_old_map)) if isinstance(strct, Beam): b = Beam(collect) new_to_old_map[b] = strct return b elif isinstance(strct, Tuplet): t = Tuplet(strct.unit_duration * self.dilation_factor, strct.unit_duration_factor, collect) new_to_old_map[t] = strct return t elif isinstance(strct, Line): line = Line() new_to_old_map[line] = strct for s in collect: line.pin( s, new_to_old_map[s].relative_position * self.dilation_factor) return line
def _build_p_map_dict(self, partial_pitch_results=None): actors = OrderedSet() for p in self.pitch_constraints: actors = actors.union(p.actors) d = OrderedDict() for note in actors: hc = self.hct[note.get_absolute_position().position] if hc is None: raise Exception( 'Cannot locate harmonic context for note \'{0}\''.format( note)) contextual = ContextualNote(PolicyContext(hc, self.pitch_range)) d[note] = contextual if partial_pitch_results is not None: for k, v in partial_pitch_results.items(): if not isinstance(k, Note): raise Exception( 'key of partial_pitch_results must be a Note.') if not isinstance(v, DiatonicPitch): raise Exception( 'value of partial_pitch_results must be a DiatonicPitch.' ) if k not in d: raise Exception( 'Note \'{0}\' of partial result is not a constraint actor.' .format(k)) d[k].note = Note(v, k.base_duration, k.num_dots) return d
def build_line(note_spec_list): note_list = list() for spec in note_spec_list: pitch = DiatonicPitch.parse(spec[0]) n = Note(pitch, Duration(spec[1][0], spec[1][1])) note_list.append(n) return Line(note_list)
def test_non_scale_note(self): logging.debug('Start test_non_scale_note') note = Note(DiatonicPitch.parse("Bb:4"), Duration(1, 4)) policy = FixedPitchConstraint(note, DiatonicPitch.parse("Ab:5")) policy_context = TestFixedPitchConstraint.policy_creator( ModalityType.Major, DiatonicTone('C'), 'tIV', 'C:2', 'C:8') contextual_note = ContextualNote(policy_context) p_map = PMap() p_map[note] = contextual_note v_result = policy.values(p_map, note) result = next(iter(v_result)) print('test_non_scale_note note= {0}'.format(result)) assert result.diatonic_pitch == DiatonicPitch.parse("Ab:5") assert result.base_duration == Duration(1, 4) contextual_note.note = result result = policy.verify(p_map) assert result is True logging.debug('end test_non_scale_note')
def test_add_post_beam_note(self): print('test add post beam note.') note1 = Note(DiatonicPitch(4, 'c'), Duration(1, 8)) note2 = Note(DiatonicPitch(4, 'd'), Duration(1, 8)) note3 = Note(DiatonicPitch(4, 'e'), Duration(1, 16)) sub_beam = Beam([note1, note2, note3]) parent_beam = Beam() parent_beam.append(Note(DiatonicPitch(4, 'f'), Duration(1, 8))) parent_beam.append(sub_beam) print(parent_beam) note4 = Note(DiatonicPitch(4, 'e'), Duration(1, 16)) sub_beam.append(note4) print(parent_beam)
def test_is_chordal(self): logging.debug('Start test_is_chordal') upper_context_note = Note(DiatonicPitch.parse('F:5'), Duration(1, 4)) lower_policy_context = TestChordalToneConstraint.policy_creator(ModalityType.Major, DiatonicTone('G'), 'tV', 'C:2', 'C:8') lower_context_note = ContextualNote(lower_policy_context) parameter_map = dict([(upper_context_note, lower_context_note)]) policy = ChordalPitchConstraint(upper_context_note) v_result = policy.values(parameter_map, upper_context_note) results = {DiatonicTone('D'), DiatonicTone('F#'), DiatonicTone('A')} for note in v_result: print('test_is_chordal; note = {0}'.format(note)) tone = note.diatonic_pitch.diatonic_tone octave = note.diatonic_pitch.octave assert tone in results assert octave in range(2, 9) assert len(v_result) == 6 * 3 for note in v_result: parameter_map[upper_context_note].note = note assert policy.verify(parameter_map) is True logging.debug('End test_is_chordal')
def test_enharmonic_fixed_tone(self): logging.debug('Start test_enharmonic_fixed_tone') note = Note(DiatonicPitch.parse("C:5"), Duration(1, 4)) policy = FixedToneConstraint(note, DiatonicToneCache.get_tone("Bbb")) lower_policy_context = TestFixedToneConstraint.policy_creator(ModalityType.Major, DiatonicTone('G'), 'tV', 'C:2', 'C:8') lower_contextual_note = ContextualNote(lower_policy_context) m = dict([(note, lower_contextual_note)]) v_result = policy.values(m, note) assert len(v_result) == 6 for note in v_result: print('test_simple_fixed_tone pitch = {0}'.format(note.diatonic_pitch)) assert note.diatonic_pitch.diatonic_tone == DiatonicToneCache.get_tone('A') assert note.base_duration == Duration(1, 4) lower_contextual_note.note = note result = policy.verify(m) assert result is True lower_contextual_note.note = None logging.debug('End test_enharmonic_fixed_tone')
def values(self, p_map, v_note): if v_note != self.actor_note: raise Exception("Illegal v_note {0} for constraint".format(v_note)) if p_map[v_note].note is not None: if p_map[v_note].note.diatonic_pitch.chromatic_distance in (p.chromatic_distance for p in self.pitches): return OrderedSet[p_map[v_note].note] raise Exception('Fixed Pitch Select Set Constraint Violated has {0} not in pitch set'.format( p_map[v_note].note.diatonic_pitch)) # Return all pitches (self.pitches) except though, for each # select a representation closest to the target tonality, if it exists. tonality = p_map[self.actor_note].policy_context.harmonic_context.tonality result_pitches = [] for pitch in self.pitches: found_pitch = pitch for p in pitch.enharmonics(): if p.diatonic_tone in tonality.annotation: found_pitch = p break result_pitches.append(found_pitch) result = OrderedSet() for p in result_pitches: result.add(Note(p, self.actor_note.base_duration, self.actor_note.num_dots)) return result