def draw(self, qp):
qp.setWindow(0, 0, self.width(), self.height()) # 设置窗口
qp.setRenderHint(QPainter.SmoothPixmapTransform)
# 画框架背景
qp.setBrush(QColor('#cecece')) # 框架背景色
qp.setPen(Qt.NoPen)
rect = QRect(0, 0, self.width(), self.height())
qp.drawRect(rect)
sw, sh = self.width(), self.height() # 图像窗口宽高
if not self.opened:
qp.drawPixmap(sw / 2 - 100, sh / 2 - 100, 200, 200,
QPixmap('img/video.svg'))
# 画图
if self.opened and self.image is not None:
ih, iw, _ = self.image.shape
self.scale = sw / iw if sw / iw < sh / ih else sh / ih # 缩放比例
px = round((sw - iw * self.scale) / 2)
py = round((sh - ih * self.scale) / 2)
qimage = QImage(self.image.data, iw, ih, 3 * iw,
QImage.Format_RGB888) # 转QImage
qpixmap = QPixmap.fromImage(
qimage.scaled(sw, sh, Qt.KeepAspectRatio)) # 转QPixmap
pw, ph = qpixmap.width(), qpixmap.height() # 缩放后的QPixmap大小
qp.drawPixmap(px, py, qpixmap)
font = QFont()
font.setFamily('Microsoft YaHei')
if self.fps > 0:
font.setPointSize(14)
qp.setFont(font)
pen = QPen()
pen.setColor(Qt.white)
qp.setPen(pen)
qp.drawText(sw - px - 130, py + 40,
'FPS: ' + str(round(self.fps, 2)))
# 画目标框
pen = QPen()
pen.setWidth(2) # 边框宽度
for obj in self.objects:
font.setPointSize(10)
qp.setFont(font)
rgb = [round(c) for c in obj['color']]
pen.setColor(QColor(rgb[0], rgb[1], rgb[2])) # 边框颜色
brush1 = QBrush(Qt.NoBrush) # 内部不填充
qp.setBrush(brush1)
qp.setPen(pen)
# 坐标 宽高
ox, oy = px + round(pw * obj['x']), py + round(ph * obj['y'])
ow, oh = round(pw * obj['w']), round(ph * obj['h'])
obj_rect = QRect(ox, oy, ow, oh)
qp.drawRect(obj_rect) # 画矩形框
# 画 类别 和 置信度
qp.drawText(
ox, oy - 5,
str(obj['class']) + str(round(obj['confidence'], 2)))
def paint_border_background(self, painter):
"""paint_border_background(self, painter:PySide2.QtGui.QPainter)"""
painter.save()
pen = QPen()
pen.setColor(self.border_color())
pen.setWidth(self.border_width())
painter.setPen(pen)
brush = QBrush(self.background_color())
painter.setBrush(brush)
painter.setOpacity(self.opacity())
# painter.setRenderHint(QPainter.Antialiasing)
rc = self.rect()
paint_path = QPainterPath()
# adjust shadow
if self._shadow is not None:
rc.adjust(self.shadow_blur(), self.shadow_blur(),
-self.shadow_blur(), -self.shadow_blur())
# self._calc_background_path(rc, paint_path)
if self._calc_background_path(rc, paint_path):
painter.setRenderHint(QPainter.Antialiasing)
if self.border_width() > 0:
painter.drawPath(paint_path)
else:
painter.fillPath(paint_path, brush)
painter.restore()
def prim(self):
vertex = self.inputInitialVertex()
if not vertex:
return
x = vertex[0]
y = vertex[1]
expansionMinima = []
visitados = []
pq = PriorityQueue()
visitados.append((x, y))
for vertice in self.grafo[(x, y)]:
pq.put((vertice[1], [(x, y), vertice[0]]))
while not pq.empty():
actual = pq.get()
if not actual[1][1] in visitados:
visitados.append(actual[1][1])
for vertice in self.grafo[actual[1][1]]:
if not vertice[0] in visitados:
pq.put((vertice[1], (actual[1][1], vertice[0])))
expansionMinima.append(actual)
print("")
print("Minimo")
for ver in expansionMinima:
print(ver)
pen = QPen()
pen.setWidth(3)
for particula in expansionMinima:
color = QColor(255, 0, 0)
pen.setColor(color)
self.scene.addLine(particula[1][0][0] + 3, particula[1][0][1] + 3,
particula[1][1][0] + 3, particula[1][1][1] + 3,
pen)
def redraw(self):
"""
Re-draws the buttons. May be called as initialization method too.
"""
# Pixmap that contains the painter and the DR
canvas = QPixmap("assets/" + self.digirule.get_img_name())
self.setPixmap(canvas)
painter = QPainter(self.pixmap(
)) # Create a painter in which buttons and LEDs are drawn
translate_matrix = QMatrix()
offset_scale = self.digirule.get_scale_offset()
translate_matrix.scale(offset_scale[0], offset_scale[1])
painter.setMatrix(translate_matrix)
# Drawing
pen = QPen()
pen.setWidth(self.digirule.get_buttons_width())
pen.setColor(QColor(0, 0, 0, 0)) # Buttons color
painter.setPen(pen)
# Buttons
for btn in self.digirule.get_buttons_positions_dic():
painter.drawPoint(QPoint(btn[0], btn[1]))
pen.setWidth(2)
painter.setPen(pen)
for btn in self.digirule.get_special_buttons_rects_dic():
# Draw rectangle given the top-left and bottom-right corners coordinates
painter.drawRect(self._build_rect(btn))
def ordenar(self):
#distancia : descendente
#velocidad : ascendente
self.limpiar()
pen = QPen()
pen.setWidth(1)
if self.ui.comboOrdenar.currentText() == "Velocidad":
self.particulas.sort()
d = 0
for particula in self.particulas:
color = QColor(particula.color.r, particula.color.g,
particula.color.b)
pen.setColor(color)
self.scene.addLine(0, d, particula.distancia, d, pen)
d += 1
elif self.ui.comboOrdenar.currentText() == "Distancia":
self.particulas.sort(key=lambda particula: particula.distancia,
reverse=True)
d = 0
for particula in self.particulas:
color = QColor(particula.color.r, particula.color.g,
particula.color.b)
pen.setColor(color)
self.scene.addLine(0, d, particula.distancia, d, pen)
d += 1
def update_chart(self, task_list, current_date=None):
self.chart.removeSeries(self.series)
self.task_list = task_list
result = TaskAnalyser.getPointFromTasks(self.task_list, self.max_bound,
self.interval)
self.axisX.setMin(self.max_bound -
datetime.timedelta(days=self.interval - 1))
self.axisY.setRange(min(result), max(result))
self.qdate = DatetimeParser.fromDateToQDate(str(self.max_bound.date()))
self.axisX.setMax(self.max_bound)
self.series = QtCharts.QLineSeries()
self.series.setName("Karma points")
self.axisX.setTickCount(self.interval)
result.reverse()
for i in range(len(result)):
self.series.append(
self.qdate.addDays(-self.interval - 1 - i).toMSecsSinceEpoch(),
result[i])
pen = QPen()
pen.setWidth(3)
pen.setColor(QColor(242, 183, 54))
pen.setCapStyle(Qt.RoundCap)
self.series.setPen(pen)
self.chart.addSeries(self.series)
self.update()
def scene_create_lines_for_cp(self, cp: ControlPoint, playerColor, enemyColor):
scene = self.scene()
pos = self._transform_point(cp.position)
for connected_cp in cp.connected_points:
pos2 = self._transform_point(connected_cp.position)
if not cp.captured:
color = CONST.COLORS["dark_"+enemyColor]
elif cp.captured:
color = CONST.COLORS["dark_"+playerColor]
else:
color = CONST.COLORS["dark_"+enemyColor]
pen = QPen(brush=color)
pen.setColor(color)
pen.setWidth(6)
if cp.captured and not connected_cp.captured and Conflict.has_frontline_between(cp, connected_cp):
if not cp.captured:
scene.addLine(pos[0], pos[1], pos2[0], pos2[1], pen=pen)
else:
posx, h = Conflict.frontline_position(self.game.theater, cp, connected_cp)
pos2 = self._transform_point(posx)
scene.addLine(pos[0], pos[1], pos2[0], pos2[1], pen=pen)
p1 = point_from_heading(pos2[0], pos2[1], h+180, 25)
p2 = point_from_heading(pos2[0], pos2[1], h, 25)
frontline_pen = QPen(brush=CONST.COLORS["bright_red"])
frontline_pen.setColor(CONST.COLORS["orange"])
frontline_pen.setWidth(8)
scene.addLine(p1[0], p1[1], p2[0], p2[1], pen=frontline_pen)
else:
scene.addLine(pos[0], pos[1], pos2[0], pos2[1], pen=pen)
def init(self):
mask_brush = QBrush()
mask_brush.setColor(Qt.gray)
mask_brush.setStyle(Qt.SolidPattern)
mask_pen = QPen()
mask_pen.setColor(Qt.gray)
self.upper_mask.setBrush(mask_brush)
self.lower_mask.setBrush(mask_brush)
self.upper_mask.setPen(mask_pen)
self.lower_mask.setPen(mask_pen)
self.addItem(self.upper_mask)
self.addItem(self.lower_mask)
font = QFont()
font.setPointSize(20)
font.setBold(True)
self.stage_text_item.setPlainText(self._stage_text % self.stage)
self.stage_text_item.setFont(font)
self.stage_text_item.setDefaultTextColor(Qt.black)
self.stage_text_item.setX(content_width / 2 - int(self.stage_text_item.boundingRect().width() / 2))
self.stage_text_item.setY(content_height / 2 - int(self.stage_text_item.boundingRect().height() / 2))
self.animation_timer_1.setInterval(interval)
self.animation_timer_1.timeout.connect(self.animation_in)
self.animation_timer_2.setSingleShot(True)
self.animation_timer_2.timeout.connect(self.animation_hold)
self.animation_timer_2.setInterval(800)
self.animation_timer_3.setInterval(interval)
self.animation_timer_3.timeout.connect(self.animation_out)
def dibujar(self):
pen = QPen() #crear una pluma, que esta definida en la clase QPen
pen.setWidth(3) #Tamaño/anchura de la pluma
for particula in self.contenedor_particulas:
#Ponerle color a la puma
r = particula.red #randint(0, 255)#Generar un color de manera aleatoria
g = particula.green #randint(0, 255)#entre 0 y 255
b = particula.blue #randint(0, 255)
color = QColor(r, g, b)
pen.setColor(color) #Asignarle el color a la variable pluma
#Posiciones de origen y destino
origen_x = particula.origen_x #randint(0, 500)
origen_y = particula.origen_y #randint(0, 500)
destino_x = particula.destino_x #randint(0, 500)
destino_y = particula.destino_y #randint(0, 500)
self.scene.addEllipse(
origen_x, origen_y, 3, 3, pen
) #En que posicion se va a dibujar (x,y) y el radio (3,3) y la pluma
self.scene.addEllipse(
destino_x, destino_y, 3, 3, pen
) #En que posicion se va a dibujar (x,y) y el radio (3,3) y la pluma
#Para dibujar una linea para conectar los 2 puntos
self.scene.addLine(origen_x + 2, origen_y + 2, destino_x,
destino_y,
pen) #Origen en 'x','y' y destino en 'x','y',
def dibujar_kruskal(self):
self.mostrar()
if not self.grafo or len(self.cern) == 0:
QMessageBox.critical(
self,
"No se pudo leer",
"Convierta a grafo no vacío antes"
)
else:
arbol = self.cern.kruskal()
print("Arbol de expansion minima: ")
print(arbol)
self.ui.tabWidget.setCurrentIndex(2)
pen = QPen()
pen.setDashPattern([1,3])
color = QColor(255,255,255)
pen.setColor(color)
pen.setWidth(4)
for arista in arbol:
origen = arista[1]
destino = arista[2]
self.scene.addLine(origen[0]+3, origen[1]+3, destino[0], destino[1], pen)
def addRandomGraph(self):
n = 50 # number of points in graph
style = {1:QCPGraph.lsLine, 2:QCPGraph.lsStepLeft, 3:QCPGraph.lsStepRight, 4:QCPGraph.lsStepCenter, 5:QCPGraph.lsImpulse }
scatter = {1:QCPScatterStyle.ssCross, 2:QCPScatterStyle.ssPlus, 3:QCPScatterStyle.ssCircle, 4:QCPScatterStyle.ssSquare, 5:QCPScatterStyle.ssDiamond, 6:QCPScatterStyle.ssDiamond }
xScale = (uniform(0,1) + 0.5)*2
yScale = (uniform(0,1) + 0.5)*2
xOffset = (uniform(0,1) - 0.5)*4
yOffset = (uniform(0,1) - 0.5)*10
r1 = (uniform(0,1) - 0.5)*2
r2 = (uniform(0,1) - 0.5)*2
r3 = (uniform(0,1) - 0.5)*2
r4 = (uniform(0,1) - 0.5)*2
x = [0.0] * n
y = [0.0] * n
for i in range(0, n):
x[i] = (float(i)/float(n)-0.5)*10.0*xScale + xOffset
y[i] = (math.sin(x[i]*r1*5.0)*math.sin(math.cos(x[i]*r2)*r4*3.0)+r3*math.cos(math.sin(x[i])*r4*2.0))*yScale + yOffset
gx = self.ui.customPlot.addGraph()
#print("GX=",gx," and ",self.ui.customPlot.graph())
gx.setName("New graph "+str(self.ui.customPlot.graphCount()-1))
gx.setData(x, y)
gx.setLineStyle(style[randint(1,5)]);
if randint(0,100) >50:
st = QCPScatterStyle(scatter[randint(1,6)])
gx.setScatterStyle(st)
graphPen = QPen()
graphPen.setColor(QColor(randint(0,245)+10, randint(0,245)+10, randint(0,245)+10));
graphPen.setWidthF(uniform(0,1)*2.0+1)
gx.setPen(graphPen)
self.ui.customPlot.replot()
def paintEvent(self, arg__1: QPaintEvent):
# super(Push, self).paintEvent(arg__1)
# lightgrey
painter = QPainter()
painter.begin(self)
pen = QPen(QColor(162, 181, 205), 2, Qt.SolidLine)
painter.setBrush(QBrush(QColor(255, 255, 255)))
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing, True)
rect = QRect()
rect.moveTo(1, 10)
rect.setWidth(140)
rect.setHeight(140)
painter.drawRoundedRect(rect, 5, 5)
painter.drawConvexPolygon(
[QPoint(60, 10), QPoint(80, 10),
QPoint(70, 1)])
pen.setColor(QColor(255, 255, 255))
painter.setPen(pen)
painter.drawLine(63, 10, 77, 10)
pen.setWidth(1)
painter.setPen(pen)
painter.drawPoints([QPoint(61, 10), QPoint(78, 10)])
painter.end()
def puntosCercanos(self):
indice = 0
objetivo = 0
for punto in self.puntos:
if indice == len(self.puntos) - 1:
minimo = self.getDistanceBetween(punto['x'], punto['y'],
self.puntos[0]['x'],
self.puntos[0]['y'])
objetivo = self.puntos[0]
else:
minimo = self.getDistanceBetween(punto['x'], punto['y'],
self.puntos[indice + 1]['x'],
self.puntos[indice + 1]['y'])
objetivo = self.puntos[indice + 1]
for puntoComparacion in self.puntos:
if puntoComparacion == punto:
continue
distance = self.getDistanceBetween(punto['x'], punto['y'],
puntoComparacion['x'],
puntoComparacion['y'])
if distance < minimo:
minimo = distance
objetivo = puntoComparacion
#
#Pintamos la linea
pen = QPen()
pen.setWidth(3)
color = QColor(punto["color"].r, punto["color"].g,
punto["color"].b)
pen.setColor(color)
self.scene.addLine(punto["x"] + 3, punto["y"] + 3,
objetivo["x"] + 3, objetivo["y"] + 3, pen)
indice += 1
class Tool:
def __init__(self):
self.pen = QPen(
QColor(0, 0, 0, 0),
0,
Qt.SolidLine,
Qt.RoundCap,
Qt.BevelJoin,
)
self.set_size(1)
def set_size(self, size):
self.size = size
self.alpha = 255
if size < 1:
self.alpha = int(255 * size)
self.size = 1
self.pen.setWidth(self.size)
color = self.pen.color()
color.setAlpha(self.alpha)
self.pen.setColor(color)
def draw(self, last, now, update_rect, scribbles, wet):
for overlay in scribbles[-1], wet:
if overlay:
overlay.reserve(update_rect)
with overlay.painter_context() as painter:
painter.setPen(self.pen)
painter.setRenderHint(QPainter.Antialiasing)
painter.drawLine(last, now)
def paint(self, painter, option, widget):
rect = self.boundingRect()
# print(rect)
# if self.pressed:
# pen = QPen(Qt.red, 3)
# painter.setPen(pen)
# painter.drawEllipse(rect)
# else:
pen = QPen(Qt.black, 3)
font = painter.font()
font.setPixelSize(12)
painter.setFont(font)
painter.setPen(pen)
painter.drawRect(rect)
painter.drawText(self.startX+5, self.startY+20, f'Slot-{self.text}')
# Draw a LED at right corner
brush = QBrush()
brush.setStyle(Qt.SolidPattern)
if self.slotId % 3 == 0:
brush.setColor(Qt.red)
elif self.slotId % 2 == 0:
brush.setColor(Qt.green)
else:
brush.setColor(Qt.cyan)
# brush.setColor(Qt.red)
painter.setBrush(brush)
pen = QPen()
pen.setWidth(1)
pen.setColor(Qt.blue)
painter.setPen(pen)
painter.drawEllipse(self.startX+5+80, self.startY+5, 10, 10)
def paint(self, painter, options, widget):
pen = QPen()
pen.setColor(self.color)
pen.setStyle(Qt.DashLine)
pen.setCapStyle(Qt.RoundCap)
pen.setWidth(ConnectionIndicator.PEN_WIDTH)
painter.setPen(pen)
painter.drawLine(self._srcPoint, self._destPoint)
def paintEvent(self, event):
kist = QPen()
kist.setColor(QColor('Yellow'))
kist.setWidth(2)
kist.setJoinStyle(Qt.RoundJoin)
painter = QPainter(self)
painter.setPen(kist)
painter.drawPath(self.path)
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(painter.Antialiasing)
font = painter.font()
font.setBold(True)
painter.setFont(font)
x = self.rect().x()
y = self.rect().y()
w = self.rect().width() - 1
h = self.rect().height() - 1
# draw the text
painter.drawText(x + 33, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop,
self.title())
painter.setRenderHint(QPainter.Antialiasing, False)
self.__drawTriangle(painter, x, y)
# draw the borders - top
headerHeight = 20
headerRect = QRect(x + 1, y + 1, w - 1, headerHeight)
headerRectShadow = QRect(x - 1, y - 1, w + 1, headerHeight + 2)
# Highlight
pen = QPen(self.palette().color(QPalette.Light))
pen.setWidthF(0.4)
painter.setPen(pen)
painter.drawRect(headerRect)
painter.fillRect(headerRect, QColor(255, 255, 255, 18))
# Shadow
pen.setColor(self.palette().color(QPalette.Dark))
painter.setPen(pen)
painter.drawRect(headerRectShadow)
if not self.isCollapsed():
# draw the lover border
pen = QPen(self.palette().color(QPalette.Dark))
pen.setWidthF(0.8)
painter.setPen(pen)
offSet = headerHeight + 3
bodyRect = QRect(x, y + offSet, w, h - offSet)
bodyRectShadow = QRect(x + 1, y + offSet, w + 1, h - offSet + 1)
painter.drawRect(bodyRect)
pen.setColor(self.palette().color(QPalette.Light))
pen.setWidthF(0.4)
painter.setPen(pen)
painter.drawRect(bodyRectShadow)
painter.end()
def mostrar(self):
self.ui.salida.clear()
self.libreria.mostrar()
self.ui.salida.insertPlainText(str(self.libreria))
self.ui.tabla.setColumnCount(10)
headers = [
'ID', 'origen x', 'origen y', 'destino x', 'destino y',
'velocidad', 'red', 'green', 'blue', 'distancia'
]
self.ui.tabla.setHorizontalHeaderLabels(headers)
self.ui.tabla.setRowCount(len(self.libreria))
row = 0
for particula in self.libreria:
id_widget = QTableWidgetItem(str(particula.id))
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
red_widget = QTableWidgetItem(str(particula.red))
green_widget = QTableWidgetItem(str(particula.green))
blue_widget = QTableWidgetItem(str(particula.blue))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.tabla.setItem(row, 0, id_widget)
self.ui.tabla.setItem(row, 1, origen_x_widget)
self.ui.tabla.setItem(row, 2, origen_y_widget)
self.ui.tabla.setItem(row, 3, destino_x_widget)
self.ui.tabla.setItem(row, 4, destino_y_widget)
self.ui.tabla.setItem(row, 5, velocidad_widget)
self.ui.tabla.setItem(row, 6, red_widget)
self.ui.tabla.setItem(row, 7, green_widget)
self.ui.tabla.setItem(row, 8, blue_widget)
self.ui.tabla.setItem(row, 9, distancia_widget)
row += 1
pen = QPen()
pen.setWidth(2)
for particula in self.libreria: #'MainWindow' object has no attribute 'particulas'
r = particula.red
g = particula.green
b = particula.blue
color = QColor(r, g, b)
pen.setColor(color)
self.scene.addEllipse(particula.origen_x, particula.origen_y, 4, 4,
pen)
self.scene.addEllipse(particula.destino_x, particula.destino_y, 4,
4, pen)
self.scene.addLine(particula.origen_x, particula.origen_y,
particula.destino_x, particula.destino_y, pen)
def paint(self, painter, rect):
painter.fillRect(rect, self.background_color)
pen = QPen()
pen.setColor(self.foreground_color)
pen.setWidth(2)
painter.setPen(pen)
for slot in self.slots:
self.paint_slot(painter, slot, rect)
def selectTile(self, x, y):
pen = QPen()
pen.setColor(QColor(0x00, 0x32, 0x32, 0x60))
pen.setWidth(4)
new_x, new_y = self.findTilePos(x, y)
selection_rect = QRect(new_x, new_y, self._tile_w, self._tile_h)
if self._selection_rect is not None:
self._scene.removeItem(self._selection_rect)
self._selection_rect = self._scene.addRect(selection_rect, pen)
def _make_pen(self):
pen = QPen()
pen.setWidth(self._width)
color = QGuiApplication.palette().color(QPalette.Normal,
QPalette.WindowText)
color.setAlphaF(0.8)
pen.setColor(color)
pen.setStyle(Qt.SolidLine)
pen.setCapStyle(Qt.RoundCap)
return pen
def resolveFinalNodeBorder(self):
pen = QPen()
if self.isAcceptable == True:
pen.setColor(self.borderQColor)
pen.setWidth(2)
else:
pen.setColor(self.currentFill)
pen.setWidth(1)
self.finalNodeBorder.setPen(pen)
self.update()
def draw(self, qp):
qp.setWindow(0, 0, self.width(), self.height()) # 设置窗口
# 画框架背景
qp.setBrush(QColor('#cecece')) # 框架背景色
qp.setPen(Qt.NoPen)
rect = QRect(0, 0, self.width(), self.height())
qp.drawRect(rect)
sw, sh = self.width(), self.height() # 图像窗口宽高
pw, ph = 0, 0 # 缩放后的QPixmap大小
# 画图
yh = 0
if self.image is not None:
ih, iw, _ = self.image.shape
self.scale = sw / iw if sw / iw < sh / ih else sh / ih # 缩放比例
yh = round((self.height() - ih * self.scale) / 2)
qimage = QImage(self.image.data, iw, ih, 3 * iw,
QImage.Format_RGB888) # 转QImage
qpixmap = QPixmap.fromImage(
qimage.scaled(self.width(), self.height(),
Qt.KeepAspectRatio)) # 转QPixmap
pw, ph = qpixmap.width(), qpixmap.height()
qp.drawPixmap(0, yh, qpixmap)
font = QFont()
font.setFamily('Microsoft YaHei')
if self.fps > 0:
font.setPointSize(14)
qp.setFont(font)
pen = QPen()
pen.setColor(Qt.white)
qp.setPen(pen)
qp.drawText(self.width() - 150, yh + 40,
'FPS: ' + str(round(self.fps, 2)))
# 画目标框
pen = QPen()
pen.setWidth(2) # 边框宽度
for obj in self.objects:
font.setPointSize(10)
qp.setFont(font)
rgb = [round(c) for c in obj['color']]
pen.setColor(QColor(rgb[0], rgb[1], rgb[2])) # 边框颜色
brush1 = QBrush(Qt.NoBrush) # 内部不填充
qp.setBrush(brush1)
qp.setPen(pen)
# 坐标 宽高
tx, ty = round(pw * obj['x']), yh + round(ph * obj['y'])
tw, th = round(pw * obj['w']), round(ph * obj['h'])
obj_rect = QRect(tx, ty, tw, th)
qp.drawRect(obj_rect) # 画矩形框
# 画 类别 和 置信度
qp.drawText(tx, ty - 5,
str(obj['class']) + str(round(obj['confidence'], 2)))
def flight_path_pen(self, player: bool, selected: bool) -> QPen:
if selected and DisplayOptions.flight_paths.all:
return self.highlight_color()
name = self.base_faction_color_name(player)
color = CONST.COLORS[name]
pen = QPen(brush=color)
pen.setColor(color)
pen.setWidth(1)
pen.setStyle(Qt.DashDotLine)
return pen
def __init__(self, x1: float, y1: float, x2: float, y2: float,
mission_target: MissionTarget) -> None:
super().__init__(x1, y1, x2, y2)
self.mission_target = mission_target
self.new_package_dialog: Optional[QNewPackageDialog] = None
self.setAcceptHoverEvents(True)
pen = QPen(brush=const.COLORS["bright_red"])
pen.setColor(const.COLORS["orange"])
pen.setWidth(8)
self.setPen(pen)
def dibujar(self):
pen = QPen()
pen.setWidth(3)
for particula in self.particulas:
color = QColor(particula.color.r, particula.color.g,
particula.color.b)
pen.setColor(color)
self.scene.addLine(particula.origen.x + 3, particula.origen.y + 3,
particula.destino.x + 3,
particula.destino.y + 3, pen)
self.dibujarPuntos()
def Dibujar_part(self):
for particula in self.administra:
pen = QPen()
pen.setWidth(2)
color = QColor(particula.red, particula.green, particula.blue)
pen.setColor(color)
self.scene.addEllipse(particula.origen_x, particula.origen_y, 3, 3,
pen)
self.scene.addEllipse(particula.destino_x, particula.destino_y, 3,
3, pen)
self.scene.addLine(particula.origen_x + 3, particula.origen_y + 3,
particula.destino_x, particula.destino_y, pen)
def recorridoDijkstra(self):
self.ui.salida_grafo.clear()
self.scene.clear()
pen = QPen()
pen.setWidth(3)
color = QColor(245, 0, 135)
pen.setColor(color)
orig_x = self.ui.orig_x_spinBox.value()
orig_y = self.ui.orig_y_spinBox.value()
dest_x = self.ui.dest_x_spinBox.value()
dest_y = self.ui.dest_y_spinBox.value()
recorrido_Dijkstra = self.contenedor_particulas.recorridoDijkstra(
orig_x, orig_y)
str = pformat(recorrido_Dijkstra, width=40, indent=1)
self.ui.salida_grafo.insertPlainText(
"RECORRIDO (CAMINO) -> ALGORITMO DE DIJKSTRA\n\n")
self.ui.salida_grafo.insertPlainText(str)
origenDIJ = (dest_x, dest_y
) #El destino es a partir de donde va a iniciar a dibujar
destinoDIJ = (orig_x, orig_y) #hasta llegar al origen
ady = recorrido_Dijkstra.get(origenDIJ)
or_x = origenDIJ[0] #Elorigen x, va a ser el destino x
or_y = origenDIJ[1] #El origen y, va a ser el destino y
dest_x = ady[0]
dest_y = ady[1]
self.scene.addEllipse(or_x, or_y, 4, 4, pen)
self.scene.addEllipse(dest_x, dest_y, 4, 4, pen)
self.scene.addLine(or_x + 2, or_y + 2, dest_x, dest_y, pen)
while destinoDIJ != ady:
nuevoDestino = (dest_x, dest_y)
or_x = nuevoDestino[0]
or_y = nuevoDestino[1]
ady = recorrido_Dijkstra.get(nuevoDestino)
dest_x = ady[0]
dest_y = ady[1]
self.scene.addEllipse(or_x, or_y, 4, 4, pen)
self.scene.addEllipse(dest_x, dest_y, 4, 4, pen)
self.scene.addLine(or_x + 2, or_y + 2, dest_x, dest_y, pen)
def drawCurve(self):
painter = QPainter(self.ui.curve)
painter.setPen(QColor(114, 159, 207))
width = self.ui.curve.width()
height = self.ui.curve.height()
for i in range(0, height, 25):
painter.drawLine(0, i, width, i)
for i in range(0, width, 20):
painter.drawLine(i, 0, i, height)
pen = QPen()
pen.setColor(QColor(114, 159, 207))
pen.setWidth(2)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing, True)
maxTemp = max(self.tempList)
minTemp = min(self.tempList)
stepTemp = max((maxTemp - minTemp) / 10, 0.01)
midTemp = (maxTemp + minTemp) / 2.0
fromTemp = (midTemp - stepTemp * 5.5)
toTemp = (midTemp + stepTemp * 5.5)
gapTemp = 11 * stepTemp
for i in range(0, 60):
painter.drawLine(
i * width / 60.0,
height * ((toTemp - self.tempList[i]) / gapTemp),
(i + 1) * width / 60.0,
height * ((toTemp - self.tempList[i + 1]) / gapTemp))
temp = toTemp
self.ui.tempLabel_1.setText("%.2f" % temp)
temp -= stepTemp
self.ui.tempLabel_2.setText("%.2f" % temp)
temp -= stepTemp
self.ui.tempLabel_3.setText("%.2f" % temp)
temp -= stepTemp
self.ui.tempLabel_4.setText("%.2f" % temp)
temp -= stepTemp
self.ui.tempLabel_5.setText("%.2f" % temp)
temp -= stepTemp
self.ui.tempLabel_6.setText("%.2f" % temp)
temp -= stepTemp
self.ui.tempLabel_7.setText("%.2f" % temp)
temp -= stepTemp
self.ui.tempLabel_8.setText("%.2f" % temp)
temp -= stepTemp
self.ui.tempLabel_9.setText("%.2f" % temp)
temp -= stepTemp
self.ui.tempLabel_10.setText("%.2f" % temp)
temp -= stepTemp
self.ui.tempLabel_11.setText("%.2f" % temp)
def paint(self, painter: QPainter, styleOption: QStyleOptionGraphicsItem, widget: QWidget=None):
pen = QPen()
pen.setWidthF(0.05)
pen.setColor(Qt.darkGray)
painter.setPen(pen)
brush = QBrush()
brush.setColor(self.color)
brush.setStyle(Qt.SolidPattern)
painter.setBrush(brush)
topLeft = QPointF(0, 0)
bottomRight = QPointF(1, 1)
rectangle = QRectF(topLeft, bottomRight)
rectangle.translate(-0.5, -0.5)
painter.drawRect(rectangle)
def paintEvent(self, paintEvent: QPaintEvent):
pen = QPen()
pen.setJoinStyle(Qt.RoundJoin)
pen.setCapStyle(Qt.RoundCap)
painter = QPainter(self)
painter.translate(self.paintOffset)
painter.setBackgroundMode(Qt.TransparentMode)
painter.setRenderHint(QPainter.Antialiasing)
if self.nodes is not None:
painted = set()
def paintNode(node):
nonlocal painter, painted
if node in painted:
return
painted.add(node)
for link in node.links:
if link not in painted:
painter.drawLine(node.point, link.point)
paintNode(link)
color = self.palette().color(QPalette.Dark)
pen.setColor(color)
pen.setWidth(0.50 * self.paintStep)
painter.setPen(pen)
for node in self.nodes.values():
if paintEvent.region().contains(node.point):
paintNode(node)
if self.startNode is not None:
color = self.palette().color(QPalette.Dark)
pen.setColor(color)
pen.setWidth(0.75 * self.paintStep)
painter.setPen(pen)
if paintEvent.region().contains(self.startNode.point):
painter.drawPoint(self.startNode.point)
if self.finishNode is not None and paintEvent.region().contains(self.finishNode.point):
color = self.palette().color(QPalette.Dark).darker(120)
pen.setColor(color)
pen.setWidth(0.75 * self.paintStep)
painter.setPen(pen)
painter.drawPoint(self.finishNode.point)
if self.player is not None:
color = self.palette().color(QPalette.Highlight)
color.setAlpha(196)
pen.setColor(color)
pen.setWidth(0.90 * self.paintStep)
painter.setPen(pen)
painter.drawPoint(self.player)
del painter, pen
def paintEvent(self, paintEvent: QPaintEvent):
painter = QPainter(self)
painter.setBackgroundMode(Qt.TransparentMode)
painter.setRenderHint(QPainter.Antialiasing)
brush = QBrush()
brush.setStyle(Qt.SolidPattern)
pen = QPen()
pen.setJoinStyle(Qt.RoundJoin)
pen.setCapStyle(Qt.RoundCap)
center = QPoint(self.width() // 2, self.height() // 2)
radius = 0.45 * min(self.width(), self.height())
pen.setColor(self.palette().color(self.color[0]))
brush.setColor(self.palette().color(self.color[1]))
if self.highlight is True:
pen.setColor(self.palette().color(QPalette.Highlight))
pen.setWidth(round(0.15 * radius))
painter.setBrush(brush)
painter.setPen(pen)
painter.drawEllipse(center, radius, radius)
if self.checked is True:
brush.setColor(self.palette().color(QPalette.Background))
pen.setColor(self.palette().color(QPalette.Background))
painter.setPen(pen)
painter.setBrush(brush)
painter.drawEllipse(center, 0.40 * radius, 0.40 * radius)
del painter, brush, pen
def __init__(self, tetris: Tetris):
super(QTetris.QScene, self).__init__()
self.tetris = tetris
pen = QPen()
pen.setWidthF(0.05)
pen.setColor(Qt.lightGray)
brush = QBrush(Qt.NoBrush)
rect = QRectF(0, 0, tetris.num_rows, tetris.num_columns)
rect.translate(-0.5, -0.5)
self.setSceneRect(rect)
self.addRect(rect, pen, brush)
self.setBackgroundBrush(self.palette().window())
for column in range(0, tetris.num_columns, 2):
pen = QPen(Qt.NoPen)
brush = QBrush(Qt.SolidPattern)
brush.setColor(Qt.lightGray)
topLeft = QPointF(0, column)
bottomRight = QPointF(tetris.num_rows, column + 1)
rectangle = QRectF(topLeft, bottomRight)
rectangle.translate(-0.5, -0.5)
self.addRect(rectangle, pen, brush)
