def nextFrame(self):
mouse_pos = self.mapFromGlobal(QCursor.pos())
mouse_x = mouse_pos.x()
mouse_y = mouse_pos.y()
self.x1 = mouse_x
self.y1 = mouse_y
self.radius1 = self.radius1 + math.sin(self.frame_count / 8) * 4
delay = 20
self.x2 += (mouse_x - self.x2) / delay
self.y2 += (mouse_y - self.y2) / delay
self.frame_count += 1
if self.paint_image.width() != self.width() or self.paint_image.height() != self.height():
self.paint_image = QPixmap(self.width(), self.height())
self.paint_image.fill(self.background_color)
p = QPainter()
p.begin(self.paint_image) # auf das paint_image malen
p.setBackground(self.background_color) # color when stuff is erased
# Hintergrund löschen, wenn Rechteck bei der Maus angekommen ist
# print("{0}, {1}".format(self.x2, mouse_x))
if round(self.x2) == mouse_x and round(self.y2) == mouse_y:
p.eraseRect(0, 0, self.paint_image.width(), self.paint_image.height())
self.drawFrame(p)
p.end()
self.repaint()
def draw_lines(self, painter: QtGui.QPainter) -> None:
# переключаем кисть
painter.setPen(self.label_pen)
painter.setBackground(QtCore.Qt.white)
# из TY1 в T1
painter.drawLine(self.points["TY1"], self.points["T1"])
# из T1 в TX
painter.drawLine(self.points["T1"], self.points["TX"])
# из TX в T2
painter.drawLine(self.points["TX"], self.points["T2"])
# из T2 в TZ
painter.drawLine(self.points["T2"], self.points["TZ"])
# из TZ в T3
painter.drawLine(self.points["TZ"], self.points["T3"])
# Из T3 в TY3
painter.drawLine(self.points["T3"], self.points["TY3"])
# рисуем сектор
self.draw_arc(painter)
def paintEvent(self, ev):
super(TagsLabelWidget, self).paintEvent(ev)
painter = QPainter(self)
painter.save()
try:
painter.setBackground(self.palette().brush(self.backgroundRole()))
painter.eraseRect(ev.rect())
painter.setClipRect(ev.rect())
fm = QFontMetrics(self.font()) # TODO use style
x = self.xmargin
for sz, tag in self._positions(self.tags):
fg, bg = tag_to_colors(tag)
painter.setPen(fg.color())
painter.fillRect(x, self.ymargin,
sz.width() + 2 * self.xpadding, fm.height(),
bg.color())
painter.drawText(x + self.xpadding, self.ymargin + fm.ascent(),
tag)
x += sz.width() + self.xmargin + 2 * self.xpadding
finally:
painter.restore()
def _check_frequency_boundaries(self, qp: QtGui.QPainter):
if (len(self.data) > 0
and (self.data[0].freq > self.fstop
or self.data[len(self.data) - 1].freq < self.fstart) and
(len(self.reference) == 0 or self.reference[0].freq > self.fstop
or self.reference[len(self.reference) - 1].freq < self.fstart)):
# Data outside frequency range
qp.setBackgroundMode(QtCore.Qt.OpaqueMode)
qp.setBackground(Chart.color.background)
qp.setPen(Chart.color.text)
qp.drawText(self.leftMargin + self.dim.width / 2 - 70,
self.topMargin + self.dim.height / 2 - 20,
"Data outside frequency span")
def paintCell(self, painter: QtGui.QPainter, rect: QtCore.QRect,
date: typing.Union[QtCore.QDate, datetime.date]) -> None:
painter.save()
with open(get_resource("config.json")) as file:
if date.toPyDate().strftime("%Y-%m-%d") in json.loads(
file.read())["favorites"]:
painter.fillRect(rect, QtGui.QColor.fromRgb(255, 255, 0))
if (date.month() != self.monthShown()):
painter.setPen(QtGui.QColor("#888888"))
elif date.dayOfWeek() == 6 or date.dayOfWeek() == 7:
painter.setPen(QtGui.QColor("red"))
tags = self.get_tags_from_date_file(date.toPyDate())
rect.adjust(0, 0, -1, -1)
pen = painter.pen()
pen.setColor(
QtGui.QColor.fromHsl(pen.color().hue(),
pen.color().saturation(),
pen.color().lightness(), 150))
painter.setPen(pen)
painter.drawRect(rect)
pen.setColor(
QtGui.QColor.fromHsl(pen.color().hue(),
pen.color().saturation(),
pen.color().lightness(), 255))
painter.setPen(pen)
painter.drawText(rect, QtCore.Qt.AlignTop, str(date.day()))
text = ""
try:
for tag in tags[:5]:
if len(tag) > 12:
tag = str(tag[:12]) + "..."
text += f" {tag} \n"
except TypeError:
text = ""
font = QtGui.QFont()
font.setPixelSize(10)
painter.setFont(font)
brush = painter.background()
random.seed(date)
brush.setColor(QtGui.QColor().fromHsl(randint(0, 255), randint(0, 255),
randint(200, 255)))
painter.setPen(QtGui.QColor("black"))
painter.setBackground(brush)
painter.setBackgroundMode(QtCore.Qt.OpaqueMode)
painter.drawText(rect, QtCore.Qt.AlignBottom | QtCore.Qt.AlignHCenter,
text)
painter.restore()
def drawTiles(painter, rect, tileSize=6, color=None, backgroundColor=None):
sz = 2 * tileSize
tiledPixmap = QPixmap(sz, sz)
pixmapPainter = QPainter(tiledPixmap)
pixmapPainter.setPen(Qt.NoPen)
pixmapPainter.setBrush(Qt.Dense4Pattern)
brush = pixmapPainter.brush()
brush.setColor(color)
pixmapPainter.setBrush(brush)
pixmapPainter.setBackground(QBrush(backgroundColor))
pixmapPainter.setBackgroundMode(Qt.OpaqueMode)
pixmapPainter.scale(tileSize, tileSize)
pixmapPainter.drawRect(tiledPixmap.rect())
pixmapPainter.end()
painter.drawTiledPixmap(rect, tiledPixmap)
def paintEvent(self, e):
painter = QPainter(self)
painter.setPen(Qt.black)
painter.setBrush(QColor(155, 88, 19, 200))
painter.setBackground(Qt.blue)
if self._players[self.board.turn].is_player:
self.QBut_pass.setEnabled(True)
else:
self.QBut_pass.setEnabled(False)
if self.board.is_started:
self.QBut_reset.setEnabled(True)
else:
self.QBut_reset.setEnabled(False)
self.draw_game_place(painter)
self.draw_board(painter)
def paintEvent(self, e):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setBackground(Qt.white)
painter.setPen(QPen(Qt.black, 2, Qt.SolidLine))
painter.setBrush(Qt.red)
for line in self.lines:
path = QPainterPath()
path.moveTo(*line[0])
path.lineTo(*line[1])
painter.drawPath(path)
for x in self.coords:
painter.drawEllipse(x[0] - 20, x[1] - 20, 40, 40)
painter.drawText(x[0] - 10, x[1] - 10, 20, 20, Qt.AlignCenter,
str(self.coords.index(x) + 1))
def paintEvent(self, e):
painter = QPainter(self)
painter.setPen(Qt.black)
painter.setBrush(QColor(155, 88, 19, 200))
painter.setBackground(Qt.blue)
# TODO move buttons from paint event
# off buttons
if self.board.get_current_player().is_player:
self.QBut_pass.setEnabled(True)
else:
self.QBut_pass.setEnabled(False)
if self.board.is_started:
self.QBut_reset.setEnabled(True)
else:
self.QBut_reset.setEnabled(False)
self.draw_game_place(painter)
self.draw_board(painter)
def paintEvent(self, a0):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setBackground(Qt.white)
painter.setPen(QPen(Qt.black, 2, Qt.SolidLine))
painter.setBrush(Qt.NoBrush)
for path in self.paths:
painter.drawPath(path)
for coord in self.coords:
painter.setBrush(coord[2])
painter.drawEllipse(coord[0] - 20, coord[1] - 20, 40, 40)
painter.drawText(coord[0] - 10, coord[1] - 10, 20, 20,
Qt.AlignCenter, str(self.coords.index(coord) + 1))
painter.setPen(QPen(Qt.darkYellow, 4, Qt.SolidLine))
for i in range(len(self.tin)):
painter.drawText(self.coords[i][0] + 20,
self.coords[i][1] - 40 // 3, 40, 10,
Qt.AlignCenter,
str(self.tin[i]) + "/" + str(self.tout[i]))
def draw_lines(self, painter: QtGui.QPainter) -> None:
# переключаем кисть
painter.setPen(self.label_pen)
painter.setBackground(QtCore.Qt.white)
painter.drawLine(self.points["T"], self.points["T1"])
painter.drawLine(self.points["T"], self.points["T2"])
painter.drawLine(self.points["T"], self.points["T3"])
painter.drawLine(self.points["T1"], self.points["TX"])
painter.drawLine(self.points["T1"], self.points["TY"])
painter.drawLine(self.points["T2"], self.points["TY"])
painter.drawLine(self.points["T2"], self.points["TZ"])
painter.drawLine(self.points["T3"], self.points["TX"])
painter.drawLine(self.points["T3"], self.points["TZ"])
painter.drawLine(self.points["TX"], self.points["0"])
painter.drawLine(self.points["TY"], self.points["0"])
painter.drawLine(self.points["TZ"], self.points["0"])
def paintEvent(self, event):
painter = QPainter(self)
# erase background
painter.setBackground(QBrush(Layer.color(LayerType.background)))
painter.setClipping(True)
painter.eraseRect(self.rect())
# draw document
if self._ctrl is not None:
# draw grid
painter.setRenderHint(QPainter.Antialiasing, False)
pen = QPen(Layer.color(LayerType.grid))
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setWidth(0)
painter.setTransform(self._transform)
painter.setPen(pen)
self._drawGrid(painter)
# draw drawables
# painter.setRenderHint(QPainter.Antialiasing)
for d in self._ctrl.getDrawables():
d.draw(painter)
painter.end()
def paintEvent(self, event):
painter = QPainter(self)
# erase background
painter.setBackground(QBrush(Layer.color(LayerType.background)))
painter.setClipping(True)
painter.eraseRect(self.rect())
# draw document
if self._ctrl is not None:
# draw grid
painter.setRenderHint(QPainter.Antialiasing, False)
pen = QPen(Layer.color(LayerType.grid))
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setWidth(0)
painter.setTransform(self._transform)
painter.setPen(pen)
self._drawGrid(painter)
# draw drawables
# painter.setRenderHint(QPainter.Antialiasing)
for d in self._ctrl.getDrawables():
d.draw(painter)
painter.end()
def drawGradients(self, painter: QPainter):
painter.setBackground(QBrush(Qt.cyan))
painter.eraseRect(0, 0, self.width(), self.height())
grad1 = QLinearGradient(0, 20, 0, 110)
grad1.setColorAt(0.1, Qt.black)
grad1.setColorAt(0.5, Qt.yellow)
grad1.setColorAt(0.9, Qt.black)
painter.fillRect(20, 20, 300, 90, grad1)
grad2 = QLinearGradient(0, 55, 250, 0)
grad2.setColorAt(0.2, Qt.black)
grad2.setColorAt(0.5, Qt.red)
grad2.setColorAt(0.8, Qt.black)
painter.fillRect(20, 140, 300, 100, grad2)
grad3 = QLinearGradient(0, 280, 0, 380)
grad3.setColorAt(0.1, QColor(0xcc, 0xcc, 0xcc, 156))
grad3.setColorAt(0.8, QColor(0xcc, 0xcc, 0xcc, 0))
painter.fillRect(20, 280, 300, 100, grad3)
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setBackground(QColor(52, 170, 253))
painter.eraseRect(painter.viewport())
painter.drawPixmap(QPoint(0, 0), self.__background)
qfont = QFont("Arial")
qfont.setPixelSize(72)
qfont.setBold(QFont.Bold)
self.__paint_outlined_text(painter, QPoint(150, 110), qfont, "UML")
qfont.setPixelSize(45)
self.__paint_outlined_text(painter, QPoint(330, 110), qfont, ".FRI")
self.__paint_outlined_text(painter, QPoint(450, 110), qfont, Application().about.version.major_minor_string)
painter.end()
super().paintEvent(event)
def paintEvent(self, event):
super().paintEvent(event)
painter = QPainter()
painter.begin(self)
# background
brushBG = QBrush(Qt.black, Qt.SolidPattern)
if not common.AppSettings["ShowMask"]:
brushBG.setColor(Qt.darkGray)
brushBG.setStyle(Qt.Dense1Pattern)
painter.setBackground(Qt.gray)
else:
brushBG.setColor(Qt.black)
brushBG.setStyle(Qt.SolidPattern)
painter.setBackground(Qt.black)
painter.setBackgroundMode(Qt.OpaqueMode)
painter.setBrush(brushBG)
painter.setPen(Qt.NoPen)
painter.drawRect(0, 0, self.width(), self.height())
# draw photo
if not self.myPhoto.isNull():
# rotate and draw photo as specified by user
transform = QTransform()
transform.translate(self.myPhotoDestRect.center().x(), self.myPhotoDestRect.center().y())
transform.rotate(-self.myPhotoRotation)
transform.translate(-self.myPhotoDestRect.center().x(), -self.myPhotoDestRect.center().y())
painter.setTransform(transform)
painter.drawImage(self.myPhotoDestRect, self.myPhoto, self.myPhotoSrcRect) # draw it
painter.resetTransform()
# useful local vars
centerPoint = QPoint(self.viewCenter[0], self.viewCenter[1])
destRect = QRect(0, 0, self.myPhotoDestRect.width(), self.myPhotoDestRect.height())
fontWidth = self.fontMetrics.width("X")
# mask
if common.AppSettings["ShowMask"]:
maskPainter = QPainter()
maskPainter.begin(self.mask)
maskPainter.setBrush(QBrush(Qt.magenta, Qt.SolidPattern))
maskPainter.drawEllipse(self.viewCenter[0] - self.myPhotoRadius, self.viewCenter[1] - self.myPhotoRadius, self.myPhotoDiameter, self.myPhotoDiameter)
maskPainter.end()
painter.setCompositionMode(QPainter.CompositionMode_DestinationIn)
painter.drawImage(0, 0, self.mask)
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
# HUD
if common.AppSettings["ShowHUD"]:
painter.setBackgroundMode(Qt.TransparentMode)
#painter.setBackground(Qt.black)
painter.setBrush(Qt.NoBrush)
painter.setFont(self.fontScaled)
# draw UV grid
if common.AppSettings["ShowUVGrid"]:
painter.setPen(self.penText)
# box
tl = self.myPhotoTopLeft
tr = (self.viewCenter[0] + self.myPhotoRadius, self.viewCenter[1] - self.myPhotoRadius)
bl = (self.viewCenter[0] - self.myPhotoRadius, self.viewCenter[1] + self.myPhotoRadius)
br = (self.viewCenter[0] + self.myPhotoRadius, self.viewCenter[1] + self.myPhotoRadius)
painter.drawLine(tl[0], tl[1], tr[0], tr[1])
painter.drawLine(bl[0], bl[1], br[0], br[1])
painter.drawLine(tl[0], tl[1], bl[0], bl[1])
painter.drawLine(tr[0], tr[1], br[0], br[1])
# crosshairs
painter.drawLine(tl[0], self.viewCenter[1], tr[0], self.viewCenter[1])
painter.drawLine(self.viewCenter[0], tr[1], self.viewCenter[0], br[1])
# labels
destRect.setCoords(tl[0] + 4, tl[1] + 4, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "0")
destRect.setCoords(tr[0] - (fontWidth+4), tr[1] + 4, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "1")
destRect.setCoords(bl[0] + 3, bl[1] - (self.fontMetrics.height()+3), self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "1")
destRect.setCoords(br[0] - (fontWidth+3), br[1] - (self.fontMetrics.height()+3), self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "1")
# grid coordinates
gpntrad = self.myPhotoRadius * 0.005
painter.setPen(self.penText)
painter.setBrush(self.brushGrid)
painter.setFont(self.fontScaled)
for i in range(0, len(self.gridpoints)):
point = self.gridpoints[i]
u, v = self.gridUVs[i]
t, p = self.gridskycoords[i]
painter.drawEllipse(QPoint(point[0], point[1]), gpntrad, gpntrad)
destRect.setCoords(point[0]+fontWidth/2, point[1]-self.fontMetrics.height(), self.width(), self.height())
textuv = "{0:.1f}u, {1:.1f}v".format(round(u,1), round(v,1))
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, textuv)
destRect.setCoords(point[0]+fontWidth/2, point[1], self.width(), self.height())
textuv = "{0:d}°, {1:d}°".format(int(round(t)), int(round(p)))
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, textuv)
painter.setBrush(Qt.NoBrush)
# draw lens warp
if common.AppSettings["ShowLensWarp"]:
# ideal lens longitudes along azimuth
painter.setPen(self.penText)
for i in range(0, int(len(self.compassTicks)/2), 3):
p1 = QPoint(self.compassTicks[i][2], self.compassTicks[i][3])
p2 = QPoint(self.compassTicks[i+18][2], self.compassTicks[i+18][3]) # tick opposite 180 degrees
painter.drawLine(p1, p2)
# ideal lens latitudes along zenith
for r, alt in self.lensIdealRadii:
painter.drawEllipse(centerPoint, r, r)
# actual/warped lens latitudes along zenith
painter.setPen(self.penLens)
for r, alt in self.lensRealRadii:
painter.drawEllipse(centerPoint, r, r)
destRect.setCoords(self.viewCenter[0] + r + 3, self.viewCenter[1] - (self.fontMetrics.height() + 3), self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "{0:d}°".format(int(alt)))
# draw compass
if common.AppSettings["ShowCompass"]:
# compass ticks text shadows
if common.AppSettings["ShowShadows"]:
painter.setPen(self.penShadowText)
for tick in self.compassTicks:
destRect.setCoords(tick[4] + 1, tick[5] + 1, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, str(tick[6])+"°")
# compass ticks text
painter.setPen(self.penText)
for tick in self.compassTicks:
painter.drawLine(tick[0], tick[1], tick[2], tick[3])
destRect.setCoords(tick[4], tick[5], self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, str(tick[6])+"°")
# photo radius
#painter.drawEllipse(self.viewCenter[0] - self.myPhotoRadius, self.viewCenter[1] - self.myPhotoRadius, self.myPhotoDiameter, self.myPhotoDiameter)
painter.drawEllipse(centerPoint, self.myPhotoRadius, self.myPhotoRadius)
# cardinal directions
destRect.setCoords(self.viewCenter[0] - self.myPhotoRadius - (fontWidth+4), self.viewCenter[1] - self.fontMetrics.height()/2, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "W")
destRect.setCoords(self.viewCenter[0] + self.myPhotoRadius + 4, self.viewCenter[1] - self.fontMetrics.height()/2, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "E")
destRect.setCoords(self.viewCenter[0] - fontWidth/2, self.viewCenter[1] - self.myPhotoRadius - (self.fontMetrics.height()+3), self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "S")
destRect.setCoords(self.viewCenter[0] - fontWidth/2, self.viewCenter[1] + self.myPhotoRadius + 3, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "N")
# draw sampling pattern
if common.AppSettings["ShowSamples"]:
painter.setPen(self.penText)
for i, points in enumerate(self.sampleAreaVisible):
painter.drawLine(QLine(points[0], points[1]))
painter.drawLine(QLine(points[1], points[2]))
painter.drawLine(QLine(points[2], points[3]))
painter.drawLine(QLine(points[3], points[0]))
for i in range(0, len(self.samplePoints)):
p = self.samplePoints[i]
painter.drawEllipse(QPoint(p[0],p[1]), ViewFisheye.SampleRadius, ViewFisheye.SampleRadius)
painter.drawText(p[0] + ViewFisheye.SampleRadius, p[1], str(i))
# draw sun path
if common.AppSettings["ShowSunPath"]:
sunradius = self.myPhotoRadius * 0.1
# shadows
painter.setPen(self.penShadowSun)
if common.AppSettings["ShowShadows"]:
painter.drawEllipse(QPoint(self.sunPositionVisible[0]+1, self.sunPositionVisible[1]+1), sunradius, sunradius)
self.pathSun.translate(1.0, 1.0)
painter.drawPath(self.pathSun)
self.pathSun.translate(-1.0, -1.0)
for i in range(0, self.pathSun.elementCount()):
e = self.pathSun.elementAt(i)
destRect.setCoords(e.x, e.y + self.fontMetrics.height()/2 + 1, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, str(self.sunPathPoints[i][2].hour))
# sun, path, hours
painter.setPen(self.penSun)
painter.drawEllipse(QPoint(self.sunPositionVisible[0], self.sunPositionVisible[1]), sunradius, sunradius)
painter.drawPath(self.pathSun)
for i in range(0, self.pathSun.elementCount()):
e = self.pathSun.elementAt(i)
destRect.setCoords(e.x, e.y + self.fontMetrics.height() / 2, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, str(self.sunPathPoints[i][2].hour))
# draw selected samples (ALWAYS)
r = QRect()
# shadows
if common.AppSettings["ShowShadows"]:
painter.setPen(self.penShadowSelected)
for i in self.samplesSelected:
x, y = self.samplePoints[i]
painter.drawEllipse(QPoint(x+1, y+1), ViewFisheye.SampleRadius, ViewFisheye.SampleRadius)
# samples
for i in self.samplesSelected:
painter.setPen(self.penSelected[i])
x, y = self.samplePoints[i]
painter.drawEllipse(QPoint(x, y), ViewFisheye.SampleRadius, ViewFisheye.SampleRadius)
# draw user's selection bounds
if (abs(self.dragSelectRect.right()-self.dragSelectRect.left()) >= ViewFisheye.SelectionRectMin and
abs(self.dragSelectRect.bottom()-self.dragSelectRect.top()) >= ViewFisheye.SelectionRectMin):
painter.setPen(self.penSelectRect)
painter.drawRect(self.dragSelectRect)
# draw timestamp
painter.setPen(self.penText)
painter.setFont(self.fontFixed)
destRect.setCoords(10, 10, self.width() / 2, 50)
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, str(self.myPhotoTime))
# draw sky cover assessment
destRect.setCoords(10, 25, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, self.skyCover.name + "/" + common.SkyCoverDesc[self.skyCover])
# draw photo rotation
if self.myPhotoRotation != 0:
destRect.setCoords(10, self.height()-25, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "Rotation: " + str(self.myPhotoRotation) + "°")
# where is the mouse relative to the center?
# this is used as an optimization to only display information when mouse is in fisheye portion
dx = self.coordsMouse[0] - self.viewCenter[0]
dy = self.coordsMouse[1] - self.viewCenter[1]
distance = math.sqrt((dx * dx) + (dy * dy)) # distance from mouse to view center
# coordinates we are interested in
#self.coordsMouse # x,y of this widget
coordsxy = (-1, -1) # x,y over photo as scaled/rendered on this widget
coordsXY = (-1, -1) # x,y over actual original photo on disk
coordsUV = (-1, -1) # u,v coords of fisheye portion of photo w/ 0,0 top left and 1,1 bottom right
coordsTP = (-1, -1) # theta,phi polar coordinates
# text
textxy = "-1, -1 xy"
textXY = "-1, -1 xy"
textUV = "-1, -1 uv"
textTP = "-1, -1 θφ"
textPX = "0 0 0 px"
# compute all relevant information only when mouse is within fisheye portion of photo
if distance < self.myPhotoRadius:
coordsxy = (self.coordsMouse[0] - self.myPhotoDestRect.x(),
self.coordsMouse[1] - self.myPhotoDestRect.y())
coordsXY = (int(coordsxy[0] / self.myPhotoDestRect.width() * self.myPhoto.width()),
int(coordsxy[1] / self.myPhotoDestRect.height() * self.myPhoto.height()))
coordsUV = ((self.coordsMouse[0] - self.myPhotoTopLeft[0]) / self.myPhotoDiameter,
(self.coordsMouse[1] - self.myPhotoTopLeft[1]) / self.myPhotoDiameter)
coordsTP = utility_angles.FisheyeUV2SkyCoord(coordsUV[0], coordsUV[1])
# text
textxy = str(coordsxy[0]) + ", " + str(coordsxy[1]) + " xy"
textXY = str(coordsXY[0]) + ", " + str(coordsXY[1]) + " xy"
textUV = "{:.2f}".format(coordsUV[0]) + ", " + "{:.2f}".format(coordsUV[1]) + " uv"
textTP = "{:.2f}".format(coordsTP[0]) + ", " + "{:.2f}".format(coordsTP[1]) + " θφ"
# pixels colors
pixreg = common.AppSettings["PixelRegion"]
colorsRegion = np.zeros((pixreg, pixreg, 4))
colorFinal = colorsRegion[0,0] # RGBA of pixel under mouse of photo on disk
# colorFinal = self.myPhoto.pixelColor(coordsXY[0], coordsXY[1])
if distance < self.myPhotoRadius:
halfdim = int(pixreg / 2)
rstart = coordsXY[1]-halfdim
rstop = coordsXY[1]+halfdim+1
cstart = coordsXY[0]-halfdim
cstop = coordsXY[0]+halfdim+1
if (rstart >= 0 and rstop<=self.myPhotoPixels.shape[0] and
cstart >= 0 and cstop<=self.myPhotoPixels.shape[1]):
colorsRegion = self.myPhotoPixels[rstart:rstop, cstart:cstop]
colorFinal = colorsRegion[halfdim, halfdim]
if pixreg > 1: # with pixel weighting
colorFinal = utility_data.collectPixels([coordsXY], [pixreg], pixels=self.myPhotoPixels, weighting=common.PixelWeighting(common.AppSettings["PixelWeighting"]))[0]
textPX = str(colorFinal[0]) + " " + str(colorFinal[1]) + " " + str(colorFinal[2]) + " px"
# draw HUD text strings
# x,y coords
destRect.setCoords(0, 0, self.width() - 10, self.height()- 124)
painter.drawText(destRect, Qt.AlignBottom | Qt.AlignRight, textxy)
# X,Y coords
destRect.setCoords(0, 0, self.width() - 10, self.height() - 114)
painter.drawText(destRect, Qt.AlignBottom | Qt.AlignRight, textXY)
# u,v coords
destRect.setCoords(0, 0, self.width() - 10, self.height() - 104)
painter.drawText(destRect, Qt.AlignBottom | Qt.AlignRight, textUV)
# t,p coords
destRect.setCoords(0, 0, self.width() - 10, self.height() - 94)
painter.drawText(destRect, Qt.AlignBottom | Qt.AlignRight, textTP)
# pixel color
destRect.setCoords(0, 0, self.width() - 10, self.height() - 84)
painter.drawText(destRect, Qt.AlignBottom | Qt.AlignRight, textPX)
# compute pixel visualization coordinates
circleX = self.width() - 10 - ViewFisheye.SelectedPixelBox - 10 - ViewFisheye.SelectedPixelBox - 10 - ViewFisheye.SelectedPixelBox
circleY = self.height() - 10 - ViewFisheye.SelectedPixelBox
pixelsX = self.width() - 10 - ViewFisheye.SelectedPixelBox - 10 - ViewFisheye.SelectedPixelBox
pixelsY = self.height() - 10 - ViewFisheye.SelectedPixelBox
pixelsWeightedX = self.width() - ViewFisheye.SelectedPixelBox - 10
pixelsWeightedY = self.height() - 10 - ViewFisheye.SelectedPixelBox
# draw pixel visualization - fills
pixreg = common.AppSettings["PixelRegion"]
if distance < self.myPhotoRadius:
painter.setPen(Qt.NoPen)
# pixel region
pixdim = ViewFisheye.SelectedPixelBox / pixreg
for row in range(0, pixreg):
for col in range(0, pixreg):
color = colorsRegion[row, col]
color = QColor(color[0], color[1], color[2])
painter.setBrush(QBrush(color, Qt.SolidPattern))
painter.drawRect(pixelsX + (col * pixdim), pixelsY + (row * pixdim), math.ceil(pixdim), math.ceil(pixdim))
# final pixel color
color = QColor(colorFinal[0], colorFinal[1], colorFinal[2])
painter.setBrush(QBrush(color, Qt.SolidPattern))
cx = circleX + (coordsUV[0] * ViewFisheye.SelectedPixelBox)
cy = circleY + (coordsUV[1] * ViewFisheye.SelectedPixelBox)
painter.drawEllipse(cx - 5, cy - 5, 10, 10)
painter.drawRect(pixelsWeightedX, pixelsWeightedY, ViewFisheye.SelectedPixelBox, ViewFisheye.SelectedPixelBox)
# draw pixel visualization - outlines
painter.setPen(self.penText)
painter.setBrush(Qt.NoBrush)
painter.drawEllipse(circleX, circleY, ViewFisheye.SelectedPixelBox, ViewFisheye.SelectedPixelBox)
painter.drawRect(pixelsX, pixelsY, ViewFisheye.SelectedPixelBox, ViewFisheye.SelectedPixelBox)
painter.drawRect(pixelsWeightedX, pixelsWeightedY, ViewFisheye.SelectedPixelBox, ViewFisheye.SelectedPixelBox)
# raw data missing indicator
# if (not self.rawAvailable):
# painter.drawPixmap(pixelX + ViewFisheye.SelectedPixelBox / 2,
# pixelY + ViewFisheye.SelectedPixelBox / 2,
# self.iconWarning)
# end draw
painter.end()
class GameField:
def __init__(self, size, scene: QGraphicsScene):
self.rectItems = []
self.pixmap = QPixmap(QSize(820,820))
self.painter = QPainter(self.pixmap)
self.scene = scene
self.owners = None
self.values = None
pen = QPen()
pen.setStyle(Qt.NoPen)
for index in range(size**2):
item = QGraphicsRectItem()
item.setRect(int(index/size), int(index%size), 0.9, 0.9)
item.setPen(pen)
scene.addItem(item)
self.rectItems.append(item)
@pyqtSlot(int, np.ndarray, np.ndarray)
def update(self, size, owners, values):
own = list(np.unique(owners))[1:]
noBrush = QBrush(Qt.NoBrush)
first = False
if self.owners is None or self.values is None:
first = True
self.owners = owners
self.values = values
for index, owner, value, cur_owner, cur_value in zip(range(size**2), owners.flat, values.flat, self.owners.flat, self.values.flat):
if first or (cur_owner != owner or cur_value != value):
if owner == 0:
brush = noBrush
else:
k = colors[own.index(owner)]
color = QtGui.QColor(k[0], k[1], k[2], int(255./np.max(values)*value) if owner >= 1000 else 255)
brush = QBrush(color)
item = self.rectItems[index]
item.setBrush(brush)
self.owners = owners
self.values = values
self.scene.update(self.scene.sceneRect())
def outputPng(self):
view = scene.views()[0]
self.pixmap.fill(Qt.white)
self.painter.setBackground(Qt.white)
self.painter.setRenderHints(QtGui.QPainter.HighQualityAntialiasing)
scene.render(self.painter, QRectF(10,10,800,800), QRectF(0,0,size,size))
self.pixmap.save("out/state.png")
def outputScorePage(self, owners, values, names, ids):
with open('out/index.html', 'w') as f:
f.write("""<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" \"http://www.w3.org/TR/html4/strict.dtd\">\n
<html>\n
\t<head>\n
\t\t<title>GPN16: Blobs</title>\n
\t\t<style>\n
\t\t\ttable\n
\t\t\t{\n
\t\t\t\tborder-collapse:collapse;\n
\t\t\t\twidth:100%;\n
\t\t\t}\n
\t\t\tth,td\n
\t\t\t{\n
\t\t\t\ttext-align:left;\n
\t\t\t\tpadding:8px;\n
\t\t\t}\n
\t\t\ttr:nth-child(even)\n
\t\t\t{\n
\t\t\t\tbackground-color:#f2f2f2;\n
\t\t\t}\n
\t\t\tth\n
\t\t\t{\n
\t\t\t\tbackground-color:#600000;\n
\t\t\t\tcolor:white\n
\t\t\t}\n
\t\t</style>\n
\t</head>\n
\t<body>\n
\t\t<h2><a href=\"http://www.gulas.ch\">GPN16</a>: <a href=\"http://www.github.com/scummos/blobs\">Blobs</a>$ Lobby</h2>\n
\t\t<center>\n
\t\t\t<img src=logo.svg /><br />\n
\t\t\t<img src=state.png /><br />\n
\t\t</center>\n
\t\t<table>\n
\t\t\t<tr>\n
\t\t\t\t<th>Rank</th>\n
\t\t\t\t<th>Bot name</th>\n
\t\t\t\t<th>Score</th>\n
\t\t\t</tr>\n""");
#TODO: output ramsh here
f.write("""\t\t</table>\n
\t</body>\n
</html>\n""")
f.close()
class GameField:
def __init__(self, size, scene: QGraphicsScene):
self.rectItems = []
self.pixmap = QPixmap(QSize(820, 820))
self.painter = QPainter(self.pixmap)
self.scene = scene
self.owners = None
self.values = None
pen = QPen()
pen.setStyle(Qt.NoPen)
for index in range(size**2):
item = QGraphicsRectItem()
item.setRect(int(index / size), int(index % size), 0.9, 0.9)
item.setPen(pen)
scene.addItem(item)
self.rectItems.append(item)
@pyqtSlot(int, np.ndarray, np.ndarray)
def update(self, size, owners, values):
own = list(np.unique(owners))[1:]
noBrush = QBrush(Qt.NoBrush)
first = False
if self.owners is None or self.values is None:
first = True
self.owners = owners
self.values = values
for index, owner, value, cur_owner, cur_value in zip(
range(size**2), owners.flat, values.flat, self.owners.flat,
self.values.flat):
if first or (cur_owner != owner or cur_value != value):
if owner == 0:
brush = noBrush
else:
k = colors[own.index(owner)]
color = QtGui.QColor(
k[0], k[1], k[2],
int(255. / np.max(values) *
value) if owner >= 1000 else 255)
brush = QBrush(color)
item = self.rectItems[index]
item.setBrush(brush)
self.owners = owners
self.values = values
self.scene.update(self.scene.sceneRect())
def outputPng(self):
view = scene.views()[0]
self.pixmap.fill(Qt.white)
self.painter.setBackground(Qt.white)
self.painter.setRenderHints(QtGui.QPainter.HighQualityAntialiasing)
scene.render(self.painter, QRectF(10, 10, 800, 800),
QRectF(0, 0, size, size))
self.pixmap.save("out/state.png")
def outputScorePage(self, owners, values, names, ids):
with open('out/index.html', 'w') as f:
f.write(
"""<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" \"http://www.w3.org/TR/html4/strict.dtd\">\n
<html>\n
\t<head>\n
\t\t<title>GPN16: Blobs</title>\n
\t\t<style>\n
\t\t\ttable\n
\t\t\t{\n
\t\t\t\tborder-collapse:collapse;\n
\t\t\t\twidth:100%;\n
\t\t\t}\n
\t\t\tth,td\n
\t\t\t{\n
\t\t\t\ttext-align:left;\n
\t\t\t\tpadding:8px;\n
\t\t\t}\n
\t\t\ttr:nth-child(even)\n
\t\t\t{\n
\t\t\t\tbackground-color:#f2f2f2;\n
\t\t\t}\n
\t\t\tth\n
\t\t\t{\n
\t\t\t\tbackground-color:#600000;\n
\t\t\t\tcolor:white\n
\t\t\t}\n
\t\t</style>\n
\t</head>\n
\t<body>\n
\t\t<h2><a href=\"http://www.gulas.ch\">GPN16</a>: <a href=\"http://www.github.com/scummos/blobs\">Blobs</a>$ Lobby</h2>\n
\t\t<center>\n
\t\t\t<img src=logo.svg /><br />\n
\t\t\t<img src=state.png /><br />\n
\t\t</center>\n
\t\t<table>\n
\t\t\t<tr>\n
\t\t\t\t<th>Rank</th>\n
\t\t\t\t<th>Bot name</th>\n
\t\t\t\t<th>Score</th>\n
\t\t\t</tr>\n""")
#TODO: output ramsh here
f.write("""\t\t</table>\n
\t</body>\n
</html>\n""")
f.close()
class LGPdfWriter(QPrinter):
def __init__(self, name: str):
super(LGPdfWriter, self).__init__()
if not self.touch(name):
raise PermissionError("Cannot open "+name)
self.setOutputFileName(name)
self.setOutputFormat(self.PdfFormat)
self.setPageSize(self.A4)
#self.setPageSizeMM(QSizeF(2100,2970))
self._rot = QPen(QColor(255,0,0))
self._blau = QPen(QColor(0,0,255))
self._grün = QPen(QColor(0,255,0))
self._schwarz = QPen(QColor(0,0,0))
self._weis = QPen(QColor(255, 255, 255))
self._fg = self._schwarz
self._fg.setWidth(3)
self._bg = QPen(QColor(0,0,0))
self._bg.setWidth(3)
self._fgs = QPen(QColor(190, 190, 190))
self._fgs.setWidth(3)
self._sg = QColor(180, 20, 51)
self._painter = QPainter(self)
self._painter.setBackground(QColor(255, 255, 255))
self._font = QFont("Arial", 20, QFont.Bold, True)
#bordersize = 20/40mm
def touch(self,filename)->bool:
basedir = os.path.dirname(filename)
if not os.path.exists(basedir):
os.makedirs(basedir)
try:
with open(filename, 'a'):
os.utime(filename, None)
except PermissionError as e:
entscheidung = QMessageBox.question(None,
"Keine Schreibberechtigung","Keine Schreibberechtigung für Datei <br><b>{}</b><br>Bitte die Datei schließen und dann fortfahren.<br><b>Fortfahren?</b>".format(filename),
QMessageBox.Yes|QMessageBox.No,QMessageBox.Yes)
if entscheidung == QMessageBox.Yes:
return self.touch(filename)
else:
return False
else:
return True
def line(self, start: QPointF, ende: QPointF, shaded: int=0) -> None:
if shaded:
diff = 2 if isinstance(shaded,bool) and shaded == True else shaded
self._painter.setPen(self._fgs)
self._painter.drawLine(start + diff, ende + diff)
self._painter.setPen(self._fg)
self._painter.drawLine(start, ende)
def rect(self, rect: QRectF, shaded: int=0) -> None:
if shaded:
diff = 6 if isinstance(shaded,bool) and shaded == True else shaded
self._painter.setPen(self._fgs)
rect.translate(diff, diff)
self._painter.drawRect(rect)
rect.translate(-diff, -diff)
self._painter.setPen(self._bg)
self._painter.drawRect(rect)
def text(self, text: str, pos: QRectF, color: QColor=None, size: int=20, shaded: int=0,
bold: bool=False,shrinkToFit=10) -> None:
if not isinstance(text,str):
text = "{}".format(text)
self._font.setPointSize(size)
if bold:
self._font.setWeight(QFont.Black)
else:
self._font.setWeight(QFont.Bold)
self._painter.setFont(self._font)
fm = QFontMetrics(self._font)
if pos.width() == 0:
pos.setWidth(fm.width(text))
if pos.height() == 0:
pos.setHeight(fm.height())
if size > shrinkToFit:
#
if fm.width(text) > pos.width() or fm.height() > pos.height()+2:
self.text(text,pos,color,size-1,shaded,bold,shrinkToFit)
return
if shaded:
diff = size//4 if isinstance(shaded,bool) and shaded == True else shaded
self._painter.setPen(self._fgs)
pos2 = pos.translated(diff, diff)
self._painter.drawText(pos2, Qt.AlignCenter, text)
p = QPen(color if color is not None else self._fg)
self._painter.setPen(p)
self._painter.drawText(pos, Qt.AlignCenter, text)
def image(self, img: str, pos: QRectF, shaded: int=0):
img = QImage(img)
imgSize = QRectF(0, 0, img.width(), img.height())
if shaded:
diff = 10 if isinstance(shaded,bool) and shaded == True else shaded
pos2 = pos.translated(diff,diff)
self._painter.drawImage(pos2, img, imgSize, Qt.MonoOnly)
self._painter.drawImage(pos, img)
def table(self,
rect: QRectF,
lineData: list=None,
columnCount: int=0,
rowCount:int=0,
w: dict=None,
h: dict=None,
size:int=18,
border:bool=True) -> None:
#lineData: [{x:1,y:2,text:"hallo"}...]
# oder [{x:[1,3],y:[2,4],text."hallo"}..]
for id in range(len(lineData)):
if not isinstance(lineData[id], dict):
lineData[id] = {"text": "{}".format(lineData[id])}
if w is None:
w = dict()
if h is None:
h = dict()
#Berechne Reservierte Größen
reserved = {"w": 0, "h": 0}
for wr in w.values():
reserved["w"] += wr
for hr in h.values():
reserved["h"] += hr
#Berechne Zellengrößen
marginX = 5
marginY = 5
remCol = columnCount - len(w)
remRow = rowCount - len(h)
regularWidth = (rect.width() - reserved["w"] - (columnCount + 1) * marginX) / remCol
regularHeight = (rect.height() - reserved["h"] - (rowCount + 1) * marginY) / remRow
def calcCellUsage() -> list:
index = 0
pos = []
for column in range(columnCount):
l = list()
for row in range(rowCount):
l.append(None)
pos.append(l)
curX = 0
curY = 0
for i in lineData:
if "x" in i.keys():
x = i["x"]
if isinstance(x, int):
x = range(x, x + 1)
elif isinstance(x, tuple):
x = range(x[0], x[-1] + 1)
else:
x = range(curX, curX + 1)
i["x"] = x
if "y" in i.keys():
y = i["y"]
if isinstance(y, int):
y = range(y, y + 1)
elif isinstance(y, tuple):
x = range(y[0], y[-1] + 1)
else:
y = range(curY, curY + 1)
i["y"] = y
curX = x[-1] + 1
curY = y[-1]
if curX >= columnCount:
curX = 0
curY += 1
for xx in x:
for yy in y:
pos[xx][yy] = index
index += 1
return pos
def calcWidth(col:int) -> float:
try:
if col in w.keys():
return w[col]
except IndexError:
pass
return regularWidth
def calcHeight(row:int) -> float:
try:
if row in h.keys():
return h[row]
except IndexError:
pass
return regularHeight
def calcCellSize(col:int, row: int) -> tuple:
if col >= columnCount:
raise IndexError
if row >= rowCount:
raise IndexError
if pos[col][row] is None:
raise IndexError
width = calcWidth(col)
height = calcHeight(row)
id = pos[col][row]
try:
if pos[col + 1][row] is id:
width += calcCellSize(col + 1, row)[0] + marginX
except IndexError:
pass
try:
if pos[col][row + 1] is id:
height += calcCellSize(col, row + 1)[1] + marginY
except IndexError:
pass
return width, height
def calcCumulativeWidth(col: int) -> float:
if col is 0:
return marginX
x = calcWidth(col - 1) + marginX + calcCumulativeWidth(col - 1)
return x
def calcCumulativeHeight(row: int) -> float:
if row is 0:
return marginY
return calcHeight(row - 1) + marginY + calcCumulativeHeight(row - 1)
def calcCell(index: int) -> tuple:
x = lineData[index]["x"]
if not isinstance(x, int):
x = x[0]
y = lineData[index]["y"]
if not isinstance(y, int):
y = y[0]
left = rect.left() + calcCumulativeWidth(x)
top = rect.top() + calcCumulativeHeight(y)
d = calcCellSize(x, y)
return left, top, d[0], d[1]
def getFontOptions(index: int) -> dict:
data = {
"size": size,
"color": self._fg,
"shaded": False,
"bold": False
}
elem = lineData[index]
if "size" in elem.keys():
data["size"] = elem["size"]
if "color" in elem.keys():
data["color"] = elem["color"]
if "shaded" in elem.keys():
data["shaded"] = elem["shaded"]
if "bold" in elem.keys():
data["bold"] = elem["bold"]
return data
if border:
self.rect(rect, False)
pos = calcCellUsage()
for elem in range(len(lineData)):
r = QRectF(*calcCell(elem))
if border:
self.rect(r, False)
self.text(lineData[elem]["text"], r, **getFontOptions(elem))
def end(self):
self._painter.end()
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.end()
