Ejemplo n.º 1
0
def start_game(game_data):
    char_data = game_data["CHAR"]
    map_data = game_data["LOC"]
    flags = game_data["FLAGS"]
    cam = Camera(screen_size=screen_size, roster=char_data, flags=flags)
    cam.load_map(map_name=map_data["MAP"], goto=map_data["POSITION"])
    return cam
Ejemplo n.º 2
0
    def __init__(self, argv):
        QtGui.QMainWindow.__init__(self)
        self.MainWindow = Ui_MainWindow
        self.ui = Ui_MainWindow
        self.MainWindow.__init__(self.window)
        self.setupUi(self)
        self.show()

        self.logger = Logger(self.logPanel)
        self.device = EthernetDevice(self.logger)

        self.device.disconState = QtGui.QPixmap(
            _fromUtf8('../res/disconnected'))
        self.device.conState = QtGui.QPixmap(_fromUtf8('../res/connected'))
        self.device.currentState = 0

        self.device.power = 0
        self.device.direction = 0

        self.addWidgets()

        self.updater = DataUpdateThread(self)  # create a thread
        self.updater.trigger.connect(
            self.updateState)  # connect to it's signal
        self.updater.start()

        self.cam = Camera(self)
Ejemplo n.º 3
0
def ch7():
    # Step 1
    floor = Sphere()
    floor.transform = Matrix.scaling(10, 0.01, 10)
    floor.material = Material()
    floor.material.color = Color(1, 0.9, 0.9)
    floor.material.specular = 0

    # Step 2
    left_wall = Sphere()
    left_wall.transform = Matrix.translation(0, 0, 5) * Matrix.rotation_y(-45) * \
                          Matrix.rotation_x(90) * Matrix.scaling(10, 0.01, 10)
    left_wall.material = floor.material

    # Step 3
    right_wall = Sphere()
    right_wall.transform = Matrix.translation(0, 0, 5) * Matrix.rotation_y(45) * \
                           Matrix.rotation_x(90) * Matrix.scaling(10, 0.01, 10)
    right_wall.material = floor.material

    # Step 4
    middle = Sphere()
    middle.transform = Matrix.translation(-0.5, 1, 0.5)
    middle.material = Material()
    middle.material.color = Color(0.1, 1, 0.5)
    middle.material.diffuse = 0.7
    middle.material.specular = 0.3

    # Step 5
    right = Sphere()
    right.transform = Matrix.translation(1.5, 0.5, -0.5) * Matrix.scaling(
        0.5, 0.5, 0.5)
    right.material = Material()
    right.material.color = Color(0.5, 1, 0.1)
    right.material.diffuse = 0.7
    right.material.specular = 0.3

    # Step 6
    left = Sphere()
    left.transform = Matrix.translation(-1.5, 0.33, -0.75) * Matrix.scaling(
        0.33, 0.33, 0.33)
    left.material = Material()
    left.material.color = Color(1, 0.8, 0.1)
    left.material.diffuse = 0.7
    left.material.specular = 0.3

    world = World()
    world.light = PointLight(point(-10, 10, -10), Color(1, 1, 1))
    world.objects.extend([floor, left_wall, right_wall, middle, right, left])

    camera = Camera(100, 50, 60)
    # camera = Camera(500, 250, 60)
    camera.transform = view_transform(point(0, 1.5, -5), point(0, 1, 0),
                                      vector(0, 1, 0))

    canvas = camera.render(world)

    with open('ch8.ppm', 'w') as fp:
        fp.write(canvas.to_ppm())
Ejemplo n.º 4
0
def ch14():
    world = World()
    world.light = PointLight(point(-10, 10, -10), Color(1, 1, 1))

    hex = hexagon()
    world.objects.append(hex)

    camera = Camera(100, 50, 60)
    camera.transform = view_transform(point(0, 2, -1), point(0, 0, 0),
                                      vector(0, 1, 0))
    canvas = camera.render(world)

    with open('ch14.ppm', 'w') as fp:
        fp.write(canvas.to_ppm())
