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()