def buildCharPreview(self):
char = self.selectedChar - self.charFrom.value()
if char < 0:
char = 0
if char >= len(self.charSizes):
char = len(self.charSizes) - 1
k = 5
s_x = self.charSizes[char][0]
w = self.charSizes[char][1]
charPix = self.chars.pixmap()
charImage = charPix.toImage()
self.charPreview.resize(w * k + 1, charPix.height() * k + 1)
pix = QPixmap(w * k, charPix.height() * k)
p = QPainter()
p.begin(pix)
p.setBrush(QBrush(QColor(0xffffff), Qt.SolidPattern))
p.drawRect(0, 0, pix.width() - 1, pix.height() - 1)
p.setBrush(QBrush(QColor(0x0), Qt.SolidPattern))
for x in range(w):
for y in range(charPix.height()):
if QColor(charImage.pixel(s_x + x, y)).lightness() == 0x0:
p.drawRect(x * k, y * k, k, k)
p.end()
self.charPreview.setPixmap(pix)
def paintEvent(self, e): qp = QPainter() qp.begin(self) qp.setBrush(QColor(200, 0, 0)) qp.drawEllipse(0,0,50,50) qp.setPen(QColor(0, 0, 0)) qp.drawText(e.rect(), Qt.AlignVCenter,str(self.node.heuristicValue))
def paintEvent(self, event):
logger.debug("paintEvent: {0} - {1}".format(self, event.rect()))
qp = QPainter()
qp.begin(self)
width = self.size().width() - 1
height = self.size().height() - 1
#draw border
qp.setPen(self.border_color)
qp.drawLine(0, 0, width, 0)
qp.drawLine(0, 0, 0, height)
qp.drawLine(width, 0, width, height)
qp.drawLine(0, height, width, height)
#draw plot
width -= 1
height -= 1
if len(self.data):
qp.setPen(self.plot_color)
max_val = max(self.data)
points = list();
for index in range(len(self.data)-1, 1, -1):
points.append(QPoint((width / 100 * index), height - (height / max_val * self.data[index])))
points.append(QPoint(1, height))
points.append(QPoint(width, height))
qp.setBrush(self.plot_color)
qp.drawPolygon(*points)
qp.end()
logger.debug("paintEvent End: {0}".format(self))
def _get_pos_widget(name, backgroundColor, foregroundColor):
label = QLabel()
label.setAttribute(Qt.WA_TransparentForMouseEvents, True)
pixmap = QPixmap(25 * 10, 25 * 10)
pixmap.fill(backgroundColor)
painter = QPainter()
painter.begin(pixmap)
pen = QPen(foregroundColor)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing)
font = QFont()
font.setBold(True)
font.setPixelSize(25 * 10 - 30)
path = QPainterPath()
path.addText(QPointF(50, 25 * 10 - 50), font, name)
brush = QBrush(foregroundColor)
painter.setBrush(brush)
painter.drawPath(path)
painter.setFont(font)
painter.end()
pixmap = pixmap.scaled(QSize(20, 20), Qt.KeepAspectRatio, Qt.SmoothTransformation)
label.setPixmap(pixmap)
spinbox = DelayedSpinBox(750)
spinbox.setAlignment(Qt.AlignCenter)
spinbox.setToolTip("{0} Spin Box".format(name))
spinbox.setButtonSymbols(QAbstractSpinBox.NoButtons)
spinbox.setMaximumHeight(20)
font = spinbox.font()
font.setPixelSize(14)
spinbox.setFont(font)
sheet = TEMPLATE.format(foregroundColor.name(), backgroundColor.name())
spinbox.setStyleSheet(sheet)
return label, spinbox
def paintEvent(self, e): # Событие перерисовки окна
qp = QPainter()
qp.begin(self)
self.DrawLines(qp) # Отрисовка ребер
self.drawVertex(qp) # Отрисовка вершин
self.MoveButton(qp) # Перемещение кнопки в правый нижний угол
qp.end()
def paintEvent(self, event):
logger.debug("paintEvent: {0} - {1}".format(self, event.rect()))
qp = QPainter()
qp.begin(self)
width = self.size().width() - 1
height = self.size().height() - 1
#draw border
qp.setPen(self.border_color)
qp.drawRect(0,0, width, height)
#draw plot
width -= 1
height -= 1
if len(self.data):
max_val = max(map(lambda x: x[-1], self.data))
plots = [list() for _ in range(self.num_data_points) ]
for index in range(len(self.data)-1, 1, -1):
for inner_index in range(self.num_data_points):
plots[inner_index].append(QPoint((width / self.data.maxlen * index),
height - (height / max_val * self.data[index][inner_index])))
for x in range(len(plots)-1, -1, -1):
qp.setPen(self.plot_colors[x])
qp.setBrush(self.plot_colors[x])
points = plots[x]
points.append(QPoint(1, height))
points.append(QPoint(width, height))
qp.drawPolygon(*points)
qp.end()
logger.debug("paintEvent End: {0}".format(self))
def paintEvent(self, event):
logger.debug("paintEvent: {0} - {1}".format(self, event.rect()))
qp = QPainter()
qp.begin(self)
width = self.size().width() - 1
height = self.size().height() - 1
#draw border
qp.setPen(self.border_color)
qp.drawLine(0, 0, width, 0)
qp.drawLine(0, 0, 0, height)
qp.drawLine(width, 0, width, height)
qp.drawLine(0, height, width, height)
#draw bar
width -= 2
height -= 2
value = orig_value = self.data_source()
value = min(self.max_range, value)
value = max(self.min_range, value)
qp.setPen(self.bar_color)
qp.setBrush(self.bar_color)
if self.orientation == 'horizontal':
qp.drawRect(1, 1,
width / self.max_range * value, height)
else:
qp.drawRect(1, height - (height / self.max_range * value), width, height)
qp.setPen(self.border_color)
qp.drawText(event.rect(), Qt.AlignCenter, str(orig_value))
qp.end()
logger.debug("paintEvent End: {0}".format(self))
def __grabRegion(self):
"""
Private method to grab the selected region (i.e. do the snapshot).
"""
pol = QPolygon(self.__selection)
if not pol.isEmpty():
self.__grabbing = True
xOffset = self.__pixmap.rect().x() - pol.boundingRect().x()
yOffset = self.__pixmap.rect().y() - pol.boundingRect().y()
translatedPol = pol.translated(xOffset, yOffset)
pixmap2 = QPixmap(pol.boundingRect().size())
pixmap2.fill(Qt.transparent)
pt = QPainter()
pt.begin(pixmap2)
if pt.paintEngine().hasFeature(QPaintEngine.PorterDuff):
pt.setRenderHints(
QPainter.Antialiasing |
QPainter.HighQualityAntialiasing |
QPainter.SmoothPixmapTransform,
True)
pt.setBrush(Qt.black)
pt.setPen(QPen(QBrush(Qt.black), 0.5))
pt.drawPolygon(translatedPol)
pt.setCompositionMode(QPainter.CompositionMode_SourceIn)
else:
pt.setClipRegion(QRegion(translatedPol))
pt.setCompositionMode(QPainter.CompositionMode_Source)
pt.drawPixmap(pixmap2.rect(), self.__pixmap, pol.boundingRect())
pt.end()
self.grabbed.emit(pixmap2)
def paintEvent(self, QPaintEvent):
qp = QPainter()
image = QImage("default.png")
image = image.scaled(32, 32)
sky_image = QImage("sky.png")
qp.begin(self)
qp.drawImage(0, 0, sky_image)
for obj in game_manager.GameManager.get_all_objects():
pos = obj.get_position()
size = obj.get_size()
#if isinstance(obj, object.MovingObject):
#qp.setPen(QColor(0, 0, 0))
#else:
#qp.setPen(QColor(255, 0, 0))
if obj is object.Bullet:
pass
if isinstance(obj, object.Unit):
qp.drawImage(pos.x + START_PLAYER_POSITION[0] - game_manager.GameManager.player.get_position().x,
pos.y + START_PLAYER_POSITION[1] - game_manager.GameManager.player.get_position().y,
image)
else:
qp.drawRect(pos.x + START_PLAYER_POSITION[0] - game_manager.GameManager.player.get_position().x,
pos.y + START_PLAYER_POSITION[1] - game_manager.GameManager.player.get_position().y,
size.x, size.y)
#qp.setPen(QColor(255, 0, 0))
#for x in game_manager.GameManager.get_map().grid.keys():
#for y in game_manager.GameManager.get_map().grid[x].keys():
#qp.drawRect(x + START_PLAYER_POSITION[0] - game_manager.GameManager.player.get_position().x,
#y + START_PLAYER_POSITION[1] - game_manager.GameManager.player.get_position().y,
#TILE_LENGHT, TILE_LENGHT)
qp.end()
def drawIndicatorIcon(palette, style):
pix = QPixmap(14, 14)
pix.fill(Qt.transparent)
branchOption = QStyleOption()
#r = QRect(QPoint(0, 0), pix.size())
branchOption.rect = QRect(2, 2, 9, 9) ## ### hardcoded in qcommonstyle.cpp
branchOption.palette = palette
branchOption.state = QStyle.State_Children
p = QPainter()
## Draw closed state
p.begin(pix)
style.drawPrimitive(QStyle.PE_IndicatorBranch, branchOption, p)
p.end()
rc = QIcon(pix)
rc.addPixmap(pix, QIcon.Selected, QIcon.Off)
## Draw opened state
branchOption.state |= QStyle.State_Open
pix.fill(Qt.transparent)
p.begin(pix)
style.drawPrimitive(QStyle.PE_IndicatorBranch, branchOption, p)
p.end()
rc.addPixmap(pix, QIcon.Normal, QIcon.On)
rc.addPixmap(pix, QIcon.Selected, QIcon.On)
return rc
def drawROIBoxes(self, image):
#print(self.frame_data)
if not isinstance(self.frame_data, pd.DataFrame) or len(self.frame_data) == 0 \
or not self.label_type in self.frame_data:
return
self.img_h_ratio = image.height()/self.image_height;
self.img_w_ratio = image.width()/self.image_width;
painter = QPainter()
painter.begin(image)
for row_id, row_data in self.frame_data.iterrows():
x = row_data['coord_x']*self.img_h_ratio
y = row_data['coord_y']*self.img_w_ratio
#check if the coordinates are nan
if not (x == x) or not (y == y):
continue
x = int(x)
y = int(y)
c = self.wlabC[int(row_data[self.label_type])]
painter.setPen(c)
painter.setFont(QFont('Decorative', 10))
painter.drawText(x, y, str(int(row_data[self.worm_index_type])))
bb = row_data['roi_size']*self.img_w_ratio
painter.drawRect(x-bb/2, y-bb/2, bb, bb);
painter.end()
def paintEvent(self, e):
print("Paint event")
qp = QPainter()
qp.begin(self)
self.drawRectangles(qp)
qp.end()
def paintEvent(self, event):
background = QRadialGradient(QPointF(self.rect().topLeft()), 500,
QPointF(self.rect().bottomRight()))
background.setColorAt(0, self.backgroundColor1)
background.setColorAt(1, self.backgroundColor2)
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(event.rect(), QBrush(background))
painter.setPen(self.pen)
for bubble in self.bubbles:
if QRectF(bubble.position - QPointF(bubble.radius, bubble.radius),
QSizeF(2*bubble.radius, 2*bubble.radius)).intersects(QRectF(event.rect())):
bubble.drawBubble(painter)
if self.newBubble:
self.newBubble.drawBubble(painter)
painter.end()
def mousePressEvent(self, event):
child = self.childAt(event.pos())
if not child:
return
pixmap = QPixmap(child.pixmap())
itemData = QByteArray()
dataStream = QDataStream(itemData, QIODevice.WriteOnly)
dataStream << pixmap << QPoint(event.pos() - child.pos())
mimeData = QMimeData()
mimeData.setData('application/x-dnditemdata', itemData)
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(pixmap)
drag.setHotSpot(event.pos() - child.pos())
tempPixmap = QPixmap(pixmap)
painter = QPainter()
painter.begin(tempPixmap)
painter.fillRect(pixmap.rect(), QColor(127, 127, 127, 127))
painter.end()
child.setPixmap(tempPixmap)
if drag.exec_(Qt.CopyAction | Qt.MoveAction, Qt.CopyAction) == Qt.MoveAction:
child.close()
else:
child.show()
child.setPixmap(pixmap)
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
qp.setPen (QPen(QColor(0,0,0,0)))
ysize, xsize = self.layout.shape
canvas = self.contentsRect()
for y in range(ysize):
for x in range(xsize):
qp.setBrush(self.colors[self.layout.grid[y][x]])
qp.drawRect(TILE_SIZE * x, TILE_SIZE * y, TILE_SIZE, TILE_SIZE)
#Color(rgb=self.colors[self.layout.grid[y][x]])
#Rectangle(pos=(TILE_SIZE * x, TILE_SIZE * y), size=(TILE_SIZE, TILE_SIZE))
pac_x = self.current_game_state.agents[0].position[0] * TILE_SIZE
pac_y = self.current_game_state.agents[0].position[1] * TILE_SIZE
qp.setBrush(QBrush(QColor(255,255,0)))
qp.drawEllipse(pac_x, pac_y, TILE_SIZE, TILE_SIZE)
for g in self.current_game_state.agents[1:]:
g_x = g.position[0] * TILE_SIZE
g_y = g.position[1] * TILE_SIZE
qp.setBrush(QBrush(QColor(255,0,0)))
qp.drawEllipse(g_x, g_y, TILE_SIZE, TILE_SIZE)
for y in range(ysize):
for x in range(xsize):
if self.current_game_state.food[y][x]:
qp.setBrush(QBrush(QColor(255,255,255)))
qp.drawEllipse(x * TILE_SIZE + TILE_SIZE / 2,
y * TILE_SIZE + TILE_SIZE / 2,
TILE_SIZE / 4, TILE_SIZE / 4)
qp.end()
def __init__(self, text, parent):
super(DragLabel, self).__init__(parent)
metric = QFontMetrics(self.font())
size = metric.size(Qt.TextSingleLine, text)
image = QImage(size.width() + 12, size.height() + 12, QImage.Format_ARGB32_Premultiplied)
image.fill(qRgba(0, 0, 0, 0))
font = QFont()
font.setStyleStrategy(QFont.ForceOutline)
painter = QPainter()
painter.begin(image)
painter.setRenderHint(QPainter.Antialiasing)
painter.setBrush(Qt.white)
painter.drawRoundedRect(QRectF(0.5, 0.5, image.width() - 1, image.height() - 1), 25, 25, Qt.RelativeSize)
painter.setFont(font)
painter.setBrush(Qt.black)
painter.drawText(QRect(QPoint(6, 6), size), Qt.AlignCenter, text)
painter.end()
self.setPixmap(QPixmap.fromImage(image))
self.labelText = text
def updateFilledCircle(self, s):
size = s * self.zoom
pixmap = QPixmap(self.width(), self.height())
pixmap.fill(Qt.transparent)
#painter filled ellipse
p = QPalette()
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHint(QPainter.Antialiasing)
brush = QBrush(p.link().color())
painter.setBrush(brush)
painter.setOpacity(0.4)
painter.drawEllipse(QRect(old_div(self.width(),2) - old_div(size,2), old_div(self.height(),2) - old_div(size,2), size, size))
painter.end()
#painter ellipse 2
painter2 = QPainter()
painter2.begin(pixmap)
painter2.setRenderHint(QPainter.Antialiasing)
pen2 = QPen(Qt.green)
pen2.setWidth(1)
painter2.setPen(pen2)
painter2.drawEllipse(QRect(old_div(self.width(),2) - old_div(size,2), old_div(self.height(),2) - old_div(size,2), size, size))
painter2.end()
self.ellipseLabel.setPixmap(QPixmap(pixmap))
self.lastSize = s
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 paintQR(self, data):
if not data:
return
qr = qrcode.QRCode()
qr.add_data(data)
matrix = qr.get_matrix()
k = len(matrix)
border_color = Qt.white
base_img = QImage(k * 5, k * 5, QImage.Format_ARGB32)
base_img.fill(border_color)
qrpainter = QPainter()
qrpainter.begin(base_img)
boxsize = 5
size = k * boxsize
left = (base_img.width() - size)/2
top = (base_img.height() - size)/2
qrpainter.setBrush(Qt.black)
qrpainter.setPen(Qt.black)
for r in range(k):
for c in range(k):
if matrix[r][c]:
qrpainter.drawRect(left+c*boxsize, top+r*boxsize, boxsize - 1, boxsize - 1)
qrpainter.end()
return base_img
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
qp.setRenderHints(QPainter.Antialiasing, True)
self.doDrawing(qp)
qp.end()
def make_cypherseed(self, img, rawnoise, calibration=False, is_seed = True):
img = img.convertToFormat(QImage.Format_Mono)
p = QPainter()
p.begin(img)
p.setCompositionMode(26) #xor
p.drawImage(0, 0, rawnoise)
p.end()
cypherseed = self.pixelcode_2x2(img)
cypherseed = QBitmap.fromImage(cypherseed)
cypherseed = cypherseed.scaled(self.f_size, Qt.KeepAspectRatio)
cypherseed = self.overlay_marks(cypherseed, True, calibration)
if not is_seed:
self.filename_prefix = 'custom_secret_'
self.was = _('Custom secret')
else:
self.filename_prefix = self.wallet_name + '_seed_'
self.was = self.wallet_name + ' ' + _('seed')
if self.extension:
self.ext_warning(self.c_dialog)
if not calibration:
self.toPdf(QImage(cypherseed))
QDesktopServices.openUrl(QUrl.fromLocalFile(self.get_path_to_revealer_file('.pdf')))
cypherseed.save(self.get_path_to_revealer_file('.png'))
self.bcrypt(self.c_dialog)
return cypherseed
def calibration_pdf(self, image):
printer = QPrinter()
printer.setPaperSize(QSizeF(210, 297), QPrinter.Millimeter)
printer.setResolution(600)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(self.get_path_to_calibration_file())
printer.setPageMargins(0,0,0,0,6)
painter = QPainter()
painter.begin(printer)
painter.drawImage(553,533, image)
font = QFont('Source Sans Pro', 10, QFont.Bold)
painter.setFont(font)
painter.drawText(254,277, _("Calibration sheet"))
font = QFont('Source Sans Pro', 7, QFont.Bold)
painter.setFont(font)
painter.drawText(600,2077, _("Instructions:"))
font = QFont('Source Sans Pro', 7, QFont.Normal)
painter.setFont(font)
painter.drawText(700, 2177, _("1. Place this paper on a flat and well iluminated surface."))
painter.drawText(700, 2277, _("2. Align your Revealer borderlines to the dashed lines on the top and left."))
painter.drawText(700, 2377, _("3. Press slightly the Revealer against the paper and read the numbers that best "
"match on the opposite sides. "))
painter.drawText(700, 2477, _("4. Type the numbers in the software"))
painter.end()
def setNameAndBrush(self, sigma, color=Qt.black):
self.sigma = sigma
self.setText(f'σ{self.column}'.translate(self.sub_trans))
if self.sigma is not None:
total_window = (1 + 2 * int(self.sigma * self.window_size + 0.5))
self.setToolTip(f'sigma = {sigma:.1f} pixels, window diameter = {total_window:.1f}')
font = QFont()
font.setPointSize(10)
# font.setBold(True)
self.setFont(font)
self.setForeground(color)
pixmap = QPixmap(self.pixmapSize)
pixmap.fill(Qt.transparent)
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setPen(color)
brush = QBrush(color)
painter.setBrush(brush)
painter.drawEllipse(QRect(old_div(self.pixmapSize.width(), 2) - old_div(self.brushSize, 2),
old_div(self.pixmapSize.height(), 2) - old_div(self.brushSize, 2),
self.brushSize, self.brushSize))
painter.end()
self.setIcon(QIcon(pixmap))
self.setTextAlignment(Qt.AlignVCenter)
def drawPixmapFor3d(self):
self.pixmap3d = QPixmap(self.itemWidth, self.itemHeight)
self.pixmap3d.fill(Qt.transparent)
painter = QPainter()
painter.begin(self.pixmap3d)
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen()
pen.setWidth(2)
painter.setPen(pen)
painter.setBrush(QBrush(QColor(220, 220, 220)))
top = [QPoint(5, 10),
QPoint(self.itemWidth - 10, 10),
QPoint(self.itemWidth - 5, 5),
QPoint(10, 5),
QPoint(5, 10)]
painter.drawConvexPolygon(*top)
left = [QPoint(self.itemWidth - 10, 10),
QPoint(self.itemWidth - 10, self.itemHeight - 5),
QPoint(self.itemWidth - 5, self.itemHeight - 10),
QPoint(self.itemWidth - 5, 5),
QPoint(self.itemWidth - 10, 10)]
painter.drawConvexPolygon(*left)
painter.setBrush(QBrush())
painter.drawRect(QRect(5, 10, self.itemWidth - 15, self.itemHeight - 15))
painter.drawText(QRect(5, 10, self.itemWidth - 15, self.itemHeight - 15), Qt.AlignCenter, '3D')
painter.end()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
getWorld().draw(painter)
painter.end()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(event.rect(), QBrush(QColor(255, 255, 255, 127)))
painter.setPen(QPen(Qt.NoPen))
for i in range(6):
x_pos = self.width() / 2 + 30 * \
math.cos(2 * math.pi * i / 6.0) - 10
y_pos = self.height() / 2 + 30 * \
math.sin(2 * math.pi * i / 6.0) - 10
if (self.counter / 5) % 6 == i:
linear_gradient = QLinearGradient(
x_pos + 10, x_pos, y_pos + 10, y_pos)
linear_gradient.setColorAt(0, QColor(135, 206, 250))
linear_gradient.setColorAt(1, QColor(0, 0, 128))
painter.setBrush(QBrush(linear_gradient))
else:
linear_gradient = QLinearGradient(
x_pos - 10, x_pos, y_pos + 10, y_pos)
linear_gradient.setColorAt(0, QColor(105, 105, 105))
linear_gradient.setColorAt(1, QColor(0, 0, 0))
painter.setBrush(QBrush(linear_gradient))
painter.drawEllipse(
x_pos,
y_pos,
20, 20)
painter.end()
def updateCircle(self, s):
size = s * self.zoom
pixmap = QPixmap(self.width(), self.height())
pixmap.fill(Qt.transparent)
#painter ellipse 1
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen(Qt.red)
pen.setWidth(3)
painter.setPen(pen)
brush = QBrush(Qt.green)
painter.setBrush(brush)
painter.drawEllipse(QRect(old_div(self.width(),2) - old_div(size,2), old_div(self.height(),2) - old_div(size,2), size, size))
painter.end()
#painter ellipse 2
painter2 = QPainter()
painter2.begin(pixmap)
painter2.setRenderHint(QPainter.Antialiasing)
pen2 = QPen(Qt.green)
pen2.setStyle(Qt.DotLine)
pen2.setWidth(3)
painter2.setPen(pen2)
painter2.drawEllipse(QRect(old_div(self.width(),2) - old_div(size,2), old_div(self.height(),2) - old_div(size,2), size, size))
painter2.end()
self.ellipseLabel.setPixmap(QPixmap(pixmap))
self.lastSize = s
def paintEvent(self, event):
logger.debug("paintEvent: {0} - {1}".format(self, event.rect()))
qp = QPainter()
qp.begin(self)
self.drawBackground(event, qp)
qp.end()
logger.debug("paintEvent End: " + str(self))
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
self.drawWidget(qp)
qp.end()
super().paintEvent(e)
def paintEvent(self, event):
"""Qt method override to paint a custom image on the Widget."""
super(FigureCanvas, self).paintEvent(event)
qp = QPainter()
qp.begin(self)
# Prepare paint rect :
fw = self.frameWidth()
rect = QRect(0 + fw, 0 + fw,
self.size().width() - 2 * fw,
self.size().height() - 2 * fw)
# Check/update image buffer :
qpix2print = None
for qpix in self.qpix_buff:
if qpix.size().width() == rect.width():
qpix2print = qpix
break
if qpix2print is None:
qpix2print = self.img.scaledToWidth(
rect.width(), mode=Qt.SmoothTransformation)
self.qpix_buff.append(qpix2print)
# Draw pixmap :
# qp.setRenderHint(QPainter.Antialiasing, True)
qp.drawPixmap(rect, qpix2print)
qp.end()
def paintEvent(self, event):
unused(event)
if self.isVisible():
# Read out most important values to limit hash table lookups
# Low-pass roll, pitch and yaw
self.rollLP = self.roll#rollLP * 0.2f + 0.8f * roll
self.pitchLP = self.pitch#pitchLP * 0.2f + 0.8f * pitch
self.yawLP = self.yaw if isinf(self.yaw) == False and isnan(self.yaw) == False else self.yawLP#yawLP * 0.2f + 0.8f * yaw
# Translate for yaw
maxYawTrans = 60.0
newYawDiff = self.yawDiff
if isinf(newYawDiff):
newYawDiff = self.yawDiff
if newYawDiff > M_PI:
newYawDiff = newYawDiff - M_PI
if newYawDiff < -M_PI:
newYawDiff = newYawDiff + M_PI
newYawDiff = self.yawDiff * 0.8 + newYawDiff * 0.2
self.yawDiff = newYawDiff
self.yawInt += newYawDiff
if self.yawInt > M_PI:
self.yawInt = M_PI
if self.yawInt < -M_PI:
self.yawInt = -M_PI
yawTrans = self.yawInt * maxYawTrans
self.yawInt *= 0.6
if (yawTrans < 5.0) and (yawTrans > -5.0):
yawTrans = 0
# Negate to correct direction
yawTrans = -yawTrans
yawTrans = 0
#qDebug() << "yaw translation" << yawTrans << "integral" << yawInt << "difference" << yawDiff << "yaw" << yaw
# And if either video or the data stream is enabled, draw the next frame.
if self.videoEnabled:
self.xImageFactor = self.width() / float(self.glImage.width())
self.yImageFactor = self.height() / float(self.glImage.height())
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.HighQualityAntialiasing, True)
pmap = QPixmap.fromImage(self.glImage).scaledToWidth(self.width())
painter.drawPixmap(0, (self.height() - pmap.height()) / 2, pmap)
# END OF OPENGL PAINTING
if self.HUDInstrumentsEnabled:
#glEnable(GL_MULTISAMPLE)
# QT PAINTING
#makeCurrent()
painter.translate((self.vwidth/2.0+self.xCenterOffset)*self.scalingFactor, (self.vheight/2.0+self.yCenterOffset)*self.scalingFactor)
# COORDINATE FRAME IS NOW (0,0) at CENTER OF WIDGET
# Draw all fixed indicators
# BATTERY
self.paintText(self.fuelStatus, self.fuelColor, 6.0, (-self.vwidth/2.0) + 10, -self.vheight/2.0 + 6, painter)
# Waypoint
self.paintText(self.waypointName, self.defaultColor, 6.0, (-self.vwidth/3.0) + 10, +self.vheight/3.0 + 15, painter)
linePen = QPen(Qt.SolidLine)
linePen.setWidth(self.refLineWidthToPen(1.0))
linePen.setColor(self.defaultColor)
painter.setBrush(Qt.NoBrush)
painter.setPen(linePen)
# YAW INDICATOR
#
# .
# . .
# .......
#
_yawIndicatorWidth = 12.0
_yawIndicatorY = self.vheight/2.0 - 15.0
yawIndicator = QPolygon(4)
yawIndicator.setPoint(0, QPoint(self.refToScreenX(0.0), self.refToScreenY(_yawIndicatorY)))
yawIndicator.setPoint(1, QPoint(self.refToScreenX(_yawIndicatorWidth/2.0), self.refToScreenY(_yawIndicatorY+_yawIndicatorWidth)))
yawIndicator.setPoint(2, QPoint(self.refToScreenX(-_yawIndicatorWidth/2.0), self.refToScreenY(_yawIndicatorY+_yawIndicatorWidth)))
yawIndicator.setPoint(3, QPoint(self.refToScreenX(0.0), self.refToScreenY(_yawIndicatorY)))
painter.drawPolyline(yawIndicator)
painter.setPen(linePen)
# CENTER
# HEADING INDICATOR
#
# __ __
# \/\/
#
_hIndicatorWidth = 20.0
_hIndicatorY = -25.0
_hIndicatorYLow = _hIndicatorY + _hIndicatorWidth / 6.0
_hIndicatorSegmentWidth = _hIndicatorWidth / 7.0
hIndicator = QPolygon(7)
hIndicator.setPoint(0, QPoint(self.refToScreenX(0.0-_hIndicatorWidth/2.0), self.refToScreenY(_hIndicatorY)))
hIndicator.setPoint(1, QPoint(self.refToScreenX(0.0-_hIndicatorWidth/2.0+_hIndicatorSegmentWidth*1.75), self.refToScreenY(_hIndicatorY)))
hIndicator.setPoint(2, QPoint(self.refToScreenX(0.0-_hIndicatorSegmentWidth*1.0), self.refToScreenY(_hIndicatorYLow)))
hIndicator.setPoint(3, QPoint(self.refToScreenX(0.0), self.refToScreenY(_hIndicatorY)))
hIndicator.setPoint(4, QPoint(self.refToScreenX(0.0+_hIndicatorSegmentWidth*1.0), self.refToScreenY(_hIndicatorYLow)))
hIndicator.setPoint(5, QPoint(self.refToScreenX(0.0+_hIndicatorWidth/2.0-_hIndicatorSegmentWidth*1.75), self.refToScreenY(_hIndicatorY)))
hIndicator.setPoint(6, QPoint(self.refToScreenX(0.0+_hIndicatorWidth/2.0), self.refToScreenY(_hIndicatorY)))
painter.drawPolyline(hIndicator)
# SETPOINT
_centerWidth = 8.0
painter.drawEllipse(
QPointF(self.refToScreenX(min(10.0, self.desiredRoll * 10.0)),
self.refToScreenY(min(10.0, self.desiredPitch * 10.0))),
self.refToScreenX(_centerWidth/2.0), self.refToScreenX(_centerWidth/2.0))
_centerCrossWidth = 20.0
# left
painter.drawLine(QPointF(self.refToScreenX(-_centerWidth / 2.0), self.refToScreenY(0.0)),
QPointF(self.refToScreenX(-_centerCrossWidth / 2.0), self.refToScreenY(0.0)))
# right
painter.drawLine(QPointF(self.refToScreenX(_centerWidth / 2.0), self.refToScreenY(0.0)),
QPointF(self.refToScreenX(_centerCrossWidth / 2.0), self.refToScreenY(0.0)))
# top
painter.drawLine(QPointF(self.refToScreenX(0.0), self.refToScreenY(-_centerWidth / 2.0)),
QPointF(self.refToScreenX(0.0), self.refToScreenY(-_centerCrossWidth / 2.0)))
# COMPASS
_compassY = -self.vheight/2.0 + 6.0
compassRect = QRectF(QPointF(self.refToScreenX(-12.0), self.refToScreenY(_compassY)),
QSizeF(self.refToScreenX(24.0), self.refToScreenY(12.0)))
painter.setBrush(Qt.NoBrush)
painter.setPen(linePen)
painter.drawRoundedRect(compassRect, 3, 3)
# YAW is in compass-human readable format, so 0 .. 360 deg.
_yawDeg = (self.yawLP / M_PI) * 180.0
if _yawDeg < 0:
_yawDeg += 360
if _yawDeg > 360:
_yawDeg -= 360
# final safeguard for really stupid systems
_yawAngle = '{:3d}'.format(int(_yawDeg) % 360)
self.paintText(_yawAngle, self.defaultColor, 8.5, -9.8, _compassY + 1.7, painter)
painter.setBrush(Qt.NoBrush)
painter.setPen(linePen)
# CHANGE RATE STRIPS
self.drawChangeRateStrip(-95.0, -60.0, 40.0, -10.0, 10.0, self.zSpeed, painter)
# CHANGE RATE STRIPS
self.drawChangeRateStrip(95.0, -60.0, 40.0, -10.0, 10.0, self.totalAcc, painter,True)
# GAUGES
# Left altitude gauge
_gaugeAltitude = self.alt if self.alt != 0 else -self.zPos
painter.setBrush(Qt.NoBrush)
painter.setPen(linePen)
self.drawChangeIndicatorGauge(-self.vGaugeSpacing, 35.0, 15.0, 10.0, _gaugeAltitude, self.defaultColor, painter, False)
self.paintText('alt m', self.defaultColor, 5.5, -73.0, 50, painter)
# Right speed gauge
self.drawChangeIndicatorGauge(self.vGaugeSpacing, 35.0, 15.0, 10.0, self.totalSpeed, self.defaultColor, painter, False)
self.paintText('v m/s', self.defaultColor, 5.5, 55.0, 50, painter)
# Waypoint name
if self.waypointName != '':
self.paintText(self.waypointName, self.defaultColor, 2.0, (-self.vwidth/3.0) + 10, +self.vheight/3.0 + 15, painter)
# MOVING PARTS
painter.translate(self.refToScreenX(yawTrans), 0)
attColor = painter.pen().color()
# Draw multi-component attitude
for key in self.attitudes:
att = self.attitudes[key]
attColor = attColor.darker(200)
painter.setPen(attColor)
# Rotate view and draw all roll-dependent indicators
painter.rotate((att.x()/M_PI)* -180.0)
painter.translate(0, (-att.y()/M_PI)* -180.0 * self.refToScreenY(1.8))
#qDebug() << "ROLL" << roll << "PITCH" << pitch << "YAW DIFF" << valuesDot.value("roll", 0.0)
# PITCH
self.paintPitchLines(att.y(), painter)
painter.translate(0, -(-att.y()/M_PI)* -180.0 * self.refToScreenY(1.8))
painter.rotate(-(att.x()/M_PI)* -180.0)
painter.end()
def createCurveIcons(self):
pix = QPixmap(self.m_iconSize)
painter = QPainter()
gradient = QLinearGradient(0, 0, 0, self.m_iconSize.height())
gradient.setColorAt(0.0, QColor(240, 240, 240))
gradient.setColorAt(1.0, QColor(224, 224, 224))
brush = QBrush(gradient)
# The original C++ code uses undocumented calls to get the names of the
# different curve types. We do the Python equivalant (but without
# cheating).
curve_types = [
(n, c) for n, c in QEasingCurve.__dict__.items()
if isinstance(c, QEasingCurve.Type) and c != QEasingCurve.Custom
]
curve_types.sort(key=lambda ct: ct[1])
painter.begin(pix)
for curve_name, curve_type in curve_types:
painter.fillRect(QRect(QPoint(0, 0), self.m_iconSize), brush)
curve = QEasingCurve(curve_type)
if curve_type == QEasingCurve.BezierSpline:
curve.addCubicBezierSegment(QPointF(0.4,
0.1), QPointF(0.6, 0.9),
QPointF(1.0, 1.0))
elif curve_type == QEasingCurve.TCBSpline:
curve.addTCBSegment(QPointF(0.0, 0.0), 0, 0, 0)
curve.addTCBSegment(QPointF(0.3, 0.4), 0.2, 1, -0.2)
curve.addTCBSegment(QPointF(0.7, 0.6), -0.2, 1, 0.2)
curve.addTCBSegment(QPointF(1.0, 1.0), 0, 0, 0)
painter.setPen(QColor(0, 0, 255, 64))
xAxis = self.m_iconSize.height() / 1.5
yAxis = self.m_iconSize.width() / 3.0
painter.drawLine(0, xAxis, self.m_iconSize.width(), xAxis)
painter.drawLine(yAxis, 0, yAxis, self.m_iconSize.height())
curveScale = self.m_iconSize.height() / 2.0
painter.setPen(Qt.NoPen)
# Start point.
painter.setBrush(Qt.red)
start = QPoint(yAxis,
xAxis - curveScale * curve.valueForProgress(0))
painter.drawRect(start.x() - 1, start.y() - 1, 3, 3)
# End point.
painter.setBrush(Qt.blue)
end = QPoint(yAxis + curveScale,
xAxis - curveScale * curve.valueForProgress(1))
painter.drawRect(end.x() - 1, end.y() - 1, 3, 3)
curvePath = QPainterPath()
curvePath.moveTo(QPointF(start))
t = 0.0
while t <= 1.0:
to = QPointF(yAxis + curveScale * t,
xAxis - curveScale * curve.valueForProgress(t))
curvePath.lineTo(to)
t += 1.0 / curveScale
painter.setRenderHint(QPainter.Antialiasing, True)
painter.strokePath(curvePath, QColor(32, 32, 32))
painter.setRenderHint(QPainter.Antialiasing, False)
item = QListWidgetItem()
item.setIcon(QIcon(pix))
item.setText(curve_name)
self.m_ui.easingCurvePicker.addItem(item)
painter.end()
def save(self, filename: str, do_crop: bool=False):
"""Save a RenderIrea as one image on disk.
Arguments:
filename {str} -- The filename of the new image.
"""
if not self.images:
return
# new label size
dst_w = 0
dst_h = 0
# Zoom
zoom = self.zoom()
# Current number of images into the stack.
nbimg = len(self.images)
# Find the current size of the output image.
images = []
for i in range(0, nbimg):
image = self.images[i]
_w = image.width() * zoom
_h = image.height() * zoom
if _w > dst_w:
dst_w = _w
if _h > dst_h:
dst_h = _h
# Scale now
images.append(
image.scaled(
_w, _h,
Qt.KeepAspectRatio,
Qt.SmoothTransformation
))
# Output image
# ARGB since we can have all types of images (colors/grayscale/alpha channel)
dst = QImage(dst_w, dst_h, QImage.Format_ARGB32)
dst.fill(0) # black pixels everywhere
# Init QPainter.
painter = QPainter()
painter.begin(dst) # Begin to draw inside the `dst` Image
# Draw every stacked images.
# From the bottom of the stack to the top.
for i in range(0, nbimg):
# Opacity
painter.setOpacity(self.opacities[i])
painter.drawImage(
self.xx[i] * zoom,
self.yy[i] * zoom,
images[i]
)
painter.end()
# Crop or not to crop?
if do_crop and self.draw_rect:
rect = QRect(self.l_pos, self.r_pos)
dst = dst.copy(rect)
# Save image, max quality
dst.save(filename, None, 100)
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
self.drawLines(qp)
qp.end()
class Battle(QWidget):
"""Widget for displaying battle results
"""
def __init__(self, game):
super(Battle, self).__init__()
self.game = game
self.color = QColor(0, 0, 0)
self.qp = QPainter()
self.font = QFont('Helvetica', 12)
self.pen = QPen()
self.pen.setWidth(2)
def paintEvent(self, event):
self.qp.begin(self)
self.draw_battle(event)
self.qp.end()
def draw_battle(self, event):
"""Draw battle results
"""
rect = event.rect()
label_rect = QRectF(rect.x(), rect.y(), rect.width(), 25)
self.qp.setPen(self.color)
self.qp.setFont(self.font)
self.qp.drawText(label_rect, Qt.AlignCenter, 'Battle')
if self.game.battle:
size = rect.width() // 4
attacker = QRectF(rect.x() + size, 30 + rect.y(), size - 10,
size - 10)
defender = QRectF(rect.x() + 2 * size, 30 + rect.y(), size - 10,
size - 10)
self.qp.setPen(self.color)
self.qp.setFont(self.font)
self.qp.setBrush(
QColor(*player_color(self.game.battle['atk_name'])))
self.qp.drawRect(attacker)
self.qp.drawText(attacker, Qt.AlignCenter,
str(self.game.battle['atk_dice']))
self.qp.setBrush(
QColor(*player_color(self.game.battle['def_name'])))
self.qp.drawRect(defender)
self.qp.drawText(defender, Qt.AlignCenter,
str(self.game.battle['def_dice']))
self.game.battle = False
else:
size = rect.width() // 4
self.qp.setBrush(QColor(230, 230, 230))
attacker = QRectF(rect.x() + size, 30 + rect.y(), size - 10,
size - 10)
deffender = QRectF(rect.x() + 2 * size, 30 + rect.y(), size - 10,
size - 10)
self.qp.drawRect(attacker)
self.qp.drawRect(deffender)
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
qp.setRenderHint(QPainter.Antialiasing)
qp.drawPath(self.path)
qp.end()
def seed_img(self, is_seed=True):
if is_seed:
try:
cseed = self.get_seed()
except UserCancelled:
return
except InvalidPassword as e:
self.d.show_error(str(e))
return
if not cseed:
self.d.show_message(_("This wallet has no seed"))
return
txt = cseed.upper()
else:
txt = self.txt.upper()
img = QImage(self.SIZE[0], self.SIZE[1], QImage.Format_Mono)
bitmap = QBitmap.fromImage(img, Qt.MonoOnly)
bitmap.fill(Qt.white)
painter = QPainter()
painter.begin(bitmap)
QFontDatabase.addApplicationFont(
os.path.join(os.path.dirname(__file__), 'SourceSansPro-Bold.otf'))
if len(txt) < 102:
fontsize = 15
linespace = 15
max_letters = 17
max_lines = 6
max_words = 3
else:
fontsize = 12
linespace = 10
max_letters = 21
max_lines = 9
max_words = int(max_letters / 4)
font = QFont('Source Sans Pro', fontsize, QFont.Bold)
font.setLetterSpacing(QFont.PercentageSpacing, 100)
font.setPixelSize(fontsize)
painter.setFont(font)
seed_array = txt.split(' ')
for n in range(max_lines):
nwords = max_words
temp_seed = seed_array[:nwords]
while len(' '.join(map(str, temp_seed))) > max_letters:
nwords = nwords - 1
temp_seed = seed_array[:nwords]
painter.drawText(
QRect(0, linespace * n, self.SIZE[0], self.SIZE[1]),
Qt.AlignHCenter, ' '.join(map(str, temp_seed)))
del seed_array[:nwords]
painter.end()
img = bitmap.toImage()
if (self.rawnoise == False):
self.make_rawnoise()
self.make_cypherseed(img, self.rawnoise, False, is_seed)
return img
class Image(QLabel):
classifiedMLP = pyqtSignal(int)
classifiedCNN = pyqtSignal(int)
clear = pyqtSignal()
def __init__(self, *args):
super().__init__(*args)
self.pressed = False
self.setFixedSize(200, 200)
self.setStyleSheet('border: 3px solid grey;')
self.classifyTimer = QTimer()
self.classifyTimer.timeout.connect(self.classify)
# загрузка весов нейронной сети MLP
data = scipy.io.loadmat('weights.mat')
self.Theta1 = np.matrix(data['Theta1'])
self.Theta2 = np.matrix(data['Theta2'])
# инициализация модели CNN
jsonFile = open('model.json', 'r')
loadedModelJson = jsonFile.read()
jsonFile.close()
self.cnnModel = model_from_json(loadedModelJson)
self.cnnModel.load_weights('model.h5')
self.cnnModel.compile(loss="categorical_crossentropy",
optimizer=Adam(),
metrics=["accuracy"])
def mousePressEvent(self, event):
self.pressed = True
self.xPrev = event.x()
self.yPrev = event.y()
self.painter = QPainter(self.pixmap())
self.painter.setRenderHint(QPainter.Antialiasing)
self.painter.begin(self.pixmap())
def mouseMoveEvent(self, event):
if self.pressed:
color = QColor(0, 0, 0)
self.painter.setBrush(color)
pen = QPen(color, 15)
pen.setCapStyle(QtCore.Qt.RoundCap)
self.painter.setPen(pen)
self.painter.drawLine(self.xPrev, self.yPrev, event.x(), event.y())
self.xPrev = event.x()
self.yPrev = event.y()
self.repaint()
def mouseReleaseEvent(self, event):
self.pressed = False
self.painter.end()
# запуск кода классификации картинки
self.classifyTimer.start(1000)
QTimer.singleShot(2000, self.clearImage)
def classify(self):
self.classifyTimer.stop()
# предсказание с помощью MLP
self.classifiedMLP.emit(self.classifyMLP())
# предсказание с помощью свёрточной сети Keras
self.classifiedCNN.emit(self.classifyCNN())
def classifyMLP(self):
# подготовка картинки к классификации
small = self.pixmap().toImage().scaled(20, 20).convertToFormat(
QImage.Format_Grayscale8)
s = small.bits().asstring(20 * 20)
sample = np.fromstring(s, dtype=np.uint8)
sample = sample.reshape((20, 20)).T.reshape((1, 400))
sample = (255 - sample) / 243.0
# предсказание с помощью классификатора
return predict(self.Theta1, self.Theta2, sample)[0] % 10
def classifyCNN(self):
# подготовка картинки к классификации
small = self.pixmap().toImage().scaled(28, 28).convertToFormat(
QImage.Format_Grayscale8)
s = small.bits().asstring(28 * 28)
sample = np.fromstring(s, dtype=np.uint8)
sample = (255 - sample) / 255
sample = sample.reshape((1, 1, 28, 28))
# предсказание с помощью классификатора
return np.argmax(self.cnnModel.predict(sample))
def clearImage(self):
self.painter.begin(self.pixmap())
self.painter.eraseRect(self.rect())
self.painter.end()
self.repaint()
self.clear.emit()
def paintEvent(self, e):
lb = QPainter()
lb.begin(self)
self.drawRect(lb)
lb.end()
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
qp.drawImage(0, 0, QImage('images/background.jpg'))
qp.end()
def paintEvent(self, event):
if not self._image3c.img_data:
self._loading_bar.hide()
self._ico_label.hide()
self._tip_label.show()
self.overlabel_display.hide()
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter.setPen(QPen(Qt.black, Qt.PenStyle(Qt.DashLine), 3))
painter.setBrush(Qt.white)
self._tip_box = (self.width() * 0.2, self.height() * 0.2,
self.width() * 0.6, self.height() * 0.6)
radius = min(self.width() * 0.1, self.height() * 0.1)
painter.drawRoundedRect(*self._tip_box, radius, radius)
painter.end()
self._tip_label.setGeometry(QRect(*self._tip_box))
self._tip_label.setText(self._action_descs[0])
self._tip_label.setAlignment(Qt.AlignCenter)
elif self._args.sys_category * 10 + self._args.sys_channel not in self._categories:
self._loading_bar.show()
self._ico_label.show()
self._tip_label.show()
self.overlabel_display.hide()
bar_wid = self.width() * 0.8
bar_hig = self.height() * 0.1
self._loading_bar.setGeometry((self.width() - bar_wid) / 2,
self.height() - bar_hig * 1.2,
bar_wid, bar_hig)
resized_img = self._ico.scaled(self.width() * 0.8,
self.height() * 0.8,
Qt.KeepAspectRatio)
img_wid = resized_img.size().width()
img_hig = resized_img.size().height()
self._ico_label.setPixmap(QPixmap.fromImage(resized_img))
self._ico_label.setGeometry((self.width() - img_wid) / 2,
bar_hig * 0.2, img_wid, img_hig)
self._tip_label.setGeometry((self.width() - bar_wid) / 2,
self.height() - bar_hig * 2.2, bar_wid,
bar_hig)
else:
self._loading_bar.hide()
self._ico_label.hide()
self._tip_label.hide()
self.overlabel_display.show()
if not self._image3c.display:
self._image3c.load_image(self._args.sys_category,
self._args.sys_channel)
self._resizing_image = True
if self._image3c.display:
if not self._move_pos:
self.home()
self._move_pos[0] = self.width() - 2 if self._move_pos[
0] > self.width() - 2 else self._move_pos[0]
self._move_pos[0] = 2 - self._move_pos[2] if self._move_pos[
0] < 2 - self._move_pos[2] else self._move_pos[0]
self._move_pos[1] = self.height() - 2 if self._move_pos[
1] > self.height() - 2 else self._move_pos[1]
self._move_pos[1] = 2 - self._move_pos[3] if self._move_pos[
1] < 2 - self._move_pos[3] else self._move_pos[1]
# aspect ratio mode: IgnoreAspectRatio, KeepAspectRatio and KeepAspectRatioByExpanding.
if self._resizing_image:
resized_img = self._image3c.display.scaled(
self._move_pos[2], self._move_pos[3],
Qt.IgnoreAspectRatio)
self.overlabel_display.setPixmap(
QPixmap.fromImage(resized_img))
self._resizing_image = False
self.overlabel_display.setGeometry(*self._move_pos)
if isinstance(self.overlabel_display.croping, tuple):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter.setPen(
QPen(QColor(*self._args.positive_color),
self._args.positive_wid))
painter.drawLine(
QPoint(
self.overlabel_display.croping[0] *
self.overlabel_display.width() +
self.overlabel_display.x(), 0),
QPoint(
self.overlabel_display.croping[0] *
self.overlabel_display.width() +
self.overlabel_display.x(), self.height()))
painter.drawLine(
QPoint(
0, self.overlabel_display.croping[1] *
self.overlabel_display.height() +
self.overlabel_display.y()),
QPoint(
self.width(), self.overlabel_display.croping[1] *
self.overlabel_display.height() +
self.overlabel_display.y()))
painter.drawLine(
QPoint(
self.overlabel_display.croping[2] *
self.overlabel_display.width() +
self.overlabel_display.x(), 0),
QPoint(
self.overlabel_display.croping[2] *
self.overlabel_display.width() +
self.overlabel_display.x(), self.height()))
painter.drawLine(
QPoint(
0, self.overlabel_display.croping[3] *
self.overlabel_display.height() +
self.overlabel_display.y()),
QPoint(
self.width(), self.overlabel_display.croping[3] *
self.overlabel_display.height() +
self.overlabel_display.y()))
painter.end()
self.ps_status_changed.emit(
(self._image3c.rgb_data.shape[1],
self._image3c.rgb_data.shape[0], "{:.1f}".format(
self.overlabel_display.croping[2] * 100),
"{:.1f}".format(self.overlabel_display.croping[3] *
100)))
elif isinstance(self.overlabel_display.locating, tuple):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter.setPen(
QPen(QColor(*self._args.positive_color),
self._args.positive_wid))
painter.drawLine(
QPoint(
self.overlabel_display.locating[0] *
self.overlabel_display.width() +
self.overlabel_display.x(), 0),
QPoint(
self.overlabel_display.locating[0] *
self.overlabel_display.width() +
self.overlabel_display.x(), self.height()))
painter.drawLine(
QPoint(
0, self.overlabel_display.locating[1] *
self.overlabel_display.height() +
self.overlabel_display.y()),
QPoint(
self.width(), self.overlabel_display.locating[1] *
self.overlabel_display.height() +
self.overlabel_display.y()))
painter.end()
self.ps_status_changed.emit(
(self._image3c.rgb_data.shape[1],
self._image3c.rgb_data.shape[0], "{:.1f}".format(
self.overlabel_display.locating[0] * 100),
"{:.1f}".format(self.overlabel_display.locating[1] *
100)))
elif self.overlabel_display.locations[
self._args.sys_activated_idx]:
self.ps_status_changed.emit(
(self._image3c.rgb_data.shape[1],
self._image3c.rgb_data.shape[0],
"{:.1f}".format(self.overlabel_display.locations[
self._args.sys_activated_idx][0] * 100),
"{:.1f}".format(self.overlabel_display.locations[
self._args.sys_activated_idx][1] * 100)))
else:
self.ps_status_changed.emit(
(self._image3c.rgb_data.shape[1],
self._image3c.rgb_data.shape[0]))
def paintEvent(self, event):
super().paintEvent(event)
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
idx_seq = list(range(5))
idx_seq = idx_seq[self._args.sys_activated_idx +
1:] + idx_seq[:self._args.sys_activated_idx + 1]
for idx in idx_seq:
if self.locations[idx]:
pt_xy = np.array((self.locations[idx][0] * self.width(),
self.locations[idx][1] * self.height()))
pt_box = get_outer_box(pt_xy, self._args.circle_dist)
if idx == self._args.sys_activated_idx:
painter.setPen(
QPen(QColor(*self._args.positive_color),
self._args.positive_wid))
else:
painter.setPen(
QPen(QColor(*self._args.negative_color),
self._args.negative_wid))
painter.setBrush(QColor(*self._args.sys_color_set[idx].rgb))
painter.drawEllipse(*pt_box)
if isinstance(self.croping, tuple):
painter.setPen(QPen(Qt.NoPen))
painter.setBrush(QColor(255, 255, 255, 160))
croping = self.sort_croping()
croping = (int(self.width() * croping[0]),
int(self.height() * croping[1]),
int(self.width() * croping[2]),
int(self.height() * croping[3]))
self.draw_rect(painter, 0, 0, croping[0], self.height())
self.draw_rect(painter, croping[2], 0, self.width(), self.height())
self.draw_rect(painter, croping[0], 0, croping[2], croping[1])
self.draw_rect(painter, croping[0], croping[3], croping[2],
self.height())
painter.setPen(
QPen(QColor(*self._args.positive_color),
self._args.positive_wid))
painter.setBrush(QBrush(Qt.NoBrush))
if 0 <= self.croping[0] <= self.width():
painter.drawLine(
QPoint(self.croping[0] * self.width(), 0),
QPoint(self.croping[0] * self.width(), self.height()))
if 0 <= self.croping[1] <= self.height():
painter.drawLine(
QPoint(0, self.croping[1] * self.height()),
QPoint(self.width(), self.croping[1] * self.height()))
if 0 <= self.croping[2] <= self.width():
painter.drawLine(
QPoint(self.croping[2] * self.width(), 0),
QPoint(self.croping[2] * self.width(), self.height()))
if 0 <= self.croping[3] <= self.height():
painter.drawLine(
QPoint(0, self.croping[3] * self.height()),
QPoint(self.width(), self.croping[3] * self.height()))
elif isinstance(self.locating, tuple):
painter.setPen(QPen(Qt.NoPen))
painter.setBrush(QColor(255, 255, 255, 160))
painter.drawRect(0, 0, self.width(), self.height())
painter.setPen(
QPen(QColor(*self._args.positive_color),
self._args.positive_wid))
painter.setBrush(QBrush(Qt.NoBrush))
if 0 <= self.locating[0] <= self.width():
painter.drawLine(
QPoint(self.locating[0] * self.width(), 0),
QPoint(self.locating[0] * self.width(), self.height()))
if 0 <= self.locating[1] <= self.height():
painter.drawLine(
QPoint(0, self.locating[1] * self.height()),
QPoint(self.width(), self.locating[1] * self.height()))
elif self.croping or self.locating:
painter.setPen(QPen(Qt.NoPen))
painter.setBrush(QColor(255, 255, 255, 160))
painter.drawRect(0, 0, self.width(), self.height())
painter.end()
def paintEvent(self, event):
if self.do_paint:
qp = QPainter()
qp.begin(self)
self.draw_flag(qp)
qp.end()
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
qp.setRenderHint(QPainter.Antialiasing)
self.drawBezierCurve(qp)
qp.end()
def paintEvent(self, event):
p = QPainter()
p.begin(self)
self.drawFunc(event, p)
p.end()
class DrawingWidget(QWidget):
def __init__(self, scale=10, a=1.0, b=1.0, c=0.0, d=1.0):
super().__init__()
self.a, self.b, self.c, self.d = a, b, c, d
self.scale_x, self.scale_y = scale, 0
self.width, self.height = 0, 0
self.dx, self.dy = 0, 0
self.mouse_click_x = -1
self.mouse_click_y = -1
self.qp = QPainter()
self.initUI()
def initUI(self):
self.setGeometry(150, 150, 900, 900)
# self.timer = QBasicTimer()
# self.timer.start(15, self)
self.setWindowTitle('Drawing')
self.show()
def paintEvent(self, event):
self.qp.setPen(Qt.black)
self.qp.begin(self)
self.draw()
self.qp.end()
def resizeEvent(self, event):
new_width = event.size().width()
new_height = event.size().height()
self.width = new_width
self.height = new_height
self.scale_y = self.scale_x # new_width * 6 / new_height
def draw(self):
# self.draw_parabola()
# self.draw_parabola_dists()
self.draw_parabola_deltas()
self.draw_axes()
def draw_axes(self):
a_, b_, c_, d_ = self.a, self.b, self.c, self.d
if a_ < 0:
self.qp.scale(-1.0, 1.0)
a_ = -a_
c_ = -c_
dx = self.get_screen_x(0) - self.get_screen_x(c_)
dy = self.get_screen_y(d_ - b_) - self.get_screen_y(0)
self.qp.setPen(Qt.black)
self.qp.translate(dx, dy)
self.qp.drawLine(-self.width / 2 - dx, 0, self.width / 2 - dx, 0)
self.qp.drawLine(0, -self.height / 2 - dy, 0, self.height / 2 - dy)
def draw_parabola_dists(self):
self.qp.setPen(Qt.darkBlue)
self.qp.resetTransform()
self.qp.translate(self.width / 2, self.height / 2)
self.qp.scale(1.0, -1.0)
a_, c_ = self.a, self.c
if a_ == 0:
self.qp.drawLine(c_, self.height, c_, -self.height)
return
elif a_ < 0:
self.qp.scale(-1.0, 1.0)
a_ = -a_
bound = self.width
f = self.get_screen_x(1 / (4 * a_)) - self.get_screen_x(0)
x, y = 0, 0
self.qp.drawPoint(x, y)
while x <= bound:
d1 = (f - x)**2 + (-(y + 1))**2 - (-f - x)**2
min_d = abs(d1)
n_x, n_y = x, y + 1
d2 = (f - (x + 1))**2 + (-(y + 1))**2 - (-f - (x + 1))**2
if abs(d2) < min_d:
n_x, n_y = x + 1, y + 1
min_d = abs(d2)
d3 = (f - (x + 1))**2 + (-y)**2 - (-f - (x + 1))**2
if abs(d3) < min_d:
n_x, n_y = x + 1, y
self.qp.drawPoint(n_x, n_y)
self.qp.drawPoint(n_x, -n_y)
x, y = n_x, n_y
def draw_parabola_deltas(self):
self.qp.setPen(Qt.red)
self.qp.resetTransform()
self.qp.translate(self.width / 2, self.height / 2)
self.qp.scale(1.0, -1.0)
a_, c_ = self.a, self.c
if a_ == 0:
self.qp.drawLine(c_, self.height, c_, -self.height)
return
elif a_ < 0:
self.qp.scale(-1.0, 1.0)
a_ = -a_
bound = self.width
p = self.get_screen_x(1 / (2 * a_)) - self.get_screen_x(0)
x, y = 0, 0
self.qp.drawPoint(x, y)
p2 = 2 * p
while x <= bound:
delta = (y + 1) * (y + 1) - p2 * (x + 1)
if delta < 0:
other = delta + p2
if abs(delta) < abs(other):
x, y = x + 1, y + 1
else:
x, y = x, y + 1
else:
other = delta - 2 * y - 1
if abs(delta) < abs(other):
x, y = x + 1, y + 1
else:
x, y = x + 1, y
self.qp.drawPoint(x, y)
self.qp.drawPoint(x, -y)
def draw_parabola(self):
self.qp.setPen(Qt.black)
self.qp.resetTransform()
self.qp.translate(self.width / 2, self.height / 2)
self.qp.scale(1.0, -1.0)
a_, b_, c_, d_ = self.a, self.b, self.c, self.d
if a_ == 0:
self.qp.drawLine(c_, self.height, c_, -self.height)
return
elif a_ < 0:
self.qp.scale(-1.0, 1.0)
a_ = -a_
c_ = -c_
bound = self.width
p = self.get_screen_x(1 / (2 * a_)) - self.get_screen_x(0)
p2 = 2 * p
p4 = 2 * p2
x, y = 0, 0
d = 1 - p
while (y < p) and (x <= bound):
self.qp.drawPoint(x, y)
self.qp.drawPoint(x, -y)
if d >= 0:
x += 1
d -= p2
y += 1
d += (2 * y + 1)
if d == 1:
d = 1 - p4
else:
d = 1 - p2
# self.qp.drawLine(x, 0, x, y)
while x <= bound:
self.qp.drawPoint(x, y)
self.qp.drawPoint(x, -y)
if d <= 0:
y += 1
d += 4 * y
x += 1
d -= p4
def get_screen_x(self, x):
return ((self.scale_x / 2 + x) / self.scale_x) * self.width
def get_screen_y(self, y):
return ((self.scale_y / 2 + y) / self.scale_y) * self.height
def timerEvent(self, event):
self.a += 0.15
if self.a > 10:
self.a = -10
self.repaint()
def paintEvent(self, event):
ap = QPainter()
ap.begin(self)
self.drawWidget(ap)
ap.end()
def ppe(self, event):
qp = QPainter()
qp.begin(self)
self.drawFlag(qp)
qp.end()
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
self.drawText(event, qp)
qp.end()
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
self.drawWidget(qp)
qp.end()
def parse_terrain_to_image(terrainfile, waterheight=None):
# In BWii the entry at position 1 is not KNHC, but something else that needs to be skipped
if terrainfile.entries[1].name != b"KNHC":
off = 1
else:
off = 0
tiles = terrainfile.entries[1 + off] # KNHC
#tiles2 = terrainfile.entries[4+off] # TWCU
tilemap = terrainfile.entries[3 + off] # PAMC
#tilemapdata = bytes(tilemap.data)
pic = QImage(64 * 4 * 4, 64 * 4 * 4, QImage.Format_ARGB32)
light_pic = QImage(64 * 4 * 4, 64 * 4 * 4, QImage.Format_ARGB32)
#colortransition = QImage(os.path.join("lib", "colors_terrainview.png"), "PNG")
#colors = []
#for i in range(colortransition.width()):
# colors.append(colortransition.pixel(i, 0))
"""new = QImage(len(colors), 200, QImage.Format_ARGB32)
trans_painter = QPainter()
trans_painter.begin(new)
for i in range(len(colors)):
r, g, b = colors[i]
pen = trans_painter.pen()
pen.setColor(QColor(r, g, b))
trans_painter.setPen(pen)
for y in range(200):
trans_painter.drawPoint(i, y)
trans_painter.end()
result = new.save("transition.png", "PNG")
print("saved", result)"""
#pic = QPixmap(64*4*4, 64*4*4)
p = QPainter()
p.begin(pic)
light_p = QPainter()
light_p.begin(light_pic)
biggestheight = 0
lowest = 0xFFFF
print(len(tiles.data) / (180 * 16))
heights = []
watercolor = (106, 152, 242)
lowest_values = {}
total_lowest_color = None
outofbounds_count = 0
for x in range(64):
for y in range(64):
a, b, offset = struct.unpack(
">BBH", tilemap.data[(y * 64 + x) * 4:(y * 64 + x + 1) * 4])
#print(a,b,offset)
if b == 1:
tiles_data = tiles.data[180 * 16 * offset:180 * 16 *
(offset + 1)]
lowest = 0xFFFF
lowest_color = None
for ix in range(4):
for iy in range(4):
coord_offset = iy * 4 + ix
single_tile = tiles_data[180 * (coord_offset):180 *
(coord_offset + 1)]
if len(single_tile) == 0:
print("Ooops:", offset)
for iix in range(4):
for iiy in range(4):
point_offset = iiy * 4 + iix
#print("do stuff", (y*64+x)*4)
height = struct.unpack(
">H",
single_tile[point_offset *
2:(point_offset + 1) * 2])[0]
light_r, light_g, light_b, unused = struct.unpack(
"BBBB",
single_tile[32 + point_offset * 4:32 +
(point_offset + 1) * 4])
#blend_r, blend_g, blend_b, wat = struct.unpack("BBBB",
# single_tile[4+32+64+point_offset*4:4+32+64+(point_offset+1)*4])
pen = p.pen()
"""if height > biggestheight:
biggestheight = height
if height < lowest:
lowest = height
if height not in heights:
heights.append(height)
if height >= 0x4FF:
height -= 0x4FF
pen.setColor(QColor(((height>>2)+50)&0xFF, ((height>>2)+50)&0xFF, ((height>>2)+50)&0xFF))
elif height >= 0x3F0:
height -= 0x3F0
pen.setColor(QColor(((height>>2)+90)&0xFF, ((height>>2)+30)&0xFF, ((height>>2)+30)&0xFF))
elif height >= 0x1FF:
height -= 0x1FF
pen.setColor(QColor(0, ((height>>2)+30)&0xFF, 0))
else:
pen.setColor(QColor(0, 0, ((height>>2)+30)&0xFF))"""
if height >= len(COLORS):
#print("oops, color out of bounds:", height, len(COLORS))
outofbounds_count += 1
height = len(COLORS) - 1
r, g, b = COLORS[height]
if waterheight is not None and height <= waterheight * 16:
r = (r + watercolor[0]) // 2
g = (r + watercolor[1]) // 2
b = (b + watercolor[2]) // 2
#r, g, b = watercolor
if height < lowest: #and height > 0:
lowest = height
lowest_color = (r, g, b)
total_lowest_color = (r, g, b)
pen.setColor(QColor(r, g, b))
#pen.setColor(QColor(light_r, light_g, light_b))
#pen.setColor(QColor(blend_r, blend_g, blend_b))
#pen.setColor(QColor(blend_r, blend_g, blend_b))
#pen.setColor(QColor(height>>8, height&0xFF, height&0xFF))
p.setPen(pen)
p.drawPoint(x * 16 + ix * 4 + iix,
y * 16 + iy * 4 + iiy)
pen.setColor(QColor(light_r, light_g, light_b))
light_p.setPen(pen)
light_p.drawPoint(x * 16 + ix * 4 + iix,
y * 16 + iy * 4 + iiy)
lowest_values[(x, y)] = lowest_color
p.end()
light_p.end()
print(pic.size().height(), pic.size().width())
print(biggestheight, hex(biggestheight))
print(lowest, hex(lowest))
heights.sort()
print(heights)
if outofbounds_count > 0:
print("{0} points out of bounds".format(outofbounds_count))
finalimage = QImage(pic.width(), pic.height(), QImage.Format_ARGB32)
p.begin(finalimage)
#common_lowest_values =
if waterheight is not None:
"""neighbours = {}
for x in range(64):
for y in range(64):
if (x,y) in lowest_values:
for i in range(-1, 1+1):
for j in range(-1, 1+1):
if (x+i, y+j) not in lowest_values:
if (x+i, y+j) not in neighbours:
neighbours[(x+i, y+j)] = [lowest_values[(x,y)]]
else:
neighbours[((x+i, y+j))].append(lowest_values[(x,y)])
all_lowest_values = []
for pos, values in neighbours.items():
all_lowest_values.extend(values)
r, g, b = values[0]
if len(values) > 1:
for r2, g2, b2 in values[1:]:
r = (r+r2)//2
g = (g+g2)//2
b = (b+b2)//2
current = 0#sum(values) // len(values)
x,y = pos
#r, g, b = colors[current]
#all_lowest = sum(all_lowest_values) // len(all_lowest_values)
#watercolor = (106, 152, 242) #colors[0x4F]
color = colors[lowest]
print("LOWEST IS", lowest)
print(neighbours)
r = (color[0]+watercolor[0]) // 2
g = (color[1]+watercolor[1]) // 2
b = (color[2]+watercolor[2]) // 2"""
p.fillRect(
0, 0, 64 * 64 * 4, 64 * 64 * 4,
QColor(total_lowest_color[0], total_lowest_color[1],
total_lowest_color[2]))
p.drawImage(0, 0, pic)
p.end()
"""p.begin(self.terrainview)
p.drawImage(0, 0, pic)
p.end()"""
return finalimage.mirrored(False, True), light_pic.mirrored(
False, True) #pic.mirrored(False, True)
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
self.circle(painter)
painter.end()
def paintEvent(self, e): qp = QPainter() qp.begin(self) self.PaintDashLine(qp) qp.end()
def renderContact(self, generator):
"""Render the contact with the defined colors."""
# startx = 90
# orig_startx = startx
start_text = 10
rowheight = 22
textoffset = 12
blackColor = QColor(0, 0, 0)
whiteColor = QColor(255, 255, 255)
merge = self.merge
offset = 10
self.labelView.clean()
self.labelView = LabelView(self.contacts)
self.labelView.setParent(self)
self.labelView.nsPerFrame = self.nsPerFrame
self.labelView.threshold = self.threshold
self.labelView.show()
# startx has to be set according to maximum button length in labelview
startx = np.max(self.labelView.buttonWidths) + 15
orig_startx = startx
# probably included in next version...
# if self.vismode:
# textoffset += 15
# start_text += 15
# startx += 15
# orig_startx += 15
# print(orig_startx)
self.timeLineXOrigin = orig_startx
self.rowh = rowheight
# self.sizeX = (len(self.contacts[0].scoreArray) + startx) * offset
# self.sizeY = len(self.contacts) * rowheight
if self.rangeFilterActive:
self.sizeX = startx + (len(self.contacts[0].scoreArray) +
merge * 2) * offset / merge
else:
self.sizeX = startx + (len(self.contacts[0].scoreArray[self.range[0]:self.range[1]]) + merge * 2) \
* offset / merge
# add one row for frame numbers
self.sizeY = (len(self.contacts) + 1) * rowheight
self.pixmap = QPixmap(QSize(self.sizeX, self.sizeY))
p = QPainter()
if generator:
p.begin(generator)
else:
p.begin(self.pixmap)
p.fillRect(0, 0, self.sizeX, self.sizeY, whiteColor)
row = 0
rownumber = 0
# print("merge value", merge)
for c in self.contacts:
self.alphaFactor = 50
bbScColor = BackboneSidechainContactType.colors[
c.determineBackboneSidechainType()]
i = 0
if not self.showHbondScores:
if self.rangeFilterActive:
rangedScores = c.scoreArray
else:
rangedScores = c.scoreArray[self.range[0]:self.range[1]]
else:
hbarray = c.hbondFramesScan()
self.alphaFactor = 100
if self.rangeFilterActive:
rangedScores = hbarray
else:
rangedScores = hbarray[self.range[0]:self.range[1]]
if rownumber == 0:
# show the frame numbers on top
p.setFont(QFont('Arial', 8))
p.drawText(start_text, row + textoffset + 2.0, "Frame:")
off = 0
if self.range[0] != 0:
off = 1
for l in range(self.range[0] + off, self.range[1] + 1,
10)[off:]:
if l == 0:
continue
# print(l)
# TODO: sometimes errors occur!
p.drawText(startx + (l - 1 - self.range[0]) * offset,
row + textoffset + 2.0, str(l * merge))
self.labelView.move(0, rowheight)
row += rowheight
while i < len(rangedScores):
p.setPen(blackColor)
merged_score = 0
for j in range(merge):
if (i + j) >= len(rangedScores):
break
x = rangedScores[i + j]
merged_score += x
merged_score /= merge
alpha = merged_score * self.alphaFactor
if alpha > 255:
alpha = 255
if self.colorScheme == ColorScheme.bbsc:
# pass
p.setBrush(
QColor(bbScColor[0], bbScColor[1], bbScColor[2],
alpha))
elif self.colorScheme == ColorScheme.custom:
color = QColor(self.customColor)
color.setAlpha(alpha)
p.setBrush(color)
if rownumber == self.clickedRow:
p.setPen(QColor(250, 50, 50))
else:
p.setPen(QColor(0, 0, 0))
p.drawRect(startx, row, offset, 20)
startx += offset
i += merge
self.offset = offset
self.endOfTimeLine = startx
startx = orig_startx
row += rowheight
rownumber += 1
if generator:
row = rowheight
for c in self.contacts:
p.setPen(0)
# print(ContactType.colors[c.contactType])
p.setFont(QFont('Arial', 9))
# string = c.resA + c.residA + "-" + c.resB + c.residB
string = c.title
p.setBrush(ContactType.qcolors[c.determine_ctype()])
p.drawRect(0, row + 3, orig_startx, rowheight - 10)
p.setPen(1)
p.drawText(start_text, row + textoffset, string)
row += rowheight
p.end()
self.globalClickedRow = self.clickedRow
self.clickedRow = -1
def overlay_marks(self, img, is_cseed=False, calibration_sheet=False):
border_color = Qt.white
base_img = QImage(self.f_size.width(), self.f_size.height(),
QImage.Format_ARGB32)
base_img.fill(border_color)
img = QImage(img)
painter = QPainter()
painter.begin(base_img)
total_distance_h = round(base_img.width() / self.abstand_v)
dist_v = round(total_distance_h) / 2
dist_h = round(total_distance_h) / 2
img = img.scaledToWidth(base_img.width() - (2 * (total_distance_h)))
painter.drawImage(total_distance_h, total_distance_h, img)
#frame around image
pen = QPen(Qt.black, 2)
painter.setPen(pen)
#horz
painter.drawLine(0, total_distance_h, base_img.width(),
total_distance_h)
painter.drawLine(0,
base_img.height() - (total_distance_h),
base_img.width(),
base_img.height() - (total_distance_h))
#vert
painter.drawLine(total_distance_h, 0, total_distance_h,
base_img.height())
painter.drawLine(base_img.width() - (total_distance_h), 0,
base_img.width() - (total_distance_h),
base_img.height())
#border around img
border_thick = 6
Rpath = QPainterPath()
Rpath.addRect(
QRectF((total_distance_h) + (border_thick / 2),
(total_distance_h) + (border_thick / 2),
base_img.width() - ((total_distance_h) * 2) -
((border_thick) - 1),
(base_img.height() -
((total_distance_h)) * 2) - ((border_thick) - 1)))
pen = QPen(Qt.black, border_thick)
pen.setJoinStyle(Qt.MiterJoin)
painter.setPen(pen)
painter.drawPath(Rpath)
Bpath = QPainterPath()
Bpath.addRect(
QRectF((total_distance_h), (total_distance_h),
base_img.width() - ((total_distance_h) * 2),
(base_img.height() - ((total_distance_h)) * 2)))
pen = QPen(Qt.black, 1)
painter.setPen(pen)
painter.drawPath(Bpath)
pen = QPen(Qt.black, 1)
painter.setPen(pen)
painter.drawLine(0,
base_img.height() / 2, total_distance_h,
base_img.height() / 2)
painter.drawLine(base_img.width() / 2, 0,
base_img.width() / 2, total_distance_h)
painter.drawLine(base_img.width() - total_distance_h,
base_img.height() / 2, base_img.width(),
base_img.height() / 2)
painter.drawLine(base_img.width() / 2, base_img.height(),
base_img.width() / 2,
base_img.height() - total_distance_h)
#print code
f_size = 37
QFontDatabase.addApplicationFont(
os.path.join(os.path.dirname(__file__), 'DejaVuSansMono-Bold.ttf'))
font = QFont("DejaVu Sans Mono", f_size - 11, QFont.Bold)
font.setPixelSize(35)
painter.setFont(font)
if not calibration_sheet:
if is_cseed: #its a secret
painter.setPen(QPen(Qt.black, 1, Qt.DashDotDotLine))
painter.drawLine(0, dist_v, base_img.width(), dist_v)
painter.drawLine(dist_h, 0, dist_h, base_img.height())
painter.drawLine(0,
base_img.height() - dist_v, base_img.width(),
base_img.height() - (dist_v))
painter.drawLine(base_img.width() - (dist_h), 0,
base_img.width() - (dist_h),
base_img.height())
painter.drawImage(
((total_distance_h)) + 11, ((total_distance_h)) + 11,
QImage(icon_path('electrumb.png')).scaledToWidth(
2.1 * (total_distance_h), Qt.SmoothTransformation))
painter.setPen(QPen(Qt.white, border_thick * 8))
painter.drawLine(
base_img.width() - ((total_distance_h)) -
(border_thick * 8) / 2 - (border_thick / 2) - 2,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8) / 2) - (border_thick / 2) - 2,
base_img.width() - ((total_distance_h)) -
(border_thick * 8) / 2 - (border_thick / 2) - 2 - 77,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8) / 2) - (border_thick / 2) - 2)
painter.setPen(QColor(0, 0, 0, 255))
painter.drawText(
QRect(
0,
base_img.height() - 107,
base_img.width() - total_distance_h - border_thick -
11,
base_img.height() - total_distance_h - border_thick),
Qt.AlignRight, self.versioned_seed.version + '_' +
self.versioned_seed.checksum)
painter.end()
else: # revealer
painter.setPen(QPen(border_color, 17))
painter.drawLine(0, dist_v, base_img.width(), dist_v)
painter.drawLine(dist_h, 0, dist_h, base_img.height())
painter.drawLine(0,
base_img.height() - dist_v, base_img.width(),
base_img.height() - (dist_v))
painter.drawLine(base_img.width() - (dist_h), 0,
base_img.width() - (dist_h),
base_img.height())
painter.setPen(QPen(Qt.black, 2))
painter.drawLine(0, dist_v, base_img.width(), dist_v)
painter.drawLine(dist_h, 0, dist_h, base_img.height())
painter.drawLine(0,
base_img.height() - dist_v, base_img.width(),
base_img.height() - (dist_v))
painter.drawLine(base_img.width() - (dist_h), 0,
base_img.width() - (dist_h),
base_img.height())
logo = QImage(icon_path('revealer_c.png')).scaledToWidth(
1.3 * (total_distance_h))
painter.drawImage((total_distance_h) + (border_thick),
((total_distance_h)) + (border_thick), logo,
Qt.SmoothTransformation)
#frame around logo
painter.setPen(QPen(Qt.black, border_thick))
painter.drawLine(
total_distance_h + border_thick,
total_distance_h + logo.height() + 3 * (border_thick / 2),
total_distance_h + logo.width() + border_thick,
total_distance_h + logo.height() + 3 * (border_thick / 2))
painter.drawLine(
logo.width() + total_distance_h + 3 * (border_thick / 2),
total_distance_h + (border_thick),
total_distance_h + logo.width() + 3 * (border_thick / 2),
total_distance_h + logo.height() + (border_thick))
#frame around code/qr
qr_size = 179
painter.drawLine((base_img.width() - ((total_distance_h)) -
(border_thick / 2) - 2) - qr_size,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8)) - (border_thick / 2) - 2,
(base_img.width() / 2 +
(total_distance_h / 2) - border_thick -
(border_thick * 8) / 2) - qr_size,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8)) - (border_thick / 2) - 2)
painter.drawLine(
(base_img.width() / 2 +
(total_distance_h / 2) - border_thick -
(border_thick * 8) / 2) - qr_size,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8)) - (border_thick / 2) - 2,
base_img.width() / 2 + (total_distance_h / 2) -
border_thick - (border_thick * 8) / 2 - qr_size,
((base_img.height() - ((total_distance_h))) -
(border_thick / 2) - 2))
painter.setPen(QPen(Qt.white, border_thick * 8))
painter.drawLine(
base_img.width() - ((total_distance_h)) -
(border_thick * 8) / 2 - (border_thick / 2) - 2,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8) / 2) - (border_thick / 2) - 2,
base_img.width() / 2 + (total_distance_h / 2) -
border_thick - qr_size,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8) / 2) - (border_thick / 2) - 2)
painter.setPen(QColor(0, 0, 0, 255))
painter.drawText(
QRect(((base_img.width() / 2) + 21) - qr_size,
base_img.height() - 107,
base_img.width() - total_distance_h - border_thick -
93,
base_img.height() - total_distance_h - border_thick),
Qt.AlignLeft,
self.versioned_seed.get_ui_string_version_plus_seed())
painter.drawText(
QRect(
0,
base_img.height() - 107,
base_img.width() - total_distance_h - border_thick -
3 - qr_size,
base_img.height() - total_distance_h - border_thick),
Qt.AlignRight, self.versioned_seed.checksum)
# draw qr code
qr_qt = self.paintQR(
self.versioned_seed.get_ui_string_version_plus_seed() +
self.versioned_seed.checksum)
target = QRectF(base_img.width() - 65 - qr_size,
base_img.height() - 65 - qr_size, qr_size,
qr_size)
painter.drawImage(target, qr_qt)
painter.setPen(QPen(Qt.black, 4))
painter.drawLine(base_img.width() - 65 - qr_size,
base_img.height() - 65 - qr_size,
base_img.width() - 65 - qr_size,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8)) - (border_thick / 2) - 4)
painter.drawLine(base_img.width() - 65 - qr_size,
base_img.height() - 65 - qr_size,
base_img.width() - 65,
base_img.height() - 65 - qr_size)
painter.end()
else: # calibration only
painter.end()
cal_img = QImage(self.f_size.width() + 100,
self.f_size.height() + 100, QImage.Format_ARGB32)
cal_img.fill(Qt.white)
cal_painter = QPainter()
cal_painter.begin(cal_img)
cal_painter.drawImage(0, 0, base_img)
#black lines in the middle of border top left only
cal_painter.setPen(QPen(Qt.black, 1, Qt.DashDotDotLine))
cal_painter.drawLine(0, dist_v, base_img.width(), dist_v)
cal_painter.drawLine(dist_h, 0, dist_h, base_img.height())
pen = QPen(Qt.black, 2, Qt.DashDotDotLine)
cal_painter.setPen(pen)
n = 15
cal_painter.setFont(QFont("DejaVu Sans Mono", 21, QFont.Bold))
for x in range(-n, n):
#lines on bottom (vertical calibration)
cal_painter.drawLine((((base_img.width()) / (n * 2)) *
(x)) + (base_img.width() / 2) - 13,
x + 2 + base_img.height() - (dist_v),
(((base_img.width()) / (n * 2)) *
(x)) + (base_img.width() / 2) + 13,
x + 2 + base_img.height() - (dist_v))
num_pos = 9
if x > 9: num_pos = 17
if x < 0: num_pos = 20
if x < -9: num_pos = 27
cal_painter.drawText((((base_img.width()) / (n * 2)) *
(x)) + (base_img.width() / 2) - num_pos,
50 + base_img.height() - (dist_v), str(x))
#lines on the right (horizontal calibrations)
cal_painter.drawLine(
x + 2 + (base_img.width() - (dist_h)),
((base_img.height() / (2 * n)) * (x)) +
(base_img.height() / n) + (base_img.height() / 2) - 13,
x + 2 + (base_img.width() - (dist_h)),
((base_img.height() / (2 * n)) * (x)) +
(base_img.height() / n) + (base_img.height() / 2) + 13)
cal_painter.drawText(30 + (base_img.width() - (dist_h)),
((base_img.height() / (2 * n)) *
(x)) + (base_img.height() / 2) + 13,
str(x))
cal_painter.end()
base_img = cal_img
return base_img
class MainWindow(QWidget):
"""Main window of the GUI containing the game board
"""
def __init__(self, game):
"""
Parameters
----------
game : Game
"""
self.logger = logging.getLogger('GUI')
super(MainWindow, self).__init__()
self.qp = QPainter()
self.game = game
self.board = game.board
self.areas_mapping = {}
for i, area in self.board.areas.items():
for h in area.get_hexes():
self.areas_mapping[h] = i
self.font = QFont('Helvetica', 16)
self.pen = QPen()
self.pen.setWidth(2)
self.activated_area_name = None
def paintEvent(self, event):
self.qp.begin(self)
self.draw_areas()
self.qp.end()
def draw_areas(self):
"""Draw areas in the game board
"""
if self.game.draw_battle:
self.activated_area_name = None
self.game.draw_battle = False
size = self.size()
x = size.width()
y = size.height()
bbox = hexutil.Rectangle(-x // 2, -y // 2, x, y)
hexgrid = hexutil.HexGrid(10)
self.qp.setPen(Qt.NoPen)
self.qp.translate(x // 2, y // 2)
for k, area in self.board.areas.items():
lines = []
first_hex = True
color = player_color(area.get_owner_name())
if self.activated_area_name == int(k):
color = (170 + color[0] // 3, 170 + color[1] // 3,
170 + color[2] // 3)
self.qp.setBrush(QColor(*color))
self.qp.setPen(Qt.NoPen)
for h in area.get_hexes():
polygon = QPolygon(
[QPoint(*corner) for corner in hexgrid.corners(h)])
self.qp.drawPolygon(polygon)
if first_hex:
self.qp.save()
rect = QRectF(*hexgrid.bounding_box(h))
self.qp.setBrush(QColor(0, 0, 0))
self.qp.setPen(self.pen)
self.qp.setFont(self.font)
self.qp.setRenderHint(QPainter.TextAntialiasing)
self.qp.drawText(rect, Qt.AlignCenter,
str(area.get_dice()))
first_hex = False
self.qp.restore()
for n in h.neighbours():
if n not in area.get_hexes():
line = []
for corner in hexgrid.corners(h):
if corner in hexgrid.corners(n):
line.append(corner)
lines.append(line)
self.qp.save()
pen = QPen()
pen.setWidth(3)
self.qp.setPen(pen)
self.qp.setBrush(QColor())
self.qp.setRenderHint(QPainter.Antialiasing)
for line in lines:
self.qp.drawLine(line[0][0], line[0][1], line[1][0],
line[1][1])
self.qp.restore()
def mousePressEvent(self, event):
hexagon = self.get_hex(event.pos())
try:
area = self.board.get_area(self.areas_mapping[hexagon])
if self.activated_area_name:
if area.get_name() == self.activated_area_name:
self.activated_area_name = None
self.update()
elif (area.get_name()
in self.activated_area.get_adjacent_areas()
and area.get_owner_name() !=
self.game.current_player.get_name()):
# attack
self.game.send_message('battle', self.activated_area_name,
area.get_name())
elif (area.get_owner_name() == self.game.player_name and
self.game.player_name == self.game.current_player.get_name()
and area.has_dice()):
# area activation
self.activated_area_name = area.get_name()
self.activated_area = area
self.update()
except KeyError:
pass
def get_hex(self, position):
"""Return coordinates of a Hex from the given pixel position
"""
size = self.size()
x = size.width() // 2
y = size.height() // 2
hexgrid = hexutil.HexGrid(10)
return hexgrid.hex_at_coordinate(position.x() - x, position.y() - y)
def generate_image(self):
"""Generate image."""
l_top = self.dockwidget.map_layer_combobox_1.currentLayer()
l_bottom = self.dockwidget.map_layer_combobox_2.currentLayer()
# TODO: QgsRuleBasedRenderer to manage later
# TODO: Filter based on renderer type
if (l_top.id() != l_bottom.id()):
colors_layer_top = self.get_colors_from_layer(
l_top, self.reverse_layer_top_colors)
colors_layer_bottom = self.get_colors_from_layer(
l_bottom, self.reverse_layer_bottom_colors)
# Set default values
len_color_layer_top = len(colors_layer_top)
len_color_layer_bottom = len(colors_layer_bottom)
# Draw image on top
img_top = self.generate_image_for_colors(colors_layer_top,
len_color_layer_bottom,
len_color_layer_top,
self.square_width_cell,
reverse=False)
img_bottom = self.generate_image_for_colors(colors_layer_bottom,
len_color_layer_bottom,
len_color_layer_top,
self.square_width_cell,
reverse=True)
# Create a new painter to merge images
painter = QPainter()
# Declare transform function to rotate axis to switch x and y
trans = QTransform()
# Start from first image
painter.begin(img_top)
# Apply blending/composition
painter.setCompositionMode(self.blend_mode)
# TODO: Manage border when pen color
painter.drawImage(0, 0, img_bottom)
painter.end()
# Rotate if necessary
if self.invert_axis:
trans = QTransform()
trans.rotate(90)
img_top = img_top.transformed(trans)
# Reuse end image and display it in an UI overview
item = QPixmap.fromImage(img_top)
scene = QGraphicsScene()
scene.addPixmap(item)
self.dockwidget.graphic_preview.setScene(scene)
# Keep reference to image to ease image export
self.image_output = img_top
else:
self.iface.messageBar().pushMessage("Information",
"""Choose two different layers.
Otherwise, no image overview will be generated.
""",
level=Qgis.Info)
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
self.drawRectangles(qp)
qp.end()
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
self.drawMandelbrot(qp)
qp.end()
def paintEvent(self, event):
self.setWindowTitle('QBrush Function Test')
self.move(0, 0)
self.setFixedSize(860, 480)
paint = QPainter()
paint.begin(self)
brush = QBrush(Qt.SolidPattern)
paint.setBrush(brush)
paint.drawRect(10, 15, 90, 60)
brush = QBrush(Qt.Dense1Pattern)
paint.setBrush(brush)
paint.drawRect(135, 15, 90, 60)
brush = QBrush(Qt.Dense2Pattern)
paint.setBrush(brush)
paint.drawRect(250, 15, 90, 60)
brush = QBrush(Qt.Dense3Pattern)
paint.setBrush(brush)
paint.drawRect(375, 15, 90, 60)
brush = QBrush(Qt.Dense4Pattern)
paint.setBrush(brush)
paint.drawRect(500, 15, 90, 60)
brush = QBrush(Qt.Dense5Pattern)
paint.setBrush(brush)
paint.drawRect(625, 15, 90, 60)
brush = QBrush(Qt.Dense6Pattern)
paint.setBrush(brush)
paint.drawRect(10, 115, 90, 60)
brush = QBrush(Qt.Dense7Pattern)
paint.setBrush(brush)
paint.drawRect(135, 115, 90, 60)
brush = QBrush(Qt.BDiagPattern)
paint.setBrush(brush)
paint.drawRect(250, 115, 90, 60)
brush = QBrush(Qt.CrossPattern)
paint.setBrush(brush)
paint.drawRect(375, 115, 90, 60)
brush = QBrush(Qt.DiagCrossPattern)
paint.setBrush(brush)
paint.drawRect(500, 115, 90, 60)
brush = QBrush(Qt.ConicalGradientPattern)
paint.setBrush(brush)
paint.drawRect(625, 115, 90, 60)
brush = QBrush(Qt.FDiagPattern)
paint.setBrush(brush)
paint.drawRect(10, 205, 90, 60)
brush = QBrush(Qt.HorPattern)
paint.setBrush(brush)
paint.drawRect(135, 205, 90, 60)
brush = QBrush(Qt.LinearGradientPattern)
paint.setBrush(brush)
paint.drawRect(250, 205, 90, 60)
brush = QBrush(Qt.RadialGradientPattern)
paint.setBrush(brush)
paint.drawRect(375, 205, 90, 60)
brush = QBrush(Qt.TexturePattern)
paint.setBrush(brush)
paint.drawRect(500, 205, 90, 60)
brush = QBrush(Qt.VerPattern)
paint.setBrush(brush)
paint.drawRect(625, 205, 90, 60)
paint.end()
