def __init__(self, config=None, guiloader=None): ''' Constructor ''' self._gui = GuiLoader() # check for config if type(config) == mrConfigParser: self.__visionConfig = config self.__visionHostName = self.__visionConfig.getConfigValue("PROTOCOl", "visionHostname") self.__visionCalibImg = self.__visionConfig.getConfigValue("GENERAL", "calibrationImg") self.__moduleName = self.__visionConfig.getConfigValue("GENERAL", "moduleName") self.__connectionTimeout = self.__visionConfig.getConfigValueFloat("NETWORK", "timeout") else: mrLogger.log( "No configuration specified", mrLogger.LOG_LEVEL['info'] ) # load network interface self.__initNetworkInterface() # start image processing start_new_thread( self.__processImage, () ) # start gui if guiloader != None: self._gui = guiloader self._imageGrabber = ImageGrabber(self._gui, self.__visionConfig) self.__distortion = Distortion(self._gui, self._imageGrabber, self.__visionConfig) self.__transformation = Transformation(self._gui, self._imageGrabber, self.__visionConfig) self.__recognition = Recognition(self._gui, self._imageGrabber, self.__visionConfig) self.__initGui()
def __init__(self, gui=None, config=None): ''' Constructor ''' self._gui = GuiLoader() self._config = config if gui != None: self._gui = gui self.__initGui()
class visionModule(object): ''' classdocs ''' _config = mrConfigParser() _gui = GuiLoader() _imageGrabber = ImageGrabber() _img = None _imgCounter = 0 def __init__(self, gui=None, imageGrabber=None, config=None): ''' Constructor ''' self._img = None self._imgCounter = 0 self._gui = gui self._config = config self._imageGrabber = imageGrabber def setImg(self, img=None): ''' Sets current image ''' if img != None: self._img = img self._imgCounter += 1 def _showImage(self): ''' Shows image ''' pass def _updateScene(self, gview, scene, img, convert=False, keepRatio=True): ''' Updates scene ''' img = copy(img) if img != None and scene != None and gview != None: # convert image to rgb if convert: img = cvtColor(img, COLOR_GRAY2RGB) # clear scene and add image pixmap scene.clear() scene.addPixmap(imageToPixmap(img)) # fit image into scene if keepRatio: gview.fitInView(scene.sceneRect(), Qt.KeepAspectRatio) else: gview.fitInView(scene.sceneRect()) # show scene gview.show()
class ImageGrabber(object): ''' classdocs ''' _config = mrConfigParser() _gui = GuiLoader() _img = None __sources = [] __grabTimer = QTimer() __scene = None __gview = None def __init__(self, gui=None, config=None): ''' Constructor ''' self._gui = GuiLoader() self._config = config if gui != None: self._gui = gui self.__initGui() def __initGui(self): ''' Initiates gui listeners ''' # initiate scene self.__gview = self._gui.getObj("imgVideo") self.__scene = QGraphicsScene() self.__gview.setScene(self.__scene) # add image size combobox items cmb = self._gui.getObj("cmbImgSize") cmb.addItem("320x240") cmb.addItem("640x480") cmb.addItem("800x600") cmb.addItem("1024x768") #cmb.addItem("1280x960") # not working with libdc1394 and avt stringray 125c # add conversion combobox items cmb = self._gui.getObj("cmbConversion") cmb.addItem("None") cmb.addItem("COLOR_BGR2RGB") cmb.addItem("COLOR_GRAY2RGB") cmb.addItem("COLOR_YUV2RGB") cmb.addItem("COLOR_HLS2RGB") # add listeners self._gui.connect("cmdStartVideo", "clicked()", self.startVideo) self._gui.connect("cmdStopVideo", "clicked()", self.stopVideo) self._gui.connect("cmdAddSource", "clicked()", self.__addCamSource) self._gui.connect("cmdAddFile", "clicked()", self.__addFileSource) self._gui.connect("cmdDelSource", "clicked()", self.__removeSourceFromList) self._gui.connect("cmbImgSize", "currentIndexChanged(QString)", self.__imageSizeChanged) self._gui.connect("cmdSaveImg", "clicked()", self.saveImg) def isActive(self): ''' @return: True if image grabbing is active ''' return self.__grabTimer.isActive() def startVideo(self): ''' Starts grabbing images ''' if self.__grabTimer.isActive(): self.__grabTimer.stop() self.__grabTimer = QTimer() self.__grabTimer.timeout.connect(self.__grabImage) self.__grabTimer.start(0) self._gui.status("Video started") def stopVideo(self): ''' Stops grabbing video ''' if self.__grabTimer.isActive(): self.__grabTimer.stop() self.__scene.clear() self.__gview.show() self._gui.status("Video stopped") sleep(1) def getImage(self): ''' Returns the last grabbed image @return: Image ''' return self._img def saveImg(self): ''' Saves image ''' if self._img != None: img = self._img # stop video active = self.isActive() self.stopVideo() # open file dialog options = copy(self._gui.dialogOptionsDef) options['type'] = self._gui.dialogTypes['FileSave'] options['filetypes'] = "JPG (*.jpg)" options['title'] = "Save current frame as" src = str(self._gui.dialog(options)) # check filepath and save if len(src) > 0: if not src.endswith(".jpg"): src = src + ".jpg" self._gui.status("write to " + src) cvtColor(img, COLOR_BGR2RGB) imwrite(src, img) # reset video streaming if active: self.startVideo() def __showImage(self): ''' Shows image on graphics view ''' if self._img != None: self.__scene.clear() self.__scene.addPixmap(imageToPixmap(self._img)) self.__gview.fitInView(self.__scene.sceneRect(), Qt.KeepAspectRatio) self.__gview.show() def __grabImage(self): ''' Graps image from sources ''' images = [] # grab all images for src in self.__sources: assert isinstance(src, AbstractSourceGrabber) images.append(src.getImg()) # join and convert images img = self.__joinImages(images) # convert image convert = eval(str(self._gui.getObj("cmbConversion").currentText())) if convert != None: try: img = cvtColor(img, convert) except: img = None # show results if type(img) == ndarray: # add image as new image self._img = img self.__showImage() else: # show message self.__scene.clear() self.__scene.addText("NO VIDEO") def __joinImages(self, images=[]): ''' Joins images ''' # TO-DO: Joining images if len(images) > 0: return images[0] return False def __imageSizeChanged(self, size="640x480"): ''' Changes image size ''' size = str(size).split("x") w = int(size[0]) h = int(size[1]) # set size for cam in self.__sources: if type(cam) == CamGrabber: assert isinstance(cam, CamGrabber) cam.setImgSize(w, h) def __addSourceToList(self, grabber=None): ''' Adds source to source list ''' assert isinstance(grabber, AbstractSourceGrabber) if grabber != None: # add grabber to list self.__sources.append(grabber) txt = None # get type of grabber if type(grabber) == CamGrabber: txt = "cam [" + str(grabber.getSource()) + "]" elif type(grabber) == FileGrabber: txt = "file [" + str(grabber.getSource()) + "]" # add text string to gui list if txt != None: self._gui.getObj("lstSources").addItem(txt) def __removeSourceFromList(self): ''' Removes selected source from list ''' for item in self._gui.getObj("lstSources").selectedItems(): # get item informationen txt = str(item.text()) if "[" in txt and "]" in txt: data = txt.split("[") iType = data[0].strip() iSource = data[1].replace(']', '') # search for grabber for grabber in self.__sources: assert isinstance(grabber, AbstractSourceGrabber) if str(grabber.getSource()) == iSource: if type(grabber) == CamGrabber and iType == "cam": self.__sources.remove(grabber) break elif type(grabber) == FileGrabber and iType == "file": self.__sources.remove(grabber) break # remove source from gui list item = self._gui.getObj("lstSources").takeItem( self._gui.getObj("lstSources").currentRow()) item = None def __addCamSource(self): ''' Adds camera as source ''' obj = self._gui.getObj("txtSource") source = int(obj.text()) grabber = CamGrabber(source) if grabber.isOpened(): self.__addSourceToList(grabber) self._gui.status("Added camera source [" + str(source) + "]") else: self._gui.status( "Could not add camera source [" + str(source) + "]", self._gui.msgTypes['ERROR']) def __addFileSource(self): ''' Adds file as source ''' self.stopVideo() options = copy(self._gui.dialogOptionsDef) options['filetypes'] = "Images (*.jpg *jpeg *gif *png *bmp *tif)" source = str(self._gui.dialog(options)) if len(source) > 0: grabber = FileGrabber(source) self.__addSourceToList(grabber) self._gui.status("Added file source [" + str(source) + "]")
class mrVisionModule(object): ''' classdocs ''' __visionConfig = mrConfigParser() __visionHostName = "vision" __visionCalibImg = "img/calibration.jpg" _gui = GuiLoader() __serverName = None __serverNameAck = False _imageGrabber = ImageGrabber() __distortion = Distortion() __transformation = Transformation() __recognition = Recognition() __socketManager = None __mode = mrVisionData.VISION_MODE_NONE __connectionTimeout = 30.0 __moduleName = None def __init__(self, config=None, guiloader=None): ''' Constructor ''' self._gui = GuiLoader() # check for config if type(config) == mrConfigParser: self.__visionConfig = config self.__visionHostName = self.__visionConfig.getConfigValue("PROTOCOl", "visionHostname") self.__visionCalibImg = self.__visionConfig.getConfigValue("GENERAL", "calibrationImg") self.__moduleName = self.__visionConfig.getConfigValue("GENERAL", "moduleName") self.__connectionTimeout = self.__visionConfig.getConfigValueFloat("NETWORK", "timeout") else: mrLogger.log( "No configuration specified", mrLogger.LOG_LEVEL['info'] ) # load network interface self.__initNetworkInterface() # start image processing start_new_thread( self.__processImage, () ) # start gui if guiloader != None: self._gui = guiloader self._imageGrabber = ImageGrabber(self._gui, self.__visionConfig) self.__distortion = Distortion(self._gui, self._imageGrabber, self.__visionConfig) self.__transformation = Transformation(self._gui, self._imageGrabber, self.__visionConfig) self.__recognition = Recognition(self._gui, self._imageGrabber, self.__visionConfig) self.__initGui() def __initGui(self): ''' Initiates gui ''' self._gui.connect( "cmdCoriander", "clicked()", self.__startCoriander ) def __initNetworkInterface(self): ''' Initiates network interface ''' host = self.__visionConfig.getConfigValue("NETWORK", "serverIP") port = self.__visionConfig.getConfigValueInt("NETWORK", "serverPort") self.__socketManager = mrSocketManager(host=host, port=port, server=True, udpOn=True, useHandshake=True, name=str(self.__moduleName)) self.__socketManager.addOnDataRecievedListener( self.__dataRecieved ) self.__socketManager.addOnClientAddedListener( self.__clientAdded ) mrLogger.log( "Vision module trying to connect to gameserver", mrLogger.LOG_LEVEL['info'] ) # wait for connection t1 = time() while (time()-t1) < self.__connectionTimeout and not self.__socketManager.isConnected(): pass if self.__socketManager.isConnected(): mrLogger.log( "Vision module started", mrLogger.LOG_LEVEL['info'] ) else: msg = "Vision module could not establish connection to server at " + str(host) msg += " on port " + str(port) mrLogger.log( msg, mrLogger.LOG_LEVEL['error'] ) return False return True def __startCoriander(self): ''' Starts external program coriander ''' self._imageGrabber.stopVideo() start_new_thread(call, ("coriander",)) def __clientAdded(self, servername, clientdata): ''' Client added listener ''' msg = "Client " + servername + " " + str(clientdata) msg += " added" mrLogger.log( msg, mrLogger.LOG_LEVEL['info'] ) def __dataRecieved(self, socket, addr, data): ''' Data recieved listener ''' try: print "recieved:", data dom = CreateFromDocument(data) print "type:", type(dom) if type(dom) == changeVisionMode: assert isinstance(dom, changeVisionMode) self.__mode = str(dom.visionmode) mode = changeVisionMode() mode.visionmode = self.__mode self.__socketManager.sendData( mode.toxml("utf-8", element_name="changevisionmode") ) self._gui.status( "Vision mode set to " + str(self.__mode) ) mrLogger.logDebug( "Vision mode set to: " + str(self.__mode) ) except: pass def __sendVisionData(self, visionObjects={'bots': [], 'rectangles': []}): ''' Sends list of recognized objects @param visionObjects: Twoi dimensional list with visionObjects['bots'] as list of bots visionObjects['rectangles'] as list of objects ''' if self.__socketManager.isConnected() and len(visionObjects) == 2: # create data package data = positionDataPackage() data.visionmode = self.__mode # add bots to datapackage if self.__mode == VISION_MODE_STREAM_BOTS or self.__mode in VISION_MODE_STREAM_ALL: for bot in visionObjects['bots']: b = positionObjectBot() b.id = bot['id'] print "-----------------" print "bot:", bot bot['center'] = ( 1-bot['center'][0], bot['center'][1] ) b.location.append( bot['center'][0] ) b.location.append( bot['center'][1] ) b.angle = bot['angle'] data.append(b) print "botsend:", bot # add rectangles to datapackage if self.__mode == VISION_MODE_STREAM_OBJ or self.__mode in VISION_MODE_STREAM_ALL: for obj in visionObjects['rectangles']: print obj # send datapackage self.__socketManager.sendData( data.toxml("utf-8", element_name="positiondatapackage") ) def __setMode(self, mode=mrVisionData.VISION_MODE_NONE): ''' Sets vision mode @param mode: mrVisionData mode ''' self.__mode = mode def __processImage(self): ''' processes image recognision ''' mrLogger.logInfo( "Main loop started in mode " + str(self.__mode) ) while self.__mode != mrVisionData.VISION_MODE_TERMINATE: #print "mode:", self.__mode # get image img = self._imageGrabber.getImage() # sets image to distortion module self.__distortion.setImg(img) # undistort and crop image if self.__distortion.isCalibrated(): img = self.__distortion.undistortImage(img) img = self.__distortion.cropImage(img) # sets image to transformation and recognition module self.__transformation.setImg(img) self.__recognition.setImg(img) # STREAM IMAGES if self.__mode in mrVisionData.VISION_STREAMING_MODES: if self._imageGrabber.isActive(): # recognize objects self.__recognition.recognize() # get bots and rectangles try: obj = {'bots': self.__recognition.getBots(), 'rectangles': self.__recognition.getRectangles()} except: pass # transformate objects self.__transformation.transformObjects( obj['bots'] ) # send vision objects self.__sendVisionData(obj) # CALIBRATE CHESSBOARD elif self.__mode == mrVisionData.VISION_MODE_CALIBRATE_DIST: if not self.__distortion.isCalibrating(): self.__distortion.calibrateCamera() while self.__distortion.isCalibrating(): pass self.__setMode(mrVisionData.VISION_MODE_NONE) # CALIBRATE TRANSFORMATIONEN elif self.__mode == mrVisionData.VISION_MODE_CALIBRATE_TRANSF: # To-DO: calibration of transformation if not self.__transformation.isCalibrating(): self.__transformation.startCalibration() while self.__transformation.isCalibrating(): pass self.__setMode(mrVisionData.VISION_MODE_NONE) # sleep(0.01) # exit program mrLogger.logInfo( "Main loop stopped" ) self.__socketManager.stopSocket()
if __name__ == '__main__': ''' set current working path ''' path = os.path.dirname(sys.argv[0]) if not path: path = str(os.getcwd()) sys.argv[0] = path + "/" + str(sys.argv[0]) os.chdir(path) # read config config = mrConfigParser("../config.ini") logLevel = config.getConfigValue("GENERAL", "logLevel") mrLogger.logClear() try: mrLogger.LOGGER_LOG_LEVEL = mrLogger.LOG_LEVEL[logLevel] except: pass # create gui app app = QtGui.QApplication(sys.argv) guiloader = GuiLoader(True) guiloader.show() # create vision module visionModule = mrVisionModule( config, guiloader ) # show gui app.exec_()