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_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_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_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_sub_line_reversal(self):
print('----- test sub line reversal -----')
source_instance_expression = '{<C-Major:I> qC:4 D E F <:v> [iD:5 B:4 A G] qC:5 D <:IV> A:4 iF E hC}'
lite_score = TestTRetrograde.create_score(source_instance_expression,
'piano', (4, 4, 'swww'))
trans = TRetrograde(lite_score)
print('--- With sub_line harmonic reversal ---')
reversed_line, hct = trans.apply(
True,
NumericInterval(Fraction(1, 2), Fraction(9, 4),
BoundaryPolicy.Closed))
print(str(lite_score.line))
print(str(lite_score.hct))
print(str(reversed_line))
print(str(hct))
score_hct_list = lite_score.hct.hc_list()
hct_list = hct.hc_list()
assert len(hct_list) == 3
assert len(score_hct_list) == 3
assert hct_list[0].is_same_harmony(score_hct_list[2])
assert hct_list[1].is_equal(score_hct_list[1])
assert hct_list[2].is_same_harmony(score_hct_list[0])
assert hct_list[0].duration == Duration(3, 8)
assert hct_list[1].duration == Duration(1)
assert hct_list[2].duration == Duration(1, 2)
def test_structures(self):
print('----- test structures -----')
source_instance_expression = '{<C-Major:I> [[[sE F G A] iC D]} }'
lite_score = TestTDilation.create_score(source_instance_expression, 'piano', (4, 4, 'swww'))
trans = TDilation(lite_score)
new_score = trans.apply(Fraction(2), False, True)
print(new_score.line)
new_line = new_score.line
notes = new_line.get_all_notes()
n = notes[0]
assert n is not None
assert n.duration == Duration(Fraction(1, 32))
source_instance_expression = '{<C-Major:I>(i, 2)[iC:3 D:4 E] }'
lite_score = TestTDilation.create_score(source_instance_expression, 'piano', (4, 4, 'swww'))
trans = TDilation(lite_score)
new_score = trans.apply(Fraction(2), False, True)
print(new_score.line)
new_line = new_score.line
notes = new_line.get_all_notes()
n = notes[0]
assert n is not None
assert n.duration == Duration(Fraction(1, 6))
def __init__(self, tempo_or_function, beat_duration=None):
"""
Constructor
.
Args:
tempo_or_function: Tempo for constant, Rational for constant, or UnivariateFunction.
beat_duration: whole note time duration (Duration) for a beat.
"""
if isinstance(tempo_or_function, Tempo):
self.fctn = ConstantUnivariateFunction(tempo_or_function.tempo, 0,
1)
if beat_duration:
raise Exception(
'Cannot specify beat_duration with Tempo specified.')
self.beat_duration = tempo_or_function.beat_duration
elif isinstance(tempo_or_function, Rational):
self.fctn = ConstantUnivariateFunction(tempo_or_function, 0, 1)
if not beat_duration:
beat_duration = Duration(1, 4)
self.beat_duration = beat_duration
elif isinstance(tempo_or_function, UnivariateFunction):
self.fctn = tempo_or_function
if not beat_duration:
beat_duration = Duration(1, 4)
self.beat_duration = beat_duration
else:
raise Exception('Illegal argument type {0)',
type(tempo_or_function))
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_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_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_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_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_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_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_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_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_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_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_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 test_for_book_example_2(self):
print('----- test for book example 2 -----')
source_instance_expression = '{<A-Major:i> [sA:4 A A A] qA:4 [iA:4 A] <:iv> qA:4 [sA:4 A A A] qA:4}'
target_instance_expression = '{<G-Major:i> wA:4 <:iv> wA:4}'
lge = LineGrammarExecutor()
source_instance_line, source_instance_hct = lge.parse(
source_instance_expression)
actors = source_instance_line.get_all_notes()
for a in actors:
print("{0}".format(a))
target_instance_line, target_instance_hct = lge.parse(
target_instance_expression)
target_hcs = target_instance_hct.hc_list()
for hc in target_hcs:
print("{0}".format(hc))
pitch_range = PitchRange(
DiatonicPitch.parse('C:4').chromatic_distance,
DiatonicPitch.parse('C:6').chromatic_distance)
p_map = PMap.create(source_instance_expression, pitch_range,
[('G-Major:I', Duration(3, 4)),
('G-Major:IV', Duration(3, 4))])
actors = p_map.actors
policies = OrderedSet()
policies.add(
StepSequenceConstraint(
[actors[0], actors[1], actors[2], actors[3]], [1, 1, 1]))
policies.add(ChordalPitchConstraint(actors[0]))
policies.add(ChordalPitchConstraint(actors[4]))
policies.add(ChordalPitchConstraint(actors[8]))
policies.add(
StepSequenceConstraint(
[actors[8], actors[9], actors[10], actors[11]], [1, -1, -1]))
policies.add(EqualPitchConstraint([actors[0], actors[12]]))
policies.add(EqualPitchConstraint([actors[4], actors[7]]))
policies.add(
RelativeDiatonicConstraint(actors[4], actors[5],
Interval(3, IntervalType.Major),
Interval(1, IntervalType.Perfect)))
policies.add(StepSequenceConstraint([actors[5], actors[6]], [-1]))
# policies.add(ChordalPitchConstraint(actors[7]))
solver = PitchConstraintSolver(policies)
full_results, partial_results = solver.solve(p_map)
print('Results has {0} results.'.format(len(full_results)))
for pm in full_results:
if str(pm[actors[7]].note.diatonic_pitch) == 'D:4' and str(
pm[actors[0]].note.diatonic_pitch) == 'G:4':
print("{0}".format(pm))
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_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 create_track(chords, tonality):
hc_track = HarmonicContextTrack()
for c in chords:
chord_t = ChordTemplate.generic_chord_template_parse(c[0])
chord = chord_t.create_chord(tonality)
duration = Duration(c[1]) if isinstance(c[1], int) else Duration(c[1][0], c[1][1])
hc_track.append(HarmonicContext(tonality, chord, duration))
return hc_track
def test_secondary_chord(self):
print('----- test_secondary_tonality -----')
diatonic_tonality = Tonality.create(ModalityType.Major,
DiatonicTone("C"))
chort_t_i = TertianChordTemplate.parse('tI')
chord_i = chort_t_i.create_chord(diatonic_tonality)
chord_v_ii = SecondaryChordTemplate.parse('V/ii').create_chord(
diatonic_tonality)
chord_vi_v = SecondaryChordTemplate.parse('vi/V').create_chord(
diatonic_tonality)
chord_t_ii = TertianChordTemplate.parse('tii')
chord_ii = chord_t_ii.create_chord(diatonic_tonality)
hc_track = HarmonicContextTrack()
hc_track.append(
HarmonicContext(diatonic_tonality, chord_i, Duration(1)))
hc_track.append(
HarmonicContext(diatonic_tonality, chord_v_ii, Duration(1)))
hc_track.append(
HarmonicContext(diatonic_tonality, chord_vi_v, Duration(1)))
hc_track.append(
HarmonicContext(diatonic_tonality, chord_ii, Duration(1)))
TestTFlip.print_hct(hc_track)
tune = [('C:5', (1, 1)), ('E:5', (1, 1)), ('E:5', (1, 1)),
('G:5', (1, 1))]
line = TestTFlip.build_line(tune)
cue = DiatonicPitch(5, 'd')
tflip = TDiatonicReflection(line, hc_track, cue)
temporal_extent = Interval(Fraction(0), Fraction(4))
score_line, score_hct = tflip.apply(temporal_extent, cue)
TestTFlip.print_notes(score_line)
TestTFlip.print_hct(score_hct)
notes = score_line.get_all_notes()
assert len(notes) == 4
assert str(notes[0].diatonic_pitch) == 'E:5'
assert str(notes[1].diatonic_pitch) == 'C#:5'
assert str(notes[2].diatonic_pitch) == 'C:5'
assert str(notes[3].diatonic_pitch) == 'A:4'
hc_list = score_hct.hc_list()
assert len(hc_list) == 4
assert hc_list[1].chord.primary_chord.chord_template.scale_degree == 7
assert {t[0].diatonic_symbol
for t in hc_list[1].chord.tones} == {'C#', 'E', 'G'}
assert hc_list[1].chord.primary_chord.chord_template.inversion == 3
assert hc_list[2].chord.primary_chord.chord_template.scale_degree == 7
assert {t[0].diatonic_symbol
for t in hc_list[2].chord.tones} == {'C', 'F#', 'A'}
assert hc_list[2].chord.primary_chord.chord_template.inversion == 3
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_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_book_examples(self):
p = Position(13, 8)
d = Duration(3, 4)
p0 = p + d
p1 = p - d
print('{0} = {1} + {2}'.format(p0, p, d))
print('{0} = {1} - {2}'.format(p1, p, d))
p += Duration(1, 8)
print('p={0}'.format(p))
d = Duration(1, 4) + d
print('d={0}'.format(d))
def _rebuild_hct(self, orig_hct, as_copy):
hc_list = orig_hct.hc_list()
if not as_copy:
orig_hct.clear()
new_hct = HarmonicContextTrack() if as_copy else orig_hct
next_index = 0
position = Position(0)
if self.pre_extent is not None:
for hc in hc_list:
intersect = hc.extent.intersection(self.pre_extent)
if intersect is None:
break
duration = Duration(
min(intersect.length(), hc.duration.duration))
new_hc = HarmonicContext(hc.tonality, hc.chord, duration,
hc.position)
new_hct.append(new_hc)
position += new_hc.duration
if hc.extent.upper > self.pre_extent.upper:
break
next_index += 1
for hc in islice(hc_list, next_index, None):
intersect = hc.extent.intersection(self.temporal_extent)
if intersect is None:
break
duration = Duration(intersect.length())
if self.keep_hct:
new_hc = HarmonicContext(hc.tonality, hc.chord, duration,
position)
else:
f = self.__hc_flip_map[hc] if hc in self.__hc_flip_map.keys() else \
ChromaticPitchReflectionFunction(hc.tonality, self.cue_pitch, self.domain_pitch_range)
new_hc = HarmonicContext(f.range_tonality,
self.remap_chord(hc), duration,
position)
new_hct.append(new_hc)
position += new_hc.duration
if hc.extent.upper > self.temporal_extent.upper:
break
next_index += 1
if self.post_extent is not None:
for hc in islice(hc_list, next_index, None):
intersect = hc.extent.intersection(self.post_extent)
if intersect is None:
break
duration = Duration(intersect.length())
new_hc = HarmonicContext(hc.tonality, hc.chord, duration,
position)
new_hct.append(new_hc)
position += new_hc.duration
return new_hct
def _rebuild_hct(self, orig_hct, as_copy):
hc_list = orig_hct.hc_list()
if not as_copy:
orig_hct.clear()
new_hct = HarmonicContextTrack() if as_copy else orig_hct
next_index = 0
position = Position(0)
if self.pre_extent is not None:
for hc in hc_list:
intersect = hc.extent.intersection(self.pre_extent)
if intersect is None:
break
duration = Duration(
min(intersect.length(), hc.duration.duration))
new_hc = HarmonicContext(hc.tonality, hc.chord, duration,
hc.position)
new_hct.append(new_hc)
position += new_hc.duration
if hc.extent.upper > self.pre_extent.upper:
break
next_index += 1
for hc in islice(hc_list, next_index, None):
intersect = hc.extent.intersection(self.temporal_extent)
if intersect is None:
break
duration = Duration(intersect.length())
if self.keep_hct:
new_hc = HarmonicContext(hc.tonality, hc.chord, duration,
position)
else:
f, range_tonality = self._build_shift_function(hc)
# TODO: the range tonality below is incorrect.
new_hc = HarmonicContext(
range_tonality, self.remap_chord(hc, f.range_tonality),
duration, position)
new_hct.append(new_hc)
position += new_hc.duration
if hc.extent.upper > self.temporal_extent.upper:
break
next_index += 1
if self.post_extent is not None:
for hc in islice(hc_list, next_index, None):
intersect = hc.extent.intersection(self.post_extent)
if intersect is None:
break
duration = Duration(intersect.length())
new_hc = HarmonicContext(hc.tonality, hc.chord, duration,
position)
new_hct.append(new_hc)
position += new_hc.duration
return new_hct
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')
