Esempio n. 1
0
class Implement(QtWidgets.QWidget, first_des.Ui_Form):
    def __init__(self):
        super().__init__()
        self.setupUi(self)
        self.img = None
        self.globl = ""
        #self.put_start_img()
        self.thread = QThread()
        self.thread.start()
        self.server = SimpleXMLRPCServer(("10.42.0.1", 60002))
        self.server.logRequests = False
        self.server.register_function(set_msg)
        self.serverControlThread = threading.Thread(
            target=self.server.serve_forever)
        self.serverControlThread.daemon = True
        self.serverControlThread.start()
        self.robot = xmlrpc.client.ServerProxy('http://%s:%d' %
                                               ("10.42.0.69", 60001))
        self.spawer = Spawer(self.on_recive, self.write_msg)
        self.spawer.start()

    def on_recive(self, img):
        '''recive image in opencv format'''
        self.img = img
        self.reWrite()  #- method for updating label content
        #self.imgLabel.setPixmap(QtGui.QPixmap.fromImage(img))
        #self.imgLabel.setAlignment(Qt.AlignHCenter    # qtCore    <-> QtCore
        #                                 | Qt.AlignVCenter)

    def write_msg(self, msg):
        self.globl += msg + "\n"
        #print(self.globl.count("\n"))
        if (self.globl.count("\n") > 30):
            ind = self.globl.find("\n")
            self.globl = self.globl[ind + 1:]
        self.globalLabel.setText(self.globl)

    def addText(self):
        if not self.text.text() == "":
            text = self.text.text()
            self.globl += self.text.text() + "\n"
            self.text.setText("")
            if (self.globl.count("\n") > 30):
                ind = self.globl.find("\n")
                self.globl = self.globl[ind + 1:]
            self.globalLabel.setText(self.globl)
            if text == "write mode":
                _ = self.robot.write_mode()
            if text == "read mode":
                _ = self.robot.read_mode()
            if text.isdigit():
                _ = self.robot.set_req(text)

    def keyPressEvent(self, e):
        if e.key() == Qt.Key_Escape:
            self.close()
        elif e.key() == Qt.Key_Return:
            self.addText()
        elif e.key() == Qt.Key_Enter:
            self.addText()

    def waiter(self):
        time.sleep(10)
        self.server.server_close()
        QApplication.instance().quit()

    def closeEvent(self, event):
        reply = QtWidgets.QMessageBox.question(
            self, 'Message', "Are you sure to quit?",
            QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,
            QtWidgets.QMessageBox.No)
        if reply == QtWidgets.QMessageBox.Yes:
            _ = self.robot.stop()
            self.spawer.stop_trigger.emit()
            t1 = threading.Thread(target=self.waiter)
            t1.start()
            event.ignore()
        else:
            event.ignore()
