class MyForm(QtGui.QMainWindow): def showMessage(self,string): self.ui.messageTextbox.setText(string) def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) #here start downloader.fileLabel = self.ui.fileLabel downloader.nowSizeLabel = self.ui.nowSizeLabel downloader.totalSizeLabel = self.ui.totalSizeLabel downloader.messageTextbox = self.ui.messageTextbox #pass para self.connect(self.ui.aButton,QtCore.SIGNAL('clicked()'),self.aButton_clicked) self.connect(self.ui.bButton,QtCore.SIGNAL('clicked()'),self.bButton_clicked) self.connect(self.ui.aAfternoonButton,QtCore.SIGNAL('clicked()'),self.aAfternoonButton_clicked) self.connect(self.ui.bAfternoonButton,QtCore.SIGNAL('clicked()'),self.bAfternoonButton_clicked) self.connect(self.ui.downloadPercentButton,QtCore.SIGNAL('clicked()'),self.downloadPercentButton_clicked) self.connect(self.ui.nextButton,QtCore.SIGNAL('clicked()'),self.nextButton_clicked) #event def aButton_clicked(self): thread.start_new_thread(downloader.main,(1,True)) def bButton_clicked(self): thread.start_new_thread(downloader.main,(0,True)) def aAfternoonButton_clicked(self): thread.start_new_thread(downloader.main,(1,False)) def bAfternoonButton_clicked(self): thread.start_new_thread(downloader.main,(0,False)) def nextButton_clicked(self): downloader.goNext = True def downloadPercentButton_clicked(self): downloader.refreshPercent()
class Test(QMainWindow): def __init__(self, parent=None): super(Test, self).__init__(parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.btn1 = self.ui.pushButton self.btn1.clicked.connect(self.make_clientid) self.btn3 = self.ui.pushButton_3 self.btn3.clicked.connect(self.make_token) self.btn2 = self.ui.pushButton_2 self.btn2.clicked.connect(self.tootstatus) def make_clientid(self): appname = self.ui.lineEdit.text() url = self.ui.lineEdit_2.text() cid_file = 'client_id.txt' Mastodon.create_app(appname, api_base_url=url, to_file=cid_file) with open(cid_file) as ci: self.ui.lineEdit_3.setText(ci.read()) def make_token(self): clientid = "client_id.txt" url = self.ui.lineEdit_4.text() email = self.ui.lineEdit_5.text() password = self.ui.lineEdit_6.text() token = "access_token.txt" mastodon = Mastodon( client_id=clientid, api_base_url=url, ) mastodon.log_in(username=email, password=password, to_file=token) with open(token) as at: self.ui.lineEdit_7.setText(at.read()) def tootstatus(self): url = self.ui.lineEdit_4.text() cid_file = 'client_id.txt' token_file = 'access_token.txt' mastodon = Mastodon(client_id=cid_file, access_token=token_file, api_base_url=url) status = self.ui.textEdit.toPlainText() count = self.ui.spinBox.value() cw = self.ui.radioButton.isChecked() cwstatus = self.ui.lineEdit_8.text() visibility = self.ui.comboBox.currentText() print(status) print(count) print(cw) print(cwstatus) print(visibility) for i in range(count): if cw == True: mastodon.status_post(status=status, spoiler_text=cwstatus, visibility=visibility) else: mastodon.status_post(status=status, visibility=visibility)
class Gui(QtGui.QMainWindow): def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.video = Video(cv2.VideoCapture(0)) self._timer = QtCore.QTimer(self) self._timer.timeout.connect(self.play) self._timer.start(27) self.update() def play(self): ''' capture frame and display ''' try: self.video.capture_next_frame() self.ui.videoFrame.setPixmap( self.video.convert_frame()) self.ui.videoFrame.setScaledContents(True) except TypeError: print "No frame" def mousePressEvent(self, event): ''' click mouse and put point on opencv window ''' self.video.add_point(QtCore.QPoint(event.pos()), self.ui.videoFrame.geometry())
class CurrencyConv(QtWidgets.QMainWindow): def __init__(self): super(CurrencyConv, self).__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.init_UI() def init_UI(self): self.setWindowTitle('Конвертер валют') self.setWindowIcon(QIcon('photo.png')) self.ui.input_currency.setPlaceholderText('Из валюты:') self.ui.input_amount.setPlaceholderText('У меня есть:') self.ui.output_currency.setPlaceholderText('В валюту:') self.ui.output_amount.setPlaceholderText('Я получу:') self.ui.pushButton.clicked.connect(self.converter) def converter(self): c = CurrencyConverter() input_currency = self.ui.input_currency.text() output_currency = self.ui.output_currency.text() input_amount = int(self.ui.input_amount.text()) output_amount = round( c.convert(input_amount, '%s' % input_currency, '%s' % output_currency), 2) self.ui.output_amount.setText(str(output_amount))
class CurrencyConv(QtWidgets.QMainWindow): def __init__(self): super(CurrencyConv, self).__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.init_UI() def init_UI(self): self.setWindowTitle('Currency Converter') self.setWindowIcon(QIcon('exchange.png')) self.ui.input_currency.setPlaceholderText('from currency:') self.ui.input_amount.setPlaceholderText('i have:') self.ui.output_currency.setPlaceholderText('to currency') self.ui.output_amount.setPlaceholderText('i will get:') self.ui.pushButton.clicked.connect(self.converter) def converter(self): c = CurrencyConverter() input_currency = self.ui.input_currency.text() output_currency = self.ui.output_currency.text() input_amount = int(self.ui.input_amount.text()) output_amount = round( c.convert(input_amount, '%s' % (input_currency), '%s' % (output_currency)), 2) self.ui.output_amount.setText(str(output_amount))
class TranslateText(QtWidgets.QMainWindow): def __init__(self): super(TranslateText, self).__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.init_UI() def init_UI(self): self.setWindowTitle('Google Translate') self.ui.btn_translate.clicked.connect(self.translate) self.ui.btn_check_lang.setDown(True) self.ui.btn_eng_lang.clicked.connect(self.translate_into_en) self.ui.btn_ru_lang.clicked.connect(self.translate_into_ru) self.ui.btn_ge_lang.clicked.connect(self.translate_into_de) def translate_into_en(self): global selected_language selected_language = 'en' def translate_into_ru(self): global selected_language selected_language = 'ru' def translate_into_de(self): global selected_language selected_language = 'de' def translate(self): global selected_language input_text = self.ui.input_text.toPlainText() translated_text = translator.translate(input_text, dest=f'{selected_language}') self.ui.output_text.setPlainText(translated_text.text)
class MainWindow(QMainWindow): def __init__(self): super(MainWindow, self).__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.setWindowTitle("SyphmoTracker")
class StartQT4(QtGui.QMainWindow): def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.clidict = Param_To_Cli() self.ui.interface_choice.addItems(netifaces.interfaces()) QtCore.QObject.connect( self.ui.start, QtCore.SIGNAL("clicked()"), self.start_sniffer) # QtCore.QObject.connect( # self.ui.interface_choice, QtCore.SIGNAL("activated(const QString&)"), self.get_interface) # # QtCore.QObject.connect( # self.ui.mode_choice, QtCore.SIGNAL("activated(const QString&)"), self.get_mode) # QtCore.QObject.connect( # self.ui.lineEdit, QtCore.SIGNAL("editingFinished()"), self.get_filter) def start_sniffer(self): self.clidict.interface = str(self.ui.interface_choice.currentText()) self.clidict.mode = str(self.ui.mode_choice.currentText()) self.clidict.filter = str(self.ui.lineEdit.text()) log.debug(self.clidict.interface + '' + self.clidict.mode + '' + self.clidict.filter) sniffer_prepare(self.clidict) self.sniff_queue = Queue() sniffer = SnifferProcess( self.sniff_queue, iface=self.clidict.interface) sniffer.start() while True: item = self.sniff_queue.get() self.ui.packet_list.addItem(item.summary()) QtGui.QApplication.processEvents()
class Gui(QtGui.QMainWindow): def __init__(self,capture, getFrame, parent = None): QtGui.QWidget.__init__(self,parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.video = Video(capture, getFrame) self._timer = QtCore.QTimer(self) self._timer.timeout.connect(self.play) self._timer.start(27) self.update() def play(self): try: self.video.captureNextFrame() self.ui.videoFrame.setPixmap(self.video.convertFrame()) self.ui.videoFrame.setScaledContents(True) gethistogram(self.ui.axes,tuple(self.video.histogram.values()),tuple(self.video.histogram.keys())) # l = [random.randint(0, 10) for i in range(4)] # self.ui.axes.plot(self.video.histogram.values(), 'r') self.ui.canvas.draw() if(len(self.video.labels)!=0): self.ui.label1.setText(self.video.name) # self.ui.label2.setText(self.video.labels[1]) # self.ui.label3.setText(self.video.labels[2]) # self.ui.label4.setText(self.video.labels[3]) # self.ui.label5.setText(self.video.labels[4]) except TypeError as e: print("No Frame", e)
class main(QtGui.QMainWindow): def __init__(self,parent=None): QtGui.QWidget.__init__(self,parent) self.file_dialog=QtGui.QFileDialog() self.ui=Ui_MainWindow() self.ui.setupUi(self) self.fn=None QtCore.QObject.connect(self.ui.action_Save,QtCore.SIGNAL("triggered()"),self.save_file) QtCore.QObject.connect(self.ui.actionNew,QtCore.SIGNAL("triggered()"),self.new_file) QtCore.QObject.connect(self.ui.actionOpen,QtCore.SIGNAL("triggered()"),self.open_file) QtCore.QObject.connect(self.ui.action_Saveas,QtCore.SIGNAL("triggered()"),self.saveas_file) QtCore.QObject.connect(self.ui.actionPrint,QtCore.SIGNAL("triggered()"),self.save_file) QtCore.QObject.connect(self.ui.actionPrint_Preview,QtCore.SIGNAL("triggered()"),self.save_file) QtCore.QObject.connect(self.ui.action_quit,QtCore.SIGNAL("triggered()"),self.quit) def save_file(self): if self.fn!=None: fileobj=open(self.fn,'w') fileobj.write(self.ui.textEdit.toPlainText()) fileobj.close() else: filename=self.file_dialog.getSaveFileName(self,u"保存文件") try: fileobj=open(filename,'w') fileobj.write(self.ui.textEdit.toPlainText()) self.fn=filename fileobj.close() except Exception ,e: pass
class Gui(QtGui.QMainWindow): def __init__(self, capture, getFrame, parent=None): QtGui.QWidget.__init__(self, parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.video = Video(capture, getFrame) self._timer = QtCore.QTimer(self) self._timer.timeout.connect(self.play) self._timer.start(27) self.update() def play(self): try: self.video.captureNextFrame() self.ui.videoFrame.setPixmap(self.video.convertFrame()) self.ui.videoFrame.setScaledContents(True) gethistogram(self.ui.axes, tuple(self.video.histogram.values()), tuple(self.video.histogram.keys())) # l = [random.randint(0, 10) for i in range(4)] # self.ui.axes.plot(self.video.histogram.values(), 'r') self.ui.canvas.draw() if (len(self.video.labels) != 0): self.ui.label1.setText(self.video.name) # self.ui.label2.setText(self.video.labels[1]) # self.ui.label3.setText(self.video.labels[2]) # self.ui.label4.setText(self.video.labels[3]) # self.ui.label5.setText(self.video.labels[4]) except TypeError as e: print("No Frame", e)
class mainForm(QtGui.QMainWindow): def __init__(self, parent = None): QtGui.QWidget.__init__(self, parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.pannel = [] # 기본 패널 self.pannel.append(tab_widget(addTab, self)) self.func_insert_tab(u'새로운 탭') self.pannel.append(tab_widget(communicationPannel, self)) self.func_insert_tab(u'DataPort') QtCore.QObject.connect(self.pannel[0].pannel.ui.clb, QtCore.SIGNAL("clicked()"), self.AddTab) def AddTab(self): current_index = len(self.ui.tabWidget) self.pannel.append(tab_widget(communicationPannel, self)) self.func_insert_tab(u'DataPort') # 프로그램을 닫으려 할때 def closeEvent(self, event): reply = QtGui.QMessageBox.warning(self, u'프로그램 종료', u"진행중인 모든 데이터 송·수신을 중지합니다.\n프로그램을 종료하시겠습니까?", QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No) if reply == QtGui.QMessageBox.Yes: event.accept() elif reply == QtGui.QMessageBox.No: event.ignore() def func_insert_tab(self, tab_name): """ * 탭이 추가되면 항상 '새탭추가탭' 앞 쪽에 위치 * 추가된 탭이 활성화 """ current_index = len(self.ui.tabWidget) self.ui.tabWidget.insertTab(current_index - 1, self.pannel[current_index], unicode(tab_name)) self.ui.tabWidget.setCurrentIndex(current_index - 1) def slot_close_tab(self, tab_index): print tab_index if 1 == self.ui.tabWidget.count(): # '새탭 추가탭'을 닫으려 할 경우 return reply = QtGui.QMessageBox.warning( self,u'탭 닫기', u"저장하지 않은 작업 내용은 잃게됩니다.\n탭을 닫으시겠습니까?", QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No) if reply == QtGui.QMessageBox.Yes: self.pannel.pop(tab_index + 1) self.ui.tabWidget.removeTab(tab_index) elif reply == QtGui.QMessageBox.No: pass
class CMonoployApp(QMainWindow): def __init__(self): super().__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.initUi() def initUi(self): pass
class MainWindow(QtWidgets.QMainWindow): def __init__(self): super(MainWindow, self).__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.ui.label.setText('Hello World!') def update(self, subject): self.ui.label.setText(str(subject.num))
class mywindow(QtWidgets.QMainWindow): def __init__(self): super(mywindow, self).__init__() self.img = '' self.mask = '' self.model = '' self.ui = Ui_MainWindow() self.ui.setupUi(self) self.ui.s_image_label.clicked.connect(self.select_image) self.ui.s_model.clicked.connect(self.select_model) self.ui.run.clicked.connect(self.execute) def select_image(self): image_path, filetype = QFileDialog.getOpenFileName(self,"選取原始圖片","./","All Files (*);;Text Files (*.txt)") label_path, filetype = QFileDialog.getOpenFileName(self,"原始圖片對應的mask","./","All Files (*);;Text Files (*.txt)") self.ui.image_path.setText(image_path) self.ui.label_path.setText(label_path) self.img = image_reader(image_path) self.mask = image_reader(label_path) #return image_path,label_path def select_model(self): model_path, filetype = QFileDialog.getOpenFileName(self,"選取模型","./","All Files (*);;Text Files (*.txt)") #print(model_path) self.ui.model_name.setText(model_path) self.model = model_loader(model_path) #return model_path def execute(self): dc_list = image_predict_v2(self.img,self.mask,self.model) self.ui.picture.setPixmap(QtGui.QPixmap("final_result.png")) self.ui.label.setText('DC 1: '+ str(dc_list[0])) self.ui.label_2.setText('DC 2: '+str(dc_list[1])) self.ui.label_3.setText('DC 3: '+str(dc_list[2])) self.ui.label_4.setText('DC 4: '+str(dc_list[3])) self.ui.label_5.setText('DC 5: '+str(dc_list[4])) self.ui.label_6.setText('DC 6: '+str(dc_list[5])) self.ui.label_7.setText('DC 7: '+str(dc_list[6])) self.ui.label_8.setText('DC 8: '+str(dc_list[7])) self.ui.label_9.setText('DC 9: '+str(dc_list[8])) self.ui.label_10.setText('DC 10: '+str(dc_list[9])) self.ui.label_11.setText('DC 11: '+str(dc_list[10])) self.ui.label_12.setText('DC 12: '+str(dc_list[11])) self.ui.label_13.setText('DC 13: '+str(dc_list[12])) self.ui.label_14.setText('DC 14: '+str(dc_list[13])) self.ui.label_15.setText('DC 15: '+str(dc_list[14])) self.ui.label_16.setText('DC 16: '+str(dc_list[15])) self.ui.label_17.setText('DC 17: '+str(dc_list[16])) self.ui.label_18.setText('DC 18: '+str(dc_list[17])) self.ui.label_19.setText('DC 19: '+str(dc_list[18])) self.ui.label_20.setText('DC AVG: '+ str(dc_list[19]))
class MyForm(QtGui.QMainWindow): def __init__(self, logAnalyser, parent=None): QtGui.QWidget.__init__(self, parent) self.ui = Ui_MainWindow() self.ui.setupUi(self, len(logAnalyser.files)) self.logAnalyser = logAnalyser self.threadLogAnalyser = ThreadedLogAnalyser(self, self.logAnalyser) self.connect(self.threadLogAnalyser, QtCore.SIGNAL("appendLogs"), self.ui.appendLogs) def main(self): self.threadLogAnalyser.start()
class MainWindow(QtWidgets.QMainWindow): def __init__(self): super(MainWindow, self).__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.ui.label.setText('Hello World!') self.ui.pushButton.clicked.connect(self.buttonClicked) def buttonClicked(self): now = datetime.now() self.ui.label.setText(str(now))
class Gui(QtGui.QMainWindow): def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.video = Video(cv2.VideoCapture(0)) self._timer = QtCore.QTimer(self) self._timer.timeout.connect(self.play) self._timer.start(27) self.update() self.ui.btnCapture.clicked.connect(self.cb) self.ui.btnAddText.clicked.connect(self.addText) self.ui.picComboBox.currentIndexChanged.connect(self.picResolution) self.ret, self.capturedFrame = self.video.capture.read() def picResolution(self): pass def cb(self): reso = self.ui.picComboBox.currentText().split('x') self.video.captureNextFrame() frame = self.video.convertFrame() self.ui.videoFrame_2.setPixmap(frame) self.ui.videoFrame_2.setScaledContents(True) self.capturedFrame = self.video.captureFrame() img = cv2.resize(self.capturedFrame, int(reso[0]), int(reso[1])) cv2.imwrite("test.jpg", img) print("captured") def addText(self): imText = self.video.getImage() imOrg = self.video.getImage() text = "%s" % self.ui.TextFieldAddText.text() cv2.putText(imText, text, (20, 450), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2) cv2.imwrite("testText.jpg", imText) pixmap = QtGui.QPixmap('testText.jpg') self.ui.videoFrame_2.setPixmap(pixmap) print('Text added' + text) def play(self): try: self.video.captureNextFrame() self.ui.videoFrame.setPixmap(self.video.convertFrame()) self.ui.videoFrame.setScaledContents(True) except TypeError: print("No frame")
class MainWindow(QMainWindow): def __init__(self): super(MainWindow, self).__init__() #ui self.ui = Ui_MainWindow() self.ui.setupUi(self) self.ui.startButton.clicked.connect(self.handleClicked) self.checkboxes = [ self.ui.checkBox, self.ui.checkBox_2, self.ui.checkBox_3, self.ui.checkBox_4, self.ui.checkBox_5, self.ui.checkBox_6 ] def handleClicked(self): if not self.ui.locationInput.text(): msgBox = QMessageBox() msgBox.setIcon(QMessageBox.Warning) msgBox.setText("지역을 설정해주세요.") else: filter = json.load(open("mod.json"))["filter"] filter_list = [] for c in self.checkboxes: if c.isChecked(): filter_list.append(filter[c.text()]) filter = ":".join(filter_list) #thread self.thread = QThread() self.worker = Worker(self.ui.locationInput.text(), filter) self.worker.moveToThread(self.thread) self.thread.started.connect(self.worker.run) self.worker.finished.connect(self.thread.quit) self.worker.finished.connect(self.worker.deleteLater) self.thread.finished.connect(self.thread.deleteLater) self.worker.progress.connect(self.ui.progressBar.setValue) self.thread.start() self.ui.startButton.setEnabled(False) self.thread.finished.connect(self.handleFinished) def handleFinished(self): self.ui.startButton.setEnabled(True) self.ui.progressBar.setValue(0) msgBox = QMessageBox() msgBox.setIcon(QMessageBox.Information) msgBox.setText("수집이 완료되었습니다.") msgBox.setDefaultButton(QMessageBox.Ok) ret = msgBox.exec_() if ret == QMessageBox.Ok: path = os.getcwd() + "/result" webbrowser.open('file:///' + path)
class MainWindow(QtWidgets.QMainWindow): def __init__(self): super(MainWindow, self).__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.ui.label.setText('Hello World!') def update(self, subject): self.ui.label.setText(str(subject.now)) alarmtime = str(subject.alarmtime) self.ui.label_2.setText(alarmtime) countdown = str(subject.countdown) self.ui.label_3.setText(countdown)
class Gui(QtGui.QMainWindow): def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.video = Video(cv2.VideoCapture(0)) self._timer = QtCore.QTimer(self) self._timer.timeout.connect(self.play) self._timer.start(27) self.update() def play(self): try: self.video.captureNextFrame() self.ui.videoFrame.setPixmap(self.video.convertFrame()) self.ui.videoFrame.setScaledContents(True) except TypeError: print "No frame"
class StartQT4(QtGui.QMainWindow): def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.clidict = Param_To_Cli() self.ui.interface_choice.addItems(netifaces.interfaces()) QtCore.QObject.connect( self.ui.start, QtCore.SIGNAL("clicked()"), self.start_sniffer) QtCore.QObject.connect( self.ui.action_stop, QtCore.SIGNAL("triggered()"), self.stop_sniffer) #self.ui.packet_list.setHorizontalHeaderLabels(['时间','源地址','目的地址','内容']) # QtCore.QObject.connect( # self.ui.interface_choice, QtCore.SIGNAL("activated(const QString&)"), self.get_interface) # # QtCore.QObject.connect( # self.ui.mode_choice, QtCore.SIGNAL("activated(const QString&)"), self.get_mode) # QtCore.QObject.connect( # self.ui.lineEdit, QtCore.SIGNAL("editingFinished()"), self.get_filter) def start_sniffer(self): self.clidict.interface = str(self.ui.interface_choice.currentText()) self.clidict.mode = str(self.ui.mode_choice.currentText()) self.clidict.filter = str(self.ui.lineEdit.text()) log.debug(self.clidict.interface + '' + self.clidict.mode + '' + self.clidict.filter) sniffer_prepare(self.clidict) self.sniff_queue = multiprocessing.JoinableQueue() self.sniffer = SnifferProcess(self.sniff_queue, iface=str(self.clidict.interface)) self.sniffer.start() self.displaythreading = DisplayPacket(self.sniff_queue, self.ui.packet_list) self.displaythreading.start() self.ui.action_stop.setEnabled(True) def stop_sniffer(self): self.sniffer.terminate() self.sniff_queue.close() while True: if self.sniff_queue.empty(): break self.displaythreading.terminate()
class ApplicationWindow(QtWidgets.QMainWindow): def __init__(self): self.images =[] self.outputs =[] super(ApplicationWindow, self).__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.ui.new_ch.clicked.connect(self.add_img) self.ui.new_ch_2.clicked.connect(self.add_output) def add_img(self): """add image and it's cpmponent there is NO number limit""" logging.info(f'add new image channel') a = cr_image(self.ui.scrollAreaWidgetContents_2,self.ui.verticalLayout_2,self.ui.comp_combo_l,self.ui.img_combo_l,self.ui.delete_ch,self.ui.open_img) self.images.append(a) def add_output(self): """add output there is NO number limit""" logging.info(f'add new output channel') a = cr_output(self.ui.scrollAreaWidgetContents,self.ui.output_display,self.ui.comp_combo_l,self.ui.output_select,self.ui.ratio_l,self.ui.img_combo_l,self.ui.save_img,self.ui.delete_ch_2) self.outputs.append(a)
class Gui(QtGui.QMainWindow): def __init__(self,parent=None): QtGui.QWidget.__init__(self,parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.ui.start_button.clicked.connect(self.start_master) self.ui.connect_button.clicked.connect(self.start_client) self.ui.close_button.clicked.connect(self.close) self.CONNECTION_PORT = 1111 self.update() def start_master(self): hablar_master(self.CONNECTION_PORT, self.ui.label) def start_client(self): ip = self.ui.ip.getText() hablar_client(ip, self.CONNECTION_PORT, self.ui.label) def close(self): sys.exit()
class MainWindow(QMainWindow): def __init__(self): QMainWindow.__init__(self) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.ui.choose.clicked.connect(self.open_file_dialog) def open_file_dialog(self): file = QFileDialog.getOpenFileName(self, 'Open File', '.')[0] if file is None or len(file) == 0: return img = cv2.imread(file, 0) edges = cv2.Canny(img, 100, 200) print(file) print(img) print(edges) self.ui.initial.setPixmap(QPixmap.fromImage(to_QImage(img))) self.ui.result.setPixmap(QPixmap.fromImage(to_QImage(edges)))
class CalcUi(QtWidgets.QMainWindow): def __init__(self): super(CalcUi, self).__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) # Czyszczenie pól self.ui.doClean.clicked.connect(lambda: self.doCleanInputs()) # Wykonanie dzialania self.ui.doCalc.clicked.connect(lambda: self.makeCalc()) self.show() def doCleanInputs(self): self.ui.input_a.setText('') self.ui.input_b.setText('') self.ui.output.setText('') def makeCalc(self): a = float(self.ui.input_a.text()) b = float(self.ui.input_b.text()) try: if self.ui.check_dodaj.isChecked(): calc = a + b self.ui.output.setText(str(calc)) elif self.ui.check_odejmij.isChecked(): calc = a - b self.ui.output.setText(str(calc)) elif self.ui.check_mnoz.isChecked(): calc = a * b self.ui.output.setText(str(calc)) elif self.ui.check_dziel.isChecked(): if b == 0.0 or b == 0 or b == '0': self.ui.output.setText('Nie dziel przez 0!') else: calc = a / b self.ui.output.setText(str(calc)) except error as e: print(e)
class FreereaderUi(QtGui.QMainWindow): def __init__(self, parent=None): QtGui.QWidget.__init__(self,parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) QtCore.QObject.connect(self.ui.readButton, QtCore.SIGNAL("clicked()"), self.readButton) QtCore.QMetaObject.connectSlotsByName(self) def readButton(self): self.notify('please wait') try: obj = feedparser.parse(str(self.ui.urlText.text())) self.notify('feed readed') if obj.entries != []: for entry in obj.entries: self.ui.listWidget.addItem(entry.title) except: self.notify('error in parsing url') def notify(self, string = ''): self.ui.notification.setText(string)
class MainWindow(QMainWindow): '''First application window the user sees''' def __init__(self, pod): super().__init__() self._pod = pod self._ui = Ui_MainWindow() self._ui.setupUi(self) self._ui.actionNetwork.triggered.connect(self.networkDialog) def networkDialog(self): '''Open a window for changing network settings''' la = self._pod.get_local_addr() ra = self._pod.get_remote_addr() info = NetworkInfo(local=la, remote=ra) dialog = NetworkDialog(info) if dialog.exec_() == QDialog.Accepted: la, old = info.local, la if la != old: self._pod.set_local_addr(info.local) ra, old = info.remote, ra if ra != old: self._pod.set_remote_addr(info.remote)
class scrap(QtWidgets.QMainWindow): def __init__(self): super(scrap, self).__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.init_UI() def init_UI(self): self.setWindowTitle('Web-scraper') self.ui.lineEdit.setPlaceholderText('url') self.ui.pushButton.clicked.connect(self.scrapping) def scrapping(self): url = self.ui.lineEdit.text() response = requests.get(url) soup = BeautifulSoup(response.text, 'lxml') quotes = soup.find_all('div') with open('test-scrap.doc', 'w', encoding='utf-8') as output_file: for quote in quotes: print(quote.text) output_file.write(quote.text)
class mywindow(QtWidgets.QMainWindow): def __init__(self): super(mywindow, self).__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.setStyleSheet( "background-image: url(binaries/backgroundmain.png);") self.setWindowIcon(QIcon('binaries/icon.png')) self.setWindowTitle('Steam Sales Finder by dewar') self.ui.listWidget.setStyleSheet( "background-image: url(binaries/background.png);color: rgb(255, 255, 255);" ) self.ui.pushButton.setStyleSheet( "background-image: url(binaries/background.png);color: rgb(255, 255, 255);" ) self.ui.pushButton_2.setStyleSheet( "background-image: url(binaries/background.png);color: rgb(255, 255, 255);" ) self.ui.spinBox.setStyleSheet( "background-image: url(binaries/background.png); color: rgb(0, 39, 75);" ) self.ui.pushButton.clicked.connect(self.btnClicked) self.ui.pushButton_2.clicked.connect(self.btnClicked_2) def btnClicked(self): count = self.ui.spinBox.value() main(count) text = str(self.ui.comboBox.currentText()) if text == "По порядку": for h in range(len(finlist)): self.ui.listWidget.addItem(finlist[h]) elif text == "По алфавиту": for h in range(len(finlist)): self.ui.listWidget.addItem(natsorted(finlist)[h]) def btnClicked_2(self): self.close()
class Main(QMainWindow): def __init__(self): super().__init__() self.ui=Ui_MainWindow() self.ui.setupUi(self) self.ui.pushButton.clicked.connect(self.startTask) self.ui.pushButton_2.clicked.connect(self.close) def startTask(self): self.ui.movie=QtGui.QMovie("C:\\Users\\KIIT\\Desktop\\JarvisUI\\sFaoXq3.gif") self.ui.label.setMovie(self.ui.movie) self.ui.movie.start() self.ui.movie=QtGui.QMovie("C:\\Users\\KIIT\\Desktop\\JarvisUI\\iron-man-jarvis-gif-5.gif") self.ui.label_2.setMovie(self.ui.movie) self.ui.movie.start() self.ui.movie=QtGui.QMovie("C:\\Users\\KIIT\\Desktop\\JarvisUI\\BigheartedVagueFoal-size_restricted.gif") self.ui.label_3.setMovie(self.ui.movie) self.ui.movie.start() self.ui.movie=QtGui.QMovie("C:\\Users\\KIIT\\Desktop\\JarvisUI\\hey.gif") self.ui.label_4.setMovie(self.ui.movie) self.ui.movie.start() self.ui.movie=QtGui.QMovie("C:\\Users\\KIIT\\Desktop\\JarvisUI\\jarvislogo.gif") self.ui.label_5.setMovie(self.ui.movie) self.ui.movie.start() self.ui.movie=QtGui.QMovie("C:\\Users\\KIIT\\Desktop\\JarvisUI\\iron-man-jarvis-gif-5.gif") self.ui.label_6.setMovie(self.ui.movie) self.ui.movie.start() timer=QTimer(self) timer.timeout.connect(self.showTime) timer.start(1000) startExecution.start() def showTime(self): current_time=QTime.currentTime() lable_time=current_time.toString("hh:mm:ss") self.ui.textBrowser.setText(lable_time)
class Main(QtWidgets.QMainWindow): def __init__(self): super(Main, self).__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.init_UI() def init_UI(self): print(4) self.ui.pushButton.clicked.connect(self.button) #self.ui.verticalSlider.setRepeatAction(self.button,50,50) def button(self): print(5) ok = int(self.ui.verticalSlider.sliderPosition() * 2.55) ok1 = int(self.ui.verticalSlider_2.sliderPosition() * 2.55) ok2 = int(self.ui.verticalSlider_3.sliderPosition() * 2.55) l = ok * 16 * 16 * 16 * 16 + ok1 * 16 * 16 + ok2 print(str(hex(l))[2::]) l = str(hex(l))[2::] if ok < 16: l = "0" + l self.ui.centralwidget.setStyleSheet("QPushButton{background-color: #" + l + ";}")
class jaabaGUI(QMainWindow): """ controller for the blob labeling GUI""" def __init__(self,parent=None): QMainWindow.__init__(self,parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) #add new slider # self.positionSlider=QSlider(Qt.Horizontal) # self.positionSlider.setGeometry (800,800,100,30) # self.positionSlider.setRange(0, 0) # self.positionSlider.sliderMoved.connect(self.setPosition) #setup Video #video player self.mediaPlayer1 = QMediaPlayer(None, QMediaPlayer.VideoSurface) self.mediaPlayer2 = QMediaPlayer(None, QMediaPlayer.VideoSurface) #self.mediaPlayer.metaDataChanged.connect(self.metaDataChanged) self.mediaPlayer1.durationChanged.connect(self.durationChanged) self.mediaPlayer1.positionChanged.connect(self.positionChanged) self.mediaPlayer2.positionChanged.connect(self.positionChanged) #visualizetion self.scene = QGraphicsScene() self.ui.graphicsView.setScene(self.scene) #self.scene.setBackgroundBrush(Qt.black) self.videoItem1 = QGraphicsVideoItem() self.videoItem2 = QGraphicsVideoItem() self.scene.addItem(self.videoItem1) self.scene.addItem(self.videoItem2) self.mediaPlayer1.setVideoOutput(self.videoItem1) self.mediaPlayer2.setVideoOutput(self.videoItem2) #slide bar print self.ui.horizontalSlider self.ui.horizontalSlider.setRange(0, 0) self.ui.horizontalSlider.sliderMoved.connect(self.setPosition) # self.ui.horizontalSlider.sliderPressed.connect(self.sliderPressed) #print self.ui.graphicsView.width()/2,self.ui.graphicsView.height() #self.videoItem1.setSize(QSizeF(self.ui.graphicsView.width()/2,self.ui.graphicsView.height())) #self.videoItem2.setSize(QSizeF(self.ui.graphicsView.width()*10,self.ui.graphicsView.height()*10)) # self.videoItem2.setSize(graphicsView.size()) #self.videoItem2.setOffset(QPointF(500,500)) #self.videoItem2.setOffset(QPointF(self.ui.graphicsView.width()/2,0)) #self.videoItem2.setPos(QPointF(0,0)) # print self.ui.graphicsView.width(), self.ui.graphicsView.height() # print self.ui.graphicsView.size() # print self.videoItem2.boundingRect().width(), self.videoItem2.boundingRect().height() # print self.ui.graphicsView.sceneRect() #self.mediaPlayer.stateChanged.connect(self.mediaStateChanged) #callbacks self.ui.actionQuit.triggered.connect(self.quit) self.ui.actionLoad_Project.triggered.connect(self.loadVideo) #self.ui.buttonPlay.clicked[bool].connect(self.setToggleText) self.ui.buttonPlay.clicked.connect(self.play) #print self.ui.graphicsView.sizeHint() #initialization self.loaded = False self.videoFilename = None self.frame_count=None self.width=None self.height=None self.frame_trans=None # ###actions starts from here### def quit(self): QApplication.quit() def loadVideo(self): self.writeLog("Loading video...") self.videoFilename = QFileDialog.getOpenFileName(self, 'Open File', '.')[0] if not self.videoFilename: self.writeLog("User cancelled - no video loaded") return else: cap=cv2.VideoCapture(self.videoFilename) self.frame_count=cap.get(cv2.CAP_PROP_FRAME_COUNT) self.width=cap.get(3) self.height=cap.get(4) self.mediaPlayer2.setMedia(QMediaContent(QUrl.fromLocalFile(self.videoFilename ))) self.mediaPlayer1.setMedia(QMediaContent(QUrl.fromLocalFile(self.videoFilename ))) self.ui.buttonPlay.setEnabled(True) # self.mediaPlayer2.setVideoOutput(self.videoItem2) # self.mediaPlayer1.setVideoOutput(self.videoItem1) # size= self.videoItem2.nativeSize() # print size #print self.mediaPlayer.duration() #print self.mediaPlayer.metaData() self.writeLog("Video loaded!") def play(self): self.videoItem1.setAspectRatioMode(0) self.videoItem2.setAspectRatioMode(0) self.scene.setSceneRect(0,0,self.ui.graphicsView.width(),self.ui.graphicsView.height()) self.videoItem1.setSize(QSizeF(self.ui.graphicsView.width()/2,self.ui.graphicsView.height())) self.videoItem2.setSize(QSizeF(self.ui.graphicsView.width()/2,self.ui.graphicsView.height())) self.videoItem1.setPos(QPointF(0,0)) self.videoItem2.setPos(QPointF(self.ui.graphicsView.width()/2,0)) #self.ui.graphicsView.setGeometry(0,0, 600,800) #print 'graphicsView size', self.ui.graphicsView.size() #print 'graphicsScene size', self.scene.sceneRect() #self.videoItem2.setSize(QSizeF(1000,300)) #print 'graphicsVideoItem size',self.videoItem2.size() # print 'item x',self.videoItem2.scenePos().x() # print 'item y', self.videoItem2.scenePos().y() # print 'item x',self.videoItem1.scenePos().x() # print 'item y', self.videoItem1.scenePos().y() if self.mediaPlayer1.state() == QMediaPlayer.PlayingState: self.ui.buttonPlay.setIcon(self.ui.style().standardIcon(PyQt5.QtWidgets.QStyle.SP_MediaPlay)) self.ui.buttonPlay.setText("Play") self.mediaPlayer1.pause() self.writeLog("Video paused") else: self.ui.buttonPlay.setIcon(self.ui.style().standardIcon(PyQt5.QtWidgets.QStyle.SP_MediaPause)) self.ui.buttonPlay.setText("Stop") self.mediaPlayer1.play() self.writeLog("Playing video") if self.mediaPlayer2.state() == QMediaPlayer.PlayingState: self.mediaPlayer2.pause() else: self.mediaPlayer2.play() #size= self.videoItem2.nativeSize() # print self.mediaPlayer.duration() #print self.mediaPlayer.metaData() # print self.ui.graphicsView.width(), self.ui.graphicsView.height() # print self.ui.graphicsView.size() # print self.videoItem2.boundingRect().width(), self.videoItem2.boundingRect().height() # print self.ui.graphicsView.sceneRect() # print self.scene.sceneRect() # print self.ui.graphicsView.sizeHint() def setPosition(self, position): self.mediaPlayer1.setPosition(position) self.mediaPlayer2.setPosition(position) # when position of media changed, set slider and text box accordingly. def positionChanged(self, position): self.ui.horizontalSlider.setValue(position) if isinstance(self.frame_trans,float): # print type(position),position # print type(self.frame_trans),self.frame_trans # print position/self.frame_trans self.ui.lineEdit.setText(str(int(round(position/self.frame_trans,0)))) self.writeLog(str(position)) def durationChanged(self, duration): self.ui.horizontalSlider.setRange(0, duration) self.frame_trans=self.mediaPlayer1.duration()/self.frame_count print self.frame_trans def writeLog(self,text): self.ui.log.setText(text)
class Gui(QtGui.QMainWindow): """ Main GUI Class It contains the main function and interfaces between the GUI and functions """ def __init__(self,parent=None): QtGui.QWidget.__init__(self,parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) """ Main Variables Using Other Classes""" self.rex = Rexarm() self.video = Video(cv2.VideoCapture(0)) self.world_coord = np.float32() """ Play and Repeat Variable """ self.wayPoints = [] self.wayPointsPos = [] self.wayPointsSpeed = [] self.wayPointsTime = [] """ Other Variables """ self.last_click = np.float32([-1,-1]) self.define_template_flag = -1 self.click_point1 = np.float32([-1,-1]) self.click_point2 = np.float32([-1,-1]) self.template = None self.targets = [] self.waypointsfp = csv.writer(open("waypoint.csv","wb")) self.currtime = 0 """ Set GUI to track mouse """ QtGui.QWidget.setMouseTracking(self,True) """ Video Function Creates a timer and calls play() function according to the given time delay (27mm) """ self._timer = QtCore.QTimer(self) self._timer.timeout.connect(self.play) self._timer.start(27) """ LCM Arm Feedback Creates a timer to call LCM handler continuously No delay implemented. Reads all time """ self._timer2 = QtCore.QTimer(self) self._timer2.timeout.connect(self.rex.get_feedback) self._timer2.start() """ ARM Plan and Command Thread Creates a timer to call REXARM.plan_command function continuously """ self._timer3 = QtCore.QTimer(self) self._timer3.timeout.connect(self.rex.plan_command) self._timer3.start() """ Connect Sliders to Function TO DO: CONNECT THE OTHER 5 SLIDERS IMPLEMENTED IN THE GUI """ self.ui.sldrBase.valueChanged.connect(self.slider_change) self.ui.sldrShoulder.valueChanged.connect(self.slider_change) self.ui.sldrElbow.valueChanged.connect(self.slider_change) self.ui.sldrWrist.valueChanged.connect(self.slider_change) self.ui.sldrMaxTorque.valueChanged.connect(self.slider_change) self.ui.sldrSpeed.valueChanged.connect(self.slider_change) """ Commands the arm as the arm initialize to 0,0,0,0 angles """ self.slider_change() """ Connect Buttons to Functions """ self.ui.btnLoadCameraCal.clicked.connect(self.load_camera_cal) self.ui.btnPerfAffineCal.clicked.connect(self.affine_cal) self.ui.btnTeachRepeat.clicked.connect(self.tr_initialize) self.ui.btnAddWaypoint.clicked.connect(self.tr_add_waypoint) self.ui.btnSmoothPath.clicked.connect(self.tr_smooth_path) self.ui.btnPlayback.clicked.connect(self.tr_playback) self.ui.btnLoadPlan.clicked.connect(self.tr_load) self.ui.btnDefineTemplate.clicked.connect(self.def_template) self.ui.btnLocateTargets.clicked.connect(self.template_match) self.ui.btnExecutePath.clicked.connect(self.exec_path) def play(self): """ Play Funtion Continuously called by GUI """ """ Renders the Video Frame """ try: self.video.captureNextFrame() for t in self.targets: self.video.addTarget(t) self.ui.videoFrame.setPixmap(self.video.convertFrame()) self.ui.videoFrame.setScaledContents(True) cv2.imwrite("curretFrame.png", self.video.currentFrame) except TypeError: print "No frame" """ Update GUI Joint Coordinates Labels TO DO: include the other slider labels """ self.ui.rdoutBaseJC.setText(str(self.rex.joint_angles_fb[0]*R2D)) self.ui.rdoutShoulderJC.setText(str(self.rex.joint_angles_fb[1]*R2D)) self.ui.rdoutElbowJC.setText(str(self.rex.joint_angles_fb[2]*R2D)) self.ui.rdoutWristJC.setText(str(self.rex.joint_angles_fb[3]*R2D)) fk_result = self.rex.rexarm_FK(3) #print fk_result self.ui.rdoutX.setText(repr(fk_result[0])) self.ui.rdoutY.setText(repr(fk_result[1])) self.ui.rdoutZ.setText(repr(fk_result[2])) self.ui.rdoutT.setText(repr(fk_result[3])) """ Mouse position presentation in GUI TO DO: after getting affine calibration make the apprriate label to present the value of mouse position in world coordinates """ x = QtGui.QWidget.mapFromGlobal(self,QtGui.QCursor.pos()).x() y = QtGui.QWidget.mapFromGlobal(self,QtGui.QCursor.pos()).y() if ((x < MIN_X) or (x > MAX_X) or (y < MIN_Y) or (y > MAX_Y)): self.ui.rdoutMousePixels.setText("(-,-)") self.ui.rdoutMouseWorld.setText("(-,-)") else: x = x - MIN_X y = y - MIN_Y self.ui.rdoutMousePixels.setText("(%.0f,%.0f)" % (x,y)) if (self.video.aff_flag == 2): """ TO DO Here is where affine calibration must be used """ self.ui.rdoutMouseWorld.setText("(%0.f,%0.f)" % (self.world_coord[0][0], self.world_coord[1][0])) else: self.ui.rdoutMouseWorld.setText("(-,-)") """ Updates status label when rexarm playback is been executed. This will be extended to includ eother appropriate messages """ if(self.rex.plan_status == 1): self.ui.rdoutStatus.setText("Playing Back - Waypoint %d" %(self.rex.wpt_number + 1)) def slider_change(self): """ Function to change the slider labels when sliders are moved and to command the arm to the given position TO DO: Implement for the other sliders """ self.ui.rdoutBase.setText(str(self.ui.sldrBase.value())) self.ui.rdoutShoulder.setText(str(self.ui.sldrShoulder.value())) self.ui.rdoutElbow.setText(str(self.ui.sldrElbow.value())) self.ui.rdoutWrist.setText(str(self.ui.sldrWrist.value())) self.ui.rdoutTorq.setText(str(self.ui.sldrMaxTorque.value()) + "%") self.ui.rdoutSpeed.setText(str(self.ui.sldrSpeed.value()) + "%") self.rex.max_torque = self.ui.sldrMaxTorque.value()/100.0 for i in xrange(4): self.rex.speed[i] = self.ui.sldrSpeed.value()/100.0 self.rex.joint_angles[0] = self.ui.sldrBase.value()*D2R self.rex.joint_angles[1] = self.ui.sldrShoulder.value()*D2R self.rex.joint_angles[2] = self.ui.sldrElbow.value()*D2R self.rex.joint_angles[3] = self.ui.sldrWrist.value()*D2R self.rex.cmd_publish() def mousePressEvent(self, QMouseEvent): """ Function used to record mouse click positions for affine calibration """ """ Get mouse posiiton """ x = QMouseEvent.x() y = QMouseEvent.y() """ If mouse position is not over the camera image ignore """ if ((x < MIN_X) or (x > MAX_X) or (y < MIN_Y) or (y > MAX_Y)): return """ Change coordinates to image axis """ self.last_click[0] = x - MIN_X self.last_click[1] = y - MIN_Y """ If affine calibration is been performed """ if (self.video.aff_flag == 1): """ Save last mouse coordinate """ self.video.mouse_coord[self.video.mouse_click_id] = [(x-MIN_X),(y-MIN_Y)] """ Update the number of used poitns for calibration """ self.video.mouse_click_id += 1 """ Update status label text """ self.ui.rdoutStatus.setText("Affine Calibration: Click point %d" %(self.video.mouse_click_id + 1)) """ If the number of click is equal to the expected number of points computes the affine calibration. TO DO: Change this code to use you programmed affine calibration and NOT openCV pre-programmed function as it is done now. """ if(self.video.mouse_click_id == self.video.aff_npoints): """ Update status of calibration flag and number of mouse clicks """ self.video.aff_flag = 2 self.video.mouse_click_id = 0 print self.video.mouse_coord print self.video.real_coord """ Perform affine calibration with OpenCV """ #self.video.aff_matrix = cv2.getAffineTransform( # self.video.mouse_coord, # self.video.real_coord) self.video.compute_affine_matrix() """ Updates Status Label to inform calibration is done """ self.ui.rdoutStatus.setText("Waiting for input") """ Uncomment to gether affine calibration matrix numbers on terminal """ print self.video.aff_matrix if self.video.aff_flag == 2: mouse_coord = np.array([[(x-MIN_X)], [(y-MIN_Y)],[1]]) self.world_coord = np.dot(self.video.aff_matrix, mouse_coord) if self.define_template_flag == 0: self.click_point1 = copy.deepcopy(self.last_click) self.define_template_flag = 1 elif self.define_template_flag == 1: self.click_point2 = copy.deepcopy(self.last_click) self.template = copy.deepcopy(self.video.bwFrame[2*self.click_point1[1]:2*self.click_point2[1],2*self.click_point1[0]:2*self.click_point2[0]]) print self.click_point1 print self.click_point2 self.define_template_flag = -1 cv2.imwrite('./template.png', self.template) def affine_cal(self): """ Function called when affine calibration button is called. Note it only chnage the flag to record the next mouse clicks and updates the status text label """ self.video.aff_flag = 1 self.ui.rdoutStatus.setText("Affine Calibration: Click point %d" %(self.video.mouse_click_id + 1)) def load_camera_cal(self): print "Load Camera Cal" self.video.loadCalibration() def tr_initialize(self): self.wayPointsPos = [] self.wayPointsSpeed = [] self.wayPointsTime = [] print "Teach and Repeat" def tr_add_waypoint(self): #waypoints1 = copy.deepcopy(self.rex.joint_angles_fb) #waypoints2 = copy.deepcopy(self.rex.joint_angles_fb) #self.wayPointsPos.append(waypoints1) #self.wayPointsTime.append([self.currtime, self.currtime, self.currtime, self.currtime]) #self.wayPointsSpeed.append([0.1, 0.1, 0.1, 0.1]) #self.currtime += 70000 #waypoints2[1] -= 0.7 #self.wayPointsPos.append(waypoints2) #self.wayPointsTime.append([self.currtime, self.currtime, self.currtime, self.currtime]) #self.wayPointsSpeed.append([0.1, 0.1, 0.1, 0.1]) #self.currtime += 70000 #self.waypointsfp.writerow(waypoints1) #self.waypointsfp.writerow(waypoints2) #np.save("waypointsPos",self.wayPointsPos) #np.save("waypointsSpeed", self.wayPointsSpeed) #np.save("waypointsTime", self.wayPointsTime) self.wayPointsPos.append(copy.deepcopy(self.rex.joint_angles_fb)) self.wayPointsSpeed.append(copy.deepcopy(self.rex.speed_fb)) self.wayPointsTime.append(copy.deepcopy(self.rex.time_fb)) np.save("waypointsPos",self.wayPointsPos) np.save("waypointsSpeed", self.wayPointsSpeed) np.save("waypointsTime", self.wayPointsTime) #print self.wayPoints print "Add Waypoint" def cubic_spline(self, q0, q0dot, t0, qf, qfdot, tf, stepnum): a0 = q0 a1 = q0dot a2 = (3*(qf-q0) - (2*q0dot+qfdot)*float(tf-t0)) / float((tf-t0)*(tf-t0)) a3 = (2*(q0-qf) + (q0dot+qfdot)*float(tf-t0)) / float((tf-t0)*(tf-t0)*(tf-t0)) stepsize = float(tf-t0)/float(stepnum) currtime = t0 + stepsize pos_interpolated = [] speed_interpolated = [] for i in xrange(stepnum-1): pos_interpolated.append(a0 + a1*currtime + a2*currtime*currtime + \ a3*currtime*currtime*currtime) speed_interpolated.append(np.abs(a1 + 2*a2*currtime + 3*a3*currtime*currtime)) currtime += stepsize #print q0, qf #print pos_interpolated return (pos_interpolated, speed_interpolated) def tr_smooth_path(self): if len(self.wayPointsPos) != len(self.wayPointsSpeed) and len(self.wayPointsPos) != len(self.wayPointsTime): print "Error on waypoints number, cannot smooth path" return for i in xrange(len(self.wayPointsTime)): for j in xrange(4): self.wayPointsTime[i][j] *= US2S for i in xrange(len(self.wayPointsSpeed)): for j in xrange(4): self.wayPointsSpeed[i][j] *= percent2rads interpolated_waypoints_pos = [] interpolated_waypoints_speed = [] for i in xrange(len(self.wayPointsPos)-1): time_offset = self.wayPointsTime[i] startPos = self.wayPointsPos[i] endPos = self.wayPointsPos[i+1] startSpeed = self.wayPointsSpeed[i] endSpeed = self.wayPointsSpeed[i+1] startTime = self.wayPointsTime[i] endTime = self.wayPointsTime[i+1] stepnum = 3 four_joint_interpolated_pos = [] four_joint_interpolated_speed = [] for j in xrange(4): q0 = startPos[j] q0dot = startSpeed[j] t0 = startTime[j] - time_offset[j] qf = endPos[j] qfdot = endSpeed[j] tf = endTime[j] - time_offset[j] res = self.cubic_spline(q0, q0dot, t0, qf, qfdot, tf, stepnum) four_joint_interpolated_pos.append(res[0]) four_joint_interpolated_speed.append(res[1]) interpolated_waypoints_pos.append(startPos) for i in xrange(len(four_joint_interpolated_pos[0])): pos = [] for j in xrange(len(four_joint_interpolated_pos)): pos.append(four_joint_interpolated_pos[j][i]) interpolated_waypoints_pos.append(pos) interpolated_waypoints_pos.append(endPos) interpolated_waypoints_speed.append(startSpeed) for i in xrange(len(four_joint_interpolated_speed[0])): speed = [] for j in xrange(len(four_joint_interpolated_speed)): speed.append(four_joint_interpolated_speed[j][i]) interpolated_waypoints_speed.append(speed) interpolated_waypoints_speed.append(endSpeed) self.wayPointsPos = interpolated_waypoints_pos self.wayPointsSpeed = interpolated_waypoints_speed for i in xrange(len(self.wayPointsSpeed)): for j in xrange(len(self.wayPointsSpeed[0])): self.wayPointsSpeed[i][j] /= percent2rads #pprint.pprint(self.wayPointsPos) #pprint.pprint(self.wayPointsSpeed) np.save("interpolated_waypoints_pos", self.wayPointsPos) np.save("interpolated_waypoints_speed", self.wayPointsSpeed) print "Smooth Path" def tr_playback(self): #print self.wayPoints self.rex.planPos = self.wayPointsPos self.rex.planSpeed = self.wayPointsSpeed #print self.rex.plan self.rex.save_data = True self.rex.plan_status = 1 self.rex.wpt_number = 0 self.rex.wpt_total = len(self.rex.planPos) print "Playback" def tr_load(self): self.wayPointsPos = np.load("waypointsPos.npy") self.wayPointsSpeed = np.load("waypointsSpeed.npy") self.wayPointsTime = np.load("waypointsTime.npy") print "Load waypoints" def def_template(self): print "Define Template" self.define_template_flag = 0 @do_cprofile def template_match(self): print "Template Match" self.targets = [] result_pq = Queue.PriorityQueue() template = cv2.resize(self.template, None, fx=0.6, fy=0.6, interpolation=cv2.INTER_AREA) frame = cv2.resize(self.video.bwFrame, None, fx=0.6, fy=0.6, interpolation=cv2.INTER_AREA) height, width = template.shape for i in xrange(0, frame.shape[0] - height): for j in xrange(0, frame.shape[1] - width): center_x = (i + height/2.0)/0.6 center_y = (j + width/2.0)/0.6 to_compare = frame[i:i+height,j:j+width] num = la.norm(to_compare - template) result_pq.put((num, center_y, center_x)) result = [] #for i in xrange(40): # t = result_pq.get() # print t[0] # result.append([int(t[1]), int(t[2])]) for i in xrange((frame.shape[0]-height)*(frame.shape[1]-width)): t = result_pq.get() if t[0] > 350: break else: result.append([int(t[1]), int(t[2])]) distort = sys.maxint cluster_size = 1 #print result while distort > 20: clustered_result, distort = scv.kmeans(np.array(result), cluster_size) cluster_size += 1 clustered_result, distort = scv.kmeans(np.array(result), 4) print "cluster_size: ", cluster_size-1 print "distort", distort for r in clustered_result: print r self.targets.append((r[0], r[1])) #circles = cv2.HoughCircles(self.video.bwFrame, cv2.cv.CV_HOUGH_GRADIENT, 1, minDist=5, param1=50, param2=50, minRadius=1, maxRadius=30) #for c in circlesi[0,:]: # print c # self.targets.append((c[0],c[1])) #img = np.zeros((1000,1000,3), np.uint8) #for t in self.targets: # img = cv2.circle(img, t, 10, (255,255,255), -1) #cv2.imwrite("./result.png", img) def exec_path(self): #waypoints = [(-80.0, 90.0, 350.0), (70.0, 80.0, 400.0), (-180.0, -250.0, 125.0),(240.0, -190.0, 95.0), (-80.0, 90.0, 350.0)] #waypoints = [(-100.0, 100.0, 5.0), (-100.0, 100.0, 200.0), (100.0, 100.0, 200.0),(100.0, 100.0, 5.0), (100.0, -100.0, 5.0), (100.0, -100.0, 200.0), (100.0, 100.0, 200.0)] waypoints = [] for t in xrange(0,12,1): x = 150 * np.cos(t) y = 150 * np.sin(t) z = 5.0 + 30.0 * t waypoints.append((x, y, z)) #waypoints = [] #if not self.targets or len(self.targets) == 0: # return #for t in self.targets: # img_coord = np.array([[(t[0]/2.0)], [(t[1]/2.0)], [1]]) # world_coord = np.dot(self.video.aff_matrix, img_coord) # print "img coord: ", img_coord # print "world coord: ", world_coord # waypoints.append((world_coord[0], world_coord[1], 5)) print waypoints self.wayPointsPos = [] self.wayPointsSpeed = [] self.wayPointsTime = [] for i in xrange(0, 3*len(waypoints), 3): x, y, z = waypoints[i/3] self.wayPointsPos.append(self.rex.rexarm_IK_Search((x,y,z))) self.wayPointsSpeed.append(copy.deepcopy([0.15, 0.15, 0.15, 0.15])) #jointsUp = self.rex.rexarm_IK_Search((x, y, 50.0)) #jointsDown = self.rex.rexarm_IK_Search((x, y, 0.0)) #if jointsUp: # self.wayPointsPos.append(copy.deepcopy(jointsUp)) # self.wayPointsSpeed.append(copy.deepcopy([0.15, 0.15, 0.15, 0.15])) # self.wayPointsTime.append([2000000*i,2000000*i,2000000*i,2000000*i]) # #if jointsDown: # self.wayPointsPos.append(copy.deepcopy(jointsDown)) # self.wayPointsSpeed.append(copy.deepcopy([0.05, 0.05, 0.05, 0.05])) # self.wayPointsTime.append([2000000*(i+1),2000000*(i+1),2000000*(i+1),2000000*(i+1)]) #if jointsUp: # self.wayPointsPos.append(copy.deepcopy(jointsUp)) # self.wayPointsSpeed.append(copy.deepcopy([0.05, 0.05, 0.05, 0.05])) # self.wayPointsTime.append([2000000*(i+2),2000000*(i+2),2000000*(i+2),2000000*(i+2)]) np.save("funPathPos",self.wayPointsPos) np.save("funPathSpeed", self.wayPointsSpeed) np.save("funPathTime", self.wayPointsTime) self.rex.planPos = self.wayPointsPos self.rex.planSpeed = self.wayPointsSpeed print self.rex.planPos self.rex.save_data = True self.rex.plan_status = 1 self.rex.wpt_number = 0 self.rex.wpt_total = len(self.rex.planPos)
class Main(QtGui.QMainWindow): """ Lanza la grilla principa """ def __init__(self,parent=None): super(Main, self).__init__(parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.load_data() self.connect_signals() self.show() def connect_signals(self): self.ui.agregar_marca.clicked.connect(self.agregar) self.ui.edtar_marca.clicked.connect(self.edit) self.ui.eliminar_marca.clicked.connect(self.delete) def load_data(self): """ Función que carga la información de marcas en la grilla incluyendo la cantidad de modelos asociados a la marca """ print "load data.." marcas = db_marcas.obtener_marcas() #Creamos el modelo asociado a la tabla self.data = QtGui.QStandardItemModel(len(marcas)+1, 3) self.data.setHorizontalHeaderItem( 0, QtGui.QStandardItem("Nombre de Marca")) self.data.setHorizontalHeaderItem( 1, QtGui.QStandardItem("Pais de Origen")) self.data.setHorizontalHeaderItem( 2, QtGui.QStandardItem(u"Cantidad de Modelos")) for r, row in enumerate(marcas): index = self.data.index(r, 0, QtCore.QModelIndex()) self.data.setData(index, row['Nombre de Marca']) index = self.data.index(r, 1, QtCore.QModelIndex()) self.data.setData(index, row['Pais de Origen']) index = self.data.index(r, 2, QtCore.QModelIndex()) self.data.setData(index, row['Cantidad de Modelos']) self.ui.tabla_marcas.setModel(self.data) # Para que las columnas 1 y 2 se estire o contraiga cuando # se cambia el tamaño de la pantalla self.ui.tabla_marcas.horizontalHeader().setResizeMode( 0, self.ui.tabla_marcas.horizontalHeader().Stretch) self.ui.tabla_marcas.horizontalHeader().setResizeMode( 1, self.ui.tabla_marcas.horizontalHeader().Stretch) self.ui.tabla_marcas.setColumnWidth(0, 100) self.ui.tabla_marcas.setColumnWidth(1, 210) self.ui.tabla_marcas.setColumnWidth(2, 210) def delete(self): """ Función que borra un alumno de la base de datos e indica el resultado de la operación """ data = self.ui.tabla_marcas.model() index = self.ui.tabla_marcas.currentIndex() if index.row() == -1: # No se ha seleccionado una fila self.errorMessageDialog = QtGui.QErrorMessage(self) self.errorMessageDialog.showMessage(u"Debe seleccionar una fila") return False else: self.resp = QtGui.QMessageBox.question( self,"Borrar", "Deseas borrar esta marca?", QtGui.QMessageBox.Yes, QtGui.QMessageBox.No); if self.resp == QtGui.QMessageBox.Yes: marca = data.index( index.row(), 0, QtCore.QModelIndex()).data() if (db_marcas.borrar(marca)): self.load_data() msgBox = QtGui.QMessageBox() msgBox.setText(u"EL registro fue eliminado.") msgBox.exec_() return True else: self.ui.errorMessageDialog = QtGui.QErrorMessage(self) self.ui.errorMessageDialog.showMessage( u"Error al eliminar el registro") return False self.load_data() def agregar(self): """ Agrega/edita una marca. Llama al formulario correspondiente """ self.ui.form = FormMarca(self) ## self.ui.form.accepted.connect(self.load_data) #self.ui.form.rejected.connect(self.load_data) self.ui.form.show() def edit(self): """ Función obtiene el alumno seleccionado en la grilla para poner sus datos en el formulario para su edición """ data = self.ui.tabla_marcas.model() index = self.ui.tabla_marcas.currentIndex() if index.row() == -1: # No se ha seleccionado una fila self.errorMessageDialog = QtGui.QErrorMessage(self) self.errorMessageDialog.showMessage(u"Debe seleccionar una fila") return False else: nom_marca = data.index(index.row(), 0, QtCore.QModelIndex()).data() self.ui.form = FormMarca(self, nom_marca) self.ui.form.accepted.connect(self.load_data) self.ui.form.show()
class MyForm(QtGui.QMainWindow): def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.connect(self.ui.pushButton, QtCore.SIGNAL('clicked()'), self.computeFunc) def computeFunc(self): # get IP try: s1 = int(self.ui.lineEdit_s1.text()) s2 = int(self.ui.lineEdit_s2.text()) s3 = int(self.ui.lineEdit_s3.text()) s4 = int(self.ui.lineEdit_s4.text()) if (self.validateFail(s1) or self.validateFail(s2) or self.validateFail(s3) or self.validateFail(s4) or int(s1) == 0 or int(s4) == 0): QtGui.QMessageBox.about(self, "Error", "Error in IP address!") except: QtGui.QMessageBox.about(self, "Error", "Empty IP address!") else: #get Mask #if short mode = None if str(self.ui.lineEdit_s5.text()) != '': mode = 's' sMask = str(self.ui.lineEdit_s5.text()) if (int(sMask) > 32 or int(sMask) < 0): QtGui.QMessageBox.about(self, "Error", "Error in short mask!") mask = '' for i in range(int(sMask)): mask += '1' while len(mask) != 32: mask += '0' #print mask m1 = mask[:8] m2 = mask[8:16] m3 = mask[16:24] m4 = mask[24:32] #if long elif (str(self.ui.lineEdit_m1.text()) != '' and str(self.ui.lineEdit_m2.text()) != '' and str(self.ui.lineEdit_m3.text()) != '' and str(self.ui.lineEdit_m4.text()) != ''): mode = 'l' lMask1 = int(self.ui.lineEdit_m1.text()) lMask2 = int(self.ui.lineEdit_m2.text()) lMask3 = int(self.ui.lineEdit_m3.text()) lMask4 = int(self.ui.lineEdit_m4.text()) #print "{0} {1} {2} {3}".format(lMask1, lMask2, lMask3, lMask4) UnitLen = self.validateLongMask(lMask1, lMask2, lMask3, lMask4) if UnitLen == -1: QtGui.QMessageBox.about(self, "Error", "Error in mask format!") else: if (lMask1 > 255 or lMask2 > 255 or lMask3 > 255 or lMask4 > 255 or lMask1 < 0 or lMask2 < 0 or lMask3 < 0 or lMask4 < 0): QtGui.QMessageBox.about(self, "Error", "Error in long mask!") else: m1 = str(self.make8bits(bin(lMask1))) m2 = str(self.make8bits(bin(lMask2))) m3 = str(self.make8bits(bin(lMask3))) m4 = str(self.make8bits(bin(lMask4))) #if empty else: QtGui.QMessageBox.about(self, "Error", "Empty mask!") if mode == 's' or mode == 'l': binIPDot = self.make8bits(bin(s1))+'.'+self.make8bits(str(bin(s2)))+'.'+\ self.make8bits(str(bin(s3)))+'.'+self.make8bits(str(bin(s4))) self.ui.label_binIP.setText(binIPDot) self.ui.label_binIP2.setText(binIPDot) binMaskDot = m1+'.'+m2+'.'+m3+'.'+m4 self.ui.label_binMask.setText(binMaskDot) self.ui.label_binMask2.setText(binMaskDot) if mode == 's': self.ui.lineEdit_m1.setText(str(int(m1, 2))) self.ui.lineEdit_m2.setText(str(int(m2, 2))) self.ui.lineEdit_m3.setText(str(int(m3, 2))) self.ui.lineEdit_m4.setText(str(int(m4, 2))) elif mode == 'l': if UnitLen >= 0: self.ui.lineEdit_s5.setText(str(UnitLen)) #calculations #netAddr netAddrStrBin = str(self.make8bits(bin(s1 & int(m1, 2))))+'.'+str(self.make8bits(bin(s2 & int(m2, 2))))+\ '.'+str(self.make8bits(bin(s3 & int(m3, 2))))+'.'+str(self.make8bits(bin(s4 & int(m4, 2)))) netAddrStr = str(s1 & int(m1, 2))+'.'+str(s2 & int(m2, 2))+'.'+str(s3 & int(m3, 2))+'.'+\ str(s4 & int(m4, 2)) self.ui.label_netAddr.setText(netAddrStrBin) self.ui.label_netAddrDec.setText(netAddrStr) #broadcastAddr broadAddrBin = self.make8bits(bin(s1|self.rev(m1)))+\ '.'+self.make8bits(bin(s2|self.rev(m2)))+\ '.'+self.make8bits(bin(s3|self.rev(m3)))+\ '.'+self.make8bits(bin(s4|self.rev(m4))) broadAddrDec = str(s1|self.rev(m1))+\ '.'+str(s2|self.rev(m2))+\ '.'+str(s3|self.rev(m3))+\ '.'+str(s4|self.rev(m4)) self.ui.label_brodAddr.setText(broadAddrBin) self.ui.label_brodAddrDec.setText(broadAddrDec) #nr of addr a = 256 - int(m1, 2) b = 256 - int(m2, 2) c = 256 - int(m3, 2) d = 256 - int(m4, 2) allAddr = a*b*c*d self.ui.label_allAddr.setText(str(allAddr)) #nr of effective addr reservedAddr = a*b*c*2 effectiveAddr = allAddr - reservedAddr if effectiveAddr < 0: effectiveAddr = 0 self.ui.label_effAddr.setText(str(effectiveAddr)) #class if ((s1 >= 0 and s1 <= 127) and\ (s2 >= 0 and s2 <= 255) and\ (s3 >= 0 and s3 <= 255) and\ (s4 >= 0 and s4 <=255)): self.ui.label_netClass.setText('A') elif ((s1 >= 128 and s1 <= 191) and\ (s2 >= 0 and s2 <= 255) and\ (s3 >= 0 and s3 <= 255) and\ (s4 >= 0 and s4 <=255)): self.ui.label_netClass.setText('B') elif ((s1 >= 192 and s1 <= 223) and\ (s2 >= 0 and s2 <= 255) and\ (s3 >= 0 and s3 <= 255) and\ (s4 >= 0 and s4 <=255)): self.ui.label_netClass.setText('C') elif ((s1 >= 244 and s1 <= 239) and\ (s2 >= 0 and s2 <= 255) and\ (s3 >= 0 and s3 <= 255) and\ (s4 >= 0 and s4 <=255)): self.ui.label_netClass.setText('D') else: self.ui.label_netClass.setText('not in class') def validateLongMask(self, m1, m2, m3, m4): str = self.make8bits(bin(m1)) + self.make8bits(bin(m2)) + self.make8bits(bin(m3)) \ + self.make8bits(bin(m4)) error = 0 pos = -1 c = 0 for i in range(32): if str[i] == '0': if c == 0 : pos = i c = pos while c < 32: if str[c] == '1': error = 1 c = c + 1 if error == 1: return -1 else: return pos # input - raw result after unpack # output - str with '0' added in front if needed to make 8 bits long def make8bits(self, string_val): string_val = str(string_val) string_val = string_val[2:] while len(string_val) < 8: string_val = '0' + string_val if len(string_val) > 8: string_val = string_val[:8] return string_val # recersing bin str def rev(self, string_val): rev_str = '' for i in string_val: if i == '0': rev_str += '1' else: rev_str += '0' return int(rev_str, 2) # ip validation def validateFail(self, ip): if not ip: return 1 try: if (int(ip) > 255 or int(ip) < 0): return 1 else: return 0 except: return 1
class DecrypterWindow(QtGui.QMainWindow): def __init__(self): """ Initializes the DecrypterWindow """ super(DecrypterWindow, self).__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) # connect event handlers self.ui.calibrateButton.clicked.connect(self.calibrateButtonHandler) self.ui.importButton.clicked.connect(self.importButtonHandler) self.ui.exportButton.clicked.connect(self.exportButtonHandler) for c in string.lowercase: self.ui.edit[c].textEdited.connect(self.editModifiedHandler) # disable unavailable functionality self.ui.importButton.setDisabled(True) self.ui.exportButton.setDisabled(True) for c in string.lowercase: self.ui.edit[c].setDisabled(True) self.decrypter = None self.show() self.setFixedSize(self.size()) def calibrateButtonHandler(self): """ Imports a calibration file and uses it to set letter frequencies """ # get path to calibration file filename = QtGui.QFileDialog.getOpenFileName(self) if len(filename) > 0: # pass path to new cypher_decriptor object self.decrypter = cypher_decriptor(filename) # enable import button self.ui.importButton.setDisabled(False) def importButtonHandler(self): """ Imports a ciphertext file and tries to decrypt it """ # get path to ciphertext filename = QtGui.QFileDialog.getOpenFileName(self) if len(filename) > 0: # pass path to self.decrypter.guess_initial_mappings self.decrypter.guess_initial_mappings(filename) # display ciphertext in upper pane self.ui.ciphertext.setPlainText(QtCore.QString(self.decrypter.cypher_text)) # display mappings mappings = self.decrypter.get_mapping() for k, v in self.ui.edit.iteritems(): v.setText(QtCore.QString(mappings[k])) # decrypt ciphertext plaintext = self.decrypter.decrypt() # show results in lower pane self.ui.plaintext.setPlainText(QtCore.QString(plaintext)) # enable export button and editing mappings self.ui.exportButton.setDisabled(False) for c in string.lowercase: self.ui.edit[c].setDisabled(False) def exportButtonHandler(self): """ Exports the putative plaintext as a text file """ filename = QtGui.QFileDialog.getSaveFileName(self) with open(filename, 'w') as f: f.write(self.decrypter.decrypt()) def editModifiedHandler(self): """ Updates the mappings and re-decrypts the ciphertext every time mappings are modified """ mappings = { c: str(self.ui.edit[c].text()) for c in string.lowercase } self.decrypter.set_mapping(mappings) plaintext = self.decrypter.decrypt() self.ui.plaintext.setPlainText(plaintext)
class ApplicationWindow(QtWidgets.QMainWindow): def __init__(self): logger.debug('Begin the program') super(ApplicationWindow, self).__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.ui_set = Set(self.ui) self.images = [None, None] self.slider_vals = [[0, 0], [0, 0]] ############## Connections ################################# logger.debug('Connections') self.ui.add_btn.clicked.connect(self.add_img) self.ui.combo_mix.currentIndexChanged.connect( lambda index: self.set_sliders(index)) for i in range(len(self.ui_set.combo_imgs)): self.connect_combo_imgs(i) for i in self.ui_set.combo_comps.keys(): self.connect_combo_comps(i) for i in range(len(self.ui_set.sliders)): self.ui_set.sliders[i].valueChanged.connect(self.mix) for i in range(len(self.ui_set.checkboxs)): self.ui_set.checkboxs[i].clicked.connect(self.mix) def connect_combo_imgs(self, i): self.ui_set.combo_imgs[i].currentIndexChanged.connect( lambda n: self.draw(i, n)) def draw(self, img_index, attr_index): logger.debug('choosing {} of image{}'.format( self.ui_set.combo_imgs[img_index].currentText(), img_index + 1)) if attr_index == 0: logger.debug('Drawing Magnitude of image{}'.format(img_index + 1)) self.draw_on(img_index + 2, 20 * np.log10(self.images[img_index].attrs[0])) else: logger.debug('Drawing {} of image{}'.format( self.ui_set.combo_imgs[img_index].currentText(), img_index + 1)) self.draw_on(img_index + 2, self.images[img_index].attrs[attr_index]) def connect_combo_comps(self, i): if i == 1: self.ui_set.combo_comps[1][1].currentIndexChanged.connect( lambda n: self.combine(n, 2)) self.ui_set.combo_comps[1][0].currentIndexChanged.connect(self.mix) if i == 2: self.ui_set.combo_comps[2][1].currentIndexChanged.connect( lambda n: self.combine(n, 1)) self.ui_set.combo_comps[2][0].currentIndexChanged.connect(self.mix) def combine(self, current_index, index_another_combo): logger.debug('Handling Component combobox') if current_index == 0: self.ui_set.combo_comps[index_another_combo][1].setCurrentIndex(1) self.ui_set.enable_checkboxs(True) if current_index == 1: self.ui_set.combo_comps[index_another_combo][1].setCurrentIndex(0) self.ui_set.enable_checkboxs(True) if current_index == 2: self.ui_set.combo_comps[index_another_combo][1].setCurrentIndex(3) self.ui_set.enable_checkboxs(False) if current_index == 3: self.ui_set.combo_comps[index_another_combo][1].setCurrentIndex(2) self.ui_set.enable_checkboxs(False) self.mix() def set_sliders( self, current_index ): # for keep track of sliders of the user change form output1 to output2 logger.debug('OutPut Changed') logger.debug('Drawing On Output{}'.format(current_index)) logger.debug('getting the previous values of sliders') for i in range(len(self.ui_set.sliders)): self.ui_set.sliders[i].blockSignals(True) self.ui_set.sliders[i].setValue(self.slider_vals[current_index][i]) self.ui_set.sliders[i].setValue(self.slider_vals[current_index][i]) self.ui_set.sliders[i].blockSignals(False) self.mix() def draw_on(self, plot_index, data): logger.debug('Draw') self.ui_set.plotItems[plot_index].clear() img = pg.ImageItem() self.ui_set.plotItems[plot_index].addItem(img) self.ui_set.plotItems[plot_index].setXRange(min=0, max=data.shape[0], padding=0) self.ui_set.plotItems[plot_index].setYRange(min=0, max=data.shape[1], padding=0) img.setImage(data.T) self.ui_set.plotItems[plot_index].autoRange(padding=0) def is_there_image(self): logger.debug('Checking if there is image !') for i in range(len(self.images)): if self.images[i] is not None: return True return False def add_img(self): logger.debug('Add Image button clicked ') current_img = self.ui.combo_add.currentIndex() filename = QFileDialog(self).getOpenFileName() path = filename[0] if path != '': if not self.is_there_image(): self.ui_set.set_combo_img(current_img) image = ImageModel(url=path) if self.check_size(image, current_img): logger.debug('Opening the image') self.images[current_img] = image self.draw_on(current_img, self.images[current_img].img_data) self.draw_on(current_img + 2, 20 * np.log10(self.images[current_img].attrs[0])) self.ui_set.enable_sliders() self.ui.combo_mix.setEnabled(True) self.mix() else: logger.debug('Error the Images must be the same size') msg = QMessageBox() msg.setWindowTitle('ERROR') msg.setText('Pls add images of the same size') msg.setIcon(QMessageBox.Critical) msg.exec_() def check_size(self, image, current_index): logger.debug('check the size of image ') if current_index == 0: try: if self.images[1].img_data.shape == image.img_data.shape: return True else: return False except: # There is one image only return True else: try: if self.images[0].img_data.shape == image.img_data.shape: return True else: return False except: # There is one image only return True def mix(self): logger.debug('Getting values to mix') current_output = self.ui.combo_mix.currentIndex() comp_imgs_index = [ self.ui_set.combo_comps[i][0].currentIndex() for i in self.ui_set.combo_comps.keys() ] # image index for each component comp_attrs_index = [ self.ui_set.combo_comps[i][1].currentIndex() for i in self.ui_set.combo_comps.keys() ] # attribute index for each component vals = np.array([ self.ui_set.sliders[i].value() / 100 for i in range(len(self.ui_set.sliders)) ]) # value for each slider for i in self.ui_set.combo_comps.keys(): logger.debug('choosing {} of {} of component{}'.format( self.ui_set.combo_comps[i][1].currentText(), self.ui_set.combo_comps[i][0].currentText(), i)) logger.debug('slider_val1 = {}, slider_val2 = {}'.format( vals[0], vals[1])) for i in range(len(self.ui_set.slider_vals)): self.ui_set.slider_vals[i].setText('{}%'.format(int(vals[i] * 100))) self.slider_vals[current_output] = vals * 100 # Checking the presence of images logger.debug('Checking the presence of images') for i in comp_imgs_index: if self.images[i] is None: logger.debug('There is no image{} to be mixed '.format(i + 1)) msg = QMessageBox() msg.setWindowTitle('ERROR') msg.setText('Pls add image {}'.format(i + 1)) msg.setIcon(QMessageBox.Critical) msg.exec_() if i == 0: self.ui_set.set_combo_img(1) else: self.ui_set.set_combo_img(0) return logger.debug('Mix') if comp_imgs_index[0] != comp_imgs_index[1]: # Two Different images if comp_attrs_index[0] == 0: if self.ui_set.checkboxs[0].isChecked( ) and self.ui_set.checkboxs[1].isChecked(): logger.debug('Uniform Magnitude, Uniform Phase') mix = self.images[comp_imgs_index[0]].mix( self.images[comp_imgs_index[1]], vals[0], vals[1], Modes.uniform_mag_phase) elif self.ui_set.checkboxs[0].isChecked(): logger.debug('Uniform Magnitude') mix = self.images[comp_imgs_index[0]].mix( self.images[comp_imgs_index[1]], vals[0], vals[1], Modes.uniform_mag) elif self.ui_set.checkboxs[1].isChecked(): logger.debug('Uniform Phase') mix = self.images[comp_imgs_index[0]].mix( self.images[comp_imgs_index[1]], vals[0], vals[1], Modes.uniform_phase) else: mix = self.images[comp_imgs_index[0]].mix( self.images[comp_imgs_index[1]], vals[0], vals[1], Modes.magnitudeAndPhase) elif comp_attrs_index[0] == 1: if self.ui_set.checkboxs[0].isChecked( ) and self.ui_set.checkboxs[1].isChecked(): mix = self.images[comp_imgs_index[0]].mix( self.images[comp_imgs_index[1]], vals[0], vals[1], Modes.uniform_mag_phase) elif self.ui_set.checkboxs[0].isChecked(): mix = self.images[comp_imgs_index[1]].mix( self.images[comp_imgs_index[0]], vals[1], vals[0], Modes.uniform_phase) elif self.ui_set.checkboxs[1].isChecked(): mix = self.images[comp_imgs_index[1]].mix( self.images[comp_imgs_index[0]], vals[1], vals[0], Modes.uniform_mag) else: mix = self.images[comp_imgs_index[1]].mix( self.images[comp_imgs_index[0]], vals[1], vals[0], Modes.magnitudeAndPhase) elif comp_attrs_index[0] == 2: mix = self.images[comp_imgs_index[0]].mix( self.images[comp_imgs_index[1]], vals[0], vals[1], Modes.realAndImaginary) else: mix = self.images[comp_imgs_index[1]].mix( self.images[comp_imgs_index[0]], vals[1], vals[0], Modes.realAndImaginary) else: # There is only one image if comp_attrs_index[0] == 0: if self.ui_set.checkboxs[0].isChecked( ) and self.ui_set.checkboxs[1].isChecked(): mix = self.images[comp_imgs_index[0]].mix( None, vals[0], vals[1], Modes.uniform_mag_phase) elif self.ui_set.checkboxs[0].isChecked(): mix = self.images[comp_imgs_index[0]].mix( None, vals[0], vals[1], Modes.uniform_mag) elif self.ui_set.checkboxs[1].isChecked(): mix = self.images[comp_imgs_index[0]].mix( None, vals[0], vals[1], Modes.uniform_phase) else: mix = self.images[comp_imgs_index[0]].mix( None, vals[0], vals[1], Modes.magnitudeAndPhase) elif comp_attrs_index[0] == 1: if self.ui_set.checkboxs[0].isChecked( ) and self.ui_set.checkboxs[1].isChecked(): mix = self.images[comp_imgs_index[0]].mix( None, vals[0], vals[1], Modes.uniform_mag_phase) elif self.ui_set.checkboxs[0].isChecked(): mix = self.images[comp_imgs_index[1]].mix( None, vals[1], vals[0], Modes.uniform_phase) elif self.ui_set.checkboxs[1].isChecked(): mix = self.images[comp_imgs_index[1]].mix( None, vals[1], vals[0], Modes.uniform_mag) else: mix = self.images[comp_imgs_index[1]].mix( None, vals[1], vals[0], Modes.magnitudeAndPhase) elif comp_attrs_index[0] == 2: mix = self.images[comp_imgs_index[0]].mix( None, vals[0], vals[1], Modes.realAndImaginary) else: mix = self.images[comp_imgs_index[1]].mix( None, vals[1], vals[0], Modes.realAndImaginary) self.draw_on(current_output + 4, mix)
class MainWindow(QtGui.QMainWindow): def __init__(self, N): super(MainWindow, self).__init__() # This is always the same self.ui = Ui_MainWindow() self.ui.setupUi(self) # no resizing self.setFixedSize(self.width(), self.height()) from sph_demo import SPHDemo enable_advanced_rendering = not '--disable-advanced-rendering' in sys.argv self.sph_demo = SPHDemo(N, size=(self.ui.fluid.width(), self.ui.fluid.height()), enable_advanced_rendering=enable_advanced_rendering) # ui.fluid is the FluidWidget QGLWidget-widget. self.ui.fluid.init(self.sph_demo) self.ui.fluid.gl_initialized.connect(self.update_gui_from_params) self.setup_signals() statusBarInfo = QtGui.QLabel() statusBarInfo.setText("%s particles, initial density: %s, mass: %.02f, gas constant k: %s, timestep: %.05f" % ( self.sph_demo.fluid_simulator.N, self.sph_demo.fluid_simulator.density0, self.sph_demo.fluid_simulator.mass, self.sph_demo.fluid_simulator.k, self.sph_demo.fluid_simulator.dt )) self.statusBarFps = QtGui.QLabel() self.statusBar().addPermanentWidget(self.statusBarFps) self.statusBar().addWidget(statusBarInfo) if not self.sph_demo.enable_advanced_rendering: # disable ui elements dealing with advanced rendering self.ui.rm_points.setChecked(True) for el in (self.ui.rm_balls, self.ui.rm_advanced, self.ui.advanced,): el.setEnabled(False) def setup_signals(self): """ Set up callbacks for the widgets. """ ui = self.ui self.fps_timer = QtCore.QTimer() def callback(): self.statusBarFps.setText("%.2f fps" % self.sph_demo.fps) self.fps_timer.timeout.connect(callback) self.fps_timer.start(1000) def callback(p): self.sph_demo.params.paused = p ui.paused.toggled.connect(callback) if self.sph_demo.enable_advanced_rendering: #from fluid_rendering.fluid_renderer import FluidRenderer def callback(p): self.sph_demo.params.blur_thickness_map = p ui.blur_thickness_map.toggled.connect(callback) def callback(p): self.sph_demo.params.render_mean_curvature = p ui.render_mean_curvature.toggled.connect(callback) def callback(): self.sph_demo.params.render_mode = 0 ui.rm_points.pressed.connect(callback) def callback(): self.sph_demo.params.render_mode = 1 ui.rm_balls.pressed.connect(callback) def callback(): self.sph_demo.params.render_mode = 2 ui.rm_advanced.pressed.connect(callback) ui.rm_advanced.toggled.connect(ui.advanced.setEnabled) def callback(n): self.sph_demo.params.smoothing_iterations = n ui.smoothing_iterations.valueChanged.connect(callback) def callback(n): self.sph_demo.params.smoothing_z_contrib = n ui.smoothing_z_contrib.valueChanged.connect(callback) def update_gui_from_params(self): params = self.sph_demo.params if not params.dirty: return ui = self.ui ui.paused.setOn(params.paused) if self.sph_demo.enable_advanced_rendering: from fluid_rendering.fluid_renderer import FluidRenderer ui.blur_thickness_map.setOn(params.blur_thickness_map) ui.render_mean_curvature.setOn(params.render_mean_curvature) { FluidRenderer.RENDERMODE_POINTS: ui.rm_points, FluidRenderer.RENDERMODE_BALLS: ui.rm_balls, FluidRenderer.RENDERMODE_ADVANCED: ui.rm_advanced }[params.render_mode].setChecked(True) ui.smoothing_iterations.setValue(params.smoothing_iterations) ui.smoothing_z_contrib.setValue(params.smoothing_z_contrib) ui.advanced.setEnabled(ui.rm_advanced.isChecked()) params.dirty = False def keyPressEvent(self, event): """ Handle keyboard shortcuts """ key = event.key() params = self.sph_demo.params if key == QtCore.Qt.Key_R: self.sph_demo.fluid_simulator.set_positions() elif key == QtCore.Qt.Key_P: params.paused = not params.paused elif key == QtCore.Qt.Key_B: params.blur_thickness_map = not params.blur_thickness_map elif key == QtCore.Qt.Key_N: params.render_mode = (params.render_mode+1) % self.sph_demo.fluid_renderer.number_of_render_modes elif key == QtCore.Qt.Key_C: params.render_mean_curvature = not params.render_mean_curvature else: super(MainWindow, self).keyPressEvent(event) self.update_gui_from_params()
class Main(QtGui.QMainWindow): """ Esta es una grilla """ def __init__(self): super(Main, self).__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.load_data() self.connect_signals() self.show() def connect_signals(self): self.ui.agregar_marca.clicked.connect(self.add) #self.ui.eliminar_marca.connect(self.delete) def add(self): self.ui.form = FormAlumno(self) self.ui.form.accepted.connect(self.load_data) self.ui.form.show() def load_data(self): """ Función que carga la información de marcas en la grilla incluyendo la cantidad de modelos asociados a la marca """ marcas = db_marcas.obtener_marcas() #Creamos el modelo asociado a la tabla self.data = QtGui.QStandardItemModel(len(marcas)+1, 3) self.data.setHorizontalHeaderItem( 0, QtGui.QStandardItem(u"Nombre de Marca")) self.data.setHorizontalHeaderItem( 1, QtGui.QStandardItem(u"País de Origen")) self.data.setHorizontalHeaderItem( 2, QtGui.QStandardItem(u"Cantidad de Modelos")) for r, row in enumerate(marcas): index = self.data.index(r, 0, QtCore.QModelIndex()) self.data.setData(index, row['Nombre de Marca']) index = self.data.index(r, 1, QtCore.QModelIndex()) self.data.setData(index, row['País de Origen']) index = self.data.index(r, 2, QtCore.QModelIndex()) self.data.setData(index, row['Cantidad de Modelos']) self.ui.tabla_marcas.setModel(self.data) # Para que las columnas 1 y 2 se estire o contraiga cuando # se cambia el tamaño de la pantalla self.ui.tabla_marcas.horizontalHeader().setResizeMode( 0, self.ui.tabla_marcas.horizontalHeader().Stretch) self.ui.tabla_marcas.horizontalHeader().setResizeMode( 1, self.ui.tabla_marcas.horizontalHeader().Stretch) self.ui.tabla_marcas.setColumnWidth(0, 100) self.ui.tabla_marcas.setColumnWidth(1, 210) self.ui.tabla_marcas.setColumnWidth(2, 210) def delete(self): """ Función que intenta borrar un alumno de la base de datos e indica el resultado de la operación """ # ANTES DE REALIZAR LA ACCIÓN SE DEBERÍA PREGUNTAR # AL USUARIO CONFIRMAR LA OPERACIÓN !!!!!!!!!!!!!! data = self.ui.tabla_marcas.model() index = self.ui.tabla_marcas.currentIndex() if index.row() == -1: # No se ha seleccionado una fila self.errorMessageDialog = QtGui.QErrorMessage(self) self.errorMessageDialog.showMessage(u"Debe seleccionar una fila") return False else: if tkMessageBox.askyesno( "Borrar Marca", "Deseas borrar esta marca?"): marca = data.index( index.row(), 0, QtCore.QModelIndex()).data() if (db_marcas.borrar(marca)): self.load_data() msgBox = QtGui.QMessageBox() msgBox.setText(u"EL registro fue eliminado.") msgBox.exec_() return True else: self.ui.errorMessageDialog = QtGui.QErrorMessage(self) self.ui.errorMessageDialog.showMessage( u"Error al eliminar el registro") return False ########### rehacer.. def edit(self): """ Función obtiene el alumno seleccionado en la grilla para poner sus datos en el formulario para su edición data = self.ui.tabla_marcas.model() index = self.ui.tabla_marcas.currentIndex() if index.row() == -1: # No se ha seleccionado una fila self.errorMessageDialog = QtGui.QErrorMessage(self) self.errorMessageDialog.showMessage(u"Debe seleccionar una fila") return False else: rut = data.index(index.row(), 0, QtCore.QModelIndex()).data() self.ui.form = FormAlumno(self, rut) self.ui.form.accepted.connect(self.load_data) self.ui.form.show() """ pass
class MainWindow(QMainWindow): '''First application window the user sees''' command = pyqtSignal(str, str) # (tag, payload) networkUpdate = pyqtSignal(str, int) # (host, port) def __init__(self, pod): super().__init__() MainWindow.console = ConsoleWidget( namespace = { 'pod': pod, 'win': self, }, text='You can use this window to enter Python commands.') MainWindow.console.setWindowTitle('Python interaction') self._ui = Ui_MainWindow() self._ui.setupUi(self) self._ui.startButton.clicked.connect(pod.begin) self._ui.submitButton.clicked.connect(self.submitCommand) pod.connected.connect(self.enable) self._ui.actionSettings.triggered.connect(self.networkDialog) self._ui.actionReconnect.triggered.connect(pod.begin) self._ui.actionConsoleOpen.triggered.connect(self.openConsole) pod.add_listener('*', self.appendNetworkLog) pod.add_listener('v', self.updateVelocityLCD) pod.add_listener('v', self._ui.velocityPlot.datum) pod.add_listener('h', self.updateHeightLCD) pod.add_listener('h', self._ui.heightPlot.datum) pod.add_listener('d', self.updateDistanceLCD) pod.add_listener('d', self._ui.distancePlot.datum) self.command.connect(pod) self.networkUpdate.connect(pod.try_connect) self.timer = QTimer() self.timer.timeout.connect(self._ui.velocityPlot.update) self.timer.timeout.connect(self._ui.heightPlot.update) self.timer.timeout.connect(self._ui.distancePlot.update) self.timer.start(_1s) @pyqtSlot() def enable(self): self._ui.startButton.setDisabled(True) self._ui.submitButton.setDisabled(False) @pyqtSlot(str) def updateVelocityLCD(self, new): self._ui.velocityLCD.display(new) @pyqtSlot(str) def updateHeightLCD(self, new): self._ui.heightLCD.display(new) @pyqtSlot(str) def updateDistanceLCD(self, new): self._ui.distanceLCD.display(new) def submitCommand(self): tag = self._ui.tagLineEdit.text() body = self._ui.bodyLineEdit.text() if tag == '' or body == '': return self.command.emit(tag, body) def sendStartMessage(self): return 'start' def openConsole(self): '''Open a console for Python interaction''' MainWindow.console.show() def networkDialog(self): '''Open a window for changing network settings''' dialog = NetworkDialog() if dialog.exec_() == QDialog.Accepted: self.networkUpdate.emit(dialog.host, dialog.port) @pyqtSlot(str) def appendNetworkLog(self, text): self._ui.networkLog.appendPlainText(text)
class M2Todo(QApplication): def __init__(self, **args): super(QApplication, self).__init__([]) self.setApplicationName(NAME) self.setApplicationVersion(VERSION) self.setOrganizationName(COMPANY) self.setOrganizationDomain(DOMAIN) self.settings = QSettings() self._mw = QMainWindow() self.ui = Ui_MainWindow() self.ui.setupUi(self._mw) self.ui.actionOpen_MM.triggered.connect(self.openMM) self.ui.actionOpen_M2T.triggered.connect(self.openM2T) self.ui.actionMerge.triggered.connect(self.merge) self.ui.actionSave.triggered.connect(self.save) self.ui.actionSave_As.triggered.connect(self.saveAs) self.ui.actionAbout_M2Todo.triggered.connect(self.about) self.ui.actionHelp.triggered.connect(self.help) self.ui.actionFreeMind.triggered.connect(self.launchFreemind) self.ui.treeWidget.itemChanged.connect(self.itemStriker) self._openPath = None self._savePath = None self.ui.actionMerge.setDisabled(True) self._mw.show() lastFile = str(self.settings.value("session/lastOpenFile", None).toString()) if lastFile: fType = self.settings.value("session/lastOpenFileType") self._openPath = {"type": fType, "path": lastFile} if fType == "m2t": self._parseM2T(lastFile) elif fType == "mm": self._parseMM(lastFile) self._mw.statusBar().showMessage(lastFile) self._mw.setWindowTitle(basename(str(lastFile)) + " - M2Todo") self.ui.actionMerge.setDisabled(False) # not debug!! here because it's always the last thing to do # even if/when we have a "last open file" option self.ui.actionSave.setDisabled(True) @pyqtSlot() def launchFreemind(self): try: subprocess.Popen(["freemind"]) except OSError: QMessageBox.critical( self._mw, "Freemind not found", "FreeMind was not found. If you installed it, add the " + "installation directory to your PATH.", ) def saveM2TState(self, *args): print args """ save details of last open file """ if self._openPath is not None: self.settings.setValue("session/lastOpenFile", self._openPath["path"]) self.settings.setValue("session/lastOpenFileType", self._openPath["type"]) @pyqtSlot("QTreeWidgetItem*", int) def itemStriker(self, item, column, *args): """ modify widgets depending on check state """ # re-enable the save button self.ui.actionSave.setDisabled(False) # strike / unstrike state = item.checkState(0) if state == Qt.Checked: strikeItem(item, True) elif state == Qt.Unchecked: strikeItem(item, False) # recurse down if item.childCount() > 0: for i in xrange(0, item.childCount()): item.child(i).setCheckState(0, state) @pyqtSlot(bool) def openMM(self, *args): """ open a FreeMind file """ mmPath = QFileDialog.getOpenFileName( self.ui.menubar, "Select MM file", expanduser("~"), "FreeMind files (*.mm);;All Files(*.*)" ) if not mmPath.isEmpty(): self.ui.treeWidget.clear() self._openPath = {"type": "mm", "path": str(mmPath)} self._savePath = None self._parseMM(mmPath) self.ui.actionSave.setDisabled(False) self._mw.statusBar().showMessage(mmPath) self._mw.setWindowTitle(basename(str(mmPath)) + " - M2Todo") self.saveM2TState() @pyqtSlot(bool) def openM2T(self, *args): """ Open a M2Todo file """ m2tPath = QFileDialog.getOpenFileName( self.ui.menubar, "Select M2T file", expanduser("~"), "M2T files (*.m2t);;All Files(*.*)" ) if not m2tPath.isEmpty(): self.ui.treeWidget.clear() self._openPath = {"type": "m2t", "path": str(m2tPath)} self._savePath = str(m2tPath) self._parseM2T(m2tPath) self.ui.actionSave.setDisabled(False) self._mw.statusBar().showMessage(m2tPath) self._mw.setWindowTitle(basename(str(m2tPath)) + " - M2Todo") self.saveM2TState() @pyqtSlot(bool) def save(self, *args): """ Save a M2Todo file """ if self._openPath is None: return if self._savePath is None: opened = self._openPath["path"] if not opened.endswith(".m2t"): orig, ext = splitext(opened) opened = orig + ".m2t" savePath = QFileDialog.getSaveFileName(self.ui.menubar, "Save", opened, "M2T file (*.m2t)") if savePath.isEmpty(): return # user cancelled action self._savePath = savePath self._writeM2T(self._savePath) self.ui.actionSave.setDisabled(True) self._mw.statusBar().showMessage(self._savePath) self._mw.setWindowTitle(basename(str(self._savePath)) + " - M2Todo") self.saveM2TState() @pyqtSlot(bool) def saveAs(self, *args): """ Save a M2Todo file with new name""" savePath = QFileDialog.getSaveFileName(self.ui.menubar, "Save As", expanduser("~"), "M2T file (*.m2t)") if not savePath.isEmpty(): self._savePath = savePath self._writeM2T(self._savePath) self.ui.actionSave.setDisabled(True) self._mw.statusBar().showMessage(self._savePath) self._mw.setWindowTitle(basename(str(self._savePath)) + " - M2Todo") self.saveM2TState() ### Parsing / writing utils ### def _writeM2T(self, path): # build our dom root = etree.Element("m2t") for i in xrange(0, self.ui.treeWidget.topLevelItemCount()): self._buildNodeFromItem(self.ui.treeWidget.topLevelItem(i), root) # first node has no checked state del root.find(".//node").attrib["m2t_checked"] etree.ElementTree(root).write(path, "utf-8") def _buildNodeFromItem(self, item, parentNode): el = etree.SubElement( parentNode, "node", { "ID": str(item.data(0, Qt.UserRole).toString()), "TEXT": item.text(0), "m2t_checked": str(int(item.checkState(0))), }, ) if item.childCount() > 0: for i in xrange(0, item.childCount()): self._buildNodeFromItem(item.child(i), el) def _parseMM(self, mmPath): doc = parse(str(mmPath)) self._parseNode(doc.firstChild) doc.unlink() def _parseM2T(self, m2tPath): doc = parse(str(m2tPath)) self._parseNode(doc.firstChild) doc.unlink() def _parseNode(self, node, parentItem=None): # ignore everything that is not a node item = None if node.nodeName == "node": if parentItem is not None: item = QTreeWidgetItem(parentItem) else: item = QTreeWidgetItem(self.ui.treeWidget) if node.hasAttribute("TEXT"): item.setText(0, node.attributes["TEXT"].value) else: # html nodes bodyNodes = node.getElementsByTagName("html") if len(bodyNodes) > 0: text = stripTags(bodyNodes[0].toxml()).strip() item.setText(0, text) if node.hasAttribute("m2t_checked"): checked = int(node.attributes["m2t_checked"].value) item.setCheckState(0, checked) elif parentItem is not None: item.setCheckState(0, 0) # unchecked # expand unchecked nodes only if item.checkState(0) == Qt.Checked: item.setExpanded(False) else: item.setExpanded(True) # save the ID item.setData(0, Qt.UserRole, str(node.attributes["ID"].value)) if node.hasChildNodes(): for n in node.childNodes: self._parseNode(n, item) @pyqtSlot() def merge(self): """ merge current view with a previously-saved M2T """ # first we get the old m2t path oldPath = QFileDialog.getOpenFileName( self.ui.menubar, "Select M2T file to merge", expanduser("~"), "M2T files (*.m2t);;All Files(*.*)" ) if oldPath.isEmpty(): return # cancel action # then we save a copy of the current view, so that we have a m2t tempFile = QTemporaryFile() tempFile.setAutoRemove(False) tempFile.open() tempFile.close() self._writeM2T(tempFile.fileName()) # then we merge old = etree.parse(str(oldPath)) new = etree.parse(str(tempFile.fileName())) oldMap = {} # get statuses in the old file for node in old.findall(".//node"): if node.attrib.has_key("m2t_checked"): checked = node.attrib["m2t_checked"] oldMap[node.attrib["ID"]] = checked # set statuses in new file for node in new.findall(".//node"): nodeId = node.attrib["ID"] if oldMap.has_key(nodeId): node.attrib["m2t_checked"] = oldMap[nodeId] # write down the result new.write(tempFile.fileName(), "utf-8") # reload the view self.ui.treeWidget.clear() self._parseM2T(str(tempFile.fileName())) self.ui.actionSave.setDisabled(False) tempFile.remove() def printTree(self): pixmap = QPixmap.grabWidget(self.ui.treeWidget) printer = QPrinter() printDlg = QPrintDialog(self, printer, self._mw) if printDlg.exec_() == QDialog.Accepted: # print pass @pyqtSlot() def about(self): template = ( "%(name)s v. %(version)s \n\n%(name)s is copyright @ " + "%(year)s %(author)s\n\n" + "This program is free software; you can redistribute it and/or " + "modify it under the terms of the GNU General Public License " + "as published by the Free Software Foundation; either version " + "3 of the License, or any later version.\n\n" + "This program is distributed in the hope that it will be " + "useful, but WITHOUT ANY WARRANTY; without even the implied " + "warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR " + "PURPOSE. See the GNU General Public License for more details." + "\n\nYou should have received a copy of the GNU General Public " + "License along with this program; if not, write to the Free " + "Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, " + "MA 02111-1307, USA." ) QMessageBox.about( self._mw, "About %(name)s" % NAME, template % {"name": NAME, "version": VERSION, "year": date.today().year, "author": AUTHOR}, ) @pyqtSlot() def help(self): QMessageBox.information( self._mw, "Help", """Once you open a FreeMind ".mm" file with File->Open MM, """ + """it will be converted to the "M2T" format. The original file will be preserved. You can then mark actions as "done" by ticking their boxes, and the status """ + """will be saved in the M2T file once you click on File->Save or File->Save As. You can open any M2T file with File->Open M2T. By default, the program will""" + """ reopen the last open file, be it MM or M2T. If you modify your original MM, you can merge the changes in this way: 1 - Open the new MM (File->Open MM) 2 - Click on Tools->Merge, then select the M2T file you want to merge (i.e.""" + """where you saved your progress) 3 - the view will now reflect the merged state, and you can save it as a """ + """new M2T or overwrite the old M2T. Tools->FreeMind launches FreeMind in a separate window.""", )
class Gui(QtGui.QMainWindow): """ Main GUI Class It contains the main function and interfaces between the GUI and functions """ def __init__(self,parent=None): QtGui.QWidget.__init__(self,parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) """ Main Variables Using Other Classes""" self.rex = Rexarm() self.video = Video(cv2.VideoCapture(0)) """ Other Variables """ self.last_click = np.float32([0,0]) """ Set GUI to track mouse """ QtGui.QWidget.setMouseTracking(self,True) """ Video Function Creates a timer and calls play() function according to the given time delay (27mm) """ self._timer = QtCore.QTimer(self) self._timer.timeout.connect(self.play) self._timer.start(27) """ LCM Arm Feedback Creates a timer to call LCM handler continuously No delay implemented. Reads all time """ self._timer2 = QtCore.QTimer(self) self._timer2.timeout.connect(self.rex.get_feedback) self._timer2.start() """ Connect Sliders to Function TO DO: CONNECT THE OTHER 5 SLIDERS IMPLEMENTED IN THE GUI """ self.ui.sldrBase.valueChanged.connect(self.slider_change) self.ui.sldrShoulder.valueChanged.connect(self.slider_change) self.ui.sldrElbow.valueChanged.connect(self.slider_change) self.ui.sldrWrist.valueChanged.connect(self.slider_change) self.ui.sldrMaxTorque.valueChanged.connect(self.slider_change) self.ui.sldrSpeed.valueChanged.connect(self.slider_change) """ Commands the arm as the arm initialize to 0,0,0,0 angles """ self.slider_change() """ Connect Buttons to Functions """ self.ui.btnLoadCameraCal.clicked.connect(self.load_camera_cal) self.ui.btnPerfAffineCal.clicked.connect(self.affine_cal) self.ui.btnTeachRepeat.clicked.connect(self.tr_initialize) self.ui.btnAddWaypoint.clicked.connect(self.tr_add_waypoint) self.ui.btnSmoothPath.clicked.connect(self.tr_smooth_path) self.ui.btnPlayback.clicked.connect(self.tr_playback) self.ui.btnDefineTemplate.clicked.connect(self.def_template) self.ui.btnLocateTargets.clicked.connect(self.template_match) self.ui.btnExecutePath.clicked.connect(self.exec_path) self.ui.path_start_time = None self.executed_path = [] self.get_template = 0 self.templat_point = None self.donuts = [] def play(self): """ Play Funtion Continuously called by GUI """ """ Renders the Video Frame """ try: self.video.captureNextFrame() self.ui.videoFrame.setPixmap( self.video.convertFrame()) self.ui.videoFrame.setScaledContents(True) except TypeError: print "No frame" """ Update GUI Joint Coordinates Labels TO DO: include the other slider labels """ self.ui.rdoutBaseJC.setText(str(self.rex.joint_angles_fb[0]*R2D)) self.ui.rdoutShoulderJC.setText(str(self.rex.joint_angles_fb[1]*R2D)) self.ui.rdoutElbowJC.setText(str(self.rex.joint_angles_fb[2]*R2D)) self.ui.rdoutWristJC.setText(str(self.rex.joint_angles_fb[3]*R2D)) t = [self.rex.joint_angles_fb[0], self.rex.joint_angles_fb[1] - 90.0 * D2R, self.rex.joint_angles_fb[2], self.rex.joint_angles_fb[3]] a = [0.0, 100.0, 100.0, 108.0] d = [116.0, 0.0, 0.0, 0.0] al = [-90.0 * D2R, 0.0 * D2R, 0.0 * D2R, 0.0 * D2R] dh_table = [t,a,d,al] (x, y, z, phi) = self.rex.rexarm_FK(dh_table, 3) self.ui.rdoutX.setText(str(x)) self.ui.rdoutY.setText(str(y)) self.ui.rdoutZ.setText(str(z)) self.ui.rdoutT.setText(str(phi*R2D)) # res = self.rex.rexarm_IK((0.0,-275.0,80.0,0.0), 1) # if res != None: # self.rex.joint_angles[0] = res[0] # self.rex.joint_angles[1] = res[1] # self.rex.joint_angles[2] = res[2] # self.rex.joint_angles[3] = res[3] # self.rex.cmd_publish() """ Mouse position presentation in GUI TO DO: after getting affine calibration make the apprriate label to present the value of mouse position in world coordinates """ x = QtGui.QWidget.mapFromGlobal(self,QtGui.QCursor.pos()).x() y = QtGui.QWidget.mapFromGlobal(self,QtGui.QCursor.pos()).y() if ((x < MIN_X) or (x > MAX_X) or (y < MIN_Y) or (y > MAX_Y)): self.ui.rdoutMousePixels.setText("(-,-)") self.ui.rdoutMouseWorld.setText("(-,-)") else: x = x - MIN_X y = y - MIN_Y self.ui.rdoutMousePixels.setText("(%.0f,%.0f)" % (x,y)) if (self.video.aff_flag == 2): """ TO DO Here is where affine calibration must be used """ aff = self.video.aff_matrix wx = x*aff[0][0] + y*aff[0][1] + aff[0][2] wy = x*aff[1][0] + y*aff[1][1] + aff[1][2] self.ui.rdoutMouseWorld.setText("(%.2f,%.2f)" %(wx,wy)) else: self.ui.rdoutMouseWorld.setText("(-,-)") """ Updates status label when rexarm playback is been executed. This will be extended to includ eother appropriate messages THIS SHOULD BE LAST BECAUSE IT RETURNS EARLY!!!!!!!! (Pedro don't be sad please) """ if(self.rex.plan_status == 1): if self.rex.wpt_total == 0: self.ui.rdoutStatus.setText("No waypoints!") self.rex.plan_status = 0 else: self.ui.rdoutStatus.setText("Playing Back - Waypoint %d" %(self.rex.wpt_number + 1)) [start_time, prev_waypoint, prev_vel] = self.rex.plan[self.rex.wpt_number-1] [end_time, current_waypoint, current_vel] = self.rex.plan[self.rex.wpt_number] t = float(micro_time() - self.path_start_time) #Linear Interp for joint in range(4): #Set the goal self.rex.joint_angles[joint] = current_waypoint[joint] #Figure the speed out dist = abs(current_waypoint[joint] - prev_waypoint[joint]) time_left = (end_time - t)/1000000.0 v = dist/time_left # rad/sec * sec/min * rot/rad / max RPM speed_val = v * (60.0/(2*math.pi)) / 59.0 speed_val = max(speed_val, 1.0/1023.0) print speed_val, time_left if time_left < 0: #were behind haul ass self.rex.speed[joint] = 1.0 else: self.rex.speed[joint] = speed_val self.rex.cmd_publish() #Check if we have arrived def within_error(joint, wpt): #print joint, wpt error = math.fabs(joint * R2D - wpt * R2D) #print error return error < 5.0 if within_error(self.rex.joint_angles_fb[0], current_waypoint[0]) and \ within_error(self.rex.joint_angles_fb[1], current_waypoint[1]) and \ within_error(self.rex.joint_angles_fb[2], current_waypoint[2]) and \ within_error(self.rex.joint_angles_fb[3], current_waypoint[3]): print "Within Error Bounds: %d" %(self.rex.wpt_number) self.rex.wpt_number += 1 self.executed_path.append([micro_time() - self.path_start_time , self.rex.joint_angles_fb[:]]) if self.rex.wpt_number >= len(self.rex.plan): self.rex.plan_status = 0 self.ui.rdoutStatus.setText("Plan finished!") self.rex.speed = [0.5, 0.5, 0.5, 0.5] self.rex.plan = self.rex.plan[1:] with open('executed_path.config', 'w') as f: pickle.dump(self.executed_path, f) def slider_change(self): """ Function to change the slider labels when sliders are moved and to command the arm to the given position TO DO: Implement for the other sliders """ self.ui.rdoutBase.setText(str(self.ui.sldrBase.value())) self.ui.rdoutShoulder.setText(str(self.ui.sldrShoulder.value())) self.ui.rdoutElbow.setText(str(self.ui.sldrElbow.value())) self.ui.rdoutWrist.setText(str(self.ui.sldrWrist.value())) self.ui.rdoutTorq.setText(str(self.ui.sldrMaxTorque.value()) + "%") self.ui.rdoutSpeed.setText(str(self.ui.sldrSpeed.value())) if self.rex.plan_status == 0: self.rex.max_torque = self.ui.sldrMaxTorque.value()/100.0 self.rex.joint_angles[0] = self.ui.sldrBase.value()*D2R self.rex.joint_angles[1] = self.ui.sldrShoulder.value()*D2R self.rex.joint_angles[2] = self.ui.sldrElbow.value()*D2R self.rex.joint_angles[3] = self.ui.sldrWrist.value()*D2R self.rex.cmd_publish() def solveAffineMatrix(self): A = [] b = [] for i in range(self.video.aff_npoints): px = self.video.mouse_coord[i][0] py = self.video.mouse_coord[i][1] wx = self.video.real_coord[i][0] wy = self.video.real_coord[i][1] A.append([px, py, 1.0, 0.0, 0.0, 0.0]) A.append([0.0, 0.0, 0.0, px, py, 1.0]) b.append(wx) b.append(wy) print A, '\n', b x, res, rank, s = np.linalg.lstsq(A, b) print x self.video.aff_matrix = [[x[0], x[1], x[2]], [x[3], x[4], x[5]], [0.0, 0.0, 1.0]] def mousePressEvent(self, QMouseEvent): """ Function used to record mouse click positions for affine calibration """ """ Get mouse posiiton """ x = QMouseEvent.x() y = QMouseEvent.y() """ If mouse position is not over the camera image ignore """ if ((x < MIN_X) or (x > MAX_X) or (y < MIN_Y) or (y > MAX_Y)): return """ Change coordinates to image axis """ self.last_click[0] = x - MIN_X self.last_click[1] = y - MIN_Y """ If affine calibration is been performed """ if (self.video.aff_flag == 1): """ Save last mouse coordinate """ self.video.mouse_coord[self.video.mouse_click_id] = [(x-MIN_X), (y-MIN_Y)] """ Update the number of used poitns for calibration """ self.video.mouse_click_id += 1 """ Update status label text """ self.ui.rdoutStatus.setText("Affine Calibration: Click point %d" %(self.video.mouse_click_id + 1)) """ If the number of click is equal to the expected number of points computes the affine calibration. TO DO: Change this code to use you programmed affine calibration and NOT openCV pre-programmed function as it is done now. """ if(self.video.mouse_click_id == self.video.aff_npoints): """ Update status of calibration flag and number of mouse clicks """ self.video.aff_flag = 2 self.video.mouse_click_id = 0 """ Perform affine calibration with OpenCV """ #self.video.aff_matrix = cv2.getAffineTransform( # self.video.mouse_coord, # self.video.real_coord) self.solveAffineMatrix() print self.video.aff_matrix """ Updates Status Label to inform calibration is done """ self.ui.rdoutStatus.setText("Waiting for input") """ Uncomment to gether affine calibration matrix numbers on terminal """ #print self.video.aff_matrix if self.get_template == 1: self.template_point = [(x-MIN_X)*(960.0/480.0), (y-MIN_Y)*(1280.0/640.0)] self.get_template += 1 elif self.get_template == 2: self.get_template = 0 bottom_point = [(x-MIN_X)*(960.0/480.0), (y-MIN_Y)*(1280.0/640.0)] dx = bottom_point[0] - self.template_point[0] dy = bottom_point[1] - self.template_point[1] grey_frame = cv2.cvtColor(self.video.currentFrame, cv2.COLOR_BGR2GRAY) self.template = grey_frame[self.template_point[1]-dy:bottom_point[1], self.template_point[0]-dx:bottom_point[0]] #self.template = cv2.cvtColor(self.template, cv2.COLOR_BGR2GRAY) cv2.imwrite('./template.png', self.template) print "Got Template" def affine_cal(self): """ Function called when affine calibration button is called. Note it only chnage the flag to record the next mouse clicks and updates the status text label """ self.video.aff_flag = 1 self.ui.rdoutStatus.setText("Affine Calibration: Click point %d" %(self.video.mouse_click_id + 1)) def load_camera_cal(self): print "Load Camera Cal" self.video.loadCalibration() def tr_initialize(self): print "Teach and Repeat" self.path_start_time = micro_time() self.rex.plan = [] self.rex.plan_status = 0 self.rex.wpt_number = 0 self.rex.max_torque = 0.0 self.ui.sldrMaxTorque.setValue(0.0) def tr_add_waypoint(self): print "Add Waypoint" self.rex.plan.append([micro_time() - self.path_start_time, self.rex.joint_angles_fb[:], [0,0,0,0]]) self.rex.wpt_total += 1 def tr_smooth_path(self): print "Smooth Path" #Basic smoothing new_plan = [] #for i, (t, p) in enumerate(self.rex.plan): # np = p[:] # nt = t + 1000000 * i + 500000 # if p[1] < 0: # np[1] += 10*D2R # else: # np[1] -= 10*D2R # # new_plan.append([nt-500000, np]) # new_plan.append([nt, p[:]]) # new_plan.append([nt+500000, np]) self.rex.plan = [[0, [0, 0, 0, 0], [0,0,0,0]]] + self.rex.plan #Handle all other points for i in range(1,len(self.rex.plan)): [tprev, qprev, vprev] = self.rex.plan[i-1] [ti, qi, vi] = self.rex.plan[i] dt = (ti - tprev) * 0.3 nprev = qprev[:] if nprev[1] < 0: nprev[1] += 10*D2R else: nprev[1] -= 10*D2R ni = qi[:] if ni[1] < 0: ni[1] += 10*D2R else: ni[1] -= 10*D2R new_plan.append([tprev + dt, nprev, vprev]) new_plan.append([ti - dt, ni, vi]) new_plan.append([ti, qi[:], vi]) #Handle last point [ti, pi, vi] = self.rex.plan[-1] ni = qi[:] if ni[1] < 0: ni[1] += 10*D2R else: ni[1] -= 10*D2R new_plan.append([ti+500000, ni, vi]) self.rex.plan = new_plan[1:] #Cubic spline smoothing # new_plan = [self.rex.plan[0][:]] # for i in range(1,len(self.rex.plan)): # [start_time, prev_waypoint, prev_vel] = self.rex.plan[i-1] # [end_time, current_waypoint, current_vel] = self.rex.plan[i] # a0 = [0,0,0,0] # a1 = [0,0,0,0] # a2 = [0,0,0,0] # a3 = [0,0,0,0] # for joint in range(4): # def calc_params(t0, q0, v0, tf, qf, vf): # a0 = q0 # a1 = v0 # a2 = (3.0*(qf-q0)-(2.0*v0+vf)*(tf-t0))/math.pow(tf-t0, 2) # a3 = (2.0*(q0-qf) + (v0+vf)*(tf-t0))/math.pow(tf-t0, 3) # return a0, a1, a2, a3 # a0[joint], a1[joint], a2[joint], a3[joint] = calc_params(0.0,\ # float(prev_waypoint[joint]),\ # float(prev_vel[joint]),\ # 1.0,\ # float(current_waypoint[joint]),\ # float(current_vel[joint])) # duration = end_time - start_time # for frac in range(1,100,10): # frac = float(frac) / 100.0 # time = start_time + int(duration * frac) # q = [0,0,0,0] # for joint in range(4): # q[joint] = a0[joint] + a1[joint] * frac + a2[joint] * frac * frac + a3[joint] * frac * frac * frac # new_plan.append([time, q[:], [0.0, 0.0, 0.0, 0.0]]) # #Add the destination point # new_plan.append(self.rex.plan[i][:]) # with open('smooth_path.config', 'w') as f: # print len(new_plan) # pickle.dump(new_plan, f) # with open('path.config', 'w') as f: # pickle.dump(self.rex.plan, f) # self.rex.plan = new_plan def tr_playback(self): print "Playback" self.path_start_time = micro_time() self.rex.wpt_number = 1 self.rex.plan_status = 1 self.rex.max_torque = 50.0 self.ui.sldrMaxTorque.setValue(50.0) self.executed_path = [] with open('path.config', 'w') as f: pickle.dump(self.rex.plan, f) self.rex.plan = [[micro_time() - self.path_start_time, self.rex.joint_angles_fb[:], [0,0,0,0]]] + self.rex.plan def def_template(self): print "Define Template" self.get_template = 1 def template_match(self): print "Template Match" def make_bounding_box(): min_x = 10000 min_y = 10000 max_x = 0 max_y = 0 for p in self.video.mouse_coord: x,y = mouse_to_raw(p[0], p[1]) if x < min_x: min_x = x if x > max_x: max_x = x if y < min_y: min_y = y if y > max_y: max_y = y return [min_x, min_y], [max_x, max_y] #TODO get this working search_image = self.video.currentFrame #Make it greyscale search_image = cv2.cvtColor(search_image, cv2.COLOR_BGR2GRAY) [tx,ty],[bx,by] = make_bounding_box() print [tx,ty], [bx,by] search_image = search_image[tx:bx:,ty:by] search_size = search_image.shape print search_size #Get the size of the template template_size = self.template.shape #We just want a greyscale 2d image def SAD(x, y): sad = 0 sub_region = search_image[x:x+template_size[0], y:y+template_size[1]] diff = sub_region - self.template sad = np.sum(diff**2) return sad / (template_size[0]*template_size[1]) # for i in range(template_size[0]): # for j in range(template_size[1]): # sad += float(abs(int(search_image[x+i,y+j]) - int(self.template[i,j]))) # return sad / (template_size[0]*template_size[1]*255.0) results = np.zeros((search_size[0]-template_size[0], search_size[1]-template_size[1])) print "Doing SAD" for x in range(search_size[0] - template_size[0]): for y in range(search_size[1] - template_size[1]): results[x,y] = SAD(x,y) print results.max(), results.min() print "Done SAD" threshold = 70.0 positions = [] max_val = results.max() def arg_min(a): min_val = float('inf') min_x = 0 min_y = 0 for x in range(a.shape[0]): for y in range(a.shape[1]): if a[x,y] < min_val: min_val = a[x,y] min_x = x min_y = y return min_x, min_y count = 0 while True: #If this is below the confidence level then quit min_index = arg_min(results) pixel_value = results[min_index] print pixel_value if pixel_value > threshold: break #Add it to potential positions positions.append(min_index) #Local max suppression def suppress_area(x,y): for i in range(-template_size[0]/2, template_size[0]/2): for j in range(-template_size[1]/2, template_size[1]/2): if x+i < 0 or y+j < 0: continue if x+i >= results.shape[0] or y+j >= results.shape[1]: continue results[x+i, y+j] = max_val suppress_area(min_index[0], min_index[1]) out = results * (255.0/results.max()) cv2.imwrite('./results_%d.png'%(count), out) count += 1 #DONE-ish the points need to be shifted by half a template image size print positions #CONVERT POINTS TO WORLD COORDS cx = self.template.shape[0]/2 cy = self.template.shape[1]/2 positions = [raw_to_mouse(p[0]+tx+cx, p[1]+ty+cx) for p in positions] def aff_trans(x, y): aff = self.video.aff_matrix wx = x*aff[0][0] + y*aff[0][1] + aff[0][2] wy = x*aff[1][0] + y*aff[1][1] + aff[1][2] return wx,wy self.donuts = [aff_trans(p[0], p[1]) for p in positions] def exec_path(self): print "Execute Path" def get_phi(x,y): from math import sqrt, pow r = sqrt(pow(x,2)+pow(y,2)) if r <= 95.0: return -135.0*D2R elif r > 95.0 and r < 190.0: return -90.0*D2R else: return -45.0*D2R self.donuts.sort(key=lambda x: math.atan2(x[1], x[0])) from itertools import chain, izip world_points = [(x,y, 50.0, get_phi(x,y)) for (x,y) in self.donuts] in_points = [(x,y, 10.0, get_phi(x,y)) for (x,y) in self.donuts] final_points = [] for i,p in enumerate(world_points): final_points.append(p) final_points.append(in_points[i]) final_points.append(p) config_space = [self.rex.rexarm_IK(p, 1) for p in final_points if self.rex.rexarm_IK(p, 1) != None] print "Playback" self.path_start_time = micro_time() self.rex.wpt_number = 1 self.rex.plan_status = 1 self.rex.max_torque = 50.0 self.ui.sldrMaxTorque.setValue(50.0) self.executed_path = [] self.rex.plan = [[0, self.rex.joint_angles_fb[:], [0,0,0,0]]] + \ [[3000000*(i+1), q, [0,0,0,0]] for i,q in enumerate(config_space)] print self.rex.plan self.rex.wpt_total = len(self.rex.plan)
class jaabaGUI(QMainWindow): """ controller for the blob labeling GUI""" def __init__(self,parent=None): self.debugMode = True self.debugVideoPath = '/Users/071cht/Desktop/Lab/jaabagui/testt.mjpeg.avi' QMainWindow.__init__(self,parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.installEventFilter(self) self.setFocusPolicy(Qt.StrongFocus) #add new slider # self.positionSlider=QSlider(Qt.Horizontal) # self.positionSlider.setGeometry (800,800,100,30) # self.positionSlider.setRange(0, 0) # self.positionSlider.sliderMoved.connect(self.setPosition) #setup Video #video player self.mediaPlayer1 = QMediaPlayer(None, QMediaPlayer.VideoSurface) self.mediaPlayer2 = QMediaPlayer(None, QMediaPlayer.VideoSurface) self.mediaPlayer2.setNotifyInterval(10) #self.mediaPlayer.metaDataChanged.connect(self.metaDataChanged) self.mediaPlayer1.durationChanged.connect(self.durationChanged) self.mediaPlayer1.positionChanged.connect(self.positionChanged) self.mediaPlayer2.positionChanged.connect(self.positionChanged) #self.mediaPlayer2.positionChanged.connect(self.paintEvent) #visualizetion self.scene = QGraphicsScene() self.ui.graphicsView.setScene(self.scene) #self.scene.setBackgroundBrush(Qt.black) self.videoItem1 = QGraphicsVideoItem() self.videoItem2 = Video() self.scene.addItem(self.videoItem1) self.scene.addItem(self.videoItem2) self.mediaPlayer1.setVideoOutput(self.videoItem1) self.mediaPlayer2.setVideoOutput(self.videoItem2) #slider bar self.ui.horizontalSlider.setRange(0, 0) self.ui.horizontalSlider.sliderMoved.connect(self.setPosition) # self.ui.horizontalSlider.sliderPressed.connect(self.sliderPressed) #draw on video self.flyCanvas= TargetView() self.scene.addItem(self.flyCanvas) #give reference to target view self.flyCanvas.setWindowReference(self) #lineEdit signals: self.ui.lineEdit.returnPressed.connect(self.lineEditChanged) #callbacks self.ui.actionQuit.triggered.connect(self.quit) self.ui.actionLoad_Project.triggered.connect(self.loadVideo) self.ui.actionImport_Labels.triggered.connect(self.loadLabels) #self.ui.buttonPlay.clicked[bool].connect(self.setToggleText) self.ui.buttonPlay.clicked.connect(self.play) self.ui.actionSave.triggered.connect(self.saveLabels) ## print self.ui.graphicsView.sizeHint() #behavior Button self.ui.buttonBehavior.clicked.connect(self.behaviorButtonClick) self.ui.buttonNone.clicked.connect(self.noneButtonClick) #initialization self.loaded = False self.videoFilename = None self.frame_count=None self.width=None self.height=None self.frame_trans=None self.previous_frame=0 self.current_frame=0 self.behaviorButtonStart = False self.noneButtonStart = False self.currentFly=1 #initialize flyInfo #self.setCurrentFly(self.currentFly) # register flyid changed callback self.flyCanvas.onCurrentFlyIdChanged(self.currentFlyIdChangedCallback) self.flyCanvas.setCurrentFlyId(self.currentFly) # when double click on video, change fly id in target view self.videoItem2.onDoubleClick(self.flyCanvas.setCurrentFlyIdByXY) ######################## # DEBUG PART HERE!!!!! # ######################## if (self.debugMode): self.debugLoadVideo() # add label UI related when load video def showEvent(self, evt): super(jaabaGUI, self).showEvent(evt) ##### HERE THE WINDOW IS LOADED!!!!!!!! # self.loadLabelUI() def loadLabelUI(self): #labels self.labelScene = QGraphicsScene() self.ui.graphLabels.setScene(self.labelScene) # the size is only accurate after the window fully displayed labelUIWidth = self.ui.graphLabels.width() labelUIHeight = self.ui.graphLabels.height()-1 self.labelScene.setSceneRect(0,0,labelUIWidth,labelUIHeight) self.labelUI = LabelUI() # visiableWidth = 850 # height = 30 # visiableFrameNum = 850 self.labelUI.setWidthPerFrame(850.0/850.0) # print '850/500',850.0/850.0b # print 'length_perframe is ', self.labelUI.widthPerFrame # 850 is the original length of graphLabel total_length= self.labelUI.widthPerFrame * self.frame_count self.labelUI.setVisiableSize(total_length,30) # set start position self.labelUI.setPos(labelUIWidth/2,0) print 'frame_count is ', self.frame_count print 'total length is', total_length self.labelScene.addItem(self.labelUI) # middle line ui self.labelUIMiddleLine = LabelUIMiddleLine() self.labelScene.addItem(self.labelUIMiddleLine) self.labelUIMiddleLine.setPos(labelUIWidth/2,0) # self.labelUI.setPos(QPointF(-100,0)) self.writeLog('Label UI loaded') def eventFilter(self, obj, event): if (event.type() == PyQt5.QtCore.QEvent.KeyPress): # http://qt-project.org/doc/qt-4.8/qt.html#Key-enum key = event.key() if (key == Qt.Key_Up) : curr_frame= int(float(self.ui.lineEdit.text())) curr_frame= curr_frame-30 media_position= int(round(curr_frame*self.frame_trans)) # print curr_frame, media_position self.mediaPlayer1.setPosition(media_position) self.mediaPlayer2.setPosition(media_position) # print 'down -30' elif (key == Qt.Key_Right): curr_frame= int(float(self.ui.lineEdit.text())) # print 'right +1' # print curr_frame curr_frame= curr_frame+1 media_position= int(round(curr_frame*self.frame_trans)) # print 'curr_frame',curr_frame # print 'frame_trans',self.frame_trans # print ' curr_frame*self.frame_trans',curr_frame*self.frame_trans # print 'media_position',media_position # print curr_frame, media_position self.mediaPlayer1.setPosition(media_position) self.mediaPlayer2.setPosition(media_position) # self.mediaPlayerPositionChanged(media_position) elif (key == Qt.Key_Left): curr_frame= int(float(self.ui.lineEdit.text())) curr_frame= curr_frame-1 media_position= int(round(curr_frame*self.frame_trans)) self.mediaPlayer1.setPosition(media_position) self.mediaPlayer2.setPosition(media_position) # print 'left -1' elif (key == Qt.Key_Down): curr_frame= int(float(self.ui.lineEdit.text())) curr_frame= curr_frame+30 media_position= int(round(curr_frame*self.frame_trans)) self.mediaPlayer1.setPosition(media_position) self.mediaPlayer2.setPosition(media_position) # print 'up +30' return True return False # ###actions starts from here### def quit(self): QApplication.quit() def loadVideo(self): # print QMediaPlayer.supportedMimeTypes() self.writeLog("Loading video...") self.videoFilename = QFileDialog.getOpenFileName(self, 'Open File', '.')[0] if not self.videoFilename: self.writeLog("User cancelled - no video loaded") return else: cap=cv2.VideoCapture(self.videoFilename) self.frame_count=cap.get(cv2.CAP_PROP_FRAME_COUNT) self.width=cap.get(3) self.height=cap.get(4) self.mediaPlayer2.setMedia(QMediaContent(QUrl.fromLocalFile(self.videoFilename ))) self.mediaPlayer1.setMedia(QMediaContent(QUrl.fromLocalFile(self.videoFilename ))) self.ui.buttonPlay.setEnabled(True) # self.mediaPlayer2.setVideoOutput(self.videoItem2) # self.mediaPlayer1.setVideoOutput(self.videoItem1) # size= self.videoItem2.nativeSize() # # print size ## print self.mediaPlayer.duration() ## print self.mediaPlayer.metaData() self.writeLog("Video loaded!") # init label related ui self.loadLabelUI() def debugLoadVideo(self): self.videoFilename = self.debugVideoPath cap=cv2.VideoCapture(self.videoFilename) self.frame_count=cap.get(cv2.CAP_PROP_FRAME_COUNT) self.width=cap.get(3) self.height=cap.get(4) self.mediaPlayer2.setMedia(QMediaContent(QUrl.fromLocalFile(self.videoFilename ))) self.mediaPlayer1.setMedia(QMediaContent(QUrl.fromLocalFile(self.videoFilename ))) self.ui.buttonPlay.setEnabled(True) self.writeLog("Video loaded!") QTimer.singleShot(1000, self.loadLabelUI) def play(self): self.videoItem1.setAspectRatioMode(0) self.videoItem2.setAspectRatioMode(0) self.scene.setSceneRect(0,0,self.ui.graphicsView.width(),self.ui.graphicsView.height()) self.videoItem1.setSize(QSizeF(self.ui.graphicsView.width()/2,self.ui.graphicsView.height())) self.videoItem2.setSize(QSizeF(self.ui.graphicsView.width()/2,self.ui.graphicsView.height())) self.videoItem1.setPos(QPointF(0,0)) self.videoItem2.setPos(QPointF(self.ui.graphicsView.width()/2,0)) self.flyCanvas.setPos(QPointF(self.ui.graphicsView.width()/2,0)) # custom function setXYScale self.videoItem2.setXYScale(self.width,self.height,self.ui.graphicsView.width()/2,self.ui.graphicsView.height()) self.flyCanvas.setXYScale(self.width,self.height,self.ui.graphicsView.width()/2,self.ui.graphicsView.height()) if self.mediaPlayer1.state() == QMediaPlayer.PlayingState: self.ui.buttonPlay.setIcon(self.ui.style().standardIcon(PyQt5.QtWidgets.QStyle.SP_MediaPlay)) self.ui.buttonPlay.setText("Play") self.mediaPlayer1.pause() self.writeLog("Video paused") else: self.ui.buttonPlay.setIcon(self.ui.style().standardIcon(PyQt5.QtWidgets.QStyle.SP_MediaPause)) self.ui.buttonPlay.setText("Stop") self.mediaPlayer1.play() self.writeLog("Playing video") if self.mediaPlayer2.state() == QMediaPlayer.PlayingState: self.mediaPlayer2.pause() else: self.mediaPlayer2.play() def loadLabels(self): self.writeLog("Loading labels from file...") self.labelFilename = QFileDialog.getOpenFileName(self, 'Open File', '.')[0] self.labelUI.labelData = pickle.load(open(self.labelFilename,"rb")) self.writeLog("Label loaded from file:" + self.labelFilename) def saveLabels(self): # Now it can only save to current file. Will add an poput window to choose path later pickle.dump( self.labelUI.labelData, open( "newLabels.p", "wb" ) ) def setPosition(self, position): self.mediaPlayer1.setPosition(position) self.mediaPlayer2.setPosition(position) # when position of media changed, set slider and text box accordingly. def positionChanged(self, position): #test change labelui position # self.labelUI.startLabel(); # self.labelUI.update() previous_frame= self.previous_frame curr_frame= int(round(position/self.frame_trans)) self.current_frame=curr_frame frame_change= previous_frame-curr_frame move_width= frame_change * self.labelUI.widthPerFrame self.previous_frame= curr_frame self.labelUI.moveBy(move_width,0) self.labelUI.setCurrentFrame(curr_frame) # enforce labelUI paint once self.labelUI.update() # self.labelUI.setPos(self.labelUI.mapToParent(1,0)); # self.labelUI.update() # # print 'triggered position' # # print position # # print 'cur position' # # print self.mediaPlayer2.position() self.updateLineEdit(position) self.updateSliderAndGraph(position) # self.ui.horizontalSlider.setValue(position) # if isinstance(self.frame_trans,float): # # # print type(position),position # # # print type(self.frame_trans),self.frame_trans # # # print position/self.frame_trans # self.ui.lineEdit.setText(str(int(round(position/self.frame_trans)))) # self.flyCanvas.getFrame(int(round(position/self.frame_trans))) # self.flyCanvas.isManualCalled = True; # self.flyCanvas.update() # self.writeLog(str(position)) # # self.updateMediaControlUI(position) # # self.flyCanvas.update() def updateSliderAndGraph(self, position): self.ui.horizontalSlider.setValue(position) if isinstance(self.frame_trans,float): self.flyCanvas.getFrame(int(round(position/self.frame_trans))) self.flyCanvas.isManualCalled = True self.flyCanvas.update() #self.writeLog(str(position)) def updateLineEdit(self, position): # # print self.width # # print self.height if isinstance(self.frame_trans,float): # # print type(position),position # # print type(self.frame_trans),self.frame_trans # # print position/self.frame_trans self.ui.lineEdit.setText(str(int(round(position/self.frame_trans)))) def durationChanged(self, duration): self.ui.horizontalSlider.setRange(0, duration) self.frame_trans=self.mediaPlayer1.duration()/self.frame_count ## print self.frame_trans #def eventFilter(self,source,event): #if (event.type()==PyQt5.QtCore.QEvent.MousePress and source is self.videoItem2): # pos=event.pos() # # print('mouse position: (%d,%d)' % (pos.x(),pos.y())) # return PyQt5.QtGui.QWidget.eventFilter(self, source, event) def writeLog(self,text): self.ui.log.setText(text) # def eventFilter (self.ui.lineEdit,event): # if event.type()==PyQt5.QtCore.QEvent def lineEditChanged(self): #set position of media curr_frame= int(float(self.ui.lineEdit.text())) media_position= int(round(curr_frame*self.frame_trans)) self.mediaPlayer1.setPosition(media_position) self.mediaPlayer2.setPosition(media_position) # print 'setPosition' # print media_position # print 'after set' # print self.mediaPlayer2.position() # self.updateSliderAndGraph(media_position) def behaviorButtonClick(self): # flip flag self.behaviorButtonStart = not self.behaviorButtonStart # check click to start or stop if (self.behaviorButtonStart): # start labeling self.labelUI.startLabel(self.ui.comboBox.currentIndex(),'',self.current_frame) self.writeLog('start labeling') else: # stop lableing self.labelUI.stopLabel() self.writeLog('stop labeling') def noneButtonClick(self): # flip flag self.noneButtonStart = not self.noneButtonStart # check click to start or stop if (self.noneButtonStart): # start labeling self.labelUI.startLabel(self.ui.comboBox.currentIndex(),'_none',self.current_frame) self.writeLog('start labeling') else: # stop lableing self.labelUI.stopLabel() self.writeLog('stop labeling') # set CurrentFly when fly changed! def setCurrentFly(self,fly): self.currentFly = fly self.ui.flyInfo.setPlainText('FlyID:' + str(self.currentFly)) self.flyCanvas.currentFly=fly def currentFlyIdChangedCallback(self,fly): print 'callback!!!!!'; self.currentFly = fly self.ui.flyInfo.setPlainText('FlyID:' + str(self.currentFly))
class Editor(QtGui.QMainWindow): def __init__(self): super(Editor, self).__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.show()
class MainWindow(QtWidgets.QMainWindow): def __init__(self): super(MainWindow, self).__init__() self.file_name = '' self.file_flag = False self.sic = None self.ui = Ui_MainWindow() self.ui.setupUi(self) self.ui.input_file_name.clicked.connect(self.set_file_name) self.ui.op_table.clicked.connect(self.op_table) self.ui.symbol_table.clicked.connect(self.symbol_table) self.ui.object_code.clicked.connect(self.object_code) self.ui.object_program_format.clicked.connect( self.object_program_format) self.ui.language.activated[str].connect(self.change_language) def create_sic(self): clear_global_variable() self.sic = sic.SIC(self.file_name) def set_message(self, index): if self.ui.language.currentText() == self.ui.languages[0]: self.ui.textBrowser.insertPlainText(self.ui.english[index - 1] + '\n') elif self.ui.language.currentText() == self.ui.languages[1]: self.ui.textBrowser.insertPlainText( self.ui.traditional_chinese[index - 1] + '\n') else: self.ui.textBrowser.insertPlainText(self.ui.japanese[index - 1] + '\n') def change_language(self): self.ui.change_language() if not self.file_name == '' and self.ui.push_button == 1: self.ui.textBrowser.clear() if self.file_flag is True: self.set_message(3) self.set_message(4) else: self.set_message(2) elif self.file_name == '': self.ui.textBrowser.clear() if self.ui.push_button == 1: self.set_message(1) elif self.ui.push_button > 1: self.set_message(5) def set_file_name(self): self.ui.push_button = 1 file_name = self.ui.textEdit.toPlainText() if file_name.find('.txt') == -1: file_name += '.txt' d_list = os.listdir() self.ui.textBrowser.clear() if file_name not in d_list: self.set_message(1) self.file_name = '' elif file_name == self.file_name: self.file_flag = False self.set_message(2) else: self.ui.textBrowser.clear() self.file_name = file_name self.file_flag = True self.set_message(3) self.create_sic() self.set_message(4) self.sic.start() def op_table(self): self.ui.push_button = 2 self.ui.textBrowser.clear() if self.file_name == '': self.set_message(5) pass else: op_table = sic.OPTABLE.items() count = 0 for each in op_table: count += 1 self.ui.textBrowser.insertPlainText( '{:<20}'.format(str(each)) + '\t') if count % 5 == 0: self.ui.textBrowser.insertPlainText('\n') def symbol_table(self): self.ui.push_button = 3 self.ui.textBrowser.clear() if self.file_name == '': self.set_message(5) pass else: count = 0 for each in sic.Symbol: count += 1 self.ui.textBrowser.insertPlainText(each + '\t') if count % 3 == 0: self.ui.textBrowser.insertPlainText('\n') def object_code(self): self.ui.push_button = 4 self.ui.textBrowser.clear() if self.file_name == '': self.set_message(5) pass else: line_count = 1 self.ui.textBrowser.insertPlainText( 'Line\t Loc\t\t\tSource statement\t\t\tObject code\n') for i in range(len(self.sic.instruction)): temp = self.sic.instruction[i] if temp.machineCode == 'error': self.ui.textBrowser.insertPlainText( '\t\tInstruction is error, so can not get the result\n' ) else: line = '{:>4}'.format(str(line_count)) + '\t' if temp.order == 'END': line += '\t' else: line += temp.leftAddress + '\t' line += '{:<18}'.format(temp.symbol) + '\t' line += temp.order + '\t\t' line += '{:<18}'.format(temp.label) + '\t ' line += temp.machineCode + '\n' self.ui.textBrowser.insertPlainText(line) line_count += 1 def object_program_format(self): self.ui.push_button = 5 self.ui.textBrowser.clear() if self.file_name == '': self.set_message(5) pass else: left = '00' temp = self.sic instruction_len = len(temp.instruction) header = 'H^' + temp.instruction[ 0].symbol + '^' + left + temp.instruction[0].leftAddress + '^' txt_begin = function.hex_to_dec(temp.instruction[0].leftAddress) txt_end = function.hex_to_dec(temp.instruction[instruction_len - 1].leftAddress) header += left + function.dec_to_hex(txt_end - txt_begin) self.ui.textBrowser.insertPlainText(header + '\n') size = 0 begin_index = 1 lines = [] b = [] sizes = [] line = '' b.append(begin_index) while True: if begin_index == instruction_len - 1: lines.append(line) sizes.append(size) b.append(begin_index) break elif size + (len(sic.MC[begin_index]) / 2) > 30: lines.append(line) sizes.append(size) b.append(begin_index) line = '' size = 0 elif sic.MC[begin_index] == '': lines.append(line) sizes.append(size) b.append(begin_index + 1) line = '' size = 0 if sic.MC[begin_index] == 'error': pass elif sic.MC[begin_index] == '': pass else: line += '^' + function.fill_zeros(sic.MC[begin_index]) size += (len(sic.MC[begin_index]) / 2) begin_index += 1 for i in range(len(lines)): line = '' if lines[i] == '': pass else: line += 'T^' + left + temp.instruction[ b[i]].leftAddress + '^' if sizes[i] < 16: line += '0' line += function.dec_to_hex(int( sizes[i])) + lines[i] + '\n' self.ui.textBrowser.insertPlainText(line) self.ui.textBrowser.insertPlainText( 'E^00' + temp.instruction[0].leftAddress)
class MainWindow(QtGui.QMainWindow): def __init__(self, settings, application=None): ''' UI Object that draws the main window. Listens to the following settings: - delay: ''' QtGui.QMainWindow.__init__(self) self.ui = Ui_MainWindow() self.ui.setupUi(self) self._renderwidgets = [ RenderWidget(self), RenderWidget(self), RenderWidget(self), RenderWidget(self), ] self.update() self.application = application self.settings = settings self.settings.settingChanged.connect(self.settingChanged) self.ui.delay.setText(str(settings.getSetting("delay"))) self._loadScreens(self.settings.getSetting("layouts")[self.settings.getSetting("selectedlayout")]["screen"]) self._bindings = {} self._windowstate = None self._loadBindings(settings.getSetting('keybinding')) # end __init__() # signals incDelay = Signal() #+>=. (while running) decDelay = Signal() #-<, (while running) incFrame = Signal() #+>=. (while paused) decFrame = Signal() #-<, (while paused) help = Signal() #F1 edit = Signal() #F2 togglePlay = Signal() #F7 <space> recordBuffer = Signal() #F12 # signals (new) processFrame = Signal(str, object) processGroup = Signal(str, object) resized = Signal() def resizeEvent(self, *args, **kwargs): returncode = QtGui.QMainWindow.resizeEvent(self, *args, **kwargs) self.resized.emit() return returncode @Slot(str,object) def settingChanged(self, name, value): if name == "delay": self.ui.delay.setText(str(value)) elif name == "keybinding": self._loadBindings(value) elif name == "selectedlayout": self._loadScreens(self.settings.getSetting("layouts")[value]["screen"]) ## reimplemented ## def showEvent(self, *args, **kwargs): if self._windowstate is None: self._windowstate = self.settings.getSetting("delayanalysisui") self.setGeometry(*self._windowstate['geometry']) if self._windowstate['mode'] == 'fullscreen': self.showFullScreen() elif self._windowstate['mode'] == 'maximised': self.showMaximized() return QtGui.QMainWindow.showEvent(self, *args, **kwargs) def closeEvent(self, *args, **kwargs): if self._windowstate is not None: self._windowstate = self.settings.getSetting("delayanalysisui") if self._windowstate['savemode'] == True: if self.windowState() == QtCore.Qt.WindowFullScreen: self._windowstate['mode'] = "fullscreen" elif self.windowState() == QtCore.Qt.WindowMaximized: self._windowstate['mode'] = "maximised" else: self._windowstate['mode'] = "normal" if self._windowstate['savegeometry'] == True: self._windowstate['geometry'] = self.geometry().getRect() self.settings.setSetting('delayanalysisui', self._windowstate) return QtGui.QMainWindow.closeEvent(self, *args, **kwargs) ## support ## def _loadScreens(self, screens): self._screens = screens self._layouts = min(4, len(self._screens)) # print "Layouts: %s" % self._layouts # print "Screens: %s" % self._screens for i in range(self._layouts): self._renderwidgets[i].setLayout(screens[i]) def _loadBindings(self, bindings): ''' Extracts the actual key ids from the string representations of them provided. @param bindings: dict containing keybindings {'<keyname>': [('<group>', '<function>', <optionargs>,...), ...]} ''' try: groups = {'core': None, 'processframe': lambda m,c: self.processFrame.emit(m,c), 'processgroup': lambda m,c: self.processGroup.emit(m,c), } corefuncs = { 'quit': lambda a,b: self.close(), 'play': lambda a,b: self.togglePlay.emit(), 'incdelay': lambda a,b: self.incDelay.emit(), 'decdelay': lambda a,b: self.decDelay.emit(), 'incframe': lambda a,b: self.incFrame.emit(), 'decframe': lambda a,b: self.decFrame.emit(), 'fullscreen': lambda a,b: self.toggleFullScreen(), 'edit': lambda a,b: self.edit.emit(), 'help': lambda a,b: self.help.emit(), } errors = [] self._bindings = {} for keystr, events in bindings.items(): for event in events: try: # convert to integer keyint = getattr(QtCore.Qt,"Key_%s"% str(keystr)) # get functions to perform tasks func = groups[event[0]] if func is None: func = corefuncs[event[1]] if keyint in self._bindings: self._bindings[keyint].append((func, event[1], event[2:])) else: self._bindings[keyint] = [(func, event[1], event[2:])] except AttributeError: errors.append("Key: %s" %keystr) except KeyError: errors.append("Group: %s" %keystr) if len(errors) > 0: print "Ignoring the following invalid key bindings (%s)" % (", ".join(errors)) except: pass def toggleFullScreen(self): '''Toggles between fullscreen and normal mode''' if not self.isFullScreen(): self.showFullScreen() else: self.showNormal() def keyPressEvent(self, e): '''Perform tasks for various key events''' if e.key() in self._bindings: for binding in self._bindings[e.key()]: func, action, config = binding func(action, config) else: print "key: %s" % (e.key(),) def renderFrameset(self, frameset): ''' Renders the relevent frames from the frameset to screen ''' for i in range(self._layouts): self._renderwidgets[i].process(frameset) # def updateView(self, vid, pixmap): # '''Updates a view to display given pixmap''' # self.ui.videoFrame.setPixmap(pixmap) # self.ui.videoFrame.setScaledContents(True) def setFrameId(self, frameid): self.ui.frameNum.setText(frameid) def setFrameRate(self, framerate): self.ui.frameRate.setText(framerate)
class Gui(QMainWindow): """ Main GUI Class contains the main function and interfaces between the GUI and functions """ def __init__(self,parent=None): QWidget.__init__(self,parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) """ Set GUI to track mouse """ QWidget.setMouseTracking(self,True) """dynamixel bus -- add other motors here""" self.dxlbus = DXL_BUS(DEVICENAME, BAUDRATE) port_num = self.dxlbus.port() base = DXL_MX(port_num, 0) shld = DXL_MX(port_num, 1) elbw = DXL_MX(port_num, 2) wrst = DXL_AX(port_num, 3) wrst2 = DXL_XL(port_num, 4) # NIC 10/4 grip = DXL_XL(port_num, 5) # NIC 10/4 """Objects Using Other Classes""" self.kinect = Kinect() self.rexarm = Rexarm((base,shld,elbw,wrst,wrst2),grip) # NIC 10/4 self.tp = TrajectoryPlanner(self.rexarm) self.sm = StateMachine(self.rexarm, self.tp, self.kinect) """ Attach Functions to Buttons & Sliders TODO: NAME AND CONNECT BUTTONS AS NEEDED """ self.ui.btn_estop.clicked.connect(self.estop) self.ui.btn_exec.clicked.connect(partial(self.sm.set_next_state,"execute_plan")) self.ui.btn_task1.clicked.connect(partial(self.sm.set_next_state,"task_1")) self.ui.btn_task2.clicked.connect(partial(self.sm.set_next_state,"task_2")) self.ui.btn_task4.clicked.connect(partial(self.sm.set_next_state,"task_5")) #self.ui.btn_exec.clicked.connect(partial(self.sm.set_next_state,"execute")) self.ui.btnUser1.setText("Calibrate") self.ui.btnUser1.clicked.connect(partial(self.sm.set_next_state, "calibrate")) self.ui.btnUser2.setText("Record Waypoints") self.ui.btnUser2.clicked.connect(partial(self.sm.set_next_state, "record")) self.ui.btnUser3.setText("Play") self.ui.btnUser3.clicked.connect(partial(self.sm.set_next_state, "play")) self.ui.btnUser4.setText("Open Gripper") # NIC 10/4 self.ui.btnUser4.clicked.connect(self.rexarm.open_gripper) # NIC 10/4 self.ui.btnUser5.setText("Close Gripper") # NIC 10/4 self.ui.btnUser5.clicked.connect(self.rexarm.close_gripper) # NIC 10/4 self.ui.sldrBase.valueChanged.connect(self.sliderChange) self.ui.sldrShoulder.valueChanged.connect(self.sliderChange) self.ui.sldrElbow.valueChanged.connect(self.sliderChange) self.ui.sldrWrist.valueChanged.connect(self.sliderChange) self.ui.sldrGrip1.valueChanged.connect(self.sliderChange) self.ui.sldrGrip2.valueChanged.connect(self.sliderChange) self.ui.sldrMaxTorque.valueChanged.connect(self.sliderChange) self.ui.sldrSpeed.valueChanged.connect(self.sliderChange) self.ui.chk_directcontrol.stateChanged.connect(self.directControlChk) self.ui.rdoutStatus.setText("Waiting for input") """initalize manual control off""" self.ui.SliderFrame.setEnabled(False) """initalize rexarm""" self.rexarm.initialize() """Setup Threads""" self.videoThread = VideoThread(self.kinect) self.videoThread.updateFrame.connect(self.setImage) self.videoThread.start() self.logicThread = LogicThread(self.sm) self.logicThread.start() self.displayThread = DisplayThread(self.rexarm, self.sm) self.displayThread.updateJointReadout.connect(self.updateJointReadout) self.displayThread.updateEndEffectorReadout.connect(self.updateEndEffectorReadout) self.displayThread.updateStatusMessage.connect(self.updateStatusMessage) self.displayThread.start() """ Setup Timer this runs the trackMouse function every 50ms """ self._timer = QTimer(self) self._timer.timeout.connect(self.trackMouse) self._timer.start(50) """ Slots attach callback functions to signals emitted from threads""" @pyqtSlot(QImage, QImage) def setImage(self, rgb_image, depth_image): if(self.ui.radioVideo.isChecked()): self.ui.videoDisplay.setPixmap(QPixmap.fromImage(rgb_image)) if(self.ui.radioDepth.isChecked()): self.ui.videoDisplay.setPixmap(QPixmap.fromImage(depth_image)) @pyqtSlot(list) def updateJointReadout(self, joints): self.ui.rdoutBaseJC.setText(str("%+.2f" % (joints[0]*R2D))) self.ui.rdoutShoulderJC.setText(str("%+.2f" % ((joints[1]*R2D)+90.0))) self.ui.rdoutElbowJC.setText(str("%+.2f" % (joints[2]*R2D))) self.ui.rdoutWristJC.setText(str("%+.2f" % (joints[3]*R2D))) @pyqtSlot(list) def updateEndEffectorReadout(self, pos): self.ui.rdoutX.setText(str("%+.2f" % (pos[0]))) self.ui.rdoutY.setText(str("%+.2f" % (pos[1]))) self.ui.rdoutZ.setText(str("%+.2f" % (pos[2]))) self.ui.rdoutT.setText(str("%+.2f" % (pos[3]))) @pyqtSlot(str) def updateStatusMessage(self, msg): self.ui.rdoutStatus.setText(msg) """ Other callback functions attached to GUI elements""" def estop(self): self.rexarm.estop = True self.sm.set_next_state("estop") def sliderChange(self): """ Function to change the slider labels when sliders are moved and to command the arm to the given position """ self.ui.rdoutBase.setText(str(self.ui.sldrBase.value())) self.ui.rdoutShoulder.setText(str(self.ui.sldrShoulder.value())) self.ui.rdoutElbow.setText(str(self.ui.sldrElbow.value())) self.ui.rdoutWrist.setText(str(self.ui.sldrWrist.value())) #enter the vale for the slider :slider rdoutGrip2 and rdoutGrip2 self.ui.rdoutTorq.setText(str(self.ui.sldrMaxTorque.value()) + "%") self.ui.rdoutSpeed.setText(str(self.ui.sldrSpeed.value()) + "%") self.rexarm.set_torque_limits([self.ui.sldrMaxTorque.value()/100.0]*self.rexarm.num_joints, update_now = False) self.rexarm.set_speeds_normalized_global(self.ui.sldrSpeed.value()/100.0, update_now = False) joint_positions = np.array([self.ui.sldrBase.value()*D2R, self.ui.sldrShoulder.value()*D2R, self.ui.sldrElbow.value()*D2R, self.ui.sldrWrist.value()*D2R, self.ui.sldrGrip1.value()*D2R, self.ui.sldrGrip2.value()*D2R]) self.rexarm.set_positions(joint_positions, update_now = False) def directControlChk(self, state): if state == Qt.Checked: self.sm.set_next_state("manual") self.ui.SliderFrame.setEnabled(True) else: self.sm.set_next_state("idle") self.ui.SliderFrame.setEnabled(False) def trackMouse(self): """ Mouse position presentation in GUI TODO: after implementing workspace calibration display the world coordinates the mouse points to in the RGB video image. """ x = QWidget.mapFromGlobal(self,QCursor.pos()).x() y = QWidget.mapFromGlobal(self,QCursor.pos()).y() if ((x < MIN_X) or (x >= MAX_X) or (y < MIN_Y) or (y >= MAX_Y)): self.ui.rdoutMousePixels.setText("(-,-,-)") self.ui.rdoutMouseWorld.setText("(-,-,-)") else: x = x - MIN_X y = y - MIN_Y if(self.kinect.currentDepthFrame.any() != 0): z = self.kinect.currentDepthFrame[y][x] self.ui.rdoutMousePixels.setText("(%.0f,%.0f,%.0f)" % (x,y,z)) if (self.kinect.kinectCalibrated): zw = self.kinect.depthcalibration(z) xwyw = self.kinect.pixeltoworldcoordinates(np.array([x,y,1]), z) self.ui.rdoutMouseWorld.setText("(%.0f,%.0f,%.0f)" % (xwyw[0],xwyw[1],zw)) def mousePressEvent(self, QMouseEvent): """ Function used to record mouse click positions for calibration """ """ Get mouse posiiton """ x = QMouseEvent.x() y = QMouseEvent.y() """ If mouse position is not over the camera image ignore """ if ((x < MIN_X) or (x > MAX_X) or (y < MIN_Y) or (y > MAX_Y)): return """ Change coordinates to image axis """ self.kinect.last_click[0] = x - MIN_X self.kinect.last_click[1] = y - MIN_Y self.kinect.new_click = True
class Calc(QtWidgets.QMainWindow): def __init__(self): super(Calc, self).__init__() self.setWindowFlags(QtCore.Qt.WindowCloseButtonHint) self.setWindowIcon(QtGui.QIcon('calculator.jpg')) self.setWindowTitle('Calculator') self.setFixedSize(QSize(426, 440)) # self.setBackgroundRole() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.setAutoFillBackground(True) palette = self.palette() palette.setColor(palette.Window, QColor(120, 20, 230)) self.setPalette(palette) self.ui.lineEdit_2.setReadOnly(True) # Заполнение comboBox for i in range(2, 17): self.ui.Of.addItem(str(i)) self.ui.In.addItem(str(i)) self.initUi() def initUi(self): # Кнопочки self.ui.zero.clicked.connect(lambda: self.entry_field(0)) self.ui.one.clicked.connect(lambda: self.entry_field(1)) self.ui.two.clicked.connect(lambda: self.entry_field(2)) self.ui.three.clicked.connect(lambda: self.entry_field(3)) self.ui.four.clicked.connect(lambda: self.entry_field(4)) self.ui.five.clicked.connect(lambda: self.entry_field(5)) self.ui.six.clicked.connect(lambda: self.entry_field(6)) self.ui.seven.clicked.connect(lambda: self.entry_field(7)) self.ui.eight.clicked.connect(lambda: self.entry_field(8)) self.ui.nine.clicked.connect(lambda: self.entry_field(9)) self.ui.A.clicked.connect(lambda: self.entry_field('A')) self.ui.B.clicked.connect(lambda: self.entry_field('B')) self.ui.C.clicked.connect(lambda: self.entry_field('C')) self.ui.D.clicked.connect(lambda: self.entry_field('D')) self.ui.F.clicked.connect(lambda: self.entry_field('F')) # self.ui.Point.clicked.connect(lambda: self.entry_field('.')) self.ui.Backsp.clicked.connect(lambda: self.ui.lineEdit.backspace()) self.ui.CE.clicked.connect(lambda: self.ui.lineEdit.clear()) self.ui.execute.clicked.connect(lambda: self.convert()) # Заполнение поля ввода def entry_field(self, sumb): if self.ui.lineEdit.text() == "Введите число" or self.ui.lineEdit.text( ) == "0": self.ui.lineEdit.clear() # print(self.ui.lineEdit.text()) self.ui.lineEdit.setText(self.ui.lineEdit.text() + str(sumb)) # Заполненеи поля результата def output_field(self, res): self.ui.lineEdit_2.clear() self.ui.lineEdit_2.setText(str(res)) # Ф-я расчета def convert(self): try: self.output_field( convert_base(self.ui.lineEdit.text(), self.ui.In.currentIndex() + 2, self.ui.Of.currentIndex() + 2)) except: self.output_field("Выбра неверная с/c")
hwd.actionEnglish.triggered.connect( lambda: set_menu_langugage_english(hwd)) hwd.actionJapanese.triggered.connect( lambda: set_menu_langugage_japanese(hwd)) hwd.actionAbout.triggered.connect(about) class MyDialog(QtWidgets.QMainWindow): def __init__(self): super(MyDialog, self).__init__() self.ffmpeg = None def closeEvent(self, evnt): super(MyDialog, self).closeEvent(evnt) if __name__ == "__main__": import sys app = QtWidgets.QApplication(sys.argv) MainWindow = MyDialog() #MainWindow.setUnifiedTitleAndToolBarOnMac(True) ui = Ui_MainWindow() ui.setupUi(MainWindow) ui.app = app ui.win = MainWindow set_up_actions(ui) MainWindow.show() sys.exit(app.exec_())
class StartQt(QtGui.QMainWindow): conf = "conf.ini" assets = "assets/" activeDb = "" activeTable = "" type_id = 35 to_check = ["delete","drop","truncate"] to_add_server = ["Name","Host","Username","Password"] def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.initSlots() self.initMenu() def setStatus(self, text): self.statusBar().showMessage(text) def initSlots(self): self.statusBar() self.ui.clear_button.clicked.connect(self.clearAction) self.ui.new_button.clicked.connect(self.newAction) self.ui.query_button.clicked.connect(self.queryAction) self.ui.list.clicked.connect(self.listAction()) self.ui.new_server.triggered.connect(self.addServer()) def initMenu(self): self.config = ConfigParser.ConfigParser() # os.path.expanduser('~') + '/' + self.ssqb_dir + '/' + self.ui.servers_menu.clear() self.config.read(self.conf) for name in self.config._sections: item = QtGui.QAction(QtGui.QIcon(self.assets+"database_connect.png"), name, self) item.triggered.connect(self.dbConnect(self.config._sections[name]["host"], self.config._sections[name]["user"], self.config._sections[name]["pass"])) self.ui.servers_menu.addAction(item); def progressBar(self): pass def queryAction(self): activeTab = self.ui.tab.currentWidget() queryField = activeTab.findChild(QtGui.QPlainTextEdit) sql = queryField.toPlainText() proceed = True danger = False for word in self.to_check: if word in sql.toLower(): danger = True self.danger_word = word msg = "Are you sure you want to %s?" % word reply = QtGui.QMessageBox.question(self, 'Message', msg, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No) if reply == QtGui.QMessageBox.No: proceed = False break if not proceed: pass else: self.progress = QtGui.QProgressDialog("Please Wait", "Cancel", 0, 100, self.ui.result_table) self.progress.setWindowModality(QtCore.Qt.WindowModal) self.progress.setAutoReset(True) self.progress.setAutoClose(True) self.progress.setMinimum(0) self.progress.setMaximum(100) self.progress.resize(800,220) self.progress.setWindowTitle("Running Query") self.progress.show() self.progress.setValue(0) self.progress.setValue(10) self.db.query(str(sql)) self.progress.setValue(25) if danger: QtGui.QMessageBox.information(self,"Message","Item was %s" % self.danger_word) self.showResults() def showResults(self): fields = self.db.getFields() rows = self.db.getRows() self.progress.setValue(30) self.ui.result_table.clear() self.ui.result_table.setColumnCount(len(fields)) self.ui.result_table.setRowCount(len(rows)) header = self.ui.result_table.horizontalHeader() self.ui.result_table.setHorizontalHeaderLabels(fields) i = 1 for row in rows: j = 0 for v in row: item = QtGui.QTableWidgetItem(str(v)) if i % 2: item.setBackgroundColor(QtGui.QColor(221,221,221)) self.ui.result_table.setItem(i,j,item) j += 1 i += 1 self.progress.setValue(100) self.progress.hide() header.setStretchLastSection(True) #header.setResizeMode(QtGui.QHeaderView.Stretch) self.ui.result_table.setVisible(False) self.ui.result_table.resizeColumnsToContents() self.ui.result_table.resizeRowsToContents() self.ui.result_table.setVisible(True) def clearAction(self): self.ui.query_field.clear() def newAction(self): next_id = self.ui.tab.count() + 1 new_tab = QtGui.QWidget() new_tab.setObjectName(_fromUtf8("tab_%i" % next_id)) new_query_field = QtGui.QPlainTextEdit(new_tab) new_query_field.setGeometry(QtCore.QRect(0, 0, 711, 161)) new_query_field.setObjectName(_fromUtf8("query_field")) vl = QtGui.QVBoxLayout(new_tab) vl.addWidget(new_query_field) self.ui.tab.addTab(new_tab, _fromUtf8("")) self.ui.tab.setTabText(self.ui.tab.indexOf(new_tab), QtGui.QApplication.translate("MainWindow", "Tab %i" % next_id, None, QtGui.QApplication.UnicodeUTF8)) self.ui.tab.setCurrentIndex(self.ui.tab.indexOf(new_tab)) def addServer(self): def callback(): self.dialog = QtGui.QWidget() save = QtGui.QPushButton("Save") test = QtGui.QPushButton("Test") cancel = QtGui.QPushButton("Cancel") cancel.clicked.connect(self.clearForm()) test.clicked.connect(self.testConnect()) save.clicked.connect(self.saveServer()) hbox = QtGui.QHBoxLayout() vbox = QtGui.QVBoxLayout() for field in self.to_add_server: item = QtGui.QLineEdit() if field == "Password": item.setEchoMode(QtGui.QLineEdit.Password) item.setObjectName(field.lower()) label = QtGui.QLabel(item) label.setText(field + ":") vbox.addWidget(label) vbox.addWidget(item) hbox.addStretch(1) hbox.addWidget(test) hbox.addWidget(save) hbox.addWidget(cancel) vbox.addStretch(1) vbox.addLayout(hbox) self.dialog.setLayout(vbox) self.dialog.move(QtGui.QApplication.desktop().screen().rect().center() - self.rect().center()) self.dialog.show() return callback def clearForm(self): def callback(): sender = self.sender() widget = sender.parent() for a in widget.findChildren(QtGui.QLineEdit): a.clear() widget.close() return callback def testConnect(self): def callback(): sender = self.sender() widget = sender.parent() tmp = {} for a in widget.findChildren(QtGui.QLineEdit): tmp[str(a.objectName())] = str(a.text()) try: con = MySQLdb.connect(tmp['host'], tmp['username'], tmp['password']) msg = "Connection successful, WOOT!" except: msg = "Awwww. Sorry, that info didn't work." pass QtGui.QMessageBox.information(widget, "Connection Test to %s" % tmp['host'], msg) return callback def saveServer(self): def callback(): sender = self.sender() widget = sender.parent() tmp = {} for a in widget.findChildren(QtGui.QLineEdit): tmp[str(a.objectName())] = str(a.text()) self.config.add_section(tmp["name"]) self.config.set(tmp["name"], "host", tmp["host"]) self.config.set(tmp["name"], "user", tmp["username"]) self.config.set(tmp["name"], "pass", tmp["password"]) with open(self.conf, 'wb') as configfile: self.config.write(configfile) for a in widget.findChildren(QtGui.QLineEdit): a.clear() widget.close() self.initMenu() QtGui.QMessageBox.information(self, "Message", "Connection Saved!") return callback def dbConnect(self, host, user, passwrd): def callback(): self.db = SsqbDb(host,user,passwrd) databases = self.db.getDbs() self.ui.list.clear() for db in databases: item = QtGui.QListWidgetItem(db['Database']) item.setData(self.type_id, "db") self.ui.list.addItem(item) return callback def listAction(self): def callback(): sender = self.sender() item = sender.currentItem() item_type = item.data(self.type_id) if item_type == "db": rtn = self.dbUseDb() elif item_type == "table": rtn = self.dbUseTable() return callback def dbUseDb(self): sender = self.sender() self.activeDb = item = sender.currentItem().text() query = "USE %s" % item self.db.queryNoVals(query) self.setStatus("%s is now the active database" % item) tables = self.db.getTables(item) self.ui.list.clear() for table in tables: item = QtGui.QListWidgetItem(table[0]) item.setData(self.type_id, "table") self.ui.list.addItem(item) def dbUseTable(self): sender = self.sender() self.activeTable = item = sender.currentItem().text() query = "SELECT * FROM %s LIMIT 1000" % item self.setStatus("%s is now the active table" % item) self.activeTab = self.ui.tab.currentWidget() self.activeQueryField = self.activeTab.findChild(QtGui.QPlainTextEdit) self.activeQueryField.setPlainText(query)
class Gui(QMainWindow): """ Main GUI Class contains the main function and interfaces between the GUI and functions """ def __init__(self,parent=None): QWidget.__init__(self,parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) """ Set GUI to track mouse """ QWidget.setMouseTracking(self,True) """ Dynamixel bus TODO: add other motors here as needed with their correct address""" self.dxlbus = DXL_BUS(DEVICENAME, BAUDRATE) port_num = self.dxlbus.port() base = DXL_MX(port_num, 1) shld = DXL_MX(port_num, 2) elbw = DXL_MX(port_num, 3) wrst = DXL_AX(port_num, 4) wrst2 = DXL_AX(port_num, 5) wrst3 = DXL_XL(port_num, 6) gripper = DXL_XL(port_num, 7) """Objects Using Other Classes""" self.kinect = Kinect() self.rexarm = Rexarm((base,shld,elbw,wrst,wrst2,wrst3),gripper) self.tp = TrajectoryPlanner(self.rexarm) self.sm = StateMachine(self.rexarm, self.tp, self.kinect) """ Attach Functions to Buttons & Sliders TODO: NAME AND CONNECT BUTTONS AS NEEDED """ self.ui.btn_exec.clicked.connect(self.execute) self.ui.btn_estop.clicked.connect(self.estop) self.ui.btnUser1.setText("Calibrate") self.ui.btnUser1.clicked.connect(partial(self.sm.set_next_state, "calibrate")) self.ui.sldrBase.valueChanged.connect(self.sliderChange) self.ui.sldrShoulder.valueChanged.connect(self.sliderChange) self.ui.sldrElbow.valueChanged.connect(self.sliderChange) self.ui.sldrWrist.valueChanged.connect(self.sliderChange) self.ui.sldrWrist2.valueChanged.connect(self.sliderChange) self.ui.sldrWrist3.valueChanged.connect(self.sliderChange) #self.ui.sldrGrip1.valueChanged.connect(self.sliderChange) self.ui.sldrMaxTorque.valueChanged.connect(self.sliderChange) self.ui.sldrSpeed.valueChanged.connect(self.sliderChange) self.ui.chk_directcontrol.stateChanged.connect(self.directControlChk) self.ui.rdoutStatus.setText("Waiting for input") """Team10 section for buttons""" self.ui.btnUser2.setText("teach") self.ui.btnUser2.clicked.connect(partial(self.sm.set_next_state, "teach")) self.ui.btnUser3.setText("repeat") self.ui.btnUser3.clicked.connect(partial(self.sm.set_next_state, "repeat")) self.ui.btnUser4.setText("Set ROI") self.ui.btnUser4.clicked.connect(partial(self.sm.set_next_state, "set_roi")) self.ui.btnUser5.setText("Set Exclusion") self.ui.btnUser5.clicked.connect(partial(self.sm.set_next_state, "set_exclusion")) self.ui.btnUser6.setText("Save frames") self.ui.btnUser6.clicked.connect(partial(self.sm.set_next_state, "save_frames")) self.ui.btn_task3.clicked.connect(partial(self.sm.set_next_state, "task3")) self.ui.btnUser7.setText("Click & Grab") self.ui.btnUser7.clicked.connect(partial(self.sm.set_next_state, "ClickandGrab")) """initalize manual control off""" self.ui.SliderFrame.setEnabled(False) """initalize rexarm""" self.rexarm.initialize() """Setup Threads""" self.videoThread = VideoThread(self.kinect) self.videoThread.updateFrame.connect(self.setImage) self.videoThread.start() self.logicThread = LogicThread(self.sm) self.logicThread.start() self.displayThread = DisplayThread(self.rexarm, self.sm) self.displayThread.updateJointReadout.connect(self.updateJointReadout) self.displayThread.updateEndEffectorReadout.connect(self.updateEndEffectorReadout) self.displayThread.updateStatusMessage.connect(self.updateStatusMessage) self.displayThread.start() """ Setup Timer this runs the trackMouse function every 50ms """ self._timer = QTimer(self) self._timer.timeout.connect(self.trackMouse) self._timer.start(50) """ Slots attach callback functions to signals emitted from threads""" @pyqtSlot(QImage, QImage, QImage, QImage) def setImage(self, rgb_image, depth_image, level_image, superpose_frame): if(self.ui.radioVideo.isChecked()): self.ui.videoDisplay.setPixmap(QPixmap.fromImage(rgb_image)) if(self.ui.radioDepth.isChecked()): self.ui.videoDisplay.setPixmap(QPixmap.fromImage(depth_image)) if(self.ui.radioUsr2.isChecked()): self.ui.videoDisplay.setPixmap(QPixmap.fromImage(level_image)) if(self.ui.radioUsr1.isChecked()): self.ui.videoDisplay.setPixmap(QPixmap.fromImage(superpose_frame)) @pyqtSlot(list) def updateJointReadout(self, joints): self.ui.rdoutBaseJC.setText(str("%+.2f" % (joints[0]*R2D))) self.ui.rdoutShoulderJC.setText(str("%+.2f" % ((joints[1]*R2D)+90.0))) self.ui.rdoutElbowJC.setText(str("%+.2f" % (joints[2]*R2D))) self.ui.rdoutWristJC.setText(str("%+.2f" % (joints[3]*R2D))) self.ui.rdoutWrist2JC.setText(str("%+.2f" % (joints[4]*R2D))) self.ui.rdoutWrist3JC.setText(str("%+.2f" % (joints[4]*R2D))) if(len(joints)>5): self.ui.rdoutWrist3JC.setText(str("%+.2f" % (joints[5]*R2D))) else: self.ui.rdoutWrist3JC.setText(str("N.A.")) @pyqtSlot(list) def updateEndEffectorReadout(self, pos): self.ui.rdoutX.setText(str("%+.2f" % (pos[0]))) self.ui.rdoutY.setText(str("%+.2f" % (pos[1]))) self.ui.rdoutZ.setText(str("%+.2f" % (pos[2]))) self.ui.rdoutT.setText(str("%+.2f" % (pos[3]))) self.ui.rdoutG.setText(str("%+.2f" % (pos[4]))) self.ui.rdoutP.setText(str("%+.2f" % (pos[5]))) @pyqtSlot(str) def updateStatusMessage(self, msg): self.ui.rdoutStatus.setText(msg) """ Other callback functions attached to GUI elements""" def execute(self): #self.rexarm.set_positions() self.sm.set_next_state("execute") def estop(self): self.rexarm.estop = True self.sm.set_next_state("estop") def sliderChange(self): """ Function to change the slider labels when sliders are moved and to command the arm to the given position """ self.ui.rdoutBase.setText(str(self.ui.sldrBase.value())) self.ui.rdoutShoulder.setText(str(self.ui.sldrShoulder.value())) self.ui.rdoutElbow.setText(str(self.ui.sldrElbow.value())) self.ui.rdoutWrist.setText(str(self.ui.sldrWrist.value())) self.ui.rdoutWrist2.setText(str(self.ui.sldrWrist2.value())) self.ui.rdoutWrist3.setText(str(self.ui.sldrWrist3.value())) #self.ui.rdoutGrip1.setText(str(self.ui.sldrGrip1.value())) self.ui.rdoutTorq.setText(str(self.ui.sldrMaxTorque.value()) + "%") self.ui.rdoutSpeed.setText(str(self.ui.sldrSpeed.value()) + "%") self.rexarm.set_torque_limits([self.ui.sldrMaxTorque.value()/100.0]*self.rexarm.num_joints, update_now = False) self.rexarm.set_speeds_normalized_global(self.ui.sldrSpeed.value()/100.0, update_now = False) joint_positions = np.array([self.ui.sldrBase.value()*D2R, self.ui.sldrShoulder.value()*D2R, self.ui.sldrElbow.value()*D2R, self.ui.sldrWrist.value()*D2R, self.ui.sldrWrist2.value()*D2R, self.ui.sldrWrist3.value()*D2R]) self.rexarm.set_positions(joint_positions, update_now = False) #self.rexarm.gripper.set_position(self.ui.sldrGrip1.value()*D2R) def directControlChk(self, state): if state == Qt.Checked: self.sm.set_next_state("manual") self.ui.SliderFrame.setEnabled(True) else: self.sm.set_next_state("idle") self.ui.SliderFrame.setEnabled(False) def trackMouse(self): """ Mouse position presentation in GUI TODO: after implementing workspace calibration display the world coordinates the mouse points to in the RGB video image. """ x = QWidget.mapFromGlobal(self,QCursor.pos()).x() y = QWidget.mapFromGlobal(self,QCursor.pos()).y() if ((x < MIN_X) or (x >= MAX_X) or (y < MIN_Y) or (y >= MAX_Y)): self.ui.rdoutMousePixels.setText("(-,-,-)") self.ui.rdoutMouseWorld.setText("(-,-,-)") else: x = x - MIN_X y = y - MIN_Y if(self.kinect.currentDepthFrame.any() != 0): z = self.kinect.currentDepthFrame[y][x] self.ui.rdoutMousePixels.setText("(%.0f,%.0f,%.0f)" % (x,y,z)) PointCameraFrm = self.kinect.ConvertImagePointToCameraFrame(np.array([x,y])) PointWorldFrm = self.kinect.ConvertCameraFrametoWorlFrame(PointCameraFrm) #self.ui.rdoutMouseWorld.setText("(-,-,-)") self.ui.rdoutMouseWorld.setText("(%.3f,%.3f,%.3f)" % (PointWorldFrm[0],PointWorldFrm[1],PointWorldFrm[2])) def mousePressEvent(self, QMouseEvent): """ Function used to record mouse click positions for calibration """ """ Get mouse posiiton """ x = QMouseEvent.x() y = QMouseEvent.y() """ If mouse position is not over the camera image ignore """ if ((x < MIN_X) or (x > MAX_X) or (y < MIN_Y) or (y > MAX_Y)): return """ Change coordinates to image axis """ self.kinect.last_click[0] = x - MIN_X self.kinect.last_click[1] = y - MIN_Y if (self.kinect.kinectCalibrated == True): self.kinect.PointCamera_last_click = self.kinect.ConvertImagePointToCameraFrame(np.array([x - MIN_X, y - MIN_Y])) self.kinect.PointWorld_last_click = self.kinect.ConvertCameraFrametoWorlFrame(self.kinect.PointCamera_last_click) for i in range(10): self.kinect.BlockCenter, self.kinect.BlockOrientation_last_click = self.kinect.SelectBlock(np.array([ self.kinect.last_click[0], self.kinect.last_click[1]])) if not np.array_equal(self.kinect.BlockCenter,np.array([0.0, 0.0, 0.0])): self.kinect.PointWorld_last_click = self.kinect.BlockCenter #print("Coodinates: "+str(self.kinect.PointWorld_last_click)) #print("Orientation: "+str(self.kinect.BlockOrientation_last_click)) break time.sleep(0.010) print("Wold point selected: "+str(self.kinect.PointWorld_last_click)) print("Orientation: " +str(self.kinect.BlockOrientation_last_click)) self.kinect.new_click = True
class MainWindow(QtGui.QMainWindow): def __init__(self): super(MainWindow, self).__init__() # UI Setup self.ui = Ui_MainWindow() self.ui.setupUi(self) # Set the default icons for UI actions self.ui.actionNew.setIcon(QtGui.QIcon.fromTheme("document-new")) self.ui.actionOpen.setIcon(QtGui.QIcon.fromTheme("document-open")) self.ui.actionSave.setIcon(QtGui.QIcon.fromTheme("document-save")) self.ui.actionSave_As.setIcon(QtGui.QIcon.fromTheme("document-save-as")) self.ui.actionPrint.setIcon(QtGui.QIcon.fromTheme("document-print")) self.ui.actionQuit.setIcon(QtGui.QIcon.fromTheme("system-log-out")) self.ui.actionUndo.setIcon(QtGui.QIcon.fromTheme("edit-undo")) self.ui.actionRedo.setIcon(QtGui.QIcon.fromTheme("edit-redo")) self.ui.actionCut.setIcon(QtGui.QIcon.fromTheme("edit-cut")) self.ui.actionCopy.setIcon(QtGui.QIcon.fromTheme("edit-copy")) self.ui.actionPaste.setIcon(QtGui.QIcon.fromTheme("edit-paste")) self.ui.actionDelete.setIcon(QtGui.QIcon.fromTheme("edit-delete")) self.ui.actionPreferences.setIcon(QtGui.QIcon.fromTheme("preferences")) self.ui.actionAbout.setIcon(QtGui.QIcon.fromTheme("help-browser")) self.ui.actionRun.setIcon(QtGui.QIcon.fromTheme("go-next")) # UI ToolBox self.buttonGroup = QtGui.QButtonGroup() self.buttonGroup.setExclusive(False) self.buttonGroup.buttonClicked[int].connect(self.toolBoxButtonClicked) self.toolBox = self.ui.componentBrowser # Populate the toolbox self.createToolBox() # Create a scene for the GraphicsView self.scene=DiagramScene() self.ui.graphicsView.setScene(self.scene) self.scene.setSceneRect(0,0,600,400) # Make it bigger self.setWindowState(QtCore.Qt.WindowMaximized) # Create an UNDO stack and view self.undoStack = QtGui.QUndoStack(self) self.undoView = QtGui.QUndoView(self.undoStack) self.undoView.setWindowTitle("Undo View") self.undoView.show() self.undoView.setAttribute(QtCore.Qt.WA_QuitOnClose, False) self.createActions() self.createMenus() # Set the window title self.setWindowTitle("Schematix") def createActions(self): self.ui.actionDelete = QtGui.QAction("&Delete Item", self) self.ui.actionDelete.setShortcut("Del"); QtCore.QObject.connect(self.ui.actionDelete, QtCore.SIGNAL("triggered()"), self.deleteItem) # QtCore.QObject.connect(self.scene, # QtCore.SIGNAL("itemMoved()"), # self.itemMoved) self.scene.itemMoved.connect(self.itemMoved) self.ui.actionUndo = self.undoStack.createUndoAction(self, "&Undo") self.ui.actionUndo.setShortcuts(QtGui.QKeySequence.Undo) self.ui.actionRedo = self.undoStack.createRedoAction(self, "&Redo") self.ui.actionRedo.setShortcuts(QtGui.QKeySequence.Redo) def createMenus(self): self.newEditMenu = self.ui.menubar.addMenu("&EditNew") self.newEditMenu.addAction(self.ui.actionUndo) self.newEditMenu.addAction(self.ui.actionRedo) self.newEditMenu.addSeparator() self.newEditMenu.addAction(self.ui.actionDelete) QtCore.QObject.connect(self.ui.menuEdit, QtCore.SIGNAL("aboutToShow()"), self.itemMenuAboutToShow) QtCore.QObject.connect(self.ui.menuEdit, QtCore.SIGNAL("aboutToHide()"), self.itemMenuAboutToHide) def itemMenuAboutToHide(self): self.ui.actionDelete.setEnabled(True) def itemMenuAboutToShow(self): self.ui.actionDelete.setEnabled(len(self.scene.selectedItems())!=0) def deleteItem(self): print "Delete called..." if (len(self.scene.selectedItems()) == 0): return deleteCommand = DeleteCommand(self.scene) self.undoStack.push(deleteCommand); def addComponent(self, component): # TODO: Make it so that the component has to be dragged onto the # canvas from the toolbox, or clicked once in the toolbox and then # clicked again on the canvas to place or right click/esc to cancel. action = AddCommand(component, self.scene) self.undoStack.push(action) def itemMoved(self, movedItem, oldPosition): print "MAINWINDOW: An item in the graphics view got moved..." self.undoStack.push(MoveCommand(movedItem, oldPosition)) def createToolBox(self): """ Populates the toolbox widget of the main UI with components from the component library """ id = 0 # Parse the component library and add components to the toolbox for library_name, library in components: # At this level of the loop we have a library of components # Create a new section on the toolbox for this library and add # its components as buttons layout = QtGui.QGridLayout() x = 0 y = 0 for component in library: # For each component, add a button title = component["name"] layout.addWidget(self.createCellWidget(title,id), y, x) id += 1 if x >= 1: x = 0 y += 1 else: x += 1 layout.setRowStretch(3, 10) layout.setColumnStretch(2, 10) itemWidget = QtGui.QWidget() itemWidget.setLayout(layout) self.toolBox.addItem(itemWidget, library_name) def createCellWidget(self, text, id): """ Create a button for the toolbox """ button = QtGui.QToolButton() button.setIcon(QtGui.QIcon.fromTheme("emblem-symbolic-link")) button.setIconSize(QtCore.QSize(32, 32)) button.setText(text) self.buttonGroup.addButton(button, id) layout = QtGui.QGridLayout() layout.addWidget(button, 0, 0, QtCore.Qt.AlignHCenter) layout.addWidget(QtGui.QLabel(text), 1, 0, QtCore.Qt.AlignCenter) widget = QtGui.QWidget() widget.setLayout(layout) return widget def toolBoxButtonClicked(self, id): """ Event handler for tool box button clicks. For now just add to the diagram the component that was clicked by the user """ # TODO: Add graphics for different block types # TODO: Allow components to be 'dragged' from the toolbox onto the # canvas # TODO: Show contextual help if the mouse is hovered over an item in # the toolbox showing information about the relevant component buttons = self.buttonGroup.buttons() for button in buttons: if self.buttonGroup.button(id) != button: button.setChecked(False) sender = self.buttonGroup.button(id).text() self.ui.ObjectInspectorText.setText(sender) self.addComponent(id)