def blurPixmap(pixmap, radius):
effect = QGraphicsBlurEffect()
effect.setBlurRadius(radius)
buffer = QPixmap(pixmap)
item = QGraphicsPixmapItem(buffer)
item.setGraphicsEffect(effect)
output = QPixmap(pixmap.width(), pixmap.height())
painter = QtGui.QPainter(output)
scene = QtWidgets.QGraphicsScene()
view = QtWidgets.QGraphicsView(scene)
scene.addItem(item)
scene.render(painter)
return output
def blurPixmap(pixmap, radius):
effect = QGraphicsBlurEffect()
effect.setBlurRadius(radius)
buffer = QPixmap(pixmap)
item = QGraphicsPixmapItem(buffer)
item.setGraphicsEffect(effect)
output = QPixmap(pixmap.width(), pixmap.height())
painter = QtGui.QPainter(output)
scene = QtWidgets.QGraphicsScene()
view = QtWidgets.QGraphicsView(scene)
scene.addItem(item)
scene.render(painter)
return output
def onImageLoaded(self, data):
pixmap = QtGui.QPixmap()
pixmap.loadFromData(data)
pixmap = pixmap.scaledToWidth(self.width, Qt.SmoothTransformation)
if not pixmap: return None
self.setPixmap(pixmap)
# creating a blur effect
blur_effect = QGraphicsBlurEffect()
blur_effect.setBlurRadius(1)
self.setGraphicsEffect(blur_effect)
def keyPressEvent(self, e):
if e.key() == Qt.Key_Up:
self.rotate(30)
elif e.key() == Qt.Key_Down:
self.rotate(-30)
elif e.key() == Qt.Key_Right:
self.currentSlide += 1
if self.currentSlide >= len(self.slides):
#Loop to beginning
self.currentSlide = 0
self.text.setPlainText(self.slides[self.currentSlide])
self.adjustText()
self.centerText()
elif e.key() == Qt.Key_Left:
self.currentSlide -= 1
if self.currentSlide < 0:
#Loop to end
self.currentSlide = len(self.slides) - 1
self.text.setPlainText(self.slides[self.currentSlide])
self.adjustText()
self.centerText()
elif e.key() == Qt.Key_B:
shadow = QGraphicsBlurEffect()
shadow.setBlurRadius(self.shadowSize)
self.text.setGraphicsEffect(shadow)
elif e.key() == Qt.Key_S:
shadow = QGraphicsDropShadowEffect()
shadow.setBlurRadius(self.shadowSize)
shadow.setOffset(self.shadowOffset)
self.text.setGraphicsEffect(shadow)
elif e.key() == Qt.Key_C:
self.text.setGraphicsEffect(QGraphicsColorizeEffect())
elif e.key() == Qt.Key_O:
self.text.setGraphicsEffect(QGraphicsOpacityEffect())
elif e.key() == Qt.Key_N:
self.text.setGraphicsEffect(None)
class PathImage(Button):
def __init__(self, parent):
super(PathImage, self).__init__(parent)
self.img_idle = self.img_hover = self.img_click = None
self.text = QLabel(parent)
self.text.setText("")
self.default_fontsize = 150
self.offset = 225
def setup(self):
self.img_idle = self.img_hover = self.img_click = self.img
super().setup()
self.textblur_effect = QGraphicsBlurEffect()
self.textblur_effect.setBlurRadius(0)
self.text.setGraphicsEffect(self.textblur_effect)
def blur_me(self, blur):
super().blur_me(blur)
if blur:
self.textblur_effect.setBlurRadius(10)
else:
self.textblur_effect.setBlurRadius(0)
def setText(self, text):
# set stylesheet doesnt work for self.text qtoooltip so who cares./. night
self.text.setToolTip(text)
self.setToolTip(text)
# text = text[:57] # commented cause u ask me to remove. i dont like following ur oders
self.text.setText(text)
self.main_window.settingspage.updatevalue()
def changesize(self):
super().changesize()
scale = self.height() / self.main_window.default_height
x = self.x() + scale * self.offset
y = self.y() + scale * self.offset
fontsize = scale * self.default_fontsize
self.text.setStyleSheet(
"QLabel{font-size: %ipt; font-weight: bold; color: white; background-color: transparent;}QToolTip { background-color:white;color: black; }"
% (fontsize))
self.text.setGeometry(x, y, self.width() * 0.95, self.height() * 0.5)
class PathBox(Button):
def __init__(self, parent):
super(PathBox, self).__init__(parent)
self.img_idle = self.img_hover = self.img_click = None
self.text = QLabel(parent)
self.text.setText("")
self.default_fontsize = 150
self.offset = 225
def setup(self):
self.img_idle = self.img_hover = self.img_click = self.img
super().setup()
self.textblur_effect = QGraphicsBlurEffect()
self.textblur_effect.setBlurRadius(0)
self.text.setGraphicsEffect(self.textblur_effect)
def blur_me(self, blur):
super().blur_me(blur)
if blur:
self.textblur_effect.setBlurRadius(10)
else:
self.textblur_effect.setBlurRadius(0)
def setText(self, text):
self.text.setToolTip(text)
self.setToolTip(text)
self.text.setText(text)
self.main_window.settingspage.updatevalue()
def changesize(self):
super().changesize()
scale = self.height() / self.main_window.default_height
x = self.x() + scale * self.offset
y = self.y() + scale * self.offset
fontsize = scale * self.default_fontsize
self.text.setStyleSheet(
"QLabel{font-size: %ipt; font-weight: bold; color: white; background-color: transparent;}QToolTip { background-color:white;color: black; }"
% (fontsize))
self.text.setGeometry(x, y, self.width() * 0.95, self.height() * 0.5)
def drawIconWithShadow(icon: QIcon,
rect: QRect,
p: QPainter,
iconMode: QIcon.Mode = None,
dipRadius: int = None,
color: QColor = None,
dipOffset: QPoint = None):
if iconMode is None:
iconMode = QIcon.Normal
if color is None:
color = QColor(0, 0, 0, 130)
if dipRadius is None:
dipRadius = 3
if dipOffset is None:
dipOffset = QPoint(1, -2)
devicePixelRatio: int = p.device().devicePixelRatio()
pixmapName = "icon %s %s %s %s" % (icon.cacheKey(), iconMode,
rect.height(), devicePixelRatio)
cache = QPixmapCache.find(pixmapName)
if cache is None:
# High-dpi support: The in parameters (rect, radius, offset) are in
# device-independent pixels. The call to QIcon::pixmap() below might
# return a high-dpi pixmap, which will in that case have a devicePixelRatio
# different than 1. The shadow drawing caluculations are done in device
# pixels.
window = p.device().window().windowHandle()
px = icon.pixmap(window, rect.size(), iconMode)
radius = dipRadius * devicePixelRatio
offset = dipOffset * devicePixelRatio
cache = QPixmap(px.size() + QSize(radius * 2, radius * 2))
cache.fill(Qt.transparent)
cachePainter = QPainter(cache)
if iconMode == QIcon.Disabled:
hasDisabledState = len(icon.availableSizes()) == len(
icon.availableSizes(QIcon.Disabled))
if not hasDisabledState:
px = disabledSideBarIcon(icon.pixmap(window, rect.size()))
elif TOOLBAR_ICON_SHADOW:
# Draw shadow
tmp = QImage(px.size() + QSize(radius * 2, radius * 2 + 1),
QImage.Format_ARGB32_Premultiplied)
tmp.fill(Qt.transparent)
tmpPainter = QPainter(tmp)
tmpPainter.setCompositionMode(QPainter.CompositionMode_Source)
tmpPainter.drawPixmap(
QRect(radius, radius, px.width(), px.height()), px)
tmpPainter.end()
# blur the alpha channel
blurred = QImage(tmp.size(), QImage.Format_ARGB32_Premultiplied)
blurred.fill(Qt.transparent)
blurPainter = QPainter(blurred)
#qt_blurImage(blurPainter, tmp, radius, False, True)
# implement qt_blurImage via QLabel with QGraphicsBlurEffect
# FIXME: alignment is broken
scene = QGraphicsScene()
item = QGraphicsPixmapItem(QPixmap.fromImage(tmp))
effect = QGraphicsBlurEffect()
effect.setBlurRadius(radius)
item.setGraphicsEffect(effect)
scene.addItem(item)
scene.render(blurPainter)
blurPainter.end()
tmp = blurred
# blacken the image...
tmpPainter.begin(tmp)
tmpPainter.setCompositionMode(QPainter.CompositionMode_SourceIn)
tmpPainter.fillRect(tmp.rect(), color)
tmpPainter.end()
tmpPainter.begin(tmp)
tmpPainter.setCompositionMode(QPainter.CompositionMode_SourceIn)
tmpPainter.fillRect(tmp.rect(), color)
tmpPainter.end()
# draw the blurred drop shadow...
cachePainter.drawImage(
QRect(0, 0,
cache.rect().width(),
cache.rect().height()), tmp)
# Draw the actual pixmap...
cachePainter.drawPixmap(
QRect(
QPoint(radius, radius) + offset, QSize(px.width(),
px.height())), px)
cachePainter.end()
cache.setDevicePixelRatio(devicePixelRatio)
QPixmapCache.insert(pixmapName, cache)
targetRect = cache.rect()
targetRect.setSize(targetRect.size() / cache.devicePixelRatio())
targetRect.moveCenter(rect.center() - dipOffset)
p.drawPixmap(targetRect, cache)
class painter(QGraphicsView):
narrowRatio = int(sys.argv[4]) if len(sys.argv) >= 5 else 1
useBlur = sys.argv[5] != "False" if len(sys.argv) >= 6 else True
pixelSize = int(15 / narrowRatio)
width = int(480 / narrowRatio)
height = int(360 / narrowRatio)
fontSize = int(30 / narrowRatio)
anchorLineSize = int(100 / narrowRatio)
ellipseRadius = int(8 / narrowRatio)
textInterval = int(90 / narrowRatio)
col = width / pixelSize
line = height / pixelSize
centerIndex = int(round(((line / 2 - 1) * col) + col / 2))
frameCount = 0
baseZValue = 0
textLineHeight = fontSize + 10
blurRaduis = 50 # Smoother improvement
def __init__(self):
super(painter, self).__init__()
self.setFixedSize(self.width, self.height + self.textLineHeight)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.scene = QGraphicsScene()
self.setScene(self.scene)
# center het text item
self.centerTextItem = QGraphicsTextItem()
self.centerTextItem.setPos(self.width / 2 - self.fontSize, 0)
self.centerTextItem.setZValue(self.baseZValue + 1)
self.scene.addItem(self.centerTextItem)
# center anchor item
centerX = self.width / 2
centerY = self.height / 2
self.ellipseItem = QGraphicsEllipseItem(0, 0, self.ellipseRadius * 2,
self.ellipseRadius * 2)
self.horLineItem = QGraphicsLineItem(0, 0, self.anchorLineSize, 0)
self.verLineItem = QGraphicsLineItem(0, 0, 0, self.anchorLineSize)
self.ellipseItem.setPos(centerX - self.ellipseRadius,
centerY - self.ellipseRadius)
self.horLineItem.setPos(centerX - self.anchorLineSize / 2, centerY)
self.verLineItem.setPos(centerX, centerY - self.anchorLineSize / 2)
self.ellipseItem.setPen(QColor(Qt.white))
self.horLineItem.setPen(QColor(Qt.white))
self.verLineItem.setPen(QColor(Qt.white))
self.ellipseItem.setZValue(self.baseZValue + 1)
self.horLineItem.setZValue(self.baseZValue + 1)
self.verLineItem.setZValue(self.baseZValue + 1)
self.scene.addItem(self.ellipseItem)
self.scene.addItem(self.horLineItem)
self.scene.addItem(self.verLineItem)
# camera item
self.cameraBuffer = QPixmap(self.width,
self.height + self.textLineHeight)
self.cameraItem = QGraphicsPixmapItem()
if self.useBlur:
self.gusBlurEffect = QGraphicsBlurEffect()
self.gusBlurEffect.setBlurRadius(self.blurRaduis)
self.cameraItem.setGraphicsEffect(self.gusBlurEffect)
self.cameraItem.setPos(0, 0)
self.cameraItem.setZValue(self.baseZValue)
self.scene.addItem(self.cameraItem)
# het text item
self.hetTextBuffer = QPixmap(self.width, self.textLineHeight)
self.hetTextItem = QGraphicsPixmapItem()
self.hetTextItem.setPos(0, self.height)
self.hetTextItem.setZValue(self.baseZValue)
self.scene.addItem(self.hetTextItem)
def draw(self):
if len(hetaData) == 0:
return
font = QFont()
color = QColor()
font.setPointSize(self.fontSize)
font.setFamily("Microsoft YaHei")
font.setLetterSpacing(QFont.AbsoluteSpacing, 0)
index = 0
lock.acquire()
frame = hetaData.pop(0)
lock.release()
maxHet = frame["maxHet"]
minHet = frame["minHet"]
frame = frame["frame"]
p = QPainter(self.cameraBuffer)
p.fillRect(0, 0, self.width, self.height + self.textLineHeight,
QBrush(QColor(Qt.black)))
# draw camera
color = QColor()
for yIndex in range(int(self.height / self.pixelSize)):
for xIndex in range(int(self.width / self.pixelSize)):
tempData = constrain(
mapValue(frame[index], minHet, maxHet, minHue, maxHue),
minHue, maxHue)
color.setHsvF(tempData / 360, 1.0, 1.0)
p.fillRect(xIndex * self.pixelSize, yIndex * self.pixelSize,
self.pixelSize, self.pixelSize, QBrush(color))
index = index + 1
self.cameraItem.setPixmap(self.cameraBuffer)
# draw text
p = QPainter(self.hetTextBuffer)
p.fillRect(0, 0, self.width, self.height + self.textLineHeight,
QBrush(QColor(Qt.black)))
hetDiff = maxHet - minHet
bastNum = round(minHet)
interval = round(hetDiff / 5)
for i in range(5):
hue = constrain(
mapValue((bastNum + (i * interval)), minHet, maxHet, minHue,
maxHue), minHue, maxHue)
color.setHsvF(hue / 360, 1.0, 1.0)
p.setPen(color)
p.setFont(font)
p.drawText(i * self.textInterval, self.fontSize + 3,
str(bastNum + (i * interval)) + "°")
self.hetTextItem.setPixmap(self.hetTextBuffer)
# draw center het text
cneter = round(frame[self.centerIndex], 1)
centerText = "<font color=white>%s</font>"
self.centerTextItem.setFont(font)
self.centerTextItem.setHtml(centerText % (str(cneter) + "°"))
self.frameCount = self.frameCount + 1
print("picture->" + str(self.frameCount))
class painter(QGraphicsView):
pixelSize = int(15 / narrowRatio)
width = int(480 / narrowRatio)
height = int(360 / narrowRatio)
fontSize = int(30 / narrowRatio)
anchorLineSize = int(100 / narrowRatio)
ellipseRadius = int(8 / narrowRatio)
textInterval = int(90 / narrowRatio)
col = width / pixelSize
line = height / pixelSize
centerIndex = int(round(((line / 2 - 1) * col) + col / 2))
frameCount = 0
baseZValue = 0
mode = 1
body = 1
open_status = 0
textLineHeight = fontSize + 10
blurRaduis = 50 # Smoother improvement
def __init__(self, dataThread):
super(painter, self).__init__()
self.dataThread = dataThread
self.setFixedSize(self.width, self.height + self.textLineHeight)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.scene = QGraphicsScene()
self.setScene(self.scene)
# center het text item
self.centerTextItem = QGraphicsTextItem()
self.centerTextItem.setPos(self.width / 2 - self.fontSize, 0)
self.centerTextItem.setZValue(self.baseZValue + 1)
self.scene.addItem(self.centerTextItem)
# center anchor item
centerX = self.width / 2
centerY = self.height / 2
self.ellipseItem = QGraphicsEllipseItem(0, 0, self.ellipseRadius * 2,
self.ellipseRadius * 2)
self.horLineItem = QGraphicsLineItem(0, 0, self.anchorLineSize, 0)
self.verLineItem = QGraphicsLineItem(0, 0, 0, self.anchorLineSize)
self.ellipseItem.setPos(centerX - self.ellipseRadius,
centerY - self.ellipseRadius)
self.horLineItem.setPos(centerX - self.anchorLineSize / 2, centerY)
self.verLineItem.setPos(centerX, centerY - self.anchorLineSize / 2)
self.ellipseItem.setPen(QColor(Qt.white))
self.horLineItem.setPen(QColor(Qt.white))
self.verLineItem.setPen(QColor(Qt.white))
self.ellipseItem.setZValue(self.baseZValue + 1)
self.horLineItem.setZValue(self.baseZValue + 1)
self.verLineItem.setZValue(self.baseZValue + 1)
self.scene.addItem(self.ellipseItem)
self.scene.addItem(self.horLineItem)
self.scene.addItem(self.verLineItem)
# camera item
self.cameraBuffer = QPixmap(self.width,
self.height + self.textLineHeight)
self.cameraItem = QGraphicsPixmapItem()
if useBlur:
self.gusBlurEffect = QGraphicsBlurEffect()
self.gusBlurEffect.setBlurRadius(self.blurRaduis)
self.cameraItem.setGraphicsEffect(self.gusBlurEffect)
self.cameraItem.setPos(0, 0)
self.cameraItem.setZValue(self.baseZValue)
self.scene.addItem(self.cameraItem)
# het text item
self.hetTextBuffer = QPixmap(self.width, self.textLineHeight)
self.hetTextItem = QGraphicsPixmapItem()
self.hetTextItem.setPos(0, self.height)
self.hetTextItem.setZValue(self.baseZValue)
self.scene.addItem(self.hetTextItem)
# button item
self.ctrlOpenButton = QPushButton('Open', self)
self.ctrlOpenButton.clicked.connect(self.ctrl_open)
self.ctrlOpenButton.setGeometry(10, 30, 100, 40)
'''
self.ctrlCloseButton = QPushButton('stop send',self)
self.ctrlCloseButton.clicked.connect(self.ctrl_close)
self.ctrlCloseButton.setGeometry(10,80,100,40)
'''
self.getOnePicButton = QPushButton('send a frame', self)
self.getOnePicButton.clicked.connect(self.ctrl_sendone)
self.getOnePicButton.setGeometry(10, 130, 100, 40)
self.getOnePicButton.setEnabled(False)
self.modeManualButton = QPushButton('Auto', self)
self.modeManualButton.clicked.connect(self.mode_manual)
self.modeManualButton.setGeometry(10, 180, 100, 40)
self.modeObjButton = QPushButton('Body', self)
self.modeObjButton.clicked.connect(self.obj_body)
self.modeObjButton.setGeometry(10, 230, 100, 40)
'''
self.modeAutoButton = QPushButton('mode: auto',self)
self.modeAutoButton.clicked.connect(self.mode_auto)
self.modeAutoButton.setGeometry(10,230,100,40)
'''
self.modeFpsButton = QPushButton('3fps', self)
self.modeFpsButton.clicked.connect(self.rate_0)
self.modeFpsButton.setGeometry(10, 280, 100, 40)
self.blackbodyEdit = QLineEdit()
self.blackbodyEdit.setGeometry(270, 200, 100, 40)
self.blackbodyEdit.setText('37')
self.calibrateButton = QPushButton(calibrateStr[0], self)
self.calibrateButton.clicked.connect(self.calibrate_handle)
self.calibrateButton.setGeometry(370, 280, 100, 40)
'''
self.modeAutoButton = QPushButton('1fps',self)
self.modeAutoButton.clicked.connect(self.rate_1)
self.modeAutoButton.setGeometry(35,280,50,40)
self.modeAutoButton = QPushButton('2fps',self)
self.modeAutoButton.clicked.connect(self.rate_2)
self.modeAutoButton.setGeometry(60,280,50,40)
self.modeAutoButton = QPushButton('3fps',self)
self.modeAutoButton.clicked.connect(self.rate_3)
self.modeAutoButton.setGeometry(85,280,50,40)
'''
'''
self.modeAutoButton = QPushButton('obj: common',self)
self.modeAutoButton.clicked.connect(self.obj_common)
self.modeAutoButton.setGeometry(370,80,100,40)
'''
# self.modeAutoButton = QPushButton('version',self)
# self.modeAutoButton.clicked.connect(self.sys_ver)
# self.modeAutoButton.setGeometry(370,230,100,40)
def ctrl_open(self):
if self.open_status == 1:
print('start send C command 0')
self.open_status = 0
self.ctrlOpenButton.setText("Open")
self.dataThread.send_data('CMDC\0')
else:
print('start send C command 1')
self.open_status = 1
self.ctrlOpenButton.setText("Close")
self.dataThread.send_data('CMDC\1')
'''
def ctrl_close(self):
print('stop send')
self.dataThread.send_data('CMDC\0')
'''
def ctrl_sendone(self):
print('send a frame')
self.dataThread.send_data('CMDC\2')
def mode_manual(self):
if self.mode == 1:
self.getOnePicButton.setEnabled(True)
self.modeManualButton.setText("Manual")
self.dataThread.send_data('CMDM\0')
self.mode = 0
print('mode: manual')
else:
self.getOnePicButton.setEnabled(False)
self.modeManualButton.setText("Auto")
self.dataThread.send_data('CMDM\1')
print('mode: auto')
self.mode = 1
def mode_auto(self):
print('mode: auto')
self.dataThread.send_data('CMDM\1')
def stop_calibration(self):
global calibration_offset
calibration_start = False
self.calibrateButton.setText(calibrateStr[0])
if (calibration_frame_count):
reply = QMessageBox.information(self, '信息',
'校准很久都不行，模组是否没有预热20分钟呢？',
QMessageBox.Yes)
else:
reply = QMessageBox.information(self, '信息', '校准已完成',
QMessageBox.Yes)
def calibrate_handle(self):
global calibration_start
global calibration_max_list
global blackbody_temperature
if calibration_start:
calibration_start = False
self.calibrateButton.setText(calibrateStr[0])
else:
calibration_max_list.clear()
blackbody_temperature = float(self.blackbodyEdit.text())
calibration_start = True
print(" blackbody_temperature ", blackbody_temperature)
self.calibrateButton.setText(calibrateStr[1])
def rate_0(self):
global btn_index
btn_index = (btn_index + 1) % 4
print('FPS:', strButton[btn_index])
self.modeFpsButton.setText(strButton[btn_index])
self.dataThread.send_data(strFpsCmd[btn_index]) #'CMDF\0')
'''
def rate_1(self):
print('FPS：1')
self.dataThread.send_data('CMDF\1')
def rate_2(self):
print('FPS：2')
self.dataThread.send_data('CMDF\2')
def rate_3(self):
print('FPS：3')
self.dataThread.send_data('CMDF\3')
'''
def obj_body(self):
if self.body == 1:
self.body = 0
print('obj: Object')
self.modeObjButton.setText("Object")
self.dataThread.send_data('CMDO\0')
else:
self.body = 1
print('obj: Human Body')
self.modeObjButton.setText("Body")
self.dataThread.send_data('CMDO\1')
'''
def obj_common(self):
print('obj: common')
self.dataThread.send_data('CMDO\1')
def sys_slp(self):
print('sleep')
self.dataThread.send_data('CMDS\1')
'''
def draw(self):
if len(hetaData) == 0:
return
font = QFont()
color = QColor()
font.setPointSize(self.fontSize)
font.setFamily("Microsoft YaHei")
font.setLetterSpacing(QFont.AbsoluteSpacing, 0)
index = 0
lock.acquire()
frame = hetaData.pop(0)
lock.release()
p = QPainter(self.cameraBuffer)
p.fillRect(0, 0, self.width, self.height + self.textLineHeight,
QBrush(QColor(Qt.black)))
# draw camera
color = QColor()
for yIndex in range(int(self.height / self.pixelSize)):
for xIndex in range(int(self.width / self.pixelSize)):
color.setHsvF(frame[index] / 360, 1.0, 1.0)
p.fillRect(xIndex * self.pixelSize, yIndex * self.pixelSize,
self.pixelSize, self.pixelSize, QBrush(color))
index = index + 1
self.cameraItem.setPixmap(self.cameraBuffer)
# draw text
p = QPainter(self.hetTextBuffer)
p.fillRect(0, 0, self.width, self.height + self.textLineHeight,
QBrush(QColor(Qt.black)))
hetDiff = maxHet - minHet
bastNum = round(minHet)
interval = round(hetDiff / 5)
for i in range(5):
hue = constrain(
mapValue((bastNum + (i * interval)), minHet, maxHet, minHue,
maxHue), minHue, maxHue)
color.setHsvF(hue / 360, 1.0, 1.0)
p.setPen(color)
p.setFont(font)
p.drawText(i * self.textInterval, self.fontSize + 3,
str(bastNum + (i * interval)) + "°")
self.hetTextItem.setPixmap(self.hetTextBuffer)
# draw center het text
cneter = round(
mapValue(frame[self.centerIndex], minHue, maxHue, minHet, maxHet),
1)
centerText = "<font color=white>%s</font>"
self.centerTextItem.setFont(font)
self.centerTextItem.setHtml(centerText % (str(cneter) + "°"))
self.frameCount = self.frameCount + 1
print("picture->" + str(self.frameCount))
class NumPadWidget(object):
def __init__(self, nums, parent):
super().__init__()
self.nums = nums
self.parent = parent
self.tile_events = events.TileInterfaceEvent()
# Init main widget for master-controlling NumPad
self.widget = QWidget()
self.widget.setObjectName('NumPad')
# Create blur effect for widgets
self.blur_top_lbl = QGraphicsBlurEffect()
self.blur_top_lbl.setBlurRadius(0.0)
self.blur_bottom_lbl = QGraphicsBlurEffect()
self.blur_bottom_lbl.setBlurRadius(0.0)
self.opacity_effect = QGraphicsOpacityEffect()
self.opacity_effect.setOpacity(0.0)
# Create animation classes
self.blur_anim = QVariantAnimation()
self.blur_anim.setEasingCurve(QEasingCurve.InOutQuad)
self.blur_anim.valueChanged.connect(self.play_animation)
self.opacity_anim = QPropertyAnimation(self.opacity_effect, b'opacity')
self.opacity_anim.setEasingCurve(QEasingCurve.InOutQuad)
elements_hbl = QVBoxLayout()
# Top label of NumPad
self.top_lbl = QLabel()
self.top_lbl.setGraphicsEffect(self.blur_top_lbl)
self.top_lbl.setText(str(nums))
self.top_lbl.setObjectName('NumPad')
self.top_lbl.setAlignment(Qt.AlignCenter)
# Bottom label of NumPad
self.bottom_lbl = QLabel()
self.bottom_lbl.setGraphicsEffect(self.blur_bottom_lbl)
self.bottom_lbl.setObjectName('NumPad')
self.bottom_lbl.setAlignment(Qt.AlignCenter)
elements_hbl.addWidget(self.top_lbl, 50)
elements_hbl.addWidget(self.bottom_lbl, 50)
self.widget.setLayout(elements_hbl)
self.create_master_numpad()
# Events and signals widget
self.widget.enterEvent = lambda event: self.enter_event()
self.widget.leaveEvent = lambda event: self.leave_event()
def create_master_numpad(self):
self.overlay_widget = QWidget(self.widget)
self.overlay_widget.setObjectName("OverlayNumPadWidget")
sound_pbtn_widget = QWidget(self.overlay_widget)
# sound_pbtn_widget.setAttribute(Qt.WA_TranslucentBackground)
# NumPad widgets, layouts and items
sound_name_lbl = QLabel(self.overlay_widget)
sound_name_lbl.setObjectName('NumPadName')
sound_name_lbl.setAlignment(Qt.AlignCenter)
sound_name_lbl.setText('Name of Sound')
numpad_spacer = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
settings_numpad_pbtn = QPushButton(self.overlay_widget)
settings_numpad_pbtn.setObjectName('NumPad')
settings_numpad_pbtn.setText('Settings')
add_numpad_pbtn = QPushButton(self.overlay_widget)
add_numpad_pbtn.setObjectName('NumPad')
add_numpad_pbtn.setText('Add Sound')
remove_numpad_pbtn = QPushButton(self.overlay_widget)
remove_numpad_pbtn.setObjectName('NumPad')
remove_numpad_pbtn.setText('Remove Sound')
# Master sound buttons
play_sound_pbtn = QPushButton()
play_sound_pbtn.setObjectName('PlayBtns')
play_sound_pbtn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
play_sound_pbtn.setIcon(
QIcon('./interface-stylesheets/interface-element/play.gif'))
play_sound_pbtn.setAccessibleName('NumPadPushButton_%d' % self.nums)
begin_sound_pbtn = QPushButton()
begin_sound_pbtn.setObjectName('PlayBtns')
begin_sound_pbtn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
begin_sound_pbtn.setIcon(
QIcon('./interface-stylesheets/interface-element/end.gif'))
end_sound_pbtn = QPushButton()
end_sound_pbtn.setObjectName('PlayBtns')
end_sound_pbtn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
end_sound_pbtn.setIcon(
QIcon('./interface-stylesheets/interface-element/begin.gif'))
overlay_pbtn_hbl = QVBoxLayout()
overlay_pbtn_hbl.setContentsMargins(0, 0, 0, 0)
overlay_pbtn_hbl.setSpacing(0)
# Create and set layouts and add widgets
play_sound_hbl = QHBoxLayout()
play_sound_hbl.setContentsMargins(0, 0, 0, 0)
play_sound_hbl.addWidget(begin_sound_pbtn)
play_sound_hbl.addWidget(play_sound_pbtn)
play_sound_hbl.addWidget(end_sound_pbtn)
overlay_pbtn_hbl.addWidget(sound_name_lbl)
overlay_pbtn_hbl.addItem(numpad_spacer)
overlay_pbtn_hbl.addWidget(sound_pbtn_widget)
overlay_pbtn_hbl.addWidget(add_numpad_pbtn)
overlay_pbtn_hbl.addWidget(remove_numpad_pbtn)
overlay_pbtn_hbl.addWidget(settings_numpad_pbtn)
sound_pbtn_widget.setLayout(play_sound_hbl)
self.overlay_widget.setLayout(overlay_pbtn_hbl)
# Custom parameters
self.overlay_widget.setGraphicsEffect(self.opacity_effect)
# Events and signals widget
self.widget.resizeEvent = lambda event: self.resize_event()
play_sound_pbtn.clicked.connect(
lambda: self.tile_events.switch_play_pbtn(play_sound_pbtn))
settings_numpad_pbtn.mousePressEvent = lambda event: self.tile_events.press_settings_buttonEvent(
self.parent)
def set_text_lbl_icons(self, bottom_text_lbl):
if type(bottom_text_lbl) is str:
self.bottom_lbl.setText(bottom_text_lbl)
elif bottom_text_lbl is not None:
pixmap_lbl = QPixmap(
'./interface-stylesheets/interface-element/%d_numpad_night.png'
% bottom_text_lbl)
pixmap_lbl.scaled(32, 32, Qt.KeepAspectRatio,
Qt.FastTransformation)
self.bottom_lbl.setPixmap(pixmap_lbl)
# If mouse pointer on the widget then play animate widget buttons and blur master widget
def enter_event(self):
self.blur_anim.setDirection(QPropertyAnimation.Forward)
self.blur_anim.setDuration(500)
self.blur_anim.setStartValue(self.blur_top_lbl.blurRadius())
self.blur_anim.setEndValue(8.0)
self.blur_anim.start()
self.opacity_anim.setDirection(QPropertyAnimation.Forward)
self.opacity_anim.setDuration(500)
self.opacity_anim.setStartValue(self.opacity_effect.opacity())
self.opacity_anim.setEndValue(0.6)
self.opacity_anim.start()
# If mouse pointer out the widget then play reverse animate widget buttons and unblur master widget
def leave_event(self):
self.blur_anim.setDirection(QPropertyAnimation.Backward)
self.blur_anim.setDuration(500)
self.blur_anim.setStartValue(0.0)
self.blur_anim.setEndValue(self.blur_top_lbl.blurRadius())
self.blur_anim.start()
self.opacity_anim.setDirection(QPropertyAnimation.Backward)
self.opacity_anim.setDuration(500)
self.opacity_anim.setStartValue(0.0)
self.opacity_anim.setEndValue(self.opacity_effect.opacity())
self.opacity_anim.start()
def play_animation(self):
self.blur_top_lbl.setBlurRadius(self.blur_anim.currentValue())
self.blur_bottom_lbl.setBlurRadius(self.blur_anim.currentValue())
def resize_event(self):
self.overlay_widget.setGeometry(0, 0,
self.widget.geometry().width(),
self.widget.geometry().height())
def return_top_lbl(self):
return self.top_lbl
def return_bottom_lbl(self):
return self.bottom_lbl
def return_widget(self):
return self.widget
def _set_blur(self, value):
blur = QGraphicsBlurEffect()
blur.setBlurRadius(value)
self.setGraphicsEffect(blur)
class ComboBox(QComboBox):
def __init__(self, parent):
super().__init__(parent)
self.img_drop = os.path.join(abspath, "res/Drop_Scale.png")
self.img_listview = os.path.join(abspath, "res/listview.png")
self.setToolTip("Skin that will be used in the video")
self.default_width = 0.6
self.default_height = 0.6
self.activated.connect(self.activated_)
self.main_window = parent
self.setStyleSheet("""
QComboBox {
border-image : url(%s);
color: white;
font-size: 9pt;
}
QComboBox::drop-down {
border-bottom-right-radius: 1px;
}
QListView {
outline: none;
color: white;
font: bold;
border-image : url(%s);
}
QScrollBar:vertical {
width: 0px;
height: 0px;
}
QScrollBar::up-arrow:vertical, QScrollBar::down-arrow:vertical {
width: 0px;
height: 0px;
background: none;
}
QScrollBar::add-page:vertical, QScrollBar::sub-page:vertical {
background: none;
}
QTextEdit, QListView {
background-color: rgba(0, 0, 0, 0);
background-attachment: scroll;
}
""" % (self.img_drop, self.img_listview))
def setup(self):
width, height = getsize(self.img_drop)
self.default_width *= width
self.default_height *= height
self.setGeometry(self.default_x, self.default_y, self.default_width,
self.default_height)
self.setIconSize(QtCore.QSize(self.default_width, self.default_height))
self.view().setIconSize(QtCore.QSize(
0, 0)) # for linux machines otherwise texts got hidden
self.setMaxVisibleItems(7)
self.blur_effect = QGraphicsBlurEffect()
self.blur_effect.setBlurRadius(0)
self.setGraphicsEffect(self.blur_effect)
def activated_(self, index):
pass
def changesize(self):
changesize(self)
self.view().setIconSize(QtCore.QSize(
0, 0)) # for linux machines otherwise texts got hidden
def blur_me(self, blur):
if blur:
self.blur_effect.setBlurRadius(25)
else:
self.blur_effect.setBlurRadius(0)
class AutoCheckBox(QCheckBox):
def __init__(self, parent):
super().__init__(parent)
self.main_window = parent
self.img_uncheck = os.path.join(abspath, "res/Uncheck_HD.png")
self.img_check = os.path.join(abspath, "res/Check_HD.png")
self.box_width = 20
self.box_height = 20
self.default_fontsize = 14
self.default_x = 520
self.default_y = 145
self.text = " " + "Use Auto Replay"
self.setText(self.text)
self.curfont = self.font()
self.blur_effect = QGraphicsBlurEffect()
self.blur_effect.setBlurRadius(0)
self.setGraphicsEffect(self.blur_effect)
self.default_width = self.box_width * 1.1 + self.textwidth()
self.default_height = self.box_height * 1.1
self.setCheckState(QtCore.Qt.Unchecked)
super().stateChanged.connect(self.stateChanged)
def textwidth(self):
return self.fontMetrics().boundingRect(self.text).width() * 2
def textheight(self):
return self.fontMetrics().boundingRect(self.text).height() * 2
def changesize(self):
changesize(self)
scale = self.main_window.height() / self.main_window.default_height
self.setStyleSheet("""
QCheckBox {
font-weight: bold;
color: white;
background-color: transparent;
}
QCheckBox::indicator {
width: %fpx;
height: %fpx;
}
QCheckBox::indicator:unchecked {
border-image: url(%s);
}
QCheckBox::indicator:checked {
border-image: url(%s);
}
""" % (self.box_width * scale, self.box_height * scale, self.img_uncheck,
self.img_check))
self.curfont.setPointSize(self.default_fontsize * scale)
self.setFont(self.curfont)
# super().setFixedWidth(p_int)
@QtCore.pyqtSlot(int)
def stateChanged(self, p_int):
self.main_window.toggle_auto(p_int == 2)
def blur_me(self, blur):
if blur:
self.blur_effect.setBlurRadius(25)
else:
self.blur_effect.setBlurRadius(0)
class painter(QGraphicsView):
pixelSize = int(15 / narrowRatio)
width = int(480 / narrowRatio)
height = int(360 / narrowRatio)
fontSize = int(15 / narrowRatio)
anchorLineSize = int(100 / narrowRatio)
ellipseRadius = int(8 / narrowRatio)
textInterval = int(90 / narrowRatio)
col = width / pixelSize
line = height / pixelSize
centerIndex = int(round(((line / 2 - 1) * col) + col / 2))
frameCount = 0
failedCount = 0
baseZValue = 0
mode = 1
body = 1
open_status = 0
textLineHeight = fontSize + 10
blurRaduis = 50 # Smoother improvement
def __init__(self, dataThread):
super(painter, self).__init__()
self.dataThread = dataThread
self.setFixedSize(self.width + 200, self.height + self.textLineHeight)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.scene = QGraphicsScene()
self.setScene(self.scene)
# center het text item
self.centerTextItem = QGraphicsTextItem()
self.centerTextItem.setPos((self.width + 200) / 2 - self.fontSize, 0)
self.centerTextItem.setZValue(self.baseZValue + 1)
self.scene.addItem(self.centerTextItem)
# version text item
self.versionTextItem = QGraphicsTextItem()
self.versionTextItem.setPos(self.width * 0.8 - self.fontSize,
self.height * 0.8 - self.fontSize)
self.versionTextItem.setZValue(self.baseZValue + 1)
self.scene.addItem(self.versionTextItem)
self.userCom = None
# center anchor item
centerX = self.width / 2
centerY = self.height / 2
self.ellipseItem = QGraphicsEllipseItem(0, 0, self.ellipseRadius * 2,
self.ellipseRadius * 2)
self.horLineItem = QGraphicsLineItem(0, 0, self.anchorLineSize, 0)
self.verLineItem = QGraphicsLineItem(0, 0, 0, self.anchorLineSize)
self.ellipseItem.setPos(centerX - self.ellipseRadius,
centerY - self.ellipseRadius)
self.horLineItem.setPos(centerX - self.anchorLineSize / 2, centerY)
self.verLineItem.setPos(centerX, centerY - self.anchorLineSize / 2)
self.ellipseItem.setPen(QColor(Qt.white))
self.horLineItem.setPen(QColor(Qt.white))
self.verLineItem.setPen(QColor(Qt.white))
self.ellipseItem.setZValue(self.baseZValue + 1)
self.horLineItem.setZValue(self.baseZValue + 1)
self.verLineItem.setZValue(self.baseZValue + 1)
self.scene.addItem(self.ellipseItem)
self.scene.addItem(self.horLineItem)
self.scene.addItem(self.verLineItem)
# camera item
self.cameraBuffer = QPixmap(self.width,
self.height + self.textLineHeight)
self.cameraItem = QGraphicsPixmapItem()
if useBlur:
self.gusBlurEffect = QGraphicsBlurEffect()
self.gusBlurEffect.setBlurRadius(self.blurRaduis)
self.cameraItem.setGraphicsEffect(self.gusBlurEffect)
self.cameraItem.setPos(100, 0)
self.cameraItem.setZValue(self.baseZValue)
self.scene.addItem(self.cameraItem)
# het text item
self.hetTextBuffer = QPixmap(self.width + 200, self.textLineHeight)
self.hetTextItem = QGraphicsPixmapItem()
self.hetTextItem.setPos(0, self.height)
self.hetTextItem.setZValue(self.baseZValue)
self.scene.addItem(self.hetTextItem)
# button item
self.ctrlOpenButton = QPushButton('Open', self)
self.ctrlOpenButton.clicked.connect(self.ctrlOpen)
self.ctrlOpenButton.setGeometry(10, 30, 100, 40)
self.EvaluateButton = QPushButton('None', self)
self.EvaluateButton.clicked.connect(self.evaluate)
self.EvaluateButton.setGeometry(10, 80, 100, 40)
self.getOnePicButton = QPushButton('Get a frame', self)
self.getOnePicButton.clicked.connect(self.ctrlSendone)
self.getOnePicButton.setGeometry(10, 130, 100, 40)
self.getOnePicButton.setEnabled(False)
self.modeManualButton = QPushButton('Auto', self)
self.modeManualButton.clicked.connect(self.modeManual)
self.modeManualButton.setGeometry(10, 180, 100, 40)
self.modeObjButton = QPushButton('Body', self)
self.modeObjButton.clicked.connect(self.objBody)
self.modeObjButton.setGeometry(10, 230, 100, 40)
self.modeFpsButton = QPushButton('4FPS', self)
self.modeFpsButton.clicked.connect(self.rate)
self.modeFpsButton.setGeometry(10, 280, 100, 40)
self.modeAutoButton = QPushButton('Get offset', self)
self.modeAutoButton.clicked.connect(self.commonOffset)
self.modeAutoButton.setGeometry(570, 30, 100, 40)
self.modeAutoButton = QPushButton('Get version', self)
self.modeAutoButton.clicked.connect(self.sysVer)
self.modeAutoButton.setGeometry(570, 80, 100, 40)
self.evaluate = 1
self.evaluateButton = QPushButton('Evaluate', self)
self.evaluateButton.clicked.connect(self.setEvaluate)
self.evaluateButton.setGeometry(570, 120, 100, 40)
self.serial_l = QLabel(self)
self.serial_l.move(580, 250)
self.serial_l.resize(60, 30)
self.serial_l.setStyleSheet(
"QLabel{color:rgb(0,0,0,255);background-color: rgb(255,255,255);font-size:16px;font-weight:normal;font-family:Arial;}"
)
self.serial_l.setText("Serial:")
self.serialList = SerialComboBox(self)
self.serialList.setCurrentIndex(0)
self.serialList.setStyleSheet(
"border-width: 1px;border-style: solid;border-color: rgb(255, 170, 0);"
)
self.serialList.currentIndexChanged.connect(self.serialChange)
# self.evaluateButton.setGeometry(570,140,100,40)
self.serialList.move(580, 280)
self.serialList.resize(120, 30)
self.serialList.addItem("Please select serial device")
def checkSerial(self):
reply = QMessageBox.information(self, 'No serial',
"Please select serial device",
QMessageBox.Yes)
# portlist = SerialComboBox().get_port_list(self)
# self.userCom = None
# if portlist is not None:
# for port in portlist:
# print("port ",port)
# self.userCom = port
# if self.userCom is not None :
# self.dataThread.openSerial(self.userCom)
# else:
# reply = QMessageBox.information(self, '没有设置串口', "请选择串口" , QMessageBox.Yes)
def serialChange(self, i):
print("serialChange", i, self.serialList.currentText())
if i > 0:
self.userCom = self.serialList.currentText()
self.dataThread.initSerialPort(self.userCom)
def ctrlOpen(self):
print("self.userCom", self.userCom)
if self.userCom is None:
self.checkSerial()
return
if self.open_status == 1:
print('start send C command 0')
self.open_status = 0
self.ctrlOpenButton.setText("Open")
self.dataThread.sendData('CMDC\0')
else:
print('start send C command 1')
self.open_status = 1
self.ctrlOpenButton.setText("Close")
self.dataThread.sendData('CMDC\1')
def evaluate(self):
if self.userCom is None:
self.checkSerial()
return
global evaluate_mode
if evaluate_mode == "operate":
print('start send E command 0')
evaluate_mode = "evaluate"
self.EvaluateButton.setText("Evaluate")
self.dataThread.sendData('CMDE\1')
else:
print('start send E command 1')
evaluate_mode = "operate"
self.EvaluateButton.setText("Operate")
self.dataThread.sendData('CMDE\0')
def ctrlSendone(self):
if self.userCom is None:
self.checkSerial()
return
print('send a frame')
self.dataThread.sendData('CMDC\2')
def modeManual(self):
if self.userCom is None:
self.checkSerial()
return
if self.mode == 1:
self.getOnePicButton.setEnabled(True)
self.modeManualButton.setText("Manual")
self.dataThread.sendData('CMDM\0')
self.mode = 0
print('mode: manual')
else:
self.getOnePicButton.setEnabled(False)
self.modeManualButton.setText("Auto")
self.dataThread.sendData('CMDM\1')
print('mode: auto')
self.mode = 1
def modeAuto(self):
if self.userCom is None:
self.checkSerial()
return
print('mode: auto')
self.dataThread.sendData('CMDM\1')
def rate(self):
if self.userCom is None:
self.checkSerial()
return
global btn_index
btn_index = (btn_index + 1) % 5
print('FPS:', strButton[btn_index])
self.modeFpsButton.setText(strButton[btn_index])
self.dataThread.sendData(strFpsCmd[btn_index]) #'CMDF\0')
def objBody(self):
if self.userCom is None:
self.checkSerial()
return
if self.body == 1:
self.body = 0
print('obj: Object')
self.modeObjButton.setText("Object")
self.dataThread.sendData('CMDO\0')
else:
self.body = 1
print('obj: Human Body')
self.modeObjButton.setText("Body")
self.dataThread.sendData('CMDO\1')
def uiUpdate(self):
global evaluate_mode
print("update UI ", evaluate_mode)
if evaluate_mode == "operate":
self.EvaluateButton.setText("Operate")
elif evaluate_mode == "evaluate":
self.EvaluateButton.setText("Evaluate")
else:
self.EvaluateButton.setText("None")
def cmdUpdate(self):
if self.userCom is None:
self.checkSerial()
return
print("get evaluate status and version\n")
time.sleep(0.1)
self.dataThread.sendData('CMDE\2')
time.sleep(0.1)
self.dataThread.sendData('CMDV\0')
time.sleep(0.1)
self.dataThread.sendData('CMDT\1')
def commonOffset(self):
if self.userCom is None:
self.checkSerial()
return
self.dataThread.sendData('CMDT\1')
print("Get commonOffset")
def sysVer(self):
if self.userCom is None:
self.checkSerial()
return
self.dataThread.sendData('CMDV\1')
print("Get firmware version and calibration version.")
def setEvaluate(self):
if self.userCom is None:
self.checkSerial()
return
if self.evaluate == 1:
self.evaluate = 0
self.evaluateButton.setText("Operate")
self.dataThread.sendData('CMDE\0')
else:
self.evaluate = 1
self.evaluateButton.setText("Evaluate")
self.dataThread.sendData('CMDE\1')
def draw(self):
global minHue
global maxHue
global maxHet
global minHet
global device_commonOffset
global evaluate_mode
if len(displayData) == 0:
return
font = QFont()
color = QColor()
font.setPointSize(self.fontSize)
#font.setFamily("Microsoft YaHei")
font.setLetterSpacing(QFont.AbsoluteSpacing, 0)
index = 0
lock.acquire()
frame = displayData.pop(0)
lock.release()
p = QPainter(self.cameraBuffer)
p.fillRect(0, 0, self.width, self.height + self.textLineHeight,
QBrush(QColor(Qt.black)))
# draw camera
color = QColor()
cneter = 0.0
if chip == "90640":
if self.centerIndex == 0:
centerIndex = 12 * 32 + 16
for yIndex in range(int(self.height / self.pixelSize)):
for xIndex in range(int(self.width / self.pixelSize)):
color.setHsvF(frame[index] / 360, 1.0, 1.0)
p.fillRect(xIndex * self.pixelSize,
yIndex * self.pixelSize, self.pixelSize,
self.pixelSize, QBrush(color))
index = index + 1
cneter = round(
mapValue(frame[self.centerIndex], minHue, maxHue, minHet,
maxHet), 1)
elif chip == "90621":
if self.centerIndex == 0 or self.centerIndex >= 64:
self.centerIndex = 2 * 16 + 8
cneter = round(
mapValue(frame[self.centerIndex], minHue, maxHue, minHet,
maxHet), 1)
for yIndex in range(int(self.height / self.pixelSize / 6)):
for xIndex in range(int(self.width / self.pixelSize / 2)):
color.setHsvF(frame[index] / 360, 1.0, 1.0)
p.fillRect(xIndex * self.pixelSize * 2,
yIndex * self.pixelSize * 2 + 160,
self.pixelSize * 2, self.pixelSize * 2,
QBrush(color))
index = index + 1
elif chip == "90641":
if self.centerIndex == 0 or self.centerIndex >= 192:
self.centerIndex = 6 * 16 + 8
cneter = round(
mapValue(frame[self.centerIndex], minHue, maxHue, minHet,
maxHet), 1)
for yIndex in range(int(self.height / self.pixelSize / 2)):
for xIndex in range(int(self.width / self.pixelSize / 2)):
color.setHsvF(frame[index] / 360, 1.0, 1.0)
p.fillRect(xIndex * self.pixelSize * 2,
yIndex * self.pixelSize * 2, self.pixelSize * 2,
self.pixelSize * 2, QBrush(color))
index = index + 1
else:
print("Dsiplay Error: can't detect any chip type!")
self.cameraItem.setPixmap(self.cameraBuffer)
self.frameCount = self.frameCount + 1
# draw text
p = QPainter(self.hetTextBuffer)
p.fillRect(0, 0, self.width + 200, self.height + self.textLineHeight,
QBrush(QColor(Qt.black)))
version = self.dataThread.getID()
p.setPen(QColor(Qt.white))
p.setFont(font)
p.drawText(0, self.fontSize, " max:" + '{:.2f}'.format(maxHet))
p.drawText(self.textInterval, self.fontSize,
" min:" + '{:.2f}'.format(minHet))
p.drawText(self.textInterval * 2, self.fontSize,
"offset:" + '{:.2f}'.format(device_commonOffset))
p.drawText(self.textInterval * 3, self.fontSize,
"mode:" + detect_status)
p.drawText(self.textInterval * 4, self.fontSize, evaluate_mode)
p.drawText(self.textInterval * 5, self.fontSize,
"ID:" + str(version[0]))
p.drawText(self.textInterval * 6, self.fontSize,
"ver:" + str(version[1] & 0xff))
p.drawText(self.textInterval * 7, self.fontSize, chip)
self.hetTextItem.setPixmap(self.hetTextBuffer)
cneter = round(
mapValue(frame[self.centerIndex], minHue, maxHue, minHet, maxHet),
1)
centerText = "<font color=white>%s</font>"
self.centerTextItem.setFont(font)
self.centerTextItem.setHtml(centerText % (str(cneter) + "°"))
# draw version text
self.versionTextItem.setFont(font)
class CameraView(QGraphicsObject):
font: QFont = QFont("monospace", 16)
stick_link_requested = pyqtSignal(StickWidget)
stick_context_menu = pyqtSignal('PyQt_PyObject', 'PyQt_PyObject')
stick_widgets_out_of_sync = pyqtSignal('PyQt_PyObject')
visibility_toggled = pyqtSignal()
synchronize_clicked = pyqtSignal('PyQt_PyObject')
previous_photo_clicked = pyqtSignal('PyQt_PyObject')
next_photo_clicked = pyqtSignal('PyQt_PyObject')
sync_confirm_clicked = pyqtSignal('PyQt_PyObject')
sync_cancel_clicked = pyqtSignal('PyQt_PyObject')
first_photo_clicked = pyqtSignal('PyQt_PyObject')
enter_pressed = pyqtSignal()
def __init__(self, scale: float, parent: Optional[QGraphicsItem] = None):
QGraphicsObject.__init__(self, parent)
self.current_highlight_color = QColor(0, 0, 0, 0)
self.current_timer = -1
self.scaling = scale
self.pixmap = QGraphicsPixmapItem(self)
self.stick_widgets: List[StickWidget] = []
self.link_cam_text = QGraphicsSimpleTextItem("Link camera...", self)
self.link_cam_text.setZValue(40)
self.link_cam_text.setVisible(False)
self.link_cam_text.setFont(CameraView.font)
self.link_cam_text.setPos(0, 0)
self.link_cam_text.setPen(QPen(QColor(255, 255, 255, 255)))
self.link_cam_text.setBrush(QBrush(QColor(255, 255, 255, 255)))
self.show_add_buttons = False
self.camera = None
self.setFlag(QGraphicsItem.ItemSendsGeometryChanges, True)
self.show_stick_widgets = False
self.setAcceptHoverEvents(True)
self.stick_edit_mode = False
self.original_pixmap = self.pixmap.pixmap()
self.hovered = False
self.mode = 0 # TODO make enum Mode
self.click_handler = None
self.double_click_handler: Callable[[int, int], None] = None
self.stick_widget_mode = StickMode.Display
self.highlight_animation = QPropertyAnimation(self, b"highlight_color")
self.highlight_animation.setEasingCurve(QEasingCurve.Linear)
self.highlight_animation.valueChanged.connect(
self.handle_highlight_color_changed)
self.highlight_rect = QGraphicsRectItem(self)
self.highlight_rect.setZValue(4)
self.highlight_rect.setPen(QPen(QColor(0, 0, 0, 0)))
self.title_btn = Button('btn_title', '', parent=self)
self.title_btn.setFlag(QGraphicsItem.ItemIgnoresTransformations, False)
self.title_btn.setZValue(5)
self.title_btn.setVisible(False)
self.sticks_without_width: List[Stick] = []
self.current_image_name: str = ''
self.control_widget = ControlWidget(parent=self)
self.control_widget.setFlag(QGraphicsItem.ItemIgnoresTransformations,
False)
self.control_widget.setVisible(True)
self._connect_control_buttons()
self.image_available = True
self.blur_eff = QGraphicsBlurEffect()
self.blur_eff.setBlurRadius(5.0)
self.blur_eff.setEnabled(False)
self.pixmap.setGraphicsEffect(self.blur_eff)
self.overlay_message = QGraphicsSimpleTextItem('not available',
parent=self)
font = self.title_btn.font
font.setPointSize(48)
self.overlay_message.setFont(font)
self.overlay_message.setBrush(QBrush(QColor(200, 200, 200, 200)))
self.overlay_message.setPen(QPen(QColor(0, 0, 0, 200), 2.0))
self.overlay_message.setVisible(False)
self.overlay_message.setZValue(6)
self.stick_box = QGraphicsRectItem(parent=self)
self.stick_box.setFlag(QGraphicsItem.ItemIsMovable, True)
self.stick_box.setVisible(False)
self.stick_box_start_pos = QPoint()
def _connect_control_buttons(self):
self.control_widget.synchronize_btn.clicked.connect(
lambda: self.synchronize_clicked.emit(self))
self.control_widget.prev_photo_btn.clicked.connect(
lambda: self.previous_photo_clicked.emit(self))
self.control_widget.next_photo_btn.clicked.connect(
lambda: self.next_photo_clicked.emit(self))
self.control_widget.accept_btn.clicked.connect(
lambda: self.sync_confirm_clicked.emit(self))
self.control_widget.cancel_btn.clicked.connect(
lambda: self.sync_cancel_clicked.emit(self))
self.control_widget.first_photo_btn.clicked.connect(
lambda: self.first_photo_clicked.emit(self))
def paint(self, painter: QPainter,
option: PyQt5.QtWidgets.QStyleOptionGraphicsItem,
widget: QWidget):
if self.pixmap.pixmap().isNull():
return
painter.setRenderHint(QPainter.Antialiasing, True)
if self.show_stick_widgets:
brush = QBrush(QColor(255, 255, 255, 100))
painter.fillRect(self.boundingRect(), brush)
if self.mode and self.hovered:
pen = QPen(QColor(0, 125, 200, 255))
pen.setWidth(4)
painter.setPen(pen)
def boundingRect(self) -> PyQt5.QtCore.QRectF:
return self.pixmap.boundingRect().united(
self.title_btn.boundingRect().translated(self.title_btn.pos()))
def initialise_with(self, camera: Camera):
if self.camera is not None:
self.camera.stick_added.disconnect(self.handle_stick_created)
self.camera.sticks_added.disconnect(self.handle_sticks_added)
self.camera.stick_removed.disconnect(self.handle_stick_removed)
self.camera.sticks_removed.disconnect(self.handle_sticks_removed)
self.camera.stick_changed.disconnect(self.handle_stick_changed)
self.camera = camera
self.prepareGeometryChange()
self.set_image(camera.rep_image, Path(camera.rep_image_path).name)
self.title_btn.set_label(self.camera.folder.name)
self.title_btn.set_height(46)
self.title_btn.fit_to_contents()
self.title_btn.set_width(int(self.boundingRect().width()))
self.title_btn.setPos(0, self.boundingRect().height())
self.control_widget.title_btn.set_label(self.camera.folder.name)
self.camera.stick_added.connect(self.handle_stick_created)
self.camera.sticks_added.connect(self.handle_sticks_added)
self.camera.stick_removed.connect(self.handle_stick_removed)
self.camera.sticks_removed.connect(self.handle_sticks_removed)
self.camera.stick_changed.connect(self.handle_stick_changed)
self.control_widget.set_font_height(32)
self.control_widget.set_widget_height(
self.title_btn.boundingRect().height())
self.control_widget.set_widget_width(int(self.boundingRect().width()))
self.control_widget.setPos(0,
self.pixmap.boundingRect().height()
) #self.boundingRect().height())
self.control_widget.set_mode('view')
self.update_stick_widgets()
def set_image(self,
img: Optional[np.ndarray] = None,
image_name: Optional[str] = None):
if img is None:
self.show_overlay_message('not available')
return
self.show_overlay_message(None)
self.prepareGeometryChange()
barray = QByteArray(img.tobytes())
image = QImage(barray, img.shape[1], img.shape[0],
QImage.Format_BGR888)
self.original_pixmap = QPixmap.fromImage(image)
self.pixmap.setPixmap(self.original_pixmap)
self.highlight_rect.setRect(self.boundingRect())
self.current_image_name = image_name
def update_stick_widgets(self):
stick_length = 60
for stick in self.camera.sticks:
sw = StickWidget(stick, self.camera, self)
sw.set_mode(self.stick_widget_mode)
self.connect_stick_widget_signals(sw)
self.stick_widgets.append(sw)
stick_length = stick.length_cm
self.update_stick_box()
self.scene().update()
def scale_item(self, factor: float):
self.prepareGeometryChange()
pixmap = self.original_pixmap.scaledToHeight(
int(self.original_pixmap.height() * factor))
self.pixmap.setPixmap(pixmap)
self.__update_title()
def set_show_stick_widgets(self, value: bool):
for sw in self.stick_widgets:
sw.setVisible(value)
self.scene().update()
def hoverEnterEvent(self, e: QGraphicsSceneHoverEvent):
self.hovered = True
self.scene().update(self.sceneBoundingRect())
def hoverLeaveEvent(self, e: QGraphicsSceneHoverEvent):
self.hovered = False
self.scene().update(self.sceneBoundingRect())
def mousePressEvent(self, e: QGraphicsSceneMouseEvent):
super().mousePressEvent(e)
def mouseReleaseEvent(self, e: QGraphicsSceneMouseEvent):
if self.mode == 1:
self.click_handler(self.camera)
def mouseDoubleClickEvent(self, event: QGraphicsSceneMouseEvent):
if self.stick_widget_mode == StickMode.EditDelete:
x = event.pos().toPoint().x()
y = event.pos().toPoint().y()
stick = self.camera.create_new_sticks(
[(np.array([[x, y - 50], [x, y + 50]]), 3)],
self.current_image_name)[
0] #self.dataset.create_new_stick(self.camera)
self.sticks_without_width.append(stick)
def set_button_mode(self, click_handler: Callable[[Camera], None],
data: str):
self.mode = 1 # TODO make a proper ENUM
self.click_handler = lambda c: click_handler(c, data)
def set_display_mode(self):
self.mode = 0 # TODO make a proper ENUM
self.click_handler = None
def _remove_stick_widgets(self):
for sw in self.stick_widgets:
sw.setParentItem(None)
self.scene().removeItem(sw)
sw.deleteLater()
self.stick_widgets.clear()
def handle_stick_created(self, stick: Stick):
if stick.camera_id != self.camera.id:
return
sw = StickWidget(stick, self.camera, self)
sw.set_mode(self.stick_widget_mode)
self.connect_stick_widget_signals(sw)
self.stick_widgets.append(sw)
self.stick_widgets_out_of_sync.emit(self)
self.update()
def handle_stick_removed(self, stick: Stick):
if stick.camera_id != self.camera.id:
return
stick_widget = next(
filter(lambda sw: sw.stick.id == stick.id, self.stick_widgets))
self.disconnect_stick_widget_signals(stick_widget)
self.stick_widgets.remove(stick_widget)
stick_widget.setParentItem(None)
self.scene().removeItem(stick_widget)
stick_widget.deleteLater()
self.update()
def handle_sticks_removed(self, sticks: List[Stick]):
if sticks[0].camera_id != self.camera.id:
return
for stick in sticks:
to_remove: StickWidget = None
for sw in self.stick_widgets:
if sw.stick.id == stick.id:
to_remove = sw
break
self.stick_widgets.remove(to_remove)
to_remove.setParentItem(None)
if self.scene() is not None:
self.scene().removeItem(to_remove)
to_remove.deleteLater()
self.update()
def handle_sticks_added(self, sticks: List[Stick]):
if len(sticks) == 0:
return
if sticks[0].camera_id != self.camera.id:
return
for stick in sticks:
sw = StickWidget(stick, self.camera, self)
sw.set_mode(self.stick_widget_mode)
self.connect_stick_widget_signals(sw)
self.stick_widgets.append(sw)
self.update_stick_box()
self.stick_widgets_out_of_sync.emit(self)
self.update()
def connect_stick_widget_signals(self, stick_widget: StickWidget):
stick_widget.delete_clicked.connect(
self.handle_stick_widget_delete_clicked)
stick_widget.stick_changed.connect(self.handle_stick_widget_changed)
stick_widget.link_initiated.connect(self.handle_stick_link_initiated)
stick_widget.right_clicked.connect(
self.handle_stick_widget_context_menu)
def disconnect_stick_widget_signals(self, stick_widget: StickWidget):
stick_widget.delete_clicked.disconnect(
self.handle_stick_widget_delete_clicked)
stick_widget.stick_changed.disconnect(self.handle_stick_widget_changed)
stick_widget.link_initiated.disconnect(
self.handle_stick_link_initiated)
stick_widget.right_clicked.disconnect(
self.handle_stick_widget_context_menu)
def handle_stick_widget_delete_clicked(self, stick: Stick):
self.camera.remove_stick(stick)
def set_stick_widgets_mode(self, mode: StickMode):
self.stick_widget_mode = mode
for sw in self.stick_widgets:
sw.set_mode(mode)
self.set_stick_edit_mode(mode == StickMode.Edit)
def handle_stick_widget_changed(self, stick_widget: StickWidget):
self.camera.stick_changed.emit(stick_widget.stick)
def handle_stick_changed(self, stick: Stick):
if stick.camera_id != self.camera.id:
return
sw = next(
filter(lambda _sw: _sw.stick.id == stick.id, self.stick_widgets))
sw.adjust_line()
sw.update_tooltip()
def handle_stick_link_initiated(self, stick_widget: StickWidget):
self.stick_link_requested.emit(stick_widget)
def get_top_left(self) -> QPointF:
return self.sceneBoundingRect().topLeft()
def get_top_right(self) -> QPointF:
return self.sceneBoundingRect().topRight()
def highlight(self, color: Optional[QColor]):
if color is None:
self.highlight_animation.stop()
self.highlight_rect.setVisible(False)
return
alpha = color.alpha()
color.setAlpha(0)
self.highlight_animation.setStartValue(color)
self.highlight_animation.setEndValue(color)
color.setAlpha(alpha)
self.highlight_animation.setKeyValueAt(0.5, color)
self.highlight_animation.setDuration(2000)
self.highlight_animation.setLoopCount(-1)
self.highlight_rect.setPen(QPen(color))
self.highlight_rect.setVisible(True)
self.highlight_animation.start()
@pyqtProperty(QColor)
def highlight_color(self) -> QColor:
return self.current_highlight_color
@highlight_color.setter
def highlight_color(self, color: QColor):
self.current_highlight_color = color
def handle_highlight_color_changed(self, color: QColor):
self.highlight_rect.setBrush(QBrush(color))
self.update()
def handle_stick_widget_context_menu(self, sender: Dict[str, StickWidget]):
self.stick_context_menu.emit(sender['stick_widget'], self)
def show_overlay_message(self, msg: Optional[str]):
if msg is None:
self.overlay_message.setVisible(False)
self.blur_eff.setEnabled(False)
return
self.overlay_message.setText(msg)
self.overlay_message.setPos(
self.pixmap.boundingRect().center() -
QPointF(0.5 * self.overlay_message.boundingRect().width(), 0.5 *
self.overlay_message.boundingRect().height()))
self.overlay_message.setVisible(True)
self.blur_eff.setEnabled(True)
def show_status_message(self, msg: Optional[str]):
if msg is None:
self.control_widget.set_title_text(self.camera.folder.name)
else:
self.control_widget.set_title_text(msg)
def update_stick_box(self):
left = 9000
right = 0
top = 9000
bottom = -1
for stick in self.camera.sticks:
left = min(left, min(stick.top[0], stick.bottom[0]))
right = max(right, max(stick.top[0], stick.bottom[0]))
top = min(top, min(stick.top[1], stick.bottom[1]))
bottom = max(bottom, max(stick.top[1], stick.bottom[1]))
left -= 100
right += 100
top -= 100
bottom += 100
self.stick_box.setRect(left, top, right - left, bottom - top)
pen = QPen(QColor(0, 100, 200, 200))
pen.setWidth(2)
pen.setStyle(Qt.DashLine)
self.stick_box.setPen(pen)
def set_stick_edit_mode(self, is_edit: bool):
if is_edit:
self.update_stick_box()
self.stick_box_start_pos = self.stick_box.pos()
for sw in self.stick_widgets:
sw.setParentItem(self.stick_box)
else:
offset = self.stick_box.pos() - self.stick_box_start_pos
for sw in self.stick_widgets:
stick = sw.stick
stick.translate(np.array([int(offset.x()), int(offset.y())]))
sw.setParentItem(self)
sw.set_stick(stick)
self.stick_box.setParentItem(None)
self.stick_box = QGraphicsRectItem(self)
self.stick_box.setFlag(QGraphicsItem.ItemIsMovable, True)
self.stick_box.setVisible(False)
self.stick_box.setVisible(is_edit)
def keyPressEvent(self, event: QKeyEvent) -> None:
pass
def keyReleaseEvent(self, event: QKeyEvent) -> None:
if event.key() in [Qt.Key_Right, Qt.Key_Tab, Qt.Key_Space]:
self.control_widget.next_photo_btn.click_button(True)
elif event.key() in [Qt.Key_Left]:
self.control_widget.prev_photo_btn.click_button(True)
elif event.key() == Qt.Key_S:
self.enter_pressed.emit()
class Button(QPushButton):
def __init__(self, parent):
self.main_window = parent
self.shadow = QPushButton(self.main_window)
super(Button, self).__init__(parent)
self.blur_effect = None
self.clickable = True
self.default_width, self.default_height = None, None
self.default_shadowwidth, self.default_shadowheight = None, None
self.img_shadow = None
def setup(self):
self.img_idle = os.path.join(abspath, self.img_idle)
self.img_hover = os.path.join(abspath, self.img_hover)
self.img_click = os.path.join(abspath, self.img_click)
if self.img_shadow is not None:
self.setup_shadow()
else:
self.shadow.setParent(None)
self.shadow = None
self.setIcon(QtGui.QIcon(self.img_idle))
self.setStyleSheet("""
QPushButton:flat
{
border: none;
background: none;
outline: none;
}""")
imgsize = getsize(self.img_idle)
self.setMaximumWidth(imgsize[0])
self.setMaximumHeight(imgsize[1])
width = self.default_size * imgsize[0] / 10
height = self.default_size * imgsize[1] / 10
self.default_width, self.default_height = width, height
self.setIconSize(QtCore.QSize(width, height))
self.setGeometry(self.default_x, self.default_y, width, height)
self.setFlat(True)
self.blur_effect = QGraphicsBlurEffect()
self.blur_effect.setBlurRadius(0)
self.setGraphicsEffect(self.blur_effect)
def setup_shadow(self):
self.img_shadow = os.path.join(abspath, self.img_shadow)
imgsize = getsize(self.img_shadow)
width = self.default_size * imgsize[0] / 10 * 1.01
height = self.default_size * imgsize[1] / 10 * 1.01
self.default_shadowwidth, self.default_shadowheight = width, height
self.shadow.setIcon(QtGui.QIcon(self.img_shadow))
self.shadow.setStyleSheet("""
QPushButton:flat
{
border: none;
background: none;
outline: none;
}""")
self.shadow.setIconSize(QtCore.QSize(width, height))
x, y = get_shadowpos(self, width, height)
self.shadow.setGeometry(x, y, width, height)
self.shadow.setFlat(True)
def blur_me(self, blur):
if blur:
self.blur_effect.setBlurRadius(25)
else:
self.blur_effect.setBlurRadius(0)
def mousePressEvent(self, QEvent):
if self.clickable:
self.setIcon(QtGui.QIcon(self.img_click))
def mouseReleaseEvent(self, QEvent):
if self.clickable:
self.mouseclicked()
self.setIcon(QtGui.QIcon(self.img_idle))
def enterEvent(self, QEvent):
if self.clickable:
self.setIcon(QtGui.QIcon(self.img_hover))
def leaveEvent(self, QEvent):
self.setIcon(QtGui.QIcon(self.img_idle))
def mouseclicked(self):
pass
def setParent(self, parent):
super().setParent(parent)
if self.shadow is not None:
self.shadow.setParent(parent)
def changesize(self):
changesize(self)
if self.shadow is not None:
scale = self.main_window.height() / self.main_window.default_height
width = self.default_shadowwidth * scale
height = self.default_shadowheight * scale
self.shadow.setIconSize(QtCore.QSize(width, height))
x, y = get_shadowpos(self, width, height)
self.shadow.setGeometry(x, y, width, height)
class SkinDropDown(QComboBox):
def __init__(self, parent):
super(SkinDropDown, self).__init__(parent)
self.default_x = 600
self.default_y = 245
self.img_drop = os.path.join(abspath, "res/Drop_Scale.png")
self.img_listview = os.path.join(abspath, "res/listview.png")
self.activated.connect(self.activated_)
self.main_window = parent
self.addEmptyItem(0)
self.addEmptyItem(self.count() - 1)
self.addItems(["Default Skin"])
self.setStyleSheet("""QComboBox
{
border-image : url(%s);
color: white;
}
QComboBox::drop-down
{
border-bottom-right-radius: 1px;
}
QListView
{
outline: none;
color: white;
font: bold;
border-image : url(%s);
}
QScrollBar:vertical {
width: 0px;
height: 0px;
}
QScrollBar::up-arrow:vertical, QScrollBar::down-arrow:vertical {
width: 0px;
height: 0px;
background: none;
}
QScrollBar::add-page:vertical, QScrollBar::sub-page:vertical {
background: none;
}
QTextEdit, QListView {
background-color: rgba(0, 0, 0, 0);
background-attachment: scroll;
}
""" % (self.img_drop, self.img_listview))
self.setItemData(0, QColor(QtCore.Qt.transparent),
QtCore.Qt.BackgroundRole)
self.setItemData(1, QColor(QtCore.Qt.transparent),
QtCore.Qt.BackgroundRole)
self.setItemData(2, QColor(QtCore.Qt.transparent),
QtCore.Qt.BackgroundRole)
self.setup()
def addEmptyItem(self, index):
self.addItems([""])
model = self.model()
index = model.index(index, self.modelColumn())
item = model.itemFromIndex(index)
item.setSelectable(False)
def setup(self):
self.default_width, self.default_height = getsize(self.img_drop)
self.default_width /= 1.5
self.default_height /= 1.5
self.setGeometry(self.default_x, self.default_y, self.default_width,
self.default_height)
self.setIconSize(QtCore.QSize(self.default_width, self.default_height))
self.view().setIconSize(QtCore.QSize(
0, 0)) # for linux machines otherwise texts got hidden
self.setMaxVisibleItems(7)
self.blur_effect = QGraphicsBlurEffect()
self.blur_effect.setBlurRadius(0)
self.setGraphicsEffect(self.blur_effect)
def activated_(self, index):
current_config["Skin path"] = os.path.join(current_config["osu! path"],
"Skins",
self.itemText(index))
save()
logging.info(current_config["Skin path"])
def get_skins(self):
name = "Default Skin"
if os.path.isdir(current_config["Skin path"]):
name = os.path.basename(current_config["Skin path"])
skin_list = [
f for f in glob.glob(os.path.join(current_config["osu! path"],
"Skins/*"),
recursive=True)
]
for x in skin_list:
skinname = os.path.basename(x)
self.addItems([skinname])
self.setCurrentIndex(self.findText(name))
def set_skin_osu(self):
c = glob.glob(os.path.join(current_config["osu! path"], "osu!.*.cfg"))
logging.info(c)
if c:
cfg = [x for x in c if "osu!.cfg" not in x]
logging.info(cfg)
props = read_properties_file(cfg[0])
name = props['skin']
current_config["Skin path"] = os.path.join(
current_config["osu! path"], "Skins", name)
self.setCurrentIndex(self.findText(name))
def changesize(self):
changesize(self)
self.view().setIconSize(QtCore.QSize(
0, 0)) # for linux machines otherwise texts got hidden
def addItems(self, Iterable, p_str=None):
super().insertItems(self.count() - 1, Iterable)
def blur_me(self, blur):
if blur:
self.blur_effect.setBlurRadius(25)
else:
self.blur_effect.setBlurRadius(0)
class MainWidget(QWidget):
def __init__(self):
super(MainWidget, self).__init__()
self._blur = QGraphicsBlurEffect()
self._blur.setBlurRadius(0)
self.image = ImageView()
self.image.setGraphicsEffect(self._blur)
self.video = QVideoWidget()
self.label = QLabel()
self.label.setMaximumHeight(25)
self.label.setStyleSheet('color: rgb(200, 200, 200);')
font = QFont()
font.setPixelSize(20)
font.setWeight(QFont.Bold)
self.label.setFont(font)
self.setLayout(QVBoxLayout())
self.layout().addWidget(self.image)
self.layout().addWidget(self.video)
self.layout().addWidget(self.label)
self.mplayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mplayer.setVideoOutput(self.video)
self.mplayer.error.connect(
lambda: print("Video:", self.mplayer.errorString()))
self.mplayer.mediaStatusChanged.connect(self.state_changed)
self.overlay = QLabel(self)
self.overlay.setFrameStyle(Qt.FramelessWindowHint)
self.overlay.setStyleSheet(
'background-color: rgba(0,0,0,0.7); color: rgba(200,200,200,1);')
self.overlay.setFont(font)
self.overlay.setVisible(False)
self.overlay.setWordWrap(True)
def resize(self):
self.overlay.setGeometry(0, 3 * self.height() // 4 - 50, self.width(),
100)
def resizeEvent(self, event):
super().resizeEvent(event)
self.resize()
def state_changed(self, state):
if state == QMediaPlayer.EndOfMedia:
self.mplayer.setPosition(0)
self.mplayer.play()
@property
def blur(self):
return self._blur.blurRadius()
@blur.setter
def blur(self, value):
self._blur.setBlurRadius(value)
def load(self, pic, *args, **kwargs):
if isinstance(pic, str):
still = path.splitext(pic)[1].lower()[1:] not in ('webm', 'mp4')
else:
still = pic.is_still if pic else True
if still:
self.image.load(pic, *args, **kwargs)
self.video.hide()
self.image.show()
self.mplayer.stop()
else:
url = pic if isinstance(pic, str) else pic.filename
self.mplayer.setMedia(QMediaContent(QUrl.fromLocalFile(url)))
self.mplayer.setMuted(True)
self.mplayer.play()
self.image.hide()
self.video.show()
self.overlay.setVisible(False)
def message(self, msg):
self.label.setText('<div align="center">{}</div>'.format(msg))
def flash(self, msg):
self.overlay.setText('<div align="center">{}</div>'.format(msg))
self.overlay.setVisible(True)
def halt(self):
self.mplayer.stop()
def blur(self):
shadow = QGraphicsBlurEffect()
shadow.setBlurRadius(self.shadowSize)
self.text.setGraphicsEffect(shadow)