def analyzeRhythmOfFloatingSpine(self, spineStart: HumdrumToken) -> bool:
durSum: HumNum = opFrac(0)
foundDur: HumNum = opFrac(0)
# Find a known durationFromStart for a line in the Humdrum file, then
# use that to calculate the starting duration of the floating spine.
if spineStart.durationFromStart >= 0:
foundDur = spineStart.durationFromStart
else:
token: t.Optional[HumdrumToken] = spineStart
while token is not None:
if token.durationFromStart >= 0:
foundDur = token.durationFromStart
break
if token.duration > 0:
durSum = opFrac(durSum + token.duration)
token = token.nextToken0
if foundDur == 0:
return self.setParseError(
'Error: cannot link floating spine to score.')
success: bool = self.assignDurationsToTrack(spineStart,
foundDur - durSum)
if not success:
return self.isValid
return self.isValid
def __init__(self,
offsetStart=0.0,
offsetEnd=None,
*,
includeEndBoundary=True,
mustFinishInSpan=False,
mustBeginInSpan=True,
includeElementsThatEndAtStart=True
):
super().__init__()
self.offsetStart = opFrac(offsetStart)
if offsetEnd is None:
self.offsetEnd = offsetStart
self.zeroLengthSearch = True
else:
self.offsetEnd = opFrac(offsetEnd)
if offsetEnd > offsetStart:
self.zeroLengthSearch = False
else:
self.zeroLengthSearch = True
self.mustFinishInSpan = mustFinishInSpan
self.mustBeginInSpan = mustBeginInSpan
self.includeEndBoundary = includeEndBoundary
self.includeElementsThatEndAtStart = includeElementsThatEndAtStart
def assignRhythmFromRecip(self, spineStart: HumdrumToken) -> bool:
currTok: t.Optional[HumdrumToken] = spineStart
while currTok is not None:
if not currTok.isData:
currTok = currTok.nextToken0
continue
if currTok.isNull:
# This should not occur in a well-formed **recip spine, but
# treat as a zero duration.
currTok = currTok.nextToken0
continue
currTok.ownerLine.duration = Convert.recipToDuration(currTok.text)
currTok = currTok.nextToken0
# now go back and set the absolute position from the start of the file.
totalDurSoFar: HumNum = opFrac(0)
for line in self._lines:
line.durationFromStart = totalDurSoFar
if line.duration is None or line.duration < 0:
line.duration = opFrac(0)
totalDurSoFar = opFrac(totalDurSoFar + line.duration)
# Analyze durations to/from barlines:
success = self.analyzeMeter()
if not success:
return False
success = self.analyzeNonNullDataTokens()
if not success:
return False
return True
def __init__(self,
offsetStart=0.0,
offsetEnd=None,
*,
includeEndBoundary=True,
mustFinishInSpan=False,
mustBeginInSpan=True,
includeElementsThatEndAtStart=True
):
super().__init__()
self.offsetStart = opFrac(offsetStart)
if offsetEnd is None:
self.offsetEnd = offsetStart
self.zeroLengthSearch = True
else:
self.offsetEnd = opFrac(offsetEnd)
if offsetEnd > offsetStart:
self.zeroLengthSearch = False
else:
self.zeroLengthSearch = True
self.mustFinishInSpan = mustFinishInSpan
self.mustBeginInSpan = mustBeginInSpan
self.includeEndBoundary = includeEndBoundary
self.includeElementsThatEndAtStart = includeElementsThatEndAtStart
def _createRecipTokenFromDuration(duration: HumNumIn) -> HumdrumToken:
dur: HumNum = opFrac(duration)
dur = opFrac(dur / opFrac(4)) # convert to quarter note units
durFraction: Fraction = Fraction(dur)
if durFraction.numerator == 0:
# if the GridSlice is at the end of a measure, the
# time between the starttime/endtime of the GridSlice should
# be subtracted from the endtime of the current GridMeasure.
return HumdrumToken('g')
if durFraction.numerator == 1:
return HumdrumToken(str(durFraction.denominator))
if durFraction.numerator % 3 == 0:
dotdur: HumNum = dur * opFrac(Fraction(2, 3))
dotdurFraction: Fraction = Fraction(dotdur)
if dotdurFraction.numerator == 1:
return HumdrumToken(str(dotdurFraction.denominator) + '.')
# try to fit to two dots here
# try to fit to three dots here
return HumdrumToken(
str(durFraction.denominator) + '%' + str(durFraction.numerator))
def __init__(self,
element: m21.base.Music21Object,
elementIndex: int,
voiceIndex: int,
ownerMeasure,
offsetInScore: t.Optional[HumNumIn] = None,
duration: t.Optional[HumNumIn] = None) -> None:
from converter21.humdrum import MeasureData
from converter21.humdrum import ScoreData
self.ownerMeasure: MeasureData = ownerMeasure
self.spannerBundle: m21.spanner.SpannerBundle = (
self.ownerMeasure.spannerBundle # from ownerScore, ultimately
)
self._startTime: HumNum = opFrac(-1)
self._duration: HumNum = opFrac(-1)
self._voiceIndex: int = voiceIndex
self._elementIndex: int = elementIndex
self._element: m21.base.Music21Object = element
self._elementType: t.Type = type(element)
self._name: str = ''
self._texts: t.List[m21.expressions.TextExpression] = []
self._tempos: t.List[m21.tempo.TempoIndication] = []
self._dynamics: t.List[t.Union[m21.dynamics.Dynamic,
m21.dynamics.DynamicWedge]] = []
self._myTextsComputed: bool = False
self._myDynamicsComputed: bool = False
self._parseEvent(element, offsetInScore, duration)
ownerScore: ScoreData = ownerMeasure.ownerStaff.ownerPart.ownerScore
ownerScore.eventFromM21Object[id(element)] = self
def prepareDurations(self, token: HumdrumToken, state: int,
startDur: HumNumIn) -> bool:
if state != token.rhythmAnalysisState:
return self.isValid
token.incrementRhythmAnalysisState()
durSum: HumNum = opFrac(startDur)
success = self.setLineDurationFromStart(token, durSum)
if not success:
return self.isValid
if token.duration > 0:
durSum = opFrac(durSum + token.duration)
reservoir: t.List[HumdrumToken] = []
startDurs: t.List[HumNum] = []
# Assign line durationFromStarts for primary track first
tcount: int = token.nextTokenCount
while tcount > 0:
for i, tok in enumerate(token.nextTokens):
if i == 0:
# we'll deal with token 0 ourselves below
continue
reservoir.append(tok)
startDurs.append(durSum)
if t.TYPE_CHECKING:
# we know here that token.nextTokenCount > 0, so
# token.nextToken0 is not None
assert isinstance(token.nextToken0, HumdrumToken)
token = token.nextToken0
if state != token.rhythmAnalysisState:
break
token.incrementRhythmAnalysisState()
success = self.setLineDurationFromStart(token, durSum)
if not success:
return self.isValid
if token.duration > 0:
durSum = opFrac(durSum + token.duration)
tcount = token.nextTokenCount
if tcount == 0 and token.isTerminateInterpretation:
success = self.setLineDurationFromStart(token, durSum)
if not success:
return self.isValid
# Process secondary tracks next:
newState: int = state
for i in reversed(range(0, len(reservoir))):
self.prepareDurations(reservoir[i], newState, startDurs[i])
return self.isValid
def assignLineDurations(self) -> None:
for i in range(0, len(self._lines)):
if i == len(self._lines) - 1:
self._lines[i].duration = opFrac(0)
else:
startDur: HumNum = self._lines[i].durationFromStart
endDur: HumNum = self._lines[i + 1].durationFromStart
self._lines[i].duration = opFrac(endDur - startDur)
def analyzeNullLineRhythms(self) -> bool:
nullLines: t.List[HumdrumLine] = []
previousLine: t.Optional[HumdrumLine] = None
nextLine: t.Optional[HumdrumLine] = None
for line in self._lines:
if t.TYPE_CHECKING:
# we know that every element of self._lines is not None
assert isinstance(line, HumdrumLine)
if not line.hasSpines:
continue
if line.isBarline:
# We start from scratch in each measure. This is because, if there is a null data
# line as the first line in a measure, we don't want it to start halfway from last
# real note in previous measure to first real note in this measure. Any such
# unprocessed null lines will end up inheriting their start time from the first
# non-null note in this measure, during fillInMissingStartTimes' first loop
# (backwards) over the lines.
previousLine = None
nullLines = []
if line.isAllRhythmicNull:
if line.isData:
nullLines.append(line)
continue
if line.durationFromStart < 0:
if line.isData:
return self.setParseError(
'Error: found an unexpectedly missing durationFromStart on '
+ f'data line {line.durationFromStart}\n' +
f'Line: {line.text}')
continue
nextLine = line
if previousLine is None:
previousLine = nextLine
nullLines = []
continue
if t.TYPE_CHECKING:
# we know previousLine is not None if we get here
assert isinstance(previousLine, HumdrumLine)
startDur: HumNum = previousLine.durationFromStart
endDur: HumNum = nextLine.durationFromStart
gapDur: HumNum = opFrac(endDur - startDur)
nullDur: HumNum = opFrac(gapDur / (len(nullLines) + 1))
for j, nullLine in enumerate(nullLines):
nullLine.durationFromStart = opFrac(startDur + opFrac(nullDur *
(j + 1)))
previousLine = nextLine
nullLines = []
return self.isValid
def durationToEnd(self) -> HumNum:
if not self._rhythmAnalyzed:
if self._ownerFile:
self._ownerFile.analyzeRhythmStructure()
else:
# there's no owner, so we can't get the score duration
return opFrac(0)
return opFrac(self._ownerFile.scoreDuration - self.durationFromStart)
def _setStartTimeOfMeasure(self) -> None:
if self.ownerStaff is None:
self._startTime = opFrac(0)
return
if self._prevMeasData is None:
self._startTime = opFrac(0)
return
self._startTime = opFrac(self._prevMeasData.startTime + self._prevMeasData.duration)
def _parseEventsIn(
self,
m21Stream: t.Union[m21.stream.Voice, m21.stream.Measure],
voiceIndex: int,
emptyStartDuration: HumNumIn = 0,
emptyEndDuration: HumNumIn = 0
) -> None:
event: EventData
durations: t.List[HumNum]
startTime: HumNum
if emptyStartDuration > 0:
# make m21 hidden rests totalling this duration, and pretend they
# were at the beginning of m21Stream
durations = Convert.getPowerOfTwoDurationsWithDotsAddingTo(emptyStartDuration)
startTime = self.startTime
for duration in durations:
m21StartRest: m21.note.Rest = m21.note.Rest(
duration=m21.duration.Duration(duration)
)
m21StartRest.style.hideObjectOnPrint = True
event = EventData(m21StartRest, -1, voiceIndex, self, offsetInScore=startTime)
if event is not None:
self.events.append(event)
startTime = opFrac(startTime + duration)
for elementIndex, element in enumerate(m21Stream.recurse()
.getElementsNotOfClass(m21.stream.Stream)):
event = EventData(element, elementIndex, voiceIndex, self)
if event is not None:
self.events.append(event)
# Make a separate event for any DynamicWedge (in score's
# spannerBundle) that starts with this element.
# Why?
# 1. So we don't put the end of the wedge in the same slice as the
# endNote (wedges end at the end time of the endNote, not at
# the start time of the endNote).
# 2. So wedge starts/ends will go in their own slice if necessary (e.g.
# if we choose not to export the voice-with-only-invisible-rests we
# may have made to position them correctly.
extraEvents: t.List[EventData] = self._parseDynamicWedgesStartedOrStoppedAt(event)
if extraEvents:
self.events += extraEvents
if emptyEndDuration > 0:
# make m21 hidden rests totalling this duration, and pretend they
# were at the end of m21Stream
durations = Convert.getPowerOfTwoDurationsWithDotsAddingTo(emptyEndDuration)
startTime = opFrac(self.startTime + self.duration - opFrac(emptyEndDuration))
for duration in durations:
m21EndRest: m21.note.Rest = m21.note.Rest(duration=m21.duration.Duration(duration))
m21EndRest.style.hideObjectOnPrint = True
event = EventData(m21EndRest, -1, voiceIndex, self, offsetInScore=startTime)
if event is not None:
self.events.append(event)
startTime = opFrac(startTime + duration)
def __init__(
self,
token: t.Optional[t.Union[HumdrumToken, str]] = None,
duration: HumNumIn = opFrac(0)
) -> None:
if isinstance(token, str):
token = HumdrumToken(token)
self._token: t.Optional[HumdrumToken] = token
self._nextDur = opFrac(duration)
# self._prevDur = opFrac(0) # appears to be unused (never set to anything but zero)
self._isTransfered: bool = False
def getValueHumNum(self, *ns1ns2key): # -> HumNum:
from converter21.humdrum import HumdrumToken
value = self.getValue(*ns1ns2key)
if value is None:
return opFrac(0)
if isinstance(value, HumdrumToken):
return opFrac(0)
# pylint: disable=bare-except
try:
return opFrac(value) # can convert from int, float, Fraction, str
except:
return opFrac(0)
def isPowerOfTwoWithDots(quarterLength: HumNumIn) -> bool:
ql: HumNum = opFrac(quarterLength)
if Convert.isPowerOfTwo(ql):
# power of two + no dots
return True
if Convert.isPowerOfTwo(ql * opFrac(Fraction(2, 3))):
# power of two + 1 dot
return True
if Convert.isPowerOfTwo(ql * opFrac(Fraction(4, 7))):
# power of two + 2 dots
return True
if Convert.isPowerOfTwo(ql * opFrac(Fraction(8, 15))):
# power of two + 3 dots
return True
return False
def beat(self, beatDuration: t.Union[str, HumNumIn] = Fraction(1, 4)) -> HumNum:
if isinstance(beatDuration, str): # recip format string, e.g. '4' means 1/4
beatDuration = Convert.recipToDuration(beatDuration)
else:
beatDuration = opFrac(beatDuration)
if t.TYPE_CHECKING:
assert isinstance(beatDuration, (float, Fraction))
if beatDuration == 0:
# avoid divide by 0, just return beatInMeasure = 0
return opFrac(0)
beatInMeasure = opFrac((self.durationFromBarline / beatDuration) + 1)
return beatInMeasure
def addLabelAbbrToken(self, tok: str, timestamp: HumNumIn,
part: int, staff: int, voice: int,
maxPart: int) -> GridSlice:
ts: HumNum = opFrac(timestamp)
gs: GridSlice
if not self.slices or self.slices[-1].timestamp < ts:
# add a new GridSlice to an empty list or at end of list if timestamp
# is after last entry in list.
gs = GridSlice(self, ts, SliceType.LabelAbbrs, maxPart)
gs.addToken(tok, part, staff, voice)
self.slices.append(gs)
return gs
# search for existing line with same timestamp and the same slice type
for gridSlice in self.slices:
if gridSlice.timestamp == ts and gridSlice.isLabelAbbrSlice:
gridSlice.addToken(tok, part, staff, voice)
gs = gridSlice
return gs
# Couldn't find a place for the label abbr, so place at beginning of measure
gs = GridSlice(self, ts, SliceType.LabelAbbrs, maxPart)
gs.addToken(tok, part, staff, voice)
self.slices.insert(0, gs)
return gs
def __init__(
self,
measure: m21.stream.Measure,
ownerStaff, # StaffData
measureIndex: int,
prevMeasData: t.Optional['MeasureData']
) -> None:
from converter21.humdrum import StaffData
self.m21Measure: m21.stream.Measure = measure
self.ownerStaff: StaffData = ownerStaff
# inherited from ownerScore, ultimately
self.spannerBundle: m21.spanner.SpannerBundle = ownerStaff.spannerBundle
self._prevMeasData: t.Optional[MeasureData] = prevMeasData
self._measureIndex: int = measureIndex
self._startTime: HumNum = opFrac(-1)
self._duration: HumNum = opFrac(-1)
self._timeSigDur: HumNum = opFrac(-1)
# leftBarlineStyle describes the left barline of this measure
self.leftBarlineStyle: MeasureStyle = MeasureStyle.Regular
# rightBarlineStyle describes the right barline of this measure
self.rightBarlineStyle: MeasureStyle = MeasureStyle.Regular
# measureStyle is a combination of this measure's leftBarlineStyle and
# the previous measure's rightBarlineStyle. It's the style we use when
# writing a barline ('=') token.
self.measureStyle: MeasureStyle = MeasureStyle.Regular
self.leftBarlineFermataStyle: FermataStyle = FermataStyle.NoFermata
self.rightBarlineFermataStyle: FermataStyle = FermataStyle.NoFermata
# fermataStyle is a combination of this measure's leftBarlineFermataStyle and
# the previous measure's rightBarlineFermataStyle. It's the fermata style we
# use when writing a barline ('=') token.
self.fermataStyle: FermataStyle = FermataStyle.NoFermata
self.inRepeatBracket: bool = False
self.startsRepeatBracket: bool = False
self.stopsRepeatBracket: bool = False
self.repeatBracketName: str = ''
self._measureNumberString: str = ''
self.events: t.List[EventData] = []
self.sortedEvents: t.List[SimultaneousEvents] = [] # list of startTime-binned events
self._parseMeasure() # generates _events and then sortedEvents (also barlines)
def recipToDuration(recip: str, scale: HumNumIn = opFrac(4)) -> HumNum:
if recip in Convert._knownRecipDurationCache:
return Convert._knownRecipDurationCache[recip]
output: HumNum = opFrac(0)
if 'q' in recip:
# grace note, ignore printed rhythm
Convert._knownRecipDurationCache[recip] = output
return output # 0
subToken = recip.split(' ')[0] # we're only interested in the first subtoken
dotCount = subToken.count('.')
m = re.search(r'([\d]+)%([\d]+)', subToken)
if m is not None:
# reciprocal rhythm 'denom%numer'
output = opFrac(Fraction(int(m.group(2)), int(m.group(1))))
else:
m = re.search(r'([\d]+)', subToken)
if m is None:
# no rhythm found
# don't fill cache with bad strings
# Convert._knownRecipDurationCache[recip] = output
return output # 0
if m.group(1).startswith('0'):
# 0-symbol (e.g. '0' is 2/1, '00' is 4/1, '000' is 8/1, etc)
zeroCount = m.group(1).count('0')
output = opFrac(Fraction(pow(2, zeroCount), 1))
else:
# plain rhythm (denominator is in subToken, numerator is 1)
output = opFrac(Fraction(1, int(m.group(1))))
scale = opFrac(scale)
dotFactor: HumNum = opFrac(1)
if dotCount > 0:
# if dotCount=1: dotFactor should be 3/2 (1.5, or one and a half)
# if dotCount=2: dotFactor should be 7/4 (1.75, or one and three quarters)
# if dotCount=3: dotFactor should be 15/8 (1.875, or one and seven eighths)
# etc...
#
# dotFactor = 2^(dotCount+1) - 1
# ------------------
# 2^dotCount
dotFactor = Fraction(pow(2, dotCount + 1) - 1, pow(2, dotCount))
dotFactor = opFrac(dotFactor)
output = opFrac(output * dotFactor * scale)
Convert._knownRecipDurationCache[recip] = output
return output
def correlateHarmonies(currentMapping, music21Part):
'''
Adds a new :class:`~music21.stream.Part` to an existing offset mapping.
>>> from music21 import corpus
>>> from music21.figuredBass import checker
>>> score = corpus.parse("corelli/opus3no1/1grave").measures(1,3)
>>> v0 = score[0]
>>> offsetMapping = checker.createOffsetMapping(v0)
>>> v1 = score[1]
>>> newMapping = checker.correlateHarmonies(offsetMapping, v1)
>>> for (offsets, notes) in sorted(newMapping.items()):
... print("{0!s:15}[{1!s:23}{2!s:21}]".format(offsets, notes[0], notes[1]))
(0.0, 1.5) [<music21.note.Note C> <music21.note.Note A>]
(1.5, 2.0) [<music21.note.Note C> <music21.note.Note A>]
(2.0, 3.0) [<music21.note.Note B-> <music21.note.Note G>]
(3.0, 4.0) [<music21.note.Note A> <music21.note.Note F>]
(4.0, 6.0) [<music21.note.Note G> <music21.note.Note E>]
(6.0, 6.5) [<music21.note.Note A> <music21.note.Note F>]
(6.5, 7.0) [<music21.note.Note B-> <music21.note.Note F>]
(7.0, 7.5) [<music21.note.Note C> <music21.note.Note F>]
(7.5, 8.0) [<music21.note.Note C> <music21.note.Note E>]
(8.0, 8.5) [<music21.note.Note C> <music21.note.Note D>]
(8.5, 9.0) [<music21.note.Note F> <music21.note.Note D>]
(9.0, 9.5) [<music21.note.Note B-> <music21.note.Note D>]
(9.5, 10.0) [<music21.note.Note B-> <music21.note.Note G>]
(10.0, 10.5) [<music21.note.Note B-> <music21.note.Note E>]
(10.5, 11.0) [<music21.note.Note B-> <music21.note.Note C>]
(11.0, 12.0) [<music21.note.Note A> <music21.note.Note F>]
'''
newMapping = {}
for offsets in sorted(currentMapping.keys()):
(initOffset, endTime) = offsets
notesInRange = music21Part.flat.iter.getElementsByClass(
'GeneralNote').getElementsByOffset(
initOffset,
offsetEnd=endTime,
includeEndBoundary=False,
mustFinishInSpan=False,
mustBeginInSpan=False,
includeElementsThatEndAtStart=False)
allNotesSoFar = currentMapping[offsets]
for music21GeneralNote in notesInRange:
newInitOffset = initOffset
newEndTime = endTime
if not music21GeneralNote.offset < initOffset:
newInitOffset = music21GeneralNote.offset
if not music21GeneralNote.offset + music21GeneralNote.quarterLength > endTime:
newEndTime = opFrac(music21GeneralNote.offset +
music21GeneralNote.quarterLength)
allNotesCopy = copy.copy(allNotesSoFar)
allNotesCopy.append(music21GeneralNote)
newMapping[(newInitOffset, newEndTime)] = allNotesCopy
return newMapping
def newNote(ts, n):
'''
Make a copy of the note and clear some settings
'''
nNew = copy.deepcopy(n)
nNew.duration = dur
if not copyPitches:
nNew.pitch = n.pitch
if nNew.stemDirection != 'noStem':
nNew.stemDirection = None
if not addTies:
return nNew
offsetDifference = common.opFrac(self.offset - ts.offset)
endTimeDifference = common.opFrac(ts.endTime -
(self.offset + quarterLength))
if offsetDifference == 0 and endTimeDifference <= 0:
addTie = None
elif offsetDifference > 0:
if endTimeDifference > 0:
addTie = 'continue'
else:
addTie = 'stop'
elif endTimeDifference > 0:
addTie = 'start'
else:
raise VerticalityException('What possibility was missed?',
offsetDifference, endTimeDifference,
ts, self)
if nNew.tie is not None and {nNew.tie.type, addTie
} == startStopSet:
nNew.tie.type = 'continue'
elif nNew.tie is not None and nNew.tie.type == 'continue':
nNew.tie.placement = None
elif addTie is None and nNew.tie is not None:
nNew.tie.placement = None
elif addTie:
nNew.tie = tie.Tie(addTie)
return nNew
def _setOffset(self, offset):
"""
sets the offset and if necessary, translates it to a Fraction for exact representation.
"""
if offset is None:
self._offset = None
elif isinstance(offset, basestring):
self._offset = offset
else:
self._offset = common.opFrac(offset)
def _setOffset(self, offset):
'''
sets the offset and if necessary, translates it to a Fraction for exact representation.
'''
if offset is None:
self._offset = None
elif isinstance(offset, basestring):
self._offset = offset
else:
self._offset = common.opFrac(offset)
def testTuplets(self):
from music21 import abcFormat
from music21.abcFormat import testFiles
tf = testFiles.testPrimitiveTuplet
af = abcFormat.ABCFile()
s = abcToStreamScore(af.readstr(tf))
match = []
# match strings for better comparison
for n in s.flat.notesAndRests:
match.append(n.quarterLength)
shouldFind = [
1.0 / 3,
1.0 / 3,
1.0 / 3,
1.0 / 5,
1.0 / 5,
1.0 / 5,
1.0 / 5,
1.0 / 5,
1.0 / 6,
1.0 / 6,
1.0 / 6,
1.0 / 6,
1.0 / 6,
1.0 / 6,
1.0 / 7,
1.0 / 7,
1.0 / 7,
1.0 / 7,
1.0 / 7,
1.0 / 7,
1.0 / 7,
2.0 / 3,
2.0 / 3,
2.0 / 3,
2.0 / 3,
2.0 / 3,
2.0 / 3,
1.0 / 12,
1.0 / 12,
1.0 / 12,
1.0 / 12,
1.0 / 12,
1.0 / 12,
1.0 / 12,
1.0 / 12,
1.0 / 12,
1.0 / 12,
1.0 / 12,
1.0 / 12,
2.0,
]
self.assertEqual(match, [common.opFrac(x) for x in shouldFind])
def correlateHarmonies(currentMapping, music21Part):
"""
Adds a new :class:`~music21.stream.Part` to an existing offset mapping.
>>> from music21 import corpus
>>> from music21.figuredBass import checker
>>> score = corpus.parse("corelli/opus3no1/1grave").measures(1,3)
>>> v0 = score[0]
>>> offsetMapping = checker.createOffsetMapping(v0)
>>> v1 = score[1]
>>> newMapping = checker.correlateHarmonies(offsetMapping, v1)
>>> for (offsets, notes) in sorted(newMapping.items()):
... print("{0!s:15}[{1!s:23}{2!s:21}]".format(offsets, notes[0], notes[1]))
(0.0, 1.5) [<music21.note.Note C> <music21.note.Note A>]
(1.5, 2.0) [<music21.note.Note C> <music21.note.Note A>]
(2.0, 3.0) [<music21.note.Note B-> <music21.note.Note G>]
(3.0, 4.0) [<music21.note.Note A> <music21.note.Note F>]
(4.0, 6.0) [<music21.note.Note G> <music21.note.Note E>]
(6.0, 6.5) [<music21.note.Note A> <music21.note.Note F>]
(6.5, 7.0) [<music21.note.Note B-> <music21.note.Note F>]
(7.0, 7.5) [<music21.note.Note C> <music21.note.Note F>]
(7.5, 8.0) [<music21.note.Note C> <music21.note.Note E>]
(8.0, 8.5) [<music21.note.Note C> <music21.note.Note D>]
(8.5, 9.0) [<music21.note.Note F> <music21.note.Note D>]
(9.0, 9.5) [<music21.note.Note B-> <music21.note.Note D>]
(9.5, 10.0) [<music21.note.Note B-> <music21.note.Note G>]
(10.0, 10.5) [<music21.note.Note B-> <music21.note.Note E>]
(10.5, 11.0) [<music21.note.Note B-> <music21.note.Note C>]
(11.0, 12.0) [<music21.note.Note A> <music21.note.Note F>]
"""
newMapping = {}
for offsets in sorted(currentMapping.keys()):
(initOffset, endTime) = offsets
notesInRange = music21Part.flat.getElementsByClass("GeneralNote").getElementsByOffset(
initOffset,
offsetEnd=endTime,
includeEndBoundary=False,
mustFinishInSpan=False,
mustBeginInSpan=False,
includeElementsThatEndAtStart=False,
)
allNotesSoFar = currentMapping[offsets]
for music21GeneralNote in notesInRange:
newInitOffset = initOffset
newEndTime = endTime
if not music21GeneralNote.offset < initOffset:
newInitOffset = music21GeneralNote.offset
if not music21GeneralNote.offset + music21GeneralNote.quarterLength > endTime:
newEndTime = opFrac(music21GeneralNote.offset + music21GeneralNote.quarterLength)
allNotesCopy = copy.copy(allNotesSoFar)
allNotesCopy.append(music21GeneralNote)
newMapping[(newInitOffset, newEndTime)] = allNotesCopy
return newMapping
def barlineDuration(self) -> HumNum:
# If necessary (and possible), analyze rhythm structure of the whole file,
# so we can answer the question
if not self._rhythmAnalyzed:
if self._ownerFile:
self._ownerFile.analyzeRhythmStructure()
if self.isBarline:
return self.durationToBarline
return opFrac(self.durationFromBarline + self.durationToBarline)
def _parseEvent(self, element: m21.base.Music21Object,
offsetInScore: t.Optional[HumNumIn],
duration: t.Optional[HumNumIn]) -> None:
if offsetInScore is not None:
self._startTime = opFrac(offsetInScore)
else:
ownerScore = self.ownerMeasure.ownerStaff.ownerPart.ownerScore
self._startTime = opFrac(
element.getOffsetInHierarchy(ownerScore.m21Score))
if duration is not None:
self._duration = opFrac(duration)
else:
self._duration = opFrac(element.duration.quarterLength)
# element.classes is a tuple containing the names (strings, not objects) of classes
# that this object belongs to -- starting with the object's class name and going up
# the mro() for the object.
# So element.classes[0] is the name of the element's class.
# e.g. 'Note' for m21.note.Note
self._name = element.classes[0]
def assignDurationsToTrack(self, startToken: HumdrumToken,
startDur: HumNumIn) -> bool:
sDur: HumNum = opFrac(startDur)
if not startToken.hasRhythm:
return self.isValid
success: bool = self.prepareDurations(startToken,
startToken.rhythmAnalysisState,
sDur)
if not success:
return self.isValid
return self.isValid
def getPowerOfTwoDurationsWithDotsAddingTo(quarterLength: HumNumIn) -> t.List[HumNum]:
output: t.List[HumNum] = []
ql: HumNum = opFrac(quarterLength)
if Convert.isPowerOfTwoWithDots(ql):
# power of two + maybe some dots
output.append(ql)
return output
powerOfTwoQLAttempt: HumNum = opFrac(4) # start with whole note
smallest: HumNum = opFrac(Fraction(1, 2048))
while powerOfTwoQLAttempt >= smallest:
if ql >= powerOfTwoQLAttempt:
output.append(powerOfTwoQLAttempt)
ql = opFrac(ql - powerOfTwoQLAttempt)
else:
powerOfTwoQLAttempt = opFrac(powerOfTwoQLAttempt / 2)
if Convert.isPowerOfTwoWithDots(ql):
# power of two + maybe some dots
output.append(ql)
return output
# we couldn't compute a full list so just return the original param
return [opFrac(quarterLength)]
def analyzeRScale(self) -> bool:
numActiveTracks: int = 0 # number of tracks currently having an active rscale parameter
rscales: t.List[HumNum] = [opFrac(1)] * (self.maxTrack + 1)
ttrack: int
for line in self._lines:
if line.isInterpretation:
for token in line.tokens():
if not token.isKern:
continue
if not token.text.startswith('*rscale:'):
continue
value: HumNum = opFrac(1)
m = re.search(r'\*rscale:(\d+)/(\d+)', token.text)
if m is not None:
top: int = int(m.group(1))
bot: int = int(m.group(2))
value = opFrac(Fraction(top, bot))
else:
m = re.search(r'\*rscale:(\d+)', token.text)
if m is not None:
top = int(m.group(1))
value = opFrac(top)
ttrack = token.track
if value == 1:
if rscales[ttrack] != 1:
rscales[ttrack] = opFrac(1)
numActiveTracks -= 1
else:
if rscales[ttrack] == 1:
numActiveTracks += 1
rscales[ttrack] = value
continue
if numActiveTracks == 0:
continue
if not line.isData:
continue
for token in line.tokens():
ttrack = token.track
if rscales[ttrack] == 1:
continue
if not token.isKern:
continue
if token.isNull:
continue
if token.duration < 0:
continue
dur: HumNum = opFrac(token.durationNoDots * rscales[ttrack])
vis: str = Convert.durationToRecip(dur)
vis += '.' * token.dotCount
token.setValue('LO', 'N', 'vis', vis)
return True
def analyzeMeter(self) -> bool:
self._barlines = []
durationSum: HumNum = opFrac(0)
foundFirstBarline: bool = False
for line in self._lines:
line.durationFromBarline = durationSum
durationSum = opFrac(durationSum + line.duration)
if line.isBarline:
foundFirstBarline = True
self._barlines.append(line)
durationSum = opFrac(0)
elif line.isData and not foundFirstBarline:
# pickup measure, so set the first barline to the start of the file
self._barlines.append(self._lines[0])
foundFirstBarline = True
durationSum = opFrac(0)
for line in reversed(self._lines):
durationSum = opFrac(durationSum + line.duration)
line.durationToBarline = durationSum
if line.isBarline:
durationSum = opFrac(0)
return True
def __init__(self, ownerGrid) -> None:
from converter21.humdrum import HumGrid
if not isinstance(ownerGrid, HumGrid):
raise HumdrumInternalError('invalid ownerGrid')
self._ownerGrid: HumGrid = ownerGrid
self.slices: t.List[GridSlice] = []
self._timestamp: HumNum = opFrac(-1)
self._duration: HumNum = opFrac(-1)
self._timeSigDur: HumNum = opFrac(-1)
self.leftBarlineStyle: MeasureStyle = MeasureStyle.Regular
self.rightBarlineStyle: MeasureStyle = MeasureStyle.Regular
self.fermataStylePerStaff: t.List[FermataStyle] = []
self.measureStyle: MeasureStyle = MeasureStyle.Regular
self.measureNumberString: str = ''
self.inRepeatBracket: bool = False
self.startsRepeatBracket: bool = False
self.stopsRepeatBracket: bool = False
self.repeatBracketName: str = ''
# only used on last measure in score
self.rightBarlineFermataStylePerStaff: t.List[FermataStyle] = []
def newNote(ts, n):
'''
Make a copy of the note and clear some settings
'''
nNew = copy.deepcopy(n)
nNew.duration = dur
if nNew.stemDirection != 'noStem':
nNew.stemDirection = None
if not addTies:
return nNew
offsetDifference = common.opFrac(self.offset - ts.offset)
endTimeDifference = common.opFrac(ts.endTime - (self.offset + quarterLength))
if offsetDifference == 0 and endTimeDifference <= 0:
addTie = None
elif offsetDifference > 0:
if endTimeDifference > 0:
addTie = 'continue'
else:
addTie = 'stop'
elif endTimeDifference > 0:
addTie = 'start'
else:
raise VerticalityException("What possibility was missed?",
offsetDifference, endTimeDifference, ts, self)
if nNew.tie is not None and {nNew.tie.type, addTie} == startStopSet:
nNew.tie.type = 'continue'
elif nNew.tie is not None and nNew.tie.type == 'continue':
nNew.tie.placement = None
elif addTie is None and nNew.tie is not None:
nNew.tie.placement = None
elif addTie:
nNew.tie = tie.Tie(addTie)
return nNew
def recurseGetTreeByClass(inputStream,
currentParentage,
initialOffset,
outputTree=None):
lastParentage = currentParentage[-1]
if outputTree is None:
outputTree = treeClass(source=lastParentage)
# do this to avoid munging activeSites
inputStreamElements = inputStream._elements[:] + inputStream._endElements
parentEndTime = initialOffset + lastParentage.duration.quarterLength
for element in inputStreamElements:
flatOffset = common.opFrac(
lastParentage.elementOffset(element) + initialOffset)
if element.isStream and flatten is not False: # True or "semiFlat"
localParentage = currentParentage + (element, )
recurseGetTreeByClass(
element, # put the elements into the current tree...
currentParentage=localParentage,
initialOffset=flatOffset,
outputTree=outputTree)
if flatten != 'semiFlat':
continue # do not insert the stream itself unless we are doing semiflat
if classList and not element.isClassOrSubclass(classList):
continue
endTime = flatOffset + element.duration.quarterLength
if useTimespans:
pitchedTimespan = spans.PitchedTimespan(
element=element,
parentage=tuple(reversed(currentParentage)),
parentOffset=initialOffset,
parentEndTime=parentEndTime,
offset=flatOffset,
endTime=endTime)
outputTree.insert(pitchedTimespan)
elif groupOffsets is False:
# for sortTuples
position = element.sortTuple(lastParentage)
flatPosition = position.modify(offset=flatOffset)
outputTree.insert(flatPosition, element)
else:
outputTree.insert(flatOffset, element)
return outputTree
def timeToNextEvent(self) -> t.Optional[OffsetQL]:
'''
Returns a float or Fraction of the quarterLength to the next
event (usually the next Verticality, but also to the end of the piece).
Returns None if there is no next event, such as when the verticality
is divorced from its tree.
'''
nextOffset = self.nextStartOffset
if nextOffset is None:
if self.timespanTree is None:
return None
nextOffset = self.timespanTree.endTime
return common.opFrac(nextOffset - self.offset)
def recurseGetTreeByClass(inputStream,
currentParentage,
initialOffset,
outputTree=None):
lastParentage = currentParentage[-1]
if outputTree is None:
outputTree = treeClass(source=lastParentage)
# do this to avoid munging activeSites
inputStreamElements = inputStream._elements[:] + inputStream._endElements
parentEndTime = initialOffset + lastParentage.duration.quarterLength
for element in inputStreamElements:
flatOffset = common.opFrac(lastParentage.elementOffset(element) + initialOffset)
if element.isStream and flatten is not False: # True or "semiFlat"
localParentage = currentParentage + (element,)
recurseGetTreeByClass(element, # put the elements into the current tree...
currentParentage=localParentage,
initialOffset=flatOffset,
outputTree=outputTree)
if flatten != 'semiFlat':
continue # do not insert the stream itself unless we are doing semiflat
if classList and not element.isClassOrSubclass(classList):
continue
endTime = flatOffset + element.duration.quarterLength
if useTimespans:
pitchedTimespan = spans.PitchedTimespan(element=element,
parentage=tuple(reversed(currentParentage)),
parentOffset=initialOffset,
parentEndTime=parentEndTime,
offset=flatOffset,
endTime=endTime)
outputTree.insert(pitchedTimespan)
elif groupOffsets is False:
# for sortTuples
position = element.sortTuple(lastParentage)
flatPosition = position.modify(offset=flatOffset)
outputTree.insert(flatPosition, element)
else:
outputTree.insert(flatOffset, element)
return outputTree
def getSiteByOffset(self, offset):
"""
For a given offset return the site that fits it
More than one Site may have the same offset; this at one point returned
the last site added by sorting time, but now we use a dict, so there's
no guarantee that the one you want will be there -- need orderedDicts!
::
>>> import fractions
>>> class Mock(base.Music21Object):
... pass
...
>>> aSite = Mock()
>>> bSite = Mock()
>>> cSite = Mock()
>>> sitesObj = sites.Sites()
>>> sitesObj.add(aSite, 2)
>>> sitesObj.add(bSite, 10.0/3)
>>> aSite is sitesObj.getSiteByOffset(2)
True
>>> bSite is sitesObj.getSiteByOffset(fractions.Fraction(10, 3))
True
>>> bSite is sitesObj.getSiteByOffset(3.33333333333)
True
"""
match = None
offset = common.opFrac(offset)
for siteId in self.siteDict:
# might need to use almost equals here
matched = False
if self.siteDict[siteId].offsetRational == offset:
matched = True
if matched is True:
if self.siteDict[siteId].isDead:
return None
match = self.siteDict[siteId].site
break
return match
def expand(self, ts=None, ks=None):
'''
The meat of it all -- expand one rule completely and return a list of Measure objects.
'''
if ts is None:
ts = meter.TimeSignature('4/4')
if ks is None:
ks = key.Key('C')
measures = []
lastRegularAtom = None
lastChord = None
for content, sep, numReps in self._measureGroups():
lastChordIsInSameMeasure = False
if sep == "$":
if content not in self.parent.rules:
raise CTRuleException("Cannot expand rule {0} in {2}".format(content, self))
rule = self.parent.rules[content]
for i in range(numReps):
returnedMeasures = rule.expand(ts, ks)
self.insertKsTs(returnedMeasures[0], ts, ks)
for m in returnedMeasures:
tsEs = m.getElementsByClass('TimeSignature', returnStreamSubClass='list')
for returnedTs in tsEs:
if returnedTs is not ts:
ts = copy.deepcopy(ts) # the TS changed mid-rule; create a new one for return.
measures.extend(returnedMeasures)
elif sep == "|":
m = stream.Measure()
atoms = content.split()
# key/timeSig pass...
regularAtoms = []
for atom in atoms:
if atom.startswith('['):
atomContent = atom[1:-1]
if atomContent == '0':
ts = meter.TimeSignature('4/4') # irregular meter. Cannot fully represent;
#TODO: replace w/ senza misura when possible.
elif '/' in atomContent: # only one key / ts per measure.
ts = meter.TimeSignature(atomContent)
else:
ks = key.Key(key.convertKeyStringToMusic21KeyString(atomContent))
elif atom == '.':
if lastRegularAtom is None:
raise CTRuleException(" . w/o previous atom: %s" % self)
regularAtoms.append(lastRegularAtom)
elif atom in ("", None):
pass
else:
regularAtoms.append(atom)
lastRegularAtom = atom
numAtoms = len(regularAtoms)
if numAtoms == 0:
continue # maybe just ts and ks setting
self.insertKsTs(m, ts, ks)
atomLength = common.opFrac(ts.barDuration.quarterLength / numAtoms)
for atom in regularAtoms:
if atom == 'R':
rest = note.Rest(quarterLength=atomLength)
lastChord = None
lastChordIsInSameMeasure = False
m.append(rest)
else:
atom = self.fixupChordAtom(atom)
rn = roman.RomanNumeral(atom, ks)
if self.isSame(rn, lastChord) and lastChordIsInSameMeasure:
lastChord.duration.quarterLength += atomLength
m.elementsChanged()
else:
rn.duration.quarterLength = atomLength
self.addOptionalTieAndLyrics(rn, lastChord)
lastChord = rn
lastChordIsInSameMeasure = True
m.append(rn)
measures.append(m)
for i in range(1, numReps):
measures.append(copy.deepcopy(m))
else:
environLocal.warn("Rule found without | or $, ignoring: '{0}','{1}': in {2}".format(
content, sep, self.text))
#pass
if len(measures) > 0:
for m in measures:
noteIter = m.recurse().notes
if noteIter and (self.parent is None or self.parent.labelSubsectionsOnScore is True) and self.LHS != 'S':
rn = noteIter[0]
lyricNum = len(rn.lyrics) + 1
rn.lyrics.append(note.Lyric(self.LHS, number=lyricNum))
break
return measures
def reBar(music21Part, inPlace=True):
"""
Re-bar overflow measures using the last known time signature.
>>> from music21 import corpus
>>> irl2 = corpus.parse("irl", number=2)
>>> irl2.metadata.title
'Aililiu na Gamhna, S.35'
>>> music21Part = irl2[1]
The whole part is in 2/4 time, but there are some measures expressed in 4/4 time
without an explicit time signature change, an error in abc parsing due to the
omission of barlines. The method will split those measures such that they conform
to the last time signature, in this case 2/4. The default is to reBar in place.
The measure numbers are updated accordingly.
(NOTE: reBar is called automatically in abcToStreamPart, hence not demonstrated below...)
The key signature and clef are assumed to be the same in the second measure after the
split, so both are omitted. If the time signature is not the same in the second measure,
the new time signature is indicated, and the measure following returns to the last time
signature, except in the case that a new time signature is indicated.
>>> music21Part.measure(15).show("text")
{0.0} <music21.note.Note A>
{1.0} <music21.note.Note A>
>>> music21Part.measure(16).show("text")
{0.0} <music21.note.Note A>
{0.5} <music21.note.Note B->
{1.0} <music21.note.Note A>
{1.5} <music21.note.Note G>
An example where the time signature wouldn't be the same. This score is
mistakenly marked as 4/4, but has some measures that are longer.
>>> irl15 = corpus.parse("irl", number=15)
>>> irl15.metadata.title
'Esternowe, S. 60'
>>> music21Part2 = irl15.parts[0] # 4/4 time signature
>>> music21Part2.measure(1).show("text")
{0.0} <music21.note.Note C>
{1.0} <music21.note.Note A>
{1.5} <music21.note.Note G>
{2.0} <music21.note.Note E>
{2.5} <music21.note.Note G>
>>> music21Part2.measure(1)[-1].duration.quarterLength
1.5
>>> music21Part2.measure(2).show("text")
{0.0} <music21.meter.TimeSignature 1/8>
{0.0} <music21.note.Note E>
"""
if not inPlace:
music21Part = copy.deepcopy(music21Part)
lastTimeSignature = None
measureNumberOffset = 0 # amount to shift current measure numbers
allMeasures = music21Part.getElementsByClass(stream.Measure)
for measureIndex in range(len(allMeasures)):
music21Measure = allMeasures[measureIndex]
if music21Measure.timeSignature is not None:
lastTimeSignature = music21Measure.timeSignature
if lastTimeSignature is None:
raise ABCTranslateException("No time signature found in this Part")
tsEnd = lastTimeSignature.barDuration.quarterLength
mEnd = common.opFrac(music21Measure.highestTime)
music21Measure.number += measureNumberOffset
if mEnd > tsEnd:
m1, m2 = music21Measure.splitAtQuarterLength(tsEnd)
m2.timeSignature = None
if lastTimeSignature.barDuration.quarterLength != m2.highestTime:
try:
m2.timeSignature = m2.bestTimeSignature()
except exceptions21.StreamException as e:
raise ABCTranslateException("Problem with measure %d (%r): %s" % (music21Measure.number, music21Measure, e))
if measureIndex != len(allMeasures) - 1:
if allMeasures[measureIndex+1].timeSignature is None:
allMeasures[measureIndex+1].timeSignature = lastTimeSignature
m2.keySignature = None # suppress the key signature
m2.clef = None # suppress the clef
m2.number = m1.number + 1
measureNumberOffset += 1
music21Part.insert(common.opFrac(m1.offsetRational + m1.highestTime), m2)
#elif (mEnd + music21Measure.paddingLeft) < tsEnd and measureIndex != len(allMeasures) - 1:
# The first and last measures are allowed to be incomplete
# music21Measure.timeSignature = music21Measure.bestTimeSignature()
# if allMeasures[measureIndex+1].timeSignature is None:
# allMeasures[measureIndex+1].timeSignature = lastTimeSignature
#
if not inPlace:
return music21Part
def makeBeams(s, inPlace=False):
'''
Return a new Measure, or Stream of Measures, with beams applied to all
notes. Measures with Voices will process voices independently.
Note that `makeBeams()` is automatically called in show('musicxml') and
other formats if there is no beaming information in the piece (see
`haveBeamsBeenMade`).
If `inPlace` is True, this is done in-place; if `inPlace` is False,
this returns a modified deep copy.
.. note: Before Version 1.6, `inPlace` default was `True`; now `False`
like most `inPlace` options in music21. Also, in 1.8, no tuplets are made
automatically. Use makeTupletBrackets()
See :meth:`~music21.meter.TimeSignature.getBeams` for the algorithm used.
>>> from music21 import meter
>>> from music21 import stream
>>> aMeasure = stream.Measure()
>>> aMeasure.timeSignature = meter.TimeSignature('4/4')
>>> aNote = note.Note()
>>> aNote.quarterLength = .25
>>> aMeasure.repeatAppend(aNote,16)
>>> bMeasure = aMeasure.makeBeams(inPlace=False)
>>> for i in range(0, 4):
... print("%d %r" % (i, bMeasure.notes[i].beams))
0 <music21.beam.Beams <music21.beam.Beam 1/start>/<music21.beam.Beam 2/start>>
1 <music21.beam.Beams <music21.beam.Beam 1/continue>/<music21.beam.Beam 2/stop>>
2 <music21.beam.Beams <music21.beam.Beam 1/continue>/<music21.beam.Beam 2/start>>
3 <music21.beam.Beams <music21.beam.Beam 1/stop>/<music21.beam.Beam 2/stop>>
OMIT_FROM_DOCS
TODO: inPlace=False does not work in many cases
'''
from music21 import stream
#environLocal.printDebug(['calling Stream.makeBeams()'])
if not inPlace: # make a copy
returnObj = copy.deepcopy(s)
else:
returnObj = s
#if s.isClass(Measure):
if 'Measure' in s.classes:
#if s.isClassOrSubclass('Measure'):
mColl = [] # store a list of measures for processing
mColl.append(returnObj)
elif s.iter.getElementsByClass('Measure'):
mColl = list(returnObj.iter.getElementsByClass('Measure')) # a list of measures
else:
raise stream.StreamException(
'cannot process a stream that neither is a Measure nor has '
'Measures')
lastTimeSignature = None
for m in mColl:
# this means that the first of a stream of time signatures will
# be used
if m.timeSignature is not None:
lastTimeSignature = m.timeSignature
if lastTimeSignature is None:
#environLocal.printDebug([
# 'makeBeams(): lastTimeSignature is None: cannot process'])
# TODO: Reduce to warning...
raise stream.StreamException(
'cannot process beams in a Measure without a time signature')
noteGroups = []
if m.hasVoices():
for v in m.voices:
noteGroups.append(v.iter.notesAndRests.stream())
else:
noteGroups.append(m.iter.notesAndRests.stream())
#environLocal.printDebug([
# 'noteGroups', noteGroups, 'len(noteGroups[0])',
# len(noteGroups[0])])
for noteStream in noteGroups:
if len(noteStream) <= 1:
continue # nothing to beam
durList = []
for n in noteStream:
durList.append(n.duration)
#environLocal.printDebug([
# 'beaming with ts', lastTimeSignature, 'measure', m, durList,
# noteStream[0], noteStream[1]])
# error check; call before sending to time signature, as, if this
# fails, it represents a problem that happens before time signature
# processing
durSum = opFrac(sum([d.quarterLength for d in durList]))
barQL = lastTimeSignature.barDuration.quarterLength
if durSum > barQL:
#environLocal.printDebug([
# 'attempting makeBeams with a bar that contains durations
# that sum greater than bar duration (%s > %s)' %
# (durSum, barQL)])
continue
# getBeams can take a list of Durations; however, this cannot
# distinguish a Note from a Rest; thus, we can submit a flat
# stream of note or note-like entities; will return
# the same list of beam objects
offset = 0.0
if m.paddingLeft != 0.0:
offset = opFrac(m.paddingLeft)
elif (noteStream.highestTime <
lastTimeSignature.barDuration.quarterLength):
offset = (lastTimeSignature.barDuration.quarterLength -
noteStream.highestTime)
beamsList = lastTimeSignature.getBeams(
noteStream, measureStartOffset=offset)
for i in range(len(noteStream)):
# this may try to assign a beam to a Rest
noteStream[i].beams = beamsList[i]
del mColl # remove Stream no longer needed
if inPlace is not True:
return returnObj
def makeTupletBrackets(s, inPlace=False):
'''
Given a Stream of mixed durations, designates the first and last tuplet of any group
of tuplets as the start or end of the tuplet, respectively.
Changed in 1.8::
* `inPlace` is False by default
* to incorporate duration.updateTupletType, can take a list of durations
TODO: does not handle nested tuplets
>>> n = note.Note()
>>> n.duration.quarterLength = 1.0/3
>>> s = stream.Stream()
>>> s.insert(0, meter.TimeSignature('2/4'))
>>> s.repeatAppend(n, 6)
>>> tupletTypes = [x.duration.tuplets[0].type for x in s.notes]
>>> tupletTypes
[None, None, None, None, None, None]
>>> stream.makeNotation.makeTupletBrackets(s, inPlace=True)
>>> tupletTypes = [x.duration.tuplets[0].type for x in s.notes]
>>> tupletTypes
['start', None, 'stop', 'start', None, 'stop']
'''
durationList = []
# legacy -- works on lists not just streams...
if isinstance(s, list) or isinstance(s, tuple):
durationList = s
else:
# Stream, as it should be...
if not inPlace: # make a copy
returnObj = copy.deepcopy(s)
else:
returnObj = s
# only want to look at notes
notes = returnObj.notesAndRests
for n in notes:
durationList.append(n.duration)
tupletMap = [] # a list of (tuplet obj / Duration) pairs
for dur in durationList: # all Duration objects
tupletList = dur.tuplets
if tupletList in [(), None]: # no tuplets, length is zero
tupletMap.append([None, dur])
elif len(tupletList) > 1:
#for i in range(len(tuplets)):
# tupletMap.append([tuplets[i],dur])
environLocal.warn('got multi-tuplet duration; cannot yet handle this. %s' % repr(tupletList))
elif len(tupletList) == 1:
tupletMap.append([tupletList[0], dur])
if tupletList[0] != dur.tuplets[0]:
raise Exception('cannot access Tuplets object from within DurationTuple.')
else:
raise Exception('cannot handle these tuplets: %s' % tupletList)
# have a list of tuplet, Duration pairs
completionCount = 0 # qLen currently filled
completionTarget = None # qLen necessary to fill tuplet
for i in range(len(tupletMap)):
tupletObj, dur = tupletMap[i]
if i > 0:
tupletPrevious = tupletMap[i - 1][0]
else:
tupletPrevious = None
if i < len(tupletMap) - 1:
tupletNext = tupletMap[i + 1][0]
# if tupletNext != None:
# nextNormalType = tupletNext.durationNormal.type
# else:
# nextNormalType = None
else:
tupletNext = None
# nextNormalType = None
# environLocal.printDebug(['updateTupletType previous, this, next:',
# tupletPrevious, tuplet, tupletNext])
if tupletObj is not None:
# thisNormalType = tuplet.durationNormal.type
completionCount = opFrac(completionCount + dur.quarterLength)
# if previous tuplet is None, always start
# always reset completion target
if tupletPrevious is None or completionTarget is None:
if tupletNext is None: # single tuplet w/o tuplets either side
tupletObj.type = 'startStop'
tupletObj.bracket = False
completionCount = 0 # reset
else:
tupletObj.type = 'start'
# get total quarter length of this tuplet
completionTarget = tupletObj.totalTupletLength()
#environLocal.printDebug(['starting tuplet type, value:',
# tuplet, tuplet.type])
#environLocal.printDebug(['completion count, target:',
# completionCount, completionTarget])
# if tuplet next is None, always stop
# if both previous and next are None, just keep a start
# this, below, is optional:
# if next normal type is not the same as this one, also stop
elif (tupletNext is None or completionCount >= completionTarget):
tupletObj.type = 'stop' # should be impossible once frozen...
completionTarget = None # reset
completionCount = 0 # reset
#environLocal.printDebug(['stopping tuplet type, value:',
# tuplet, tuplet.type])
#environLocal.printDebug(['completion count, target:',
# completionCount, completionTarget])
# if tuplet next and previous not None, increment
elif tupletPrevious != None and tupletNext != None:
# do not need to change tuplet type; should be None
pass
#environLocal.printDebug(['completion count, target:',
# completionCount, completionTarget])
if not inPlace:
return returnObj
def makeElement(self,
quarterLength=1.0,
*,
addTies=True,
addPartIdAsGroup=False,
removeRedundantPitches=True,
gatherArticulations='single',
gatherExpressions='single'
):
r'''
Makes a Chord or Rest from this verticality and quarterLength.
>>> score = tree.makeExampleScore()
>>> scoreTree = tree.fromStream.asTimespans(score, flatten=True,
... classList=(note.Note, chord.Chord))
>>> verticality = scoreTree.getVerticalityAt(4.0)
>>> verticality
<Verticality 4.0 {E#3 G3}>
>>> verticality.startTimespans
(<PitchedTimespan (4.0 to 5.0) <music21.note.Note G>>,
<PitchedTimespan (4.0 to 6.0) <music21.note.Note E#>>)
>>> el = verticality.makeElement(2.0)
>>> el
<music21.chord.Chord E#3 G3>
>>> el.duration.quarterLength
2.0
>>> el.duration.type
'half'
If there is nothing there, then a Rest is created
>>> verticality = scoreTree.getVerticalityAt(400.0)
>>> verticality
<Verticality 400.0 {}>
>>> el = verticality.makeElement(1./3)
>>> el
<music21.note.Rest rest>
>>> el.duration.fullName
'Eighth Triplet (1/3 QL)'
>>> n1 = note.Note('C4')
>>> n2 = note.Note('C4')
>>> s = stream.Score()
>>> s.insert(0, n1)
>>> s.insert(0.5, n2)
>>> scoreTree = s.asTimespans()
>>> verticality = scoreTree.getVerticalityAt(0.5)
>>> c = verticality.makeElement(0.5)
>>> c
<music21.chord.Chord C4>
>>> c = verticality.makeElement(0.5, removeRedundantPitches=False)
>>> c
<music21.chord.Chord C4 C4>
gatherArticulations and gatherExpressions can be True, False, or (default) 'single'.
* If False, no articulations (or expressions) are transferred to the chord.
* If True, all articulations are transferred to the chord.
* If 'single', then no more than one articulation of each class (chosen from the lowest
note) will be added. This way, the chord does not get 4 fermatas, etc.
>>> n1 = note.Note('C4')
>>> n2 = note.Note('D4')
>>> s = stream.Stream()
>>> s.insert(0, n1)
>>> s.insert(0.5, n2)
>>> class AllAttachArticulation(articulations.Articulation):
... def __init__(self):
... super().__init__()
... self.tieAttach = 'all'
>>> class OtherAllAttachArticulation(articulations.Articulation):
... def __init__(self):
... super().__init__()
... self.tieAttach = 'all'
>>> n1.articulations.append(articulations.Accent())
>>> n1.articulations.append(AllAttachArticulation())
>>> n1.expressions.append(expressions.Fermata())
>>> n2.articulations.append(articulations.Staccato())
>>> n2.articulations.append(AllAttachArticulation())
>>> n2.articulations.append(OtherAllAttachArticulation())
>>> n2.expressions.append(expressions.Fermata())
>>> scoreTree = s.asTimespans()
>>> verticality = scoreTree.getVerticalityAt(0.0)
>>> c = verticality.makeElement(1.0)
>>> c.expressions
[<music21.expressions.Fermata>]
>>> c.articulations
[<music21.articulations.Accent>, <music21.articulations.AllAttachArticulation>]
>>> verticality = scoreTree.getVerticalityAt(0.5)
Here there will be no expressions, because there is no note ending
at 0.75 and Fermatas attach to the last note:
>>> c = verticality.makeElement(0.25)
>>> c.expressions
[]
>>> c = verticality.makeElement(0.5)
>>> c.expressions
[<music21.expressions.Fermata>]
Only two articulations, since accent attaches to beginning and staccato attaches to last
and we are beginning after the start of the first note (with an accent)
and cutting right through the second note (with a staccato)
>>> c.articulations
[<music21.articulations.AllAttachArticulation>,
<music21.articulations.OtherAllAttachArticulation>]
>>> c = verticality.makeElement(0.5, gatherArticulations=True)
>>> c.articulations
[<music21.articulations.AllAttachArticulation>,
<music21.articulations.AllAttachArticulation>,
<music21.articulations.OtherAllAttachArticulation>]
>>> c = verticality.makeElement(0.5, gatherArticulations=False)
>>> c.articulations
[]
>>> verticality = scoreTree.getVerticalityAt(1.0)
>>> c = verticality.makeElement(0.5)
>>> c.expressions
[<music21.expressions.Fermata>]
>>> c.articulations
[<music21.articulations.Staccato>,
<music21.articulations.AllAttachArticulation>,
<music21.articulations.OtherAllAttachArticulation>]
'''
if not self.pitchSet:
r = note.Rest()
r.duration.quarterLength = common.opFrac(quarterLength)
return r
# easy stuff done, time to get to the hard stuff...
c = chord.Chord()
c.duration.quarterLength = common.opFrac(quarterLength)
dur = c.duration
seenPitches = set()
notesToAdd = {}
startStopSet = {'start', 'stop'}
pitchBust = 0 # used if removeRedundantPitches is False.
def newNote(ts, n):
'''
Make a copy of the note and clear some settings
'''
nNew = copy.deepcopy(n)
nNew.duration = dur
if nNew.stemDirection != 'noStem':
nNew.stemDirection = None
if not addTies:
return nNew
offsetDifference = common.opFrac(self.offset - ts.offset)
endTimeDifference = common.opFrac(ts.endTime - (self.offset + quarterLength))
if offsetDifference == 0 and endTimeDifference <= 0:
addTie = None
elif offsetDifference > 0:
if endTimeDifference > 0:
addTie = 'continue'
else:
addTie = 'stop'
elif endTimeDifference > 0:
addTie = 'start'
else:
raise VerticalityException("What possibility was missed?",
offsetDifference, endTimeDifference, ts, self)
if nNew.tie is not None and {nNew.tie.type, addTie} == startStopSet:
nNew.tie.type = 'continue'
elif nNew.tie is not None and nNew.tie.type == 'continue':
nNew.tie.placement = None
elif addTie is None and nNew.tie is not None:
nNew.tie.placement = None
elif addTie:
nNew.tie = tie.Tie(addTie)
return nNew
def conditionalAdd(ts, n):
'''
Add an element only if it is not already in the chord.
If it has more tie information than the previously
added note, then remove the previously added note and add it
'''
nonlocal pitchBust # love Py3!!!
p = n.pitch
pitchKey = p.nameWithOctave
pitchGroup = None
if addPartIdAsGroup:
partContext = n.getContextByClass('Part')
if partContext is not None:
pidStr = str(partContext.id)
pitchGroup = pidStr.replace(' ', '_') # spaces are not allowed as group names
n.pitch.groups.append(pitchGroup)
n.groups.append(pitchGroup)
if pitchKey not in seenPitches:
seenPitches.add(pitchKey)
notesToAdd[pitchKey] = newNote(ts, n)
return
elif not removeRedundantPitches:
notesToAdd[pitchKey + str(pitchBust)] = newNote(ts, n)
pitchBust += 1
return
elif addPartIdAsGroup:
notesToAdd[pitchKey].groups.append(pitchGroup)
notesToAdd[pitchKey].pitch.groups.append(pitchGroup)
if not addTies:
return
# else add derivation once multiple derivations are allowed.
oldNoteTie = notesToAdd[pitchKey].tie
if oldNoteTie is not None and oldNoteTie.type == 'continue':
return # previous note was as good or better
possibleNewNote = newNote(ts, n)
possibleNewNote.groups = notesToAdd[pitchKey].groups
if possibleNewNote.tie is None:
return # do nothing
elif oldNoteTie is None:
notesToAdd[pitchKey] = possibleNewNote # a better note to add
elif {oldNoteTie.type, possibleNewNote.tie.type} == startStopSet:
notesToAdd[pitchKey].tie.type = 'continue'
elif possibleNewNote.tie.type == 'continue':
notesToAdd[pitchKey] = possibleNewNote # a better note to add
elif possibleNewNote.tie.type == oldNoteTie.type:
return
else:
raise VerticalityException("Did I miss one? ", possibleNewNote.tie, oldNoteTie)
for ts in self.startAndOverlapTimespans:
if not isinstance(ts, spans.PitchedTimespan):
continue
el = ts.element
if 'Chord' in el.classes:
if len(el) == 0: # pylint: disable=len-as-condition
continue
if el.articulations or el.expressions:
firstSubEl = copy.deepcopy(el[0]) # this makes an additional deepcopy
firstSubEl.articulations += el.articulations
firstSubEl.expressions += el.expressions
else:
firstSubEl = el[0]
conditionalAdd(ts, firstSubEl)
if len(el) > 1:
for subEl in list(el)[1:]:
conditionalAdd(ts, subEl)
else:
conditionalAdd(ts, el)
seenArticulations = set()
seenExpressions = set()
# pylint: disable=unidiomatic-typecheck
for n in sorted(notesToAdd.values(), key=lambda x: x.pitch.ps):
c.add(n)
if gatherArticulations:
for art in n.articulations:
if art.tieAttach == 'first' and n.tie is not None and n.tie.type != 'start':
continue
if art.tieAttach == 'last' and n.tie is not None and n.tie.type != 'stop':
continue
if gatherArticulations == 'single' and type(art) in seenArticulations:
continue
c.articulations.append(art)
seenArticulations.add(type(art))
if gatherExpressions:
for exp in n.expressions:
if exp.tieAttach == 'first' and n.tie is not None and n.tie.type != 'start':
continue
if exp.tieAttach == 'last' and n.tie is not None and n.tie.type != 'stop':
continue
if gatherExpressions == 'single' and type(exp) in seenExpressions:
continue
c.expressions.append(exp)
seenExpressions.add(type(exp))
return c
def isElementOffsetInRange(self, e, offset, *, stopAfterEnd=False):
'''
Given an element, offset, and stream, return
True, False, or raise StopIteration if the
element is in the range, not in the range, or (if stopAfterEnd is True) is not
and no future elements will be in the range.
Factored out from __call__ to be used by OffsetHierarchyFilter and it's just
a beast. :-)
'''
if offset > self.offsetEnd: # anything that begins after the span is definitely out
if stopAfterEnd:
# if sorted, optimize by breaking after exceeding offsetEnd
# eventually we could do a binary search to speed up...
raise StopIteration
else:
return False
dur = e.duration
elementEnd = opFrac(offset + dur.quarterLength)
if elementEnd < self.offsetStart:
# anything that finishes before the span ends is definitely out
return False
# some part of the element is at least touching some part of span.
# all the simple cases done! Now need to filter out those that
# are border cases depending on settings
if dur.quarterLength == 0:
elementIsZeroLength = True
else:
elementIsZeroLength = False
if self.zeroLengthSearch is True and elementIsZeroLength is True:
# zero Length Searches -- include all zeroLengthElements
return True
if self.mustFinishInSpan is True:
if elementEnd > self.offsetEnd:
# environLocal.warn([elementEnd, offsetEnd, e])
return False
if self.includeEndBoundary is False:
# we include the end boundary if the search is zeroLength --
# otherwise nothing can be retrieved
if elementEnd == self.offsetEnd:
return False
if self.mustBeginInSpan is True:
if offset < self.offsetStart:
return False
if self.includeEndBoundary is False and offset == self.offsetEnd:
return False
elif (elementIsZeroLength is False
and elementEnd == self.offsetEnd
and self.zeroLengthSearch is True):
return False
if self.includeEndBoundary is False and offset == self.offsetEnd:
return False
if self.includeElementsThatEndAtStart is False and elementEnd == self.offsetStart:
return False
return True
def partScoreFromSystemScore(self, systemScore):
'''
Take a :class:`~music21.stream.Score` object which is organized
by Systems and return a new `Score` object which is organized by
Parts.
'''
# this line is redundant currently, since all we have in systemScore
# are Systems, but later there will be other things.
systemStream = systemScore.getElementsByClass('System')
partDictById = {}
for thisSystem in systemStream:
# this line is redundant currently, since all we have in
# thisSystem are Parts, but later there will be other things.
systemOffset = thisSystem.getOffsetBySite(systemScore)
partStream = thisSystem.getElementsByClass('Part')
for j, thisPart in enumerate(partStream):
if thisPart.id not in partDictById:
newPart = stream.Part()
newPart.id = thisPart.id
partDictById[thisPart.id] = {'part': newPart, 'number': j}
else:
newPart = partDictById[thisPart.id]['part']
for el in thisPart: # no need for recurse...
newPart._insertCore(common.opFrac(el.offset + systemOffset), el)
newPart._elementsChanged()
newScore = stream.Score()
## ORDERED DICT
parts = [None for i in range(len(partDictById))]
for partId in partDictById:
partDict = partDictById[partId]
parts[partDict['number']] = partDict['part']
for p in parts:
# remove redundant Clef and KeySignatures
clefs = p.getElementsByClass('Clef')
keySignatures = p.getElementsByClass('KeySignature')
lastClef = None
lastKeySignature = None
for c in clefs:
if c == lastClef:
p.remove(c)
else:
lastClef = c
for ks in keySignatures:
if ks == lastKeySignature:
p.remove(ks)
else:
lastKeySignature = ks
p.makeMeasures(inPlace=True)
# for m in p.getElementsByClass('Measure'):
# barLines = m.getElementsByClass('Barline')
# for bl in barLines:
# blOffset = bl.offset
# if blOffset == 0.0:
# m.remove(bl)
# m.leftBarline = bl
# elif blOffset == m.highestTime:
# m.remove(bl)
# m.rightBarline = bl # will not yet work for double repeats!
newScore._insertCore(0, p)
newScore._elementsChanged()
return newScore
def __call__(self, e, iterator):
dur = e.duration
s = iterator.srcStream
if s is e:
return False
offset = s.elementOffset(e)
#offset = common.cleanupFloat(offset)
if offset > self.offsetEnd: # anything that ends after the span is definitely out
if s.isSorted:
# if sorted, optimize by breaking after exceeding offsetEnd
# eventually we could do a binary search to speed up...
raise StopIteration
else:
return False
elementEnd = opFrac(offset + dur.quarterLength)
if elementEnd < self.offsetStart:
# anything that finishes before the span ends is definitely out
return False
if dur.quarterLength == 0:
elementIsZeroLength = True
else:
elementIsZeroLength = False
# all the simple cases done! Now need to filter out those that
# are border cases depending on settings
if self.zeroLengthSearch is True and elementIsZeroLength is True:
# zero Length Searches -- include all zeroLengthElements
return True
if self.mustFinishInSpan is True:
if elementEnd > self.offsetEnd:
#environLocal.warn([elementEnd, offsetEnd, e])
return False
if self.includeEndBoundary is False:
# we include the end boundary if the search is zeroLength --
# otherwise nothing can be retrieved
if elementEnd == self.offsetEnd:
return False
if self.mustBeginInSpan is True:
if offset < self.offsetStart:
return False
if self.includeEndBoundary is False:
if offset >= self.offsetEnd:
# >= is unnecessary, should just be ==, but better safe than sorry
return False
if self.mustBeginInSpan is False:
if elementIsZeroLength is False:
if elementEnd == self.offsetEnd and self.zeroLengthSearch is True:
return False
if self.includeEndBoundary is False:
if offset >= self.offsetEnd:
return False
if self.includeElementsThatEndAtStart is False and elementEnd == self.offsetStart:
return False
return True
def getBeatFloatOrFrac(self):
'''
Gets the beat number as a float or fraction. Time signature independent
>>> RTB = romanText.rtObjects.RTBeat
Simple ones:
>>> RTB('b1').getBeatFloatOrFrac()
1.0
>>> RTB('b2').getBeatFloatOrFrac()
2.0
etc.
with easy float:
>>> RTB('b1.5').getBeatFloatOrFrac()
1.5
>>> RTB('b1.25').getBeatFloatOrFrac()
1.25
with harder:
>>> RTB('b1.33').getBeatFloatOrFrac()
Fraction(4, 3)
>>> RTB('b2.66').getBeatFloatOrFrac()
Fraction(8, 3)
>>> RTB('b1.2').getBeatFloatOrFrac()
Fraction(6, 5)
A third digit of .5 adds 1/2 of 1/DENOM of before. Here DENOM is 3 (in 5/3) so
we add 1/6 to 5/3 to get 11/6:
>>> RTB('b1.66').getBeatFloatOrFrac()
Fraction(5, 3)
>>> RTB('b1.66.5').getBeatFloatOrFrac()
Fraction(11, 6)
Similarly .25 adds 1/4 of 1/DENOM... to get 21/12 or 7/4 or 1.75
>>> RTB('b1.66.25').getBeatFloatOrFrac()
1.75
And .75 adds 3/4 of 1/DENOM to get 23/12
>>> RTB('b1.66.75').getBeatFloatOrFrac()
Fraction(23, 12)
A weird way of writing 'b1.5'
>>> RTB('b1.33.5').getBeatFloatOrFrac()
1.5
'''
beatStr = self.src.replace('b', '')
# there may be more than one decimal in the number, such as
# 1.66.5, to show halfway through 2/3rd of a beat
parts = beatStr.split('.')
mainBeat = int(parts[0])
if len(parts) > 1: # 1.66
fracPart = common.addFloatPrecision('.' + parts[1])
else:
fracPart = 0.0
if len(parts) > 2: # 1.66.5
fracPartDivisor = float('.' + parts[2]) # 0.5
if isinstance(fracPart, float):
fracPart = Fraction.from_float(fracPart)
denom = fracPart.denominator
fracBeatFrac = common.opFrac(1./(denom/fracPartDivisor))
else:
fracBeatFrac = 0.0
if len(parts) > 3:
environLocal.printDebug(['got unexpected beat: %s' % self.src])
raise RTTokenException('cannot handle specification: %s' % self.src)
beat = common.opFrac(mainBeat + fracPart + fracBeatFrac)
return beat
def makeTies(
s,
meterStream=None,
inPlace=True,
displayTiedAccidentals=False,
):
'''
Given a stream containing measures, examine each element in the
Stream. If the elements duration extends beyond the measure's boundary,
create a tied entity, placing the split Note in the next Measure.
Note that this method assumes that there is appropriate space in the
next Measure: this will not shift Note objects, but instead allocate
them evenly over barlines. Generally, makeMeasures is called prior to
calling this method.
If `inPlace` is True, this is done in-place;
if `inPlace` is False, this returns a modified deep copy.
Put a 12-quarter-note-long note into a Stream w/ 4/4 as the duration.
>>> d = stream.Stream()
>>> d.insert(0, meter.TimeSignature('4/4'))
>>> n = note.Note('C4')
>>> n.quarterLength = 12
>>> d.insert(0, n)
>>> d.show('text')
{0.0} <music21.meter.TimeSignature 4/4>
{0.0} <music21.note.Note C>
After running makeMeasures, we get nice measures, a clef, but only one
way-too-long note in Measure 1:
>>> x = d.makeMeasures()
>>> x.show('text')
{0.0} <music21.stream.Measure 1 offset=0.0>
{0.0} <music21.clef.TrebleClef>
{0.0} <music21.meter.TimeSignature 4/4>
{0.0} <music21.note.Note C>
{4.0} <music21.stream.Measure 2 offset=4.0>
<BLANKLINE>
{8.0} <music21.stream.Measure 3 offset=8.0>
{0.0} <music21.bar.Barline style=final>
>>> n2 = x.measure(1).notes[0]
>>> n2.duration.quarterLength
12.0
>>> n2 is n
False
But after running makeTies, all is good:
>>> x.makeTies(inPlace=True)
>>> x.show('text')
{0.0} <music21.stream.Measure 1 offset=0.0>
{0.0} <music21.clef.TrebleClef>
{0.0} <music21.meter.TimeSignature 4/4>
{0.0} <music21.note.Note C>
{4.0} <music21.stream.Measure 2 offset=4.0>
{0.0} <music21.note.Note C>
{8.0} <music21.stream.Measure 3 offset=8.0>
{0.0} <music21.note.Note C>
{4.0} <music21.bar.Barline style=final>
>>> m = x.measure(1).notes[0]
>>> m.duration.quarterLength
4.0
>>> m is n
False
>>> m.tie
<music21.tie.Tie start>
>>> x.measure(2).notes[0].tie
<music21.tie.Tie continue>
>>> x.measure(3).notes[0].tie
<music21.tie.Tie stop>
Same experiment, but with rests:
>>> d = stream.Stream()
>>> d.insert(0, meter.TimeSignature('4/4'))
>>> r = note.Rest()
>>> r.quarterLength = 12
>>> d.insert(0, r)
>>> x = d.makeMeasures()
>>> x.makeTies(inPlace = True)
>>> x.show('text')
{0.0} <music21.stream.Measure 1 offset=0.0>
{0.0} <music21.clef.TrebleClef>
{0.0} <music21.meter.TimeSignature 4/4>
{0.0} <music21.note.Rest rest>
{4.0} <music21.stream.Measure 2 offset=4.0>
{0.0} <music21.note.Rest rest>
{8.0} <music21.stream.Measure 3 offset=8.0>
{0.0} <music21.note.Rest rest>
{4.0} <music21.bar.Barline style=final>
Notes: uses base.Music21Object.splitAtQuarterLength() once it has figured out
what to split.
OMIT_FROM_DOCS
TODO: inPlace should be False
TODO: take a list of clases to act as filter on what elements are tied.
configure ".previous" and ".next" attributes
'''
from music21 import stream
#environLocal.printDebug(['calling Stream.makeTies()'])
if not inPlace: # make a copy
returnObj = copy.deepcopy(s)
else:
returnObj = s
if len(returnObj) == 0:
raise stream.StreamException('cannot process an empty stream')
# get measures from this stream
measureStream = returnObj.getElementsByClass('Measure')
if len(measureStream) == 0:
raise stream.StreamException(
'cannot process a stream without measures')
#environLocal.printDebug([
# 'makeTies() processing measureStream, length', measureStream,
# len(measureStream)])
# may need to look in activeSite if no time signatures are found
# presently searchContext is False to save time
if meterStream is None:
meterStream = returnObj.getTimeSignatures(sortByCreationTime=True,
searchContext=False)
mCount = 0
lastTimeSignature = None
while True:
# update measureStream on each iteration,
# as new measure may have been added to the returnObj stream
measureStream = returnObj.getElementsByClass('Measure')
if mCount >= len(measureStream):
break # reached the end of all measures available or added
# get the current measure to look for notes that need ties
m = measureStream[mCount]
if m.timeSignature is not None:
lastTimeSignature = m.timeSignature
# get next measure; we may not need it, but have it ready
if mCount + 1 < len(measureStream):
mNext = measureStream[mCount + 1]
mNextAdd = False # already present; do not append
else: # create a new measure
mNext = stream.Measure()
# set offset to last offset plus total length
moffset = measureStream.elementOffset(m)
if lastTimeSignature is not None:
mNext.offset = (moffset +
lastTimeSignature.barDuration.quarterLength)
else:
mNext.offset = moffset
if len(meterStream) == 0: # in case no meters are defined
ts = meter.TimeSignature()
ts.load('%s/%s' % (defaults.meterNumerator,
defaults.meterDenominatorBeatType))
else: # get the last encountered meter
ts = meterStream.getElementAtOrBefore(mNext.offset)
# only copy and assign if not the same as the last
if (lastTimeSignature is not None and
not lastTimeSignature.ratioEqual(ts)):
mNext.timeSignature = copy.deepcopy(ts)
# increment measure number
mNext.number = m.number + 1
mNextAdd = True # new measure, needs to be appended
if mNext.hasVoices():
mNextHasVoices = True
else:
mNextHasVoices = False
#environLocal.printDebug([
# 'makeTies() dealing with measure', m, 'mNextAdd', mNextAdd])
# for each measure, go through each element and see if its
# duraton fits in the bar that contains it
# if there are voices, we must look at voice id values to only
# connect ties to components in the same voice, assuming there
# are voices in the next measure
try:
mEnd = lastTimeSignature.barDuration.quarterLength
except AttributeError:
ts = m.getContextByClass('TimeSignature')
if ts is not None:
lastTimeSignature = ts
mEnd = lastTimeSignature.barDuration.quarterLength
else:
mEnd = 4.0 # Default
if m.hasVoices():
bundle = m.voices
mHasVoices = True
else:
bundle = [m]
mHasVoices = False
# bundle components may be voices, or just a measure
for v in bundle:
for e in v:
#environLocal.printDebug([
# 'Stream.makeTies() iterating over elements in measure',
# m, e])
#if hasattr(e, 'duration') and e.duration is not None:
if e.duration is not None:
# check to see if duration is within Measure
eOffset = v.elementOffset(e)
eEnd = opFrac(eOffset + e.duration.quarterLength)
# assume end can be at boundary of end of measure
overshot = eEnd - mEnd
if overshot > 0:
if eOffset >= mEnd:
continue # skip elements that extend past measure boundary.
# raise stream.StreamException(
# 'element (%s) has offset %s within a measure '
# 'that ends at offset %s' % (e, eOffset, mEnd))
qLenBegin = mEnd - eOffset
e, eRemain = e.splitAtQuarterLength(qLenBegin,
retainOrigin=True,
displayTiedAccidentals=displayTiedAccidentals)
# manage bridging voices
if mNextHasVoices:
if mHasVoices: # try to match voice id
dst = mNext.voices[v.id]
# src does not have voice, but dst does
else: # place in top-most voice
dst = mNext.voices[0]
else:
# mNext has no voices but this one does
if mHasVoices:
# internalize all components in a voice
mNext.internalize(container=stream.Voice)
# place in first voice
dst = mNext.voices[0]
else: # no voices in either
dst = mNext
#eRemain.activeSite = mNext
# manually set activeSite
# cannot use _insertCore here
dst.insert(0, eRemain)
# we are not sure that this element fits
# completely in the next measure, thus, need to
# continue processing each measure
if mNextAdd:
#environLocal.printDebug([
# 'makeTies() inserting mNext into returnObj',
# mNext])
returnObj.insert(mNext.offset, mNext)
elif overshot > 0:
environLocal.printDebug([
'makeTies() found and skipping extremely small '
'overshot into next measure', overshot])
mCount += 1
del measureStream # clean up unused streams
# changes elements
returnObj.elementsChanged()
if not inPlace:
return returnObj
else:
return None
