def mouseDoubleClickEvent(self, event):
"""
Mouse double click event
:type event: QMouseEvent
:param event:
:return:
"""
if GetImageHeight() == 0:
return
if not vut.IsPointOnScreen(event.x(), event.y(), self.surface):
return
if GetGCPGeoTransform() is not None and self._interaction.lineDrawer:
self.drawLines.append([None, None, None])
return
if GetGCPGeoTransform(
) is not None and self._interaction.measureDistance:
self.drawMeasureDistance.append([None, None, None])
self.parent.actionMeasureDistance.toggle()
return
if GetGCPGeoTransform() is not None and self._interaction.measureArea:
self.drawMeasureArea.append([None, None, None])
self.parent.actionMeasureArea.toggle()
return
if GetGCPGeoTransform(
) is not None and self._interaction.polygonDrawer:
ok = AddDrawPolygonOnMap(self.poly_coordinates)
# Prevent invalid geometry (Polygon with 2 points)
if not ok:
return
self.drawPolygon.append([None, None, None])
# Empty RubberBand
for _ in range(self.poly_Canvas_RubberBand.numberOfVertices()):
self.poly_Canvas_RubberBand.removeLastPoint()
# Empty List
self.poly_coordinates = []
return
self.UpdateSurface()
scr = QApplication.desktop().screenNumber(self)
self.setGeometry(QApplication.desktop().screenGeometry(scr))
self.setFullScreen(not self.isFullScreen())
event.accept()
def GetTransf(event, surface):
"""Return video coordinates to map coordinates
@type event: QMouseEvent
@param event:
@type surface: QAbstractVideoSurface
@param surface: Abstract video surface
@return:
"""
gt = GetGCPGeoTransform()
# return gt([(event.x() - VideoUtils.GetXBlackZone(surface)) *
# VideoUtils.GetXRatio(surface), (event.y() -
# VideoUtils.GetYBlackZone(surface)) * VideoUtils.GetYRatio(surface)])
imagepoint = [
(event.x() - VideoUtils.GetXBlackZone(surface)) *
VideoUtils.GetXRatio(surface),
(event.y() - VideoUtils.GetYBlackZone(surface)) *
VideoUtils.GetYRatio(surface),
1,
]
worldpoint = np.array(np.dot(gt, imagepoint))
scalar = worldpoint[2]
xworld = worldpoint[0] / scalar
yworld = worldpoint[1] / scalar
return xworld, yworld
def GetTransf(event, surface):
''' Return video coordinates to map coordinates '''
gt = GetGCPGeoTransform()
return gt([(event.x() - VideoUtils.GetXBlackZone(surface)) *
VideoUtils.GetXRatio(surface),
(event.y() - VideoUtils.GetYBlackZone(surface)) *
VideoUtils.GetYRatio(surface)])
def GetTransf(event, surface):
'''Return video coordinates to map coordinates
@type event: QMouseEvent
@param event:
@type surface: QAbstractVideoSurface
@param surface: Abstract video surface
@return:
'''
gt = GetGCPGeoTransform()
return gt([(event.x() - VideoUtils.GetXBlackZone(surface)) * VideoUtils.GetXRatio(surface), (event.y() - VideoUtils.GetYBlackZone(surface)) * VideoUtils.GetYRatio(surface)])
def GetInverseMatrix(x, y, gt, surface):
""" inverse matrix transformation (lon-lat to video units x,y) """
gt = GetGCPGeoTransform()
imagepoint = np.array(np.dot(np.linalg.inv(gt), [x, y, 1]))
scalar = imagepoint[2]
ximage = imagepoint[0] / scalar
yimage = imagepoint[1] / scalar
scr_x = (ximage / VideoUtils.GetXRatio(surface)
) + VideoUtils.GetXBlackZone(surface)
scr_y = (yimage / VideoUtils.GetYRatio(surface)
) + VideoUtils.GetYBlackZone(surface)
return scr_x, scr_y
def paintEvent(self, event):
''' Paint Event '''
self.gt = GetGCPGeoTransform()
self.painter = QPainter(self)
self.painter.setRenderHint(QPainter.HighQualityAntialiasing)
if (self.surface.isActive()):
videoRect = self.surface.videoRect()
if not videoRect.contains(event.rect()):
region = event.region()
region.subtracted(QRegion(videoRect))
brush = self.palette().window()
for rect in region.rects():
self.painter.fillRect(rect, brush)
try:
self.painter = self.surface.paint(self.painter)
except Exception:
None
else:
self.painter.fillRect(event.rect(), self.palette().window())
try:
SetImageSize(self.surface.currentFrame.width(),
self.surface.currentFrame.height())
except Exception:
None
# Draw On Video
draw.drawOnVideo(self.drawPtPos, self.drawLines, self.drawPolygon,
self.drawRuler, self.drawCesure, self.painter,
self.surface, self.gt)
# Magnifier Glass
if self.zoomed and self._interaction.magnifier:
draw.drawMagnifierOnVideo(self.width(), self.height(),
self.maskPixmap, self.dragPos,
self.zoomPixmap, self.surface,
self.painter, self.offset)
self.painter.end()
return
def paintEvent(self, event):
"""
@type event: QPaintEvent
@param event:
@return:
"""
if not self.surface.isActive():
return
self.painter = QPainter(self)
self.painter.setRenderHint(QPainter.HighQualityAntialiasing)
region = event.region()
self.painter.fillRect(region.boundingRect(), self.brush) # Background painter color
try:
self.surface.paint(self.painter)
SetImageSize(self.currentFrame().width(),
self.currentFrame().height())
except Exception:
None
# Prevent draw on video if not started or finished
if self.parent.player.position() == 0:
self.painter.end()
return
self.gt = GetGCPGeoTransform()
# Draw On Video
draw.drawOnVideo(self.drawPtPos, self.drawLines, self.drawPolygon,
self.drawMeasureDistance, self.drawMeasureArea, self.drawCesure, self.painter, self.surface, self.gt)
# Draw On Video Object tracking test
if self._interaction.objectTracking and self._isinit:
frame = convertQImageToMat(self.currentFrame())
offset = self.surface.videoRect()
# Update tracker
result = resize(frame, (offset.width(), offset.height()))
ok, bbox = self.tracker.update(result)
# Draw bounding box
if ok:
# check negative values
x = bbox[0] + offset.x()
y = bbox[1] + offset.y()
if vut.IsPointOnScreen(x, y, self.surface):
self.painter.setPen(self.blue_Pen)
self.painter.drawRect(x, y, bbox[2], bbox[3])
# Get Track object center
xc = x + (bbox[2] / 2)
yc = y + (bbox[3] / 2)
p = QPoint(xc, yc)
Longitude, Latitude, _ = vut.GetPointCommonCoords(
p, self.surface)
# Draw Rubber Band on canvas
self.Track_Canvas_RubberBand.addPoint(QgsPointXY(Longitude, Latitude))
else:
self._isinit = False
del self.tracker
# Magnifier Glass
if self._interaction.magnifier and not self.dragPos.isNull():
draw.drawMagnifierOnVideo(self, self.dragPos, self.currentFrame(), self.painter)
# Stamp On Video
if self._interaction.stamp:
draw.drawStampOnVideo(self, self.painter)
self.painter.end()
return
def mousePressEvent(self, event):
"""
@type event: QMouseEvent
@param event:
@return:
"""
if GetImageHeight() == 0:
return
# Prevent draw on video if not started or finished
# if self.parent.player.position() == 0:
# return
if event.button() == Qt.LeftButton:
# Magnifier Glass
if self._interaction.magnifier:
self.dragPos = event.pos()
self.tapTimer.stop()
self.tapTimer.start(10, self)
if not vut.IsPointOnScreen(event.x(), event.y(), self.surface):
return
# point drawer
if GetGCPGeoTransform(
) is not None and self._interaction.pointDrawer:
Longitude, Latitude, Altitude = vut.GetPointCommonCoords(
event, self.surface)
pointIndex = len(self.drawPtPos) + 1
AddDrawPointOnMap(pointIndex, Longitude, Latitude, Altitude)
self.drawPtPos.append([Longitude, Latitude, Altitude])
# polygon drawer
if GetGCPGeoTransform(
) is not None and self._interaction.polygonDrawer:
Longitude, Latitude, Altitude = vut.GetPointCommonCoords(
event, self.surface)
self.poly_Canvas_RubberBand.addPoint(
QgsPointXY(Longitude, Latitude))
self.poly_coordinates.extend(QgsPointXY(Longitude, Latitude))
self.drawPolygon.append([Longitude, Latitude, Altitude])
# line drawer
if GetGCPGeoTransform(
) is not None and self._interaction.lineDrawer:
Longitude, Latitude, Altitude = vut.GetPointCommonCoords(
event, self.surface)
self.drawLines.append([Longitude, Latitude, Altitude])
AddDrawLineOnMap(self.drawLines)
self.origin = event.pos()
# Object Tracking Interaction
if self._interaction.objectTracking:
self.Tracking_Video_RubberBand.setGeometry(
QRect(self.origin, QSize()))
self.Tracking_Video_RubberBand.show()
# Censure Interaction
if self._interaction.censure:
self.Censure_RubberBand.setGeometry(QRect(
self.origin, QSize()))
self.Censure_RubberBand.show()
# Measure Distance drawer
if GetGCPGeoTransform(
) is not None and self._interaction.measureDistance:
Longitude, Latitude, Altitude = vut.GetPointCommonCoords(
event, self.surface)
self.drawMeasureDistance.append(
[Longitude, Latitude, Altitude])
# Measure Distance drawer
if GetGCPGeoTransform(
) is not None and self._interaction.measureArea:
Longitude, Latitude, Altitude = vut.GetPointCommonCoords(
event, self.surface)
self.drawMeasureArea.append([Longitude, Latitude, Altitude])
# if not called, the paint event is not triggered.
self.UpdateSurface()
def mouseMoveEvent(self, event, useLast=False):
"""
@type event: QMouseEvent
@param event:
@return:
"""
if event is not None:
self.lastMouseX = event.x()
self.lastMouseY = event.y()
if useLast is False and self.lastMouseX != -1 and self.lastMouseY != -1:
# generates an event that simulates a mouse move, because even if
# mouse is still, video is running and mouse lat/lon must be
# updated.
event = QMouseEvent(
QEvent.MouseMove,
QPoint(self.lastMouseX, self.lastMouseY),
Qt.NoButton,
Qt.NoButton,
Qt.NoModifier,
)
else:
return
# Magnifier can move on black screen for show image borders
if self._interaction.magnifier:
self.dragPos = event.pos()
self.UpdateSurface()
# check if the point is on picture (not in black borders)
if not vut.IsPointOnScreen(event.x(), event.y(), self.surface):
self.setCursor(QCursor(Qt.ArrowCursor))
self.Cursor_Canvas_RubberBand.reset(QgsWkbTypes.PointGeometry)
return
# Prevent draw on video if not started or finished
# if self.parent.player.position() == 0:
# return
# Mouse cursor drawing
if (self._interaction.pointDrawer or self._interaction.polygonDrawer
or self._interaction.lineDrawer
or self._interaction.measureDistance
or self._interaction.measureArea or self._interaction.censure
or self._interaction.objectTracking):
self.setCursor(QCursor(Qt.CrossCursor))
# Cursor Coordinates
if GetGCPGeoTransform() is not None:
Longitude, Latitude, Altitude = vut.GetPointCommonCoords(
event, self.surface)
tr = QgsCoordinateTransform(
QgsCoordinateReferenceSystem("EPSG:4326"),
iface.mapCanvas().mapSettings().destinationCrs(),
QgsProject.instance().transformContext(),
)
mapPt = tr.transform(QgsPointXY(Longitude, Latitude))
vertices = self.Cursor_Canvas_RubberBand.numberOfVertices()
if vertices > 0:
self.Cursor_Canvas_RubberBand.removePoint(0, True, 0)
self.Cursor_Canvas_RubberBand.movePoint(mapPt, 0)
else:
self.Cursor_Canvas_RubberBand.addPoint(mapPt)
if self._MGRS:
try:
mgrsCoords = QgsMgrs.toMgrs(Latitude, Longitude)
except Exception:
mgrsCoords = ""
txt = ("<span style='font-size:9pt; font-weight:normal;'>" +
("%s" % mgrsCoords) + "</span>")
else:
txt = "<span style='font-size:10pt; font-weight:bold;'>Lon : </span>"
txt += ("<span style='font-size:9pt; font-weight:normal;'>" +
("%.5f" % Longitude) + "</span>")
txt += "<span style='font-size:10pt; font-weight:bold;'> Lat : </span>"
txt += ("<span style='font-size:9pt; font-weight:normal;'>" +
("%.5f" % Latitude) + "</span>")
if hasElevationModel():
txt += (
"<span style='font-size:10pt; font-weight:bold;'> Alt : </span>"
)
txt += (
"<span style='font-size:9pt; font-weight:normal;'>" +
("%.0f" % Altitude) + "</span>")
else:
txt += (
"<span style='font-size:10pt; font-weight:bold;'> Alt : </span>"
)
txt += "<span style='font-size:9pt; font-weight:normal;'>-</span>"
self.parent.lb_cursor_coord.setText(txt)
# Polygon drawer mouseMoveEvent
if self._interaction.polygonDrawer:
self.AddMoveEventValue(self.drawPolygon, Longitude, Latitude,
Altitude)
# Line drawer mouseMoveEvent
if self._interaction.lineDrawer:
self.AddMoveEventValue(self.drawLines, Longitude, Latitude,
Altitude)
# Measure Distance drawer mouseMoveEvent
if self._interaction.measureDistance and self.drawMeasureDistance:
self.AddMoveEventValue(self.drawMeasureDistance, Longitude,
Latitude, Altitude)
# Measure Area drawer mouseMoveEvent
if self._interaction.measureArea and self.drawMeasureArea:
self.AddMoveEventValue(self.drawMeasureArea, Longitude,
Latitude, Altitude)
else:
self.parent.lb_cursor_coord.setText(
"<span style='font-size:10pt; font-weight:bold;'>Lon :</span>"
+ "<span style='font-size:9pt; font-weight:normal;'>-</span>" +
"<span style='font-size:10pt; font-weight:bold;'> Lat :</span>"
+ "<span style='font-size:9pt; font-weight:normal;'>-</span>" +
"<span style='font-size:10pt; font-weight:bold;'> Alt :</span>"
+ "<span style='font-size:9pt; font-weight:normal;'>-</span>")
# Object tracking rubberband
if not self.Tracking_Video_RubberBand.isHidden():
self.Tracking_Video_RubberBand.setGeometry(
QRect(self.origin, event.pos()).normalized())
# Censure rubberband
if not self.Censure_RubberBand.isHidden():
self.Censure_RubberBand.setGeometry(
QRect(self.origin, event.pos()).normalized())
def paintEvent(self, event):
self.gt = GetGCPGeoTransform()
painter = QPainter(self)
if (self.surface.isActive()):
videoRect = self.surface.videoRect()
if not videoRect.contains(event.rect()):
region = event.region()
region.subtracted(QRegion(videoRect))
brush = self.palette().window()
for rect in region.rects():
painter.fillRect(rect, brush)
try:
self.surface.paint(painter)
except Exception:
None
else:
painter.fillRect(event.rect(), self.palette().window())
try:
SetImageSize(self.surface.currentFrame.width(),
self.surface.currentFrame.height())
except:
None
# Magnifier Glass
if self.zoomed and magnifier:
dim = min(self.width(), self.height())
magnifierSize = min(MAX_MAGNIFIER, dim * 2 / 3)
radius = magnifierSize / 2
ring = radius - 15
box = QSize(magnifierSize, magnifierSize)
# reupdate our mask
if self.maskPixmap.size() != box:
self.maskPixmap = QPixmap(box)
self.maskPixmap.fill(Qt.transparent)
g = QRadialGradient()
g.setCenter(radius, radius)
g.setFocalPoint(radius, radius)
g.setRadius(radius)
g.setColorAt(1.0, QColor(64, 64, 64, 0))
g.setColorAt(0.5, QColor(0, 0, 0, 255))
mask = QPainter(self.maskPixmap)
mask.setRenderHint(QPainter.Antialiasing)
mask.setCompositionMode(QPainter.CompositionMode_Source)
mask.setBrush(g)
mask.setPen(Qt.NoPen)
mask.drawRect(self.maskPixmap.rect())
mask.setBrush(QColor(Qt.transparent))
mask.drawEllipse(g.center(), ring, ring)
mask.end()
center = self.dragPos - QPoint(0, radius)
center += QPoint(0, radius / 2)
corner = center - QPoint(radius, radius)
xy = center * 2 - QPoint(radius, radius)
# only set the dimension to the magnified portion
if self.zoomPixmap.size() != box:
self.zoomPixmap = QPixmap(box)
self.zoomPixmap.fill(Qt.lightGray)
if True:
painter = QPainter(self.zoomPixmap)
painter.translate(-xy)
self.largePixmap = QPixmap.fromImage(self.surface.image)
painter.drawPixmap(self.offset, self.largePixmap)
painter.end()
clipPath = QPainterPath()
clipPath.addEllipse(QPointF(center), ring, ring)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setClipPath(clipPath)
painter.drawPixmap(corner, self.zoomPixmap)
painter.drawPixmap(corner, self.maskPixmap)
painter.setPen(Qt.gray)
painter.drawPath(clipPath)
return