summaryrefslogtreecommitdiff
path: root/passage.py
diff options
context:
space:
mode:
authorHouyhnhnm <hykusb@bitmai.la>2018-06-05 15:38:15 +0200
committerHouyhnhnm <hykusb@bitmai.la>2018-06-05 15:38:15 +0200
commitfb85212cbc8e7a2866c6dda916e810df2a4ea4e0 (patch)
tree1d0c2f116052aad26ace6d8b32340a23112d29ac /passage.py
parent6f14ded166e35879e0522f2e62347a3a709518e4 (diff)
compute barlines preferentially for most prominent downs
Diffstat (limited to 'passage.py')
-rw-r--r--passage.py217
1 files changed, 209 insertions, 8 deletions
diff --git a/passage.py b/passage.py
index b95ad2c..6c25168 100644
--- a/passage.py
+++ b/passage.py
@@ -1,4 +1,7 @@
+import rhythm
from binarytree import *
+from utils import *
+from math import ceil, floor
from copy import copy, deepcopy
class Passage(object):
@@ -17,6 +20,10 @@ class Passage(object):
node.value = i
node.unify = {}
self.unified = []
+ self.durations = []
+ self.anacruses = []
+ self.landings = []
+ self.bars = []
def printSyntax(self):
print(self.tree)
@@ -64,6 +71,208 @@ class Passage(object):
return spellout
+ def setMeter(self):
+ durations = self.getDurations(self.unified)
+ pickupBar = max([fl(ceil(-self.anacruses[0])),2.0])
+ bars = []
+ for i in range(len(self.durations)-1):
+ bars.append(self.landings[i]-self.anacruses[i+1])
+ bars.append(self.landings[-1])
+ # partitionedBars = self.partition(bars, self.tree)
+ # depthScores = (flatten(depth(partitionedBars,0)))
+ # depthTransitions = [abs(depthScores[i]-depthScores[i+1]) for i in range(len(depthScores)-1) ]
+
+ print('bars',bars)
+ # print('depthScores',depthScores)
+ removedIndices = []
+ while isOversliced(bars):
+ bars, removedIndices = self.desliceBars(bars, removedIndices)
+
+ print('bars',bars)
+ removedIndices.sort()
+ removedIndices.reverse()
+ print('removedIndices',removedIndices)
+ for index in removedIndices:
+ bars.pop(index)
+ print('bars',bars)
+
+ bars.insert(0, pickupBar)
+ self.bars = bars
+ return bars
+
+
+ def desliceBars(self, bars, removedIndices):
+ # targets = [bar < 2.5 for bar in bars]
+ # i = targets.index(True)
+ targets = []
+ for b, bar in enumerate(bars):
+ if bar < 2.5:
+ targets.append(self.tree.inorder[b].size)
+ else:
+ targets.append(0)
+
+ i = targets.index(max(targets))
+ prev = i-1
+ next = i+1
+ while prev in removedIndices:
+ prev -= 1
+ while next in removedIndices:
+ next += 1
+
+ print('targets', targets)
+ print('max(targets)', max(targets), 'targets.index(max(targets))', targets.index(max(targets)))
+ scores = [node.size for node in self.tree.inorder]
+ print('scores',scores)
+ if bars[i] < 2.5:
+ right = False
+ if i == 0 or prev < 0:
+ right = True
+ elif i == len(bars)-1 or next > len(bars)-1:
+ right = False
+ else:
+ if bars[i]+bars[next] < 6 and bars[i]+bars[prev] > 6:
+ right = True
+ elif bars[i]+bars[next] > 6 and bars[i]+bars[prev] < 6:
+ right = False
+ else:
+ if scores[i] > scores[prev]:
+ right = True
+ else:
+ right = False
+
+ if right == True:
+ bars[i] += bars[next]
+ # bars.pop(next)
+ removedIndices.append(next)
+ else:
+ bars[i] += bars[prev]
+ # bars.pop(prev)
+ removedIndices.append(prev)
+ return bars, removedIndices
+
+ def consolidate(self, bars):
+ # [[[3.0, [2.5, 2.5, [5.0, 4.5]]], [2.5, [5.0, 7.0], [7.0, 4.5]]], [3.0, [5.0, [4.5, 5.0, 7.0, 5.0]], [5.0, [[4.5, 5.0], [7.0, 7.0, 4.5]], 2.0]]]
+ for component in bars:
+ pass
+
+ def partition(self, bars, syntaxTree):
+
+ if syntaxTree.left:
+ if syntaxTree.left.height > 0:
+ splitAt = syntaxTree.inorder.index(syntaxTree.left.inorder[-1])
+ leftBars = bars[0:splitAt+1]
+ leftBars = self.partition(leftBars, syntaxTree.left)
+ else:
+ leftIndex = syntaxTree.inorder.index(syntaxTree.left.inorder[-1])
+ leftBars = bars[leftIndex]
+ else:
+ leftBars = None
+
+ if syntaxTree.right:
+ if syntaxTree.right.height > 0:
+ splitAt = syntaxTree.inorder.index(syntaxTree.right.inorder[0])
+ rightBars = bars[splitAt:]
+ rightBars = self.partition(rightBars, syntaxTree.right)
+ if isinstance(rightBars, float) or isinstance(rightBars, int):
+ rightBars = [bars[splitAt-1], rightBars]
+ else:
+ rightBars.insert(0, bars[splitAt-1])
+ else:
+ rightIndex = syntaxTree.inorder.index(syntaxTree.right.inorder[0])
+ rightBars = bars[rightIndex-1:rightIndex+1]
+ else:
+ # rightIndex = syntaxTree.inorder.index(syntaxTree.right.inorder[-1])
+ rightBars = bars[-1]
+
+ if leftBars != None and rightBars != None:
+ newBars = [leftBars, rightBars]
+ elif leftBars != None:
+ newBars = leftBars
+ elif rightBars != None:
+ newBars = rightBars
+ else:
+ newBars = []
+
+ return newBars
+
+
+ def incrementalSetMeter(self, durations, anacruses, landings):
+ firstChunk = -anacruses[0]
+ firstBar = ceil(firstChunk)
+ bars = [firstBar]
+ load = 0
+ partitions = []
+ nextPartition = []
+ for i, duration in enumerate(durations):
+ nextChunk = landings[i]
+ if (i+1) < len(landings):
+ nextChunk -= anacruses[i+1]
+ load += nextChunk
+ nextPartition.append(duration)
+ if load >= 3:
+ bars.append(load)
+ partitions.append(nextPartition)
+ load = 0
+ nextPartition = []
+ return bars, partitions
+
+ def getDurations(self, unified):
+ durations = []
+ anacruses = []
+ for lexeme in unified:
+ # special extra bit before barline
+ anacrusis = 0.0
+ boundaryEvents = []
+ metricBoundaries = []
+ subdurations = []
+ for i, foot in enumerate(lexeme.cadence.footprint):
+ offsets = rhythm.getOffsets(foot)
+ firstAttack = offsets[0]
+ lastAttack = offsets[-1]
+ boundaryEvents.append( (firstAttack, offsets[-1]) )
+
+ leadingBoundary = 0
+ if firstAttack < 0:
+ leadingBoundary = floor((firstAttack*2)) / 2
+ # leadingBoundary = floor(firstAttack) # use this version for whole-beat measures (1 of 3)
+
+ trailingBoundary = 0
+ if lastAttack > 0:
+ trailingBoundary = ceil((lastAttack*2)) / 2
+ # trailingBoundary = ceil(lastAttack) # use this version for whole-beat measures (2 of 3)
+
+ # give last note some time to sustain
+ if lastAttack - floor(lastAttack) == 0:
+ trailingBoundary += 1
+ # comment below out in case of whole-beat measures (3 of 3)
+ if lastAttack - floor(lastAttack) == 0.5:
+ trailingBoundary += 0.5
+
+ # pad out to minimum duration
+ if trailingBoundary < foot['span']:
+ trailingBoundary = fl(foot['span'])
+
+ metricBoundaries.append( (leadingBoundary, trailingBoundary) )
+ subdurations.append(trailingBoundary - leadingBoundary)
+
+ # remember anacrusis of first foot - barline will come after it
+ if i == 0:
+ anacruses.append(leadingBoundary)
+
+ durations.append(sum(subdurations))
+
+ # print('boundaryEvents', boundaryEvents)
+ # print('metricBoundaries', metricBoundaries)
+ # print('subdurations', subdurations)
+
+ # print('durations', durations)
+ # print('anacruses', anacruses)
+ self.durations = durations
+ self.anacruses = anacruses
+ self.landings = [self.durations[i] + self.anacruses[i] for i in range(len(durations))]
+ return durations
+
+
'''
>>> print(root)
@@ -86,12 +295,4 @@ class Passage(object):
>>> root.postorder
[Node(4), Node(5), Node(2), Node(3), Node(1)]
-
-
-{scaffold, configuration, shell, backbone, spine, projection}
-
-# example
-dee = Passage()
-dee.print()
-
'''