Ejemplo n.º 5
0
def ch9():
    # Step 1
    floor = Plane()
    floor.transform = Matrix.scaling(10, 0.01, 10)
    floor.material = Material()
    floor.material.color = Color(1, 0.9, 0.9)
    floor.material.specular = 0
    floor.material.pattern = StripePattern(Color(1, 0, 0), Color(0, 0, 1))

    # Middle biggest sphere
    middle = Sphere()
    middle.transform = Matrix.translation(-0.5, 1, 0.5)
    middle.material = Material()
    middle.material.color = Color(0.1, 1, 0.5)
    middle.material.diffuse = 0.7
    middle.material.specular = 0.3
    middle.material.pattern = RingPattern(Color(1, 0, 1), Color(1, 1, 1))
    middle.material.pattern.transform = Matrix.scaling(0.25, 0.5, 0.25)

    # Smaller right sphere
    right = Sphere()
    right.transform = Matrix.translation(1.5, 0.5, -0.5) * Matrix.scaling(0.5, 0.5, 0.5)
    right.material = Material()
    right.material.color = Color(0.5, 1, 0.1)
    right.material.diffuse = 0.7
    right.material.specular = 0.3
    right.material.reflective = 1.0

    # Left yellow sphere
    left = Sphere()
    left.transform = Matrix.translation(-1.5, 0.33, -0.75) * Matrix.scaling(0.33, 0.33, 0.33)
    left.material = Material()
    left.material.color = Color(1, 0.8, 0.1)
    left.material.diffuse = 0.7
    left.material.specular = 0.3

    world = World()
    world.light = PointLight(point(-10, 10, -10), Color(1, 1, 1))
    world.objects.extend([floor, middle, right, left])

    camera = Camera(100, 50, 60)
    # camera = Camera(500, 250, 60)
    camera.transform = view_transform(point(0, 1.5, -5),
                                      point(0, 1, 0),
                                      vector(0, 1, 0))

    canvas = camera.render(world)

    with open('ch9.ppm', 'w') as fp:
        fp.write(canvas.to_ppm())
Ejemplo n.º 6
0
    def generateNeighbour(self, camera_move_method):
        # deep copy cameras
        cameras = [copy.copy(c) for c in self.cameras]

        transformation = self.randomlyChooseTransformationMethod(cameras)

        # perform transformation
        if transformation == 'insert':
            new_camera = Camera(self.problem,
                                self.getRandomFreePointFromRoom())
            cameras.append(new_camera)
        elif transformation == 'remove':
            cameras.remove(random.choice(self.cameras))
        elif transformation == 'move':
            to_modify = random.choice(self.cameras)
            if camera_move_method == 'local':
                to_modify.move()
            elif camera_move_method == 'random':
                to_modify.move(self.getRandomFreePointFromRoom())
            else:
                raise RuntimeError("Wrong move camera method!")
        else:
            raise RuntimeError("Wrong transformation method!")

        return State(self.problem, cameras)
Ejemplo n.º 7
0
    def generateCameras(self):
        cameras = []
        for _ in range(self.problem.min_number_of_cams):
            cameras.append(
                Camera(self.problem, self.getRandomFreePointFromRoom()))

        return cameras
Ejemplo n.º 8
0
 def __init__(self, argv):
     QtGui.QMainWindow.__init__(self)
     self.MainWindow=Ui_MainWindow
     self.ui=Ui_MainWindow
     self.MainWindow.__init__(self.window)
     self.setupUi(self)
     self.show()
     
     self.logger = Logger(self.logPanel)
     self.device = EthernetDevice(self.logger)
     
     self.device.disconState = QtGui.QPixmap(_fromUtf8('../res/disconnected'))
     self.device.conState = QtGui.QPixmap(_fromUtf8('../res/connected'))
     self.device.currentState = 0
     
     self.device.power=0
     self.device.direction=0
     
     self.addWidgets()
     
     self.updater = DataUpdateThread(self)    # create a thread
     self.updater.trigger.connect(self.updateState)  # connect to it's signal
     self.updater.start() 
     
     self.cam = Camera(self)
