Beispiel #1
0
	def startCamera(self):
		print "cam start.."
		self.stop = False
		if self.camera != None:
			self.camera.kill = False
		self.camera = CameraThread(self.url[0], self.url[1])
		self.camera.start()
Beispiel #2
0
 def __init__(self, parent=None):
     super(CameraTab, self).__init__(parent)
     
     self.indicatorBuffer = []
     self.maxIndicator = 0
     
     self.cameraThreadObject = CameraThread()
     self.cameraThread = QtCore.QThread()
     self.cameraThreadObject.moveToThread(self.cameraThread)
     self.cameraThread.started.connect(self.cameraThreadObject.setup)
     
     self.setupGUI()
     
     self.settingsShowCapture.stateChanged.connect(self.settingsCaptureRadioMarked.setEnabled)
     self.settingsShowCapture.stateChanged.connect(self.settingsCaptureRadioUnfiltered.setEnabled)
     self.settingsShowCapture.stateChanged.connect(self.settingsCaptureRadioMask.setEnabled)
     self.settingsGainSelection.sigValueChanged.connect(self._settingsGainChanged)
     self.settingsExposureSelection.sigValueChanged.connect(self._settingsExposureChanged)
     self.settingsCaptureRadioUnfiltered.clicked.connect(self._settingsCaptureChanged)
     self.settingsCaptureRadioMarked.clicked.connect(self._settingsCaptureChanged)
     self.settingsCaptureRadioMask.clicked.connect(self._settingsCaptureChanged)
     
     self.settingsStartStopBtn.clicked.connect(self.connectButtonClicked)
     self.radioCOMRefreshButton.clicked.connect(self._refreshCOMPorts)
     self.radioConnectButton.clicked.connect(self._connectRadio)
     self.radioTestButton.clicked.connect(self._performRadioTest)
     self.radioSendUpdates.stateChanged.connect(lambda state:
         self.sendCommand.emit("radio on" if state else "radio off"))
     def clearIndicatorBuffer():
         self.indicatorBuffer = []
         self.maxIndicator = 0
         self.telemetryRadioDelayIndicator.setText("?")
     self.telemetryRadioIndicatorReset.clicked.connect(clearIndicatorBuffer)
     
     self.cameraThreadObject.frameCaptured.connect(self._updateCameraFrame)
     self.cameraThreadObject.message.connect(self.settingsStatusLabel.setText)
     self.cameraThreadObject.connected.connect(self._cameraConnected)
     self.cameraThreadObject.disconnected.connect(self._cameraDisconected)
     self.cameraThreadObject.fpsUpdated.connect(lambda x: self.settingsFPSCurrent.setText("%.1f" % (x)))
     self.cameraThreadObject.telemetry.connect(self._telemetryFromCamera)
     
     self.cameraThread.start()
Beispiel #3
0
def main():
    logging.basicConfig(
        level=logging.INFO,
        format="%(asctime)s [%(threadName)-12.12s] [%(levelname)-5.5s]  %(message)s",
        handlers=[
            logging.StreamHandler()
        ]
    )

    lst = queue.LifoQueue(5)
    # Video source can be anything compatible with cv2.VideoCapture.open()
    # in DEMO videofeed is provided by a RPI 3B and videoStreamer.py
    camTh = CameraThread("http://192.168.12.131:8000/stream.mjpg", lst)
    camTh.start()

    cvTh = CvThread(lst, (0, 0, 0, 0), (180, 255, 35, 0), True)
    cvTh.start()

    while True:
        # Who dies first kills the other
        if not camTh.isAlive():
            cvTh._evt.set()

        if not cvTh.isAlive():
            camTh._evt.set()

        # If everyone is dead, quit mainThread
        if not cvTh.isAlive() and not camTh.isAlive():
            break
        time.sleep(0.1)  # Save a bit of CPU
    logging.debug("quit")
	def __init__(self, thread_id, thread_name):
		# display title
		self.print_text("[ barcode detection ]")
		
		# get parameters
		self.thread_id = thread_id
		self.thread_name = thread_name
		
		# calculate morphological kernel
		self.kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (20, 5))
		
		# create thread
		self.camera_thread = CameraThread(1, "camera_thread", self)
