コード例 #1
0
ファイル: envelope.py プロジェクト: tjingboem/athenaCL
def durToAdsr(tStart,
              propAbsSwitch,
              dur,
              attack,
              decay,
              sustain,
              release,
              susScalar,
              min=0,
              max=1):
    """create an adsr envelope
    sustain scalar is a value, w/n the unit interval, of the difference between
    min and max

    >>> durToAdsr(0, 'absolute', 10, 2, 1, 2, 2, .5)
    [[0, 0.0], [2, 1.0], [3, 0.5], [5, 0.5], [7, 0.0], [9.999..., 0.0]]

    """
    # will automatically sort min, max
    peak = unit.denorm(1, min, max)
    nadir = unit.denorm(0, min, max)
    susLevel = (peak - nadir) * unit.limit(susScalar)

    if propAbsSwitch not in ['absolute', 'proportional']:
        raise error.ParameterObjectSyntaxError('incorrect switch')

    if propAbsSwitch == 'absolute':
        timeUnitDenorm = [attack, decay, sustain, release]
        if sum(timeUnitDenorm) > dur:  # force proportional
            propAbsSwitch = 'proportional'

    if propAbsSwitch == 'proportional':
        timeUnit = unit.unitNormProportion([attack, decay, sustain, release])
        timeUnitDenorm = [x * dur for x in timeUnit]

    tEnd = tStart + dur
    t = tStart

    envelope = []
    envelope.append([t, nadir])

    t = t + _stepFilter(timeUnitDenorm[0])  # attack
    envelope.append([t, peak])

    t = t + _stepFilter(timeUnitDenorm[1])  # decay
    envelope.append([t, susLevel])

    t = t + _stepFilter(timeUnitDenorm[2])  # sustain
    envelope.append([t, susLevel])

    if propAbsSwitch == 'proportional':
        t = tEnd - OFFSET  # always measure to end
        envelope.append([t, nadir])
    else:  # absolute
        t = t + _stepFilter(timeUnitDenorm[3])  # sustain
        envelope.append([t, nadir])
        t = tEnd - OFFSET  # always measure to end
        envelope.append([t, nadir])

    return envelope
コード例 #2
0
ファイル: envelope.py プロジェクト: tjingboem/athenaCL
def durToTrapezoid(tStart,
                   propAbsSwitch,
                   dur,
                   rampUp,
                   widthMax,
                   rampDown,
                   widthMin,
                   min=0,
                   max=1):
    """assume dir of peal is widthOn
    will automatically convert to proportion if abs sum extends past dur
    this is an trapezoid with only one ramp; may not have complete duration time; always leads on

    >>> durToTrapezoid(0, 'absolute', 10, 3, 3, 3, .5)
    [[0, 0.0], [3, 1.0], [6, 1.0], [9, 0.0], [9.999..., 0.0]]
    """

    # will automatically sort min, max
    peak = unit.denorm(1, min, max)
    nadir = unit.denorm(0, min, max)

    if propAbsSwitch not in ['absolute', 'proportional']:
        raise error.ParameterObjectSyntaxError('incorrect switch')

    if propAbsSwitch == 'absolute':
        timeUnitDenorm = [rampUp, widthMax, rampDown, widthMin]
        if sum(timeUnitDenorm) > dur:  # force proportional
            propAbsSwitch = 'proportional'

    if propAbsSwitch == 'proportional':
        timeUnit = unit.unitNormProportion(
            [rampUp, widthMax, rampDown, widthMin])
        timeUnitDenorm = [x * dur for x in timeUnit]

    tEnd = tStart + dur
    t = tStart

    envelope = []
    envelope.append([t, nadir])

    t = t + _stepFilter(timeUnitDenorm[0])  # ramp
    envelope.append([t, peak])

    t = t + _stepFilter(timeUnitDenorm[1])  # width
    envelope.append([t, peak])

    t = t + _stepFilter(timeUnitDenorm[2])  # ramp
    envelope.append([t, nadir])

    t = tEnd - OFFSET  # always measure to end
    envelope.append([t, nadir])

    return envelope
