class WsnViewer(QtGui.QMainWindow, Ui_WsnViewerUI):
def __init__(self, parent=None):
super(WsnViewer, self).__init__(parent)
self.setupUi (self)
self.m_nodeNumber = 10
self.m_maxRfRange = 70
self.m_macAddr = MacAddress ()
self.m_nodeLoc = Coordonate ()
self.m_nodeList = self.m_macAddr.GetListAddr(10)
self.m_edgeList = 0
self.m_edgeDict = {}
self.m_nodeLocDict = {}
self.m_scene = QGraphicsScene (self.graphicsView)
#self.m_paramWin = Ui_paramWindow ()
self.m_graph = nx.Graph()
self.m_data = list ()
self.DataReader = Data ()
self.graphicsView.setDragMode (self.graphicsView.RubberBandDrag)
self.graphicsView.setRenderHints (QPainter.Antialiasing | QPainter.SmoothPixmapTransform)
self.graphicsView.setScene (self.m_scene)
self.ConnectActions ()
def ConnectActions(self):
self.actionQuit.triggered.connect (QtGui.qApp.quit)
self.actionOpen.triggered.connect (self.OpenWsnTopology)
self.actionRandom_topology.triggered.connect (self.GenerateRandWsn)
self.actionTools.triggered.connect(self.SetRadioRange)
self.actionSave.triggered.connect(self.Save)
def OpenWsnTopology (self):
fileName = QtGui.QFileDialog.getOpenFileName(
self,
"Ouvrir un fichier des positions des noeuds",
QtCore.QDir.homePath(),
"Fichiers texte (*.txt)"
)
if (fileName):
self.m_data = self.DataReader.ReadFile(fileName)
def GenerateRandWsn (self):
self.m_nodeList = self.m_macAddr.GetListAddr(self.m_nodeNumber)
#print(self.m_nodeList)
self.m_edgeList, self.m_nodeLocDict = self.m_nodeLoc.EdgeCreate (self.m_nodeList)
#print(self.m_nodeLocDict)
#print(self.m_edgeList)
self.m_scene.clear()
self.DrawGraph ()
def main (self):
self.show()
def OpenDialog(self):
self.dlg = OpenFileDialog ()
self.dlg.show()
def DrawGraph (self):
for edge in self.m_edgeList:
self.m_edgeDict [edge] = EdgeItem (self.m_nodeLocDict, edge[0], edge[1])
self.m_scene.addItem(self.m_edgeDict [edge])
for node in self.m_nodeLocDict.iterkeys():
nodeItem = NodeItem (self.m_scene, self.m_nodeLocDict, node)
#nodeItem.m_signalLinkNode.nodeItemSignal.connect (self.UpdateNodeLocDict)
self.m_scene.addItem (nodeItem)
def Save (self):
filename = QtGui.QFileDialog.getSaveFileName (
self,
"Ouvrir un fichier des positions des noeuds",
QtCore.QDir.homePath(),
"Fichiers texte (*.txt)"
)
if self.m_edgeList and filename:
self.DataReader.WriteWSn(self.m_edgeList, self.m_nodeLocDict, filename)
def UpdateNodeLocDict (self, nodeName, nodePos):
self.m_nodeLocDict [nodeName] = nodePos
for node, pos in self.m_nodeLocDict.items():
if node != nodeName:
edge = (nodeName, node)
if self.Distance(nodePos, pos) <= self.m_maxRfRange:
if not edge in self.m_edgeList and not edge[::-1] in self.m_edgeList:
self.m_edgeList.append (edge)
self.m_edgeDict [edge] = EdgeItem (self.m_nodeLocDict, edge[0], edge[1])
self.m_scene.addItem(self.m_edgeDict [edge])
#print ("%s %s %s" % (node, pos[0], pos[1]))
else:
self.RemoveLink (edge)
self.UpdateNodeList (edge)
#print ("%s %s %s" % (node, pos[0], pos[1]))
def UpdateNodeList (self, edge):
while edge in self.m_edgeList:
self.m_edgeList.remove (edge)
#while edge[::-1] in self.m_edgeList:
# self.m_edgeList.remove (edge[::-1])
def RemoveLink (self, edge):
if edge in self.m_edgeDict:
self.m_scene.removeItem (self.m_edgeDict [edge])
del self.m_edgeDict [edge]
self.m_scene.update()
print ("%s %s" % (edge[0], edge[1]))
def UpdateScene (self, edge):
self.m_scene.addItem(EdgeItem (self.m_nodeLocDict, edge[0], edge[1]))
def Distance (self, u, v):
x0, y0 = u
x1, y1 = v
return math.sqrt((x0 - x1)**2 + (y0 - y1)**2)
def SetRadioRange (self):
self.rfWindow = RfSettingWindow ()
resultat = self.rfWindow.exec_()
if resultat:
self.rfWindow.SetRadioValues ()
self.m_nodeNumber = self.rfWindow.GetNodeNumber ()
self.m_maxRfRange = self.rfWindow.GetRfRange ()
self.GenerateRandWsn ()
class FlowChartView(QWidget):
"""
Flowchart view
"""
def __init__(self, parent):
"""
Constructs FlowChartView widget
@param parent:
@type parent:
"""
QWidget.__init__(self, parent)
self.steps = []
self.timestamps = []
self.arrows = []
self.createWidget()
def createWidget(self):
"""
Create the widget
"""
self.diagramScene = QGraphicsScene(self)
self.view = QGraphicsView(self.diagramScene)
self.view.setRenderHint(QPainter.Antialiasing)
# set the main layout
layout = QVBoxLayout()
self.logEdit = QTextEdit()
self.logEdit.setReadOnly(True)
hSplitter2 = QSplitter(self)
hSplitter2.setOrientation(Qt.Vertical)
hSplitter2.addWidget(self.view)
hSplitter2.addWidget(self.logEdit)
hSplitter2.setStretchFactor(0, 1)
layout.addWidget(hSplitter2)
self.setLayout(layout)
def reset(self):
"""
Clear all
"""
#self.diagramScene.clear()
for stp in self.steps:
self.diagramScene.removeItem(stp)
for stp in self.arrows:
self.diagramScene.removeItem(stp)
for stamp in self.timestamps:
self.diagramScene.removeItem(stamp)
self.diagramScene.clear()
self.diagramScene.update()
self.view.resetCachedContent()
self.steps = []
self.arrows = []
self.timestamps = []
self.logEdit.setText("")
def addStep(self,
text,
color="#A5A2A5",
width=400,
height=40,
data=None,
textBold=False,
textItalic=False,
timestamp="00:00:00"):
"""
Add step
"""
# take the last one
if len(self.steps):
latestBlock = self.steps[-1:][0]
else:
latestBlock = None
newBlock = BlockItem(self,
text,
blockColor=color,
width=width,
height=height,
data=data,
bold=textBold,
italic=textItalic)
if width == 100:
newBlock.setPos(400 / 2 - 100 / 2, len(self.steps) * 80)
elif width == 300:
newBlock.setPos(400 / 2 - 300 / 2, len(self.steps) * 80)
else:
newBlock.setPos(0, len(self.steps) * 80)
self.steps.append(newBlock)
self.diagramScene.addItem(newBlock)
newTimestampBlock = TimestampItem(self, timestamp)
newTimestampBlock.setPos(-200, len(self.timestamps) * 80)
self.timestamps.append(newTimestampBlock)
self.diagramScene.addItem(newTimestampBlock)
if latestBlock is not None:
newArrow = LineItem(latestBlock, newBlock)
self.diagramScene.addItem(newArrow)
self.arrows.append(newArrow)
if QtHelper.str2bool(Settings.instance().readValue(
key='TestRun/auto-scrolling-graph')):
self.view.centerOn(newBlock)
return newBlock
class Canvas(QGraphicsView):
def __init__(self, window, resultDict, imagePath):
QGraphicsView.__init__(self)
self.window = window
self.pen = QPen(QColor("red"))
self.pen.setWidth(0.5)
self.canvasScene = QGraphicsScene()
self.setScene(self.canvasScene)
self.resultDict = resultDict
self.imagePath = imagePath
self.setBackgroundBrush(QBrush(Qt.black, Qt.SolidPattern))
def drawImage(self, imageFile):
"""Draw an image on the canvas"""
image = QPixmap(imageFile)
self.canvasScene.addPixmap(image)
return image
def drawFeaturePoint(self, pointList):
"""Draw a feature point on the canvas"""
radius = 0.5
width, height = 2, 2
x1, y1, x2, y2 = pointList
#Draw ellipse and bounding rect. Is a hacked version!
self.canvasScene.addEllipse(x1 - radius + 5, y1 - radius + 3, 2 * radius, 2 * radius, self.pen)
self.canvasScene.addEllipse(x2 - radius + self.imageWidth + 10, y2 - radius + 3, 2 * radius, 2 * radius, self.pen)
self.canvasScene.addRect(x1 - width / 2. + 5, y1 - height / 2. + 3, width, height, self.pen)
self.canvasScene.addRect(x2 - width / 2. + self.imageWidth + 10, y2 - height / 2. + 3, width, height, self.pen)
def drawFeatureImages(self, imageFile):
"""Draw two consecutive images on the screen"""
#Load image files
path, file_ = os.path.split(imageFile)
image1 = QPixmap(os.path.join(path, 'first_' + file_))
image2 = QPixmap(os.path.join(path, 'second_' + file_))
self.imageWidth = image1.width()
#Add pixmaps
image1Map = self.canvasScene.addPixmap(image1)
image2Map = self.canvasScene.addPixmap(image2)
#Shift pixmaps to the right position
image1Map.setOffset(QPointF(5, 3))
image2Map.setOffset(QPointF(10 + image1.width(), 3))
def drawPolygon(self, Polygon):
"""Draw a polygon on the canvas"""
polygon = QPolygonF()
for point in Polygon:
polygon.append(QPointF(point[0], point[1]))
self.canvasScene.addPolygon(polygon, self.pen)
def getWorkerId(self):
return self.resultDict.values()[self.index][0][0]
def getAssignmentId(self):
return self.resultDict.keys()[self.index]
def nextImage(self):
"""Load next image"""
self.index += 1
self.canvasScene.clear()
if self.index > len(self.resultDict) - 1 or len(self.resultDict) <= 0:
self.canvasScene.addText("No annotations to review")
self.window.reviewFlag = False
self.window.updateTable()
else:
#Draw Image and Polygon
assignmentId = self.resultDict.keys()[self.index]
result = self.resultDict[assignmentId]
image = result[0][1]
pointList = result[0][2]
if self.window.segmentation_mode:
pointList = [round(float(point), 3) for point in pointList]
pointList = zip(*[iter(pointList)] * 2)
self.drawImage(os.path.join(self.imagePath, image))
self.drawPolygon(pointList)
else:
pointList = [round(float(point), 3) for point in pointList]
pointList = zip(*[iter(pointList)] * 4)
self.drawFeatureImages(os.path.join(self.imagePath, image))
for point in pointList:
self.drawFeaturePoint(point)
#update scene
self.window.setWindowTitle("MTurk Review Tool ({0}/{1}) Rejected: {2} Approved: {3}".format(self.index + 1,
len(self.resultDict), len(self.window.rejected), len(self.window.approved)))
self.canvasScene.setSceneRect(self.canvasScene.itemsBoundingRect())
self.fitInView(0, 0, self.canvasScene.width(), self.canvasScene.height(), 1)
self.canvasScene.update(0, 0, self.canvasScene.width(), self.canvasScene.height())
