if a != b: return False
return True
- def add_result(self, analyzer_result):
+ def add(self, analyzer_result):
if type(analyzer_result) == list:
for a in analyzer_result:
- self.add_result(a)
+ self.add(a)
return
if type(analyzer_result) != AnalyzerResult:
raise TypeError('only AnalyzerResult can be added')
result = AnalyzerResult(id = self.id(), name = self.name(), unit = "something")
result.value = self.result_data
- container.add_result(result)
+ container.add(result)
# add other results in the container if needed...
# Set Data
melenergy.data.value = self.melenergy_results
- self.resultContainer.add_result(melenergy)
+ self._results.add(melenergy)
mfcc.parameters = parameters
mfcc.data.value = self.mfcc_results
- self.resultContainer.add_result(mfcc)
+ self._results.add(mfcc)
# Set Data
pitch.data.value = numpy.array(self.pitches)
- self.resultContainer.add_result(pitch)
+ self._results.add(pitch)
res_specdesc.data.value = self.specdesc_results[method]
- self.resultContainer.add_result(res_specdesc)
+ self._results.add(res_specdesc)
onsets.labelMetadata.label = {1: 'Onset'}
- self.resultContainer.add_result(onsets)
+ self._results.add(onsets)
#---------------------------------
# Onset Rate
else:
onsetrate.data.value = []
- self.resultContainer.add_result(onsetrate)
+ self._results.add(onsetrate)
#---------------------------------
# Beats
beats.labelMetadata.label = {1: 'Beat'}
- self.resultContainer.add_result(beats)
+ self._results.add(beats)
#---------------------------------
# BPM
else:
bpm.data.value = []
- self.resultContainer.add_result(bpm)
+ self._results.add(bpm)
def __init__(self, analyzer_results=None):
super(AnalyzerResultContainer,self).__init__()
if analyzer_results is not None:
- self.add_result(analyzer_results)
+ self.add(analyzer_results)
# def __getitem__(self, i):
# return self.results[i]
#def __ne__(self, other):
# return not self.__eq__(other)
- def add_result(self, analyzer_result):
+ def add(self, analyzer_result):
if isinstance(analyzer_result, list):
for res in analyzer_result:
- self.add_result(res)
+ self.add(res)
return
# Check result
if not isinstance(analyzer_result, AnalyzerResult):
root = ET.fromstring(xml_string)
for child in root.iter('result'):
result = AnalyzerResult()
- results.add_result(result.from_xml(ET.tostring(child)))
+ results.add(result.from_xml(ET.tostring(child)))
return results
if key not in ['dataMode', 'timeMode']:
res[key] = res_json[key]
- results.add_result(res)
+ results.add(res)
return results
def to_yaml(self):
res = AnalyzerResult()
for key in res_yaml.keys():
res[key] = res_yaml[key]
- results.add_result(res)
+ results.add(res)
return results
def to_numpy(self, output_file):
else:
result[subgroup_name][dsetName] = []
- data_list.add_result(result)
+ data_list.add(result)
except TypeError:
print('TypeError for HDF5 serialization')
finally:
self.result_stepsize = self.input_stepsize
def results(self):
- #container = AnalyzerResultContainer()
- return self.resultContainer
+ #TODO :return self._results[id=analyzerID]
+ return self._results
@staticmethod
@interfacedoc
dc_result.idMetadata.unit = "%"
# Set Data
dc_result.data.value = numpy.round(numpy.mean(100*self.values),3)
- self.resultContainer.add_result(dc_result)
\ No newline at end of file
+ self._results.add(dc_result)
\ No newline at end of file
max_level.idMetadata.unit = "dBFS"
max_level.data.value = numpy.round(20*numpy.log10(self.max_value), 3)
- self.resultContainer.add_result(max_level)
+ self._results.add(max_level)
# RMS level
rms_level = self.new_result(dataMode='value', timeMode='global')
rms_level.data.value = numpy.round(20*numpy.log10(
numpy.sqrt(numpy.mean(self.mean_values))), 3)
- self.resultContainer.add_result(rms_level)
+ self._results.add(rms_level)
result.data.value = self.yaafe_engine.readOutput(featName)
# Store results in Container
if len(result.data.value):
- self.resultContainer.add_result(result)
+ self._results.add(result)
last = source
from timeside.analyzer.core import AnalyzerResultContainer
- self.resultContainer = AnalyzerResultContainer()
+ self._results = AnalyzerResultContainer()
# setup/reset processors and configure properties throughout the pipe
for item in items:
blocksize = last.blocksize(),
totalframes = last.totalframes())
item.source_mediainfo = source.mediainfo()
- item.resultContainer = self.resultContainer
+ item._results = self._results
last = item
# now stream audio data along the pipe