def drawMeasureAreaOnVideo(values, painter, surface, gt):
''' Draw Measure Area on Video '''
a_value = sphere.polygon_area([values])
poly = []
lat = []
long = []
for pt in values:
if hasElevationModel():
pt = GetLine3DIntersectionWithPlane(
GetSensor(), pt, GetFrameCenter()[2])
scr_x, scr_y = vut.GetInverseMatrix(
pt[1], pt[0], gt, surface)
center = QPoint(scr_x, scr_y)
poly.append(center)
lat.append(pt[0])
long.append(pt[1])
# Fix: Temporary correction
# mousePressEvent calls after mouseMoveEvent.
# A problem occurs because the centroid is miscalculated.
# We remove duplicates values
lat = list(dict.fromkeys(lat))
long = list(dict.fromkeys(long))
# Calculate Centroid Position
scr_x, scr_y = vut.GetInverseMatrix(
sum(long)/len(long), sum(lat)/len(lat), gt, surface)
centroid = QPoint(scr_x, scr_y)
# Create Poligon
polygon = QPolygonF(poly)
path = QPainterPath()
path.addPolygon(polygon)
painter.setFont(DrawToolBar.bold_12)
painter.setPen(MeasurePen)
painter.drawPolygon(polygon)
painter.fillPath(path, MeasureBrush)
painter.setPen(DrawToolBar.white_pen)
painter.drawPoints(polygon)
# Area
if a_value >= 10000:
painter.drawText(centroid , str(round(a_value/1000000, 2)) + " km²")
else:
painter.drawText(centroid , str(round(a_value, 2)) + " m²")
return
def drawMeasureAreaOnVideo(values, painter, surface, gt):
""" Draw Measure Area on Video """
da = QgsDistanceArea()
da.setEllipsoid(WGS84String)
points = []
poly = []
for pt in values:
scr_x, scr_y = vut.GetInverseMatrix(pt[1], pt[0], gt, surface)
center = QPoint(scr_x, scr_y)
poly.append(center)
points.append(QgsPointXY(pt[1], pt[0]))
# Create Video Polygon
polygon = QPolygonF(poly)
path = QPainterPath()
path.addPolygon(polygon)
painter.setFont(DrawToolBar.bold_12)
painter.setPen(MeasurePen)
painter.drawPolygon(polygon)
painter.fillPath(path, MeasureBrush)
painter.setPen(DrawToolBar.white_pen)
painter.drawPoints(polygon)
# Create QGIS Polygon
mapPolygon = QgsGeometry.fromPolygonXY([points])
# Calculate polygon area
area = da.measureArea(mapPolygon)
try:
ctr = mapPolygon.centroid().asPoint()
# Calculate Centroid Position
scr_x, scr_y = vut.GetInverseMatrix(ctr.x(), ctr.y(), gt, surface)
centroid = QPoint(scr_x, scr_y)
# Area
if area >= 10000:
painter.drawText(
centroid,
str(round(da.convertAreaMeasurement(area, 1), 2)) + " km²")
else:
painter.drawText(centroid, str(round(area, 2)) + " m²")
except Exception:
None
return
def __init__(self, canvas):
super().__init__(canvas)
self.rotation = 0
self.pixmap = QPixmap()
self.item_size = QSizeF()
self.marker_font = QFont()
self.marker_font.setPointSize(12)
self.marker_font.setBold(True)
self.arrow_path = QPainterPath()
im = QImage(24, 24, QImage.Format_ARGB32)
im.fill(Qt.transparent)
self.set_symbol(im)
def drawMeasureAreaOnVideo(values, painter, surface, gt):
''' Draw Measure Area on Video '''
a_value = sphere.polygon_area([values])
poly = []
lat = []
long = []
for pt in values:
scr_x, scr_y = vut.GetInverseMatrix(pt[1], pt[0], gt, surface)
center = QPoint(scr_x, scr_y)
poly.append(center)
lat.append(pt[0])
long.append(pt[1])
lat = list(dict.fromkeys(lat))
long = list(dict.fromkeys(long))
# Calculate Centroid Position
scr_x, scr_y = vut.GetInverseMatrix(
sum(long) / len(long),
sum(lat) / len(lat), gt, surface)
centroid = QPoint(scr_x, scr_y)
# Create Poligon
polygon = QPolygonF(poly)
path = QPainterPath()
path.addPolygon(polygon)
painter.setFont(DrawToolBar.bold_12)
painter.setPen(MeasurePen)
painter.drawPolygon(polygon)
painter.fillPath(path, MeasureBrush)
painter.setPen(DrawToolBar.white_pen)
painter.drawPoints(polygon)
# Area
if a_value >= 10000:
painter.drawText(centroid,
str(round(a_value / 1000000, 2)) + " km²")
else:
painter.drawText(centroid, str(round(a_value, 2)) + " m²")
return
def updatePath(self):
self.endPoints = []
controlPoints = []
endPt = self.endItem.getLinkPointForParameter(self.endIndex)
if isinstance(self.startItem.element, QgsProcessingModelParameter):
startPt = self.startItem.getLinkPointForParameter(self.startIndex)
else:
startPt = self.startItem.getLinkPointForOutput(self.startIndex)
if isinstance(self.endItem.element, QgsProcessingModelParameter):
endPt = self.endItem.getLinkPointForParameter(self.startIndex)
if isinstance(self.startItem.element, QgsProcessingModelChildAlgorithm):
if self.startIndex != -1:
controlPoints.append(self.startItem.pos() + startPt)
controlPoints.append(self.startItem.pos() + startPt +
QPointF(ModelerGraphicItem.BOX_WIDTH / 3, 0))
controlPoints.append(self.endItem.pos() + endPt -
QPointF(ModelerGraphicItem.BOX_WIDTH / 3, 0))
controlPoints.append(self.endItem.pos() + endPt)
pt = QPointF(self.startItem.pos() + startPt + QPointF(-3, -3))
self.endPoints.append(pt)
pt = QPointF(self.endItem.pos() + endPt + QPointF(-3, -3))
self.endPoints.append(pt)
else:
# Case where there is a dependency on an algorithm not
# on an output
controlPoints.append(self.startItem.pos() + startPt)
controlPoints.append(self.startItem.pos() + startPt +
QPointF(ModelerGraphicItem.BOX_WIDTH / 3, 0))
controlPoints.append(self.endItem.pos() + endPt -
QPointF(ModelerGraphicItem.BOX_WIDTH / 3, 0))
controlPoints.append(self.endItem.pos() + endPt)
else:
controlPoints.append(self.startItem.pos())
controlPoints.append(self.startItem.pos() +
QPointF(ModelerGraphicItem.BOX_WIDTH / 3, 0))
controlPoints.append(self.endItem.pos() + endPt -
QPointF(ModelerGraphicItem.BOX_WIDTH / 3, 0))
controlPoints.append(self.endItem.pos() + endPt)
pt = QPointF(self.endItem.pos() + endPt + QPointF(-3, -3))
self.endPoints.append(pt)
path = QPainterPath()
path.moveTo(controlPoints[0])
path.cubicTo(*controlPoints[1:])
self.setPath(path)
def drawPolygonOnVideo(values, painter, surface, gt):
''' Draw Polygons on Video '''
poly = []
for pt in values:
scr_x, scr_y = vut.GetInverseMatrix(pt[1], pt[0], gt, surface)
center = QPoint(scr_x, scr_y)
poly.append(center)
polygon = QPolygonF(poly)
path = QPainterPath()
path.addPolygon(polygon)
painter.setPen(PolyPen)
painter.drawPolygon(polygon)
painter.fillPath(path, PolyBrush)
painter.setPen(DrawToolBar.white_pen)
painter.drawPoints(polygon)
return
def drawPolygonOnVideo(values, painter, surface, gt):
''' Draw Polygons on Video '''
poly = []
for pt in values:
if hasElevationModel():
pt = GetLine3DIntersectionWithPlane(GetSensor(), pt,
GetFrameCenter()[2])
scr_x, scr_y = vut.GetInverseMatrix(pt[1], pt[0], gt, surface)
center = QPoint(scr_x, scr_y)
poly.append(center)
polygon = QPolygonF(poly)
path = QPainterPath()
path.addPolygon(polygon)
painter.setPen(PolyPen)
painter.drawPolygon(polygon)
painter.fillPath(path, PolyBrush)
painter.setPen(DrawToolBar.white_pen)
painter.drawPoints(polygon)
return
def drawMagnifierOnVideo(widget, dragPos, source, painter):
''' Draw Magnifier on Video '''
oldTransform = painter.transform()
painter.setTransform(oldTransform)
painter.setBrush(DrawToolBar.transparent_brush)
dim = min(widget.width(), widget.height())
magnifierSize = min(MAX_MAGNIFIER, dim * 2 / 3)
radius = magnifierSize / 2
ring = radius - 15
box = QSize(magnifierSize, magnifierSize)
center = dragPos - QPoint(0, radius)
center += QPoint(0, radius / 2)
corner = center - QPoint(radius, radius)
xy = center * MAX_FACTOR - QPoint(radius, radius)
# only set the dimension to the magnified portion
zoomPixmap = QPixmap(box)
zoomPixmap.fill(Qt.black)
painter_p = QPainter(zoomPixmap)
painter_p.setRenderHint(QPainter.HighQualityAntialiasing)
painter_p.translate(-xy)
painter_p.scale(MAX_FACTOR, MAX_FACTOR)
painter_p.drawImage(widget.surface.videoRect(), source,
widget.surface.sourceRect())
painter_p.end()
clipPath = QPainterPath()
center = QPointF(center)
# Shape Type
if TYPE_MAGNIFIER == 0:
# Square
clipPath.addRect(center.x(), center.y(), magnifierSize,
magnifierSize)
clipPath.translate(-radius, -radius)
else:
# Circle
clipPath.addEllipse(center, ring, ring)
painter.setClipPath(clipPath)
painter.drawPixmap(corner, zoomPixmap)
painter.setPen(DrawToolBar.glass_pen)
painter.drawPath(clipPath)
return
def set_symbol(self, symbol_image: QImage):
self.pixmap = QPixmap.fromImage(symbol_image)
fm = QFontMetricsF(self.marker_font)
# set item size
self.item_size.setWidth(self.pixmap.width() + fm.width("360"))
pixmap_height = self.pixmap.height()
font_height = fm.height()
if pixmap_height >= font_height:
self.item_size.setHeight(self.pixmap.height())
else:
self.item_size.setHeight(fm.height())
half_item_width = self.pixmap.width() / 2.0
self.arrow_path = QPainterPath()
self.arrow_path.moveTo(half_item_width, pixmap_height)
self.arrow_path.lineTo(half_item_width, 0)
self.arrow_path.moveTo(self.pixmap.width() * 0.25,
pixmap_height * 0.25)
self.arrow_path.lineTo(half_item_width, 0)
self.arrow_path.lineTo(self.pixmap.width() * 0.75,
pixmap_height * 0.25)
def paint(self, painter, styleoptions, widget=None):
try:
width, realsize, label, fontsize = self._calc_size()
except ZeroDivisionError:
return
mapunits = self.canvas.mapUnits()
# painter.drawRect(self.boundingRect())
array = QPolygon()
canvasheight = self.canvas.height()
canvaswidth = self.canvas.width()
margin = 20
originy = 0
originx = 0
self.setPos(margin, canvasheight - margin)
x1, y1 = originx, originy
x2, y2 = originx, originy + self.ticksize
x3, y3 = originx + width, originy + self.ticksize
midx, midy = originx + width / 2, originy + self.ticksize / 2
x4, y4 = originx + width, originy
for pen in self.pens:
painter.setPen(pen)
# Drwa the scale bar
painter.drawLine(x1, y1, x2, y2)
painter.drawLine(x2, y2, x3, y3)
painter.drawLine(x3, y3, x4, y4)
painter.drawLine(midx, midy, midx, y1)
# Draw the text
fontwidth = self.metrics.width("0")
fontheight = self.metrics.height()
fontheight /= 2
fontwidth /= 2
path = QPainterPath()
point = QPointF(x1 - fontwidth, y1 - fontheight)
path.addText(point, self.font, "0")
painter.setPen(self.whitepen)
painter.setBrush(self.blackbrush)
painter.setRenderHints(QPainter.Antialiasing)
painter.setFont(self.font)
painter.drawPath(path)
fontwidth = self.metrics.width(label)
fontheight = self.metrics.height()
fontheight /= 2
fontwidth /= 2
point = QPointF(x4 - fontwidth, y4 - fontheight)
path.addText(point, self.font, label)
painter.drawPath(path)
def updatePath(self):
self.endPoints = []
controlPoints = []
endPt = self.endItem.getLinkPointForParameter(self.endIndex)
if isinstance(self.startItem.element,
QgsProcessingModelAlgorithm.ModelParameter):
startPt = self.startItem.getLinkPointForParameter(self.startIndex)
else:
startPt = self.startItem.getLinkPointForOutput(self.startIndex)
if isinstance(self.endItem.element,
QgsProcessingModelAlgorithm.ModelParameter):
endPt = self.endItem.getLinkPointForParameter(self.startIndex)
if isinstance(self.startItem.element,
QgsProcessingModelAlgorithm.ChildAlgorithm):
if self.startIndex != -1:
controlPoints.append(self.startItem.pos() + startPt)
controlPoints.append(self.startItem.pos() + startPt +
QPointF(ModelerGraphicItem.BOX_WIDTH /
3, 0))
controlPoints.append(self.endItem.pos() + endPt -
QPointF(ModelerGraphicItem.BOX_WIDTH /
3, 0))
controlPoints.append(self.endItem.pos() + endPt)
pt = QPointF(self.startItem.pos() + startPt + QPointF(-3, -3))
self.endPoints.append(pt)
pt = QPointF(self.endItem.pos() + endPt + QPointF(-3, -3))
self.endPoints.append(pt)
else:
# Case where there is a dependency on an algorithm not
# on an output
controlPoints.append(self.startItem.pos() + startPt)
controlPoints.append(self.startItem.pos() + startPt +
QPointF(ModelerGraphicItem.BOX_WIDTH /
3, 0))
controlPoints.append(self.endItem.pos() + endPt -
QPointF(ModelerGraphicItem.BOX_WIDTH /
3, 0))
controlPoints.append(self.endItem.pos() + endPt)
else:
controlPoints.append(self.startItem.pos())
controlPoints.append(self.startItem.pos() +
QPointF(ModelerGraphicItem.BOX_WIDTH / 3, 0))
controlPoints.append(self.endItem.pos() + endPt -
QPointF(ModelerGraphicItem.BOX_WIDTH / 3, 0))
controlPoints.append(self.endItem.pos() + endPt)
pt = QPointF(self.endItem.pos() + endPt + QPointF(-3, -3))
self.endPoints.append(pt)
path = QPainterPath()
path.moveTo(controlPoints[0])
path.cubicTo(*controlPoints[1:])
self.setPath(path)
def paint(self, painter, option, widget):
if not painter:
return
painter.save()
painter.setRenderHint(QPainter.Antialiasing, True)
# do a bit of trigonometry to find out how to transform a rotated item such
# that the center point is at the point feature
x = 0.0
y = 0.0
if self.pixmap.width() > 0 and self.pixmap.height() > 0:
half_item_diagonal = math.sqrt(
self.pixmap.width() * self.pixmap.width() +
self.pixmap.height() * self.pixmap.height()) / 2
diagonal_angle = math.acos(
self.pixmap.width() / (half_item_diagonal * 2)) * 180 / math.pi
x = half_item_diagonal * math.cos(
(self.rotation - diagonal_angle) * math.pi / 180)
y = half_item_diagonal * math.sin(
(self.rotation - diagonal_angle) * math.pi / 180)
painter.rotate(self.rotation)
painter.translate(x - self.pixmap.width() / 2.0,
-y - self.pixmap.height() / 2.0)
painter.drawPixmap(0, 0, self.pixmap)
# draw arrow, using a red line over a thicker white line so that the arrow is visible
# against a range of backgrounds
pen = QPen()
pen.setWidth(GuiUtils.scale_icon_size(4))
pen.setColor(QColor(Qt.white))
painter.setPen(pen)
painter.drawPath(self.arrow_path)
pen.setWidth(GuiUtils.scale_icon_size(1))
pen.setColor(QColor(Qt.red))
painter.setPen(pen)
painter.drawPath(self.arrow_path)
painter.restore()
# draw numeric value beside the symbol
painter.save()
painter.setRenderHint(QPainter.Antialiasing, True)
buffer_pen = QPen()
buffer_pen.setColor(Qt.white)
buffer_pen.setWidthF(GuiUtils.scale_icon_size(4))
fm = QFontMetricsF(self.marker_font)
label = QPainterPath()
label.addText(self.pixmap.width(),
self.pixmap.height() / 2.0 + fm.height() / 2.0,
self.marker_font, str(round(self.rotation, 1)))
painter.setPen(buffer_pen)
painter.setBrush(Qt.NoBrush)
painter.drawPath(label)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(Qt.black))
painter.drawPath(label)
painter.restore()
class PointRotationItem(QgsMapCanvasItem):
"""
A map canvas item which shows an angle display and preview of marker rotation
"""
def __init__(self, canvas):
super().__init__(canvas)
self.rotation = 0
self.pixmap = QPixmap()
self.item_size = QSizeF()
self.marker_font = QFont()
self.marker_font.setPointSize(12)
self.marker_font.setBold(True)
self.arrow_path = QPainterPath()
im = QImage(24, 24, QImage.Format_ARGB32)
im.fill(Qt.transparent)
self.set_symbol(im)
def paint(self, painter, option, widget):
if not painter:
return
painter.save()
painter.setRenderHint(QPainter.Antialiasing, True)
# do a bit of trigonometry to find out how to transform a rotated item such
# that the center point is at the point feature
x = 0.0
y = 0.0
if self.pixmap.width() > 0 and self.pixmap.height() > 0:
half_item_diagonal = math.sqrt(
self.pixmap.width() * self.pixmap.width() +
self.pixmap.height() * self.pixmap.height()) / 2
diagonal_angle = math.acos(
self.pixmap.width() / (half_item_diagonal * 2)) * 180 / math.pi
x = half_item_diagonal * math.cos(
(self.rotation - diagonal_angle) * math.pi / 180)
y = half_item_diagonal * math.sin(
(self.rotation - diagonal_angle) * math.pi / 180)
painter.rotate(self.rotation)
painter.translate(x - self.pixmap.width() / 2.0,
-y - self.pixmap.height() / 2.0)
painter.drawPixmap(0, 0, self.pixmap)
# draw arrow, using a red line over a thicker white line so that the arrow is visible
# against a range of backgrounds
pen = QPen()
pen.setWidth(GuiUtils.scale_icon_size(4))
pen.setColor(QColor(Qt.white))
painter.setPen(pen)
painter.drawPath(self.arrow_path)
pen.setWidth(GuiUtils.scale_icon_size(1))
pen.setColor(QColor(Qt.red))
painter.setPen(pen)
painter.drawPath(self.arrow_path)
painter.restore()
# draw numeric value beside the symbol
painter.save()
painter.setRenderHint(QPainter.Antialiasing, True)
buffer_pen = QPen()
buffer_pen.setColor(Qt.white)
buffer_pen.setWidthF(GuiUtils.scale_icon_size(4))
fm = QFontMetricsF(self.marker_font)
label = QPainterPath()
label.addText(self.pixmap.width(),
self.pixmap.height() / 2.0 + fm.height() / 2.0,
self.marker_font, str(round(self.rotation, 1)))
painter.setPen(buffer_pen)
painter.setBrush(Qt.NoBrush)
painter.drawPath(label)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(Qt.black))
painter.drawPath(label)
painter.restore()
def set_point_location(self, p):
transformed_point = self.toCanvasCoordinates(p)
self.setPos(transformed_point.x() - self.pixmap.width() / 2.0,
transformed_point.y() - self.pixmap.height() / 2.0)
def set_symbol_rotation(self, rotation: float):
self.rotation = rotation
def set_symbol(self, symbol_image: QImage):
self.pixmap = QPixmap.fromImage(symbol_image)
fm = QFontMetricsF(self.marker_font)
# set item size
self.item_size.setWidth(self.pixmap.width() + fm.width("360"))
pixmap_height = self.pixmap.height()
font_height = fm.height()
if pixmap_height >= font_height:
self.item_size.setHeight(self.pixmap.height())
else:
self.item_size.setHeight(fm.height())
half_item_width = self.pixmap.width() / 2.0
self.arrow_path = QPainterPath()
self.arrow_path.moveTo(half_item_width, pixmap_height)
self.arrow_path.lineTo(half_item_width, 0)
self.arrow_path.moveTo(self.pixmap.width() * 0.25,
pixmap_height * 0.25)
self.arrow_path.lineTo(half_item_width, 0)
self.arrow_path.lineTo(self.pixmap.width() * 0.75,
pixmap_height * 0.25)
def append_CharacterMarkerSymbolLayerAsSvg(symbol, layer, context: Context): # pylint: disable=too-many-locals
"""
Appends a CharacterMarkerSymbolLayer to a symbol, rendering the font character
to an SVG file.
"""
font_family = layer.font
character = chr(layer.unicode)
color = symbol_color_to_qcolor(layer.color)
angle = convert_angle(layer.angle)
font = QFont(font_family)
font.setPointSizeF(layer.size)
# Using the rect of a painter path gives better results then using font metrics
path = QPainterPath()
path.setFillRule(Qt.WindingFill)
path.addText(0, 0, font, character)
rect = path.boundingRect()
font_bounding_rect = QFontMetricsF(font).boundingRect(character)
# adjust size -- marker size in esri is the font size, svg marker size in qgis is the svg rect size
scale = rect.width() / font_bounding_rect.width()
gen = QSvgGenerator()
svg_path = symbol_name_to_filename(context.symbol_name,
context.picture_folder, 'svg')
gen.setFileName(svg_path)
gen.setViewBox(rect)
painter = QPainter(gen)
painter.setFont(font)
# todo -- size!
if context.parameterise_svg:
painter.setBrush(QBrush(QColor(255, 0, 0)))
else:
painter.setBrush(QBrush(color))
painter.setPen(Qt.NoPen)
painter.drawPath(path)
painter.end()
if context.parameterise_svg:
with open(svg_path, 'r') as f:
t = f.read()
t = t.replace('#ff0000', 'param(fill)')
t = t.replace('fill-opacity="1" ',
'fill-opacity="param(fill-opacity)"')
t = t.replace(
'stroke="none"',
'stroke="param(outline)" stroke-opacity="param(outline-opacity) 1" stroke-width="param(outline-width) 0"'
)
with open(svg_path, 'w') as f:
f.write(t)
svg_path = context.convert_path(svg_path)
out = QgsSvgMarkerSymbolLayer(svg_path)
out.setSizeUnit(context.units)
out.setSize(context.convert_size(scale * rect.width()))
out.setAngle(angle)
out.setFillColor(color)
out.setStrokeWidth(0)
out.setEnabled(layer.enabled)
out.setLocked(layer.locked)
out.setOffset(
adjust_offset_for_rotation(
QPointF(context.convert_size(layer.x_offset),
-context.convert_size(layer.y_offset)), layer.angle))
out.setOffsetUnit(context.units)
symbol.appendSymbolLayer(out)
def drawLine(self, painter, commit, parent):
commitRow = self.graph.commitRows[commit.commitid]
commitCol = self.graph.commitColumns[commit.commitid]
parentRow = self.graph.commitRows[parent.commitid]
parentCol = self.graph.commitColumns[parent.commitid]
commitX = self.RADIUS * 3 + commitCol * self.COLUMN_SEPARATION
parentX = self.RADIUS * 3 + parentCol * self.COLUMN_SEPARATION
commitY = commitRow * self.COMMIT_GRAPH_HEIGHT
parentY = parentRow * self.COMMIT_GRAPH_HEIGHT
color = self._columnColor(parentCol)
if parent is not None and self.graph.isFauxLink(parent.commitid, commit.commitid)\
and len(parent.childrenIds)>1:
# draw a faux line
path = QPainterPath()
path.moveTo(parentX, parentY)
path.lineTo(commitX , commitY)
color = QColor(255,160,255)
pen = QPen()
pen.setWidth(2)
pen.setBrush(color)
pen.setStyle(Qt.DashLine)
painter.setPen(pen)
painter.drawPath(path)
# draw arrow
# draw arrow
ARROW_POINT_SIZE = 9
painter.setPen(color)
painter.setBrush(color)
line = QLineF(commitX , commitY, parentX, parentY)
angle = math.acos(line.dx() / line.length())
if line.dy() >= 0:
angle = 2.0 * math.pi - angle
sourcePoint = QPointF(commitX,commitY)
sourceArrowP1 = sourcePoint + QPointF(math.sin(angle + math.pi / 3) * ARROW_POINT_SIZE,
math.cos(angle + math.pi / 3) * ARROW_POINT_SIZE)
sourceArrowP2 = sourcePoint + QPointF(math.sin(angle + math.pi - math.pi / 3) * ARROW_POINT_SIZE,
math.cos(angle + math.pi - math.pi / 3) * ARROW_POINT_SIZE)
arrow = QPolygonF([line.p1(), sourceArrowP1, sourceArrowP2])
painter.drawPolygon(arrow)
return
path = QPainterPath()
painter.setBrush(color)
painter.setPen(color)
if parentCol != commitCol:
if parent.isFork() and commit.getParents()[0].commitid == parent.commitid:
path.moveTo(commitX, commitY)
path.lineTo(commitX, parentY)
if parentX<commitX:
path.lineTo(parentX + self.RADIUS + 1, parentY)
else:
path.lineTo(parentX - self.RADIUS, parentY)
color = self._columnColor(commitCol)
else:
path2 = QPainterPath()
path2.moveTo(commitX + self.RADIUS + 1, commitY)
path2.lineTo(commitX + self.RADIUS + self.COLUMN_SEPARATION / 2, commitY + self.COLUMN_SEPARATION / 3)
path2.lineTo(commitX + self.RADIUS + self.COLUMN_SEPARATION / 2, commitY - self.COLUMN_SEPARATION / 3)
path2.lineTo(commitX + + self.RADIUS + 1, commitY)
painter.setBrush(color)
painter.setPen(color)
painter.drawPath(path2)
path.moveTo(commitX + self.RADIUS + self.COLUMN_SEPARATION / 2, commitY)
path.lineTo(parentX, commitY)
path.lineTo(parentX, parentY)
if parent.isFork():
if commitCol in self.columnColor.keys():
del self.columnColor[commitCol]
else:
path.moveTo(commitX, commitY)
path.lineTo(parentX, parentY)
pen = QPen(color, self.PEN_WIDTH, Qt.SolidLine, Qt.FlatCap, Qt.RoundJoin)
painter.strokePath(path, pen)
if not commit.commitid in self.linked:
y = commitRow * self.COLUMN_SEPARATION
x = self.RADIUS * 3 + commitCol * self.COLUMN_SEPARATION
painter.setPen(color)
painter.setBrush(color)
painter.drawEllipse(QPoint(x, y), self.RADIUS, self.RADIUS)
self.linked.append(commit.commitid)
def paint(self, painter, xxx, xxx2):
self.setPos(self.toCanvasCoordinates(self.map_pos))
halfSize = self.size / 2.0
rect = QRectF(0 - halfSize, 0 - halfSize, self.size, self.size)
painter.setRenderHint(QPainter.Antialiasing)
if self.quality == 0:
color = self.red
elif self.quality == 1:
color = self.green
elif self.quality >= 2:
color = self.blue
else:
color = self.red
self.pointpen.setColor(Qt.gray)
self.pointpen.setWidth(2)
self.pointbrush.setColor(color)
painter.setBrush(self.pointbrush)
painter.setPen(self.pointpen)
y = 0 - halfSize
x = rect.width() / 2 - halfSize
line = QLine(x, y, x, rect.height() - halfSize)
y = rect.height() / 2 - halfSize
x = 0 - halfSize
line2 = QLine(x, y, rect.width() - halfSize, y)
# Arrow
p = QPolygonF()
p.append(QPoint(0 - halfSize, 0))
p.append(QPoint(0, -self.size))
x = rect.width() - halfSize
p.append(QPoint(x, 0))
p.append(QPoint(0, 0))
offsetp = QPolygonF()
offsetp.append(QPoint(0 - halfSize, 0))
offsetp.append(QPoint(0, -self.size))
x = rect.width() - halfSize
offsetp.append(QPoint(x, 0))
offsetp.append(QPoint(0, 0))
waypoint = self.gps.waypoint
if waypoint:
az = self.map_pos.azimuth(waypoint)
painter.save()
painter.rotate(az)
self.pointbrush.setColor(Qt.red)
painter.setBrush(self.pointbrush)
path = QPainterPath()
path.addPolygon(offsetp)
painter.drawPath(path)
painter.restore()
painter.save()
painter.rotate(self._heading)
path = QPainterPath()
path.addPolygon(p)
painter.drawPath(path)
painter.restore()
painter.drawEllipse(rect)
painter.drawLine(line)
painter.drawLine(line2)
def shape(self):
p = QPainterPath()
p.addEllipse(-2, -2, 5, 5)
return p
