def __init__(self, args, refDict):
basePmtr.RhythmParameter.__init__(self, args, refDict) # call base init
self.type = 'rhythmSieve'
self.doc = lang.docPoRs
self.argTypes = [['str', 'num', 'list'], 'num', 'str', 'list',]
self.argNames = ['logicalString', 'sieveLength', 'selectionString',
'parameterObject: Rhythm Generator']
self.argDefaults = ['3|4|5', 60, 'rw', ('l', ((3,1,1),(3,1,1),(3,5,1))),]
self.priority = 9 # rhythm gets top priority
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
self.currentPulse = None # init value, used in getCurrentRhythm
self.length = abs(int(round(self.args[1])))
self.z = list(range(0, self.length))
try:
self.sieveObj = sieve.Sieve(self.args[0], self.z)
except AttributeError:
raise error.ParameterObjectSyntaxError("incorrect sieve syntax.")
# NOTE: update this to use binary segment
# gets a binary representawtion
self.sieveSeg = self.sieveObj(0, self.z, 'bin')
# set z as list from which selector draws
self.control = self._selectorParser(self.args[2]) # raises exception
# select 1/0 from ginary sieve seg
self.selector = basePmtr.Selector(self.sieveSeg, self.control)
# create a parameter object
self.rthmObj = self._loadSub(self.args[3], 'rthmPmtrObjs')
def __init__(self, args, refDict):
"""searches a list of directories recursively and finds all files
files named in args are found within these directories
dirs are onlys serached if list of dirs has changed"""
basePmtr.Parameter.__init__(self, args, refDict) # call base init
self.type = None # in subclass
self.outputFmt = 'str' # declare outputFmt as string
self.argTypes = [['list', 'str'], 'str']
self.argNames = ['fileNameList', 'selectionString']
self.argDefaults = [[], 'rc']
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
self.dirList = [] # used to look for changes
self.filePathList = [] # updated on __call__
self.timer = rhythm.Timer() # sets start time
self.updatePathList = 1 # forces update of paths
# not sure this is functioning
#self.tLastUpdate = 0.0 # time of last file dir update
if drawer.isList(self.args[0]):
self.nameList = self.args[0]
elif drawer.isStr(self.args[0]):
tempList = []
tempList.append(self.args[0])
self.nameList = tuple(tempList)
self.control = self._selectorParser(self.args[1]) # raises exception
# choose names from name list
self.selector = basePmtr.Selector(self.nameList, self.control)
def __init__(self, args, refDict):
basePmtr.Parameter.__init__(self, args, refDict) # call base init
self.type = 'directorySelect'
self.doc = lang.docPoDs
self.outputFmt = 'str' # declare outputFmt as string
self.argTypes = ['str', 'str', 'str']
self.argNames = [
'directoryFilePath', 'fileExtension', 'selectionString'
]
self.argDefaults = ['.', 'aif', 'rw']
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
self.dirPath = ''
self.fileExt = '' # can start w/ period or not
self.filePathList = [] # updated on __call__
self.timer = rhythm.Timer() # sets start time
self.dirPath = self.args[0]
self.fileExt = self.args[1]
self.control = self._selectorParser(self.args[2]) # raises exception
# will update in self._updateFileList
# can initialize selector empty, but cannot call empty
self.selector = basePmtr.Selector([], self.control)
self.updatePathList = 1 # force update of path list on init
def __init__(self, args, refDict):
basePmtr.RhythmParameter.__init__(self, args, refDict) # call base init
self.type = 'gaRhythm'
self.doc = lang.docPoGr
self.argTypes = ['list', 'num', 'num', 'num', 'str', 'num']
self.argNames = ['pulseList', 'crossover', 'mutation', 'elitism',
'selectionString', 'populationSize']
self.argDefaults = [[(3,1,1),(3,1,1),(6,1,1),(6,3,1),(3,1,0)],.70,
.060, 0.01, 'oc', 20]
self.priority = 9 # rhythm gets top priority
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
# args = [rObj, crossoverRate, mutationRate, percentElite]
self.currentPulse = None # init value, used in getCurrentRhythm
self.rObj = rhythm.Rhythm(self.args[0])
# must check rhythm before instantiating genome
if len(self.rObj) <= 2:
msg = 'pulse list error: supply a rhythm of 3 or more pulses'
raise error.ParameterObjectSyntaxError(msg) # report error
# exapnd rhythms without rests
#self.rObj = self._expandRhythm(self.rObj)
self.bpm = 120 # used for initial dur calculations
self.crossoverRate = self.args[1]
self.mutationRate = self.args[2]
self.percentElite = self.args[3]
# get populationi size as last arg
self.popSize = self.args[5]
if self.popSize < 2:
msg = 'population size must be 2 or greater'
raise error.ParameterObjectSyntaxError(msg) # report error
try:
self.genome = genetic.Genome(self.popSize, self.rObj.get('triple'),
rhythm.bpmToBeatTime(self.bpm), self.crossoverRate,
self.mutationRate, self.percentElite)
except ValueError:
self.genome = None # this will return error when args checked
if self.genome == None:
raise error.ParameterObjectSyntaxError('genome failed to be populated.')
self.rObjBundle = [] # stores list of rhythms, by family
self.pulseBundle = [] # stores all pulses as one list
self.rawRhythmBundle = self.genome.gen(40, 1) # 2nd arg makes silent
for rawList in self.rawRhythmBundle:
rObj = rhythm.Rhythm(rawList)
rObj.setSus(.94) # create equal sustain
self.rObjBundle.append(rObj) # list of rhythms
for i in range(0, len(rObj)):
self.pulseBundle.append(rObj[i]) # flat list of pulse objects
# set pulseBundle as list from which selector draws
self.control = self._selectorParser(self.args[4]) # raises exception
self.selector = basePmtr.Selector(self.pulseBundle, self.control)
def __init__(self, args, refDict):
basePmtr.RhythmParameter.__init__(self, args, refDict) # call base init
self.type = 'pulseSieve'
self.doc = lang.docPoPs
self.argTypes = [['str', 'num','list'], 'num', 'list', 'str', 'str']
self.argNames = ['logicalString', 'sieveLength', 'pulse',
'selectionString', 'articulationString']
self.argDefaults = ['3|4|5@2', 60, (3,1,1), 'oc', 'a']
self.argDemos = [['3|4|5@2', 60, (4,1,1), 'rc', 's'],
]
self.priority = 9 # rhythm gets top priority
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
self.currentPulse = None # init value, used in getCurrentRhythm
self.length = abs(int(round(self.args[1])))
self.z = list(range(0, self.length))
try:
self.sieveObj = sieve.Sieve(self.args[0], self.z)
except AttributeError:
raise error.ParameterObjectSyntaxError("incorrect sieve syntax.")
try:
self.pulseObj = rhythm.Pulse(self.args[2])
except error.PulseSyntaxError:
raise error.ParameterObjectSyntaxError("incorrect sieve syntax.")
self.pulseObj.setSus(.94) # no sustain
self.pulseOn = self.pulseObj.copy()
self.pulseOn.setAcc(1) # force on
self.pulseOff = self.pulseObj.copy()
self.pulseOff.setAcc(0) # force off
# gets a list if numbers, like 0,3,4,6,9,10
# interpret as equal dur time points
# get format based on ariticulation
self.articulation = self._articulationParser(self.args[4])
if self.articulation == 'sustain': fmt = 'wid'
elif self.articulation == 'attack': fmt = 'bin'
self.sieveObj.segFmtSet(fmt)
self.sieveSeg = self.sieveObj(0, self.z)
# set z as list from which selector draws
self.control = self._selectorParser(self.args[3]) # raises exception
self.selector = basePmtr.Selector(self.sieveSeg, self.control)
def _refresh(self, count, t, refDict):
"""refresh values stored in the col attribute; this is done during a run
and is not the same as a reset"""
count = int(round(count))
if count == 0 and self.valueBuffer != []:
return # do nothing if filled, continue to use values
elif count == 0 and self.valueBuffer == []:
count = self.FAILLIMIT # force some values to be added
else: pass # keep count as is
self.valueBuffer = [] # clear list
# get total event count values when refreshing
for t in range(self.eventCountTotal, self.eventCountTotal + count):
valTriple = self.srcObj(t, refDict)
valObj = self.srcObj.currentPulse
self.valueBuffer.append((valTriple, valObj))
self.selector = basePmtr.Selector(self.valueBuffer, self.control)
self.eventCount = 0
def __call__(self, valArray, tArray, refDictArray):
# vale and time should always be the same length
assert (len(valArray) == len(tArray)
and len(tArray) == len(refDictArray))
# process each value
self.currentValue = []
# normalize all values and add to selector w/ pre-defiend
normSeries = unit.unitNormRange(valArray)
selector = basePmtr.Selector(normSeries, self.control)
for i in range(len(valArray)):
val = valArray[i] # original value
t = tArray[i]
refDict = refDictArray[i]
# get normalized val from selector, remap b/n min and max
postVal = unit.denorm(selector(), self.minObj(t, refDict),
self.maxObj(t, refDict))
self.currentValue.append(postVal)
# return list of values
return self.currentValue
class IterateRhythmWindow(basePmtr.RhythmParameter):
# this follows closel
def __init__(self, args, refDict):
basePmtr.RhythmParameter.__init__(self, args, refDict) # call base init
self.type = 'iterateRhythmWindow'
self.doc = lang.docPoIrw
self.argTypes = ['list', 'list', 'str']
self.argNames = ['parameterObjectList: a list of Rhythm Generators',
'parameterObject: generate or skip control Generator',
'selectionString']
self.argDefaults = [(
('l', ((4,3,1),(4,3,1),(4,2,0),(8,1,1),(4,2,1),(4,2,1)),'oc'),
('cs', ('ru', 1.5, 4)),
),
('bg','rc',(-3,6,-1,15)),
'oc']
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
self.valueBuffer = [] # values g selected
from athenaCL.libATH.libPmtr import parameter
self.objArray = []
for argList in self.args[0]:
try:
pmtrObj = parameter.factory(argList, 'rthmPmtrObjs')
except error.ParameterObjectSyntaxError, msg:
raise error.ParameterObjectSyntaxError, 'failed sub-parameter: %s' % msg
self.objArray.append(pmtrObj)
self.countObj = self._loadSub(self.args[1], 'genPmtrObjs')
# check control string
self.control = self._selectorParser(self.args[2])
# create a selector that returns indix values for objArray
self.selector = basePmtr.Selector(range(len(self.objArray)), self.control)
def __init__(self, args, refDict):
basePmtr.RhythmParameter.__init__(self, args, refDict) # call base init
self.type = 'loop'
self.doc = lang.docPoL
self.argTypes = ['list', 'str']
self.argNames = ['pulseList', 'selectionString']
self.argDefaults = [((3,1,1),(3,1,1),(8,1,1),(8,1,1),(8,3,1),(3,2,0)),
'oc']
self.priority = 9 # rhythm gets top priority
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
self.currentPulse = None # init value, used in getCurrentRhythm
try:
self.rObj = rhythm.Rhythm(self.args[0])
except error.PulseSyntaxError:
raise error.ParameterObjectSyntaxError("enter a list of pulse objects.")
for r in range(0, len(self.rObj)):
self.rObj[r].setSus(.94) # set constant sustain, was 98, but still cut
self.control = self._selectorParser(self.args[1]) # raises exception
self.selector = basePmtr.Selector(self.rObj, self.control)
def _scoreMain(self):
"""creates score
note: octave choose for every note
>>> from athenaCL.libATH.libTM import texture
>>> ti = texture.factory('TimeFill')
>>> ti.tmName == 'TimeFill'
True
>>> ti.loadDefault()
>>> ti.score() == True
True
"""
# texture-wide time elements
inst = self.getInst()
# needed for preliminary parameter values
# tStart, tEnd = self.getTimeRange()
# tCurrent = tStart
# get field, octave selection method value
textFieldLevel = self.getTextStatic('lfm', 'level')
textOctaveLevel = self.getTextStatic('lom', 'level')
textPitchSelectorControl = self.getTextStatic('psc', 'selectionString')
textEventCount = self.getTextStatic('tec', 'count')
textEventPartition = self.getTextStatic('lep', 'level')
textDensityPartition = self.getTextStatic('edp', 'level')
if textDensityPartition == 'set': # get a list of values
pLen = self.getPathLen()
eventPerSet = [int(round(textEventCount / pLen))] * pLen
else: # duration fraction
scalars = self.getPathDurationPercent()
eventPerSet = [int(round(x * textEventCount)) for x in scalars]
eventIndex = 0
# create a list of chords from the appropriate pitch mode
for pathPos in self.getPathPos():
chordCurrent = self.getPitchGroup(pathPos)
multisetCurrent = self.getMultiset(pathPos)
# start and end of this set is in real-time, not local to path
# if not by set, boundaries here are always tt of entire texture
if textEventPartition == 'set':
tStartSet, tEndSet = self.clockPoints(
) # value relative to start
else: # its a path based, treat tiem as one set
tStartSet, tEndSet = self.getTimeRange(
) # value relative to path
# create a generator to get pitches from chord as index values
selectorChordPos = basePmtr.Selector(range(len(chordCurrent)),
textPitchSelectorControl)
# real set start is always the formal start time here
tCurrent = copy.deepcopy(tStartSet)
tStartSetReal = copy.deepcopy(tStartSet)
self.stateUpdate(tCurrent, chordCurrent, None, multisetCurrent,
None, None)
if textFieldLevel == 'set':
transCurrent = self.getField(tCurrent) # choose PITCHFIELD
if textOctaveLevel == 'set':
octCurrent = self.getOct(tCurrent) # choose OCTAVE
# get event count from list of eventPerSet list by pathPos
for i in range(eventPerSet[pathPos]): # pitch in chord
eventIndex = eventIndex + 1 # cumulative count
# even when rounded, dont exceed maximum; last set may have less
if eventIndex > textEventCount: break
# tCurrent here is assumed as start of set initiall, although
# this is not exactly correct
tUnit = unit.limit(
self.getTextDynamic('fillGenerator', tCurrent))
tCurrent = unit.denorm(tUnit, tStartSet, tEndSet)
# choose pc from chord
ps = chordCurrent[selectorChordPos()] # get position w/n chord
self.stateUpdate(tCurrent, chordCurrent, ps, multisetCurrent,
None, None)
if textFieldLevel == 'event':
transCurrent = self.getField(tCurrent) # choose PITCHFIELD
if textOctaveLevel == 'event':
octCurrent = self.getOct(tCurrent) # choose OCTAVE
psReal = pitchTools.psToTempered(ps, octCurrent,
self.temperamentObj,
transCurrent)
self.stateUpdate(tCurrent, chordCurrent, ps, multisetCurrent,
None, psReal)
bpm, pulse, dur, sus, acc = self.getRhythm(tCurrent)
if acc == 0 and not self.silenceMode: # this is a rest
tCurrent = tCurrent + dur
continue
amp = self.getAmp(tCurrent) * acc # choose amp, pan
pan = self.getPan(tCurrent)
auxiliary = self.getAux(
tCurrent) # chooose AUX, pack into list
eventDict = self.makeEvent(tCurrent, bpm, pulse, dur, sus, acc,
amp, psReal, pan, auxiliary)
self.storeEvent(eventDict)
# tCurrent = tCurrent + dur # move clocks forward by dur unit
self.clockForward() # advances path positon
return 1
def _scoreMain(self):
"""creates score
note: octave choose for every note
>>> from athenaCL.libATH.libTM import texture
>>> ti = texture.factory('HarmonicShuffle')
>>> ti.tmName == 'HarmonicShuffle'
True
>>> ti.loadDefault()
>>> ti.score() == True
True
"""
# texture-wide time elements
inst = self.getInst()
# needed for preliminary parameter values
tStart, tEnd = self.getTimeRange()
tCurrent = tStart
# get static texture values
textMultisetSelectorControl = self.getTextStatic('msc', 'selectionString')
textPitchSelectorControl = self.getTextStatic('psc', 'selectionString')
textMaxTimeOffset = self.getTextStatic('mto', 'time')
textFieldLevel = self.getTextStatic('lfp', 'level')
textOctaveLevel = self.getTextStatic('lop', 'level')
pLen = self.getPathLen()
selectorMultisetPos = basePmtr.Selector(range(pLen),
textMultisetSelectorControl)
# random generator for creating offset in vetical attacks
# same technique used in LiteralVertical, DroneArticulate
self.gaussPmtrObj = parameter.factory(('randomGauss', .5, .1, -1, 1))
while tCurrent < tEnd:
pathPos = selectorMultisetPos() # select path position
chordCurrent = self.getPitchGroup(pathPos)
multisetCurrent = self.getMultiset(pathPos)
# get number of simultaneities from this multiset
# count is probabilistic, absolute value; cannot be zero
multisetCount = abs(drawer.floatToInt(
self.getTextDynamic('countPerMultiset', tCurrent), 'weight'))
# make zero == 1; alternatively, make zero a skib and continue
if multisetCount == 0: multisetCount = 1
if textFieldLevel == 'set':
transCurrent = self.getField(tCurrent) # choose PITCHFIELD
if textOctaveLevel == 'set':
octCurrent = self.getOct(tCurrent) # choose OCTAVE
# number of times a simultaneity is drawn
for k in range(multisetCount):
if tCurrent > tEnd: break
# create a selector to get pitches from chord as index values
# only need to create one for each chord
selectorChordPos = basePmtr.Selector(range(len(chordCurrent)),
textPitchSelectorControl)
# determine how many pitches in this simultaneity
# abs value, rounded to nearest integer
simultaneityCount = abs(drawer.floatToInt(
self.getTextDynamic('countPerSimultaneity', tCurrent), 'weight'))
# if zero set to max chord size
if simultaneityCount == 0:
simultaneityCount = len(chordCurrent)
elif simultaneityCount > len(chordCurrent):
simultaneityCount = len(chordCurrent)
self.stateUpdate(tCurrent, chordCurrent, None,
multisetCurrent, None, None)
if textFieldLevel == 'event':
transCurrent = self.getField(tCurrent) # choose PITCHFIELD
if textOctaveLevel == 'event':
octCurrent = self.getOct(tCurrent) # choose OCTAVE
# rhythm, amp, pan, aux: all chosen once per simultaneity
bpm, pulse, dur, sus, acc = self.getRhythm(tCurrent)
if acc == 0 and not self.silenceMode: # this is a rest
tCurrent = tCurrent + dur
continue
amp = self.getAmp(tCurrent) * acc # choose amp, pan
pan = self.getPan(tCurrent)
tThisChord = copy.deepcopy(tCurrent)
# get each pitch in the simultaneity
for i in range(simultaneityCount): # pitch in chord
ps = chordCurrent[selectorChordPos()] # get position w/n chord
self.stateUpdate(tCurrent, chordCurrent, ps,
multisetCurrent, None, None)
if textFieldLevel == 'voice':
transCurrent = self.getField(tCurrent) # choose PITCHFIELD
if textOctaveLevel == 'voice':
octCurrent = self.getOct(tCurrent) # choose OCTAVE
psReal = pitchTools.psToTempered(ps, octCurrent,
self.temperamentObj, transCurrent)
self.stateUpdate(tCurrent, chordCurrent, ps,
multisetCurrent, None, psReal)
# aux values are drawn here once per voice;
# this is common to TMs: DroneArticulate, DroneSustain
auxiliary = self.getAux(tCurrent) # chooose AUX, pack into list
# offset value is between -textMaxOffset, 0, and +textMaxOffset
offset = self.gaussPmtrObj(0.0) * textMaxTimeOffset
tCurrent = tCurrent + offset
if tCurrent < 0: # cant start before 0
tCurrent = tThisChord # reset
eventDict = self.makeEvent(tCurrent, bpm, pulse, dur, sus,
acc, amp, psReal, pan, auxiliary)
self.storeEvent(eventDict)
# restore time to tCurrent before processing offset again
tCurrent = tThisChord
# move clocks forward by dur unit
tCurrent = tCurrent + dur
return 1
def _scoreMain(self):
"""creates score
note: octave choose for every note
>>> from athenaCL.libATH.libTM import texture
>>> ti = texture.factory('TimeSegment')
>>> ti.tmName == 'TimeSegment'
True
>>> ti.loadDefault()
>>> ti.score() == True
True
"""
# texture-wide time elements
inst = self.getInst()
# needed for preliminary parameter values
# tStart, tEnd = self.getTimeRange()
# tCurrent = tStart
# get field, octave selection method value
textPitchSelectorControl = self.getTextStatic('psc', 'selectionString')
textFieldLevel = self.getTextStatic('lfm', 'level')
textOctaveLevel = self.getTextStatic('lom', 'level')
# this is level tt event count numbers are applied (not count itself)
textLevelEventCount = self.getTextStatic('lec', 'level')
textTotalSegmentCount = self.getTextStatic('tsc', 'count')
segmentManifest = [] # store [count, segWeight, start, end]
# process segments first, determine events per segemtn
tSeg = 0
if textLevelEventCount == 'segment': # event count per segement
for q in range(textTotalSegmentCount):
eventCount = self.getTextDynamic('eventCountGenerator', tSeg)
segmentManifest.append([int(round(eventCount))
]) # store as list
tSeg = tSeg + 1
elif textLevelEventCount == 'count': # event count is total
# get one value and divide
eventCount = self.getTextDynamic('eventCountGenerator', tSeg)
segEventCount = int(round((eventCount / textTotalSegmentCount)))
if segEventCount <= 0: segEventCount = 1 # force minimum per seg
for q in range(textTotalSegmentCount):
segmentManifest.append([segEventCount]) # store as list
#print _MOD, 'levelEventCount', textLevelEventCount
#print _MOD, 'textTotalSegmentCount', textTotalSegmentCount
#print _MOD, 'segmentManifest', segmentManifest
# get total duration
tStart, tEnd = self.getTimeRange()
tDurSpan = tEnd - tStart # not final dur, but time start span
# get segment proportions
tSeg = 0 # segment count as event step size
segmentWidth = [] # store widths before getting scaled size
for q in range(textTotalSegmentCount):
# what if segment widht is zero?
val = self.getTextDynamic('segmentWidthGenerator', tSeg)
if val <= 0: pass # continue or warn?
segmentWidth.append(val)
tSeg = tSeg + 1
# transfrom segment width into a collection of boundaries
#print _MOD, 'segmentWidth', segmentWidth
segmentBounds = unit.unitBoundaryProportion(segmentWidth)
for q in range(textTotalSegmentCount):
s, m, e = segmentBounds[q]
segmentManifest[q].append(s * tDurSpan)
segmentManifest[q].append(e * tDurSpan)
#print _MOD, 'segmentWidth', segmentManifest
# get texture start time as init time
tCurrent = tStart # defined abovie
# if field/oct vals are taken once per set, pre calculate and store
# in a list; access from this list with pathPos index
fieldValBuf = []
if textFieldLevel == 'set':
for q in range(self.getPathLen()):
s, e = self.clockPoints(q) # use path df start time
fieldValBuf.append(self.getField(s))
octValBuf = []
if textOctaveLevel == 'set':
for q in range(self.getPathLen()):
s, e = self.clockPoints(q)
octValBuf.append(self.getOct(s))
# iterate through segments in order
for segPos in range(textTotalSegmentCount):
segEventCount = segmentManifest[segPos][
0] # count is first in list
tStartSeg = segmentManifest[segPos][1]
tEndSeg = segmentManifest[segPos][2]
# create events for thsi segment
#print _MOD, 'segPos', segPos
for i in range(segEventCount): #
# get generator value w/n unit interval
tUnit = unit.limit(
self.getTextDynamic('fillGenerator', tCurrent))
tCurrent = unit.denorm(tUnit, tStartSeg, tEndSeg)
pathPos = self.clockFindPos(
tCurrent) # get pos for current time
if pathPos == None:
raise ValueError, 'tCurrent out of all time ranges'
#print _MOD, 'pp, tc', pathPos, tCurrent
#print _MOD, 'tss, tes', tStartSeg, tEndSeg
# need to determin path position based on time point of event
chordCurrent = self.getPitchGroup(pathPos)
multisetCurrent = self.getMultiset(pathPos)
# create a generator to get pitches from chord as index values
selectorChordPos = basePmtr.Selector(
range(0, len(chordCurrent)), textPitchSelectorControl)
# choose pc from chord
ps = chordCurrent[selectorChordPos()] # get position w/n chord
# a if the division of path dfs is w/n a single segment
# either side of the path may occur more than once.
# perhaps pre calculate and store in a list?
if textFieldLevel == 'event': # every event
transCurrent = self.getField(tCurrent) # choose PITCHFIELD
elif textFieldLevel == 'set':
transCurrent = fieldValBuf[pathPos] # choose PITCHFIELD
if textOctaveLevel == 'event':
octCurrent = self.getOct(tCurrent) # choose OCTAVE
elif textOctaveLevel == 'set':
octCurrent = octValBuf[pathPos] # choose OCTAVE
#print _MOD, 'pathPos, oct, t', pathPos, octCurrent, tCurrent
psReal = pitchTools.psToTempered(ps, octCurrent,
self.temperamentObj,
transCurrent)
self.stateUpdate(tCurrent, chordCurrent, ps, multisetCurrent,
None, psReal)
bpm, pulse, dur, sus, acc = self.getRhythm(tCurrent)
if acc == 0 and not self.silenceMode: # this is a rest
tCurrent = tCurrent + dur
continue
amp = self.getAmp(tCurrent) * acc # choose amp, pan
pan = self.getPan(tCurrent)
auxiliary = self.getAux(
tCurrent) # chooose AUX, pack into list
eventDict = self.makeEvent(tCurrent, bpm, pulse, dur, sus, acc,
amp, psReal, pan, auxiliary)
self.storeEvent(eventDict)
# tCurrent = tCurrent + dur # move clocks forward by dur unit
# self.clockForward() # advances path positon
return 1
def _scoreMain(self):
"""creates score
>>> from athenaCL.libATH.libTM import texture
>>> ti = texture.factory('InterpolateFill')
>>> ti.tmName == 'InterpolateFill'
True
>>> ti.loadDefault()
>>> ti.score() == True
True
"""
# texture-wide time elements
inst = self.getInst()
tStart, tEnd = self.getTimeRange()
tCurrent = tStart
# get field, octave selection method value
textFieldLevel = self.getTextStatic('lfm', 'level')
textOctaveLevel = self.getTextStatic('lom', 'level')
textPitchSelectorControl = self.getTextStatic('psc', 'selectionString')
textEventCount = self.getTextStatic('tec', 'count')
textEventPartition = self.getTextStatic('lep', 'level')
textDensityPartition = self.getTextStatic('edp', 'level')
textInterpolationMethodControl = self.getTextStatic('imc', 'method')
textLevelFrameDuration = self.getTextStatic('lfd', 'level')
textParameterInterpolationControl = self.getTextStatic('pic', 'onOff')
textSnapSustainTime = self.getTextStatic('sst', 'onOff')
# cannot snap event time in this context
#textSnapEventTime = self.getTextStatic('set', 'onOff')
if textDensityPartition == 'set': # get a list of values
pLen = self.getPathLen()
eventPerSet = [int(round(textEventCount / pLen))] * pLen
else: # duration fraction
scalars = self.getPathDurationPercent()
eventPerSet = [int(round(x * textEventCount)) for x in scalars]
eventIndex = 0
# a list of frame data: tStart, dur, eventFlag, interpMethod,interpExponet
tFrameArray = []
# create a list of chords from the appropriate pitch mode
for pathPos in self.getPathPos():
chordCurrent = self.getPitchGroup(pathPos)
multisetCurrent = self.getMultiset(pathPos)
# start and end of this set is in real-time, not local to path
# if not by set, boundaries here are always tt of entire texture
if textEventPartition == 'set':
tStartSet, tEndSet = self.clockPoints(
) # value relative to start
else: # its a path based, treat tiem as one set
tStartSet, tEndSet = self.getTimeRange(
) # value relative to start
# create a generator to get pitches from chord as index values
selectorChordPos = basePmtr.Selector(
list(range(len(chordCurrent))), textPitchSelectorControl)
# real set start is always the formal start time here
tCurrent = copy.deepcopy(tStartSet)
tStartSetReal = copy.deepcopy(tStartSet)
self.stateUpdate(tCurrent, chordCurrent, None, multisetCurrent,
None, None)
if textFieldLevel == 'set':
transCurrent = self.getField(tCurrent) # choose PITCHFIELD
if textOctaveLevel == 'set':
octCurrent = self.getOct(tCurrent) # choose OCTAVE
# get event count from list of eventPerSet list by pathPos
for i in range(eventPerSet[pathPos]): # pitch in chord
eventIndex = eventIndex + 1 # cumulative count
# even when rounded, dont exceed maximum; last set may have less
if eventIndex > textEventCount: break
# tCurrent here is assumed as start of set initiall, although
# this is not exactly correct
tUnit = unit.limit(
self.getTextDynamic('fillGenerator', tCurrent))
tCurrent = unit.denorm(tUnit, tStartSet, tEndSet)
# choose pc from chord
ps = chordCurrent[selectorChordPos()] # get position w/n chord
self.stateUpdate(tCurrent, chordCurrent, ps, multisetCurrent,
None, None)
if textFieldLevel == 'event':
transCurrent = self.getField(tCurrent) # choose PITCHFIELD
if textOctaveLevel == 'event':
octCurrent = self.getOct(tCurrent) # choose OCTAVE
psReal = pitchTools.psToTempered(ps, octCurrent,
self.temperamentObj,
transCurrent)
self.stateUpdate(tCurrent, chordCurrent, ps, multisetCurrent,
None, psReal)
bpm, pulse, dur, sus, acc = self.getRhythm(tCurrent)
# silence mode has to be ignored
amp = self.getAmp(tCurrent) * acc # choose amp, pan
pan = self.getPan(tCurrent)
auxiliary = self.getAux(
tCurrent) # chooose AUX, pack into list
eventDict = self.makeEvent(tCurrent, bpm, pulse, dur, sus, acc,
amp, psReal, pan, auxiliary)
self.storeEvent(eventDict)
# tCurrent = tCurrent + dur # move clocks forward by dur unit
# always store event time in array, w/ interp type and exponent
tFrameArray.append(
(tCurrent, dur, 1, textInterpolationMethodControl,
self.getTextDynamic('exponent', tCurrent)))
# tFrame = copy.deepcopy(tCurrent)
self.clockForward() # advances path positon
# sort frames and events; should both be the same size and in order
self.esObj.sort()
tFrameArray.sort()
# sort stored events
# process frame start times
# store first event, as well as interp exponet if needed
# tFrame is set to tCurrent
tFrameArrayPost = []
for i in range(len(tFrameArray) - 1): # dont do last event
eventDict = self.esObj[i]
tCurrent = eventDict['time']
tFrame = copy.deepcopy(tCurrent)
# get relative duration to next event
durRel = self.esObj[i + 1]['time'] - eventDict['time']
# transfer old tFrame to new
tFrameArrayPost.append(tFrameArray[i])
if textLevelFrameDuration == 'event': # one frame dur / event
frameDur = self.getTextDynamic('frameDuration', tCurrent)
if frameDur < durRel:
# can eval in loop b/c frameDur is constant
while (tFrame + frameDur) < (tCurrent + durRel):
tFrame = tFrame + frameDur
tFrameArrayPost.append((tFrame, frameDur, 0))
# frame updates / frame
elif textLevelFrameDuration == 'frame':
while 1:
# must calc frameDur to see if it is over e next event
frameDur = self.getTextDynamic('frameDuration', tFrame)
if (tFrame + frameDur) > (tCurrent + durRel):
break # cannot fit another frame w/o passing next event
tFrame = tFrame + frameDur
tFrameArrayPost.append((tFrame, frameDur, 0))
# cannot snap event time here; woudl require repositioning
# next event
# restore the last tFrame to the new tFrame
tFrameArrayPost.append(tFrameArray[-1])
# configure which parameters, in EventSequence object, are interpolated
if textParameterInterpolationControl == 'on':
active = ['time', 'acc', 'bpm', 'amp', 'ps', 'pan', 'aux'] #
elif textParameterInterpolationControl == 'off':
active = ['time', 'bpm']
# interpolate events
self.interpolate(tFrameArrayPost, textSnapSustainTime, active)
return 1
def _scoreMain(self):
"""creates score
>>> from athenaCL.libATH.libTM import texture
>>> ti = texture.factory('InterpolateLine')
>>> ti.tmName == 'InterpolateLine'
True
>>> ti.loadDefault()
>>> ti.score() == True
True
"""
# texture-wide time elements
inst = self.getInst()
tStart, tEnd = self.getTimeRange()
tCurrent = tStart
# get field, octave selection method value
textFieldLevel = self.getTextStatic('lfm', 'level')
textOctaveLevel = self.getTextStatic('lom', 'level')
textPitchSelectorControl = self.getTextStatic('psc', 'selectionString')
textInterpolationMethodControl = self.getTextStatic('imc', 'method')
textLevelFrameDuration = self.getTextStatic('lfd', 'level')
textParameterInterpolationControl = self.getTextStatic('pic', 'onOff')
textSnapSustainTime = self.getTextStatic('sst', 'onOff')
textSnapEventTime = self.getTextStatic('set', 'onOff')
# a list of frame data: tStart, dur, eventFlag, interpMethod,interpExponet
tFrameArray = []
# create a list of chords from the appropriate pitch mode
for pathPos in self.getPathPos():
chordCurrent = self.getPitchGroup(pathPos)
multisetCurrent = self.getMultiset(pathPos)
tStartSet, tEndSet = self.clockPoints()
selectorChordPos = basePmtr.Selector(range(len(chordCurrent)),
textPitchSelectorControl)
tStartSetReal = copy.deepcopy(tCurrent)
self.stateUpdate(tCurrent, chordCurrent, None, multisetCurrent,
None, None)
if textFieldLevel == 'set':
transCurrent = self.getField(tCurrent) # choose PITCHFIELD
if textOctaveLevel == 'set':
octCurrent = self.getOct(tCurrent) # choose OCTAVE
while 1: # pitch in chord
if tCurrent >= tEndSet: break
# choose pc from chord
ps = chordCurrent[selectorChordPos()] # get position w/n chord
self.stateUpdate(tCurrent, chordCurrent, ps, multisetCurrent,
None, None)
if textFieldLevel == 'event':
transCurrent = self.getField(tCurrent) # choose PITCHFIELD
if textOctaveLevel == 'event':
octCurrent = self.getOct(tCurrent) # choose OCTAVE
psReal = pitchTools.psToTempered(ps, octCurrent,
self.temperamentObj,
transCurrent)
self.stateUpdate(tCurrent, chordCurrent, ps, multisetCurrent,
None, psReal)
bpm, pulse, dur, sus, acc = self.getRhythm(tCurrent)
# silence mode has to be ignored
amp = self.getAmp(tCurrent) * acc # choose amp, pan
pan = self.getPan(tCurrent)
auxiliary = self.getAux(
tCurrent) # chooose AUX, pack into list
eventDict = self.makeEvent(tCurrent, bpm, pulse, dur, sus, acc,
amp, psReal, pan, auxiliary)
# need to store events in order to do proper post-event processing
self.storeEvent(eventDict)
# always store event time in array, w/ interp type and exponent
tFrameArray.append(
(tCurrent, dur, 1, textInterpolationMethodControl,
self.getTextDynamic('exponent', tCurrent)))
tFrame = copy.deepcopy(tCurrent)
# check if this is the last event of entire texture
# if so, do not calculate frames
if tCurrent + dur > tEnd:
tCurrent = tCurrent + dur
break
# process frame start times
# store first event, as well as interp exponet if needed
# tFrame is set to tCurrent
else:
if textLevelFrameDuration == 'event': # one frame dur / event
frameDur = self.getTextDynamic('frameDuration',
tCurrent)
if frameDur < dur:
# can eval in loop b/c frameDur is constant
while (tFrame + frameDur) < (tCurrent + dur):
tFrame = tFrame + frameDur
tFrameArray.append((tFrame, frameDur, 0))
# frame updates / frame
elif textLevelFrameDuration == 'frame':
while 1:
# must calc frameDur to see if it is over e next event
frameDur = self.getTextDynamic(
'frameDuration', tFrame)
if (tFrame + frameDur) > (tCurrent + dur):
break # cannot fit another frame w/o passing next event
tFrame = tFrame + frameDur
tFrameArray.append((tFrame, frameDur, 0))
# update current time after fram processing
if textSnapEventTime == 'on':
# always use existing frame dur for both event and frame proc
# add to last set frame time
tCurrent = tFrame + frameDur
else:
tCurrent = tCurrent + dur
# advances path positon
self.clockForward()
# configure which parameters, in EventSequence object, are interpolated
if textParameterInterpolationControl == 'on':
active = ['time', 'acc', 'bpm', 'amp', 'ps', 'pan', 'aux'] #
elif textParameterInterpolationControl == 'off':
active = ['time', 'bpm']
# interpolate events
self.interpolate(tFrameArray, textSnapSustainTime, active)
return 1
def _scoreMain(self):
"""creates score
>>> from athenaCL.libATH.libTM import texture
>>> ti = texture.factory('lg')
>>> ti.tmName == 'LineGroove'
True
>>> ti.loadDefault()
>>> ti.score() == True
True
"""
# texture-wide time elements
inst = self.getInst()
tStart, tEnd = self.getTimeRange()
tCurrent = tStart
#texture-wide (self.textQ amd)options
#used for optional parallel voices
textParallelVoiceList = self.getTextStatic('pml', 'transpositionList')
textParallelDelayTime = self.getTextStatic('pml', 'timeDelay')
# get field, octave selection method value
textFieldLevel = self.getTextStatic('lfm', 'level')
textOctaveLevel = self.getTextStatic('lom', 'level')
textPitchSelectorControl = self.getTextStatic('psc', 'selectionString')
# create a list of chords from the appropriate pitch mode
for pathPos in self.getPathPos():
chordCurrent = self.getPitchGroup(pathPos)
multisetCurrent = self.getMultiset(pathPos)
tStartSet, tEndSet = self.clockPoints()
selectorChordPos = basePmtr.Selector(list(range(len(chordCurrent))),
textPitchSelectorControl)
tStartSetReal = copy.deepcopy(tCurrent)
self.stateUpdate(tCurrent, chordCurrent, None,
multisetCurrent, None, None)
if textFieldLevel == 'set':
transCurrent = self.getField(tCurrent) # choose PITCHFIELD
if textOctaveLevel == 'set':
octCurrent = self.getOct(tCurrent) # choose OCTAVE
while 1: # pitch in chord
if tCurrent >= tEndSet: break
# choose pc from chord
ps = chordCurrent[selectorChordPos()] # get position w/n chord
self.stateUpdate(tCurrent, chordCurrent, ps,
multisetCurrent, None, None)
if textFieldLevel == 'event':
transCurrent = self.getField(tCurrent) # choose PITCHFIELD
if textOctaveLevel == 'event':
octCurrent = self.getOct(tCurrent) # choose OCTAVE
psReal = pitchTools.psToTempered(ps, octCurrent,
self.temperamentObj, transCurrent)
self.stateUpdate(tCurrent, chordCurrent, ps,
multisetCurrent, None, psReal)
bpm, pulse, dur, sus, acc = self.getRhythm(tCurrent)
if acc == 0 and not self.silenceMode: # this is a rest
tCurrent = tCurrent + dur
continue
amp = self.getAmp(tCurrent) * acc # choose amp, pan
pan = self.getPan(tCurrent)
auxiliary = self.getAux(tCurrent) # chooose AUX, pack into list
eventDict = self.makeEvent(tCurrent, bpm, pulse, dur, sus, acc,
amp, psReal, pan, auxiliary)
self.storeEvent(eventDict)
# Parallel transposition
offset = 0
for parallelVoice in textParallelVoiceList:
#offset to avoid amp problems, correct error w/ offset
tCurrent = tCurrent + textParallelDelayTime
offset = offset + textParallelDelayTime
psText = pitchTools.psTransposer(psReal, parallelVoice)
eventDict = self.makeEvent(tCurrent, bpm, pulse, dur, sus,
acc, amp, psText, pan, auxiliary)
self.storeEvent(eventDict)
# move clocks forward by dur unit
tCurrent = (tCurrent + dur) - offset
self.clockForward() # advances path positon
return 1
def _scoreMain(self):
"""creates score
>>> from athenaCL.libATH.libTM import texture
>>> ti = texture.factory('LineCluster')
>>> ti.tmName == 'LineCluster'
True
>>> ti.loadDefault()
>>> ti.score() == True
True
"""
# texture-wide PATH/PITCH elements
# texture-wide time elements
inst = self.getInst()
tStart, tEnd = self.getTimeRange()
tCurrent = tStart
# texture-wide TEXTURE (self.textQ amd)options
#used for optional parallel voices
textParallelVoiceList = self.getTextStatic('pml', 'transpositionList')
textParallelDelayTime = self.getTextStatic('pml', 'timeDelay')
# get field, octave selection method value
textFieldLevel = self.getTextStatic('lfp', 'level')
textOctaveLevel = self.getTextStatic('lop', 'level')
textPitchSelectorControl = self.getTextStatic('psc', 'selectionString')
#textNonRedundantSwitch = self.getTextStatic('nrs', 'onOff')
# create a list of chords from the appropriate pitch mode
for pathPos in self.getPathPos():
chordCurrent = self.getPitchGroup(pathPos)
multisetCurrent = self.getMultiset(pathPos)
tStartSet, tEndSet = self.clockPoints()
# if textNonRedundantSwitch == 'on': selectorControl = 'randomPermutate'
# else: selectorControl = 'randomChoice'
selectorChordPos = basePmtr.Selector(
list(range(len(chordCurrent))), textPitchSelectorControl)
tStartSetReal = copy.deepcopy(tCurrent)
self.stateUpdate(tCurrent, chordCurrent, None, multisetCurrent,
None, None)
if textFieldLevel == 'set':
transCurrent = self.getField(tCurrent) # choose PITCHFIELD
if textOctaveLevel == 'set':
octCurrent = self.getOct(tCurrent) # choose OCTAVE
while 1: # PITCH in CHORD
if tCurrent >= tEndSet: break
bpm, pulse, dur, sus, acc = self.getRhythm(
tCurrent) # choose RHYTHM
if acc == 0 and not self.silenceMode: # this is a rest
tCurrent = tCurrent + dur
continue
# this ps should be used as ROOT;
# this is _not_ implemented yet, however
# choose PC from CHORD
ps = chordCurrent[selectorChordPos()]
self.stateUpdate(tCurrent, chordCurrent, ps, multisetCurrent,
None, None)
if textFieldLevel == 'event':
transCurrent = self.getField(tCurrent) # choose PITCHFIELD
if textOctaveLevel == 'event':
octCurrent = self.getOct(tCurrent) # choose OCTAVE
#subprocess psChord is a list of PCH's needed to make chord,
psChord = []
for pitchSpace in chordCurrent:
if textFieldLevel == 'voice':
transCurrent = self.getField(
tCurrent) # choose PITCHFIELD
if textOctaveLevel == 'voice':
octCurrent = self.getOct(tCurrent) # choose OCTAVE
psReal = pitchTools.psToTempered(pitchSpace, octCurrent,
self.temperamentObj,
transCurrent)
psChord.append(psReal)
# amp and pan done for each chord, not voice
amp = self.getAmp(tCurrent) * acc
pan = self.getPan(tCurrent)
#do this for each PCH in psChord, already transposed
for psReal in psChord:
self.stateUpdate(tCurrent, chordCurrent, pitchSpace,
multisetCurrent, None, psReal)
# choose aux for each voice
auxiliary = self.getAux(tCurrent)
eventDict = self.makeEvent(tCurrent, bpm, pulse, dur, sus,
acc, amp, psReal, pan,
auxiliary)
self.storeEvent(eventDict)
# parellel transposition
offset = 0
for parallelVoice in textParallelVoiceList:
#offset to avoid amp problems, correct error w/ offset
tCurrent = tCurrent + textParallelDelayTime
offset = offset + textParallelDelayTime
psText = pitchTools.psTransposer(psReal, parallelVoice)
eventDict = self.makeEvent(tCurrent, bpm, pulse, dur,
sus, acc, amp, psText, pan,
auxiliary)
self.storeEvent(eventDict)
#----------------------------
# move clocks forward by dur unit
tCurrent = (tCurrent + dur) - offset
self.clockForward() # advances path positon
# return value to check for errors
return 1
