def __init__(self, userOptsTargetObject, AnalInterface):
self.filename = userOptsTargetObject.filename
self.filename = util.verifyPath(self.filename,
AnalInterface.searchPaths)
self.filename = os.path.abspath(self.filename)
self.startSec = userOptsTargetObject.start
self.endSec = userOptsTargetObject.end
# check for signal decomposition
self.decompose = userOptsTargetObject.decompose
if self.decompose != {}:
if self.startSec == None: self.startSec = 0
import audioguide.signaldecompose as signaldecompose
newtargetpath, origtargetduration = signaldecompose.decomposeTargetSf(
self.filename, self.startSec, self.endSec, self.decompose)
self.decompose['origfilename'] = self.filename
self.decompose['origduration'] = origtargetduration
self.filename = newtargetpath
self.segmentationThresh = userOptsTargetObject.thresh
self.segmentationOffsetRise = userOptsTargetObject.offsetRise
self.segmentationOffsetThreshAdd = userOptsTargetObject.offsetThreshAdd
self.segmentationOffsetThreshAbs = userOptsTargetObject.offsetThreshAbs
self.segmentationMinLenSec = userOptsTargetObject.minSegLen
self.segmentationMaxLenSec = userOptsTargetObject.maxSegLen
self.envDb = userOptsTargetObject.scaleDb
self.midiPitchMethod = userOptsTargetObject.midiPitchMethod
self.stretch = userOptsTargetObject.stretch
self.segmentationFilepath = userOptsTargetObject.segmentationFilepath
# multirise corpus segmentation ?
self.multiriseBool = userOptsTargetObject.multiriseBool
self.multirisePercentDev = userOptsTargetObject.multirisePercentDev
self.multiriseSteps = userOptsTargetObject.multiriseSteps
def __init__(self, userOptsTargetObject, AnalInterface):
self.filename = userOptsTargetObject.filename
self.filename = util.verifyPath(self.filename,
AnalInterface.searchPaths)
self.filename = os.path.abspath(self.filename)
self.startSec = userOptsTargetObject.start
self.endSec = userOptsTargetObject.end
# check for signal decomposition
self.decompose = userOptsTargetObject.decompose
if self.decompose != {}:
if self.startSec == None: self.startSec = 0
import audioguide.fileoutput.signaldecompose as signaldecompose
newtargetpath, origtargetduration = signaldecompose.decomposeTargetSf(
self.filename,
self.startSec,
self.endSec,
self.decompose,
directory=os.path.split(__file__)[0])
self.decompose['origfilename'] = self.filename
self.decompose['origduration'] = origtargetduration
self.filename = newtargetpath
# partials
self.partials = userOptsTargetObject.partials
if self.partials != None:
params = {
'frame_size': 4096,
'win_size': 4096,
'hop_size': 1024,
'partial_min_duration': 0.05,
'partial_limit_midi': (20, 110),
'partial_limit_db': (-60, 0),
'partial_max_overlaps': 20,
'partial_min_confidence': 0, # 0->100
'partial_resynthsis_file': '/Users/ben/Desktop/partials/p.wav',
'forceAnalysis': False,
'use_partials_for_segmentation': False,
}
params.update(self.partials)
self.partials = params
self.has_partials = True
else:
self.has_partials = False
# segmentation stuff
self.segmentationThresh = userOptsTargetObject.thresh
self.segmentationOffsetRise = userOptsTargetObject.offsetRise
self.segmentationOffsetThreshAdd = userOptsTargetObject.offsetThreshAdd
self.segmentationOffsetThreshAbs = userOptsTargetObject.offsetThreshAbs
self.segmentationMinLenSec = userOptsTargetObject.minSegLen
self.segmentationMaxLenSec = userOptsTargetObject.maxSegLen
self.envDb = userOptsTargetObject.scaleDb
self.midiPitchMethod = userOptsTargetObject.midiPitchMethod
self.stretch = userOptsTargetObject.stretch
self.segmentationFilepath = userOptsTargetObject.segmentationFilepath
# multirise corpus segmentation ?
self.multiriseBool = userOptsTargetObject.multiriseBool
self.multirisePercentDev = userOptsTargetObject.multirisePercentDev
self.multiriseSteps = userOptsTargetObject.multiriseSteps
def __init__(self, corpusFromUserOptions,
corpusGlobalAttributesFromOptions,
restrictCorpusSelectionsByFilenameString, searchPaths,
AnalInterface, p):
self.preloadlist = []
self.preLimitSegmentList = []
self.postLimitSegmentNormList = []
self.selectedSegmentList = []
self.simSelectRuleByCorpusId = []
self.len = len(corpusFromUserOptions)
self.data = {}
self.data['lastVoice'] = None
self.data['totalLengthInSeconds'] = 0.
self.data['vcToCorpusName'] = []
self.data['postLimitSegmentDictVoice'] = {}
self.data['postLimitSegmentCount'] = 0
self.data['selectionTimeByVoice'] = {}
self.data['cspInfo'] = []
for cidx in range(len(corpusFromUserOptions)):
self.data['postLimitSegmentDictVoice'][cidx] = []
self.data['selectionTimeByVoice'][cidx] = []
# find any GLOBAL limitations the user has placed on the corpus
self.globalLimits = []
self.localLimits = []
if 'limit' in corpusGlobalAttributesFromOptions:
for stringy in corpusGlobalAttributesFromOptions['limit']:
self.globalLimits.append(
cpsLimit(stringy, range(len(corpusFromUserOptions)),
AnalInterface))
self.data['numberVoices'] = len(corpusFromUserOptions)
for cidx, cobj in enumerate(corpusFromUserOptions):
# add this voice
vcCnt = 0
cobj.name = util.verifyPath(cobj.name, AnalInterface.searchPaths)
cobj.voiceID = cidx
self.simSelectRuleByCorpusId.append(cobj.superimposeRule)
self.data['vcToCorpusName'].append(cobj.name)
for name, val in corpusGlobalAttributesFromOptions.items():
if name == 'limit': continue
setattr(cobj, name, val)
# add local limits
totalLimitList = []
for limitstr in cobj.limit:
limitObj = cpsLimit(limitstr, [cidx], AnalInterface)
self.localLimits.append(limitObj)
totalLimitList.append(limitObj)
# add global limits
totalLimitList.extend(
self.globalLimits) # from CORPUS_GLOBAL_ATTRIBUTES
# get segments/files list
timeList = []
if os.path.isdir(cobj.name): fileType = 'dir'
if os.path.isfile(cobj.name): fileType = 'file'
if os.path.islink(cobj.name): fileType = 'link'
# list of segmentation files?
if type(cobj.segmentationFile) in [tuple,
list]: # a list of seg files
cobj.segmentationFile = [
path.test(string, ops.SEARCH_PATHS)[1]
for string in cobj.segmentationFile
]
if fileType == 'file': # an audio file
##################
## input a FILE ## -- look for audacity-style txt label file
##################
times = []
if cobj.wholeFile:
times.append([0, None])
else:
cobj.segmentationFile = findSegmentationFile(
cobj.name, searchPaths[:], cobj.segmentationExtension,
cobj.wholeFile)
if not os.path.isfile(cobj.segmentationFile):
util.error(
'segmentation file',
"Cannot find segmentation file '%s'" %
cobj.segmentationFile)
sgs = util.readAudacityLabelFile(cobj.segmentationFile)
times.extend(sgs)
p.log(
"Using segments from segmentation file %s (%i segments)"
% (cobj.segmentationFile, len(sgs)))
for timeSeg in times:
timeList.append([cobj.name] + timeSeg)
cobj.numbSfFiles = 1
elif fileType == 'dir': # a directory
#######################
## input a DIRECTORY ##
#######################
files = util.getDirListOnlyExt(cobj.name, cobj.recursive,
AnalInterface.validSfExtensions)
cobj.segmentationFile = None # don't print it
for file in files:
segFileTest = findSegmentationFile(
file, searchPaths, cobj.segmentationExtension,
cobj.wholeFile)
if segFileTest != None and os.path.exists(segFileTest):
times = util.readAudacityLabelFile(segFileTest)
p.log(
"Using segments from segmentation file %s (%i segments)"
% (segFileTest, len(times)))
else:
times = [[0, None]]
for timeSeg in times:
timeList.append([file] + timeSeg)
cobj.numbSfFiles = len(files)
# reset counters...
segCount = 0
windowDist = descriptordata.hannWin(len(timeList) * 2)
# segment list
stringMatchingWithFullPaths = True
for idx in range(len(timeList)):
startSec = timeList[idx][1]
endSec = timeList[idx][2]
if cobj.start != None and startSec < cobj.start:
continue # skip it
if cobj.end != None and startSec > cobj.end:
continue # skip it
# matchSting: includeStr/excludeStr
if stringMatchingWithFullPaths:
stringMatchPath = os.path.abspath(timeList[idx][0])
else:
stringMatchPath = os.path.split(timeList[idx][0])[1]
if cobj.includeStr != None:
skip = True
if type(cobj.includeStr) not in [list, tuple]:
cobj.includeStr = [cobj.includeStr]
for test in cobj.includeStr:
if util.matchString(stringMatchPath,
test,
caseSensative=True):
skip = False
if skip: continue
if cobj.excludeStr != None:
skip = False
if type(cobj.excludeStr) not in [list, tuple]:
cobj.excludeStr = [cobj.excludeStr]
for test in cobj.excludeStr:
if util.matchString(stringMatchPath,
test,
caseSensative=True):
skip = True
if skip: continue
# minTime / maxTime
# matchTime: includeTimes/excludeTimes
if len(cobj.includeTimes) > 0:
skip = True
for timeTuple in cobj.includeTimes:
if startSec >= timeTuple[0] and endSec <= timeTuple[1]:
skip = False
if skip: continue
if len(cobj.excludeTimes) > 0:
skip = False
if type(cobj.excludeTimes) not in [list, tuple]:
cobj.excludeTimes = [cobj.excludeTimes
] # force it to be a list
for timeTuple in cobj.excludeTimes:
if startSec >= timeTuple[0] and startSec < timeTuple[1]:
skip = True
#print stringMatchPath, start, end, skip
if skip: continue
# see if there is any extra data from the segmentation file
if len(timeList[idx]) > 3:
segmentationfileData = ' '.join(timeList[idx][3:])
else:
segmentationfileData = None
# test if limitDur is set...
if cobj.limitDur != None:
if endSec != None and endSec - startSec > cobj.limitDur:
endSec = startSec + cobj.limitDur
# see which sf to map sound concatenation onto...
if cobj.concatFileName == None:
concatFileName = timeList[idx][0]
else:
concatFileName = cobj.concatFileName
# get any metadata
metadata = ''
for mstring, mstart, mstop in cobj.metadata:
if startSec >= mstart and startSec <= mstop:
metadata += mstring + ' '
# see if global RESTRICT_CORPUS_SELECT_PERCENTAGE_BY_STRING applies
maxPercentTargetSegmentsByString = None
for restrictStr, restrictVal in restrictCorpusSelectionsByFilenameString.items(
):
if util.matchString(timeList[idx][0], restrictStr):
maxPercentTargetSegmentsByString = restrictVal
self.preloadlist.append([
timeList[idx][0], timeList[idx][1], timeList[idx][2],
cobj.scaleDb, cobj.onsetLen, cobj.offsetLen,
cobj.envelopeSlope, AnalInterface, concatFileName,
cobj.name, cobj.voiceID, cobj.midiPitchMethod,
totalLimitList, cobj.pitchfilter, cobj.scaleDistance,
cobj.superimposeRule, cobj.transMethod, cobj.transQuantize,
cobj.allowRepetition, cobj.restrictInTime,
cobj.restrictOverlaps, cobj.restrictRepetition,
cobj.postSelectAmpBool, cobj.postSelectAmpMin,
cobj.postSelectAmpMax, cobj.postSelectAmpMethod,
segmentationfileData, metadata, cobj.clipDurationToTarget,
cobj.instrTag, cobj.instrParams
])
vcCnt += 1
self.data['cspInfo'].append({
'name': cobj.name,
'filehead': os.path.split(cobj.name)[1],
'segs': str(vcCnt),
'fileType': fileType,
'numbSfFiles': cobj.numbSfFiles,
'restrictInTime': cobj.restrictInTime,
'segFile': cobj.segmentationFile,
'restrictOverlaps': cobj.restrictOverlaps,
'scaleDb': cobj.scaleDb,
'maxPercentTargetSegments': cobj.maxPercentTargetSegments,
'selectedTargetSegments': [],
'instrTag': cobj.instrTag,
'instrParams': cobj.instrParams
})
###########################
## done with CORPUS loop ##
###########################
p.startPercentageBar(upperLabel="Evaluating CORPUS...",
total=len(self.preloadlist))
# in a seperate loop for printing...
for cidx, corpusSegParams in enumerate(self.preloadlist):
start = corpusSegParams[1]
stop = corpusSegParams[2]
if start == None: start = 0
if stop == None: stop = 100
p.percentageBarNext(lowerLabel="%s@%.2f-%.2f" %
(corpusSegParams[0], start, stop))
# make the obj
cpsSeg = sfsegment.corpusSegment(*corpusSegParams)
# add it to the list!
self.preLimitSegmentList.append(cpsSeg)
self.evaluatePreConcateLimitations()
self.evaluateCorpusPitchFilters()
self.finalizeSegmentNormList()
p.percentageBarClose(
txt="Read %i/%i segments (%.0f%%, %.2f min.)" %
(self.data['postLimitSegmentCount'], len(self.preLimitSegmentList),
self.data['postLimitSegmentCount'] /
float(len(self.preLimitSegmentList)) * 100.,
self.data['totalLengthInSeconds'] / 60.))
self.printConcateLimitations(p)
def __init__(self,
filename,
startSec,
endSec,
descriptors,
AnalInterface,
envDb=+0,
envAttackSec=0.,
envDecaySec=0.,
envSlope=1.,
envAttackenvDecayCushionSec=0.01):
self.filename = util.verifyPath(filename, AnalInterface.searchPaths)
self.printName = os.path.split(
self.filename)[1] # short name for printing
# filename-based descriptor info
self.midiPitchFromFilename = descriptordata.getMidiPitchFromString(
self.printName)
self.rmsAmplitudeFromFilename, self.dynamicFromFilename = util.getDynamicFromFilename(
self.printName, notFound=-1000)
# other info
self.soundfileExtension = os.path.splitext(self.filename)[1]
self.soundfileTotalDuration, self.soundfileChns = AnalInterface.validateAnalResource(
self.filename)
self.segmentStartSec = startSec
self.segmentEndSec = endSec
self.envDb = util.getScaleDb(envDb, self)
self.envAttack = envAttackSec
self.envDecay = envDecaySec
self.envSlope = envSlope
# if startSec=None, it is begninning
# if endSec=None, it is end of file
if self.segmentStartSec == None: self.segmentStartSec = 0
else: self.segmentStartSec = self.segmentStartSec
if self.segmentEndSec == None:
self.segmentEndSec = self.soundfileTotalDuration
else:
self.segmentEndSec = self.segmentEndSec
self.segmentDurationSec = self.segmentEndSec - self.segmentStartSec
# ensure length is at least 1 fram
self.lengthInFrames = max(
1,
AnalInterface.getSegmentFrameLength(self.segmentDurationSec,
self.filename))
self.f2s = AnalInterface.f2s(1)
##############################################################
## check to make sure all user supplied values check out OK ##
##############################################################
self.testForInitErrors(AnalInterface)
################
## other shit ##
################
self.segmentHash = util.listToCheckSum([
self.filename, self.segmentStartSec, self.segmentEndSec,
self.envDb, self.envAttack, self.envDecay, self.envSlope
])
####################################
## get information about envelope ##
####################################
self.envAttackSec = util.getDurationFromValueOrString(
self.envAttack, self.segmentDurationSec)
self.envDecaySec = util.getDurationFromValueOrString(
self.envDecay, self.segmentDurationSec)
if (self.envAttackSec + self.envDecaySec +
envAttackenvDecayCushionSec) > self.segmentDurationSec:
self.envDecaySec = self.segmentDurationSec - self.envAttackSec - envAttackenvDecayCushionSec
self.envAttackFrames = int(
round(AnalInterface.s2f(self.envAttackSec, self.filename)))
self.envDecayFrames = int(
round(AnalInterface.s2f(self.envDecaySec, self.filename)))
if (self.envAttackFrames + self.envDecayFrames) > self.lengthInFrames:
if self.envAttackFrames > self.envDecayFrames:
self.envAttackFrames = self.lengthInFrames - self.envDecayFrames
else:
self.envDecayFrames = self.lengthInFrames - self.envAttackFrames
if self.envAttackFrames <= 1 and self.envDecayFrames <= 1:
self.envelopeMask = util.dbToAmp(self.envDb)
else:
self.envelopeMask = np.ones(self.lengthInFrames)
if self.envAttackFrames > 0:
self.envelopeMask[:self.envAttackFrames] = np.linspace(
1 / float(self.envAttackFrames),
1,
num=self.envAttackFrames)
if self.envDecayFrames > 0:
self.envelopeMask[self.envDecayFrames * -1:] = np.linspace(
1, 1 / float(self.envDecayFrames), num=self.envDecayFrames)
self.envelopeMask = np.power(self.envelopeMask, self.envSlope)
self.envelopeMask *= util.dbToAmp(self.envDb)
########################################
## manage duration and time-in-frames ##
########################################
self.segmentStartFrame = AnalInterface.getSegmentStartInFrames(
self.filename, self.segmentStartSec, self.segmentEndSec,
self.lengthInFrames)
###############################
## initalise descriptor data ##
###############################
self.desc = descriptordata.container(
descriptors, self) # for storing descriptor values from disk
# tells us which descriptors are:
# SdifDescList - loaded from NYC analyses
# ComputedDescList - transformed from loaded descriptor data - delta, deltadelta, odf, etc.
# AveragedDescList - averaged descriptors from loaded descriptor data
AnalDescList, ComputedDescList, AveragedDescList = self.desc.getDescriptorOrigins(
)
for d in AnalDescList:
self.desc[d.name] = AnalInterface.getDescriptorForsfsegment(
self.filename, self.segmentStartFrame, self.lengthInFrames, d,
self.envelopeMask)
for dobj in ComputedDescList:
self.desc[dobj.name] = descriptordata.DescriptorComputation(
dobj, self, None, None)
self.triggerinit = False
def __init__(self,
filename,
startSec,
endSec,
AnalInterface,
envDb=+0,
envAttackSec=0.,
envDecaySec=0.,
envSlope=1.,
envAttackenvDecayCushionSec=0.01,
normtag='notag'):
self.filename = util.verifyPath(filename, AnalInterface.searchPaths)
self.soundfileExtension = os.path.splitext(self.filename)[1]
self.printName = os.path.split(
self.filename)[1] # short name for printing
# filename-based descriptor info
self.midipitch = None
self.midiPitchFromFilename = descriptordata.getMidiPitchFromString(
self.printName)
self.rmsAmplitudeFromFilename, self.dynamicFromFilename = descriptordata.getDynamicFromFilename(
self.printName,
AnalInterface.dynToDbDict,
AnalInterface.stringToDynDict,
notFound=-1000)
# other info
self.soundfileTotalDuration, self.soundfileChns = AnalInterface.validateAnalResource(
self.filename)
self.segmentStartSec = startSec
self.segmentEndSec = endSec
self.envDb = util.getScaleDb(envDb, self)
self.envAttack = envAttackSec
self.envDecay = envDecaySec
self.envSlope = envSlope
if self.segmentStartSec == None: self.segmentStartSec = 0
else: self.segmentStartSec = self.segmentStartSec
if self.segmentEndSec == None:
self.segmentEndSec = self.soundfileTotalDuration
else:
self.segmentEndSec = self.segmentEndSec
self.segmentDurationSec = self.segmentEndSec - self.segmentStartSec
# ensure length is at least 1 frame
self.lengthInFrames = max(
1,
AnalInterface.getSegmentFrameLength(self.segmentStartSec,
self.segmentDurationSec,
self.filename))
self.f2s = AnalInterface.f2s(1)
##############################################################
## check to make sure all user supplied values check out OK ##
##############################################################
self.testForInitErrors(AnalInterface)
################
## other shit ##
################
self.segmentHash = util.listToCheckSum([
self.filename, self.segmentStartSec, self.segmentEndSec,
self.envDb, self.envAttack, self.envDecay, self.envSlope
])
####################################
## get information about envelope ##
####################################
self.envAttackSec = util.getDurationFromValueOrString(
self.envAttack, self.segmentDurationSec)
self.envDecaySec = util.getDurationFromValueOrString(
self.envDecay, self.segmentDurationSec)
if (self.envAttackSec + self.envDecaySec +
envAttackenvDecayCushionSec) > self.segmentDurationSec:
self.envDecaySec = self.segmentDurationSec - self.envAttackSec - envAttackenvDecayCushionSec
self.envAttackFrames = int(
round(AnalInterface.s2f(self.envAttackSec, self.filename)))
self.envDecayFrames = int(
round(AnalInterface.s2f(self.envDecaySec, self.filename)))
if (self.envAttackFrames + self.envDecayFrames) > self.lengthInFrames:
if self.envAttackFrames > self.envDecayFrames:
self.envAttackFrames = self.lengthInFrames - self.envDecayFrames
else:
self.envDecayFrames = self.lengthInFrames - self.envAttackFrames
if self.envAttackFrames <= 1 and self.envDecayFrames <= 1:
self.envelopeMask = util.dbToAmp(self.envDb)
else:
self.envelopeMask = np.ones(self.lengthInFrames)
if self.envAttackFrames > 0:
self.envelopeMask[:self.envAttackFrames] = np.linspace(
1 / float(self.envAttackFrames),
1,
num=self.envAttackFrames)
if self.envDecayFrames > 0:
self.envelopeMask[self.envDecayFrames * -1:] = np.linspace(
1, 1 / float(self.envDecayFrames), num=self.envDecayFrames)
self.envelopeMask = np.power(self.envelopeMask, self.envSlope)
self.envelopeMask *= util.dbToAmp(self.envDb)
########################################
## manage duration and time-in-frames ##
########################################
self.segmentStartFrame = AnalInterface.getSegmentStartInFrames(
self.filename, self.segmentStartSec, self.segmentEndSec,
self.lengthInFrames)
###############################
## initalise descriptor data ##
###############################
self.desc = AnalInterface.desc_manager.create_sf_descriptor_obj(
self,
AnalInterface.getDescriptorMatrix(self.filename),
self.segmentStartFrame,
self.lengthInFrames,
tag=normtag,
envelope=self.envelopeMask)
self.triggerinit = False