def tongjidistype(fname, attrname):
filereader = FileReader(fname)
attridx = filereader.getattridx(attrname)
trandata = {}
while True:
tmptran = filereader.readtransection()
if tmptran is None:
break
summary = tmptran[attridx]
if summary not in trandata:
trandata[summary] = 0
trandata[summary] += 1
valuelist = trandata.values()
valuelist.sort()
c = Counter(valuelist)
keylist = c.keys()
keylist.sort()
for key in keylist:
print key, "\t:\t", c[key]
itemslist = trandata.items()
itemslist.sort(key=lambda v: v[1], reverse=True)
# for key,value in itemslist:
# print key
# print value
# raw_input()
# print valuelist
# raw_input()
print "========================================================"
import pprint
pp = pprint.PrettyPrinter(indent=4)
pp.pprint(trandata)
print "length:", len(trandata)
class Demonstrator():
''' Runs both files in one go process and filereader '''
def __init__(self,filename):
self.process = Process() # Creats an object
self.reader = FileReader(filename,self.process) # Creates an object
self.reader.run() # call the run method
self.process.workOut()
def newFile(self,filename):
'''Ressets object and run the object again'''
self.process.reset() #resets objects
self.reader.FileReader(filename,self.process)
self.reader.run()
def displayResults(self):
'''Display the object result'''
print (self.process.showAnswer())
def displayQ1(self): return '%0.2f'% (self.process.get_Length()) # To get the value
def displayQ2(self): return '%0.2f%%'% (self.process.get_Mark()) # for GUIs
def displayQ3(self): return '%0.2f%%'% (self.process.get_Action())
def displayQ4(self): return '%0.2f'% (self.process.get_Count())
def displayQ5(self): return '%d'% (self.process.get_Match())
def displayQ6(self): return '%0.2f%%'% (self.process.get_Tree())
def displayQ7(self): return '%d'% (self.process.get_LineCount())
def setUp(self):
self.tmpfn = tempfile.mktemp("filereadertest")
fp = open(self.tmpfn, 'w')
for line in self.lines:
fp.write(line)
fp.close()
self.f = FileReader(self.tmpfn)
class Demonstrator():
''' Runs both files in one go process and filereader '''
def __init__(self, filename):
self.process = Process() # Creats an object
self.reader = FileReader(filename, self.process) # Creates an object
self.reader.run() # call the run method
self.process.totalCost()
def displayRow(self):
return self.process.getRowCount()
def displayTotalSum(self):
return '\u00A3%0.2f' % (self.process.getTotalSum())
def displayCostDate(self):
return self.process.dateList()
def displayStaff_Names(self):
return self.process.getListOfName()
def displayStaffCost(self):
return self.process.getStaffCost()
def displaySpendings(self, ID):
return self.process.spendingType(ID)
#Last Method Run
def total_Cost(self):
return self.process.totalCost() #Must be run after
def displayStaffSum(self):
return self.process.getStaffCost()
def staffName(self):
return self.process.getStaff()
def tongjilocation():
filereader = FileReader("../1022.csv")
attridx = filereader.getattridx("LOCATION")
trandata = {}
while True:
tmptran = filereader.readtransection()
if tmptran is None:
break
loc = tmptran[attridx]
try:
locinfo = loc.split(";")[1].split("/")
targetloc = locinfo[0]
if targetloc not in trandata:
trandata[targetloc] = 0
trandata[targetloc] += 1
except:
print loc
# raw_input()
valuelist = trandata.values()
valuelist.sort()
c = Counter(valuelist)
keylist = c.keys()
keylist.sort()
for key in keylist:
print key,"\t:\t",c[key]
raw_input()
raw_input()
itemslist = trandata.items()
itemslist.sort(key=lambda v:v[1],reverse=True)
for key,value in itemslist:
print key
print value
raw_input()
def show_open_dialog(self):
self.audioFile = QtGui.QFileDialog.getOpenFileName(
self, 'Open audio file', '', "Audio Files (*.wav)", None,
QtGui.QFileDialog.DontUseNativeDialog)
if self.audioFile != "":
self.featuresTbl.setRowCount(0)
self.featuresTbl.setColumnCount(0)
self.audioClassInput.setText("")
fileName = str(self.audioFile)
self.audio_signal, self.audio_fs = FileReader.read_audio(fileName)
self.silenced_signal, self.audio_fs = self.mfcc.remove_silence(
fileName)
self.fsValLbl.setText(": " + str(self.audio_fs) + " Hz")
self.sampleValLbl.setText(": " + str(len(self.audio_signal)) +
" | " + str(len(self.silenced_signal)) +
" (silenced)")
self.audioFilenameLbl.setText(": " + fileName[fileName.rfind('/') +
1:len(fileName)])
self.audioClassInput.setText(FileReader.get_output_class(fileName))
self.audioPlayBtn.setDisabled(False)
self.extractSaveBtn.setDisabled(False)
self.player.set_audio_source(self.audioFile)
def read_file_test(self):
file_reader = FileReader("data/partitions.txt")
cluster_points = file_reader.read_file_to_cluster_points()
self.assertIsInstance(cluster_points, list)
self.assertGreater(len(cluster_points), 1)
self.assertEqual(cluster_points[0].point_id, 1)
self.assertEqual(cluster_points[0].cluster_id, 2)
for cluster_point in cluster_points:
self.assertIsInstance(cluster_point, ClusterPoint)
def printinfo():
fnamelist = ["../10"+str(v)+".csv" for v in xrange(22,23)]
cnt = 0
found = 0
wholeresult = {}
# writefile = open("../cleandata","w")
missloc = {}
for fname in fnamelist:
filereader = FileReader(fname)
alarmcode = filereader.getattridx("ALARMCODE")
attridx = filereader.getattridx("SUMMARY")
locidx= filereader.getattridx("LOCATION")
timeidx = filereader.getattridx("ALARMHAPPENTIME")
cntidx = 0
while True:
tmptran = filereader.readtransection()
cntidx += 1
# print cntidx
if tmptran is None:
filereader.close()
break
summary = tmptran[attridx]
location = tmptran[locidx]
if location.startswith("SU6095-SU2551"):
print "SUMMARY:"
print summary
print "--------------"
print "LOCATION"
print location
def remove_silence(self, audio):
call([
'sox', audio,
FileReader.add_temp(audio), 'silence', self.above_period,
self.duration, self.threshold, self.below_period, self.duration,
self.threshold
])
silenced_signal, silenced_fs = FileReader.read_audio(
FileReader.add_temp(audio))
os.remove(FileReader.add_temp(audio))
return [silenced_signal, silenced_fs]
def run(self):
self.emit(QtCore.SIGNAL("update()"))
self.mfcc.frame_size = int(self.par.frameSizeVal.currentText())
self.mfcc.overlap = self.mfcc.frame_size / 2
for index, file_audio in enumerate(self.audio_files):
file_audio = str(file_audio)
self.audio_signal, self.audio_fs = FileReader.read_audio(
file_audio)
self.silenced_signal, self.audio_fs = self.mfcc.remove_silence(
file_audio)
self.num_frames, self.framed_signal = self.mfcc.frame_blocking(
self.silenced_signal)
self.windowed_signal = self.mfcc.hamm_window(self.framed_signal)
self.fft_signal = self.mfcc.calc_fft(self.windowed_signal)
self.log_energy, self.fbank = self.mfcc.fbank(
self.fft_signal, self.audio_fs)
self.features = self.mfcc.features(self.log_energy)
# var = [st.variance(self.features[:,i]) for i in xrange(self.mfcc.num_filter)]
# [self.all_features.append(self.features[i,:]) for i in xrange(self.features.shape[0])]
# self.variances.append(var)
features = []
if TYPE == 1:
file_id = self.db.insert("files", {"file_path": file_audio})
for i in xrange(self.features.shape[0]):
# [31, 28, 29, 30, 27, 26, 25, 24, 23, 22, 20, 21, 19
# features.append([file_id, i, self.features[i, 1:14], str(self.par.featuresTbl.item(index,1).text())])
features.append([
file_id, i, self.features[
i, [1, 2, 3, 4, 5, 7, 6, 9, 8, 10, 11, 12, 13]],
str(self.par.featuresTbl.item(index, 1).text())
])
self.db.insert_features(features)
else:
output_class_id = self.db.insert(
"output_classes", {
"file_path": file_audio,
"class": str(FileReader.get_output_class(file_audio))
})
for i in xrange(self.features.shape[0]):
features.append(
[output_class_id, i, self.features[i, 1:14]])
self.db.insert_features(features)
self.emit(QtCore.SIGNAL("update()"))
# self.variances = np.asarray(self.variances)
# rata2 = [st.mean(self.variances[:,i]) for i in xrange(self.mfcc.num_filter)]
# self.write_excel(rata2)
# print str(np.sort(rata2))
# print str(np.argsort(rata2))
self.emit(QtCore.SIGNAL("finish()"))
def loadtopo(self):
self.m_directtopo = {}
self.m_fatherdata = {}
self.m_topodict = {}
filereader = FileReader("../NE_TOPO_INFO.csv")
neidx = filereader.getattridx("NE_ID")
parentidx = filereader.getattridx("PARENT_NE_ID")
empty = 0
nonempty = 0
halfempty = 0
while True:
tmptran = filereader.readtransection()
if tmptran is None:
break
neid = tmptran[neidx]
parentneid = tmptran[parentidx]
childne = self.getnebysiteid(neid)
parentne = self.getnebysiteid(parentneid)
if childne is None and parentne is None:
empty += 1
continue
elif childne is None or parentne is None:
halfempty += 1
if parentne is None:
childnename = childne.m_name
parentnename = parentneid
if childnename not in self.m_fatherdata:
self.m_fatherdata[childnename] = []
self.m_fatherdata[childnename].append(parentnename)
continue
else:
nonempty += 1
childnename = childne.m_name
parentnename = parentne.m_name
if childnename not in self.m_fatherdata:
self.m_fatherdata[childnename] = []
self.m_fatherdata[childnename].append(parentnename)
if childnename not in self.m_topodict:
self.m_topodict[childnename] = []
if parentnename not in self.m_topodict:
self.m_topodict[parentnename] = []
if parentnename not in self.m_directtopo:
self.m_directtopo[parentnename] = []
self.m_topodict[childnename].append(parentnename)
self.m_topodict[parentnename].append(childnename)
self.m_directtopo[parentnename].append(childnename)
print "empty:", empty
print "halfempty:", halfempty
print "nonempty:", nonempty
class FileReaderTestCase(unittest.TestCase):
lines = ('1st line\n', '2nd line\n', '3rd line\n')
def setUp(self):
self.tmpfn = tempfile.mktemp("filereadertest")
fp = open(self.tmpfn, 'w')
for line in self.lines:
fp.write(line)
fp.close()
self.f = FileReader(self.tmpfn)
def tearDown(self):
self.f.close()
os.unlink(self.tmpfn)
def tongjinetype():
filereader = FileReader("../NE_INFO.csv")
attridx = filereader.getattridx("NE_CAT_ID")
trandata = {}
while True:
tmptran = filereader.readtransection()
if tmptran is None:
break
summary = tmptran[attridx]
if summary not in trandata:
trandata[summary] = 0
trandata[summary] += 1
import pprint
pp = pprint.PrettyPrinter(indent=4)
pp.pprint(trandata)
class MainClass:
def __init__(self):
self.utils = Utils()
self.filereader = FileReader()
self.parser = Parser()
pass
def main(self):
Tables_map = {}
self.filereader.create_table_signatures("metadata.txt", Tables_map)
query = str(sys.argv[1])
if query:
self.parser.parse_query(query, Tables_map)
else:
print("No query")
def show_open_dialog(self):
self.audioFile = QtGui.QFileDialog.getOpenFileName(self, 'Open audio file',
'',
"Audio Files (*.wav)",
None, QtGui.QFileDialog.DontUseNativeDialog)
if self.audioFile != "":
fileName = str(self.audioFile)
self.audio_signal, self.audio_fs = FileReader.read_audio(fileName)
self.silenced_signal, self.audio_fs = self.mfcc.remove_silence(fileName)
self.fsValLbl.setText(": " + str(self.audio_fs) + " Hz")
self.sampleValLbl.setText(
": " + str(len(self.audio_signal)) + " | " + str(len(self.silenced_signal)) + " (silenced)")
self.audioFilenameLbl.setText(": " + fileName[fileName.rfind('/') + 1:len(fileName)])
self.audioPlayBtn.setDisabled(False)
self.clear_all_layout()
fig = Figure()
self.origSignalPlot = fig.add_subplot(111)
self.origSignalPlot.plot(self.audio_signal)
self.add_figure(fig, self.originalPlotLyt)
self.extractSaveBtn.setDisabled(False)
self.player.set_audio_source(self.audioFile)
self.testDataTab.setCurrentIndex(0)
def execution():
parser = argparse.ArgumentParser()
parser.add_argument("-v",
"--verbosity",
type=str,
help="increase output verbosity")
parser.add_argument("-i",
"--input",
type=str,
default="data_kidney",
help="input")
parser.add_argument("-o",
"--output",
type=str,
default='data_kidney.jpg',
help="output")
args = parser.parse_args()
file_reader = FileReader(args.input)
scanconversion = ScanConverter(file_reader)
scanconversion.convert(file_reader, args.output)
def __init__(self):
# this is determined by whether we read from a file or not
self.data_set = None
self.data_targets = None
self.file_reader = FileReader()
# these hold our training and testing values after we split the data
self.training_data = None
self.training_targets = None
self.test_data = None
self.test_targets = None
# these values hold the label encoded arrays for working with sklearn's implementation
self.sklearn_training_data = None
self.sklearn_training_targets = None
self.sklearn_testing_data = None
self.sklearn_testing_targets = None
self.most_common = None
self.classifier = None
self.model = None
self.predicted_targets = None
pandas.options.mode.chained_assignment = None
def list_file_recursive(self, path):
"""Print list of given file's contents recursively."""
with FileReader(path, 'rb') as file:
decoder = codec.getDecoderForFile(file)
decoder = decoder(file, None)
items = []
for obj in decoder.objects:
self._list_recursive(obj)
def run(self):
self.emit(QtCore.SIGNAL("update()"))
self.mfcc.frame_size = int(self.par.frameSizeVal.currentText())
self.mfcc.overlap = self.mfcc.frame_size / 2
for index, file_audio in enumerate(self.audio_files):
file_audio = str(file_audio)
self.audio_signal, self.audio_fs = FileReader.read_audio(file_audio)
self.silenced_signal, self.audio_fs = self.mfcc.remove_silence(file_audio)
self.num_frames, self.framed_signal = self.mfcc.frame_blocking(self.silenced_signal)
self.windowed_signal = self.mfcc.hamm_window(self.framed_signal)
self.fft_signal = self.mfcc.calc_fft(self.windowed_signal)
self.log_energy, self.fbank = self.mfcc.fbank(self.fft_signal, self.audio_fs)
self.features = self.mfcc.features(self.log_energy)
# var = [st.variance(self.features[:,i]) for i in xrange(self.mfcc.num_filter)]
# [self.all_features.append(self.features[i,:]) for i in xrange(self.features.shape[0])]
# self.variances.append(var)
features = []
if TYPE == 1:
file_id = self.db.insert("files", {"file_path": file_audio})
for i in xrange(self.features.shape[0]):
# [31, 28, 29, 30, 27, 26, 25, 24, 23, 22, 20, 21, 19
# features.append([file_id, i, self.features[i, 1:14], str(self.par.featuresTbl.item(index,1).text())])
features.append([file_id, i, self.features[i, [1, 2, 3, 4, 5, 7, 6, 9, 8, 10, 11, 12, 13]],
str(self.par.featuresTbl.item(index, 1).text())])
self.db.insert_features(features)
else:
output_class_id = self.db.insert("output_classes",
{"file_path": file_audio,
"class": str(FileReader.get_output_class(file_audio))})
for i in xrange(self.features.shape[0]):
features.append([output_class_id, i, self.features[i, 1:14]])
self.db.insert_features(features)
self.emit(QtCore.SIGNAL("update()"))
# self.variances = np.asarray(self.variances)
# rata2 = [st.mean(self.variances[:,i]) for i in xrange(self.mfcc.num_filter)]
# self.write_excel(rata2)
# print str(np.sort(rata2))
# print str(np.argsort(rata2))
self.emit(QtCore.SIGNAL("finish()"))
def loadloc(self):
filereader = FileReader("../NE_INFO.csv")
neididx = filereader.getattridx("NE_ID")
noidx = filereader.getattridx("NE_NO")
nameidx = filereader.getattridx("NE_NAME")
ididx = filereader.getattridx("ID_IN_NM")
self.m_locdata = []
while True:
tmptran = filereader.readtransection()
if tmptran is None:
break
innminfo = tmptran[ididx]
siteididx = innminfo.find("BtsSiteMgr=BCF-")
if siteididx == -1:
siteididx = innminfo.find("BtsSiteMgr=")
if siteididx == -1:
innm = "-1"
else:
innm = innminfo[siteididx + len("BtsSiteMgr="):]
else:
# innm = innminfo[siteididx+len("BtsSiteMgr=BCF-"):]
innm = "-1"
self.m_locdata.append(
NE(tmptran[noidx], tmptran[nameidx], tmptran[ididx],
tmptran[neididx]))
def include_word(self):
if self.inclWordCheck.isChecked():
for i in xrange(self.featuresTbl.rowCount()):
text = str(self.featuresTbl.item(i, 0).text())
self.featuresTbl.setItem(i, 1, QtGui.QTableWidgetItem(str(FileReader.get_output_class(str(text)))))
else:
for i in xrange(self.featuresTbl.rowCount()):
text = str(self.featuresTbl.item(i, 1).text())
self.featuresTbl.setItem(i, 1, QtGui.QTableWidgetItem(str(text[:text.rfind("-")])))
def shuffle_files(self):
self.audio_files = sample(self.audio_files, len(self.audio_files))
for i in xrange(self.featuresTbl.rowCount()):
self.featuresTbl.setItem(
i, 0, QtGui.QTableWidgetItem(str(self.audio_files[i])))
self.featuresTbl.setItem(
i, 1,
QtGui.QTableWidgetItem(
str(FileReader.get_output_class(str(
self.audio_files[i])))))
def makeFileReader(self, file, mode='rb') -> FileReader:
"""Make a FileReader for the given file,
with default settings for this app.
"""
log.debug("makeFileReader(%s: %s)", file, getattr(file, 'name', None))
if isinstance(file, FileReader): return file
return FileReader(file,
mode,
endian=self.endian,
defaultStringLengthFmt='H')
def calneidlen():
filereader = FileReader("../NE_INFO.csv")
attridx = filereader.getattridx("NE_NO")
lendict = {}
idx = 0
while True:
tmptran = filereader.readtransection()
if tmptran is None:
break
neid = tmptran[attridx]
neidlen = len(neid)
if neidlen not in lendict:
lendict[neidlen] = 0
lendict[neidlen] += 1
idx += 1
print neid
if idx % 100 == 0:
raw_input()
import pprint
pp = pprint.PrettyPrinter(indent=4)
pp.pprint(lendict)
def solve(self):
results = {}
reader = FileReader(self.fileName)
procNum = reader.readline()
taskNum = reader.readline()
execTimes = [reader.readline() for _ in range(taskNum)]
times = []
genetics = [
PCMaxGenetic(execTimes, procNum) for _ in range(self.instNum)
]
for genetic in genetics:
try:
_, cmax = genetic.solve(self.iterNum, self.normIter,
self.mutIter)
times.append(cmax)
except OptimumFoundException, e:
times.append(e.cmax)
break
def process_dump(input_file, out_file, workers_count):
"""
:param input_file: name of the wikipedia dump file; '-' to read from stdin
:param out_file: directory where to store extracted data, or '-' for stdout
:param workers_count: number of extraction processes to spawn.
"""
logging.info("Starting map reduce processes...")
workers_count = max(1, workers_count)
maxsize = 10 * workers_count
# output queue
output_queue = Queue(maxsize=maxsize)
# input queue
jobs_queue = Queue(maxsize=maxsize)
file_reader = FileReader(input_file)
database_writer = DatabaseWriter(config, buffer_size=1000)
# database_writer.check_connection()
workers = []
for i in range(workers_count):
worker = json_processor_class(i)
extractor = Instance(target=worker.execute,
args=(jobs_queue, output_queue))
extractor.daemon = True # only live while parent process lives
extractor.start()
worker.process = extractor
workers.append(worker)
output = Instance(target=database_writer.execute, args=(output_queue, ))
output.start()
output_queue_size = lambda: output_queue.qsize()
# map job that sorts and prints output
map = Instance(target=file_reader.execute,
args=(jobs_queue, output_queue_size))
map.start()
map.join()
logging.info("Completing workers...")
for _ in workers:
jobs_queue.put(None)
for w in workers:
w.process.join()
logging.info("Completing database writer...")
output_queue.put(None)
output.join()
def run(self):
self.emit(QtCore.SIGNAL("update()"))
self.mfcc.frame_size = int(self.par.frameSizeVal.currentText())
self.mfcc.overlap = self.mfcc.frame_size / 2
speaker_correct = 0
speaker_word_correct = 0
for index, file_audio in enumerate(self.audio_files):
file_audio = str(file_audio)
self.audio_signal, self.audio_fs = FileReader.read_audio(
file_audio)
self.silenced_signal, self.audio_fs = self.mfcc.remove_silence(
file_audio)
self.num_frames, self.framed_signal = self.mfcc.frame_blocking(
self.silenced_signal)
self.windowed_signal = self.mfcc.hamm_window(self.framed_signal)
self.fft_signal = self.mfcc.calc_fft(self.windowed_signal)
self.log_energy, self.fbank = self.mfcc.fbank(
self.fft_signal, self.audio_fs)
self.features = self.mfcc.features(self.log_energy)
self.lvq = LVQ(str(self.par.databaseSelect.currentText()))
# result = self.lvq.test_data(self.features[:, 1:14])
# [31, 28, 29, 30, 27, 26, 25, 24, 23, 22, 20, 21, 19]
result = self.lvq.test_data(
self.features[:, [1, 2, 3, 4, 5, 7, 6, 9, 8, 10, 11, 12, 13]])
print "vote for file " + str(index) + " : " + str(result)
# full = str(result[1][0]) if len(result) >= 2 else str(result[0][0])
full = str(result[0][0])
speaker = full[:full.rfind('-')] if full.rfind('-') != -1 else full
word = full[full.rfind('-') + 1:] if full.rfind('-') != -1 else "-"
self.par.featuresTbl.setItem(index, 2,
QtGui.QTableWidgetItem(speaker))
self.par.featuresTbl.setItem(index, 3,
QtGui.QTableWidgetItem(word))
if speaker == self.par.featuresTbl.item(index, 0).text():
speaker_correct += 1
if speaker == self.par.featuresTbl.item(
index, 0).text() and word == self.par.featuresTbl.item(
index, 1).text():
speaker_word_correct += 1
self.par.speaker_word_acc = (speaker_word_correct /
float(len(self.audio_files))) * 100
self.par.speaker_only_acc = (speaker_correct /
float(len(self.audio_files))) * 100
self.emit(QtCore.SIGNAL("update()"))
self.emit(QtCore.SIGNAL("finish()"))
def include_word(self):
if self.inclWordCheck.isChecked():
for i in xrange(self.featuresTbl.rowCount()):
text = str(self.featuresTbl.item(i, 0).text())
self.featuresTbl.setItem(
i, 1,
QtGui.QTableWidgetItem(
str(FileReader.get_output_class(str(text)))))
else:
for i in xrange(self.featuresTbl.rowCount()):
text = str(self.featuresTbl.item(i, 1).text())
self.featuresTbl.setItem(
i, 1, QtGui.QTableWidgetItem(str(text[:text.rfind("-")])))
def show_open_dialog(self):
audioFiles = QtGui.QFileDialog.getOpenFileNames(self, 'Open audio file',
'',
"Audio Files (*.wav)",
None, QtGui.QFileDialog.DontUseNativeDialog)
self.featuresTbl.setColumnWidth(0, 300)
for file in audioFiles:
self.audio_files.append(file)
currentRow = self.featuresTbl.rowCount()
self.featuresTbl.insertRow(currentRow)
self.featuresTbl.setItem(currentRow, 0, QtGui.QTableWidgetItem(str(file)))
self.featuresTbl.setItem(currentRow, 1, QtGui.QTableWidgetItem(str(FileReader.get_output_class(str(file)))))
self.audioFilenameLbl.setText(": " + str(len(self.audio_files)))
def testwrongfile():
filereader = FileReader("../wrongdocfile")
alarmcodeidx = filereader.getattridx("ALARMCODE")
attridx = filereader.getattridx("SUMMARY")
locidx = filereader.getattridx("LOCATION")
timeidx = filereader.getattridx("ALARMHAPPENTIME")
print "idxdata:", timeidx, alarmcodeidx, locidx, attridx
print filereader.m_header
print filereader.m_headerlen
while True:
tmptran = filereader.readtransection()
if tmptran is None:
filereader.close()
break
summary = tmptran[attridx]
location = tmptran[locidx]
alarmcode = tmptran[alarmcodeidx]
timestr = tmptran[timeidx]
print tmptran
raw_input()
def printidentifier():
filereader = FileReader("../1022.csv")
identifieridx = filereader.getattridx("NEIDENTIFIER")
while True:
tmptran = filereader.readtransection()
identifier = tmptran[identifieridx]
if tmptran is None:
filereader.close()
break
print identifier
raw_input()
def update_stream(self):
if len(
self.test_files) and (
self.stream is None or not self.stream.is_alive()):
self.stream = FileReader(self.test_files.pop())
self.active = True
self.reset_data()
self.stream.start()
elif not self.stream.is_alive():
self.img = Image.open("Googlemapslogo2014.png")
self.img = self.img.convert("RGB")
self.photo_image = ImageTk.PhotoImage(self.img)
self.canvas.create_image(250, 250, image=self.photo_image)
self.active = False
self.after(1000, self.update_stream)
def __init__(self):
self.iris = datasets.load_iris()
# this is determined by whether we read from a file or not
self.data_set = None
self.data_targets = None
self.file_reader = FileReader()
# these hold our training and testing values after we split the data
self.training_data = None
self.training_targets = None
self.test_data = None
self.test_targets = None
self.classifier = None
self.model = None
self.predicted_targets = None
def addmesh(self, meshfilelocation, pixelrange):
meshfile = FileReader(meshfilelocation, "read")
meshdata = []
color = [255, 255, 255]
complete = False
width = 1
for x in meshfile.fileOutput:
if "color" in x:
color = list(map(int, x.split("=")[1].split(" ")))
elif "linewidth" in x:
width = int(x.split("=")[1])
elif "complete" in x:
complete = bool(x.split("=")[1])
else:
meshdata.append(list(map(int, x.split(" "))))
self.drawMeshList.append(
Mesh(meshdata, pixelrange, color, complete, width))
def show_open_dialog(self):
audioFiles = QtGui.QFileDialog.getOpenFileNames(
self, 'Open audio file', '', "Audio Files (*.wav)", None,
QtGui.QFileDialog.DontUseNativeDialog)
self.featuresTbl.setColumnWidth(0, 300)
for file in audioFiles:
self.audio_files.append(file)
currentRow = self.featuresTbl.rowCount()
self.featuresTbl.insertRow(currentRow)
self.featuresTbl.setItem(currentRow, 0,
QtGui.QTableWidgetItem(str(file)))
self.featuresTbl.setItem(
currentRow, 1,
QtGui.QTableWidgetItem(
str(FileReader.get_output_class(str(file)))))
self.audioFilenameLbl.setText(": " + str(len(self.audio_files)))
def show_open_dialog(self):
audioFiles = QtGui.QFileDialog.getOpenFileNames(self, 'Open audio file',
'',
"Audio Files (*.wav)",
None, QtGui.QFileDialog.DontUseNativeDialog)
for file in audioFiles:
self.indic = 4 if str(file).rfind('4 Detik') != -1 else 8
speaker = str(FileReader.get_output_class(str(file)))
word = speaker[speaker.rfind('-')+1:] if speaker.rfind('-') != -1 else ""
self.audio_files.append(file)
currentRow = self.featuresTbl.rowCount()
self.featuresTbl.insertRow(currentRow)
self.featuresTbl.setItem(currentRow, 0, QtGui.QTableWidgetItem(str(speaker[:speaker.rfind('-')])))
self.featuresTbl.setItem(currentRow, 1, QtGui.QTableWidgetItem(str(word)))
self.audioFilenameLbl.setText(": " + str(len(self.audio_files)))
self.startTestBtn.setDisabled(False)
self.frameSizeVal.setDisabled(False)
def run(self):
self.emit(QtCore.SIGNAL("update()"))
self.mfcc.frame_size = int(self.par.frameSizeVal.currentText())
self.mfcc.overlap = self.mfcc.frame_size/2
speaker_correct = 0
speaker_word_correct = 0
for index,file_audio in enumerate(self.audio_files):
file_audio = str(file_audio)
self.audio_signal, self.audio_fs = FileReader.read_audio(file_audio)
self.silenced_signal, self.audio_fs = self.mfcc.remove_silence(file_audio)
self.num_frames, self.framed_signal = self.mfcc.frame_blocking(self.silenced_signal)
self.windowed_signal = self.mfcc.hamm_window(self.framed_signal)
self.fft_signal = self.mfcc.calc_fft(self.windowed_signal)
self.log_energy, self.fbank = self.mfcc.fbank(self.fft_signal, self.audio_fs)
self.features = self.mfcc.features(self.log_energy)
self.lvq = LVQ(str(self.par.databaseSelect.currentText()))
# result = self.lvq.test_data(self.features[:, 1:14])
# [31, 28, 29, 30, 27, 26, 25, 24, 23, 22, 20, 21, 19]
result = self.lvq.test_data(self.features[:, [1, 2, 3, 4, 5, 7, 6, 9, 8, 10, 11, 12, 13]])
print "vote for file " + str(index) + " : " + str(result)
# full = str(result[1][0]) if len(result) >= 2 else str(result[0][0])
full = str(result[0][0])
speaker = full[:full.rfind('-')] if full.rfind('-') != -1 else full
word = full[full.rfind('-')+1:] if full.rfind('-') != -1 else "-"
self.par.featuresTbl.setItem(index, 2, QtGui.QTableWidgetItem(speaker))
self.par.featuresTbl.setItem(index, 3, QtGui.QTableWidgetItem(word))
if speaker == self.par.featuresTbl.item(index,0).text():
speaker_correct += 1
if speaker == self.par.featuresTbl.item(index,0).text() and word == self.par.featuresTbl.item(index,1).text():
speaker_word_correct += 1
self.par.speaker_word_acc = (speaker_word_correct / float(len(self.audio_files))) * 100
self.par.speaker_only_acc = (speaker_correct / float(len(self.audio_files))) * 100
self.emit(QtCore.SIGNAL("update()"))
self.emit(QtCore.SIGNAL("finish()"))
def shuffle_files(self):
self.audio_files = sample(self.audio_files, len(self.audio_files))
for i in xrange(self.featuresTbl.rowCount()):
self.featuresTbl.setItem(i, 0, QtGui.QTableWidgetItem(str(self.audio_files[i])))
self.featuresTbl.setItem(i, 1, QtGui.QTableWidgetItem(str(FileReader.get_output_class(str(self.audio_files[i])))))
class Mips:
def __init__(self):
self.inicio()
self.fr = FileReader()
def addListaMemoria(self, endereco):
cont = -1
for i in self.listaMemoria:
cont = cont + 1
if i[0] == endereco:
del self.listaMemoria[cont]
self.listaMemoria.append([endereco, str(eval(self.mem[endereco].valor))])
if len(self.listaMemoria) > 4:
self.listaMemoria = self.listaMemoria[-4:]
def getListaMemoria(self, i):
if len(self.listaMemoria) < i:
return ["", ""]
else:
return self.listaMemoria[-i]
def addDesbloqueio(self, destino):
self.listaDeDesbloqueio.append(destino)
def ClockDesbloquear(self):
for i in self.listaDeDesbloqueio:
i.desbloquear()
self.listaDeDesbloqueio = []
def read(self, filePath):
self.fr.read(filePath)
def inicio(self):
self.clock = 0
self.pc = bin(0)
self.concluidas = 0
self.produtividade = 0
self.E1 = InstructionFetch(1, self)
self.E2 = InstructionDecodeRegisterFetch(2, self)
self.E3 = InstructionExecute(3, self)
self.E4 = MemoryAccess(4, self)
self.E5 = WriteBack(5, self)
self.E1.setNop()
self.E2.setNop()
self.E3.setNop()
self.E4.setNop()
self.E5.setNop()
self.end1 = None
self.val1 = None
self.end2 = None
self.val2 = None
self.end3 = None
self.val3 = None
self.end4 = None
self.val4 = None
self.mem = []
for i in range(0, 2**15):
self.mem.append(Registrador())# vc pode checar o tamanho com len(self.mem) e acessar cada posicao
# independentemente com self.mips.mem[i] dai para manipular os 32 bits podemos
# mexer com os valores binarios e decimais
self.reg = []
for i in range(0, 2**5):
self.reg.append(Registrador())
self.avancapc = False
self.listaDeDesbloqueio = []
self.listaMemoria = []
def setView(self, view):
self.view = view
def memoryAccess(self):
pass
def writeBack(self):
pass
def proxEstagio(self):
self.clock = self.clock + 1
self.ClockDesbloquear()
if not self.E5.bloqueado:
if not self.E5.desbloqueou:
if self.E5.instrucao.__class__.__name__ != "Nop":
self.concluidas = self.concluidas + 1
if not self.E4.bloqueado:
if not self.E4.desbloqueou:
self.E5.setInstrucao(self.E4.instrucao)
self.E5.do()
if not self.E3.bloqueado:
if not self.E3.desbloqueou:
self.E4.setInstrucao(self.E3.instrucao)
self.E4.do()
if not self.E2.bloqueado:
if not self.E2.desbloqueou:
self.E3.setInstrucao(self.E2.instrucao)
self.E3.do()
if not self.E1.bloqueado:
if not self.E1.desbloqueou:
self.E2.setInstrucao(self.E1.instrucao)
self.E2.do()
if not self.avancapc:
self.avancapc = True
else:
self.pc = bin(eval(self.pc) + 4)
self.E1.setInstrucao(self.E2.decodInst(self.E1.do(eval(self.pc)/4)))
else:
self.E2.setNop()
self.E1.desbloqueou = False
self.E1.do()
else:
self.E2.setNop()
else:
self.E3.setNop()
self.E2.desbloqueou = False
self.E2.do()
else:
self.E3.setNop()
else:
self.E4.setNop()
self.E3.desbloqueou = False
self.E3.do()
else:
self.E4.setNop()
else:
self.E5.setNop()
self.E4.desbloqueou = False
self.E4.do()
else:
self.E5.setNop()
else:
self.E5.desbloqueou = False
self.E5.do()
self.produtividade = float(self.concluidas)/self.clock
self.atualizarLabels()
def setText(self, label, ori, none):
if ori is not None:
label["text"] = ori
else:
label["text"] = none
def atualizarLabels(self):
if self.view is not None:
self.setText(self.view.E1_instrucao, self.E1.InstName, "")
self.setText(self.view.E2_instrucao, self.E2.InstName, "")
self.setText(self.view.E3_instrucao, self.E3.InstName, "")
self.setText(self.view.E4_instrucao, self.E4.InstName, "")
self.setText(self.view.E5_instrucao, self.E5.InstName, "")
self.setText(self.view.E1_controle, self.E1.SinControle, "")
self.setText(self.view.E2_controle, self.E2.SinControle, "")
self.setText(self.view.E3_controle, self.E3.SinControle, "")
self.setText(self.view.E4_controle, self.E4.SinControle, "")
self.setText(self.view.E5_controle, self.E5.SinControle, "")
self.view.lclock["text"] = self.clock
self.view.lpc["text"] = str(eval(self.pc))
self.view.lconcluidas["text"] = self.concluidas
self.view.lprodutividade["text"] = "{0:.2f}".format(100*self.produtividade)+"%"
self.setText(self.view.lend1, self.getListaMemoria(1)[0], "")
self.setText(self.view.lval1, self.getListaMemoria(1)[1], "?")
self.setText(self.view.lend2, self.getListaMemoria(2)[0], "")
self.setText(self.view.lval2, self.getListaMemoria(2)[1], "?")
self.setText(self.view.lend3, self.getListaMemoria(3)[0], "")
self.setText(self.view.lval3, self.getListaMemoria(3)[1], "?")
self.setText(self.view.lend4, self.getListaMemoria(4)[0], "")
self.setText(self.view.lval4, self.getListaMemoria(4)[1], "?")
self.view.lr0["text"] = str(eval(self.reg[0].valor))
self.view.lr1["text"] = str(eval(self.reg[1].valor))
self.view.lr2["text"] = str(eval(self.reg[2].valor))
self.view.lr3["text"] = str(eval(self.reg[3].valor))
self.view.lr4["text"] = str(eval(self.reg[4].valor))
self.view.lr5["text"] = str(eval(self.reg[5].valor))
self.view.lr6["text"] = str(eval(self.reg[6].valor))
self.view.lr7["text"] = str(eval(self.reg[7].valor))
self.view.lr8["text"] = str(eval(self.reg[8].valor))
self.view.lr9["text"] = str(eval(self.reg[9].valor))
self.view.lr10["text"] = str(eval(self.reg[10].valor))
self.view.lr11["text"] = str(eval(self.reg[11].valor))
self.view.lr12["text"] = str(eval(self.reg[12].valor))
self.view.lr13["text"] = str(eval(self.reg[13].valor))
self.view.lr14["text"] = str(eval(self.reg[14].valor))
self.view.lr15["text"] = str(eval(self.reg[15].valor))
self.view.lr16["text"] = str(eval(self.reg[16].valor))
self.view.lr17["text"] = str(eval(self.reg[17].valor))
self.view.lr18["text"] = str(eval(self.reg[18].valor))
self.view.lr19["text"] = str(eval(self.reg[19].valor))
self.view.lr20["text"] = str(eval(self.reg[20].valor))
self.view.lr21["text"] = str(eval(self.reg[21].valor))
self.view.lr22["text"] = str(eval(self.reg[22].valor))
self.view.lr23["text"] = str(eval(self.reg[23].valor))
self.view.lr24["text"] = str(eval(self.reg[24].valor))
self.view.lr25["text"] = str(eval(self.reg[25].valor))
self.view.lr26["text"] = str(eval(self.reg[26].valor))
self.view.lr27["text"] = str(eval(self.reg[27].valor))
self.view.lr28["text"] = str(eval(self.reg[28].valor))
self.view.lr29["text"] = str(eval(self.reg[29].valor))
self.view.lr30["text"] = str(eval(self.reg[30].valor))
self.view.lr31["text"] = str(eval(self.reg[31].valor))
def __init__(self):
self.units_ = FileReader.read_units(UNITS)
class TripSimulator(tkinter.Tk):
def __init__(self, *files):
super(TripSimulator, self).__init__()
self.title("Trip Simulator")
self.img = Image.open("Googlemapslogo2014.png")
self.img = self.img.convert("RGB")
self.photo_image = ImageTk.PhotoImage(self.img)
self.canvas = tkinter.Canvas(self, width=500, height=500)
self.canvas.create_image(250, 250, image=self.photo_image)
self.canvas.pack()
self.last_position = None
self.last_speed = None
self.last_direction = None
self.inter_lat = None
self.inter_lng = None
self.center = np.array([250, 250]) # Center of screen
self.bind("<Key>", self.handle_key_press)
self.cli = googlemaps.Client(
key="AIzaSyCehm2J69ZTy8Z-10FwDDgVZb5l0k0PFEE")
self.coord_mem_cap = 5 # capacity = 5
self.test_files = list(files)
self.stream = None
self.map = Maps()
self.update_stream()
self.address_lookup = Thread()
self.turning = {} # Dictionary to be filled with points and a timer, for marking turns
# Current street address (derived from coords)
self.street_address = None
self.coord_mem = deque() # Remember few last coords for the turn line
self.coord_mem_cap = 5 # capacity = 5
self.adding_turn_signals = False # For creating new data set with turn signals
self.signal_blink_time = time.time()
self.velocities = []
self.update_image() # Periodic tasks
self.mainloop()
def handle_key_press(self, key):
if key.keycode == 1769515: # "+"
self.stream.change_speed_by(1.5) # speed up stream
elif key.keycode == 2883629: # "-"
self.stream.change_speed_by(1 / 1.5) # slow down stream
elif key.keycode == 983154: # "r"
self.stream.record = not self.stream.record
elif key.keycode == 720994: # "b"
self.stream.rewind = 30
self.reset_data()
elif key.keycode == 1114228: # "t" : Add turn signals to new dataset
if not self.adding_turn_signals:
self.stream.rewind = 7
lock, data = self.stream.get_data()
with lock:
self.stream.add_line = "right" if data[
'steering_wheel_angle'][-1][0] < 0 else "left"
self.adding_turn_signals = True
else:
self.stream.add_line = "off"
self.adding_turn_signals = False
elif key.keycode == 3473435: # "esc" : Exit logic
if self.stream.line_indices:
data = open(self.stream.url).readlines()
for i, val in self.stream.line_indices:
data[i:i] = json.dumps({
"name": "turn_signals",
"value": val,
"timestamp": json.loads(data[i])['timestamp']
}) + '\n'
open(
self.stream.url[
:-
5] +
"_turn_sigs.json",
"w").write(
"".join(data))
self.destroy()
exit()
elif key.keycode == 65651: # "s" save speed_limits
self.stream.calculate_speed_limits()
else:
print("Key =", key.keycode)
def update_stream(self):
if len(
self.test_files) and (
self.stream is None or not self.stream.is_alive()):
self.stream = FileReader(self.test_files.pop())
self.active = True
self.reset_data()
self.stream.start()
elif not self.stream.is_alive():
self.img = Image.open("Googlemapslogo2014.png")
self.img = self.img.convert("RGB")
self.photo_image = ImageTk.PhotoImage(self.img)
self.canvas.create_image(250, 250, image=self.photo_image)
self.active = False
self.after(1000, self.update_stream)
def reset_data(self):
self.last_position = None
self.street_address = None
self.turning = {} # Dictionary to be filled with points and a timer, for marking turns
# Current street address (derived from coords)
self.street_address = None
self.coord_mem = deque() # Remember few last coords for the turn line
def update_image(self):
if not self.active:
return
lock, data = self.stream.get_data()
with lock:
lat = data[
'latitude'][-1][0] if len(data['latitude']) > 0 else None
lng = data[
'longitude'][-1][0] if len(data['longitude']) > 0 else None
speed = data[
'vehicle_speed'][-1][0] if len(data['vehicle_speed']) > 0 else None
speed_limit = data[
'speed_limit'][-1][0] if len(data['speed_limit']) > 0 else None
wheel_angle = data[
'steering_wheel_angle'][-1][0] if len(data['steering_wheel_angle']) > 0 else None
turn_signal = data[
'turn_signals'][-1][0] if len(data['turn_signals']) > 0 else None
del data # delete reference
if lat is not None and lng is not None:
if self.last_position is None:
self.last_position = (lat, lng)
self.interpolate_time = time.time()
elif self.last_position[0] != lat or self.last_position[1] != lng:
self.last_direction = (
lat - self.last_position[0],
lng - self.last_position[1])
self.last_position = (lat, lng)
self.interpolate_time = time.time()
self.inter_lat, self.inter_lng = lat, lng
self.check_turning(lat, lng, wheel_angle)
else:
if self.last_speed is not None and speed is not None and self.last_direction is not None:
self.interpolate(speed)
lat, lng = self.inter_lat, self.inter_lng
marker, turn_circle = self.make_marker_and_turn_signal(turn_signal)
self.last_speed = speed
self.redraw_elements(
lat,
lng,
speed,
speed_limit,
marker,
turn_circle,
wheel_angle)
self.after(50, self.update_image)
def interpolate(self, speed):
r = np.array(self.last_direction)
r /= np.linalg.norm(r)
# 2.5 is a magic constant :-(
r *= 0.5 / 3.6 / 1.4 * (self.last_speed + speed) * \
(time.time() - self.interpolate_time) * self.stream.get_speed()
self.interpolate_time = time.time()
self.inter_lat += r[0] / 111111
self.inter_lng += r[1] / (111111 * cos(self.inter_lat / 360 * 2 * pi))
def make_marker_and_turn_signal(self, turn_signal):
if self.last_direction is None:
marker = (self.center[0] - 5, self.center[1] - 5,
self.center[0] + 5, self.center[1] - 5,
self.center[0] + 5, self.center[1] + 5,
self.center[0] - 5, self.center[1] + 5)
else:
# [lng - self.last_position[1], lat - self.last_position[0]] # retningsvektor
r = self.last_direction[::-1]
ortog = [1, 1] # orthogonal vektor
if r[0] == 0:
ortog[1] = 0
elif r[1] == 0:
ortog[0] = 0
else:
ortog[1] = -r[0] / r[1]
r = np.array(r) # Linear algebra vector
ortog = np.array(ortog)
# Normaliserer til lengde 20
r = r * 20 / np.linalg.norm(r)
ortog = ortog * 20 / np.linalg.norm(ortog)
r[1] *= -1
ortog[1] *= -1
if r[0] * (-1) * ortog[1] + r[1] * \
ortog[0] > 0: # Ensure ortog points to the right
ortog *= -1
marker = list(self.center - 0.5 * r - ortog * 0.3) + \
list(self.center + r * 0.5) + list(self.center - 0.5 * r + ortog * 0.3)
turn_circle = None
if turn_signal == "left":
turn_circle = list(
map(list, [self.center + 0.5 * r - ortog * 0.3 + radius for radius in [-3, 3]]))
elif turn_signal == "right":
turn_circle = list(
map(list, [self.center + 0.5 * r + ortog * 0.3 + radius for radius in [-3, 3]]))
return marker, turn_circle
def check_turning(self, lat, lng, wheel_angle):
self.coord_mem.append((lat, lng))
if self.coord_mem_cap < len(self.coord_mem):
self.coord_mem.popleft()
if self.turning: # Evaluate as bool
if len(self.turning['coords']) > 2 and 0.0003 < \
np.linalg.norm(np.array(self.turning['coords'][-1] - np.array(self.turning['coords'][0]))) \
and 4 < time.time() - self.turning['time']:
self.turning = {}
else:
self.turning['coords'].append((lat, lng))
return
if wheel_angle is None or abs(wheel_angle) < 150:
return
if not self.address_lookup.is_alive():
self.address_lookup = Thread(
target=self.lookup_address, args=(lat, lng))
self.address_lookup.start()
def lookup_address(self, lat, lng):
address = self.street_address
try: # Haults (stucks) after quota of 2500 lookups per day.
response = self.cli.reverse_geocode(
(lat, lng), result_type="route")
response = response[0]
for line in response['address_components']:
if 'route' in line['types']:
address = line['long_name']
break
except Exception as e:
print(e)
if self.street_address is None:
self.street_address = address
elif address != self.street_address:
self.turning = {
'time': time.time(),
'coords': list(
self.coord_mem)}
self.street_address = address
if time.time() - self.signal_blink_time > 3:
print("\a\a\a", end="")
stdout.flush()
def redraw_elements(
self,
lat,
lng,
speed,
speed_limit,
marker,
turn_circle,
wheel_angle):
self.canvas.delete("all")
self.img = self.map[lat, lng]
self.photo_image = ImageTk.PhotoImage(self.img)
self.canvas.create_image(250, 250, image=self.photo_image)
self.canvas.create_polygon(marker, fill="blue")
if turn_circle is not None:
if 0.250 < time.time() - self.signal_blink_time:
self.canvas.create_oval(
*turn_circle, fill="orange", outline="orange")
if 0.500 < time.time() - self.signal_blink_time:
self.signal_blink_time = time.time()
if self.stream.record:
self.canvas.create_oval(490, 15, 500, 5, fill="red")
self.canvas.create_rectangle(0, 0, 150, 80, fill="white")
self.canvas.create_text((10, 5), anchor="nw", text="Play speed: " +
format(self.stream.get_speed(), '.1f') + "x")
self.canvas.create_text((10, 20), anchor="nw", text="Velocity: " +
(format(speed, '.1f') + " km/h" if speed is not None else "?"))
self.canvas.create_text((10, 35), anchor="nw", text="Speed limit: " +
(format(speed_limit, '.1f') if speed_limit is not None else "?"))
speeding = "Unknown"
color = "black"
if speed is not None and speed_limit is not None:
if speed <= speed_limit:
speeding = "No"
color = "green"
else:
speeding = "Yes"
color = "red"
self.canvas.create_text(
(10, 50), anchor="nw", text="Speeding: " + speeding, fill=color)
self.canvas.create_text((10, 65), anchor="nw", text="Wheel rotation: " + (
format(abs(wheel_angle), '.0f') if wheel_angle is not None else "?"))
def fetch_img(self, lat, lng):
req = self.build_request(lat, lng)
response = requests.get(req)
if response.ok:
parser = ImageFile.Parser()
parser.feed(response.content)
image = parser.close()
return image
else:
raise Exception("Could not fetch map image")
def build_request(self, lat, lng):
col = "%3A" # URL encoding for :
pip = "%7C"
s = "https://maps.googleapis.com/maps/api/staticmap?" + \
"key=AIzaSyCehm2J69ZTy8Z-10FwDDgVZb5l0k0PFEE" + "&" + \
"center=" + str(lat) + "," + str(lng) + "&" + \
"zoom=17" + "&" + \
"size=500x500"
if self.turning:
s += "&path=color" + col + "0x0000ffff" + pip + "weight" + col + "5" + \
pip.join(str(tup[0]) + "," + str(tup[1]) for tup in self.turning['coords'])
print(s)
return s
def remove_silence(self, audio):
call(['sox', audio, FileReader.add_temp(audio), 'silence', self.above_period, self.duration, self.threshold, self.below_period, self.duration, self.threshold])
silenced_signal, silenced_fs = FileReader.read_audio(FileReader.add_temp(audio))
os.remove(FileReader.add_temp(audio))
return [silenced_signal, silenced_fs]
def __init__(self): self.inicio() self.fr = FileReader()
def __init__(self,filename):
self.process = Process() # Creats an object
self.reader = FileReader(filename,self.process) # Creates an object
self.reader.run() # call the run method
self.process.workOut()