Ejemplo n.º 9
0
    def __init__(self):
        logging.info("Starting Spaceship")
        self.q_mode_camera = Queue.Queue()
        self.q_com_device_in = Queue.Queue()
        self.q_com_device_out = Queue.Queue()

        GPIO.setmode(GPIO.BOARD)
        # init pin 7 for camera PWM
        GPIO.setup(7, GPIO.OUT)
        # Init pin 11 for diode
        GPIO.setup(11, GPIO.OUT)
        # Init pin 13 for relay for power to servo
        GPIO.setup(13, GPIO.OUT)

        self.mode = ""
        self.online = False
        self.camera = Camera(self.q_mode_camera)
        self.com_device = ComDevice(self.q_com_device_in, self.q_com_device_out)
        self.running = True
Ejemplo n.º 10
0
class Spaceship:
    def __init__(self):
        logging.info("Starting Spaceship")
        self.q_mode_camera = Queue.Queue()
        self.q_com_device_in = Queue.Queue()
        self.q_com_device_out = Queue.Queue()

        GPIO.setmode(GPIO.BOARD)
        # init pin 7 for camera PWM
        GPIO.setup(7, GPIO.OUT)
        # Init pin 11 for diode
        GPIO.setup(11, GPIO.OUT)
        # Init pin 13 for relay for power to servo
        GPIO.setup(13, GPIO.OUT)

        self.mode = ""
        self.online = False
        self.camera = Camera(self.q_mode_camera)
        self.com_device = ComDevice(self.q_com_device_in, self.q_com_device_out)
        self.running = True

    # Main loop
    def run(self):

        logging.info('Started')
        self.com_device.start()
        self.camera.start()

        try:
            while self.running:
                self.check_queue()
                self.blink_diode()
                time.sleep(2)
        except KeyboardInterrupt:
            self.shutdown()
        finally:
            pass
        GPIO.cleanup()
        logging.info('Finished')

    def set_mode(self, mode):
        logging.info("Setting mode "+mode)
        self.q_mode_camera.put(mode)
        self.q_com_device_in.put(mode)
        self.mode = mode

    def shutdown(self):
        print("Shutting down...")
        self.running = False
        self.set_mode("EXIT")
        logging.info("All shut down")
        logging.info("Shutdown Spaceship")

    def check_queue(self):
        try:
            msg = self.q_com_device_out.get_nowait().upper()
            if msg == "MODE 1" \
                    or msg == "MODE 2" \
                    or msg == "MODE 3" \
                    or msg == "START":
                self.set_mode(msg)
            elif msg == "EXIT":
                self.shutdown()
            elif msg == "ONLINE":
                self.online = True
            elif msg == "OFFLINE":
                self.online = False
        except Queue.Empty:
            None
        finally:
            pass

    def blink_diode(self):
        if self.mode == "":
            GPIO.output(11, GPIO.HIGH)
            time.sleep(0.5)
            GPIO.output(11, GPIO.LOW)
            time.sleep(0.5)
            self.blink_online_status()

        elif self.mode == "MODE 1":
            self.blink()
            time.sleep(0.5)
            self.blink_online_status()

        elif self.mode == "MODE 2":
            self.blink()
            self.blink()
            time.sleep(0.5)
            self.blink_online_status()

        elif self.mode == "MODE 3":
            self.blink()
            self.blink()
            self.blink()
            time.sleep(0.5)
            self.blink_online_status()

    def blink_online_status(self):
        if self.online:
            GPIO.output(11, GPIO.HIGH)
            time.sleep(0.5)
            GPIO.output(11, GPIO.LOW)
        else:
            time.sleep(0.5)

    @staticmethod
    def blink():
        GPIO.output(11, GPIO.HIGH)
        time.sleep(0.1)
        GPIO.output(11, GPIO.LOW)
        time.sleep(0.1)
