def __init__(self):
from music21 import stream
from music21 import note
from music21 import meter
self.s = stream.Score()
for j in [1]:
p = stream.Part()
for mn in range(10):
m = stream.Measure()
if mn == 0:
m.timeSignature = meter.TimeSignature('3/4')
for i in range(3):
m.append(note.Note())
p.append(m)
self.s.insert(0, p)
def midi_beats(midi_file):
music = converter.parse(midi_file)
# Use dummy 1/4 time
for part in music.parts:
for sig in part.getTimeSignatures():
denom = max(4, sig.denominator)
part.insert(sig.offset, meter.TimeSignature('1/%d' % denom))
part.remove(sig)
measures = []
for measure in music.flat.makeMeasures():
offsetMap = defaultdict(set)
for note in measure.notes:
offset = int(round(note.offset * RESOLUTION))
offsetMap[offset].update([pitch.midi for pitch in note.pitches])
measures.append(offsetMap)
return measures
def generateTripletBlues(blRealization = None, numRepeats = 5): #12/8
'''
Turns whole notes in twelve bar blues bass line to triplet blues bass line. Takes
in numRepeats, which is the number of times to repeat the bass line. Also, takes in a
realization of :meth:`~music21.figuredBass.examples.twelveBarBlues`. If none is provided,
a default realization with :attr:`~music21.figuredBass.rules.Rules.forbidVoiceOverlap`
set to False and :attr:`~music21.figuredBass.rules.Rules.partMovementLimits` set to
[(1,4),(2,12),(3,12)] is used.
>>> from music21.figuredBass import examples
>>> #_DOCS_SHOW examples.generateTripletBlues(numRepeats = 1).show()
.. image:: images/figuredBass/fbExamples_tripletBlues.*
:width: 700
'''
from music21 import converter, stream, interval, meter
if blRealization == None:
bluesLine = twelveBarBlues()
fbRules = rules.Rules()
fbRules.partMovementLimits = [(1,4),(2,12),(3,12)]
fbRules.forbidVoiceOverlap = False
blRealization = bluesLine.realize(fbRules)
sampleScore = blRealization.generateRandomRealizations(numRepeats)
tripletBassLine = converter.parse("tinynotation: BB-4 BB-8 D4 D8 F4 F8 A-8 G8 F8", makeNotation=False)
newBassLine = stream.Part()
for n in sampleScore[1].notes:
i = interval.notesToInterval(tripletBassLine[0], n)
tp = tripletBassLine.transpose(i)
for lyr in n.lyrics:
tp.notes[0].addLyric(lyr.text)
for m in tp.notes:
newBassLine.append(m)
newTopLine = stream.Part()
for sampleChord in sampleScore[0].notes:
sampleChordCopy = copy.deepcopy(sampleChord)
sampleChordCopy.quarterLength = 6.0
newTopLine.append(sampleChordCopy)
newScore = stream.Score()
newScore.append(meter.TimeSignature("12/8")) #Time signature
newScore.append(sampleScore[1][1]) #Key signature
newScore.insert(0, newTopLine)
newScore.insert(0, newBassLine)
return newScore
def testExpandTrills(self):
from music21 import note, stream, clef, key, meter
p1 = stream.Part()
m1 = stream.Measure()
p1.append(clef.TrebleClef())
p1.append(key.Key('D', 'major'))
p1.append(meter.TimeSignature('1/4'))
n1 = note.Note('E4', type='eighth')
n1.expressions.append(Trill())
m1.append(n1)
p1.append(m1)
realized = realizeOrnaments(n1)
self.assertIsInstance(realized, list)
self.assertEqual(len(realized), 4)
self.assertIsInstance(realized[0], note.Note)
self.assertEqual(realized[0].quarterLength, 0.125)
self.assertEqual('E4 F#4 E4 F#4', ' '.join(n.pitch.nameWithOctave for n in realized))
def xtestExpandTurns(self):
from music21 import note, stream, clef, key, meter
p1 = stream.Part()
m1 = stream.Measure()
m2 = stream.Measure()
p1.append(clef.TrebleClef())
p1.append(key.Key('F', 'major'))
p1.append(meter.TimeSignature('2/4'))
n1 = note.Note('C5', type='half')
n1.expressions.append(Turn())
n2 = note.Note('B4', type='half')
n2.expressions.append(InvertedTurn())
m1.append(n1)
m2.append(key.KeySignature(5))
m2.append(n2)
p1.append(m1)
p1.append(m2)
def addPart(minLength=80, maxProbability=0.7, instrument=None):
s1 = rhythmLine(minLength=minLength, maxProbability=maxProbability)
ts1 = meter.TimeSignature("4/4")
s1.insert(0, ts1)
s1.insert(0, tempo.MetronomeMark(number=180, text="very fast"))
if instrument is not None:
s1.insert(0, instrument)
s1.makeAccidentals()
s1.makeMeasures(inPlace=True)
sf = s1.flat.notesAndRests
for n in sf:
if n.tie is not None and n.tie.type != 'start':
r = note.Rest()
r.quarterLength = n.quarterLength
s1.replace(n, r, allDerived=True)
return s1
def timeSignatureFromTimeSign(self, timeSign):
'''
Returns a :class:`~music21.meter.TimeSignature` object from a timeSign tag.
>>> ci = capella.fromCapellaXML.CapellaImporter()
>>> timeSign = ci.domElementFromText('<timeSign time="4/4"/>')
>>> ci.timeSignatureFromTimeSign(timeSign)
<music21.meter.TimeSignature 4/4>
'''
if 'time' in timeSign._attrs:
timeString = timeSign._attrs['time'].value
if timeString != 'infinite':
return meter.TimeSignature(timeString)
else:
return None
else:
return None
def testStreamLilySemiComplex(self):
from copy import deepcopy
from music21 import meter, note, stream, pitch, duration
a = stream.Stream()
ts = meter.TimeSignature("3/8")
b = stream.Stream()
q = note.EighthNote()
dur1 = duration.Duration()
dur1.type = "eighth"
tup1 = duration.Tuplet()
tup1.tupletActual = [5, dur1]
tup1.tupletNormal = [3, dur1]
q.octave = 2
q.duration.appendTuplet(tup1)
for i in range(0, 5):
b.append(deepcopy(q))
b.elements[i].accidental = pitch.Accidental(i - 2)
b.elements[0].duration.tuplets[0].type = "start"
b.elements[-1].duration.tuplets[0].type = "stop"
b2temp = b.elements[2]
c = b2temp.editorial
c.comment.text = "a real C"
bestC = b.bestClef(allowTreble8vb=True)
a.insert(bestC)
a.insert(ts)
a.insert(b)
conv = LilypondConverter()
outStr = conv.fromObject(a)
testStr = u'\n { \\clef "bass" \\time 3/8 \n { \\times 3/5 {ceses,8 ces,8 c,8_"a real C" cis,8 cisis,8} } }'
# for i in range(len(outStr)):
# self.assertEqual(outStr[i], testStr[i])
# print outStr
# print testStr
self.assertEqual(outStr, testStr)
def test_reframe_ts():
ex1 = meter.TimeSignature("44/32")
ex1_res = utils.reframe_ts(ex1)
expected_ex1 = meter.TimeSignature("11/8")
assert ex1_res.ratioEqual(expected_ex1)
ex2 = meter.TimeSignature("8/2")
ex2_res = utils.reframe_ts(ex2, new_denominator=2)
expected_ex2 = meter.TimeSignature("8/2")
assert ex2_res.ratioEqual(expected_ex2)
ex3 = meter.TimeSignature("8/8")
ex3_res = utils.reframe_ts(ex3, new_denominator=16)
expected_ex3 = meter.TimeSignature("16/16")
assert ex3_res.ratioEqual(expected_ex3)
ex4 = meter.TimeSignature("13/2")
ex4_res = utils.reframe_ts(ex4)
expected_ex4 = meter.TimeSignature("13/2")
assert ex4_res.ratioEqual(expected_ex4)
def song():
"""
Simple helper function that returns "Wlazł kotek na płotek" music stream
"""
s = stream.Stream()
ts1 = meter.TimeSignature("3/4")
p1 = stream.Part(number=1)
p1.insert(0, ts1)
p1.insert(0, key.KeySignature(0))
p1.insert(0, clef.TrebleClef())
m1 = stream.Measure(number=1)
m1.append(note.Note("G"))
m1.append(note.Note("E"))
m1.append(note.Note("E", type="quarter"))
m2 = stream.Measure(number=2)
m2.append(note.Note("F"))
m2.append(note.Note("D"))
m2.append(note.Note("D"))
m3 = stream.Measure(number=3)
m3.append(note.Note("C", type="eighth"))
m3.append(note.Note("E", type="eighth"))
m3.append(note.Note("G", type="half"))
p1.append(m1)
p1.append(m2)
p1.append(m3)
m4 = stream.Measure(number=4)
m4.append(note.Note("G"))
m4.append(note.Note("E"))
m4.append(note.Note("E", type="quarter"))
m5 = stream.Measure(number=5)
m5.append(note.Note("F"))
m5.append(note.Note("D"))
m5.append(note.Note("D"))
m6 = stream.Measure(number=6)
m6.append(note.Note("C4", type="eighth"))
m6.append(note.Note("E4", type="eighth"))
m6.append(note.Note("C4", type="half"))
p1.append(m4)
p1.append(m5)
p1.append(m6)
s.insert(0, p1)
return s
def testTabClefBeamDirections(self):
from music21 import stream
from music21 import clef
from music21 import meter
from music21 import note
m = stream.Measure()
n1 = note.Note(64, quarterLength=0.25)
n2 = note.Note(67, quarterLength=0.25)
m.append(clef.TabClef())
m.append(meter.TimeSignature('4/4'))
m.append(n1)
m.append(n2)
m.makeBeams(inPlace=True)
self.assertEqual(m.notes[0].stemDirection, 'down')
def testScoreLily(self):
from copy import deepcopy
from music21 import clef, meter, note, stream
ts = meter.TimeSignature("2/4")
p1 = stream.Part()
p1.id = "P1"
p1.append(clef.TrebleClef())
p1.append(ts)
p1.append(note.Note("C4"))
p1.append(note.Note("D4"))
p2 = stream.Part()
p2.id = "P2"
p2.append(clef.BassClef())
p2.append(deepcopy(ts))
p2.append(note.Note("E2"))
p2.append(note.Note("F2"))
score1 = stream.Score()
score1.insert(0, p1)
score1.insert(0, p2)
# score1.show('text')
# score2 = score1.makeNotation()
# score2.show('text')
conv = LilypondConverter()
outStr = conv.fromObject(score1)
# print outStr
# conv2 = LilypondConverter(score1)
# conv2.showSVG()
self.assertEqual(
outStr, r''' \score {
{ <<
\new Staff
{
{ \clef "treble" \time 2/4 c'4 d'4 } }
\new Staff
{
{ \clef "bass" \time 2/4 e,4 f,4 } } >>
} }''')
def testExportMetronomeMarksE(self):
'''
Test writing of sound tags
'''
from music21 import meter
from music21 import tempo
p = stream.Part()
p.repeatAppend(note.Note('g#3'), 8)
# default quarter assumed
p.insert(0, tempo.MetronomeMark('super slow', number=30.2))
raw = fromMusic21Object(p)
match1 = '<sound tempo="30.2"/>'
self.assertEqual(raw.find(match1) > 0, True)
#p.show()
p = stream.Part()
p.repeatAppend(note.Note('g#3'), 14)
# default quarter assumed
p.insert(meter.TimeSignature('2/4'))
p.insert(0, tempo.MetronomeMark(number=30))
p.insert(2, tempo.MetronomeMark(number=60))
p.insert(4, tempo.MetronomeMark(number=120))
p.insert(6, tempo.MetronomeMark(number=240))
p.insert(8, tempo.MetronomeMark(number=240, referent=.75))
p.insert(10, tempo.MetronomeMark(number=240, referent=.5))
p.insert(12, tempo.MetronomeMark(number=240, referent=.25))
#p.show()
raw = fromMusic21Object(p)
match1 = '<sound tempo="30.0"/>'
self.assertEqual(raw.find(match1) > 0, True)
match2 = '<sound tempo="60.0"/>'
self.assertEqual(raw.find(match2) > 0, True)
match3 = '<sound tempo="120.0"/>'
self.assertEqual(raw.find(match3) > 0, True)
match4 = '<sound tempo="240.0"/>'
self.assertEqual(raw.find(match4) > 0, True)
# from the dotted value
match5 = '<sound tempo="180.0"/>'
self.assertEqual(raw.find(match5) > 0, True)
def createTimeSignature(self, attributes):
r'''
Adding a time signature in the score.
>>> measure = stream.Measure()
>>> nwt = noteworthy.translate.NoteworthyTranslator()
>>> nwt.currentMeasure = measure
>>> nwt.createTimeSignature({"Signature":"4/4"})
>>> measure[0]
<music21.meter.TimeSignature 4/4>
'''
times = attributes['Signature']
if times == "AllaBreve": # These are strange cases
times = "2/2"
elif times == "Common":
times = "4/4"
self.currentMeasure.append(meter.TimeSignature(times))
def createTimeSignature(self, attributes):
r'''
Adding a time signature in the score.
>>> measure = stream.Measure()
>>> nwt = noteworthy.translate.NoteworthyTranslator()
>>> nwt.currentMeasure = measure
>>> nwt.createTimeSignature({'Signature':'4/4'})
>>> measure[0]
<music21.meter.TimeSignature 4/4>
'''
times = attributes['Signature']
if times == 'AllaBreve': # These are strange cases
times = '2/2'
elif times == 'Common':
times = '4/4'
self.currentMeasure.append(meter.TimeSignature(times))
def getMeasuresList(scores_json):
scores = scores_json
allMeasures = []
lastMetronomeMark = tempo.MetronomeMark()
lastKeysignature = key.KeySignature()
lastTimeSignature = meter.TimeSignature()
lastClef = clef.Clef()
for i, strm in enumerate(scores):
path = strm['path']
strmScore = strm['score']
for p in strmScore.getElementsByClass(stream.Part):
for m in p.getElementsByClass(stream.Measure):
isActive = False
for r in m.recurse():
if type(r) == clef.TrebleClef:
lastClef = r
if type(r) == clef.BassClef:
lastClef = r
if type(r) == note.Note:
isActive = True
if type(r) == tempo.MetronomeMark:
lastMetronomeMark = r
if type(r) == key.KeySignature:
lastKeysignature = r
if type(r) == meter.TimeSignature:
lastTimeSignature = r
try:
m.insert(0, lastTimeSignature)
m.insert(0, lastMetronomeMark)
m.insert(0, lastKeysignature)
m.insert(0, lastClef)
except:
True
if isActive:
obj = {
"path": path,
"part": p.partName,
"number": m.number,
"measure": m
}
allMeasures.append(obj)
return allMeasures
def testMeasureStream1():
'''
returns a simple measure stream for testing:
>>> s = analysis.reduceChordsOld.testMeasureStream1()
>>> s.show('text')
{0.0} <music21.meter.TimeSignature 4/4>
{0.0} <music21.chord.Chord C4 E4 G4 C5>
{2.0} <music21.chord.Chord C4 E4 F4 B4>
{3.0} <music21.chord.Chord C4 E4 G4 C5>
'''
s = stream.Measure()
t = meter.TimeSignature('4/4')
c1 = chord.Chord('C4 E4 G4 C5')
c1.quarterLength = 2.0
c2 = chord.Chord('C4 E4 F4 B4')
c3 = chord.Chord('C4 E4 G4 C5')
for c in [t, c1, c2, c3]:
s.append(c)
return s
def testSingle(self):
'''Need to test direct meter creation w/o stream
'''
from music21 import note, meter
s = stream.Stream()
ts = meter.TimeSignature('4/4')
s.append(ts)
n = note.Note()
n.quarterLength = 1
s.repeatAppend(n, 4)
n = note.Note()
n.quarterLength = .5
s.repeatAppend(n, 8)
s = s.makeMeasures()
s = labelBeatDepth(s)
s.show()
def test_note_beat_strength_indexer_3(self):
# When there are a few notes
expected = pandas.DataFrame(
{'0': pandas.Series([1.0, 0.5, 0.5, 1.0, 0.5, 0.5])})
test_part = stream.Part()
# add stuff to the test_part
measure = stream.Measure()
# In music21 beginning time signatures are preferably inserted in the first measure and a
# timeSignature is needed to be able to calculate beatStrength
measure.insert(0, m21_meter.TimeSignature('3/4'))
for i in range(6):
add_me = note.Note(u'C4', quarterLength=1.0)
add_me.offset = i
measure.append(add_me)
test_part.insert(0, measure) # finished adding stuff to the test_part
ip = IndexedPiece()
ip.metadata('parts', expected.columns)
ip._analyses['part_streams'] = [test_part] # supply part_streams.
actual = ip._get_beat_strength()['meter.NoteBeatStrengthIndexer']
self.assertTrue(actual.equals(expected))
def __init__(self, fiveExcelCells=None, parentPiece=None):
stream.Score.__init__(self)
if fiveExcelCells == None:
fiveExcelCells = []
if fiveExcelCells != []:
if len(fiveExcelCells) != 5:
raise Exception(
"Need five Excel Cells to make a PolyphonicSnippet object")
for part in fiveExcelCells[0:3]:
if part is not None and hasattr(
part, 'isStream') and part.isStream == True:
part.__class__ = stream.Part
part.classes.insert(0, 'Part')
self.cadenceType = fiveExcelCells[3]
self.timeSig = meter.TimeSignature(fiveExcelCells[4])
self.parentPiece = parentPiece
self.cantus = fiveExcelCells[0]
self.tenor = fiveExcelCells[1]
self.contratenor = fiveExcelCells[2]
if self.contratenor == "" or self.contratenor is None:
self.contratenor = None
else:
self.contratenor.id = 'Ct'
if self.tenor == "" or self.tenor is None:
self.tenor = None
else:
self.tenor.id = 'T'
if self.cantus == "" or self.cantus is None:
self.cantus = None
else:
self.cantus.id = 'C'
md = metadata.Metadata()
md.title = self.header()
self.insert(0, md)
self._appendParts()
self._padParts()
def getMinimumWindowStream(self, timeSignature='1/4'):
'''
Take the loaded stream and restructure it into measures of 1 quarter note duration.
>>> s = corpus.parse('bach/bwv324')
>>> p = analysis.discrete.Ambitus()
Placing one part into analysis
>>> wa = analysis.windowed.WindowedAnalysis(s.parts[0], p)
>>> post = wa.getMinimumWindowStream()
>>> len(post.getElementsByClass('Measure'))
42
>>> post.getElementsByClass('Measure')[0]
<music21.stream.Measure 1 offset=0.0>
Time signature set to 1/4 time signature
>>> post.getElementsByClass('Measure')[0].timeSignature
<music21.meter.TimeSignature 1/4>
leaves one note in this measure
>>> len(post.getElementsByClass('Measure')[1].notes)
1
'''
# create a stream that contains just a 1/4 time signature; this is
# the minimum window size (and partitioning will be done by measure)
meterStream = stream.Stream()
meterStream.insert(0, meter.TimeSignature(timeSignature))
# makeTies() splits the durations into proper measure boundaries for
# analysis; this means that a duration that spans multiple 1/4 measures
# will be represented in each of those measures
measured = self._srcStream.makeMeasures(meterStream)
# need to make sure we only have Measures here, as layout.StaffGroup
# or similar objs may be retained
measured.removeByNotOfClass('Measure')
measured.makeTies(inPlace=True)
return measured
def testMeasureStream1():
'''
returns a simple measure stream for testing:
>>> s = analysis.reduceChords.testMeasureStream1()
>>> s.show('text')
{0.0} <music21.meter.TimeSignature 4/4>
{0.0} <music21.chord.Chord C4 E4 G4 C5>
{2.0} <music21.chord.Chord C4 E4 F4 B4>
{3.0} <music21.chord.Chord C4 E4 G4 C5>
'''
#from music21 import chord
measure = stream.Measure()
timeSignature = meter.TimeSignature('4/4')
chord1 = chord.Chord('C4 E4 G4 C5')
chord1.quarterLength = 2.0
chord2 = chord.Chord('C4 E4 F4 B4')
chord3 = chord.Chord('C4 E4 G4 C5')
for element in (timeSignature, chord1, chord2, chord3):
measure.append(element)
return measure
def testFromScoreNoParts(self):
'''
Badly nested streams should warn but output no gaps.
'''
s = stream.Score()
s.append(meter.TimeSignature('1/4'))
s.append(note.Note())
s.append(note.Note())
gex = GeneralObjectExporter(s)
with self.assertWarns(MusicXMLWarning) as cm:
tree = et_fromstring(gex.parse().decode('utf-8'))
self.assertIn(repr(s).split(' 0x')[0], str(cm.warning))
self.assertIn(' is not well-formed; see isWellFormedNotation()',
str(cm.warning))
# The original score with its original address should not
# be found in the message because makeNotation=True makes a copy
self.assertNotIn(repr(s), str(cm.warning))
# Assert no gaps in stream
self.assertSequenceEqual(tree.findall('.//forward'), [])
def testExpandTurns(self):
from music21 import note
from music21 import stream
from music21 import clef
from music21 import key
from music21 import meter
p1 = stream.Part()
m1 = stream.Measure()
m2 = stream.Measure()
p1.append(clef.TrebleClef())
p1.append(key.Key('F', 'major'))
p1.append(meter.TimeSignature('2/4'))
n1 = note.Note('C5', type='half')
turn0 = Turn()
n1.expressions.append(turn0)
n2 = note.Note('B4', type='quarter')
n2.duration.dots = 1
n2.expressions.append(InvertedTurn())
m1.append(n1)
m2.append(key.KeySignature(5))
m2.append(n2)
m2.append(note.Rest('eighth'))
p1.append(m1)
p1.append(m2)
realized1 = realizeOrnaments(n1)
realized2 = realizeOrnaments(n2)
self.assertEqual('C5 D5 C5 B-4 C5',
' '.join(n.pitch.nameWithOctave for n in realized1))
self.assertEqual('B4 A#4 B4 C#5 B4',
' '.join(n.pitch.nameWithOctave for n in realized2))
self.assertEqual(realized1[0].quarterLength, 1.0)
self.assertEqual(realized1[1].quarterLength, 0.25)
self.assertEqual(realized2[0].quarterLength, 0.5)
self.assertEqual(realized2[1].quarterLength, 0.25)
turn0.quarterLength = 0.125
realized1b = realizeOrnaments(n1)
self.assertEqual(realized1b[0].quarterLength, 1.5)
self.assertEqual(realized1b[1].quarterLength, 0.125)
def testSubclassMatchingA(self):
from music21 import stream, note, clef, meter, classCache, common, chord
s2 = stream.Stream()
s2.repeatAppend(note.Note(), 300)
s2.repeatAppend(note.Rest(), 300)
s2.repeatAppend(chord.Chord(), 300)
s2.repeatInsert(meter.TimeSignature(), [0, 50, 100, 150])
s2.repeatInsert(clef.BassClef(), [0, 50, 100, 150])
t1 = common.Timer()
t1.start()
cc = classCache.ClassCache()
# simulate what would happen in getElementsByClass
cc.load(s2)
s = stream.Stream()
cc.getElementsByClass(s, ['Rest'])
self.assertEqual(len(s), 300)
s = stream.Stream()
cc.getElementsByClass(s, ['Note'])
self.assertEqual(len(s), 300)
s = stream.Stream()
cc.getElementsByClass(s, ['GeneralNote'])
self.assertEqual(len(s), 900)
s = stream.Stream()
cc.getElementsByClass(s, ['NotRest'])
self.assertEqual(len(s), 600)
s = stream.Stream()
cc.getElementsByClass(s, ['BassClef'])
self.assertEqual(len(s), 4)
s = stream.Stream()
cc.getElementsByClass(s, ['Clef'])
self.assertEqual(len(s), 4)
s = stream.Stream()
cc.getElementsByClass(s, ['TimeSignature'])
self.assertEqual(len(s), 4)
def timeSignatureFromTimeSign(self, timeSign):
# noinspection PyShadowingNames
'''
Returns a :class:`~music21.meter.TimeSignature` object from a timeSign tag.
>>> ci = capella.fromCapellaXML.CapellaImporter()
>>> timeSign = ci.domElementFromText('<timeSign time="4/4"/>')
>>> ci.timeSignatureFromTimeSign(timeSign)
<music21.meter.TimeSignature 4/4>
>>> timeSign = ci.domElementFromText('<timeSign time="infinite"/>')
>>> ci.timeSignatureFromTimeSign(timeSign) is None
True
'''
if 'time' in timeSign.attrib:
timeString = timeSign.attrib['time']
if timeString != 'infinite':
return meter.TimeSignature(timeString)
else:
return None
else:
return None
def makeScore(self):
"""Make a short score with pick up and two voices."""
sc = stream.Score()
num_voices = 2
pitches = ['C', 'A-']
for i in range(num_voices):
part = stream.Part()
part.id = 'part %d' % i
time_sig = meter.TimeSignature('4/4')
key_sig = key.Key('c')
# Make a note.
n1 = music21_note.Note(pitches[i])
n1.duration.quarterLength = 1
# Add full measure.
full_m = stream.Measure()
full_m.append(time_sig)
full_m.append(key_sig)
full_m.append(n1)
n2 = n1.transpose('M2')
full_m.append(n2)
full_m.repeatAppend(n1, 2)
part.append(full_m)
# Add another full measure.
full_m = stream.Measure()
full_m.append(n1)
n2 = n1.transpose('M2')
full_m.append(n2)
full_m.repeatAppend(n1, 2)
part.append(full_m)
sc.insert(0, part)
# Show the full score and all score elements in indented text.
# sc.show('text')
return sc
def generate_sub_cycle(root_scale, starting_chord, cycle_matrix_page, note_ranges=()):
chord_as_list = list(starting_chord.pitches)
measure = stream.Measure()
# make it a 7/4 measure as there are 7 chords to a sub-cycle
measure.append(meter.TimeSignature('7/4'))
# add the first chord before generating the rest of the cycle
if len(note_ranges) != 0:
check_note_ranges_and_transpose(starting_chord.pitches, note_ranges)
measure.append(chord.Chord(starting_chord))
# apply the rules of the cycle matrix to generate the rest of the chords. since we're dealing with diatonic chords
# at the moment, the cycle will need to be run twice to generate the remaining six chords
for i in range(0, 2):
for row in cycle_matrix_page:
apply_row_to_chord(row, chord_as_list, root_scale)
# check to see if the new chord is within the specified range if ranges are specified
if len(note_ranges) != 0:
check_note_ranges_and_transpose(chord_as_list, note_ranges)
measure.append(chord.Chord(chord_as_list))
apply_row_to_chord(cycle_matrix_page[6 % len(cycle_matrix_page)], chord_as_list, root_scale)
return measure, chord.Chord(chord_as_list)
def __init__(self, fiveExcelCells=None, parentPiece=None):
super().__init__()
if fiveExcelCells is None:
fiveExcelCells = []
if fiveExcelCells != []:
if len(fiveExcelCells) != 5:
raise Exception(
"Need five Excel Cells to make a PolyphonicSnippet object")
self.cadenceType = fiveExcelCells[3]
self.timeSig = meter.TimeSignature(fiveExcelCells[4])
self.parentPiece = parentPiece
self.cantus = fiveExcelCells[0]
self.tenor = fiveExcelCells[1]
self.contratenor = fiveExcelCells[2]
self.longestLineLength = 0
if self.contratenor == "" or self.contratenor is None:
self.contratenor = None
else:
self.contratenor.id = 'Ct'
if self.tenor == "" or self.tenor is None:
self.tenor = None
else:
self.tenor.id = 'T'
if self.cantus == "" or self.cantus is None:
self.cantus = None
else:
self.cantus.id = 'C'
md = metadata.Metadata()
md.title = self.header()
self.insert(0, md)
self._appendParts()
self._padParts()
def ch2_writing_I_A(tsStr, barGroups):
from music21 import meter, stream
ts = meter.TimeSignature(tsStr)
ex = stream.Stream()
ex.insert(0, ts)
for b in barGroups:
summation = 0
for ql in b:
if ql > 0: # quick encoding: negative values for rests
n = note.Note()
else:
n = note.Rest()
n.quarterLength = abs(ql)
summation += abs(ql)
ex.append(n)
if ts.barDuration.quarterLength - summation > 0:
nFill = note.Note()
# subtract bar dur from sum of existing notes
nFill.quarterLength = ts.barDuration.quarterLength - summation
ex.append(nFill)
return ex
