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_()