コード例 #3
0
ファイル: envelope.py プロジェクト: ericahub/athenacl
def durToAdsr(tStart, propAbsSwitch, dur, attack, decay, 
                         sustain, release, susScalar, min=0, max=1):
    """create an adsr envelope
    sustain scalar is a value, w/n the unit interval, of the difference between
    min and max

    >>> durToAdsr(0, 'absolute', 10, 2, 1, 2, 2, .5)
    [[0, 0.0], [2, 1.0], [3, 0.5], [5, 0.5], [7, 0.0], [9.999..., 0.0]]

    """
    # will automatically sort min, max
    peak = unit.denorm(1, min, max)
    nadir = unit.denorm(0, min, max)
    susLevel = (peak-nadir) * unit.limit(susScalar)

    if propAbsSwitch not in ['absolute', 'proportional']:
        raise error.ParameterObjectSyntaxError, 'incorrect switch'

    if propAbsSwitch == 'absolute':
        timeUnitDenorm = [attack, decay, sustain, release]
        if sum(timeUnitDenorm) > dur: # force proportional
            propAbsSwitch = 'proportional' 

    if propAbsSwitch == 'proportional':
        timeUnit = unit.unitNormProportion([attack, decay, sustain, release])
        timeUnitDenorm = [x*dur for x in timeUnit]

    tEnd = tStart + dur
    t = tStart 

    envelope = []
    envelope.append([t, nadir])

    t = t + _stepFilter(timeUnitDenorm[0]) # attack
    envelope.append([t, peak])

    t = t + _stepFilter(timeUnitDenorm[1]) # decay
    envelope.append([t, susLevel])

    t = t + _stepFilter(timeUnitDenorm[2]) # sustain
    envelope.append([t, susLevel])

    if propAbsSwitch == 'proportional':
        t = tEnd - OFFSET # always measure to end
        envelope.append([t, nadir])
    else: # absolute
        t = t + _stepFilter(timeUnitDenorm[3]) # sustain
        envelope.append([t, nadir])
        t = tEnd - OFFSET # always measure to end
        envelope.append([t, nadir])


    return envelope
コード例 #4
0
ファイル: envelope.py プロジェクト: tjingboem/athenaCL
def durToUnit(tStart, dur, center, width, min=0, max=1):
    """
    this unit envelope is based on a csound model here
     iAttack     = ((1 - iSusPcent) * iSusCenterPcent) * iDur 
     iRelease    = ((1 - iSusPcent) * (1-iSusCenterPcent)) * iDur 
     kAmp        linen     iAmp, iAttack, iDur, iRelease

    >>> durToUnit(0, 10, .5, .5)
    [[0, 0.0], [2.5, 1.0], [7.5, 1.0], [9.999..., 0.0]]

"""
    # will automatically sort min, max
    peak = unit.denorm(1, min, max)
    nadir = unit.denorm(0, min, max)

    # normalize w/n unit interval
    center = unit.limit(center)
    width = unit.limit(width)

    # must be greater or smaller than 0/1 to avoid double points at same x
    # or, worse, the alst event not being the last
    if center >= 1:
        center = center - OFFSET
    if center <= 0:
        center = center + OFFSET
    if width >= 1:
        width = width - OFFSET
    if width <= 0:
        width = width + OFFSET

    rampUp = ((1 - width) * center) * dur
    rampDown = ((1 - width) * (1 - center)) * dur
    center = width * dur

    timeUnitDenorm = [rampUp, center, rampDown]

    tEnd = tStart + dur
    t = tStart

    envelope = []
    envelope.append([t, nadir])

    t = t + timeUnitDenorm[0]  # ramp
    envelope.append([t, peak])

    t = t + timeUnitDenorm[1]  # width
    envelope.append([t, peak])

    t = tEnd - OFFSET  # always measure to end
    envelope.append([t, nadir])

    return envelope
