def testQuantizer(self):
steps_per_quarter = 4
note_sequence = common_testing_lib.parse_test_proto(
music_pb2.NoteSequence,
"""
time_signatures: {
numerator: 4
denominator: 4}
tempos: {
qpm: 60}""")
testing_lib.add_track_to_sequence(
note_sequence, 0,
[(12, 100, 0.01, 10.0), (11, 55, 0.22, 0.50), (40, 45, 2.50, 3.50),
(55, 120, 4.0, 4.01), (52, 99, 4.75, 5.0)])
expected_quantized_sequence = sequences_lib.QuantizedSequence()
expected_quantized_sequence.qpm = 60.0
expected_quantized_sequence.steps_per_quarter = steps_per_quarter
testing_lib.add_quantized_track_to_sequence(
expected_quantized_sequence, 0,
[(12, 100, 0, 40), (11, 55, 1, 2), (40, 45, 10, 14),
(55, 120, 16, 17), (52, 99, 19, 20)])
unit = pipelines_common.Quantizer(steps_per_quarter)
self._unit_transform_test(unit, note_sequence,
[expected_quantized_sequence])
def checkFMajorScale(self, filename):
"""Verify MusicXML scale file.
Verify that it contains the correct pitches (sounding pitch) and durations.
Args:
filename: file to test.
"""
# Expected QuantizedSequence
# Sequence tuple = (midi_pitch, velocity, start_seconds, end_seconds)
expected_quantized_sequence = sequences_lib.QuantizedSequence()
expected_quantized_sequence.steps_per_quarter = self.steps_per_quarter
expected_quantized_sequence.qpm = 120.0
expected_quantized_sequence.time_signature = (
sequences_lib.QuantizedSequence.TimeSignature(numerator=4,
denominator=4))
testing_lib.add_quantized_track_to_sequence(
expected_quantized_sequence, 0,
[(65, 64, 0, 4), (67, 64, 4, 8), (69, 64, 8, 12), (70, 64, 12, 16),
(72, 64, 16, 20), (74, 64, 20, 24), (76, 64, 24, 28),
(77, 64, 28, 32)])
# Convert MusicXML to QuantizedSequence
source_musicxml = musicxml_parser.MusicXMLDocument(filename)
sequence_proto = musicxml_reader.musicxml_to_sequence_proto(
source_musicxml)
quantized = sequences_lib.QuantizedSequence()
quantized.from_note_sequence(sequence_proto, self.steps_per_quarter)
# Check equality
self.assertEqual(expected_quantized_sequence, quantized)
def testExtractChordsForMelodiesCoincidentChords(self):
self.quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(self.quantized_sequence, 0,
[(12, 100, 2, 4),
(11, 1, 6, 11)])
testing_lib.add_quantized_track_to_sequence(self.quantized_sequence, 1,
[(12, 127, 2, 4),
(14, 50, 6, 8),
(50, 100, 33, 37),
(52, 100, 34, 37)])
testing_lib.add_quantized_chords_to_sequence(self.quantized_sequence,
[('C', 2), ('G7', 6),
('E13', 8),
('Cmaj7', 8)])
melodies, _ = melodies_lib.extract_melodies(
self.quantized_sequence,
min_bars=1,
gap_bars=2,
min_unique_pitches=2,
ignore_polyphonic_notes=True)
chord_progressions, stats = chords_lib.extract_chords_for_melodies(
self.quantized_sequence, melodies)
expected = [[NO_CHORD, NO_CHORD, 'C', 'C', 'C', 'C', 'G7', 'G7'],
['Cmaj7', 'Cmaj7', 'Cmaj7', 'Cmaj7', 'Cmaj7']]
stats_dict = dict([(stat.name, stat) for stat in stats])
self.assertIsNone(chord_progressions[0])
self.assertEqual(expected,
[list(chords) for chords in chord_progressions[1:]])
self.assertEqual(stats_dict['coincident_chords'].count, 1)
def testExtractChordsForMelodies(self):
self.quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(self.quantized_sequence, 0,
[(12, 100, 2, 4),
(11, 1, 6, 11)])
testing_lib.add_quantized_track_to_sequence(self.quantized_sequence, 1,
[(12, 127, 2, 4),
(14, 50, 6, 8),
(50, 100, 33, 37),
(52, 100, 34, 37)])
testing_lib.add_quantized_chords_to_sequence(self.quantized_sequence,
[('C', 2), ('G7', 6),
('Cmaj7', 33)])
melodies, _ = melodies_lib.extract_melodies(
self.quantized_sequence,
min_bars=1,
gap_bars=2,
min_unique_pitches=2,
ignore_polyphonic_notes=True)
chord_progressions, _ = chords_lib.extract_chords_for_melodies(
self.quantized_sequence, melodies)
expected = [[
NO_CHORD, NO_CHORD, 'C', 'C', 'C', 'C', 'G7', 'G7', 'G7', 'G7',
'G7'
], [NO_CHORD, NO_CHORD, 'C', 'C', 'C', 'C', 'G7', 'G7'],
['G7', 'Cmaj7', 'Cmaj7', 'Cmaj7', 'Cmaj7']]
self.assertEqual(expected,
[list(chords) for chords in chord_progressions])
def testQuantizer(self):
steps_per_quarter = 4
note_sequence = common_testing_lib.parse_test_proto(
music_pb2.NoteSequence, """
time_signatures: {
numerator: 4
denominator: 4}
tempos: {
qpm: 60}""")
testing_lib.add_track_to_sequence(note_sequence, 0,
[(12, 100, 0.01, 10.0),
(11, 55, 0.22, 0.50),
(40, 45, 2.50, 3.50),
(55, 120, 4.0, 4.01),
(52, 99, 4.75, 5.0)])
expected_quantized_sequence = sequences_lib.QuantizedSequence()
expected_quantized_sequence.qpm = 60.0
expected_quantized_sequence.steps_per_quarter = steps_per_quarter
testing_lib.add_quantized_track_to_sequence(
expected_quantized_sequence, 0,
[(12, 100, 0, 40), (11, 55, 1, 2), (40, 45, 10, 14),
(55, 120, 16, 17), (52, 99, 19, 20)])
unit = pipelines_common.Quantizer(steps_per_quarter)
self._unit_transform_test(unit, note_sequence,
[expected_quantized_sequence])
def testExtractLeadSheetFragmentsNoChords(self):
self.quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 0,
[(12, 100, 2, 4), (11, 1, 6, 11)])
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 1,
[(12, 127, 2, 4), (14, 50, 6, 8),
(50, 100, 33, 37), (52, 100, 34, 37)])
testing_lib.add_quantized_chords_to_sequence(
self.quantized_sequence,
[('C', 2), ('G7', 6), (NO_CHORD, 10)])
lead_sheets, stats = lead_sheets_lib.extract_lead_sheet_fragments(
self.quantized_sequence, min_bars=1, gap_bars=2, min_unique_pitches=2,
ignore_polyphonic_notes=True, require_chords=True)
melodies, _ = melodies_lib.extract_melodies(
self.quantized_sequence, min_bars=1, gap_bars=2, min_unique_pitches=2,
ignore_polyphonic_notes=True)
chord_progressions, _ = chords_lib.extract_chords_for_melodies(
self.quantized_sequence, melodies)
stats_dict = dict([(stat.name, stat) for stat in stats])
# Last lead sheet should be rejected for having no chords.
self.assertEqual(list(melodies[:2]),
list(lead_sheet.melody for lead_sheet in lead_sheets))
self.assertEqual(list(chord_progressions[:2]),
list(lead_sheet.chords for lead_sheet in lead_sheets))
self.assertEqual(stats_dict['empty_chord_progressions'].count, 1)
def testExtractMelodiesTooFewPitches(self):
# Test that extract_melodies discards melodies with too few pitches where
# pitches are equivalent by octave.
self.quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(self.quantized_sequence, 0,
[(12, 100, 0, 1),
(13, 100, 1, 2),
(18, 100, 2, 3),
(24, 100, 3, 4),
(25, 100, 4, 5)])
testing_lib.add_quantized_track_to_sequence(self.quantized_sequence, 1,
[(12, 100, 0, 1),
(13, 100, 1, 2),
(18, 100, 2, 3),
(25, 100, 3, 4),
(26, 100, 4, 5)])
expected = [[12, 13, 18, 25, 26]]
melodies, _ = melodies_lib.extract_melodies(
self.quantized_sequence,
min_bars=1,
gap_bars=1,
min_unique_pitches=4,
ignore_polyphonic_notes=True)
melodies = [list(melody) for melody in melodies]
self.assertEqual(expected, melodies)
def testExtractLeadSheetFragmentsCoincidentChords(self):
self.quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 0,
[(12, 100, 2, 4), (11, 1, 6, 11)])
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 1,
[(12, 127, 2, 4), (14, 50, 6, 8),
(50, 100, 33, 37), (52, 100, 34, 37)])
testing_lib.add_quantized_chords_to_sequence(
self.quantized_sequence,
[('C', 2), ('G7', 6), ('Cmaj7', 33), ('F', 33)])
lead_sheets, _ = lead_sheets_lib.extract_lead_sheet_fragments(
self.quantized_sequence, min_bars=1, gap_bars=2, min_unique_pitches=2,
ignore_polyphonic_notes=True, require_chords=True)
melodies, _ = melodies_lib.extract_melodies(
self.quantized_sequence, min_bars=1, gap_bars=2, min_unique_pitches=2,
ignore_polyphonic_notes=True)
chord_progressions, _ = chords_lib.extract_chords_for_melodies(
self.quantized_sequence, melodies)
# Last lead sheet should be rejected for coincident chords.
self.assertEqual(list(melodies[:2]),
list(lead_sheet.melody for lead_sheet in lead_sheets))
self.assertEqual(list(chord_progressions[:2]),
list(lead_sheet.chords for lead_sheet in lead_sheets))
def testFromNotesPolyphonic(self):
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 0,
[(12, 100, 4, 16), (19, 100, 4, 12)])
melody = melodies_lib.Melody()
with self.assertRaises(melodies_lib.PolyphonicMelodyException):
melody.from_quantized_sequence(self.quantized_sequence,
start_step=0, track=0,
ignore_polyphonic_notes=False)
self.assertFalse(list(melody))
def testExtractDrumTracksTooShort(self):
self.quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(self.quantized_sequence,
0, [(12, 127, 2, 4),
(14, 50, 6, 7)],
is_drum=True)
drum_tracks, _ = drums_lib.extract_drum_tracks(self.quantized_sequence,
min_bars=2,
gap_bars=1)
drum_tracks = [list(drums) for drums in drum_tracks]
self.assertEqual([], drum_tracks)
def testFromNotesTrimEmptyMeasures(self):
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 0,
[(12, 100, 6, 7), (11, 100, 8, 9)])
melody = melodies_lib.Melody()
melody.from_quantized_sequence(self.quantized_sequence,
start_step=0, track=0,
ignore_polyphonic_notes=False)
expected = [NO_EVENT, NO_EVENT, NO_EVENT, NO_EVENT, NO_EVENT, NO_EVENT, 12,
NOTE_OFF, 11]
self.assertEqual(expected, list(melody))
self.assertEqual(16, melody.steps_per_bar)
def testRounding(self):
testing_lib.add_track_to_sequence(
self.note_sequence, 1,
[(12, 100, 0.01, 0.24), (11, 100, 0.22, 0.55), (40, 100, 0.50, 0.75),
(41, 100, 0.689, 1.18), (44, 100, 1.19, 1.69), (55, 100, 4.0, 4.01)])
testing_lib.add_quantized_track_to_sequence(
self.expected_quantized_sequence, 1,
[(12, 100, 0, 1), (11, 100, 1, 2), (40, 100, 2, 3),
(41, 100, 3, 5), (44, 100, 5, 7), (55, 100, 16, 17)])
quantized = sequences_lib.QuantizedSequence()
quantized.from_note_sequence(self.note_sequence, self.steps_per_quarter)
self.assertEqual(self.expected_quantized_sequence, quantized)
def testExtractDrumTracksLateStart(self):
self.quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(self.quantized_sequence,
0, [(12, 100, 102, 103),
(13, 100, 104, 106)],
is_drum=True)
expected = [[NO_DRUMS, NO_DRUMS, DRUMS(12), NO_DRUMS, DRUMS(13)]]
drum_tracks, _ = drums_lib.extract_drum_tracks(self.quantized_sequence,
min_bars=1,
gap_bars=1)
drum_tracks = sorted([list(drums) for drums in drum_tracks])
self.assertEqual(expected, drum_tracks)
def testFromNotesTimeOverlap(self):
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 0,
[(12, 100, 4, 8), (11, 100, 13, 15),
(13, 100, 8, 16)])
melody = melodies_lib.Melody()
melody.from_quantized_sequence(self.quantized_sequence,
start_step=0, track=0,
ignore_polyphonic_notes=False)
expected = [NO_EVENT, NO_EVENT, NO_EVENT, NO_EVENT, 12, NO_EVENT, NO_EVENT,
NO_EVENT, 13, NO_EVENT, NO_EVENT, NO_EVENT, NO_EVENT, 11,
NO_EVENT]
self.assertEqual(expected, list(melody))
def testFromNotesPolyphonicWithIgnorePolyphonicNotes(self):
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 0,
[(12, 100, 0, 8), (19, 100, 0, 12),
(12, 100, 4, 12), (19, 100, 4, 16)])
melody = melodies_lib.Melody()
melody.from_quantized_sequence(self.quantized_sequence,
start_step=0, track=0,
ignore_polyphonic_notes=True)
expected = ([19] + [NO_EVENT] * 3 + [19] + [NO_EVENT] * 11)
self.assertEqual(expected, list(melody))
self.assertEqual(16, melody.steps_per_bar)
def testFromQuantizedSequence(self):
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 0,
[(12, 100, 0, 40), (11, 55, 1, 2), (40, 45, 10, 14),
(55, 120, 16, 17), (52, 99, 19, 20)])
melody = melodies_lib.Melody()
melody.from_quantized_sequence(self.quantized_sequence,
start_step=0, track=0)
expected = ([12, 11, NOTE_OFF, NO_EVENT, NO_EVENT, NO_EVENT, NO_EVENT,
NO_EVENT, NO_EVENT, NO_EVENT, 40, NO_EVENT, NO_EVENT, NO_EVENT,
NOTE_OFF, NO_EVENT, 55, NOTE_OFF, NO_EVENT, 52])
self.assertEqual(expected, list(melody))
self.assertEqual(16, melody.steps_per_bar)
def testFromNotesStartAndEndStep(self):
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 0,
[(12, 100, 4, 8), (11, 100, 9, 10), (13, 100, 13, 15),
(14, 100, 19, 20), (15, 100, 21, 27)])
melody = melodies_lib.Melody()
melody.from_quantized_sequence(self.quantized_sequence,
start_step=18, track=0,
ignore_polyphonic_notes=False)
expected = [NO_EVENT, NO_EVENT, NO_EVENT, 14, NOTE_OFF, 15, NO_EVENT,
NO_EVENT, NO_EVENT, NO_EVENT, NO_EVENT]
self.assertEqual(expected, list(melody))
self.assertEqual(16, melody.start_step)
self.assertEqual(27, melody.end_step)
def testFromNotesTrimEmptyMeasures(self):
testing_lib.add_quantized_track_to_sequence(self.quantized_sequence,
0, [(12, 100, 6, 7),
(11, 100, 8, 9)],
is_drum=True)
drums = drums_lib.DrumTrack()
drums.from_quantized_sequence(self.quantized_sequence, start_step=0)
expected = [
NO_DRUMS, NO_DRUMS, NO_DRUMS, NO_DRUMS, NO_DRUMS, NO_DRUMS,
DRUMS(12), NO_DRUMS,
DRUMS(11)
]
self.assertEqual(expected, list(drums))
self.assertEqual(16, drums.steps_per_bar)
def testExtractMelodiesStatistics(self):
self.quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 0,
[(12, 100, 2, 4), (11, 1, 6, 7), (10, 100, 8, 10), (9, 100, 11, 14),
(8, 100, 16, 40), (7, 100, 41, 42)])
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 1,
[(12, 127, 2, 4), (14, 50, 2, 8)])
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 2,
[(12, 127, 0, 1)])
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 3,
[(12, 127, 2, 4), (12, 50, 6, 8)])
_, stats = melodies_lib.extract_melodies(
self.quantized_sequence, min_bars=1, gap_bars=1, min_unique_pitches=2,
ignore_polyphonic_notes=False)
stats_dict = dict([(stat.name, stat) for stat in stats])
self.assertEqual(stats_dict['polyphonic_tracks_discarded'].count, 1)
self.assertEqual(stats_dict['melodies_discarded_too_short'].count, 1)
self.assertEqual(stats_dict['melodies_discarded_too_few_pitches'].count, 1)
self.assertEqual(
stats_dict['melody_lengths_in_bars'].counters,
{float('-inf'): 0, 0: 1, 1: 0, 2: 1, 10: 1, 20: 0, 30: 0, 40: 0, 50: 0,
100: 0, 200: 0, 500: 0})
def testExtractMelodiesMelodyTooShort(self):
self.quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 0,
[(12, 127, 2, 4), (14, 50, 6, 7)])
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 1,
[(12, 127, 2, 4), (14, 50, 6, 9)])
expected = [[NO_EVENT, NO_EVENT, 12, NO_EVENT, NOTE_OFF, NO_EVENT, 14,
NO_EVENT, NO_EVENT]]
melodies, _ = melodies_lib.extract_melodies(
self.quantized_sequence, min_bars=2, gap_bars=1, min_unique_pitches=2,
ignore_polyphonic_notes=True)
melodies = [list(melody) for melody in melodies]
self.assertEqual(expected, melodies)
def testExtractDrumTracksTooLongDiscard(self):
self.quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(self.quantized_sequence,
0, [(12, 127, 2, 4),
(14, 50, 6, 15),
(14, 50, 10, 15),
(16, 100, 14, 19),
(14, 100, 18, 19)],
is_drum=True)
drum_tracks, _ = drums_lib.extract_drum_tracks(self.quantized_sequence,
min_bars=1,
max_steps_discard=18,
gap_bars=1)
drum_tracks = [list(drums) for drums in drum_tracks]
self.assertEqual([], drum_tracks)
def testExtractMelodiesLateStart(self):
self.quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 0,
[(12, 100, 102, 103), (13, 100, 104, 106)])
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 1,
[(12, 100, 100, 101), (13, 100, 102, 105)])
expected = [[NO_EVENT, NO_EVENT, 12, NOTE_OFF, 13, NO_EVENT],
[12, NOTE_OFF, 13, NO_EVENT, NO_EVENT]]
melodies, _ = melodies_lib.extract_melodies(
self.quantized_sequence, min_bars=1, gap_bars=1, min_unique_pitches=2,
ignore_polyphonic_notes=True)
melodies = sorted([list(melody) for melody in melodies])
self.assertEqual(expected, melodies)
def testFromQuantizedSequenceNotCommonTimeSig(self):
self.quantized_sequence.time_signature = (
sequences_lib.QuantizedSequence.TimeSignature(numerator=7,
denominator=8))
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 0,
[(12, 100, 0, 40), (11, 55, 1, 2), (40, 45, 10, 14),
(55, 120, 16, 17), (52, 99, 19, 20)])
melody = melodies_lib.Melody()
melody.from_quantized_sequence(self.quantized_sequence,
start_step=0, track=0)
expected = ([12, 11, NOTE_OFF, NO_EVENT, NO_EVENT, NO_EVENT, NO_EVENT,
NO_EVENT, NO_EVENT, NO_EVENT, 40, NO_EVENT, NO_EVENT, NO_EVENT,
NOTE_OFF, NO_EVENT, 55, NOTE_OFF, NO_EVENT, 52])
self.assertEqual(expected, list(melody))
self.assertEqual(14, melody.steps_per_bar)
def testDeepcopy(self):
quantized = sequences_lib.QuantizedSequence()
testing_lib.add_track_to_sequence(
self.note_sequence, 0,
[(12, 100, 0.01, 10.0), (11, 55, 0.22, 0.50), (40, 45, 2.50, 3.50),
(55, 120, 4.0, 4.01), (52, 99, 4.75, 5.0)])
quantized.from_note_sequence(self.note_sequence, self.steps_per_quarter)
quantized_copy = copy.deepcopy(quantized)
self.assertEqual(quantized, quantized_copy)
testing_lib.add_quantized_track_to_sequence(
quantized, 1,
[(12, 100, 4, 20), (19, 100, 8, 16), (24, 100, 12, 14)])
self.assertNotEqual(quantized, quantized_copy)
def testExtractMelodiesMelodyTooLongWithPad(self):
self.quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 0,
[(12, 127, 2, 4), (14, 50, 6, 15)])
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 1,
[(12, 127, 2, 4), (14, 50, 6, 18)])
expected = [[NO_EVENT, NO_EVENT, 12, NO_EVENT, NOTE_OFF, NO_EVENT, 14,
NO_EVENT, NO_EVENT, NO_EVENT, NO_EVENT, NO_EVENT]]
melodies, _ = melodies_lib.extract_melodies(
self.quantized_sequence, min_bars=1, max_steps_truncate=14,
max_steps_discard=18, gap_bars=1, min_unique_pitches=2,
ignore_polyphonic_notes=True, pad_end=True)
melodies = [list(melody) for melody in melodies]
self.assertEqual(expected, melodies)
def testExtractMelodiesTooFewPitches(self):
# Test that extract_melodies discards melodies with too few pitches where
# pitches are equivalent by octave.
self.quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 0,
[(12, 100, 0, 1), (13, 100, 1, 2), (18, 100, 2, 3),
(24, 100, 3, 4), (25, 100, 4, 5)])
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 1,
[(12, 100, 0, 1), (13, 100, 1, 2), (18, 100, 2, 3),
(25, 100, 3, 4), (26, 100, 4, 5)])
expected = [[12, 13, 18, 25, 26]]
melodies, _ = melodies_lib.extract_melodies(
self.quantized_sequence, min_bars=1, gap_bars=1, min_unique_pitches=4,
ignore_polyphonic_notes=True)
melodies = [list(melody) for melody in melodies]
self.assertEqual(expected, melodies)
def testFromNotesStartAndEndStep(self):
testing_lib.add_quantized_track_to_sequence(self.quantized_sequence,
0, [(12, 100, 4, 8),
(11, 100, 9, 10),
(13, 100, 13, 15),
(14, 100, 19, 20),
(15, 100, 21, 27)],
is_drum=True)
drums = drums_lib.DrumTrack()
drums.from_quantized_sequence(self.quantized_sequence, start_step=18)
expected = [
NO_DRUMS, NO_DRUMS, NO_DRUMS,
DRUMS(14), NO_DRUMS,
DRUMS(15)
]
self.assertEqual(expected, list(drums))
self.assertEqual(16, drums.start_step)
self.assertEqual(22, drums.end_step)
def testFromNoteSequence(self):
testing_lib.add_track_to_sequence(
self.note_sequence, 0,
[(12, 100, 0.01, 10.0), (11, 55, 0.22, 0.50), (40, 45, 2.50, 3.50),
(55, 120, 4.0, 4.01), (52, 99, 4.75, 5.0)])
testing_lib.add_chords_to_sequence(
self.note_sequence,
[('B7', 0.22), ('Em9', 4.0)])
testing_lib.add_quantized_track_to_sequence(
self.expected_quantized_sequence, 0,
[(12, 100, 0, 40), (11, 55, 1, 2), (40, 45, 10, 14),
(55, 120, 16, 17), (52, 99, 19, 20)])
testing_lib.add_quantized_chords_to_sequence(
self.expected_quantized_sequence,
[('B7', 1), ('Em9', 16)])
quantized = sequences_lib.QuantizedSequence()
quantized.from_note_sequence(self.note_sequence, self.steps_per_quarter)
self.assertEqual(self.expected_quantized_sequence, quantized)
def testExtractMultipleMelodiesFromSameTrack(self):
self.quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 0,
[(12, 100, 2, 4), (11, 1, 6, 11)])
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 1,
[(12, 127, 2, 4), (14, 50, 6, 8),
(50, 100, 33, 37), (52, 100, 34, 37)])
expected = [[NO_EVENT, NO_EVENT, 12, NO_EVENT, NOTE_OFF, NO_EVENT, 11,
NO_EVENT, NO_EVENT, NO_EVENT, NO_EVENT],
[NO_EVENT, NO_EVENT, 12, NO_EVENT, NOTE_OFF, NO_EVENT, 14,
NO_EVENT],
[NO_EVENT, 50, 52, NO_EVENT, NO_EVENT]]
melodies, _ = melodies_lib.extract_melodies(
self.quantized_sequence, min_bars=1, gap_bars=2, min_unique_pitches=2,
ignore_polyphonic_notes=True)
melodies = sorted([list(melody) for melody in melodies])
self.assertEqual(expected, melodies)
def testExtractDrumTracksTooLongTruncate(self):
self.quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(self.quantized_sequence,
0, [(12, 127, 2, 4),
(14, 50, 6, 15),
(14, 50, 10, 15),
(16, 100, 14, 19)],
is_drum=True)
expected = [[
NO_DRUMS, NO_DRUMS,
DRUMS(12), NO_DRUMS, NO_DRUMS, NO_DRUMS,
DRUMS(14), NO_DRUMS, NO_DRUMS, NO_DRUMS,
DRUMS(14), NO_DRUMS, NO_DRUMS, NO_DRUMS
]]
drum_tracks, _ = drums_lib.extract_drum_tracks(self.quantized_sequence,
min_bars=1,
max_steps_truncate=14,
gap_bars=1)
drum_tracks = [list(drums) for drums in drum_tracks]
self.assertEqual(expected, drum_tracks)
def testFilterDrums(self):
testing_lib.add_track_to_sequence(
self.note_sequence, 0,
[(12, 100, 1.0, 4.0), (19, 100, 0.95, 3.0)])
testing_lib.add_track_to_sequence(
self.note_sequence, 3,
[(12, 100, 1.0, 4.0), (19, 100, 2.0, 5.0)])
# Make instrument 0 a drum.
for note in self.note_sequence.notes:
if note.instrument == 0:
note.is_drum = True
testing_lib.add_quantized_track_to_sequence(
self.expected_quantized_sequence, 3,
[(12, 100, 4, 16), (19, 100, 8, 20)])
quantized = sequences_lib.QuantizedSequence()
quantized.from_note_sequence(self.note_sequence, self.steps_per_quarter)
self.assertEqual(self.expected_quantized_sequence, quantized)
def testMelodyExtractor(self):
quantized_sequence = sequences_lib.QuantizedSequence()
quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(
quantized_sequence, 0,
[(12, 100, 2, 4), (11, 1, 6, 7)])
testing_lib.add_quantized_track_to_sequence(
quantized_sequence, 1,
[(12, 127, 2, 4), (14, 50, 6, 8)])
expected_events = [
[NO_EVENT, NO_EVENT, 12, NO_EVENT, NOTE_OFF, NO_EVENT, 11],
[NO_EVENT, NO_EVENT, 12, NO_EVENT, NOTE_OFF, NO_EVENT, 14, NO_EVENT]]
expected_melodies = []
for events_list in expected_events:
melody = melodies_lib.Melody(
events_list, steps_per_quarter=1, steps_per_bar=4)
expected_melodies.append(melody)
unit = pipelines_common.MelodyExtractor(
min_bars=1, min_unique_pitches=1, gap_bars=1)
self._unit_transform_test(unit, quantized_sequence, expected_melodies)
def testDrumsExtractor(self):
quantized_sequence = sequences_lib.QuantizedSequence()
quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(
quantized_sequence, 0,
[(12, 100, 2, 4), (11, 1, 6, 7), (12, 1, 6, 8)],
is_drum=True)
testing_lib.add_quantized_track_to_sequence(
quantized_sequence, 1,
[(12, 127, 2, 4), (14, 50, 6, 8)])
expected_events = [
[NO_DRUMS, NO_DRUMS, DRUMS(12), NO_DRUMS, NO_DRUMS, NO_DRUMS,
DRUMS(11, 12)]]
expected_drum_tracks = []
for events_list in expected_events:
drums = drums_lib.DrumTrack(
events_list, steps_per_quarter=1, steps_per_bar=4)
expected_drum_tracks.append(drums)
unit = drum_pipelines.DrumsExtractor(min_bars=1, gap_bars=1)
self._unit_transform_test(unit, quantized_sequence, expected_drum_tracks)
def testExtractMelodiesSimple(self):
self.quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 0,
[(12, 100, 2, 4), (11, 1, 6, 7)])
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 1,
[(12, 127, 2, 4), (14, 50, 6, 9)])
expected = [[NO_EVENT, NO_EVENT, 12, NO_EVENT, NOTE_OFF, NO_EVENT, 11],
[NO_EVENT, NO_EVENT, 12, NO_EVENT, NOTE_OFF, NO_EVENT, 14,
NO_EVENT, NO_EVENT]]
melodies, _ = melodies_lib.extract_melodies(
self.quantized_sequence, min_bars=1, gap_bars=1, min_unique_pitches=2,
ignore_polyphonic_notes=True)
self.assertEqual(2, len(melodies))
self.assertTrue(isinstance(melodies[0], melodies_lib.Melody))
self.assertTrue(isinstance(melodies[1], melodies_lib.Melody))
melodies = sorted([list(melody) for melody in melodies])
self.assertEqual(expected, melodies)
def testExtractChordsForMelodies(self):
self.quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 0,
[(12, 100, 2, 4), (11, 1, 6, 11)])
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 1,
[(12, 127, 2, 4), (14, 50, 6, 8),
(50, 100, 33, 37), (52, 100, 34, 37)])
testing_lib.add_quantized_chords_to_sequence(
self.quantized_sequence,
[('C', 2), ('G7', 6), ('Cmaj7', 33)])
melodies, _ = melodies_lib.extract_melodies(
self.quantized_sequence, min_bars=1, gap_bars=2, min_unique_pitches=2,
ignore_polyphonic_notes=True)
chord_progressions, _ = chords_lib.extract_chords_for_melodies(
self.quantized_sequence, melodies)
expected = [[NO_CHORD, NO_CHORD, 'C', 'C', 'C', 'C',
'G7', 'G7', 'G7', 'G7', 'G7'],
[NO_CHORD, NO_CHORD, 'C', 'C', 'C', 'C', 'G7', 'G7'],
['G7', 'Cmaj7', 'Cmaj7', 'Cmaj7', 'Cmaj7']]
self.assertEqual(expected, [list(chords) for chords in chord_progressions])
def testExtractChordsForMelodiesCoincidentChords(self):
self.quantized_sequence.steps_per_quarter = 1
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 0,
[(12, 100, 2, 4), (11, 1, 6, 11)])
testing_lib.add_quantized_track_to_sequence(
self.quantized_sequence, 1,
[(12, 127, 2, 4), (14, 50, 6, 8),
(50, 100, 33, 37), (52, 100, 34, 37)])
testing_lib.add_quantized_chords_to_sequence(
self.quantized_sequence,
[('C', 2), ('G7', 6), ('E13', 8), ('Cmaj7', 8)])
melodies, _ = melodies_lib.extract_melodies(
self.quantized_sequence, min_bars=1, gap_bars=2, min_unique_pitches=2,
ignore_polyphonic_notes=True)
chord_progressions, stats = chords_lib.extract_chords_for_melodies(
self.quantized_sequence, melodies)
expected = [[NO_CHORD, NO_CHORD, 'C', 'C', 'C', 'C', 'G7', 'G7'],
['Cmaj7', 'Cmaj7', 'Cmaj7', 'Cmaj7', 'Cmaj7']]
stats_dict = dict([(stat.name, stat) for stat in stats])
self.assertIsNone(chord_progressions[0])
self.assertEqual(expected,
[list(chords) for chords in chord_progressions[1:]])
self.assertEqual(stats_dict['coincident_chords'].count, 1)
