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