コード例 #5
0
ファイル: envelope.py プロジェクト: ericahub/athenacl
def durToUnit(tStart, dur, center, width, min=0, max=1):
    """
    this unit envelope is based on a csound model here
     iAttack     = ((1 - iSusPcent) * iSusCenterPcent) * iDur 
     iRelease    = ((1 - iSusPcent) * (1-iSusCenterPcent)) * iDur 
     kAmp        linen     iAmp, iAttack, iDur, iRelease

    >>> durToUnit(0, 10, .5, .5)
    [[0, 0.0], [2.5, 1.0], [7.5, 1.0], [9.999..., 0.0]]

"""
    # will automatically sort min, max
    peak = unit.denorm(1, min, max)
    nadir = unit.denorm(0, min, max)

    # normalize w/n unit interval
    center = unit.limit(center)
    width = unit.limit(width)

    # must be greater or smaller than 0/1 to avoid double points at same x
    # or, worse, the alst event not being the last
    if center >= 1:
        center = center - OFFSET
    if center <= 0:
        center = center + OFFSET
    if width >= 1:
        width = width - OFFSET
    if width <= 0:
        width = width + OFFSET

    rampUp = ((1 - width) * center) * dur
    rampDown = ((1 - width) * (1 - center)) * dur
    center = width * dur

    timeUnitDenorm = [rampUp, center, rampDown]

    tEnd = tStart + dur
    t = tStart 

    envelope = []
    envelope.append([t, nadir])

    t = t + timeUnitDenorm[0] # ramp
    envelope.append([t, peak])

    t = t + timeUnitDenorm[1] # width
    envelope.append([t, peak])

    t = tEnd - OFFSET # always measure to end
    envelope.append([t, nadir])

    return envelope
コード例 #6
0
ファイル: audioTools.py プロジェクト: tjingboem/athenaCL
    def unitSynthesizer(self, xList, method=None):
        """scale values to the bit depth
        pack into a list, convert to string data
        
        assumes that values are normalized b/n 0 and 1

        direct; scales value in range of 0 to 1 between -max and amx
        """
#         for i in range(len(xList)):
#             xList[i] = unit.limit(xList[i])
            
        zList = []
        max = byteToInt(self.bytes)     
        #print _MOD, max
        if method in [None, 'direct']:
            for x in xList:
                valSigned = int(round(unit.denorm(x, -max, max)))
                # add a value for each channel
                for ch in range(self.ch):
                    zList.append(valSigned)
        # thee use zero crossings to effect sig of the wave form
        elif method in ['reflect']:
            sign = 1 # 1 is positive
            for x in xList:         
                val = unit.denorm(x, 0, max)
                if val == 0: # only change sign at zero crossing
                    if sign == 1: sign = -1
                    else: sign = 1
                valSigned = val*sign
                # add a value for each channel
                for ch in range(self.ch):
                    zList.append(valSigned)
        elif method == 'fold':
            sign = 1 # 1 is positive
            for x in xList:         
                val = abs(unit.denorm(x, -max, max)) # abs of full range
                if val == 0: # only change sign at zero crossing
                    if sign == 1: sign = -1
                    else: sign = 1
                valSigned = val*sign
                # add a value for each channel
                for ch in range(self.ch):
                    zList.append(valSigned)

        #print zList
        return array.array("h", zList).tostring()
コード例 #7
0
ファイル: audioTools.py プロジェクト: ericahub/athenacl
    def unitSynthesizer(self, xList, method=None):
        """scale values to the bit depth
        pack into a list, convert to string data
        
        assumes that values are normalized b/n 0 and 1

        direct; scales value in range of 0 to 1 between -max and amx
        """
