class ImageViewer(QWidget):
def __init__(self, parent):
super().__init__()
self.parent = parent
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
layout = QVBoxLayout()
layout.addWidget(self.view)
self.img_width = None
self.img_height = None
self.setLayout(layout)
def load_image(self, image_arr):
self.clear()
image_path = QImage(image_arr, image_arr.shape[1], image_arr.shape[0], QImage.Format_RGB888)
pixmap = QPixmap(image_path)
self.scene.addPixmap(pixmap)
self.img_width = pixmap.width()
self.img_height = pixmap.height()
self.scale_self()
self.scene.update()
def scale_self(self):
if self.img_width is not None:
self.view.fitInView(QRectF(0, 0, self.img_width, self.img_height), Qt.KeepAspectRatio)
self.view.scale(self.img_width / self.scene.width(), self.img_height / self.scene.height())
def clear(self):
self.scene.clear()
class TestGUI(QMainWindow):
def __init__(self):
self.app = QApplication(sys.argv)
ui_file = QFile("testgui.ui")
ui_file.open(QFile.ReadOnly)
loader = QUiLoader()
self.window = loader.load(ui_file)
ui_file.close()
self.scene_gt = QGraphicsScene()
self.scene_gt.setSceneRect(-2000, -3000, 4000, 6000)
self.view_gt = QGraphicsView(self.scene_gt, self.window.scene_gt)
self.view_gt.scale(-0.1, 0.1)
self.view_gt.resize(self.window.scene_gt.geometry().width(),
self.window.scene_gt.geometry().height())
self.personPos_gt = self.scene_gt.addEllipse(
QRectF(-200, -200, 400, 400), QPen(QColor("LightGreen")),
QBrush(QColor("LightGreen")))
self.personPos_gt.setFlag(QGraphicsItem.ItemIsMovable)
self.personPos_gt.setPos(0, 0)
self.personAng_gt = self.scene_gt.addRect(QRectF(-10, 0, 20, 300),
QPen(QColor("Green")),
QBrush(QColor("Green")))
self.personAng_gt.setFlag(QGraphicsItem.ItemIsMovable)
self.personAng_gt.setPos(0, 0)
self.scene_cc = QGraphicsScene()
self.scene_cc.setSceneRect(-2000, -3000, 4000, 6000)
self.view_cc = QGraphicsView(self.scene_cc, self.window.scene_cc)
self.view_cc.scale(-0.1, 0.1)
self.view_cc.resize(self.window.scene_cc.geometry().width(),
self.window.scene_cc.geometry().height())
self.personPos_cc = self.scene_cc.addEllipse(
QRectF(-200, -200, 400, 400), QPen(QColor("Red")),
QBrush(QColor("Red")))
self.personPos_cc.setFlag(QGraphicsItem.ItemIsMovable)
self.personPos_cc.setPos(0, 0)
self.personAng_cc = self.scene_cc.addRect(QRectF(-10, 0, 20, 300),
QPen(QColor("Black")),
QBrush(QColor("Black")))
self.personAng_cc.setFlag(QGraphicsItem.ItemIsMovable)
self.personAng_cc.setPos(0, 0)
self.scene_nn = QGraphicsScene()
self.scene_nn.setSceneRect(-2000, -3000, 4000, 6000)
self.view_nn = QGraphicsView(self.scene_nn, self.window.scene_nn)
self.view_nn.scale(-0.1, 0.1)
self.view_nn.resize(self.window.scene_nn.geometry().width(),
self.window.scene_nn.geometry().height())
self.personPos_nn = self.scene_nn.addEllipse(
QRectF(-200, -200, 400, 400), QPen(QColor("LightBlue")),
QBrush(QColor("LightBlue")))
self.personPos_nn.setFlag(QGraphicsItem.ItemIsMovable)
self.personPos_nn.setPos(0, 0)
self.personAng_nn = self.scene_nn.addRect(QRectF(-10, 0, 20, 300),
QPen(QColor("Blue")),
QBrush(QColor("Blue")))
self.personAng_nn.setFlag(QGraphicsItem.ItemIsMovable)
self.personAng_nn.setPos(0, 0)
self.loadData(sys.argv[1])
self.window.instantScrollBar.valueChanged.connect(self.changeInstant)
self.it = 0
self.timer = QTimer()
self.timer.timeout.connect(self.compute)
self.timer.start(150)
self.window.show()
r = self.app.exec_()
sys.exit(r)
def loadData(self, filename):
test_dataset = graph_generator.CalibrationDataset(filename, 'run', '1')
with open(sys.argv[1], 'r') as f:
raw = f.read()
raw = list(raw)
raws = ''.join(raw)
data = json.loads(raws)['data_set']
model = trackerapi.TrackerAPI('.', test_dataset)
self.x_gt = []
self.x_cc = []
self.x_nn = []
self.z_gt = []
self.z_cc = []
self.z_nn = []
self.a_gt = []
self.a_cc = []
self.a_nn = []
try:
with open('kk', 'rb') as f:
results = pickle.load(f)
except:
results = [x for x in model.predict()]
with open('kk', 'wb') as f:
pickle.dump(results, f, pickle.HIGHEST_PROTOCOL)
eX_cc = []
eZ_cc = []
eA_cc = []
eX_nn = []
eZ_nn = []
eA_nn = []
self.trajectory = []
s = 0
ang_prev = 0
for i in range(int(len(results))):
n_joints = 0
for cam in range(len(data[i]['superbody'])):
n_joints += len(data[i]['superbody'][cam]['joints'])
if n_joints < 3:
continue
s += 1
if s < 2 or s % 1 != 0:
continue
self.x_gt.append(data[i]['superbody'][0]['ground_truth'][0])
self.z_gt.append(data[i]['superbody'][0]['ground_truth'][2])
self.a_gt.append(data[i]['superbody'][0]['ground_truth'][3] *
180. / math.pi)
self.trajectory.append(QPointF(self.x_gt[-1], self.z_gt[-1]))
x_cc = 0
z_cc = 0
ncams = 0
for cam in range(0, len(data[i]['superbody'])):
x_cc += data[i]['superbody'][cam]['world'][0]
z_cc += data[i]['superbody'][cam]['world'][2]
ncams += 1
self.x_cc.append(x_cc / ncams)
self.z_cc.append(z_cc / ncams)
s_cc = 0
c_cc = 0
ncams = 0
for cam in range(0, len(data[i]['superbody'])):
joints = data[i]['superbody'][cam]["joints"]
if ("right_shoulder" in joints and "left_shoulder"
in joints) or ("right_hip" in joints
and "left_hip" in joints):
s_cc = math.sin(data[i]['superbody'][cam]['world'][3])
c_cc = math.cos(data[i]['superbody'][cam]['world'][3])
ncams += 1
if ncams > 0:
a_cc = math.atan2(s_cc / ncams, c_cc / ncams)
ang_prev = a_cc
else:
a_cc = ang_prev
self.a_cc.append(a_cc * 180. / math.pi)
self.x_nn.append(results[i][0] * 4000)
self.z_nn.append(results[i][2] * 4000)
self.a_nn.append(
math.atan2(results[i][3] / 0.7, results[i][4] / 0.7) * 180. /
math.pi)
eX_cc.append(abs(self.x_gt[-1] - self.x_cc[-1]))
eZ_cc.append(abs(self.z_gt[-1] - self.z_cc[-1]))
eAng = 180 - abs(abs(self.a_gt[-1] - self.a_cc[-1]) - 180)
if eAng < 0:
eAng = 360 + eAng
eA_cc.append(eAng)
eX_nn.append(abs(self.x_gt[-1] - self.x_nn[-1].item()))
eZ_nn.append(abs(self.z_gt[-1] - self.z_nn[-1].item()))
eAng = 180 - abs(abs(self.a_gt[-1] - self.a_nn[-1]) - 180)
if eAng < 0:
eAng = 360 + eAng
eA_nn.append(eAng)
array_err_z = np.array(eZ_nn)
print("len array error", len(array_err_z))
# self.window.eX_cc.display(np.array(eX_cc).mean())
# self.window.eZ_cc.display(np.array(eZ_cc).mean())
# self.window.eA_cc.display(np.array(eA_cc).mean())
# self.window.eX_nn.display(np.array(eX_nn).mean())
# self.window.eZ_nn.display(np.array(eZ_nn).mean())
# self.window.eA_nn.display(np.array(eA_nn).mean())
self.scene_gt.addPolygon(self.trajectory, QPen(QColor("Black")))
self.scene_cc.addPolygon(self.trajectory, QPen(QColor("Black")))
self.scene_nn.addPolygon(self.trajectory, QPen(QColor("Black")))
self.window.instantScrollBar.setMaximum(len(self.a_gt) - 1)
def compute(self):
if self.window.playButton.isChecked():
if self.it >= len(self.x_gt):
self.it = 0
self.movePerson()
self.it += 1
self.window.instantScrollBar.setValue(self.it)
def changeInstant(self, instant):
self.it = instant
self.movePerson()
def movePerson(self):
self.personPos_gt.setPos(self.x_gt[self.it], self.z_gt[self.it])
self.personAng_gt.setPos(self.x_gt[self.it], self.z_gt[self.it])
self.personAng_gt.setRotation(self.a_gt[self.it])
self.personPos_cc.setPos(self.x_cc[self.it], self.z_cc[self.it])
self.personAng_cc.setPos(self.x_cc[self.it], self.z_cc[self.it])
self.personAng_cc.setRotation(self.a_cc[self.it])
self.personPos_nn.setPos(self.x_nn[self.it], self.z_nn[self.it])
self.personAng_nn.setPos(self.x_nn[self.it], self.z_nn[self.it])
self.personAng_nn.setRotation(self.a_nn[self.it])
class Escena(QWidget):
def __init__(self):
QWidget.__init__(self)
self.resize(QDesktopWidget().availableGeometry(self).size() * 0.6)
self.scene = QGraphicsScene()
self.scene.setSceneRect(-3000, -4000, 6000, 8000)
self.view = QGraphicsView(self.scene)
self.view.resize(self.size())
self.view.fitInView(self.scene.sceneRect(), Qt.KeepAspectRatio)
self.view.setParent(self)
self.view.setTransformationAnchor(QGraphicsView.NoAnchor)
self.view.setResizeAnchor(QGraphicsView.NoAnchor)
self.view.scale(3, -3)
self.lines = []
self.show()
def wheelEvent(self, event):
zoomInFactor = 1.15
zoomOutFactor = 1 / zoomInFactor
# Zoom
if event.delta() > 0:
zoomFactor = zoomInFactor
else:
zoomFactor = zoomOutFactor
self.view.scale(zoomFactor, zoomFactor)
def resizeEvent(self, event):
self.view.resize(self.size())
def draw(self, comps, cluster):
colors = QColor.colorNames()
# for co in sample:
# print(co)
# x, _, z, _ = co['world']
# self.scene.addEllipse(x-50,z-50,100,100, pen=QPen(QColor('orange'), 5))
# x,_,z,_ = sample[-1]['world']
# self.scene.addRect(x,z,60,60, pen=QPen(QColor('red'), 100))
# x,_,z,_ = sample[0]['world']
# self.scene.addRect(x,z,60,60, pen=QPen(QColor('green'), 100))
# for co in comps:
# if sample[co[-1]]['timestamp']-sample[co[0]]['timestamp'] > 200 and len(co)> 4:
# color = colors[random.randint(0, len(colors)-1)]
# for c in co:
# x, _, z, _ = sample[c]['world']
# self.scene.addEllipse(x-15,z-15,30,30, pen=QPen(QColor(color), 100), brush=QBrush(color=QColor(color)))
if cluster[-1]['timestamp'] - cluster[0]['timestamp'] > 200 and len(
cluster) > 4:
color = colors[random.randint(0, len(colors) - 1)]
for sample in cluster:
x, _, z, _ = sample['world']
self.scene.addEllipse(x - 15,
z - 15,
30,
30,
pen=QPen(QColor(color), 100),
brush=QBrush(color=QColor(color)))
def drawTrack(self, clusters):
colors = QColor.colorNames()
# for line in self.lines:
# self.scene.removeItem(line)
self.scene.clear()
for cluster in clusters:
color = colors[random.randint(0, len(colors) - 1)]
for t in cluster:
self.scene.addLine(t[0][0],
t[0][1],
t[1][0],
t[1][1],
pen=QPen(QColor(color), 60))
class Window(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("Network Designer")
self.setGeometry(300, 200, 840, 720)
self.current_id = 1
self.createLayout()
self.couple = []
self.show()
def makeButtonsLayout(self):
self.button = QPushButton("Add Node", self)
self.button.clicked.connect(self.addNode)
self.btn_connection = QPushButton("Add Connection:", self)
self.btn_connection.clicked.connect(self.addConnection)
self.button3 = QPushButton("Export Network", self)
self.button3.clicked.connect(self.file_save)
self.lbl_connection = QLabel("Connection")
self.l_btns = QHBoxLayout()
self.l_btns.addWidget(self.button3)
self.l_btns.addStretch()
self.l_btns.addWidget(self.btn_connection)
self.l_btns.addWidget(self.lbl_connection)
self.l_btns.addStretch()
self.l_btns.addWidget(self.button)
self.btns = QWidget()
self.btns.setLayout(self.l_btns)
self.btns.setFixedHeight(40)
def initializeGview(self):
self.scene = GraphicsScene()
self.scene.setSceneRect(0, 0, 480, 480)
self.scene.click.connect(self.keepNode)
self.addNode()
self.view = QGraphicsView(self.scene)
self.view.setGeometry(0, 0, 500, 500)
self.view.scale(1, 1)
def createOrderList(self):
self.orderList = QListWidget()
# Enable drag & drop ordering of items.
self.orderList.setDragDropMode(QAbstractItemView.InternalMove)
def createLayout(self):
self.makeButtonsLayout()
self.initializeGview()
self.createOrderList()
l_network = QHBoxLayout()
l_network.addWidget(self.view)
l_network.addStretch()
l_network.addWidget(self.orderList)
self.l_root = QVBoxLayout()
self.l_root.addLayout(l_network)
self.l_root.addStretch()
self.l_root.addWidget(self.btns)
# self.l_root.addWidget(self.view)
self.setLayout(self.l_root)
def addNode(self):
greenBrush = QBrush(Qt.green)
blackPen = QPen(Qt.black)
# blueBrush = QBrush(Qt.blue)
blackPen.setWidth(5)
ellipse = GraphicsEllipse(str(self.current_id), blackPen, greenBrush, 100, 100, NODE_D, NODE_D)
self.scene.addItem(ellipse)
self.current_id += 1
def keepNode(self, node):
if len(self.couple) < 2:
self.couple.append(node)
else:
self.couple.pop(0)
self.couple.append(node)
if len(self.couple) == 2:
self.lbl_connection.setText(self.couple[0].label + " --> " + self.couple[1].label)
def addConnection(self):
line = GraphicsLine(self.couple[0], self.couple[1], NODE_R)
self.scene.addItem(line)
for v in self.couple:
v.add_connection(line)
self.orderList.addItem(self.lbl_connection.text())
def getNodes(self):
positions = {}
for i in self.scene.items():
if type(i) is GraphicsEllipse:
positions[int(i.label)] = i.getPosition()
return positions
def getConnections(self):
connections = []
for i in range(self.orderList.count()):
conn = self.orderList.item(i).text().split(" --> ")
connections.append((int(conn[0]), int(conn[1]), {"label": str(i + 1)}))
return connections
def file_save(self):
positions = self.getNodes()
connections = self.getConnections()
network = {}
network["labels"] = {i: i for i in sorted(list(positions.keys()))}
network["edges"] = connections
network["pos"] = positions
text = json.dumps(network)
name = QFileDialog.getSaveFileName(self, 'Save File')
file = open(name[0], 'w')
# text = "something"
file.write(text)
file.close()
class TMSTester(QMainWindow):
def __init__(self, width, height):
super(TMSTester, self).__init__(None)
self.setStyleSheet("background: transparent")
self.canvasSize = QRectF(QPointF(0, 0), QPointF(width, height))
self.view = QGraphicsView()
self.view.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.view.setDragMode(QGraphicsView.ScrollHandDrag)
self.scene = QGraphicsScene(0, 0, width, height, self.view)
self.view.setScene(self.scene)
self.centreCoordinate = QPointF(-32.2138204, 115.0387413)
self.zoom = 3
self.mapLayer = TMSLayer('CRUSE:World_Bathymetric_Heightmap',
self.canvasSize, self.centreCoordinate, 3)
self.mapLayerHandle = self.scene.addWidget(self.mapLayer)
self.setCentralWidget(self.view)
self.mapLayer.setFocus()
def mouseMoveEvent(self, event):
tcX = self.mapLayer.requiredTiles['left']
tcY = self.mapLayer.requiredTiles['top']
offsetX = self.mapLayer.canvasSize.width() / 2 - (
self.mapLayer.centrePoint.x() - tcX) * TILE_DIMENSION
offsetY = self.mapLayer.canvasSize.height() / 2 + (
self.mapLayer.centrePoint.y() - (tcY + 1)) * TILE_DIMENSION
xTile = tcX + ((event.pos().x() - offsetX) / 256)
yTile = (tcY + 1) - ((event.pos().y() - offsetY) / 256)
self.mapLayer.centreCoordinate = self.mapLayer.tileToGeographic(
xTile, yTile, self.mapLayer.tileZoomIndex)
print('{}'.format(self.mapLayer.centreCoordinate))
def mousePressEvent(self, event):
tcX = self.mapLayer.requiredTiles['left']
tcY = self.mapLayer.requiredTiles['top']
offsetX = self.mapLayer.canvasSize.width() / 2 - (
self.mapLayer.centrePoint.x() - tcX) * TILE_DIMENSION
offsetY = self.mapLayer.canvasSize.height() / 2 + (
self.mapLayer.centrePoint.y() - (tcY + 1)) * TILE_DIMENSION
xTile = tcX + ((event.pos().x() - offsetX) / 256)
yTile = (tcY + 1) - ((event.pos().y() - offsetY) / 256)
centreCoordinate = self.mapLayer.tileToGeographic(
xTile, yTile, self.mapLayer.tileZoomIndex)
self.mapLayer.updateCentre(centreCoordinate)
def wheelEvent(self, event):
'''
Only used for zooming.
'''
self.view.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.view.viewport().installEventFilter(self)
if event.delta() > 0:
self.zoom *= 1 + (event.delta() / 120) * 0.1
scale = 1 + (self.zoom % self.mapLayer.tileZoomIndex)
else:
self.zoom *= (1 + (event.delta() / 120) * 0.1)
scale = 1 / (1 + (self.zoom % self.mapLayer.tileZoomIndex))
rasterZoom = self.mapLayer.tileZoomIndex + 2**(
floor(log(self.zoom, 2)) + 0) - 1
if scale <= 2:
self.view.scale(scale, scale)
else:
self.view.scale(1 / scale, 1 / scale)
self.mapLayer.updateZoom(rasterZoom)
print('zoom:{} scale:{} raster:{}'.format(self.zoom, scale,
rasterZoom))
def eventFilter(self, qobject, event):
if (event.type() == QEvent.Wheel):
return True
else:
return False
def keyPressEvent(self, event):
if event.key() == Qt.Key_Left:
self.centreCoordinate = QPointF(
self.mapLayer.centreCoordinate.x(),
self.mapLayer.centreCoordinate.y() -
self.mapLayer.tileZoomIndex)
self.mapLayer.updateCentre(self.centreCoordinate)
if event.key() == Qt.Key_Right:
self.centreCoordinate = QPointF(
self.mapLayer.centreCoordinate.x(),
self.mapLayer.centreCoordinate.y() +
self.mapLayer.tileZoomIndex)
self.mapLayer.updateCentre(self.centreCoordinate)
if event.key() == Qt.Key_Up:
self.centreCoordinate = QPointF(
self.mapLayer.centreCoordinate.x() +
self.mapLayer.tileZoomIndex,
self.mapLayer.centreCoordinate.y())
self.mapLayer.updateCentre(self.centreCoordinate)
if event.key() == Qt.Key_Down:
self.centreCoordinate = QPointF(
self.mapLayer.centreCoordinate.x() -
self.mapLayer.tileZoomIndex,
self.mapLayer.centreCoordinate.y())
self.mapLayer.updateCentre(self.centreCoordinate)
if event.key() == Qt.Key_Z:
self.zoom *= 1.3
self.mapLayer.updateZoom(self.zoom)
if event.key() == Qt.Key_X:
self.zoom /= 1.3
self.mapLayer.updateZoom(self.zoom)
if event.key() == Qt.Key_P:
self.centreCoordinate = QPointF(-32.2138204, 115.0387413)
self.mapLayer.updateCentre(self.centreCoordinate)
if event.key() == Qt.Key_A:
self.centreCoordinate = QPointF(-35.09138204, 138.07387413)
self.mapLayer.updateCentre(self.centreCoordinate)
if event.key() == Qt.Key_M:
self.centreCoordinate = QPointF(0, 0)
self.mapLayer.updateCentre(self.centreCoordinate)
self.mapLayer.updateCanvasSize(self.canvasSize)
