def test(self):
span = mud.Span([
(mud.Note('C4', 1), mud.Time(0)),
(mud.Note('G5', 1), mud.Time(0)),
(mud.Rest( 1), mud.Time(1)),
(mud.Note('C4', 2), mud.Time(2)),
(mud.Note('A4', 2), mud.Time(2)),
])
bar_data = mud.fmt.BarData(span, formatter, slice_resolution=0.5)
self.assertEqual(len(bar_data.timeslices), 8)
self.assertTrue([isinstance(ts_data, mud.fmt.TimeSliceData)
for ts_data in bar_data.timeslices],
[True for _ in bar_data.timeslices])
ts_data = bar_data.timeslices[1]
self.assertEqual(len(ts_data.events), 2)
self.assertEqual(ts_data.events[0].vec.tolist(),
[1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
self.assertEqual(ts_data.events[0].labels, (0, 0))
self.assertEqual(ts_data.events[1].vec.tolist(),
[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0])
self.assertEqual(ts_data.events[1].labels, (7, 0))
# Test rest.
ts_rest_data = bar_data.timeslices[2]
self.assertEqual(len(ts_rest_data.events), 1)
self.assertEqual(ts_rest_data.events[0].vec.tolist(),
[0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0])
self.assertEqual(ts_rest_data.events[0].labels, (None, 1))
def test_raw_events(self):
events = [
mud.Event(mud.Note('C4', 1), mud.Time(0)),
mud.Event(mud.Note('G5', 1), mud.Time(0)),
mud.Event(mud.Rest( 1), mud.Time(1)),
mud.Event(mud.Note('C4', 2), mud.Time(2)),
mud.Event(mud.Note('A4', 2), mud.Time(2)),
]
span = mud.Span(events, length=4, offset=4)
# Test slices which intersect with the first two notes
slices_first_two = [
mud.TimeSlice(span, (0.0, 0.4)),
mud.TimeSlice(span, (0.6, 1.0)),
mud.TimeSlice(span, (0.3, 0.7)),
mud.TimeSlice(span, (0.0, 1.0)),
]
for ts in slices_first_two:
self.assertEqual(ts.num_events(), 2)
for i, event in enumerate(ts.raw_events()):
self.assertEqual(event, events[i])
self.assertLess(i, 2)
# Test slicing the rest.
slices_rest = [
mud.TimeSlice(span, (1.0, 2.0)),
mud.TimeSlice(span, (1.1, 1.2)),
]
for ts in slices_rest:
self.assertEqual(ts.num_events(), 1)
for i, event in enumerate(ts.raw_events()):
self.assertEqual(event, events[2])
self.assertLess(i, 1)
def test_slice(self):
span = mud.Span([
(mud.Note('C4', 1), mud.Time(0)),
(mud.Note('G5', 1), mud.Time(0)),
(mud.Rest(1), mud.Time(1)),
(mud.Note('C4', 2), mud.Time(2)),
(mud.Note('A4', 2), mud.Time(2)),
])
ts = span.get_slice((0.0, 0.5))
self.assertEqual(ts.num_events(), 2)
self.assertTrue(ts.is_atomic_slice())
ts = list(ts.sliced_events())
self.assertEqual(ts[0].time(), mud.Time(0.0))
self.assertEqual(ts[0].duration(), mud.Time(0.5))
self.assertEqual(ts[0].pitch(), mud.Pitch('C4'))
self.assertEqual(ts[1].time(), mud.Time(0.0))
self.assertEqual(ts[1].duration(), mud.Time(0.5))
self.assertEqual(ts[1].pitch(), mud.Pitch('G5'))
ts = span.get_slice((1.5, 2.5))
self.assertEqual(ts.num_events(), 3)
self.assertFalse(ts.is_atomic_slice())
ts = list(span.generate_slices(0.5))
self.assertAlmostEqual(len(ts), 8)
self.assertAlmostEqual(float(len(ts)), span.length().in_beats() / 0.5)
def test_creation(self):
n = mud.Note('G#6', 2)
t = mud.Time(2)
event = mud.Event(n, t)
self.assertEqual(event.unwrap(), n)
self.assertEqual(event.unwrap(), mud.Note('G#6', mud.Time(2.0)))
self.assertEqual(event.time(), t)
self.assertEqual(event.time(), mud.Time(2.0, resolution=0.5))
(n2, t2) = event
self.assertEqual(n, n2)
self.assertEqual(t, t2)
def test(self):
p = mud.Piece()
p.build_from_spans(
mud.Span([
(mud.Note('C4', 1), mud.Time(0)),
(mud.Note('G5', 1), mud.Time(0)),
(mud.Rest(1), mud.Time(1)),
(mud.Note('C4', 2), mud.Time(2)),
(mud.Note('A4', 2), mud.Time(2)),
]))
self.assertTrue(mud.piece_filter.AtomicSlicable(0.25)(p))
self.assertTrue(mud.piece_filter.AtomicSlicable(1.0)(p))
self.assertFalse(mud.piece_filter.AtomicSlicable(1.5)(p))
def test_sliced_events(self):
events = [
mud.Event(mud.Note('C4', 1), mud.Time(0)),
mud.Event(mud.Note('G5', 1), mud.Time(0)),
mud.Event(mud.Rest( 1), mud.Time(1)),
mud.Event(mud.Note('C4', 2), mud.Time(2)),
mud.Event(mud.Note('A4', 2), mud.Time(2)),
]
span = mud.Span(events, length=4, offset=4)
ts = mud.TimeSlice(span, (2.5, 3.0))
self.assertEqual(ts.num_events(), 2)
sliced_events = list(ts.sliced_events())
self.assertEqual(len(sliced_events), 2)
self.assertNotEqual(sliced_events[0],
mud.Event(mud.Note('C4', 2.0), mud.Time(2)))
self.assertNotEqual(sliced_events[0],
mud.Event(mud.Note('C4', 0.5), mud.Time(2)))
self.assertEqual(sliced_events[0].time(), mud.Time(2.5))
self.assertEqual(sliced_events[0].duration(), mud.Time(0.5))
se0 = mud.SlicedEvent((2.5, 3.0), mud.Event(mud.Note('C4', 2), mud.Time(2)))
self.assertEqual(sliced_events[0], se0)
self.assertEqual(sliced_events[1].time(), mud.Time(2.5))
self.assertEqual(sliced_events[1].duration(), mud.Time(0.5))
se1 = mud.SlicedEvent((2.5, 3.0), mud.Event(mud.Note('A4', 2), mud.Time(2)))
self.assertEqual(sliced_events[1], se1)
def test(self):
p = mud.Piece()
p.build_from_spans(mud.Span([
(mud.Note('C4', 1), mud.Time(0)),
(mud.Note('G5', 1), mud.Time(0)),
(mud.Rest( 1), mud.Time(1)),
(mud.Note('C4', 2), mud.Time(2)),
(mud.Note('A4', 2), mud.Time(2)),
]))
piece_data = mud.fmt.PieceData(p, formatter, slice_resolution=0.25)
self.assertEqual(len(piece_data.bars), 1)
self.assertTrue(isinstance(piece_data.bars[0], mud.fmt.BarData))
self.assertTrue(len(piece_data.bars[0].timeslices), 16)
def test(self):
events = [
(mud.Note('C4', 1), mud.Time(0)),
(mud.Note('G5', 1), mud.Time(0)),
(mud.Rest(1), mud.Time(1)),
(mud.Note('C4', 2), mud.Time(2)),
(mud.Note('A4', 2), mud.Time(2)),
]
span = mud.Span(events, length=4, offset=4)
self.assertAlmostEqual(span.length().in_beats(), 4.0)
self.assertAlmostEqual(span.offset().in_beats(), 4.0)
for i, (event, time) in enumerate(events):
self.assertEqual(span[i], mud.Event(event, time))
def test(self):
f = feature.ContinuingPreviousEvent()
self.assertEqual(f.dim(), 1)
event = mud.Event(mud.Note('C#4', mud.Time(4.0)), mud.Time(0.0))
v = f.make_subvector(event)
self.assertEqual(v.shape, (1, ))
self.assertAlmostEqual(v[0], 0.0)
# middle slice
sliced_event = mud.SlicedEvent((2.0, 3.0), event)
v = f.make_subvector(sliced_event)
self.assertEqual(v.shape, (1, ))
self.assertAlmostEqual(v[0], 1.0)
# no slice
sliced_event = mud.SlicedEvent((0.0, 4.0), event)
v = f.make_subvector(sliced_event)
self.assertEqual(v.shape, (1, ))
self.assertAlmostEqual(v[0], 0.0)
# slice to end
sliced_event = mud.SlicedEvent((2.0, 4.0), event)
v = f.make_subvector(sliced_event)
self.assertEqual(v.shape, (1, ))
self.assertAlmostEqual(v[0], 1.0)
def test(self):
f = feature.ContinuesNextEvent()
self.assertEqual(f.dim(), 1)
event = mud.Event(mud.Note('A6', mud.Time(4.0)), mud.Time(0.0))
v = f.make_subvector(event)
self.assertEqual(v.shape, (1, ))
self.assertAlmostEqual(v[0], 0.0)
# middle slice
sliced_event = mud.SlicedEvent((2.0, 3.0), event)
v = f.make_subvector(sliced_event)
self.assertEqual(v.shape, (1, ))
self.assertAlmostEqual(v[0], 1.0)
# no slice
sliced_event = mud.SlicedEvent((0.0, 4.0), event)
v = f.make_subvector(sliced_event)
self.assertEqual(v.shape, (1, ))
self.assertAlmostEqual(v[0], 0.0)
# slice from start
sliced_event = mud.SlicedEvent((0.0, 3.5), event)
v = f.make_subvector(sliced_event)
self.assertEqual(v.shape, (1, ))
self.assertAlmostEqual(v[0], 1.0)
def test_unpack(self):
n = mud.Note('Ab2', 4)
(p, d) = n
self.assertEqual(p.relative_pitch(),
mud.Pitch.str_to_relative_pitch['Ab'])
self.assertEqual(p.octave(), 2)
self.assertAlmostEqual(d.in_beats(), 4.0)
def test_in_span_range(self):
# Event is from 2.5 to 0.5
n = mud.Note('D5', 0.5)
t = mud.Time(2)
event = mud.Event(n, t)
# Exact
self.assertTrue(event.in_span_range((2.0, 2.5)))
# End before start
with self.assertRaises(ValueError):
event.in_span_range((2.5, 2.3))
# Span starts before
self.assertTrue(event.in_span_range((1.5, 2.5)))
# Span ends after
self.assertTrue(event.in_span_range((2.0, 4.0)))
# Span starts before and ends after
self.assertTrue(event.in_span_range((0.0, 3.0)))
# Span starts inside and ends inside
self.assertTrue(event.in_span_range((2.3, 2.4)))
# Span starts inside and ends after
self.assertTrue(event.in_span_range((2.3, 3.1)))
# Span starts before and ends inside
self.assertTrue(event.in_span_range((1.8, 2.4)))
# Span starts before and ends before
self.assertFalse(event.in_span_range((1.8, 1.9)))
# Span starts after and ends after
self.assertFalse(event.in_span_range((2.6, 5.0)))
def test_complex_piece(self):
# Canon in D violin solo from https://musescore.com/user/88585/scores/105013
p = mud.Piece('./test/test-files/canon_in_d.mxl')
self.assertEqual(p.name, './test/test-files/canon_in_d.mxl')
self.assertEqual(p.num_bars(), 27)
bar = p.bars()[22]
self.assertEqual(bar.num_events(), 4)
# note 0: D, quarter note
note, time = bar[0]
self.assertEqual(note, mud.Note('D5', 1.0))
self.assertEqual(time, mud.Time(0.0))
# note 3: F, quarter note
note, time = bar[3]
self.assertEqual(note, mud.Note('F#4', 1.0))
self.assertEqual(time, mud.Time(3.0))
def test(self):
event = mud.Event(mud.Note('A6', 1.0), 2.0)
event = mud.SlicedEvent((2.0, 2.5), event)
# The event is a 1/2 note slice that continues into the next slice.
event_data = mud.fmt.EventData(event, formatter)
self.assertEqual(event_data.vec.tolist(),
[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0])
self.assertEqual(event_data.labels, (9, 1))
def test_copy(self):
n = mud.Note('D5', 0.5)
t = mud.Time(2)
event = mud.Event(n, t)
event2 = mud.Event(event)
self.assertEqual(event, event2)
self.assertEqual(event2.unwrap(), n)
self.assertEqual(event2.time(), t)
def test(self):
n = mud.Note('G#6', 0.5)
self.assertEqual(n.pitch().relative_pitch(), 8)
self.assertEqual(n.pitch().octave(), 6)
self.assertEqual(n.pitch().name(), 'Ab6')
self.assertEqual(n.pitch(), mud.Pitch(8, 6))
self.assertEqual(n.duration(), mud.Time(0.5))
self.assertTrue(n.duration().is_quantized())
self.assertAlmostEqual(n.duration().in_beats(), 0.5)
def test(self):
f = feature.SpanPosition(resolution=0.25, span_length=4.0)
self.assertEqual(f.dim(), 16)
event = mud.Event(mud.Note('E3', 1.0), 2.0)
v = f.make_subvector(event)
for i in range(16):
if i == 8:
self.assertAlmostEqual(v[i], 1.0)
continue
self.assertAlmostEqual(v[i], 0.0)
def test(self):
f = feature.NoteLength(resolution=0.5, max_length=4.0)
self.assertEqual(f.dim(), 8)
event = mud.Event(mud.Note('E3', 1.0), 2.0)
v = f.make_subvector(event)
for i in range(8):
if i == 2:
self.assertAlmostEqual(v[i], 1.0)
continue
self.assertAlmostEqual(v[i], 0.0)
def test(self):
p = mud.Piece('./test/test-files/piece.musicxml')
self.assertEqual(p.name, './test/test-files/piece.musicxml')
self.assertEqual(p.count_events(), 1)
bar = p.bars()[0]
self.assertAlmostEqual(bar.offset().in_beats(), 0.0)
self.assertAlmostEqual(bar.length().in_beats(), 4.0)
self.assertEqual(bar.num_events(), 1)
note, time = bar[0]
self.assertEqual(time, mud.Time(0))
pitch, duration = note
self.assertEqual(note, mud.Note('Db4', mud.Time(4.0)))
self.assertEqual(pitch, mud.Pitch('Db4'))
self.assertEqual(duration, mud.Time(4))
def test(self):
span = mud.Span([
(mud.Note('C4', 1), mud.Time(0)),
(mud.Note('G5', 1), mud.Time(0)),
(mud.Rest( 1), mud.Time(1)),
(mud.Note('C4', 2), mud.Time(2)),
(mud.Note('A4', 2), mud.Time(2)),
])
ts = mud.TimeSlice(span, (2.0, 3.0))
ts_data = mud.fmt.TimeSliceData(ts, formatter)
self.assertEqual(len(ts_data.events), 2)
self.assertTrue([isinstance(event_data, mud.fmt.EventData)
for event_data in ts_data.events],
[True for _ in ts_data.events])
self.assertEqual(ts_data.events[0].vec.tolist(),
[1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0])
self.assertEqual(ts_data.events[0].labels, (0, 1))
self.assertEqual(ts_data.events[1].vec.tolist(),
[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0])
self.assertEqual(ts_data.events[1].labels, (9, 1))
def test_edit_members(self):
n = mud.Note('C1', mud.Time(0.55, resolution=None))
self.assertEqual(n.pitch().name(), 'C1')
n.set_pitch(mud.Pitch('C2'))
self.assertEqual(n.pitch().name(), 'C2')
self.assertFalse(n.duration().is_quantized())
self.assertAlmostEqual(n.duration().in_beats(), 0.55)
err = n.duration().quantize()
self.assertAlmostEqual(err, 0.55 - 0.5)
self.assertAlmostEqual(err, 0.55 - n.duration().in_beats())
self.assertEqual(n.duration(), mud.Time(0.5))
def test(self):
f = feature.BooleanFlag('flag')
self.assertEqual(f.dim(), 1)
event = mud.Event(mud.Note('A6', mud.Time(4.0)), mud.Time(0.0))
v = f.make_subvector(event)
self.assertEqual(v.shape, (1, ))
self.assertAlmostEqual(v[0], 0.0)
v = f.make_subvector(event, flag=False)
self.assertEqual(v.shape, (1, ))
self.assertAlmostEqual(v[0], 0.0)
v = f.make_subvector(event, flag=True)
self.assertEqual(v.shape, (1, ))
self.assertAlmostEqual(v[0], 1.0)
def test(self):
pitch_labels = label.PitchLabels(octave_range=(4, 6))
formatter = mud.fmt.EventDataBuilder(features=(
feature.IsNote(),
feature.IsRest(),
feature.NotePitch(pitch_labels),
),
labels=(pitch_labels, ))
# TEST INPUT VECTOR CONSTRUCTION
event_note = mud.Event(mud.Note('C#4', mud.Time(1.0)), mud.Time(0.0))
v = formatter.make_vector(event_note)
self.assertEqual(
v.shape,
(12 * 3 + 2, )) # 3 octaves + 1 note indicator + 1 rest indicator
note_label = pitch_labels.get_label_of('C#4')
self.assertEqual(note_label, 1)
for i in range(v.shape[0]):
if (i == 0 # The note indicator
or i == 2 + note_label): # The pitch marker
self.assertAlmostEqual(v[i], 1.0)
else:
self.assertAlmostEqual(v[i], 0.0)
event_rest = mud.Event(mud.Rest(mud.Time(3.0)), mud.Time(1.0))
v = formatter.make_vector(event_rest)
self.assertEqual(
v.shape,
(12 * 3 + 2, )) # 3 octaves + 1 note indicator + 1 rest indicator
for i in range(v.shape[0]):
if i == 1: # note indicator
self.assertAlmostEqual(v[i], 1.0)
else:
self.assertAlmostEqual(v[i], 0.0)
# TEST LABEL GENERATION
l = formatter.make_labels(event_note)
self.assertEqual(len(l), 1)
self.assertEqual(l[0], note_label)
self.assertEqual(l[0], 1)
l = formatter.make_labels(event_rest)
self.assertEqual(len(l), 1)
self.assertEqual(l[0], None)
def test(self):
l = label.ContinuesNextEventLabel()
event = mud.Event(mud.Note('A6', mud.Time(4.0)), mud.Time(0.0))
self.assertEqual(l.get_event_label(event), 0)
# middle slice
sliced_event = mud.SlicedEvent((2.0, 3.0), event)
self.assertFalse(sliced_event.is_note_end())
self.assertEqual(l.get_event_label(sliced_event), 1)
# no slice
sliced_event = mud.SlicedEvent((0.0, 4.0), event)
self.assertTrue(sliced_event.is_note_end())
self.assertEqual(l.get_event_label(sliced_event), 0)
# slice from start
sliced_event = mud.SlicedEvent((0.0, 3.5), event)
self.assertFalse(sliced_event.is_note_end())
self.assertEqual(l.get_event_label(sliced_event), 1)
def test_overlay(self):
span_a = mud.Span([
(mud.Note('C4', 1), mud.Time(0)),
(mud.Note('G5', 1), mud.Time(1)),
])
span_b = mud.Span([
(mud.Note('A4', 1), mud.Time(0)),
(mud.Note('C4', 1), mud.Time(1)),
])
events_target = [
(mud.Note('C4', 1), mud.Time(0)),
(mud.Note('A4', 1), mud.Time(0)),
(mud.Note('C4', 1), mud.Time(1)),
(mud.Note('G5', 1), mud.Time(1)),
]
span_overlaid = mud.Span.overlay(span_a, span_b)
self.assertAlmostEqual(span_overlaid.length().in_beats(), 2.0)
self.assertAlmostEqual(span_overlaid.offset().in_beats(), 0.0)
for i, (event, time) in enumerate(events_target):
self.assertEqual(span_overlaid[i], mud.Event(event, time))
def test_concat(self):
span_a = mud.Span([
(mud.Note('C4', 1), mud.Time(0)),
(mud.Note('G5', 1), mud.Time(0)),
])
span_b = mud.Span([
(mud.Rest(1), mud.Time(0)),
(mud.Note('C4', 2), mud.Time(1)),
(mud.Note('A4', 2), mud.Time(1)),
])
events_target = [
(mud.Note('C4', 1), mud.Time(0)),
(mud.Note('G5', 1), mud.Time(0)),
(mud.Rest(1), mud.Time(1)),
(mud.Note('C4', 2), mud.Time(2)),
(mud.Note('A4', 2), mud.Time(2)),
]
span_concat = mud.Span.concat(span_a, span_b)
self.assertAlmostEqual(span_concat.length().in_beats(), 4.0)
self.assertAlmostEqual(span_concat.offset().in_beats(), 0.0)
for i, (event, time) in enumerate(events_target):
self.assertEqual(span_concat[i], mud.Event(event, time))
def test_is_monophonic(self):
span1 = mud.Span([
(mud.Note('C4', 1), mud.Time(0)),
(mud.Note('A4', 2), mud.Time(2)),
],
length=4,
offset=4)
self.assertTrue(span1.is_monophonic())
span2 = mud.Span([
(mud.Note('C4', 1), mud.Time(0)),
(mud.Note('G5', 1), mud.Time(0)),
(mud.Rest(1), mud.Time(1)),
(mud.Note('C4', 2), mud.Time(2)),
(mud.Note('A4', 2), mud.Time(2)),
],
length=4,
offset=4)
self.assertTrue(not span2.is_monophonic())
def test(self):
l = label.NoteLength(resolution=0.5, max_length=4.0)
self.assertEqual(l.num_labels, 8)
event = mud.Event(mud.Note('E3', 1.0), 2.0)
self.assertEqual(l.get_event_label(event), 2)
def test(self):
l = label.BooleanFlag('flag')
event = mud.Event(mud.Note('A6', mud.Time(4.0)), mud.Time(0.0))
self.assertEqual(l.get_event_label(event), 0)
self.assertEqual(l.get_event_label(event, flag=False), 0)
self.assertEqual(l.get_event_label(event, flag=True), 1)
import unittest
import mud
import mud.fmt.feature as feature
import mud.fmt.label as label
import numpy as np
note = mud.Event(mud.Note('G7', 2.0), mud.Time(0.0))
rest = mud.Event(mud.Rest(1.0), mud.Time(0.0))
class TestIsNote(unittest.TestCase):
def test(self):
f = feature.IsNote()
self.assertEqual(f.dim(), 1)
self.assertEqual(f.make_subvector(note).shape, (1, ))
self.assertEqual(f.make_subvector(note), np.ones(1))
self.assertEqual(f.make_subvector(note)[0], 1)
self.assertEqual(f.make_subvector(rest).shape, (1, ))
self.assertEqual(f.make_subvector(rest), np.zeros(1))
self.assertEqual(f.make_subvector(rest)[0], 0)
class TestIsRest(unittest.TestCase):
def test(self):
f = feature.IsRest()
self.assertEqual(f.dim(), 1)
self.assertEqual(f.make_subvector(note).shape, (1, ))
self.assertEqual(f.make_subvector(note), np.zeros(1))
self.assertEqual(f.make_subvector(note)[0], 0)
self.assertEqual(f.make_subvector(rest).shape, (1, ))
self.assertEqual(f.make_subvector(rest), np.ones(1))