Ejemplo n.º 11
0
def step_impl(context):
    context.c = Camera(context.hsize, context.vsize, context.field_of_view)
Ejemplo n.º 12
0
def step_impl(context, width, height, degrees):
    context.c = Camera(width, height, degrees)
Ejemplo n.º 13
0
 def parse(self):
     args = sys.argv
     for i in range(len(args)):
         if args[i] == "-h":
             self.help()
         elif args[i] == "-t":
             camera = Camera()
             checkboard = (6, 9)
             winSize = (5, 5)
             print(args)
             camera.Calibration(args[i + 1], checkboard, winSize)
             camera.save()
         elif args[i] == "-i":
             if not args[i + 1]:
                 raise Exception(
                     "need path after -i type -h for more information")
             camera = Camera()
             camera.load()
             img = cv2.imread(args[i + 1])
             camera.imgCamToWorld(img)
Ejemplo n.º 14
0
class ControlApp(QtGui.QMainWindow, Ui_MainWindow):
    #def values
    camDirectionAngle = 0
    keylist = []
    cam = None
    updater = None

    def __init__(self, argv):
        QtGui.QMainWindow.__init__(self)
        self.MainWindow = Ui_MainWindow
        self.ui = Ui_MainWindow
        self.MainWindow.__init__(self.window)
        self.setupUi(self)
        self.show()

        self.logger = Logger(self.logPanel)
        self.device = EthernetDevice(self.logger)

        self.device.disconState = QtGui.QPixmap(
            _fromUtf8('../res/disconnected'))
        self.device.conState = QtGui.QPixmap(_fromUtf8('../res/connected'))
        self.device.currentState = 0

        self.device.power = 0
        self.device.direction = 0

        self.addWidgets()

        self.updater = DataUpdateThread(self)  # create a thread
        self.updater.trigger.connect(
            self.updateState)  # connect to it's signal
        self.updater.start()

        self.cam = Camera(self)

    def addWidgets(self):
        """ В этом методе мы добавляем виджеты и wприсоединяем обработчики сигналов.
            Обработчик сигнала для виджета так же называется "слотом"
        """

        #camview setup
        #path="C:\\Users\\SCB\\Downloads\\test.avi"

        path = QtCore.QUrl("rtsp://192.168.2.100:7070/")
        media = Phonon.MediaSource(path)
        self.videoPlayer.load(media)
        self.videoPlayer.play()

        #set maps properties
        url = "res.gmap.html"
        page = QtCore.QUrl("../res/gmap.html")
        self.mapView.load(page)

        #thumper pic
        myPixmap = QtGui.QPixmap(_fromUtf8('../res/thumper_top.jpg'))
        self.thumperImage.setPixmap(myPixmap)
        self.thumperImage.setScaledContents(True)

        #camDirection
        myPixmap = QtGui.QPixmap(_fromUtf8('../res/cam.png'))
        myPixmap = myPixmap.transformed(QtGui.QTransform().rotate(
            self.camDirectionAngle))
        self.camDirection.setPixmap(myPixmap)
        self.camDirection.setScaledContents(True)

        #logger
        self.actionSaveLog.triggered.connect(self.saveLog)
        self.actionSaveLog.setShortcut('Ctrl+S')

        #define menu actions
        self.actionExit.triggered.connect(self.exitApp)
        self.actionExit.setShortcut('Ctrl+Q')

        #device state
        #self.connectStateIndicator.connect(self.connectStateIndicator, QtCore.SIGNAL("")
        self.connectStateIndicator.setPixmap(self.device.disconState)
        self.connectStateIndicator.setScaledContents(True)
        self.actionConnect.triggered.connect(self.changeConnectionState)
        self.actionConnect.setShortcut('F5')
        self.resetTelemetry()

        #get state
        self.actionBattery.triggered.connect(self.addMarkerWithLabel)

        #init direction level (altitude direction indicator)

        #init battery state
        #self.actionBattery.setShortcut('R')

    def keyPressEvent(self, event):

        if event.key() not in self.keylist:
            self.keylist.append(event.key())
            self.processmultikeys(self.keylist)

    def keyReleaseEvent(self, event):

        if event.key() in self.keylist:
            if not event.isAutoRepeat():
                self.keylist.remove(event.key())
                self.processmultikeys(self.keylist)

    def processmultikeys(self, keyspressed):
        #TODO send eth control

        print(self.keylist)

        Key_G = QtCore.Qt.Key_G in self.keylist
        Key_J = QtCore.Qt.Key_J in self.keylist
        Key_Y = QtCore.Qt.Key_Y in self.keylist
        Key_H = QtCore.Qt.Key_H in self.keylist
        Key_Q = QtCore.Qt.Key_Q in self.keylist
        Key_E = QtCore.Qt.Key_E in self.keylist

        Key_R = QtCore.Qt.Key_R in self.keylist

        Key_W = QtCore.Qt.Key_W in self.keylist
        Key_S = QtCore.Qt.Key_S in self.keylist

        self.device.power = 0 + Key_W - Key_S

        Key_A = QtCore.Qt.Key_A in self.keylist
        Key_D = QtCore.Qt.Key_D in self.keylist

        Key_I = QtCore.Qt.Key_I in self.keylist

        self.device.direction = 0 + Key_A - Key_D

        Key_SPACE = QtCore.Qt.Key_Space in self.keylist

        if (self.device.isConnected()):
            self.device.movePD(1 + Key_W - Key_S, 1 + Key_A - Key_D)

        print("ololololololo" + str(Key_W) + "|" + str(QtCore.Qt.Key_W))

        self.cam.zdirection = 0 + Key_Q - Key_E
        self.cam.hdirection = 0 + Key_G - Key_J
        self.cam.vdirection = 0 + Key_Y - Key_H

        if (Key_I):
            self.cam.moveReset()
        else:

            if (Key_R):
                self.cam.home()
            else:
                self.cam.move()

    def closeEvent(self, event):
        # do stuff
        self.updater.stop()
        self.updater.wait()
        self.device.destroy()
        print("Goodby, World!")
        sys.exit()

    def exitApp(self):
        self.updater.stop()
        self.updater.wait()
        self.device.destroy()
        print("Goodby, World!")
        sys.exit()

    def saveLog(self):
        self.logger.save()

    def updateState(self):
        BatteryState = self.device.getBatteryState()
        self.leftBatteryState.setValue(int(BatteryState[0]))
        self.rightBatteryState.setValue(int(BatteryState[1]))
        self.obstacleLeftTop.setValue(10)
        self.obstacleRightTop.setValue(10)
        self.obstacleTop.setValue(10)
        self.obstacleBottom.setValue(10)

        #if BatteryState[0] <= 7000:
        #    self.logger.append("Low left battery level")
        #if BatteryState[1] <= 7000:
        #    self.logger.append("Low right battery level")

    def addMarkerWithLabel(self):
        doc = self.mapView.page().mainFrame().documentElement()
        #user = doc.findFirst("div[id=map_canvas]")
        #user.evaluateJavaScript("panTo(new google.maps.LatLng(51.98646, 81.90669));")

    def resetTelemetry(self):
        self.obstacleLeftTop.setValue(0)
        self.obstacleRightTop.setValue(0)
        self.obstacleTop.setValue(0)
        self.obstacleBottom.setValue(0)

    def changeConnectionState(self):
        if (self.device.isConnected()):
            self.device.disconnect()
            self.connectStateIndicator.setPixmap(self.device.disconState)
            self.actionConnect.setText("Connect")
            self.actionConnect.setShortcut('F5')
            self.device.currentState = 0
            self.resetTelemetry()

        else:
            if self.device.connect() == 0:
                self.connectStateIndicator.setPixmap(self.device.conState)
                self.actionConnect.setText("Disconnect")
                self.actionConnect.setShortcut('Ctrl+D')
                self.device.currentState = 1