#         for i in range(len(xList)):
#             xList[i] = unit.limit(xList[i])
            
        zList = []
        max = byteToInt(self.bytes)     
        #print _MOD, max
        if method in [None, 'direct']:
            for x in xList:
                valSigned = int(round(unit.denorm(x, -max, max)))
                # add a value for each channel
                for ch in range(self.ch):
                    zList.append(valSigned)
        # thee use zero crossings to effect sig of the wave form
        elif method in ['reflect']:
            sign = 1 # 1 is positive
            for x in xList:         
                val = unit.denorm(x, 0, max)
                if val == 0: # only change sign at zero crossing
                    if sign == 1: sign = -1
                    else: sign = 1
                valSigned = val*sign
                # add a value for each channel
                for ch in range(self.ch):
                    zList.append(valSigned)
        elif method == 'fold':
            sign = 1 # 1 is positive
            for x in xList:         
                val = abs(unit.denorm(x, -max, max)) # abs of full range
                if val == 0: # only change sign at zero crossing
                    if sign == 1: sign = -1
                    else: sign = 1
                valSigned = val*sign
                # add a value for each channel
                for ch in range(self.ch):
                    zList.append(valSigned)

        #print zList
        return array.array("h", zList).tostring()
コード例 #8
0
ファイル: envelope.py プロジェクト: ericahub/athenacl
def durToTrapezoid(tStart, propAbsSwitch, dur, rampUp, widthMax, rampDown,
                         widthMin, min=0, max=1):
    """assume dir of peal is widthOn
    will automatically convert to proportion if abs sum extends past dur
    this is an trapezoid with only one ramp; may not have complete duration time; always leads on

    >>> durToTrapezoid(0, 'absolute', 10, 3, 3, 3, .5)
    [[0, 0.0], [3, 1.0], [6, 1.0], [9, 0.0], [9.999..., 0.0]]
    """

    # will automatically sort min, max
    peak = unit.denorm(1, min, max)
    nadir = unit.denorm(0, min, max)

    if propAbsSwitch not in ['absolute', 'proportional']:
        raise error.ParameterObjectSyntaxError, 'incorrect switch'

    if propAbsSwitch == 'absolute':
        timeUnitDenorm = [rampUp, widthMax, rampDown, widthMin]
        if sum(timeUnitDenorm) > dur: # force proportional
            propAbsSwitch = 'proportional' 

    if propAbsSwitch == 'proportional':
        timeUnit = unit.unitNormProportion([rampUp, widthMax, rampDown, widthMin])
        timeUnitDenorm = [x*dur for x in timeUnit]

    tEnd = tStart + dur
    t = tStart 

    envelope = []
    envelope.append([t, nadir])

    t = t + _stepFilter(timeUnitDenorm[0]) # ramp
    envelope.append([t, peak])

    t = t + _stepFilter(timeUnitDenorm[1]) # width
    envelope.append([t, peak])

    t = t + _stepFilter(timeUnitDenorm[2]) # ramp
    envelope.append([t, nadir])

    t = tEnd - OFFSET # always measure to end
    envelope.append([t, nadir])

    return envelope
コード例 #9
0
 def _scrubList(self, data, min=None, max=None):
     """for presenting list data
     used to apply scalar to uncalculated values"""
     msg = []
     for element in data:
         if min != None and max != None:
             element = unit.denorm(element, min, max)
         msg.append(typeset.anyDataToStr(element))
     dataStr = ','.join(msg)
     return '(%s)' % dataStr
コード例 #10
0
ファイル: basePmtr.py プロジェクト: ericahub/athenacl
 def _scrubList(self, data, min=None, max=None):
     """for presenting list data
     used to apply scalar to uncalculated values"""
     msg = []
     for element in data:
         if min != None and max != None:
             element = unit.denorm(element, min, max)
         msg.append(typeset.anyDataToStr(element))
     dataStr = ','.join(msg)
     return '(%s)' % dataStr
コード例 #11
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
コード例 #12
0
ファイル: cloneFilter.py プロジェクト: ericahub/athenacl
    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
コード例 #13
0
ファイル: TimeSegment.py プロジェクト: ericahub/athenacl
    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
コード例 #14
0
ファイル: TimeSegment.py プロジェクト: gmkling/athenacl
    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
コード例 #15
0
ファイル: InterpolateFill.py プロジェクト: ericahub/athenacl
    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(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
コード例 #16
0
ファイル: InterpolateFill.py プロジェクト: tjingboem/athenaCL
    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
コード例 #17
0
    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
コード例 #18
0
ファイル: TimeFill.py プロジェクト: ericahub/athenacl
    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