Beispiel #5
0
class testsprite(pygame.sprite.Sprite):
	def __init__(self, pos, url):
		pygame.sprite.Sprite.__init__(self)
		self.x, self.y = pos
		self.url = url
		self.camera = None #CameraThread(url[0], url[1])
		self.stop = False
		#self.camera.start()
		self.image = pygame.image.load("lol.jpg")
		self.rect = self.image.get_rect()
		self.scale = 1
		
	def stopCamera(self):
		print "cam stop.."
		self.stop = True
		self.camera.kill = True
		self.camera.join()
		self.image = pygame.image.load("lol.jpg")
	
	def startCamera(self):
		print "cam start.."
		self.stop = False
		if self.camera != None:
			self.camera.kill = False
		self.camera = CameraThread(self.url[0], self.url[1])
		self.camera.start()
	
	def setScale(self, scale):
		self.scale = scale

	def update(self):
		if self.camera != None:
			pic = self.camera.pic
			if pic is not None:
				self.image = pygame.transform.scale(pygame.image.frombuffer(pic.tostring(), pic.size, 'RGB'), (160 * self.scale, 120 * self.scale))

				self.rect = self.image.get_rect()
		self.rect.topleft = (self.x, self.y)
Beispiel #6
0
class CameraTab(QtGui.QWidget):
    sendCommand = QtCore.pyqtSignal(str)
    debugCameraMessageRegex = re.compile(r"^Radio: ((-?\d+\.\d+ ){3})Pred: ((-?\d+\.\d+ ){3})Odo: ((-?\d+\.\d+ ){3})Filt: ((-?\d+\.\d+ ){3})Time: (\d+)$")
    
    def __init__(self, parent=None):
        super(CameraTab, self).__init__(parent)
        
        self.indicatorBuffer = []
        self.maxIndicator = 0
        
        self.cameraThreadObject = CameraThread()
        self.cameraThread = QtCore.QThread()
        self.cameraThreadObject.moveToThread(self.cameraThread)
        self.cameraThread.started.connect(self.cameraThreadObject.setup)
        
        self.setupGUI()
        
        self.settingsShowCapture.stateChanged.connect(self.settingsCaptureRadioMarked.setEnabled)
        self.settingsShowCapture.stateChanged.connect(self.settingsCaptureRadioUnfiltered.setEnabled)
        self.settingsShowCapture.stateChanged.connect(self.settingsCaptureRadioMask.setEnabled)
        self.settingsGainSelection.sigValueChanged.connect(self._settingsGainChanged)
        self.settingsExposureSelection.sigValueChanged.connect(self._settingsExposureChanged)
        self.settingsCaptureRadioUnfiltered.clicked.connect(self._settingsCaptureChanged)
        self.settingsCaptureRadioMarked.clicked.connect(self._settingsCaptureChanged)
        self.settingsCaptureRadioMask.clicked.connect(self._settingsCaptureChanged)
        
        self.settingsStartStopBtn.clicked.connect(self.connectButtonClicked)
        self.radioCOMRefreshButton.clicked.connect(self._refreshCOMPorts)
        self.radioConnectButton.clicked.connect(self._connectRadio)
        self.radioTestButton.clicked.connect(self._performRadioTest)
        self.radioSendUpdates.stateChanged.connect(lambda state:
            self.sendCommand.emit("radio on" if state else "radio off"))
        def clearIndicatorBuffer():
            self.indicatorBuffer = []
            self.maxIndicator = 0
            self.telemetryRadioDelayIndicator.setText("?")
        self.telemetryRadioIndicatorReset.clicked.connect(clearIndicatorBuffer)
        
        self.cameraThreadObject.frameCaptured.connect(self._updateCameraFrame)
        self.cameraThreadObject.message.connect(self.settingsStatusLabel.setText)
        self.cameraThreadObject.connected.connect(self._cameraConnected)
        self.cameraThreadObject.disconnected.connect(self._cameraDisconected)
        self.cameraThreadObject.fpsUpdated.connect(lambda x: self.settingsFPSCurrent.setText("%.1f" % (x)))
        self.cameraThreadObject.telemetry.connect(self._telemetryFromCamera)
        
        self.cameraThread.start()
        
    def __del__(self):
        self.cameraThread.quit()
        self.cameraThread.wait()
        
        if self.radioThread:
            self.radioThread.quit()
            self.radioThread.wait()
        
    @QtCore.pyqtSlot()
    def _connectRadio(self):
        if self._tryDisconnectRadio():
            return

        com = str(self.radioCOMSelect.currentText())
        br = str(self.radioBaudrateEdit.text())
       
        try:
            self.radioThreadObject = COMSSClient(com, br)
        except Exception as e:
            Logger.getInstance().error("Cannot establish radio connection: " + str(e))
        else:
            self.radioThread = myThread.makeThread(self.radioThreadObject)
            self.radioThreadObject.arrived.connect(lambda x: self._radioMessageArrived(x.payload))
            myThread.startThread(self.radioThreadObject)
            self.radioStatusLabel.show()
            Logger.getInstance().log("Radio connection established on " + com + " @" + br)
            self.radioConnectButton.setText("Disconnect")

    def _tryDisconnectRadio(self):
        if self._radioIsConnected():
            self.radioThread.quit()
            self.radioThread.wait()
            del self.radioThread
            del self.radioThreadObject
            self.radioConnectButton.setText("Connect")
            self.radioTestLabel.setText("Not tested")
            self.radioStatusLabel.hide()
            self.radioSendUpdates.setChecked(False)
            Logger.getInstance().log("Radio connection closed")
            return True
        return False            
            
    def _radioIsConnected(self):
        return self.radioConnectButton.text() == "Disconnect"        
        
    @QtCore.pyqtSlot(str)
    def _radioMessageArrived(self, msg):
        if msg == "I am alive!":
            self._radioTestTxPassed()
        else:
            Logger.getInstance().debug(msg)        
        
    @QtCore.pyqtSlot()
    def _refreshCOMPorts(self):
        current = self.radioCOMSelect.currentText()
        self.radioCOMSelect.clear()
        self.radioCOMSelect.addItems(list(COMMngr().getAllPorts()))
        self.radioCOMSelect.setCurrentIndex(self.radioCOMSelect.findText(current))        
        
    @QtCore.pyqtSlot()
    def connectButtonClicked(self):
        self._tryStartCamera() or self._tryStopCamera()        
        
    def _tryStartCamera(self):
        if not self._cameraIsConnected():
            fps = float(self.settingsFPSSelection.value())
            options = {'gain': self.settingsGainSelection.value(), 
                'exposure': self.settingsExposureSelection.value(),
                'returnImage': 'marked' if self.settingsCaptureRadioMarked.isChecked() else 'unfiltered'}
            QtCore.QMetaObject.invokeMethod(self.cameraThreadObject, 'connect', Qt.QueuedConnection, 
                QtCore.Q_ARG(float, fps), QtCore.Q_ARG(dict, options))
            Logger.getInstance().info("Trying to start camera at %.2f fps" % (fps))
            return True
        return False
       
    def _tryStopCamera(self):
        if self._cameraIsConnected():
            QtCore.QMetaObject.invokeMethod(self.cameraThreadObject, 'disconnect', Qt.QueuedConnection)
            Logger.getInstance().info("Trying to stop camera")
            return True
        return False
          
    def _cameraIsConnected(self):
        return self.settingsStartStopBtn.text() == "Stop"          
           
    def _sendToRadio(self, str):
        try:
            self.radioThreadObject._outgoing.put("<"+str+">")
        except (NameError, AttributeError):
            return False
        return True
           
    @QtCore.pyqtSlot(tuple)
    def _telemetryFromCamera(self, telemetry):
        if self.radioSendUpdates.isChecked():
            data = struct.pack('<3f', *telemetry)
            self._sendToRadio("U"+data)
            
        self.telemetryX.setText("%.2f" % (telemetry[0]))
        self.telemetryY.setText("%.2f" % (telemetry[1]))
        self.telemetryODeg.setText("%.2f" % (telemetry[2]*180.0/math.pi))
        self.telemetryORad.setText("%.2f" % (telemetry[2]))
        Logger.getInstance().debug("X: %.5f Y: %.5f O: %.7f rad" % telemetry)
      
    @QtCore.pyqtSlot()
    def _cameraConnected(self):
        self.settingsStartStopBtn.setText("Stop")
        Logger.getInstance().info("Camera started")
        
    @QtCore.pyqtSlot()
    def _cameraDisconected(self):
        self.telemetryX.setText("?")
        self.telemetryY.setText("?")
        self.telemetryODeg.setText("?")
        self.telemetryORad.setText("?")
        self.settingsFPSCurrent.setText("?")
        self.settingsStartStopBtn.setText("Start")
        Logger.getInstance().info("Camera stopped")
           
    @QtCore.pyqtSlot(QtGui.QImage)
    def _updateCameraFrame(self, image):
        if self.settingsShowCapture.isChecked():
            pixmap = QtGui.QPixmap.fromImage(image)
            scaledPixMap = pixmap.scaled(self.frameLabel.size(), Qt.KeepAspectRatio)
            self.frameLabel.setPixmap(scaledPixMap)
       
    @QtCore.pyqtSlot()
    def _settingsGainChanged(self):
        if self._cameraIsConnected():
            QtCore.QMetaObject.invokeMethod(self.cameraThreadObject, 'setParam', Qt.QueuedConnection, 
                QtCore.Q_ARG(dict, {'gain': self.settingsGainSelection.value()} ))
            Logger.getInstance().info("Changing gain of working camera")
        
    @QtCore.pyqtSlot()
    def _settingsExposureChanged(self):    
        if self._cameraIsConnected():
            QtCore.QMetaObject.invokeMethod(self.cameraThreadObject, 'setParam', Qt.QueuedConnection, 
                QtCore.Q_ARG(dict, {'exposure': self.settingsExposureSelection.value()} ))
            Logger.getInstance().info("Changing exposure of working camera")
       
    @QtCore.pyqtSlot()
    def _settingsCaptureChanged(self):
        if self._cameraIsConnected():
            if self.settingsCaptureRadioMarked.isChecked():
                option = 'marked'
            elif self.settingsCaptureRadioMask.isChecked():
                option = 'mask'
            else:
                option = 'unfiltered'
            QtCore.QMetaObject.invokeMethod(self.cameraThreadObject, 'setParam', Qt.QueuedConnection, 
                QtCore.Q_ARG(dict, {'returnImage': option} ))
            Logger.getInstance().info("Changing return image type of working camera to " + option)
    
    @QtCore.pyqtSlot()
    def _performRadioTest(self):
        self.radioTestLabel.setText("Not tested")
        self.sendCommand.emit("radio test")
        self._sendToRadio("?")
        
    def _radioTestTxPassed(self):
        current = self.radioTestLabel.text()
        if current == "Not tested":
            self.radioTestLabel.setText("Tx OK")
        elif current == "Rx OK":
            self.radioTestLabel.setText("Tx/Rx OK")
            
    @QtCore.pyqtSlot()
    def radioTestRxPassed(self):
        current = self.radioTestLabel.text()
        if current == "Not tested":
            self.radioTestLabel.setText("Rx OK")
        elif current == "Tx OK":
            self.radioTestLabel.setText("Tx/Rx OK")
    
    @QtCore.pyqtSlot(str)
    def radioDebugCommHandler(self, data):
        matches = self.debugCameraMessageRegex.match(str(data))

        if matches:
            radio = matches.group(1)
            pred = matches.group(3)
            odo = matches.group(5)
            filt = matches.group(7)
            time = int(matches.group(9))
            
            predspl = [float(s) for s in pred.split()]
            odospl = [float(s) for s in odo.split()]
            diff = [predspl[i] - odospl[i] for i in range(3)]
            indicator = (diff[0]**2 + diff[1]**2)**0.5
            print indicator
            self.indicatorBuffer.append(indicator)
            if len(self.indicatorBuffer) > 30:
                self.indicatorBuffer.pop(0)
                
            mean = sum(self.indicatorBuffer)/float(len(self.indicatorBuffer))
            if mean > self.maxIndicator:
                self.maxIndicator = mean
                
            self.telemetryRadioDelayIndicator.setText("%.4g mm" % (self.maxIndicator))
    
    def resetDefault(self):
        self._tryStopCamera()
        self._tryDisconnectRadio()
        self.telemetryRadioDelayIndicator.setText("?")

    def setupGUI(self):
        # main layout
        layout = QtGui.QHBoxLayout()
        layout.setMargin(10)
        self.setLayout(layout)
        leftSideWdgt = QtGui.QWidget()
        leftSideWdgt.setSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Expanding)
        leftSideWdgt.setFixedWidth(250);
        self.frameLabel = QtGui.QLabel();
        layout.addWidget(leftSideWdgt)
        layout.addWidget(self.frameLabel)
        
        # left layout
        leftLayout = QtGui.QVBoxLayout()
        layout.setMargin(0)
        leftSideWdgt.setLayout(leftLayout)
        
        # settings
        self.settingsStartStopBtn = QtGui.QPushButton("Start")
        self.settingsFPSSelection = pg.SpinBox(bounds=[1,188], int=True, dec=False, minStep=1, step=10, suffix="fps")
        self.settingsFPSSelection.setValue(10)
        self.settingsFPSCurrent = QtGui.QLineEdit()
        self.settingsFPSCurrent.setReadOnly(True)
        self.settingsFPSCurrent.setText("?")
        self.settingsShowCapture = QtGui.QCheckBox("Show capture")
        self.settingsStatusLabel = QtGui.QLabel("Disconnected")
        self.settingsGainSelection = pg.SpinBox(bounds=[0,79], int=True, dec=False, minStep=1, step=5)
        self.settingsGainSelection.setValue(30)
        self.settingsExposureSelection = pg.SpinBox(bounds=[0,511], int=True, dec=False, minStep=1, step=10)
        self.settingsExposureSelection.setValue(400)
        self.settingsCaptureRadioUnfiltered = QtGui.QRadioButton("Unfiltered")
        self.settingsCaptureRadioUnfiltered.setDisabled(True)
        self.settingsCaptureRadioMask = QtGui.QRadioButton("Mask")
        self.settingsCaptureRadioMask.setDisabled(True)
        self.settingsCaptureRadioMarked = QtGui.QRadioButton("Marked")
        self.settingsCaptureRadioMarked.setDisabled(True)
        self.settingsCaptureRadioMarked.setChecked(True)
        
        settingsBox = QtGui.QGroupBox("Settings")
        settingsLayout = QtGui.QGridLayout()
        settingsLayout.setSpacing(3)
        settingsLayout.setMargin(5)
        settingsLayout.addWidget(self.settingsStartStopBtn, 0, 0, 1, 1)
        settingsLayout.addWidget(self.settingsFPSSelection, 0, 1, 1, 1)
        settingsLayout.addWidget(QtGui.QLabel("Current FPS"), 1, 0, 1, 1)
        settingsLayout.addWidget(self.settingsFPSCurrent, 1, 1, 1, 1)
        settingsLayout.addWidget(QtGui.QLabel("Gain"), 2, 0, 1, 1)
        settingsLayout.addWidget(self.settingsGainSelection, 2, 1, 1, 1)
        settingsLayout.addWidget(QtGui.QLabel("Exposure"), 3, 0, 1, 1)
        settingsLayout.addWidget(self.settingsExposureSelection, 3, 1, 1, 1)
        settingsLayout.addWidget(self.settingsShowCapture, 4, 0, 1, 1)
        settingsLayout.addWidget(self.settingsCaptureRadioUnfiltered, 4, 1, 1, 1)
        settingsLayout.addWidget(self.settingsCaptureRadioMask, 5, 1, 1, 1)
        settingsLayout.addWidget(self.settingsCaptureRadioMarked, 6, 1, 1, 1)
        settingsLayout.addWidget(self.settingsStatusLabel, 7, 0, 1, 2)
        settingsBox.setLayout(settingsLayout)
        leftLayout.addWidget(settingsBox)
        
        # radio
        self.radioCOMSelect = QtGui.QComboBox()
        self.radioCOMSelect.addItems(list(COMMngr().getAllPorts()))
        self.radioBaudrateEdit = QtGui.QLineEdit("115200")
        self.radioBaudrateEdit.setValidator(QtGui.QIntValidator(0, 10000000))
        self.radioConnectButton = QtGui.QPushButton("Connect")
        self.radioStatusLabel = QtGui.QLabel("Connected")
        self.radioStatusLabel.hide()
        self.radioCOMRefreshButton = QtGui.QPushButton("R")
        self.radioCOMRefreshButton.setMaximumWidth(25)
        self.radioSendUpdates = QtGui.QCheckBox("Enable radio transmission")
        self.radioTestLabel = QtGui.QLabel("Not tested")
        self.radioTestButton = QtGui.QPushButton("Test")
        
        radioBox = QtGui.QGroupBox("Radio transmitter")
        radioLayout = QtGui.QGridLayout()
        radioLayout.setSpacing(3)
        radioLayout.setMargin(5)
        radioLayout.addWidget(QtGui.QLabel("COM Port"), 0, 0, 1, 1)
        radioLayout.addWidget(QtGui.QLabel("Baudrate"), 0, 2, 1, 1)
        radioLayout.addWidget(self.radioCOMSelect, 1, 0, 1, 1)
        radioLayout.addWidget(self.radioCOMRefreshButton, 1, 1, 1, 1)
        radioLayout.addWidget(self.radioBaudrateEdit, 1, 2, 1, 1)
        radioLayout.addWidget(self.radioStatusLabel, 2, 0, 1, 2)
        radioLayout.addWidget(self.radioConnectButton, 2, 2, 1, 1)
        radioLayout.addWidget(self.radioTestLabel, 3, 0, 1, 2)
        radioLayout.addWidget(self.radioTestButton, 3, 2, 1, 1)
        radioLayout.addWidget(self.radioSendUpdates, 4, 0, 1, 3)
        radioLayout.setColumnStretch(0, 1)
        radioLayout.setColumnStretch(1, 1)
        radioLayout.setColumnStretch(2, 1)
        radioBox.setLayout(radioLayout)
        leftLayout.addWidget(radioBox)
        
        # telemetry
        self.telemetryX = QtGui.QLineEdit("?")
        self.telemetryY = QtGui.QLineEdit("?")
        self.telemetryORad = QtGui.QLineEdit("?")
        self.telemetryODeg = QtGui.QLineEdit("?")
        self.telemetryX.setReadOnly(True)
        self.telemetryY.setReadOnly(True)
        self.telemetryORad.setReadOnly(True)
        self.telemetryODeg.setReadOnly(True)
        self.telemetryRadioDelayIndicator = QtGui.QLineEdit("?")
        self.telemetryRadioDelayIndicator.setReadOnly(True)
        self.telemetryRadioIndicatorReset = QtGui.QPushButton("X")
        self.telemetryRadioIndicatorReset.setFixedWidth(25)
        
        telemetryBox = QtGui.QGroupBox("Telemetry")
        telemetryLayout = QtGui.QGridLayout()
        telemetryLayout.setSpacing(3)
        telemetryLayout.setMargin(5)
        telemetryLayout.addWidget(QtGui.QLabel("X"), 0, 0, 1, 1)
        telemetryLayout.addWidget(self.telemetryX, 0, 1, 1, 3)
        telemetryLayout.addWidget(QtGui.QLabel("[mm]"), 0, 4, 1, 1)
        telemetryLayout.addWidget(QtGui.QLabel("Y"), 1, 0, 1, 1)
        telemetryLayout.addWidget(self.telemetryY, 1, 1, 1, 3)
        telemetryLayout.addWidget(QtGui.QLabel("[mm]"), 1, 4, 1, 1)
        telemetryLayout.addWidget(QtGui.QLabel("O"), 2, 0, 1, 1)
        telemetryLayout.addWidget(self.telemetryODeg, 2, 1, 1, 1)
        telemetryLayout.addWidget(QtGui.QLabel("[deg]"), 2, 2, 1, 1)
        telemetryLayout.addWidget(self.telemetryORad, 2, 3, 1, 1)
        telemetryLayout.addWidget(QtGui.QLabel("[rad]"), 2, 4, 1, 1)
        telemetryLayout.addWidget(QtGui.QLabel("Delay indicator"), 3, 0, 1, 2)
        telemetryLayout.addWidget(self.telemetryRadioDelayIndicator, 3, 2, 1, 2)
        telemetryLayout.addWidget(self.telemetryRadioIndicatorReset, 3, 4, 1, 1)
        telemetryBox.setLayout(telemetryLayout)
        leftLayout.addWidget(telemetryBox)
        
        # end
        leftLayout.addStretch()