Ejemplo n.º 15
0
class ControlApp(QtGui.QMainWindow, Ui_MainWindow):
    #def values
    camDirectionAngle=0
    keylist = []
    cam = None
    updater = None
    def __init__(self, argv):
        QtGui.QMainWindow.__init__(self)
        self.MainWindow=Ui_MainWindow
        self.ui=Ui_MainWindow
        self.MainWindow.__init__(self.window)
        self.setupUi(self)
        self.show()
        
        self.logger = Logger(self.logPanel)
        self.device = EthernetDevice(self.logger)
        
        self.device.disconState = QtGui.QPixmap(_fromUtf8('../res/disconnected'))
        self.device.conState = QtGui.QPixmap(_fromUtf8('../res/connected'))
        self.device.currentState = 0
        
        self.device.power=0
        self.device.direction=0
        
        self.addWidgets()
        
        self.updater = DataUpdateThread(self)    # create a thread
        self.updater.trigger.connect(self.updateState)  # connect to it's signal
        self.updater.start() 
        
        self.cam = Camera(self)
        
    def addWidgets(self):
        """ В этом методе мы добавляем виджеты и wприсоединяем обработчики сигналов.
            Обработчик сигнала для виджета так же называется "слотом"
        """
        
        #camview setup
        #path="C:\\Users\\SCB\\Downloads\\test.avi"
        
        path=QtCore.QUrl("rtsp://192.168.2.100:7070/")
        media = Phonon.MediaSource(path)
        self.videoPlayer.load(media)
        self.videoPlayer.play()
        
        #set maps properties
        url = "res.gmap.html"
        page = QtCore.QUrl("../res/gmap.html")
        self.mapView.load(page)
        
        #thumper pic
        myPixmap = QtGui.QPixmap(_fromUtf8('../res/thumper_top.jpg'))
        self.thumperImage.setPixmap(myPixmap)
        self.thumperImage.setScaledContents(True)
        
        #camDirection
        myPixmap = QtGui.QPixmap(_fromUtf8('../res/cam.png'))
        myPixmap = myPixmap.transformed(QtGui.QTransform().rotate(self.camDirectionAngle))
        self.camDirection.setPixmap(myPixmap)
        self.camDirection.setScaledContents(True)
                
        #logger 
        self.actionSaveLog.triggered.connect(self.saveLog)
        self.actionSaveLog.setShortcut('Ctrl+S')
        
        #define menu actions
        self.actionExit.triggered.connect(self.exitApp)
        self.actionExit.setShortcut('Ctrl+Q')
        
        #device state
        #self.connectStateIndicator.connect(self.connectStateIndicator, QtCore.SIGNAL("")
        self.connectStateIndicator.setPixmap(self.device.disconState)
        self.connectStateIndicator.setScaledContents(True)
        self.actionConnect.triggered.connect(self.changeConnectionState)
        self.actionConnect.setShortcut('F5')
        self.resetTelemetry()
        
        #get state
        self.actionBattery.triggered.connect(self.addMarkerWithLabel)
        
        #init direction level (altitude direction indicator)
        
        #init battery state
        #self.actionBattery.setShortcut('R')  
        
    def keyPressEvent(self, event):
        
        if event.key() not in self.keylist:
            self.keylist.append(event.key())
            self.processmultikeys(self.keylist)

    def keyReleaseEvent(self, event):
        
        if event.key() in self.keylist:
            if not event.isAutoRepeat():
                self.keylist.remove(event.key())
                self.processmultikeys(self.keylist)
    
    def processmultikeys(self, keyspressed):
        #TODO send eth control
        
        print(self.keylist)
        
        Key_G = QtCore.Qt.Key_G in self.keylist
        Key_J = QtCore.Qt.Key_J in self.keylist
        Key_Y = QtCore.Qt.Key_Y in self.keylist
        Key_H = QtCore.Qt.Key_H in self.keylist
        Key_Q = QtCore.Qt.Key_Q in self.keylist
        Key_E = QtCore.Qt.Key_E in self.keylist        
        
        Key_R = QtCore.Qt.Key_R in self.keylist
        
        
        Key_W = QtCore.Qt.Key_W in self.keylist
        Key_S = QtCore.Qt.Key_S in self.keylist
        
        self.device.power = 0 + Key_W - Key_S

        Key_A = QtCore.Qt.Key_A in self.keylist
        Key_D = QtCore.Qt.Key_D in self.keylist
         
        Key_I = QtCore.Qt.Key_I in self.keylist
         
        self.device.direction = 0 + Key_A - Key_D

        Key_SPACE = QtCore.Qt.Key_Space in self.keylist

        if(self.device.isConnected()):
            self.device.movePD(1 + Key_W - Key_S, 1 + Key_A - Key_D)
        

        print("ololololololo"+str(Key_W) +"|"+ str(QtCore.Qt.Key_W))
        
        self.cam.zdirection = 0 + Key_Q - Key_E
        self.cam.hdirection = 0 + Key_G - Key_J
        self.cam.vdirection = 0 + Key_Y - Key_H
        
        if(Key_I):
            self.cam.moveReset();
        else:
            
            if(Key_R):
                self.cam.home();
            else:
                self.cam.move();
            
            
        
        
        
    def closeEvent(self, event):
        # do stuff
        self.updater.stop()
        self.updater.wait()
        self.device.destroy()
        print("Goodby, World!")
        sys.exit()
    
    def exitApp(self):
        self.updater.stop()
        self.updater.wait()
        self.device.destroy()
        print("Goodby, World!")
        sys.exit()
 
    def saveLog(self):
        self.logger.save()

    def updateState(self):
        BatteryState = self.device.getBatteryState()
        self.leftBatteryState.setValue(int(BatteryState[0]))
        self.rightBatteryState.setValue(int(BatteryState[1]))
        self.obstacleLeftTop.setValue(10)
        self.obstacleRightTop.setValue(10)
        self.obstacleTop.setValue(10)
        self.obstacleBottom.setValue(10)            
        
        #if BatteryState[0] <= 7000:
        #    self.logger.append("Low left battery level")
        #if BatteryState[1] <= 7000:
        #    self.logger.append("Low right battery level")
        
    def addMarkerWithLabel(self):
        doc = self.mapView.page().mainFrame().documentElement()
        #user = doc.findFirst("div[id=map_canvas]")
        #user.evaluateJavaScript("panTo(new google.maps.LatLng(51.98646, 81.90669));")
        
    def resetTelemetry(self):
        self.obstacleLeftTop.setValue(0)
        self.obstacleRightTop.setValue(0)
        self.obstacleTop.setValue(0)
        self.obstacleBottom.setValue(0)
    
    def changeConnectionState(self):
        if(self.device.isConnected()):
            self.device.disconnect()
            self.connectStateIndicator.setPixmap(self.device.disconState)
            self.actionConnect.setText("Connect")
            self.actionConnect.setShortcut('F5')
            self.device.currentState = 0
            self.resetTelemetry()
            
        else:
            if self.device.connect() == 0:
                self.connectStateIndicator.setPixmap(self.device.conState)
                self.actionConnect.setText("Disconnect")
                self.actionConnect.setShortcut('Ctrl+D')