Esempio n. 2
0
class Implement(QtWidgets.QWidget, mouseEvent.Ui_Form):
    def __init__(self):
        super().__init__()
        self.setupUi(self)
        self.draw = False
        self.mode = {"mode": 404, "assert": False}
        self.default = cv2.imread("img.jpg")
        self.frame = None
        self.send_request = False  #tell us about write or rwad mode
        self.texts = [
            "geting ready for writing mode", "geting ready for reading mode",
            "put finger on the sensor", "remove finger from sensor",
            "put the same finger again", "stored!", "read out",
            "look at the camera", "match", "Unexpected ERROR"
        ]
        self.Ready_for_update = threading.Event()
        self.Ready_for_update.set()
        self.set(self.default)
        self.pos = []
        self.start = None
        self.face_cascade = cv2.CascadeClassifier(
            '../../data/haarcascades/haarcascade_frontalface_default.xml')
        self.finished = True  #predict twise requesting
        self.thread = QThread()
        self.thread.start()
        self.server = SimpleXMLRPCServer(("10.42.0.1", 60002))
        self.server.logRequests = False
        self.server.register_function(self.comReceiver)
        self.serverControlThread = threading.Thread(
            target=self.server.serve_forever)
        self.serverControlThread.daemon = True
        self.serverControlThread.start()
        self.robot = xmlrpc.client.ServerProxy('http://%s:%d' %
                                               ("10.42.0.69", 60001))
        self.spawer = Spawer(self.on_recive)  #, self.write_msg)
        self.spawer.start()

    def on_recive(self, frame):
        self.frame = frame
        self.set(self.frame)

    def comReceiver(self, msg):
        t = threading.Thread(target=self.comHandler, args=(msg, ))
        t.start()
        return 0

    def comHandler(self, msg):
        self.mode = {"mode": 404, "assert": 0}
        if msg == "error": self.mode["mode"] = 8  #msg = self.texts[8]
        elif msg == "put finger": self.mode["mode"] = 2  #msg = self.texts[2]
        elif msg == "remove finger":
            self.mode["mode"] = 3  #msg = self.texts[3]
        elif msg == "same finger":
            self.mode["mode"] = 4  #msg = self.texts[4]
        elif msg == "stored":
            self.mode["mode"] = 5  #msg = self.texts[5]
        elif msg == "read":
            self.mode["mode"] = 6  #msg = self.texts[5]
        elif msg == "camera":
            self.mode["mode"] = 7  #msg = self.texts[6]
        elif msg == "match":
            self.mode["mode"] = 8  #msg = self.texts[7]
        elif msg == "unstored":
            self.mode = {"mode": 5, "assert": 1}  #msg = "Un" + self.texts[5]
        elif msg == "unread":
            self.mode = {"mode": 6, "assert": 1}  #msg = "Un" + self.texts[5]
        elif msg == "No match":
            self.mode = {"mode": 8, "assert": 1}  #msg = "No " + self.texts[7]
        elif msg == "square face":
            self.mode["mode"] = 9
        elif msg == "return":
            time.sleep(2)
            self.mode = {"mode": 404, "assert": False}
        self.set(self.frame)

    def set(self, img, check=False, msg=""):
        if self.Ready_for_update.is_set():
            self.update(img, check, msg)

    def update(self, img, check=False, msg=""):
        self.Ready_for_update.clear()
        if self.mode["assert"]: msg = "not "
        if img is None: img = self.default
        img = img.copy()
        if self.draw:
            x0, y0 = self.pos[0]
            x1, y1 = self.pos[1]
            angle = math.atan2(x1 - x0, y1 - y0)
            angle = angle * 180 / 3.14
            if angle > -97 and angle < -83:
                color = (0, 255, 0)
                if check:
                    self.start = True
            elif angle > 83 and angle < 97:
                color = (0, 255, 0)
                if check: self.start = False
            else: color = (0, 0, 255)
            cv2.line(img, self.pos[0], self.pos[1], color, 2)
            cv2.putText(img, str(int(angle)), (300, 300),
                        cv2.FONT_HERSHEY_SIMPLEX, 1, color, 2)
        elif self.mode["mode"] < 2:
            msg += self.texts[self.mode["mode"]]
            gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
            gray_image = cv2.equalizeHist(gray_image)
            img = cv2.cvtColor(gray_image, cv2.COLOR_GRAY2RGB)
            cv2.putText(img, msg, (180, 300), cv2.FONT_HERSHEY_SIMPLEX, 1,
                        (51, 51, 153), 2)
            #if self.mode["mode"]: t = threading.Thread(target=self.fake_robot, args=(True,))
            #else: t = threading.Thread(target=self.fake_robot, args=(False, ))
            if not self.send_request:
                if self.mode["mode"] == 0: _ = self.robot.write_mode()
                elif self.mode["mode"] == 1: _ = self.robot.read_mode()
                self.send_request = True
                #self.finished = False

        elif self.mode["mode"] < 9:
            msg += self.texts[self.mode["mode"]]
            gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
            gray_image = cv2.equalizeHist(gray_image)
            img = cv2.cvtColor(gray_image, cv2.COLOR_GRAY2RGB)
            cv2.putText(img, msg, (180, 300), cv2.FONT_HERSHEY_SIMPLEX, 1,
                        (0, 0, 153), 2)
        elif self.mode["mode"] == 9:
            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
            faces = self.face_cascade.detectMultiScale(gray, 1.3, 5)
            for (x, y, w, h) in faces:
                cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2)
            self.send_request = False
        '''if self.flag[1] or self.flag[2]:
            gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
            gray_image = cv2.equalizeHist(gray_image)
            if self.flag[1]: text = "get ready for writeng mode"
            else:            text = "put finger on the sensor" 
            cv2.putText(gray_image, text,
                        (180,300),
                        cv2.FONT_HERSHEY_SIMPLEX,
                        1,
                        (255),
                        2)
            img = cv2.cvtColor(gray_image,cv2.COLOR_GRAY2RGB)
            self.direct = None
            if self.flag[1]: ar = (2, 1, 5)
            else:            ar = (2, 2, 5) 
            t = threading.Thread(target=self.waiter, args=ar)
            t.start()'''

        height, width, colors = img.shape
        bytesPerLine = 3 * width
        QImage = QtGui.QImage
        image = QImage(img.data, width, height, bytesPerLine,
                       QImage.Format_RGB888)
        image = image.rgbSwapped()
        pixmap = QtGui.QPixmap(image)
        self.label.setPixmap(pixmap)
        self.Ready_for_update.set()

    def keyPressEvent(self, e):
        if e.key() == Qt.Key_Escape:
            self.close()

    def closeEvent(self, event):
        reply = QtWidgets.QMessageBox.question(
            self, 'Message', "Are you sure to quit?",
            QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,
            QtWidgets.QMessageBox.No)
        if reply == QtWidgets.QMessageBox.Yes:
            _ = self.robot.stop()
            event.accept()
        else:
            event.ignore()

    def mousePressEvent(self, ev):
        if not self.send_request:
            if ev.button() == Qt.LeftButton:
                print("Pressed")
                self.draw = True
                self.pos.append((ev.x(), ev.y()))
                self.pos.append((ev.x(), ev.y()))
                self.set(self.frame)

    def mouseReleaseEvent(self, ev):
        if not self.send_request:
            if ev.button() == Qt.LeftButton:
                print("Released")
                self.set(self.frame, check=True)
                self.draw = False
                if not self.start is None:
                    if self.start: self.mode["mode"] = 0
                    else: self.mode["mode"] = 1
            #    t = threading.Thread(target=self.waiter, args=(1, 0))
            #    t.start()
            #print("HERE")
                self.set(self.frame)
                self.pos = []

    def mouseMoveEvent(self, ev):
        if not self.send_request:
            self.pos[1] = (ev.x(), ev.y())
            self.set(self.frame)
