Пример #1
0
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))
Пример #2
0
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)