Ejemplo n.º 16
0
def detection_pipeline(log, args=None):
    """
    Detection main function
    :param log:
    :param args:
    :return:
    """
    config = Config(log)

    img_archive_dir = config.img_archive_dir
    if not os.path.exists(img_archive_dir):
        os.makedirs(img_archive_dir)

    father_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))

    '''would need a starting time for video'''
    config.st = datetime.datetime.now()
    if config.socket_enable:
        config.start_status_report_timer()
        if config.reupload_enbale:
            config.re_upload_cache()
        config.start_log_upload_timer()

    # Initialize for each camera
    if args[1] in ['use_onboard_camera', 'use_local_rtsp']:
        camera = Camera(log, args[1], local=False, cfg_path=father_dir + '/camera_info.txt')
    elif args[1] == 'use_captured_video':
        camera = Camera(log, args[1], local=True, cfg_path=father_dir + '/camera_info.txt')
    else:
        log.logger.error('Unrecognized execution mode argument {}'.format(args[1]))
        exit()

    dnn_model = DnnModel(log, config)
    for cam_id in camera.info:
        motion_roi = camera.info[cam_id]['coord']['bounding_rect']
        cov_roi, spot_roi1, spot_roi2 = camera.info[cam_id]['coord']['roi_rects']
        parking_ids = camera.info[cam_id]['parking_ids']
        transformation_matrix = camera.info[cam_id]['transformation_matrix']

        # convert to (left, top, right, bottom), may change in yaml file later.
        motion_roi = [motion_roi[0], motion_roi[1], motion_roi[0] + motion_roi[2], motion_roi[1] + motion_roi[3]]
        cov_roi = [cov_roi[0], cov_roi[1], cov_roi[0] + cov_roi[2], cov_roi[1] + cov_roi[3]]
        spot_roi1 = [spot_roi1[0], spot_roi1[1], spot_roi1[0] + spot_roi1[2], spot_roi1[1] + spot_roi1[3]]
        spot_roi2 = [spot_roi2[0], spot_roi2[1], spot_roi2[0] + spot_roi2[2], spot_roi2[1] + spot_roi2[3]]
        # trace_roi are used for backtrace
        trace_roi = [cov_roi[0] * 2 - cov_roi[2], cov_roi[1], cov_roi[0], cov_roi[3]]

        # set parameters for different cameras
        if int(cam_id) == 1:
            distance_thres = [-0.2, 0.9]
        elif int(cam_id) == 2:
            distance_thres = [-0.3, 0.9]
        elif int(cam_id) == 3:
            distance_thres = [-0.3, 0.9]
        else:
            distance_thres = [-0.3, 0.9]
        parking_spot = ParkingSpot(log, config, cov_roi, spot_roi1, spot_roi2, parking_ids, trace_roi, distance_thres,
                                   camera.info[cam_id]['initial_state'])
        logic = B_logic(log, 8)
        motion = Motion(log, motion_roi, dnn_model, parking_spot, logic, transformation_matrix)
        camera.info[cam_id]['ParkingSpot'] = motion

    if args[1] == 'use_onboard_camera' or args[1] == 'use_local_rtsp':
        camera.capture_pic_multithread()

    while config.cap_on is True:
        # camera robin-round
        for cam_id in camera.info:
            motion = camera.info[cam_id]['ParkingSpot']
            parking_draw = camera.info[cam_id]['parking_draw']
            # Read frame-by-frame
            if args[1] == 'use_onboard_camera' or args[1] == 'use_local_rtsp':
                ret, video_cur_frame, video_cur_time, video_cur_cnt = camera.get_frame_from_queue(cam_id)
            else:
                cap = camera.info[cam_id]['video_cap']
                if cap is None:
                    continue
                # Current position of the video file in seconds, indicate current time
                video_cur_time = cap.get(cv2.CAP_PROP_POS_MSEC) / 1000.0
                # Index of the frame to be decoded/captured next
                video_cur_cnt = cap.get(cv2.CAP_PROP_POS_FRAMES)
                ret, video_cur_frame = cap.read()

            if ret is False:
                log.logger.info('Video Analysis Finished!')
                config.cap_on = False
                break
            elif ret is None:
                continue

            '''run each ParkingSpot'''
            frame_info = {'cur_frame': video_cur_frame, 'cur_time': video_cur_time, 'cur_cnt': video_cur_cnt}
            if video_cur_cnt % motion.read_step == 0:
                # frame_for_display is returned for debug, need to change later
                frame_for_display = detection_flow(log, motion, dnn_model, frame_info)

                # the rest is added only for debug
                show_camera(motion, frame_for_display, parking_draw)

    camera.release_video_cap()
    config.stop_status_report_timer()
    config.ftp_upload_enable = False