Esempio n. 3
0
class ExampleApp(QtWidgets.QWidget, mouseEvent.Ui_Form):
    def __init__(self):
        # Это здесь нужно для доступа к переменным, методам
        # и т.д. в файле design.py
        super().__init__()
        self.stopEvent = threading.Event()
        self.check = True
        self.thread = QThread()
        self.thread.start()
        self.setWindowFlags(Qt.FramelessWindowHint)
        self.setupUi(self)  # Это нужно для инициализации нашего дизайна
        self.robot = xmlrpc.client.ServerProxy('http://%s:%d' %
                                               (IP_ROBOT, CONTROL_PORT))
        self.spawer = Spawer(self.on_recive, self.stopEvent)
        self.spawer.start()

    def on_recive(self, img):
        pixmap = QtGui.QPixmap(img)
        self.label.setPixmap(pixmap)

    def closeEvent(self, event):
        reply = QtWidgets.QMessageBox.question(
            self, 'Message', "Are you sure to quit?",
            QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,
            QtWidgets.QMessageBox.No)
        if reply == QtWidgets.QMessageBox.Yes:
            _ = self.robot.stopStreaming()
            self.stopEvent.wait()
            event.accept()
        else:
            event.ignore()

    def keyPressEvent(self, e):
        if self.check:
            if e.type() == QEvent.KeyPress:
                if e.text() == 'w':
                    _ = self.robot.comRecv('cam/down')
                    #self.check = False
                    e.accept()
                elif e.text() == 'd':
                    _ = self.robot.comRecv('cam/RIGHT')
                    #self.check = False
                    e.accept()
                elif e.text() == 'a':
                    _ = self.robot.comRecv('cam/LEFT')
                    #self.check = False
                    e.accept()
                elif e.text() == 's':
                    _ = self.robot.comRecv('cam/up')
                    #self.check = False
                    e.accept()
                elif e.key() == Qt.Key_Up:
                    _ = self.robot.comRecv('drive/ahead/200')
                    self.check = False
                    e.accept()
                elif e.key() == Qt.Key_Down:
                    _ = self.robot.comRecv('drive/backward/200')
                    self.check = False
                    e.accept()
                elif e.key() == Qt.Key_Left:
                    _ = self.robot.comRecv('drive/left/200')
                    self.check = False
                    e.accept()
                elif e.key() == Qt.Key_Right:
                    _ = self.robot.comRecv('drive/right/200')
                    self.check = False
                    e.accept()
        if e.key() == Qt.Key_Escape:
            self.close()

    def keyReleaseEvent(self, e):
        if e.type() == QEvent.KeyRelease:
            if e.key() in [Qt.Key_Up, Qt.Key_Down, Qt.Key_Left, Qt.Key_Right
                           ] and not e.isAutoRepeat():
                _ = self.robot.comRecv('drive/ahead/0')
                self.check = True
                e.accept()