Beispiel #7
0
from CameraThread import CameraThread

threads = []
urllist = open("knowngood", "r")

for url in urllist:
	url = url[7:]
	ip = url[:url.find('/')]
	path = url[url.find('/'):] 
	print ip, path 

	c = CameraThread(ip.strip(), path.strip())
	threads.append(c)
	c.start()

while len(threads) > 0:
	try:
		threads = [t.join(1) for t in threads if t is not None and t.isAlive()]
	except KeyboardInterrupt:
	        print "Ctrl-c received! Sending kill to %i threads... " % len(threads)
		for t in threads:
			t.kill = True
		print "..done"
print "done!"
class MainThread():

	def __init__(self, thread_id, thread_name):
		# display title
		self.print_text("[ barcode detection ]")
		
		# get parameters
		self.thread_id = thread_id
		self.thread_name = thread_name
		
		# calculate morphological kernel
		self.kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (20, 5))
		
		# create thread
		self.camera_thread = CameraThread(1, "camera_thread", self)

	# start thread
	def start(self):
		self.print_text("starting thread: id (%d), name (%s)" %
			(self.thread_id, self.thread_name))
		self.camera_thread.start()

	# stop thread
	def stop(self):
		self.print_text("stopping thread: id (%d), name (%s)" %
			(self.thread_id, self.thread_name))
		cv2.destroyAllWindows()
		sys.exit()

	# display text on terminal
	def print_text(self, text):
		print text

	# detect barcode in image
	def _detect_barcode(self, img):
		# convert image to grayscale
		gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

		# calculate Sobel X gradient
		grad_x = cv2.Sobel(
			gray_img, ddepth=cv2.CV_32F, dx=1, dy=0, ksize=-1)
		grad_img = cv2.convertScaleAbs(grad_x)

		# remove noise by blurring and extract barcode by thresholding
		blur_img = cv2.blur(grad_img, (9,9))
		(_, thresh_img) = cv2.threshold(
			blur_img, 225, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)

		# enhance barcode region by morphology
		morph_img = cv2.morphologyEx(
			thresh_img, cv2.MORPH_CLOSE, self.kernel, iterations=1)
		morph_img = cv2.erode(morph_img, None, iterations=8)

		# find largest contour and calculate bounding box
		(_, contours, _) = cv2.findContours(morph_img.copy(), 
			cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
		if len(contours) > 0:
			cnt = sorted(
				contours, key=cv2.contourArea, reverse=True)[0]
			rect = cv2.minAreaRect(cnt)
			bbox = np.int0(cv2.boxPoints(rect))
			return rect, bbox
		else:
			return None

	''' WORK IN PROGRESS
	def _scan_barcode(self, img, rect):
		if rect is None:
			return None
		gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

		(x, y) = np.int0(rect[0])
		(w, h) = np.int0(rect[1])
		angle = rect[2]
		if angle < -45.0:
			angle += 90.0
			w, h = h, w
		M = cv2.getRotationMatrix2D((x,y), angle, 1.0)
		rot_img = cv2.warpAffine(img, M, gray_img.shape)
		barcode_img = cv2.getRectSubPix(rot_img, (w,h), (x,y))
		return barcode_img
	'''

	def process(self, frame):
		# mirror the camera frame
		frame = cv2.flip(frame, 1)

		# detect barcode in image
		rect, bbox = self._detect_barcode(frame)

		# draw barcode bounding box on frame
		bbox_img = frame.copy()
		if bbox is not None: 
			cv2.drawContours(bbox_img, [bbox], -1, (0,255,0), 2)

		''' WORK IN PROGRESS		
		barcode_img = self._scan_barcode(frame, rect)
		bg_img = np.zeros(frame.shape, dtype=frame.dtype)
		if barcode_img is not None:
			(w, h, _) = barcode_img.shape
			bg_img[:w, :h, :] = barcode_img

		result_img = np.hstack([bbox_img, bg_img])
		result_img = cv2.resize(result_img, dsize=(0,0), fx=0.5, fy=0.5)
		'''

		# display result
		cv2.imshow("result", bbox_img)
Beispiel #9
0
import threading
import time
import sys

from CameraThread import CameraThread
from FaceDetection import FaceDetection
from IOThread import IOThread

max_frames = int(sys.argv[1])

# mulithreading stuff
shared1 = []
shared2 = []
lock1 = threading.Lock()
lock2 = threading.Lock()

threads = [
    CameraThread(max_frames, lock1, shared1),
    FaceDetection(max_frames, lock1, lock2, shared1, shared2),
    IOThread(max_frames, lock2, shared2)
]

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()