def createImage(self, transform):
if self.type == DemoTextItem.DYNAMIC_TEXT:
return None
sx = min(transform.m11(), transform.m22())
sy = max(transform.m22(), sx)
textItem = QGraphicsTextItem()
textItem.setHtml(self.text)
textItem.setTextWidth(self.textWidth)
textItem.setFont(self.font)
textItem.setDefaultTextColor(self.textColor)
textItem.document().setDocumentMargin(2)
w = textItem.boundingRect().width()
h = textItem.boundingRect().height()
image = QImage(int(w * sx), int(h * sy),
QImage.Format_ARGB32_Premultiplied)
image.fill(QColor(0, 0, 0, 0).rgba())
painter = QPainter(image)
painter.scale(sx, sy)
style = QStyleOptionGraphicsItem()
textItem.paint(painter, style, None)
return image
def texting(self):
# image = self.image.copy()
# cv2.putText(image,
# self.ui.textEdit_edit.toPlainText(),
# (10, 10),
# cv2.FONT_HERSHEY_SIMPLEX,
# 0.6, (0, 0, 0), lineType=cv2.LINE_AA)
# qpixmap = mat2qpixmap(image)
# self.scene_edit.clear()
# self.scene_edit.addPixmap(qpixmap)
# self.scene_edit.update()
text = self.ui.textEdit_edit.toPlainText()
self.scene_edit.clear()
self.scene_edit.addPixmap(self.qPixmap)
qText = QGraphicsTextItem()
qText.setDefaultTextColor(QColor(0, 0, 0))
qText.setPlainText(text)
qText.setFont(self.font)
qPixmapWidth = self.qPixmap.width()
qTextWidth = qText.boundingRect().width()
qPixmapHeight = self.qPixmap.height()
qTextHeigt = qText.boundingRect().height()
posX = (qPixmapWidth - qTextWidth) / 2 + self.posX_default
posY = (qPixmapHeight - qTextHeigt) / 2 + self.posY_default
qText.setPos(posX, posY)
self.scene_edit.addItem(qText)
self.scene_edit.update()
class GraphicItem(QGraphicsPixmapItem):
def __init__(self, parent=None, text='', left=True):
super().__init__(parent)
self.pix = QPixmap("./res/Model.png")
self.width = 55
self.height = 55
self.setPixmap(self.pix.scaled(self.width, self.height))
self.setFlag(QGraphicsItem.ItemIsSelectable)
self.setFlag(QGraphicsItem.ItemIsMovable)
self.left = left
self.index = 0
self.text = QGraphicsTextItem(self)
self.text.setPlainText(text)
if self.left:
self.text.setDefaultTextColor(QColor(236, 190, 92))
else:
self.text.setDefaultTextColor(QColor(255, 59, 48))
font = QFont()
font.setBold(True)
font.setPixelSize(16)
self.text.setFont(font)
def mouseMoveEvent(self, event):
super().mouseMoveEvent(event)
# update selected node and its edge
if self.isSelected():
for gr_edge in self.scene().edges:
gr_edge.edge_wrap.update_positions()
def render_items(self, event=None):
self.links = self.get_links_dict()
self.render_preview()
for item in self.settings['items']:
text = QGraphicsTextItem()
font_color = QColor('black')
text.setPos(QPointF(item['x'], item['y']))
font = QFont()
font_name = item['params'].get(const.ITEM_DATA_KEY_FONT)
if font_name:
font.fromString(font_name)
font_size = item['params'].get(const.ITEM_DATA_KEY_FONT_SIZE)
if font_size:
font.setPointSize(font_size)
else:
font.setPointSize(12)
font_color_list = item['params'].get(
const.ITEM_DATA_KEY_FONT_COLOR)
if font_color_list:
font_color.setRgb(*font_color_list)
text.setFont(font)
text_align = item['params'].get(const.ITEM_DATA_KEY_FONT_ALIGN)
text.setFont(font)
text.setTextWidth(item['w'])
text.setDefaultTextColor(font_color)
text.setHtml(
f"<div align='{text_align}'>{self.test_row[self.links[item['name']]]}</div>"
)
self.scene.addItem(text)
def __showCircle(self):
ratio = 3
pen = QPen()
pen.setBrush(Qt.red)
pen.setWidth(0.01)
font = QFont()
font.setPointSize(200 * ratio)
self.scene.clear()
for i in range(len(self.pointsXYItem)):
(x, y) = self.pointsXYItem[i]
r = self.radius[i] * ratio
circleItem = QGraphicsEllipseItem(x - r, y - r, 2 * r, 2 * r)
circleItem.setPen(pen)
self.scene.addItem(circleItem)
strItem = QGraphicsTextItem()
strItem.setDefaultTextColor(Qt.blue)
strItem.setFont(font)
strItem.setPlainText(self.pointsName[i])
strItem.setPos(x, y)
self.scene.addItem(strItem)
def createImage(self, transform):
if self.type == DemoTextItem.DYNAMIC_TEXT:
return None
sx = min(transform.m11(), transform.m22())
sy = max(transform.m22(), sx)
textItem = QGraphicsTextItem()
textItem.setHtml(self.text)
textItem.setTextWidth(self.textWidth)
textItem.setFont(self.font)
textItem.setDefaultTextColor(self.textColor)
textItem.document().setDocumentMargin(2)
w = textItem.boundingRect().width()
h = textItem.boundingRect().height()
image = QImage(int(w * sx), int(h * sy),
QImage.Format_ARGB32_Premultiplied)
image.fill(QColor(0, 0, 0, 0).rgba())
painter = QPainter(image)
painter.scale(sx, sy)
style = QStyleOptionGraphicsItem()
textItem.paint(painter, style, None)
return image
def select_level(self):
#set switches to the correct state
self.set_switches_off('level')
#self.cancel_button.clicked.connect(self.cancel_level_select)
#initialize enter-key value and set correct state to selecting_level
self.enter = 0
self.selecting_level = True
self.level_text = ''
#initialize a scene where to put levels
self.level_scene = QGraphicsScene()
#view for scene
self.level_scene_view = QGraphicsView(self.level_scene, self)
self.level_scene_view.adjustSize()
self.level_scene_view.show()
self.layout.addWidget(self.level_scene_view)
level = QGraphicsTextItem('Level')
path = os.getcwd() #get the current working dir
os.chdir(path) #change dir to the current working dir
os.chdir('game_levels')
position = 50
levels = []
data = os.listdir()
for item in data:
if os.path.isfile(item):
levels.append(item)
#add also item to level_scene to show user what levels there are to choose from
level = QGraphicsTextItem(item)
#change color, can be changed later
level.setDefaultTextColor(QColor(225,100,25))
self.level_scene.addItem(level)
level.setPos(0,position)
position +=20
self.qline_edit = QLineEdit()
#change text color
palette = QPalette()
palette.setColor(QPalette.Text,QColor(225,100,25)) #the color can be changed
self.qline_edit.setPalette(palette)
self.layout.addWidget(self.qline_edit)
self.qline_edit.textEdited[str].connect(self.qline_edited)
os.chdir(path) #remember to change back to the working dir where all classes etc are
def addWP(self, wp):
if wp.command in [mavutil.mavlink.MAV_CMD_NAV_WAYPOINT,
mavutil.mavlink.MAV_CMD_NAV_WAYPOINT,
mavutil.mavlink.MAV_CMD_NAV_LOITER_TO_ALT,
mavutil.mavlink.MAV_CMD_NAV_LOITER_TURNS,
mavutil.mavlink.MAV_CMD_NAV_LOITER_TIME,
mavutil.mavlink.MAV_CMD_NAV_LOITER_UNLIM,
mavutil.mavlink.MAV_CMD_NAV_LAND]:
#point
rad = self.__wp_diameter * 0.5
ellipse = QGraphicsEllipseItem(wp.y - rad, -wp.x - rad,
self.__wp_diameter, self.__wp_diameter, self.__mission_layer)
ellipse.setBrush(QBrush(QColor(255, 255, 255)))
e_pen = QPen(QColor(255, 255, 255))
e_pen.setWidth(0)
ellipse.setPen(e_pen)
self.__mission_layer.addToGroup(ellipse)
#label
label = QGraphicsTextItem(str(wp.seq), self.__mission_layer)
label.setZValue(2)
label.setDefaultTextColor(Qt.white)
label.setPos(wp.y + rad, -wp.x - rad)
label.setScale(0.00002) #bit hacky -- really should scale based on
#current zoom, but I'm in a hurry.
self.__mission_layer.addToGroup(label)
label.show()
class fadingPic(QObject):
""" Wrap a QGraphicsPixmapItem and impliment the fade in/out animation"""
def __init__(self, pixmap, parent=None):
super().__init__(parent)
self.pixmap_item = QGraphicsPixmapItem(pixmap)
self.text_item = QGraphicsTextItem(
"Nerual Network based Channel Learning")
font = QFont("Nokia Pure Text Light", 18) # QFont.Bold
self.text_item.setFont(font)
self.text_item.setDefaultTextColor(QColor(18, 65, 145))
def _set_opacity(self, opc):
self.pixmap_item.setOpacity(opc)
self.text_item.setOpacity(opc)
def fadeIn(self):
anim = QPropertyAnimation(self, b'opacity')
anim.setDuration(800)
anim.setStartValue(0)
anim.setEndValue(1)
#anim.setLoopCount(1)
return anim
def fadeOut(self):
anim = QPropertyAnimation(self, b'opacity')
anim.setDuration(800)
anim.setStartValue(1)
anim.setEndValue(0)
#anim.setLoopCount(1)
return anim
opacity = pyqtProperty(float, fset=_set_opacity)
class DSO_range(QGraphicsPolygonItem):
def __init__(self, parent, text="", color=Qt.white, text_col=Qt.black):
super().__init__(None)
polygon = QPolygonF()
self.width = 175
self.height = 24
polygon.append(QPointF(0, 0))
polygon.append(QPointF(0, self.height))
polygon.append(QPointF(self.width, self.height))
polygon.append(QPointF(self.width, 0))
self.setPolygon(polygon)
# we want black background
bg = QBrush()
col = QColor(color)
col.setAlpha(200)
bg.setColor(col)
bg.setStyle(Qt.SolidPattern)
self.setBrush(bg)
self.text = QGraphicsTextItem(self)
self.text.setDefaultTextColor(QColor(text_col))
self.text.setPlainText(text)
self.show()
def setText(self, text):
self.text.setPlainText(text)
def _showLetter(self, i, j):
"""
Graphical representation of a square to fill is created here.
"""
x = j * self.SQUARE_SIZE
y = i * self.SQUARE_SIZE
self.scene.addRect(x, y, self.SQUARE_SIZE, self.SQUARE_SIZE,
QPen(Qt.black, 1, Qt.SolidLine), QBrush(Qt.NoBrush))
square = self.model.grid[i][j]
if len(square) == 1:
numberTextItem = QGraphicsTextItem(str(square[0]))
numberTextItem.setDefaultTextColor(Qt.darkGreen)
numberTextItem.setPos(x + self.SQUARE_SIZE / 3,
y + self.SQUARE_SIZE / 3)
self.scene.addItem(numberTextItem)
else:
for number in square:
numberTextItem = QGraphicsTextItem(str(number))
xPos = x + ((number - 1) % 3) * self.SQUARE_SIZE / 3
yPos = y + ((number - 1) / 3) * self.SQUARE_SIZE / 3
numberTextItem.setPos(xPos, yPos)
self.scene.addItem(numberTextItem)
def __drawPoint(self, x, y, index):
#横线
line1 = QGraphicsLineItem()
line1.setPen(self.pen)
line1.setLine(x - self.lineRadius, y, x + self.lineRadius, y)
#竖线
line2 = QGraphicsLineItem()
line2.setPen(self.pen)
line2.setLine(x, y - self.lineRadius, x, y + self.lineRadius)
#文字说明
text = QGraphicsTextItem()
text.setDefaultTextColor(Qt.blue)
text.setFont(self.font)
text.setPlainText(self.pointsName[index])
text.setPos(x, y)
#放到组中
pointGroup = QGraphicsItemGroup()
pointGroup.addToGroup(line1)
pointGroup.addToGroup(line2)
pointGroup.addToGroup(text)
#显示
if self.pointsItem[index] is not None:
self.scene.removeItem(self.pointsItem[index])
#保存到字典
self.pointsItem[index] = pointGroup
#显示该点
self.scene.addItem(self.pointsItem[index])
class Node(QGraphicsEllipseItem):
def __init__(self, name, rect=QRectF(0, 0, 20, 20), parent=None):
QGraphicsEllipseItem.__init__(self, rect, parent)
self.setX(random.randrange(0, 1000, 1))
self.setY(random.randrange(0, 300, 1))
self.edges = []
self.setZValue(2)
self.brush_color = QColor(153, 153, 153)
self.setBrush(self.brush_color)
self.setPen(QPen(Qt.NoPen))
self.setFlags(QGraphicsItem.ItemIsMovable
| QGraphicsItem.ItemIsSelectable
| QGraphicsItem.ItemSendsGeometryChanges)
self.text = QGraphicsTextItem(name)
self.text.setDefaultTextColor(self.brush_color)
self.text.setPos(-float(len(self.text.toPlainText())), -20.0)
self.text.setParentItem(self)
self.screen = ''
def set_screen(self, screen):
self.screen = screen
def addEdge(self, edge):
self.edges.append(edge)
def itemChange(self, change, value):
if change == QGraphicsItem.ItemSelectedChange:
self.setBrush(QColor("#1976D2") if value else self.brush_color)
self.text.setDefaultTextColor(
QColor("#1976D2") if value else self.brush_color)
for i in range(len(self.edges)):
self.edges[i].focus() if value else self.edges[i].defocus()
if change == QGraphicsItem.ItemPositionHasChanged:
for edge in self.edges:
edge.adjust()
return QGraphicsItem.itemChange(self, change, value)
def mouseDoubleClickEvent(self, event):
try:
file = open(os.path.join(self.screen.project_folder,
self.text.toPlainText()),
'r',
encoding='utf-8',
errors='ignore')
with file:
text = file.read()
self.screen.new_document(title=self.text.toPlainText())
self.screen.current_editor.setPlainText(text)
self.screen.current_editor.set_change_name(
self.screen.tab_widget, False)
except FileNotFoundError as error:
QMessageBox.question(self.screen, 'Error',
'Error occured : ' + str(error),
QMessageBox.Close)
class AnimatedClock(QGraphicsView):
def __init__(self, parent=None):
QGraphicsView.__init__(self, parent)
self.updateSecs = 0.5
# Border
self.setLineWidth(0)
self.setFrameShape(QtWidgets.QFrame.NoFrame)
# Size
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
sizePolicy.setHeightForWidth(True)
self.setSizePolicy(sizePolicy)
# No scrollbars
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
# Scene
self.scene = QGraphicsScene()
self.setScene(self.scene)
self.setBackgroundBrush(QColor("black"))
# Text of clock
self.textItem = QGraphicsTextItem()
self.textItem.color = QColor(QColor("black"))
self.textItem.setFont(QFont("Segoe UI", 80))
self.textItem.setDefaultTextColor(QColor("white"))
self.textItem.setHtml("")
self.textItem.setZValue(20)
self.scene.addItem(self.textItem)
# Start ticking
self.start()
def sizeHint(self):
return QSize(300, 150)
def start(self):
self.updateTimer = QTimer()
self.updateTimer.setInterval(self.updateSecs * 990)
self.updateTimer.timeout.connect(self.updateClock)
self.updateTimer.start()
print("Animated clock - starting")
def stop(self):
if self.updateTimer != None:
self.updateTimer.stop()
print("Animated clock - stopping")
def updateClock(self):
localtime = time.localtime()
timeString = time.strftime("%H:%M:%S", localtime)
self.textItem.setHtml(timeString)
width = self.frameGeometry().width()
self.textItem.setFont(QFont("Segoe UI", width / 8))
self.textItem.update()
def heightForWidth(self, width):
return width * .32
def keyPressEvent(self, event): #QKeyEvent
event.ignore()
def create_winner_label(self):
w = QGraphicsTextItem()
w.setPlainText("%s" % self.mini_game_winner)
game_board = self.parent()
print(game_board)
w.setFont(QFont('SansSerif', self.fonts[self.mini_game_winner]))
w.setDefaultTextColor(Qt.black)
w.setPos(self.x(), self.y())
w.setVisible(False)
return w
def printAttributes(self, background, border, text):
"""
Prints the attributes of the node
The attributes are a key, value pair
:param background: background color of the node
:param border: border color for the node
:param text: text color for the node
"""
y = self.y() + self.headerHeight
x = self.x()
self.attributesHeight = 0
for k, v in self.node.attributes.items():
key = QGraphicsTextItem()
key.setFont(Configuration.font)
key.setDefaultTextColor(QColor(text))
key.setTextWidth(100)
key.setPlainText(k)
keyHeight = int(key.boundingRect().height() / 20 + 0.5) * 20
value = QGraphicsTextItem()
value.setFont(Configuration.font)
value.setDefaultTextColor(QColor(text))
value.setTextWidth(100)
value.setPlainText(v)
valueHeight = int(value.boundingRect().height() / 20 + 0.5) * 20
height = valueHeight if valueHeight > keyHeight else keyHeight
keyRect = QGraphicsRectItem()
keyRect.setRect(x, y, 100, height)
valueRect = QGraphicsRectItem()
valueRect.setRect(x + 100, y, 100, height)
keyRect.setBrush(QBrush(QColor(background)))
valueRect.setBrush(QBrush(QColor(background)))
keyRect.setPen(QPen(QColor(border), 2))
valueRect.setPen(QPen(QColor(border), 2))
key.setPos(x, y - 2)
value.setPos(x + 100, y - 2)
self.attributes.addToGroup(keyRect)
self.attributes.addToGroup(valueRect)
self.attributes.addToGroup(key)
self.attributes.addToGroup(value)
y = y + height
self.attributesHeight += height
self.addToGroup(self.attributes)
def on_actItem_Text_triggered(self):
strText,OK=QInputDialog.getText(self,"输入","请输入文字")
if (not OK):
return
item=QGraphicsTextItem(strText)
font=self.font()
font.setPointSize(20)
font.setBold(True)
item.setFont(font) #设置字体
item.setDefaultTextColor(Qt.black) #设置颜色
self.__setItemProperties(item,"文字")
def showImage(self):
(newImg, newImgInfo) = self.loadImage()
# return PicItem(Pixmap(QPixmap(newImg)), -1, -1, xFactor, yFactor, newImgInfo)
self.scene.clear()
imgSz = newImgInfo.imgSize
self.setSceneRect(QRectF(0,0,imgSz.width(), imgSz.height()))
pixMap = QPixmap.fromImage(newImg)
# # pixMap.setWidth(self.width())
pixMapItem = self.scene.addPixmap(pixMap)
# pixMapItem.setPos(50,50)
# self.fitInView(QRectF(0, 0, self.width(), self.height()), Qt.KeepAspectRatio)
# Add caption
caption = QGraphicsTextItem()
caption.setDefaultTextColor(QColor(255,255,255))
caption.setPos(0, self.height()*0.94)
caption.setFont(QFont("Segoe UI", 30))
caption.setTextWidth(self.width())
# caption.setPos(100, 100)
# caption.setTextWidth(1500)
# if newImgInfo.createDate is not None:
# caption.setPlainText(newImgInfo.createDate.format());
# else:
# caption.setPlainText("Image is called bananas");
# print("Tags", newImgInfo.tags)
# tagStr = ""
# for tag in newImgInfo.tags:
# if tag != "Duplicate":
# tagStr += (", " if len(tagStr) != 0 else "") + tag
# if tagStr == "":
# tagStr = "NO TAGS"
# captionStr = '<h1 style="text-align:center;width:100%">' + tagStr + '</h1>'
# if newImgInfo.createDate is not None:
# print(newImgInfo.createDate.format())
# captionStr += '<BR><h2>' + newImgInfo.createDate.format() + '</h2>'
captionStr = ""
try:
if newImgInfo.rating is not None:
for i in range(newImgInfo.rating):
captionStr += "★"
for i in range(5-newImgInfo.rating):
captionStr += "☆"
if newImgInfo.mainDate is not None:
if len(captionStr) != 0:
captionStr += " "
captionStr += newImgInfo.mainDate.strftime("%d %b %Y")
except Exception as excp:
print("StaticPhotos: Cannot set caption")
captionStr = '<div style="background-color:#000000;text-align: right;padding-right:10dp;">' + captionStr + "</div>"
print(captionStr)
caption.setHtml(captionStr)
self.scene.addItem(caption)
self.scene.update()
class PickingStation(VisualizerGraphicItem):
def __init__(self, ID=0, x=0, y=0):
super(self.__class__, self).__init__(ID, x, y)
self._kind_name = 'pickingStation'
self._items = []
self._graphics_item = QGraphicsRectItem(self)
self._items.append(QGraphicsRectItem(self._graphics_item))
self._items.append(QGraphicsRectItem(self._graphics_item))
self._text = QGraphicsTextItem(self._graphics_item)
def set_rect(self, rect):
scale = config.get('display', 'id_font_scale')
bold = config.get('display', 'id_font_bold')
self._text.setFont(QFont('', rect.width() * 0.08 * scale))
self._text.setPos(rect.x(), rect.y() + 0.6 * rect.height())
self._text.setDefaultTextColor(
QColor(config.get('display', 'id_font_color')))
if self._display_mode == 0:
if bold:
self._text.setHtml('<b>P(' + str(self._id) + ')</b>')
else:
self._text.setHtml('P(' + str(self._id) + ')')
self._graphics_item.setRect(rect.x(), rect.y(), rect.width(),
rect.height())
self._items[0].setRect(rect.x() + rect.width() / 5, rect.y(),
rect.width() / 5, rect.height())
self._items[1].setRect(rect.x() + rect.width() / 5 * 3, rect.y(),
rect.width() / 5, rect.height())
elif self._display_mode == 1:
self._text.setPlainText('')
self._graphics_item.setRect(rect.x(), rect.y(), rect.width(),
rect.height())
self._items[0].setRect(rect.x() + rect.width() / 5, rect.y(),
rect.width() / 5, rect.height())
self._items[1].setRect(rect.x() + rect.width() / 5 * 3, rect.y(),
rect.width() / 5, rect.height())
def determine_color(self, number, count, pattern=None):
color = self._colors[0]
color2 = self._colors[1]
color.setAlpha(150)
color2.setAlpha(150)
brush = QBrush(color)
brush2 = QBrush(color2)
self._graphics_item.setBrush(brush)
self._items[0].setBrush(brush2)
self._items[1].setBrush(brush2)
def get_rect(self):
return self._graphics_item.rect()
class ParticipantItem(QGraphicsItem):
def __init__(self, model_item: Participant, parent=None):
super().__init__(parent)
self.model_item = model_item
self.text = QGraphicsTextItem(self)
self.line = QGraphicsLineItem(self)
self.line.setPen(
QPen(Qt.darkGray, 1, Qt.DashLine, Qt.RoundCap, Qt.RoundJoin))
self.refresh()
def update_position(self, x_pos=-1, y_pos=-1):
if x_pos == -1:
x_pos = self.x_pos()
if y_pos == -1:
y_pos = self.line.line().y2()
self.text.setPos(x_pos - (self.text.boundingRect().width() / 2), 0)
self.line.setLine(x_pos, 30, x_pos, y_pos)
def x_pos(self):
return self.line.line().x1()
def width(self):
return self.boundingRect().width()
def refresh(self):
self.text.setPlainText(
"?" if not self.model_item else self.model_item.shortname)
if hasattr(self.model_item, "simulate") and self.model_item.simulate:
font = QFont()
font.setBold(True)
self.text.setFont(font)
self.text.setDefaultTextColor(Qt.darkGreen)
self.line.setPen(
QPen(Qt.darkGreen, 2, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
else:
self.text.setFont(QFont())
self.text.setDefaultTextColor(constants.LINECOLOR)
self.line.setPen(
QPen(Qt.darkGray, 1, Qt.DashLine, Qt.RoundCap, Qt.RoundJoin))
def boundingRect(self):
return self.childrenBoundingRect()
def paint(self, painter, option, widget):
pass
def updateIcon(self, id, uav_state, image_num=0):
if uav_state.get_lon() == 0.0:
#haven't received a Pose message yet
return
if id not in self.__plane_icons:
#make the plane's label first
label = QGraphicsTextItem(str(id), self.__plane_layer)
label.setZValue(2)
label.setDefaultTextColor(Qt.red)
self.__plane_layer.addToGroup(label)
label.show()
self.__plane_labels[id] = label
self.__plane_icons[id] = MapGraphicsIcon(id, label,
self.__plane_layer)
self.__plane_icons[id].centerIconAt(uav_state.get_lon(),
-uav_state.get_lat())
self.__plane_icons[id].textureIcon(self.__plane_icon_pixmaps[image_num])
#plane icons need to be drawn on top of map tiles:
self.__plane_icons[id].setZValue(1)
self.__plane_layer.addToGroup(self.__plane_icons[id])
#key 0 = last update time
self.__plane_icons[id].setData(0, 0)
#refresh:
#HACK: don't know why zooming works to refresh. Couldn't
#get scene.invalidate() nor scene.update() to work
self.onZoom(self.__current_detail_layer)
#end if
now = time.time()
#if we don't have new pose data, then we don't update the plane icon
if (self.__plane_icons[id].data(0) is None
or self.__plane_icons[id].data(0) >= uav_state.get_last_pose_update()):
return
#place icon
self.__plane_icons[id].centerIconAt(uav_state.get_lon(), -uav_state.get_lat())
#give correct heading:
quat = uav_state.get_quat()
heading = acs_math.yaw_from_quat(quat[0], quat[1], quat[2], quat[3])
self.__plane_icons[id].setHeading(heading)
#set last update time
self.__plane_icons[id].setData(0, now)
def initUi(self):
pos = QPointF(0, 0)
for i in range(0, self.length): #每一秒有1個刻度，總共 length 秒
t1 = QGraphicsTextItem('|', self)
t1.setDefaultTextColor(QColor(Qt.blue))
t1.setPos(pos)
t2 = QGraphicsTextItem('{}'.format(i + int(self.start)), self)
t2.setDefaultTextColor(QColor(Qt.blue))
t2.setPos(t1.boundingRect().bottomLeft() + pos)
pos.setX(pos.x() + int(self.w / self.length))
self.setRect(0, 0, self.w, self.h)
class MyRect(QGraphicsRectItem):
def __init__(self, parent=None):
super(MyRect, self).__init__(parent)
self.text_item = QGraphicsTextItem('My Text Here', self)
self.value_item = QGraphicsTextItem('My Value Here', self)
self.text_item.setDefaultTextColor(QColor(Qt.blue))
self.value_item.setDefaultTextColor(QColor(Qt.red))
self.value_item.setPos(self.text_item.boundingRect().bottomLeft())
width = max(self.text_item.boundingRect().width(),
self.value_item.boundingRect().width())
height = self.text_item.boundingRect().height(
) + self.value_item.boundingRect().height()
self.setRect(50, 50, width, height)
class ParticipantItem(QGraphicsItem):
def __init__(self, model_item: Participant, parent=None):
super().__init__(parent)
self.model_item = model_item
self.text = QGraphicsTextItem(self)
self.line = QGraphicsLineItem(self)
self.line.setPen(QPen(Qt.darkGray, 1, Qt.DashLine, Qt.RoundCap, Qt.RoundJoin))
self.refresh()
def update_position(self, x_pos=-1, y_pos=-1):
if x_pos == -1:
x_pos = self.x_pos()
if y_pos == -1:
y_pos = self.line.line().y2()
self.text.setPos(x_pos - (self.text.boundingRect().width() / 2), 0)
self.line.setLine(x_pos, 30, x_pos, y_pos)
def x_pos(self):
return self.line.line().x1()
def width(self):
return self.boundingRect().width()
def refresh(self):
self.text.setPlainText("?" if not self.model_item else self.model_item.shortname)
if hasattr(self.model_item, "simulate") and self.model_item.simulate:
font = QFont()
font.setBold(True)
self.text.setFont(font)
self.text.setDefaultTextColor(Qt.darkGreen)
self.line.setPen(QPen(Qt.darkGreen, 2, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
else:
self.text.setFont(QFont())
self.text.setDefaultTextColor(constants.LINECOLOR)
self.line.setPen(QPen(Qt.darkGray, 1, Qt.DashLine, Qt.RoundCap, Qt.RoundJoin))
def boundingRect(self):
return self.childrenBoundingRect()
def paint(self, painter, option, widget):
pass
class AnimatedClock():
updateTimer = None
calDataLock = threading.Lock()
calDataUpdated = False
curCalendars = None
def __init__(self, scene, widthClkTextArea, heightClkTextArea, borders, updateSecs):
self.masterScene = scene
self.widthClkTextArea = widthClkTextArea
self.heightClkTextArea = heightClkTextArea
self.borders = borders
self.updateSecs = updateSecs
# Background
self.textBkgd = QGraphicsRectItem(0, 0, self.widthClkTextArea, self.heightClkTextArea)
self.textBkgd.setPos(self.borders[3], self.borders[0])
self.textBkgd.setBrush(QColor("light green"))
self.textBkgd.setZValue(10)
scene.addItem(self.textBkgd)
# Text Item
self.textItem = QGraphicsTextItem()
self.textItem.setFont(QFont("Segoe UI", 80))
self.textItem.setDefaultTextColor(QColor("black"))
self.textItem.setPos(QPointF(self.borders[3]+10,self.borders[0]+5))
self.textItem.setHtml("<B>Clock</B>")
self.textItem.setZValue(20)
self.textItem.setTextWidth(self.widthClkTextArea-20)
scene.addItem(self.textItem)
def start(self):
self.updateTimer = QTimer()
self.updateTimer.setInterval(self.updateSecs * 1000)
self.updateTimer.timeout.connect(self.updateClock)
self.updateTimer.start()
def stop (self):
if self.updateTimer != None:
self.updateTimer.stop()
def updateClock(self):
localtime = time.localtime()
# dateString = time.strftime("%a %d %b %Y", localtime)
timeString = time.strftime("%H:%M:%S", localtime)
self.textItem.setHtml(timeString)
# self.textItem.setTextWidth(self.widthCalTextArea-20)
self.textItem.update()
def create_map_points(self):
self.map_points_text_items = []
self.map_points_items = []
for map_point in self.map_data.map_points:
color = QColor().fromRgb(map_point.r, map_point.g, map_point.b)
rect = QGraphicsRectItem(
QRectF(
QPointF(map_point.x, map_point.y),
QSizeF(5 / self.scale_ratio, 5 / self.scale_ratio)
)
)
rect.setPen(QPen(Qt.black, 1 / self.scale_ratio))
rect.setBrush(color)
self.map_points_items.append(rect)
text = QGraphicsTextItem(map_point.text)
text.setDefaultTextColor(color)
text.setPos(map_point.x, map_point.y)
text.setFont(QFont('Times New Roman', 8 / self.scale_ratio, 2))
self.map_points_text_items.append(text)
class Bar(QGraphicsRectItem):
def __init__(self, parent=None):
super().__init__(parent)
self.max_val = 1
self.current_val = 1
self.WIDTH = parent.pixmap().width() if parent else 60
self.setRect(parent.pos().x(), parent.pos().y(), self.WIDTH, 8)
self.setBrush(Qt.red)
self.text = QGraphicsTextItem(self)
self.text.setDefaultTextColor(Qt.white)
font = QFont('comic sans', 7)
self.text.setFont(font)
self.text.setPos(self.x(), self.y() - 7)
def update_bar(self):
# updates the bar graphics to the current amount of fullnes
fill_fraction = float(self.current_val) / self.max_val
self.text.setPlainText('{} / {}'.format(self.current_val,
self.max_val))
self.setRect(self.rect().x(),
self.rect().y(), fill_fraction * self.WIDTH, 8)
def get_current_val(self):
return self.current_val
def set_current_val(self, value):
self.current_val = value
def set_max_val(self, value):
self.max_val = value
def increment(self, amount):
# increase the amount the bar is filled and updates it
self.current_val += amount
self.update_bar()
def decrement(self, amount):
# decreases and updates
self.current_val -= amount
self.update_bar()
def actually_show_text(self, data):
text_item = QGraphicsTextItem()
text_item.setZValue(5)
if len(data) >= 8 and data[7] != None:
text_item.setDefaultTextColor(QColor(data[7]))
else:
text_item.setDefaultTextColor(QColor("#FFFFFF"))
text_item.setX(data[2])
text_item.setY(data[3])
text_item.setTextWidth(data[4])
text_item.setPlainText(data[5])
temp_font = text_item.font()
temp_font.setPointSize(data[6])
text_item.setFont(temp_font)
self.addItem(text_item)
self.texts[data[1]] = text_item
self.call_next_action()
class Video(QMainWindow):
def __init__(self):
super(Video, self).__init__()
self.resize(1920, 1080)
# ITEM
self._item = QGraphicsVideoItem()
self._textItem = QGraphicsTextItem()
self._view = QGraphicsView()
self._scene = QGraphicsScene()
self._view.resize(1920, 1080)
self._view.setScene(self._scene)
self._scene.addItem(self._item)
self._scene.addItem(self._textItem)
self._textItem.setPlainText('SRT TEXT')
self._textItem.setDefaultTextColor(Qt.red)
font = self._textItem.font()
font.setPixelSize(50)
self._textItem.setFont(font)
self._view.show()
self._item.setSize(QSizeF(1920, 1080))
self._player = QMediaPlayer(self)
self._player.setMedia(
QMediaContent(
QUrl.fromLocalFile(
'/Users/huangkai/Documents/PycharmProjects/AllTest/Qt插入背景/AddVideos/Videos/yellow.mov'
)))
self._player.setVideoOutput(self._item)
self._player.play()
self.setCentralWidget(self._view)
self._item.setPos(400, 500)
# BUTTON
self._btn = QPushButton(self)
self._btn.resize(100, 50)
self._btn.move(500, 500)
self._btn.setText('test')
self._btn.clicked.connect(self._change_text)
def _change_text(self):
self._textItem.setPlainText('Fighting')
def update_view(self, steno_layout: StenoLayout, stroke: List[str]):
''' Updates the layout display for the provided layout and stroke '''
scene = self.graphics_scene
pen = self._scene_pen
font = QFont(steno_layout.font) if steno_layout.font else QFont()
# Clear all items from the scene. Could be more efficient...
scene.clear()
scene.setBackgroundBrush(QBrush(QColor(steno_layout.background_color)))
for key in steno_layout.keys:
path = LayoutDisplayView._create_key_path(steno_layout, key)
brush = LayoutDisplayView._get_key_path_brush(key, (key.name in stroke))
pen.setColor(QColor(key.stroke_color))
# Add the key path before its label, then center the label
scene.addPath(path, pen, brush)
if key.label:
label = QGraphicsTextItem(key.label)
label.setFont(font)
label.setDefaultTextColor(QColor(key.font_color))
label_rect = label.boundingRect()
label_rect.moveCenter(path.boundingRect().center())
label.setPos(label_rect.x(), label_rect.y())
scene.addItem(label)
# Scene rects don't shrink when items are removed, so need to manually
# set it to the current size needed by the contained items + margin
margin = steno_layout.margin
scene_rect = scene.itemsBoundingRect()
scene_rect = scene_rect.marginsAdded(QMarginsF(margin, margin,
margin, margin))
scene.setSceneRect(scene_rect)
self.fitInView(scene.sceneRect(), Qt.KeepAspectRatio)
self.setScene(scene)
self.show()
def addCircle(self, index, points, r):
(x, y) = points
circleItem = QGraphicsEllipseItem(x - r, y - r, 2 * r, 2 * r)
circleItem.setPen(self.pen)
# self.scene.addItem(circleItem)
#横线
line1 = QGraphicsLineItem()
line1.setPen(self.pen)
line1.setLine(x - self.lineRadius, y, x + self.lineRadius, y)
#竖线
line2 = QGraphicsLineItem()
line2.setPen(self.pen)
line2.setLine(x, y - self.lineRadius, x, y + self.lineRadius)
#文字说明
text = QGraphicsTextItem()
text.setDefaultTextColor(Qt.blue)
text.setFont(self.font)
text.setPlainText(str(self.names[index]))
text.setPos(x, y)
#放到组中
pointGroup = QGraphicsItemGroup()
pointGroup.addToGroup(line1)
pointGroup.addToGroup(line2)
pointGroup.addToGroup(text)
pointGroup.addToGroup(circleItem)
#显示该点
self.scene.addItem(pointGroup)
self.pointsItem.append(pointGroup)
class KeyWidget(QGraphicsRectItem):
def __init__(self, rect: QRect, idx: int, note: str):
super().__init__(rect.x(), rect.y(), rect.width(), rect.height())
self.rect = rect
self.idx = idx
self.note = note
self.label = None
if note in WHITE_KEYS:
self.setBrush(WHITE_KEY_COLOR)
# set the label
self.label = QGraphicsTextItem()
self.label.setDefaultTextColor(Qt.black)
# font = self.label.font()
# font.setBold(True)
# self.label.setFont(font)
self.label.setZValue(100)
self.label.setPlainText(note)
self.label.setPos(
self.rect.x() + self.rect.width() / 2 -
self.label.boundingRect().width() / 2,
self.rect.y() + self.rect.height() * 0.8)
else:
self.setBrush(Qt.black)
def press(self, out_of_range=False):
if out_of_range:
self.setBrush(Qt.yellow)
else:
self.setBrush(Qt.gray)
def release(self):
if self.note in WHITE_KEYS:
self.setBrush(WHITE_KEY_COLOR)
else:
self.setBrush(BLACK_KEY_COLOR)
class QGraphicsResizableRect(QGraphicsRectItem):
hoverColor = QColor(255, 0, 0) #_hovering and selection color
def __init__(self,x,y,h,w, scene=None,parent=None, editor=None):
""""
This class implements the resizable rectangle item which is dispalied on the scene
x y should be the original positions in scene coordinates
h,w are the height and the width of the rectangle
"""
self._editor = editor
QGraphicsRectItem.__init__(self,0,0,w,h,parent=parent)
self.Signaller=QGraphicsResizableRectSignaller(parent=parent)
scene.addItem(self)
#Default Appearence Properties
self._fontColor=QColor(255, 255, 255)
self._fontSize=10
self._lineWidth=1
##Note: need to do like this because the x,y of the graphics item fix the position
# of the zero relative to the scene
self.moveBy(x,y)
#Flags
self.setFlag(QGraphicsItem.ItemIsMovable,True )
self.setFlag(QGraphicsItem.ItemIsSelectable,True)
self.setFlag(QGraphicsItem.ItemSendsGeometryChanges ,True)
self.setAcceptHoverEvents(True)
self.setAcceptedMouseButtons(Qt.LeftButton | Qt.RightButton)
self._resizeHandles=[]
# A bit of flags
self._hovering=False
self._normalColor = QColor(0, 0, 255)
self.updateColor()
self._has_moved=False
self._selected=False
self._dbg=False
self._setupTextItem()
self._isFixed = False
self.initHandles()
self.hideHandles()
self.setToolTip("Hold CTRL to drag the box")
@property
def fontColor(self):
return self._fontColor
@pyqtSlot(int)
def setFontColor(self,color):
self._fontColor=color
self.textItem.setDefaultTextColor(color)
self.updateText(self.textItem.toPlainText())
@property
def fontSize(self):
return self._fontSize
@pyqtSlot(int)
def setFontSize(self,s):
self._fontSize=s
font=QFont()
font.setPointSize(self._fontSize)
self.textItem.setFont(font)
self.updateText(self.textItem.toPlainText())
@property
def lineWidth(self):
return self._lineWidth
@pyqtSlot(int)
def setLineWidth(self,s):
self._lineWidth=s
self.updateColor()
@property
def color(self):
return self._normalColor
@pyqtSlot(int)
def setColor(self,qcolor):
self._normalColor=qcolor
self.updateColor()
@pyqtSlot()
def _setupTextItem(self):
#Set up the text
self.textItem=QGraphicsTextItem("",parent=self)
textItem=self.textItem
font=QFont()
font.setPointSize(self._fontSize)
textItem.setFont(font)
textItem.setPos(QPointF(0,0)) #upper left corner relative to the father
textItem.setDefaultTextColor(self._fontColor)
if self._dbg:
#another text item only for debug
self.textItemBottom=QGraphicsTextItem("",parent=self)
self.textItemBottom.setPos(QPointF(self.width,self.height))
self.textItemBottom.setDefaultTextColor(QColor(255, 255, 255))
self._updateTextBottom("shape " +str(self.shape))
@pyqtSlot(str)
def _updateTextBottom(self,string):
self.textItemBottom.setPlainText(string)
def setNewSize(self, constrainAxis, size, flip=False):
if constrainAxis == 0:
h,w = size, self.rect().width()
else:
h,w = self.rect().height(), size
if flip and constrainAxis ==0:
w=-w
if flip and constrainAxis ==1:
h=-h
newrect=QRectF(0, 0, w, h).normalized()
self.setRect(newrect)
self.width=self.rect().width()
self.height=self.rect().height()
self.shape=(self.height,self.width)
#Ensures that the text is in the upper left corner
a=0
b=0
if w<=0: a=w
if h<=0: b=h
self.textItem.setPos(QPointF(a,b))
if self._dbg:
self.textItemBottom.setPos(QPointF(self.width,self.height))
for el in self._resizeHandles:
#print "shape = %s , left = %s , right = %s , top = %s , bottm , %s "%(self.shape,self.rect().left(),self.rect().right(),self.rect().top(),self.rect().bottom())
el.resetOffset(el._constrainAxis,rect=newrect)
self.Signaller.signalHasResized.emit()
def hoverEnterEvent(self, event):
event.setAccepted(True)
self._hovering = True
#elf.setCursor(Qt.BlankCursor)
#self.radius = self.radius # modified radius b/c _hovering
self.updateColor()
self.setSelected(True)
self.showHandles()
super(QGraphicsResizableRect,self).hoverEnterEvent( event)
self._editor.imageViews[2].setFocus()
def hoverLeaveEvent(self, event):
event.setAccepted(True)
self._hovering = False
self.setSelected(False)
#self.setCursor(CURSOR)
#self.radius = self.radius # no longer _hovering
self.hideHandles()
super(QGraphicsResizableRect,self).hoverLeaveEvent( event)
def initHandles(self):
for constrAxes in range(2):
h = ResizeHandle(self.rect(), constrAxes, self)
self._resizeHandles.append( h )
def moveHandles(self):
for h, constrAxes in zip(self._resizeHandles, list(range(2))):
h.resetOffset(constrAxes, self.rect())
def hideHandles(self):
for h in self._resizeHandles:
h.hide()
def showHandles(self):
for h in self._resizeHandles:
h.show()
@pyqtSlot(int)
def setSelected(self, selected):
QGraphicsRectItem.setSelected(self, selected)
if self.isSelected(): self.Signaller.signalSelected.emit()
if not self.isSelected(): self._hovering=False
self.updateColor()
#self.resetHandles()
@pyqtSlot()
def updateColor(self):
color = self.hoverColor if (self._hovering or self.isSelected()) else self._normalColor
self.setPen(QPen(color,self._lineWidth))
self.setBrush(QBrush(color, Qt.NoBrush))
def dataPos(self):
dataPos = self.scenePos()
pos = [int(dataPos.x()), int(dataPos.y())]
return pos
def topLeftDataPos(self):
dataPos = self.rect().topLeft()+self.scene().scene2data.map(self.scenePos())
pos = [int(dataPos.x()), int(dataPos.y())]
return pos
def bottomRightDataPos(self):
dataPos = self.rect().bottomRight()+self.scene().scene2data.map(self.scenePos())
pos = [int(dataPos.x()), int(dataPos.y())]
return pos
def mousePressEvent(self,event):
modifiers=QApplication.queryKeyboardModifiers()
if modifiers == Qt.ControlModifier:
QApplication.setOverrideCursor(Qt.ClosedHandCursor)
def mouseMoveEvent(self,event):
pos=self.dataPos()
modifiers=QApplication.queryKeyboardModifiers()
if modifiers == Qt.ControlModifier:
self._has_moved=True
super(QGraphicsResizableRect, self).mouseMoveEvent(event)
string=str(self.pos()).split("(")[1][:-1]
#self.QResizableRect.signalIsMoving.emit()
# dataPos = self.scene().scene2data.map(self.scenePos())
# pos = [dataPos.x(), dataPos.y()]
#self.updateText("("+string+")"+" "+str(pos))
def mouseDoubleClickEvent(self, event):
logger.debug("DOUBLE CLICK ON ITEM")
#FIXME: Implement me
event.accept()
@pyqtSlot(str)
def updateText(self,string):
self.textItem.setPlainText(string)
def mouseReleaseEvent(self, event):
if self._has_moved:
self.Signaller.signalHasMoved.emit(self.pos())
#self._has_moved=False
self._has_moved=False
QApplication.restoreOverrideCursor()
return QGraphicsRectItem.mouseReleaseEvent(self, event)
def itemChange(self, change,value):
if change==QGraphicsRectItem.ItemPositionChange:
newPos=value #new position in scene coordinates
rect=self.scene().sceneRect()
topLeftRectCoords=self.rect().topLeft()
bottomRightRectCoords=self.rect().bottomRight()
ntl=topLeftRectCoords+newPos
nbr=bottomRightRectCoords+newPos
if not rect.contains(ntl) or not rect.contains(nbr):
ntl.setX(min(rect.right()-self.rect().width(), max(ntl.x(),rect.left())))
ntl.setY(min(rect.bottom()-self.rect().height(), max(ntl.y(), rect.top())));
return ntl-topLeftRectCoords
return QGraphicsRectItem.itemChange(self, change,value)
def setOpacity(self,float):
logger.debug("Resetting Opacity {}".format(float))
self._normalColor.setAlpha(float*255)
self.updateColor()
def fixSelf(self, isFixed):
self._isFixed = isFixed
self.setFlag(QGraphicsItem.ItemIsMovable,not isFixed)
class OcrArea(QGraphicsRectItem):
## static data
resizeBorder = .0
def __init__(self, pos, size, type_, parent = None, scene = None,
areaBorder = 2, index = 0, textSize = 50):
QGraphicsRectItem.__init__(self, 0, 0, size.width(), size.height(),
parent)
self.setPos(pos)
self.newEvent = IsClicked()
self.newEvent.area = self
#self.setAcceptedMouseButtons(QtCore.Qt.NoButton)
self.setFlags(QGraphicsItem.ItemIsMovable |
QGraphicsItem.ItemIsFocusable |
QGraphicsItem.ItemIsSelectable)
## set index label
self.text = QGraphicsTextItem("%d" % index, self)
self.setTextSize(textSize)
## TODO: How to create constants for the type?
## (such as constants in Qt) (enum?)
self.kind = type_
pen = QPen(self.color, areaBorder, Qt.SolidLine,
Qt.RoundCap, Qt.RoundJoin)
self.setPen(pen)
# self.setAcceptsHoverEvents(True) # TODO
# self.text.setFlag(QtGui.QGraphicsItem.ItemIgnoresTransformations)
def setIndex(self, idx):
self.text.setPlainText(str(idx))
def setTextSize(self, size):
font = QFont()
font.setPointSizeF(size)
self.text.setFont(font)
def contextMenuEvent(self, event):
menu = QMenu()
removeAction = menu.addAction(QA.translate('QOcrWidget', "Remove"))
#Action = menu.addAction(self.scene().tr("Remove"))
menu.addSeparator()
textAction = menu.addAction(QA.translate('QOcrWidget', "Text"))
graphicsAction = menu.addAction(QA.translate('QOcrWidget', "Graphics"))
## verification of the type of the selection and
## setting a check box near the type that is in use
textAction.setCheckable(True)
graphicsAction.setCheckable(True)
if self.kind == 1:
textAction.setChecked(True)
elif self.kind == 2:
graphicsAction.setChecked(True)
selectedAction = menu.exec_(event.screenPos())
if selectedAction == removeAction:
self.scene().removeArea(self)
elif selectedAction == textAction:
self.kind = 1
elif selectedAction == graphicsAction:
self.kind = 2
# when the area is selected the signal "isClicked()" is raised
def mousePressEvent(self, event):
self.newEvent.isClicked.emit()
QGraphicsRectItem.mousePressEvent(self, event)
# type property
def _setType(self, type_):
self.__type = type_
if self.__type == 1:
self.color = Qt.darkGreen
else: ## TODO: else -> elif ... + else raise exception
self.color = Qt.blue
self.text.setDefaultTextColor(self.color)
pen = self.pen()
pen.setColor(self.color)
self.setPen(pen)
def _type(self):
return self.__type
kind = property(fget=_type, fset=_setType)
class QGraphicsResizableRect(QGraphicsRectItem):
hoverColor = QColor(255, 0, 0) # _hovering and selection color
def __init__(self, x, y, h, w, scene=None, parent=None, editor=None):
""""
This class implements the resizable rectangle item which is dispalied on the scene
x y should be the original positions in scene coordinates
h,w are the height and the width of the rectangle
"""
self._editor = editor
QGraphicsRectItem.__init__(self, 0, 0, w, h, parent=parent)
self.Signaller = QGraphicsResizableRectSignaller(parent=parent)
scene.addItem(self)
# Default Appearence Properties
self._fontColor = QColor(255, 255, 255)
self._fontSize = 10
self._lineWidth = 1
##Note: need to do like this because the x,y of the graphics item fix the position
# of the zero relative to the scene
self.moveBy(x, y)
# Flags
self.setFlag(QGraphicsItem.ItemIsMovable, True)
self.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.setFlag(QGraphicsItem.ItemSendsGeometryChanges, True)
self.setAcceptHoverEvents(True)
self.setAcceptedMouseButtons(Qt.LeftButton | Qt.RightButton)
self._resizeHandles = []
# A bit of flags
self._hovering = False
self._normalColor = QColor(0, 0, 255)
self.updateColor()
self._has_moved = False
self._selected = False
self._dbg = False
self._setupTextItem()
self._isFixed = False
self.initHandles()
self.hideHandles()
self.setToolTip("Hold CTRL to drag the box")
@property
def fontColor(self):
return self._fontColor
@pyqtSlot(int)
def setFontColor(self, color):
self._fontColor = color
self.textItem.setDefaultTextColor(color)
self.updateText(self.textItem.toPlainText())
@property
def fontSize(self):
return self._fontSize
@pyqtSlot(int)
def setFontSize(self, s):
self._fontSize = s
font = QFont()
font.setPointSize(self._fontSize)
self.textItem.setFont(font)
self.updateText(self.textItem.toPlainText())
@property
def lineWidth(self):
return self._lineWidth
@pyqtSlot(int)
def setLineWidth(self, s):
self._lineWidth = s
self.updateColor()
@property
def color(self):
return self._normalColor
@pyqtSlot(int)
def setColor(self, qcolor):
self._normalColor = qcolor
self.updateColor()
@pyqtSlot()
def _setupTextItem(self):
# Set up the text
self.textItem = QGraphicsTextItem("", parent=self)
textItem = self.textItem
font = QFont()
font.setPointSize(self._fontSize)
textItem.setFont(font)
textItem.setPos(QPointF(0, 0)) # upper left corner relative to the father
textItem.setDefaultTextColor(self._fontColor)
if self._dbg:
# another text item only for debug
self.textItemBottom = QGraphicsTextItem("", parent=self)
self.textItemBottom.setPos(QPointF(self.width, self.height))
self.textItemBottom.setDefaultTextColor(QColor(255, 255, 255))
self._updateTextBottom("shape " + str(self.shape))
@pyqtSlot(str)
def _updateTextBottom(self, string):
self.textItemBottom.setPlainText(string)
def setNewSize(self, constrainAxis, size, flip=False):
if constrainAxis == 0:
h, w = size, self.rect().width()
else:
h, w = self.rect().height(), size
if flip and constrainAxis == 0:
w = -w
if flip and constrainAxis == 1:
h = -h
newrect = QRectF(0, 0, w, h).normalized()
self.setRect(newrect)
self.width = self.rect().width()
self.height = self.rect().height()
self.shape = (self.height, self.width)
# Ensures that the text is in the upper left corner
a = 0
b = 0
if w <= 0:
a = w
if h <= 0:
b = h
self.textItem.setPos(QPointF(a, b))
if self._dbg:
self.textItemBottom.setPos(QPointF(self.width, self.height))
for el in self._resizeHandles:
# print "shape = %s , left = %s , right = %s , top = %s , bottm , %s "%(self.shape,self.rect().left(),self.rect().right(),self.rect().top(),self.rect().bottom())
el.resetOffset(el._constrainAxis, rect=newrect)
self.Signaller.signalHasResized.emit()
def hoverEnterEvent(self, event):
event.setAccepted(True)
self._hovering = True
# elf.setCursor(Qt.BlankCursor)
# self.radius = self.radius # modified radius b/c _hovering
self.updateColor()
self.setSelected(True)
self.showHandles()
super(QGraphicsResizableRect, self).hoverEnterEvent(event)
self._editor.imageViews[2].setFocus()
def hoverLeaveEvent(self, event):
event.setAccepted(True)
self._hovering = False
self.setSelected(False)
# self.setCursor(CURSOR)
# self.radius = self.radius # no longer _hovering
self.hideHandles()
super(QGraphicsResizableRect, self).hoverLeaveEvent(event)
def initHandles(self):
for constrAxes in range(2):
h = ResizeHandle(self.rect(), constrAxes, self)
self._resizeHandles.append(h)
def moveHandles(self):
for h, constrAxes in zip(self._resizeHandles, list(range(2))):
h.resetOffset(constrAxes, self.rect())
def hideHandles(self):
for h in self._resizeHandles:
h.hide()
def showHandles(self):
for h in self._resizeHandles:
h.show()
@pyqtSlot(int)
def setSelected(self, selected):
QGraphicsRectItem.setSelected(self, selected)
if self.isSelected():
self.Signaller.signalSelected.emit()
if not self.isSelected():
self._hovering = False
self.updateColor()
# self.resetHandles()
@pyqtSlot()
def updateColor(self):
color = self.hoverColor if (self._hovering or self.isSelected()) else self._normalColor
self.setPen(QPen(color, self._lineWidth))
self.setBrush(QBrush(color, Qt.NoBrush))
def dataPos(self):
dataPos = self.scenePos()
pos = [int(dataPos.x()), int(dataPos.y())]
return pos
def topLeftDataPos(self):
dataPos = self.rect().topLeft() + self.scene().scene2data.map(self.scenePos())
pos = [int(dataPos.x()), int(dataPos.y())]
return pos
def bottomRightDataPos(self):
dataPos = self.rect().bottomRight() + self.scene().scene2data.map(self.scenePos())
pos = [int(dataPos.x()), int(dataPos.y())]
return pos
def mousePressEvent(self, event):
modifiers = QApplication.queryKeyboardModifiers()
if modifiers == Qt.ControlModifier:
QApplication.setOverrideCursor(Qt.ClosedHandCursor)
def mouseMoveEvent(self, event):
pos = self.dataPos()
modifiers = QApplication.queryKeyboardModifiers()
if modifiers == Qt.ControlModifier:
self._has_moved = True
super(QGraphicsResizableRect, self).mouseMoveEvent(event)
string = str(self.pos()).split("(")[1][:-1]
# self.QResizableRect.signalIsMoving.emit()
# dataPos = self.scene().scene2data.map(self.scenePos())
# pos = [dataPos.x(), dataPos.y()]
# self.updateText("("+string+")"+" "+str(pos))
def mouseDoubleClickEvent(self, event):
logger.debug("DOUBLE CLICK ON ITEM")
# FIXME: Implement me
event.accept()
@pyqtSlot(str)
def updateText(self, string):
self.textItem.setPlainText(string)
def mouseReleaseEvent(self, event):
if self._has_moved:
self.Signaller.signalHasMoved.emit(self.pos())
# self._has_moved=False
self._has_moved = False
QApplication.restoreOverrideCursor()
return QGraphicsRectItem.mouseReleaseEvent(self, event)
def itemChange(self, change, value):
if change == QGraphicsRectItem.ItemPositionChange:
newPos = value # new position in scene coordinates
rect = self.scene().sceneRect()
topLeftRectCoords = self.rect().topLeft()
bottomRightRectCoords = self.rect().bottomRight()
ntl = topLeftRectCoords + newPos
nbr = bottomRightRectCoords + newPos
if not rect.contains(ntl) or not rect.contains(nbr):
ntl.setX(min(rect.right() - self.rect().width(), max(ntl.x(), rect.left())))
ntl.setY(min(rect.bottom() - self.rect().height(), max(ntl.y(), rect.top())))
return ntl - topLeftRectCoords
return QGraphicsRectItem.itemChange(self, change, value)
def setOpacity(self, float):
logger.debug("Resetting Opacity {}".format(float))
self._normalColor.setAlpha(float * 255)
self.updateColor()
def fixSelf(self, isFixed):
self._isFixed = isFixed
self.setFlag(QGraphicsItem.ItemIsMovable, not isFixed)
class TcamScreen(QtWidgets.QGraphicsView):
new_pixmap = pyqtSignal(QtGui.QPixmap)
new_pixel_under_mouse = pyqtSignal(bool, int, int, QtGui.QColor)
destroy_widget = pyqtSignal()
fit_in_view = pyqtSignal()
def __init__(self, parent=None):
super(TcamScreen, self).__init__(parent)
self.setMouseTracking(True)
self.setSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding)
self.setDragMode(QGraphicsView.ScrollHandDrag)
self.setFrameStyle(0)
self.scene = QGraphicsScene(self)
self.setScene(self.scene)
self.new_pixmap.connect(self.on_new_pixmap)
self.fit_in_view.connect(self.fit_view)
self.pix = ViewItem()
self.scene.addItem(self.pix)
self.scene.setSceneRect(self.pix.boundingRect())
self.is_fullscreen = False
# Flag to differentiate between actual images
# and 'fake images' i.e. color background + text while
# waiting for first trigger image
self.display_real_image = True
self.text_item = None
self.fit_in_view_called = False
self.mouse_position_x = -1
self.mouse_position_y = -1
self.zoom_factor = 1.0
self.first_image = True
self.image_counter = 0
self.capture_roi = False
self.roi_obj = None
self.roi_origin = None
self.roi_widgets = []
self.selection_area = None
self.capture_widget = None
self.origin = None
def fit_view(self):
"""
"""
self.reset_zoom()
self.scene.setSceneRect(self.pix.boundingRect())
self.scene.update()
self.fitInView(self.scene.sceneRect(), Qt.KeepAspectRatio)
def reset_zoom(self):
self.zoom_factor = 1.0
# this resets the view internal transformation matrix
self.setTransform(QtGui.QTransform())
def on_new_pixmap(self, pixmap):
self.image_counter += 1
self.pix.setPixmap(pixmap)
if not self.display_real_image:
self.text_item.hide()
self.scene.removeItem(self.text_item)
self.display_real_image = True
if self.image_counter == 1:
self.resize(self.size())
self.scene.setSceneRect(self.pix.boundingRect())
self.update()
self.reset_zoom()
self.first_image = False
# wait for the second image
# resizeEvents, etc appear before the scene has adjusted
# to the actual image size. By waiting for the 2. image
# we circumvent this by having the first image making all
# adjustments for us. The only scenario where this will
# cause problems is triggering.
if self.is_fullscreen and self.image_counter == 2:
self.fit_view()
self.send_mouse_pixel()
# don't call repaint here
# it causes problems once the screen goes blank due to screensavers, etc
# self.repaint()
def wait_for_first_image(self):
if not self.display_real_image:
return
self.reset_zoom()
self.display_real_image = False
self.text_item = QGraphicsTextItem()
self.text_item.setDefaultTextColor(QColor("white"))
self.text_item.setPos(100, 70)
self.text_item.setPlainText("In Trigger Mode. Waiting for first image...")
bg = QPixmap(1280, 720)
bg.fill(QColor("grey"))
self.pix.setPixmap(bg)
self.image_counter += 1
self.scene.addItem(self.text_item)
def send_mouse_pixel(self):
# mouse positions start at 0
# we want the lower right corner to have the correct coordinates
# e.g. an 1920x1080 image should have the coordinates
# 1920x1080 for the last pixel
self.new_pixel_under_mouse.emit(self.pix.legal_coordinates(self.mouse_position_x,
self.mouse_position_y),
self.mouse_position_x + 1,
self.mouse_position_y + 1,
self.pix.get_color_at_position(self.mouse_position_x,
self.mouse_position_y))
def mouseMoveEvent(self, event):
mouse_position = self.mapToScene(event.pos())
self.mouse_position_x = mouse_position.x()
self.mouse_position_y = mouse_position.y()
if self.selection_area:
# adjust rect since we want to pull in all directions
# origin can well be bottom left, thus recalc
def calc_selection_rect():
x = min(self.origin.x(), event.pos().x())
y = min(self.origin.y(), event.pos().y())
x2 = max(self.origin.x(), event.pos().x())
y2 = max(self.origin.y(), event.pos().y())
return QPoint(x, y), QPoint(x2, y2)
p1, p2 = calc_selection_rect()
self.selection_area.setGeometry(QRect(p1, p2))
super().mouseMoveEvent(event)
def mousePressEvent(self, event):
""""""
if self.capture_widget:
self.selection_area = QRubberBand(QRubberBand.Rectangle, self)
self.selection_area.setGeometry(QRect(event.pos(), QSize()))
self.origin = event.pos()
self.selection_area.show()
super().mousePressEvent(event)
def mouseReleaseEvent(self, event):
if self.capture_widget:
selectionBBox = self.selection_area.rect()
rect = QRect(self.selection_area.pos(), selectionBBox.size())
selectionBBox = self.mapToScene(rect).boundingRect().toRect()
self.capture_widget.emit(selectionBBox)
self.selection_area.hide()
self.selection_area = None
QApplication.restoreOverrideCursor()
self.capture_widget = None
self.selection_area = None
super().mouseReleaseEvent(event)
def is_scene_larger_than_image(self):
"""
checks if the entire ViewItem is visible in the scene
"""
port_rect = self.viewport().rect()
scene_rect = self.mapToScene(port_rect).boundingRect()
item_rect = self.pix.mapRectFromScene(scene_rect)
isec = item_rect.intersected(self.pix.boundingRect())
res = self.pix.get_resolution()
if (isec.size().width() >= QSizeF(res).width() and
isec.size().height() >= QSizeF(res).height()):
return True
return False
def wheelEvent(self, event):
if not self.display_real_image:
return
# Zoom Factor
zoomInFactor = 1.25
zoomOutFactor = 1 / zoomInFactor
# Set Anchors
self.setTransformationAnchor(QGraphicsView.NoAnchor)
self.setResizeAnchor(QGraphicsView.NoAnchor)
# Save the scene pos
oldPos = self.mapToScene(event.pos())
# Zoom
if event.angleDelta().y() > 0:
zoomFactor = zoomInFactor
else:
zoomFactor = zoomOutFactor
if (self.is_scene_larger_than_image() and
zoomFactor < 1.0):
return
self.zoom_factor *= zoomFactor
# we scale the view itself to get infinite zoom
# so that we can inspect a single pixel
self.scale(zoomFactor, zoomFactor)
# Get the new position
newPos = self.mapToScene(event.pos())
# Move scene to old position
delta = newPos - oldPos
self.translate(delta.x(), delta.y())
self.scene.setSceneRect(self.pix.boundingRect())
def set_scale_position(self, scale_factor, x, y):
self.scale(scale_factor, scale_factor)
self.translate(x, y)
def keyPressEvent(self, event):
if self.isFullScreen():
if (event.key() == Qt.Key_F11 or
event.key() == Qt.Key_Escape or
event.key() == Qt.Key_F):
self.destroy_widget.emit()
elif self.capture_widget and event.key() == Qt.Key_Escape:
self.abort_roi_capture()
else:
# Ignore event so that parent widgets can use it.
# This is only called when we are not fullscreen.
# Fullscreen causes us to have no parents.
event.ignore()
def start_roi_capture(self, finished_signal):
"""
Capture a region of interest
"""
self.capture_widget = finished_signal
QApplication.setOverrideCursor(Qt.CrossCursor)
def abort_roi_capture(self):
"""
Abort the capture of a regoin of interest
"""
self.capture_widget = None
self.origin = None
if self.selection_area:
self.selection_area.hide()
self.selection_area = None
QApplication.restoreOverrideCursor()
def add_roi(self, roi_widget):
"""
Add roi_widget to the QGraphicsScene for display
"""
if not roi_widget:
return
self.roi_widgets.append(roi_widget)
self.scene.addItem(roi_widget)
roi_widget.show()
def remove_roi(self, roi_widget):
"""
Remove given roi widget from the scene
"""
if not roi_widget:
return
roi_widget.hide()
try:
self.roi_widgets.remove(roi_widget)
except ValueError as e:
# This means the widget is not in the list
pass
def draw_fretboard(self, scene, posX, posY):
# Real 22 frets Gibson guitar scale length
SCALE_LENGTH = [
0, 35.28, 68.59, 100.02, 129.69, 157.69, 184.13, 209.08, 232.63,
254.85, 275.83, 295.63, 314.32, 331.98, 348.61, 364.34, 379.17,
393.17, 406.39, 418.86, 430.64, 441.75, 452.24
]
# Increase them for better representation
self.scaleLength = [i * 3 for i in SCALE_LENGTH]
# Distance between two strings
DISTANCE = 34
# Starting cooridnates
x = posX
y = posY
# Note coordinates of the strings
# Open position coordinates
self.sNoteCoordinate1 = [QPoint(x, y)]
self.sNoteCoordinate2 = [QPoint(x, y + DISTANCE)]
self.sNoteCoordinate3 = [QPoint(x, y + DISTANCE * 2)]
self.sNoteCoordinate4 = [QPoint(x, y + DISTANCE * 3)]
self.sNoteCoordinate5 = [QPoint(x, y + DISTANCE * 4)]
self.sNoteCoordinate6 = [QPoint(x, y + DISTANCE * 5)]
# Offset from the open position
OFFSET = 30
# The remaining position coordinates
for i in range(len(self.scaleLength) - 1):
x = self.scaleLength[i] + (
(self.scaleLength[i + 1] - self.scaleLength[i]) /
2) + OFFSET - 14
self.sNoteCoordinate1.append(QPoint(x, y))
self.sNoteCoordinate2.append(QPoint(x, y + DISTANCE))
self.sNoteCoordinate3.append(QPoint(x, y + DISTANCE * 2))
self.sNoteCoordinate4.append(QPoint(x, y + DISTANCE * 3))
self.sNoteCoordinate5.append(QPoint(x, y + DISTANCE * 4))
self.sNoteCoordinate6.append(QPoint(x, y + DISTANCE * 5))
# Store the strings in a list for better iteration
self.sNoteCoordinates = []
self.sNoteCoordinates.append(self.sNoteCoordinate6)
self.sNoteCoordinates.append(self.sNoteCoordinate5)
self.sNoteCoordinates.append(self.sNoteCoordinate4)
self.sNoteCoordinates.append(self.sNoteCoordinate3)
self.sNoteCoordinates.append(self.sNoteCoordinate2)
self.sNoteCoordinates.append(self.sNoteCoordinate1)
# Starting guitar string cooridnates
x = posX
y = posY
# Draw outer fretboard box
whitePen = QPen(Qt.white)
whitePen.setWidth(5)
whitePen.setJoinStyle(Qt.MiterJoin)
brownBrush = QBrush(QColor(75, 30, 0))
rect1 = QRectF(x, y, self.scaleLength[-1] + OFFSET, DISTANCE * 6)
scene.addRect(rect1, whitePen, brownBrush)
whiteBrush = QBrush(Qt.white)
rect2 = QRectF(x, y, x + OFFSET, DISTANCE * 6)
scene.addRect(rect2, whitePen, whiteBrush)
# Starting inlay cooridnates
x = posX
y = posY
# Trapezoid inlay color
gradient = QLinearGradient(0, 0, 50, 50)
gradient.setColorAt(0.0, QColor(200, 200, 200))
gradient.setColorAt(0.5, Qt.white)
gradient.setColorAt(1.0, QColor(200, 200, 200))
gradient.setSpread(QGradient.ReflectSpread)
grayPen = QPen(QColor(216, 216, 216))
grayBrush = QBrush(gradient)
# The 3rd, 5th, 7th and 9th inlay
leftTrim = 5
rightTrim = 40
j = 2
for i in range(4):
x1 = x + self.scaleLength[j] + (
(self.scaleLength[j + 1] - self.scaleLength[j]) / 2) + leftTrim
x2 = x + self.scaleLength[j + 1] + (
(self.scaleLength[i + 2] - self.scaleLength[i + 1]) /
2) - rightTrim
path = QPainterPath()
path.moveTo(x1, y + DISTANCE)
path.lineTo(x1, y + DISTANCE * 5)
path.lineTo(x2, y + DISTANCE * 5 - 20)
path.lineTo(x2, y + DISTANCE + 15)
path.closeSubpath()
scene.addPath(path, grayPen, grayBrush)
leftTrim += 2
rightTrim -= 5
j += 2
# The 12th inlay
leftTrim = 15
rightTrim = 8
x1 = x + self.scaleLength[11] + (
(self.scaleLength[12] - self.scaleLength[11]) / 2) + leftTrim
x2 = x + self.scaleLength[12] + (
(self.scaleLength[13] - self.scaleLength[12]) / 2) - rightTrim
path = QPainterPath()
path.moveTo(x1, y + DISTANCE)
path.lineTo(x1, y + DISTANCE * 5)
path.lineTo(x2, y + DISTANCE * 5 - 20)
path.lineTo(x2, y + DISTANCE + 15)
path.closeSubpath()
scene.addPath(path, grayPen, grayBrush)
# The 15th, 17th, 19th and 21th inlay
leftTrim = 15
rightTrim = 28
j = 14
for i in range(4):
x1 = x + self.scaleLength[j] + (
(self.scaleLength[j + 1] - self.scaleLength[j]) / 2) + leftTrim
x2 = x + self.scaleLength[j + 1] + (
(self.scaleLength[i + 2] - self.scaleLength[i + 1]) /
2) - rightTrim
path = QPainterPath()
path.moveTo(x1, y + DISTANCE)
path.lineTo(x1, y + DISTANCE * 5)
path.lineTo(x2, y + DISTANCE * 5 - 20)
path.lineTo(x2, y + DISTANCE + 15)
path.closeSubpath()
scene.addPath(path, grayPen, grayBrush)
leftTrim += 2
rightTrim -= 1 + (i + 1)
j += 2
# Starting guitar string cooridnates
x = posX
y = posY - 20
# Draw the guitar strings
s = QLineF(x, y, x + self.scaleLength[-1] + OFFSET, y)
whitePen = QPen(Qt.white)
whitePen.setWidth(1)
startHPos = DISTANCE
stringWidth = 1
for i in range(6):
whitePen.setWidth(stringWidth)
guitarString = scene.addLine(s, whitePen)
guitarString.setPos(0, startHPos)
startHPos += DISTANCE
stringWidth += 0.4
# Starting fret cooridnates
x = posX
y = posY
# Draw the frets
fretPen = QPen(Qt.white)
fretPen.setWidth(5)
fret = QLineF(x + OFFSET, y, x + OFFSET, y + DISTANCE * 6 - 5)
for i in range(len(self.scaleLength)):
guitarFret = scene.addLine(fret, fretPen)
guitarFret.setPos(self.scaleLength[i], 0)
# Add fret numbers
for i in range(22):
fret_num = QGraphicsTextItem(str(i))
fret_num.setFont(QFont("Verdana", 20))
fret_num.setDefaultTextColor(QColor(Qt.red))
fret_num.setPos(self.scaleLength[i], 220)
scene.addItem(fret_num)
class QNEPort(QGraphicsPathItem):
(NamePort, TypePort) = (1, 2)
(Type) = (QGraphicsItem.UserType + 1)
def __init__(self, parent):
super(QNEPort, self).__init__(parent)
self.textColor = Qt.black
self.label = QGraphicsTextItem(self)
self.radius_ = 4
self.margin = 3
self.setPen(QPen(Qt.darkRed))
self.setBrush(Qt.red)
self.setFlag(QGraphicsItem.ItemSendsScenePositionChanges)
self.m_portFlags = 0
self.isOutput_ = False
self.m_block = None
self.m_connections = []
def __del__(self):
#print("Del QNEPort %s" % self.name)
for connection in self.m_connections:
if connection.port1():
connection.port1().removeConnection(connection)
if connection.port2():
connection.port2().removeConnection(connection)
if self.scene():
self.scene().removeItem(connection)
def setName(self, name):
self.name = name
self.label.setPlainText(name)
self.label.setDefaultTextColor(self.textColor)
self.setBrush(Qt.red)
def setIsOutput(self, isOutput):
self.isOutput_ = isOutput
path = QPainterPath()
if self.isOutput_:
if self.name == '':
path.addRect(-2 * self.radius_, -self.radius_,
2 * self.radius_, 2 * self.radius_)
self.label.setPos(
-self.radius_ - self.margin -
self.label.boundingRect().width(),
-self.label.boundingRect().height() / 2)
else:
path.addEllipse(-2 * self.radius_, -self.radius_,
2 * self.radius_, 2 * self.radius_)
self.label.setPos(
-self.radius_ - self.margin -
self.label.boundingRect().width(),
-self.label.boundingRect().height() / 2)
else:
if self.name == '':
path.addRect(0, -self.radius_, 2 * self.radius_,
2 * self.radius_)
self.label.setPos(self.radius_ + self.margin,
-self.label.boundingRect().height() / 2)
else:
path.addEllipse(0, -self.radius_, 2 * self.radius_,
2 * self.radius_)
self.label.setPos(self.radius_ + self.margin,
-self.label.boundingRect().height() / 2)
self.setPath(path)
def setNEBlock(self, block):
self.m_block = block
def setPortFlags(self, flags):
self.m_portFlags = flags
if self.m_portFlags & self.TypePort:
font = self.scene().font()
font.setItalic(True)
self.label.setFont(font)
self.setPath(QPainterPath())
elif self.m_portFlags & self.NamePort:
font = self.scene().font()
font.setBold(True)
self.label.setFont(font)
self.setPath(QPainterPath())
def setPtr(self, ptr):
self.m_ptr = ptr
def type(self):
return self.Type
def radius(self):
return self.radius_
def portName(self):
return self.name
def isOutput(self):
return self.isOutput_
def block(self):
return self.m_block
def portFlags(self):
return self.m_portFlags
def ptr(self):
return self.m_ptr
def addConnection(self, connection):
self.m_connections.append(connection)
def removeConnection(self, connection):
try:
self.m_connections.remove(connection)
except:
pass
def connections(self):
return self.m_connections
def isConnected(self, other):
for connection in self.m_connections:
if connection.port1() == other or connection.port2() == other:
return True
return False
def itemChange(self, change, value):
if change == QGraphicsItem.ItemScenePositionHasChanged:
for connection in self.m_connections:
connection.updatePosFromPorts()
connection.updatePath()
return value
class MatchEnd(InfoScene):
def __init__(self, parent):
super().__init__()
self.__parent__ = parent
self.font = QFont()
self.font.setPointSize(20)
self.my_points = QGraphicsTextItem(str(self.__parent__.my_score))
self.my_points.setDefaultTextColor(Qt.white)
self.my_points.setFont(self.font)
self.opponent_points = QGraphicsTextItem(
str(self.__parent__.opponent_score))
self.opponent_points.setDefaultTextColor(Qt.white)
self.opponent_points.setFont(self.font)
self.logo = QGraphicsPixmapItem()
self.logo.setPos((SCENE_WIDTH - 600) / 2, 50)
if self.__parent__.player == Player.PLAYER_1:
self.my_points.setPos(50, 250)
self.opponent_points.setPos(
SCENE_WIDTH -
(50 + self.opponent_points.boundingRect().width()), 250)
else:
self.opponent_points.setPos(50, 250)
self.my_points.setPos(
SCENE_WIDTH -
(50 + self.opponent_points.boundingRect().width()), 250)
self.buttons = [
Button(self.__parent__.load_info_scene, InfoScenes.MAIN_MENU.value,
(SCENE_WIDTH - 300) / 2, SCENE_HEIGHT - 100,
IMAGES_DIR + "menu/continue_highlighted.png",
IMAGES_DIR + "menu/continue_highlighted.png",
ButtonState.HIGHLIGHTED)
]
if self.__parent__.my_score == self.__parent__.opponent_score:
self.logo.setPixmap(QPixmap(IMAGES_DIR + "menu/draw.png"))
elif self.__parent__.my_score > self.__parent__.opponent_score:
self.logo.setPixmap(QPixmap(IMAGES_DIR + "menu/you_won.png"))
else:
self.logo.setPixmap(QPixmap(IMAGES_DIR + "menu/you_lost.png"))
self.__draw_menu_buttons()
self.addItem(self.my_points)
self.addItem(self.opponent_points)
self.addItem(self.logo)
""" Handles keyboard presses """
def keyPressEvent(self, event):
if event.key() == Qt.Key_W:
self.__change_button_focus(Direction.UP)
elif event.key() == Qt.Key_S:
self.__change_button_focus(Direction.DOWN)
elif event.key() == Qt.Key_Return:
self.__execute_button()
""" Draws buttons in the scene """
def __draw_menu_buttons(self):
for button in self.buttons:
self.addItem(button.graphics_item)
""" Executes button logic """
def __execute_button(self):
for index in range(len(self.buttons)):
self.buttons[index].execute()
""" Changes button focus """
def __change_button_focus(self, direction: Direction):
if direction is None:
return
count = len(self.buttons)
old_index = -1
new_index = -1
for index in range(count):
if self.buttons[index].state is ButtonState.HIGHLIGHTED:
old_index = index
if direction is Direction.UP:
if index - 1 > 0:
new_index = index - 1
else:
new_index = 0
elif direction is Direction.DOWN:
if index + 1 > count - 1:
new_index = count - 1
else:
new_index = index + 1
self.buttons[old_index].set_state(ButtonState.NORMAL)
self.buttons[new_index].set_state(ButtonState.HIGHLIGHTED)
class Checkpoint(VisualizerGraphicItem):
def __init__(self, ID=0, x=0, y=0):
super(self.__class__, self).__init__(ID, x, y)
self._kind_name = 'checkpoint'
self._ids = {}
self._graphics_item = QGraphicsRectItem(self)
self._text = QGraphicsTextItem(self._graphics_item)
self._shine = False
def set_rect(self, rect):
scale = config.get('display', 'id_font_scale')
bold = config.get('display', 'id_font_bold')
font = QFont('', rect.width() * 0.08 * scale)
self._text.setFont(font)
self._text.setPos(rect.x(), rect.y() + 0.6 * rect.height())
self._text.setDefaultTextColor(
QColor(config.get('display', 'id_font_color')))
if self._display_mode == 0:
ss = ''
if bold:
ss = '<b>'
for key in self._ids:
count = 0
for ii in self._ids[key]:
if count == 0:
ss = ss + '(' + key + ': ' + ii[0]
else:
ss = ss + ', ' + ii[0]
count += 1
ss = ss + ')\n'
if bold:
ss += '</b>'
self._text.setHtml(ss)
self._graphics_item.setRect(rect.x(), rect.y(), rect.width(),
rect.height())
elif self._display_mode == 1:
self._text.setPlainText('')
self._graphics_item.setRect(rect.x(), rect.y(), rect.width(),
rect.height())
def do_action(self, time_step):
self._shine = False
return
def undo_action(self, time_step):
self._shine = False
return
def visit(self):
self._shine = True
def determine_color(self, number, count, pattern=None):
color = None
if len(self._ids) == 1:
for key in self._ids:
color_id = self._ids[key][0][1] + 1
if color_id < len(self._colors):
color = self._colors[color_id]
if color is None:
color = self._colors[0]
if self._shine:
color = calculate_color(color, QColor(255, 255, 255), 0.4)
self._graphics_item.setBrush(QBrush(color))
def parse_init_value(self, name, value):
result = super(self.__class__, self).parse_init_value(name, value)
if result != 1:
return result
if name == 'checkpoint' and len(value.arguments) == 3:
if str(value.arguments[0]) not in self._ids:
self._ids[str(value.arguments[0])] = []
self._ids[str(value.arguments[0])].append(
(str(value.arguments[1]), value.arguments[2].number))
return 0
return 1
def get_rect(self):
return self._graphics_item.rect()
class QmyMainWindow(QMainWindow):
def __init__(self, parent=None):
super().__init__(parent) #调用父类构造函数，创建窗体
self.ui = Ui_MainWindow() #创建UI对象
self.ui.setupUi(self) #构造UI界面
self.player = QMediaPlayer(self) #创建视频播放器
self.player.setNotifyInterval(1000) #信息更新周期, ms
scene = QGraphicsScene(self)
self.ui.graphicsView.setScene(scene)
self.videoItem = QGraphicsVideoItem() #视频显示画面
self.videoItem.setSize(QSizeF(320, 220))
self.videoItem.setFlag(QGraphicsItem.ItemIsMovable)
self.videoItem.setFlag(QGraphicsItem.ItemIsSelectable)
self.videoItem.setFlag(QGraphicsItem.ItemIsFocusable)
scene.addItem(self.videoItem)
self.player.setVideoOutput(self.videoItem) #设置视频显示图形项
self.textItem = QGraphicsTextItem("面朝大海，春暖花开") #弹幕文字
font = self.textItem.font()
font.setPointSize(20)
self.textItem.setFont(font)
self.textItem.setDefaultTextColor(Qt.red)
self.textItem.setPos(100, 220)
self.textItem.setFlag(QGraphicsItem.ItemIsMovable)
self.textItem.setFlag(QGraphicsItem.ItemIsSelectable)
self.textItem.setFlag(QGraphicsItem.ItemIsFocusable)
scene.addItem(self.textItem)
self.ui.btnText.setCheckable(True) #弹幕文字按钮
self.ui.btnText.setChecked(True)
self.__duration = ""
self.__curPos = ""
self.player.stateChanged.connect(self.do_stateChanged)
self.player.positionChanged.connect(self.do_positionChanged)
self.player.durationChanged.connect(self.do_durationChanged)
## ==============自定义功能函数========================
## ==============event处理函数==========================
def closeEvent(self, event): #窗体关闭时
# 窗口关闭时不能自动停止播放，需手动停止
if (self.player.state() == QMediaPlayer.PlayingState):
self.player.stop()
## ==========由connectSlotsByName()自动连接的槽函数============
@pyqtSlot() ##打开文件
def on_btnOpen_clicked(self):
curPath = QDir.currentPath() #获取系统当前目录
## curPath=os.getcwd()
title = "选择视频文件"
filt = "视频文件(*.wmv *.avi);;所有文件(*.*)"
fileName, flt = QFileDialog.getOpenFileName(self, title, curPath, filt)
if (fileName == ""):
return
fileInfo = QFileInfo(fileName)
baseName = fileInfo.fileName()
## baseName=os.path.basename(fileName)
self.ui.LabCurMedia.setText(baseName)
curPath = fileInfo.absolutePath()
QDir.setCurrent(curPath) #重设当前目录
media = QMediaContent(QUrl.fromLocalFile(fileName))
self.player.setMedia(media) #设置播放文件
self.player.play()
@pyqtSlot() ##播放
def on_btnPlay_clicked(self):
self.player.play()
@pyqtSlot() ##暂停
def on_btnPause_clicked(self):
self.player.pause()
@pyqtSlot() ##停止
def on_btnStop_clicked(self):
self.player.stop()
@pyqtSlot() ##全屏
def on_btnFullScreen_clicked(self):
self.videoWidget.setFullScreen(True)
@pyqtSlot() ##静音按钮
def on_btnSound_clicked(self):
mute = self.player.isMuted()
self.player.setMuted(not mute)
if mute:
self.ui.btnSound.setIcon(QIcon(":/icons/images/volumn.bmp"))
else:
self.ui.btnSound.setIcon(QIcon(":/icons/images/mute.bmp"))
@pyqtSlot(int) ##音量调节
def on_sliderVolumn_valueChanged(self, value):
self.player.setVolume(value)
@pyqtSlot(int) ##播放进度调节
def on_sliderPosition_valueChanged(self, value):
self.player.setPosition(value)
@pyqtSlot() ##放大
def on_btnZoomIn_clicked(self):
sc = self.videoItem.scale()
self.videoItem.setScale(sc + 0.1)
@pyqtSlot() ##缩小
def on_btnZoomOut_clicked(self):
sc = self.videoItem.scale()
self.videoItem.setScale(sc - 0.1)
@pyqtSlot(bool) ##弹幕
def on_btnText_clicked(self, checked):
self.textItem.setVisible(checked)
## =============自定义槽函数===============================
def do_stateChanged(self, state):
isPlaying = (state == QMediaPlayer.PlayingState)
self.ui.btnPlay.setEnabled(not isPlaying)
self.ui.btnPause.setEnabled(isPlaying)
self.ui.btnStop.setEnabled(isPlaying)
def do_durationChanged(self, duration):
self.ui.sliderPosition.setMaximum(duration)
secs = duration / 1000 #秒
mins = secs / 60 #分钟
secs = secs % 60 #余数秒
self.__duration = "%d:%d" % (mins, secs)
self.ui.LabRatio.setText(self.__curPos + "/" + self.__duration)
def do_positionChanged(self, position):
if (self.ui.sliderPosition.isSliderDown()):
return #如果正在拖动滑条，退出
self.ui.sliderPosition.setSliderPosition(position)
secs = position / 1000 #秒
mins = secs / 60 #分钟
secs = secs % 60 #余数秒
self.__curPos = "%d:%d" % (mins, secs)
self.ui.LabRatio.setText(self.__curPos + "/" + self.__duration)
class AnimatedCalendar():
updatesRunning = False
updateTimer = None
listUpdateThread = None
calDataLock = threading.Lock()
calDataUpdated = False
curCalendars = None
def __init__(self, scene, widthCalTextArea, heightCalTextArea, borders, calFeeds, calUpdateSecs):
self.masterScene = scene
self.widthCalTextArea = widthCalTextArea
self.heightCalTextArea = heightCalTextArea
self.borders = borders
self.calFeeds = calFeeds
self.calendarUpdateSecs = calUpdateSecs
# Background
self.textBkgd = QGraphicsRectItem(0, 0, self.widthCalTextArea, self.heightCalTextArea)
self.textBkgd.setPos(self.borders[3], self.borders[0])
self.textBkgd.setBrush(QColor("light green"))
self.textBkgd.setZValue(10)
scene.addItem(self.textBkgd)
# Text Item
self.textItem = QGraphicsTextItem()
self.textItem.setFont(QFont("Segoe UI", 24))
self.textItem.setDefaultTextColor(QColor("black"))
self.textItem.setPos(QPointF(self.borders[3]+10,self.borders[0]+10))
self.textItem.setHtml("<B>Hello</B>Hello")
self.textItem.setZValue(20)
self.textItem.setTextWidth(self.widthCalTextArea-20)
scene.addItem(self.textItem)
def start(self):
self.updatesRunning = True
QTimer.singleShot(100, self.updateCalendar)
self.listUpdateThread = CalendarUpdateThread(self, self.calFeeds, self.calendarUpdateSecs)
self.listUpdateThread.start()
# print("CalStarted")
def stop (self):
self.updatesRunning = False
if self.updateTimer != None:
self.updateTimer.stop()
if self.listUpdateThread != None:
self.listUpdateThread.stop()
def setNewCalendarEntries(self, calendars):
with self.calDataLock:
self.curCalendars = calendars
self.calDataUpdated = True
def updateCalendar(self):
# print("Update cal")
with self.calDataLock:
if self.calDataUpdated and self.curCalendars != None:
for calEvents in self.curCalendars:
calStr = ""
lastDay = -1
for anEvent in calEvents:
# date, duration, summary, location, UID
eventDate = anEvent[0]
duration = anEvent[1]
summary = anEvent[2]
location = anEvent[3]
if lastDay != eventDate.day:
if lastDay != -1:
calStr += "<br/>"
calStr += "<b>" + anEvent[0].strftime("%a") + " (" + anEvent[0].strftime("%d %B)") + ")</b><br/>"
lastDay = eventDate.day
strDurTime = str(duration).rpartition(":")[0]
durStr = (str(duration.days) + "day" + ("s" if duration.days != 1 else "")) if duration.days > 0 else strDurTime
locStr = "<small>("+location+")</small>" if location != "" else ""
calStr += anEvent[0].strftime("%H:%M") + " <small>(" + durStr + ")</small> " + summary + " " + locStr + "<br/>"
# print (anEvent)
# print(date)
self.textItem.setHtml(calStr)
self.textItem.setTextWidth(self.widthCalTextArea-20)
self.textItem.update()
self.calDataUpdated = False
if not self.updatesRunning:
return
self.updateTimer = QTimer()
self.updateTimer.setInterval(5000)
self.updateTimer.setSingleShot(True)
self.updateTimer.timeout.connect(self.updateCalendar)
self.updateTimer.start()