def set_image(self, image_filename):
size = 800
pixmap = QPixmap(image_filename)
if pixmap.width() > pixmap.height():
if pixmap.width() > size:
pixmap = pixmap.scaledToWidth(size)
else:
if pixmap.height() > size:
pixmap = pixmap.scaledToHeight(size)
self.ui.label.setPixmap(pixmap)
self.ui.label.setMask(pixmap.mask())
self.ui.label.show()
def _setup_layout(self):
main_layout = QVBoxLayout()
content_layout = QHBoxLayout()
splash_path = os.path.join(
os.path.split(ilastik.__file__)[0], 'ilastik-splash.png'
)
splash_pixmap = QPixmap(splash_path)
logo_label = QLabel()
logo_label.setPixmap(splash_pixmap)
content_layout.addWidget(logo_label)
text_label = QLabel()
text_label.setWordWrap(True)
text_label.setTextFormat(Qt.RichText)
text_label.setOpenExternalLinks(True)
text_label.setText(about_text)
content_layout.addWidget(text_label)
btn_box = QDialogButtonBox(QDialogButtonBox.Ok)
btn_box.accepted.connect(self.accept)
main_layout.addLayout(content_layout)
main_layout.addWidget(btn_box)
self.setLayout(main_layout)
self.setStyleSheet("background-color: white;")
self.setWindowTitle('About ilastik')
self.setFixedSize(splash_pixmap.width() * 2.5, splash_pixmap.height() * 1.05)
def initUI(self):
self.setFixedSize(400, 260)
self.setWindowTitle('Fomoire!')
fomoire = QPixmap(os.path.join('./Pictures/', "fomoire.png"))
logo = QLabel(self)
logo.setPixmap(fomoire)
logo.setFixedSize(fomoire.size())
logo.move(400 / 2 - fomoire.width() / 2, 15)
towerDefence = QLabel('A Tower Defence Game', self)
towerDefence.move(130, 66)
selectMap = QLabel('Select map:', self)
selectMap.move(50, 105)
mapList = QComboBox(self)
mapList.addItem('No map selected')
for mapFile in os.listdir('./Maps/'):
mapList.addItem(mapFile)
mapList.move(135, 102)
mapList.activated[str].connect(self.selectMap)
setSpeed = QLabel('Set game speed:', self)
setSpeed.move(50, 140)
slow = QLabel('Slow', self)
slow.move(170, 140)
slider = QSlider(Qt.Horizontal, self)
slider.setFocusPolicy(Qt.NoFocus)
slider.setSliderPosition(100 - self.gameSpeed)
slider.setGeometry(210, 140, 100, 20)
slider.valueChanged[int].connect(self.changeGameSpeed)
fast = QLabel('Fast', self)
fast.move(325, 140)
start = QPushButton('Start game!', self)
start.move(145, 175)
start.clicked[bool].connect(self.startGame)
quitButton = QPushButton('Quit', self)
quitButton.move(168, 210)
quitButton.clicked[bool].connect(qApp.quit)
barbarian = QLabel(self)
brbr = QPixmap(os.path.join('./Pictures/', "barbarian.png"))
barbarian.setPixmap(brbr)
barbarian.move(70, 185)
berserker = QLabel(self)
berber = QPixmap(os.path.join('./Pictures/', "berserker_left.png"))
berserker.setPixmap(berber)
berserker.move(290, 185)
self.show()
def drawRects(self, source, rectsTree, scale):
"""Draw rectangles in 'rectsTree' on 'source'.
"""
pixmap = QPixmap(source)
self.drawBackground(pixmap)
def drawRect(node, parentHash):
painter = QtGui.QPainter(pixmap)
roi, param, tracking = node.data
x, y, w, h = common.scaleRect(roi, scale)
painter.setPen(param.color)
funcTable = {
self.FILL_MASK: self.fillMask,
self.FILL_BLUR: self.fillBlur,
self.FILL_IMAGE: self.fillImage,
self.FILL_COLOR: self.fillColor,
self.FILL_OUTLINE: self.fillOutline
}
for fill, func in funcTable.iteritems():
if param.fill == fill:
func(pixmap, painter, (x, y, w, h), param, source)
if param.tracking:
self.drawTracking(painter, tracking, scale)
if param.showName:
painter.drawText(x, y, param.name)
return param.hash
h, w = pixmap.height(), pixmap.width()
rectsTree.map(None, drawRect)
painter = QtGui.QPainter(source)
painter.drawPixmap(0, 0, pixmap)
def draw_indicator(indicator: int):
pixmap = QPixmap(24, 24)
painter = QPainter(pixmap)
w, h = pixmap.width(), pixmap.height()
painter.fillRect(0, 0, w, h, QBrush((QColor(0, 0, 200, 255))))
pen = QPen(QColor("white"))
pen.setWidth(2)
painter.setPen(pen)
font = util.get_monospace_font()
font.setBold(True)
font.setPixelSize(16)
painter.setFont(font)
f = QFontMetrics(painter.font())
indicator_str = str(indicator) if indicator < 10 else "+"
fw = f.width(indicator_str)
fh = f.height()
painter.drawText(math.ceil(w / 2 - fw / 2), math.ceil(h / 2 + fh / 4), indicator_str)
painter.end()
return QIcon(pixmap)
def buildCharPreview(self):
char = self.selectedChar - self.charFrom.value()
if char < 0:
char = 0
if char >= len(self.charSizes):
char = len(self.charSizes) - 1
k = 5
s_x = self.charSizes[char][0]
w = self.charSizes[char][1]
charPix = self.chars.pixmap()
charImage = charPix.toImage()
self.charPreview.resize(w * k + 1, charPix.height() * k + 1)
pix = QPixmap(w * k, charPix.height() * k)
p = QPainter()
p.begin(pix)
p.setBrush(QBrush(QColor(0xffffff), Qt.SolidPattern))
p.drawRect(0, 0, pix.width() - 1, pix.height() - 1)
p.setBrush(QBrush(QColor(0x0), Qt.SolidPattern))
for x in range(w):
for y in range(charPix.height()):
if QColor(charImage.pixel(s_x + x, y)).lightness() == 0x0:
p.drawRect(x * k, y * k, k, k)
p.end()
self.charPreview.setPixmap(pix)
def paintEvent(self,event=None):
painter = QPainter(self)
pixmap=QPixmap(":/images/wheelfinal.png")
#painter.begin(self)
#painter.drawPixmap(QtCore.QRect(self.left, self.top, self.width, self.height), self.pixmap)
painter.drawPixmap(self.rect(), pixmap)
self.resize(pixmap.width(),pixmap.height())
pen = QPen(Qt.red, 3)
painter.setPen(pen)
painter.drawArc (self.disc_center-int(self.distance_from_center(self.points[0])) ,
self.disc_center - int(self.distance_from_center (self.points[0])) ,
2*int(self.distance_from_center(self.points[0])) ,
2*int(self.distance_from_center(self.points[0])) ,
int(16*self.hue_min) ,
int(16*(self.hue_max-self.hue_min)))#arc joining point 0 and point 1
painter.drawLine(int(self.points[0][0]),int(self.points[0][1]),int(self.points[3][0]),int(self.points[3][1]))#line joining point 0 and point 3
painter.drawArc(self.disc_center-int(self.distance_from_center(self.points[2])) ,
self.disc_center - int(self.distance_from_center (self.points[2])) ,
2*int(self.distance_from_center(self.points[2])) ,
2*int(self.distance_from_center(self.points[2])) ,
int(16*self.hue_min) ,
int(16*(self.hue_max-self.hue_min)))#arc joining point 2 and 3
painter.drawLine(int(self.points[1][0]),int(self.points[1][1]),int(self.points[2][0]),int(self.points[2][1]))#line joining point 1 and 2
self.update()
def createThemePreview(theme, screenRect, size=QSize(200, 120)):
if type(theme) == str and os.path.exists(theme):
# Theme is the path to an ini file
themeDatas = loadThemeDatas(theme)
else:
themeDatas = theme
pixmap = generateTheme(themeDatas, screenRect)
addThemePreviewText(pixmap, themeDatas, screenRect)
px = QPixmap(pixmap).scaled(size, Qt.KeepAspectRatio)
w = px.width() / 10
h = px.height() / 10
r = themeTextRect(themeDatas, screenRect)
painter = QPainter(px)
painter.drawPixmap(QRect(w, h, w * 4, h * 5), pixmap,
QRect(r.topLeft() - QPoint(w / 3, h / 3), QSize(w * 4, h * 5)))
painter.setPen(Qt.white)
painter.drawRect(QRect(w, h, w * 4, h * 5))
painter.end()
return px
def draw(self, defending, status, scene, size):
"""function draw
:param defending: boolean
:param status: str {'Charge', 'Shoot', 'Stand'}
:param scene: QGraphicsScene
:param size: QSize
no return
"""
pix = QPixmap('')
pix.width()
unit_pixmap = self.get_pixmap(status).scaled(size.width() * 80 / 100, size.height() * 80 / 100)
if defending:
unit_pixmap = mirror_pixmap(unit_pixmap)
scene.addPixmap(unit_pixmap)
def __init_ui(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
label = QLabel(self)
image = QPixmap('15_flower.jpg')
label.setPixmap(image)
label.move(0, 0)
self.resize(image.width(), image.height())
class PlayerUI(ShapeUI):
def __init__(self, parent, game):
super().__init__(parent, game)
self.player = game.player
self.speed = game.player_speed
self.pixmap = QPixmap("images/smile3.png")
self.image_height_fix = 48 # 48
self.width = self.pixmap.width()
self.height = self.pixmap.height()
self.set_shape_size()
self.set_initial_position()
self.show()
def set_initial_position(self):
"""Set the initial position of the player and moves the player
there.
"""
self.x = (self.field_width - self.image_size[0]) / 2
self.y = self.field_height - 50
self.move(self.x, self.y)
@property
def is_player_invincible(self):
"""Checks if the player is invincible"""
return self.player.is_player_invincible
def set_player_invinciblity(self):
"""Sets the player's invincibility to the opposite of the current
value.
"""
self.player.set_player_invinciblity()
@pyqtSlot()
def move_left(self):
"""Moves the player to the left and checks if the move is valid
(if the move is out of the game field).
"""
print("left")
if(self.x - self.speed > 0):
self.x -= self.speed
self.move(self.x, self.y)
@pyqtSlot()
def move_right(self):
"""Moves the player to the right and checks if the move is valid
(if the move is out of the game field).
"""
print("right")
if(self.x + self.speed < self.field_width -
self.image_size[0]):
self.x += self.speed
self.move(self.x, self.y)
class ShapeWidget(QWidget):
def __init__(self,parent=None):
super(ShapeWidget,self).__init__(parent)
self.i = 1
self.mypix()
self.timer = QTimer()
self.timer.setInterval(500) # 500毫秒
self.timer.timeout.connect(self.timeChange)
self.timer.start()
# 显示不规则 pic
def mypix(self):
self.update()
if self.i == 5:
self.i = 1
self.mypic = {1: './images/left.png', 2: "./images/up.png", 3: './images/right.png', 4: './images/down.png'}
self.pix = QPixmap(self.mypic[self.i], "0", Qt.AvoidDither | Qt.ThresholdDither | Qt.ThresholdAlphaDither)
self.resize(self.pix.size())
self.setMask(self.pix.mask())
self.dragPosition = None
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.m_drag=True
self.m_DragPosition=event.globalPos()-self.pos()
event.accept()
self.setCursor(QCursor(Qt.OpenHandCursor))
def mouseMoveEvent(self, QMouseEvent):
if Qt.LeftButton and self.m_drag:
self.move(QMouseEvent.globalPos()- self.m_DragPosition )
QMouseEvent.accept()
def mouseReleaseEvent(self, QMouseEvent):
self.m_drag=False
self.setCursor(QCursor(Qt.ArrowCursor))
def paintEvent(self, event):
painter = QPainter(self)
painter.drawPixmap(0, 0, self.pix.width(),self.pix.height(),self.pix)
# 鼠标双击事件
def mouseDoubleClickEvent(self, event):
if event.button() == 1:
self.i += 1
self.mypix()
# 每500毫秒修改paint
def timeChange(self):
self.i += 1
self.mypix()
class RoundRectItem(QGraphicsObject):
def __init__(self, bounds, color, parent=None):
super(RoundRectItem, self).__init__(parent)
self.fillRect = False
self.bounds = QRectF(bounds)
self.pix = QPixmap()
self.gradient = QLinearGradient()
self.gradient.setStart(self.bounds.topLeft())
self.gradient.setFinalStop(self.bounds.bottomRight())
self.gradient.setColorAt(0, color)
self.gradient.setColorAt(1, color.darker(200))
self.setCacheMode(QGraphicsItem.ItemCoordinateCache)
def setFill(self, fill):
self.fillRect = fill
self.update()
def fill(self):
return self.fillRect
fill = pyqtProperty(bool, fill, setFill)
def paint(self, painter, option, widget):
painter.setPen(Qt.NoPen)
painter.setBrush(QColor(0, 0, 0, 64))
painter.drawRoundedRect(self.bounds.translated(2, 2), 25.0, 25.0)
if self.fillRect:
painter.setBrush(QApplication.palette().brush(QPalette.Window))
else:
painter.setBrush(self.gradient)
painter.setPen(QPen(Qt.black, 1))
painter.drawRoundedRect(self.bounds, 25.0, 25.0)
if not self.pix.isNull():
painter.scale(1.95, 1.95)
painter.drawPixmap(-self.pix.width() / 2, -self.pix.height() / 2, self.pix)
def boundingRect(self):
return self.bounds.adjusted(0, 0, 2, 2)
def pixmap(self):
return QPixmap(self.pix)
def setPixmap(self, pixmap):
self.pix = QPixmap(pixmap)
self.update()
def loadImage(self, path):
self.markable_picture = QMarkablePicture(self)
hbox = QHBoxLayout(self)
picture = QPixmap(path)
if picture.width() > self.maximumWidth():
picture = picture.scaledToWidth(self.maximumWidth())
if picture.height() > self.maximumHeight():
picture = picture.scaledToHeight(self.maximumHeight())
self.markable_picture.setPixmap(picture)
hbox.addWidget(self.markable_picture)
hbox.setContentsMargins(0, 0, 0, 0)
self.setLayout(hbox)
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
button = QPushButton('PyQt5 button', self)
button.setToolTip('This is an example button')
button.move(0,0)
button.clicked.connect(self.on_click)
# # Create widget
label = QLabel(self)
pixmap = QPixmap(os.path.join(full_mask_path, 'EN20160520L039-26_mask.jpg'))
label.setPixmap(pixmap)
self.resize(pixmap.width(),pixmap.height())
self.show()
class ImageToggleButton(ToggleButton): def __init__(self,imgId,img): super(ImageToggleButton, self).__init__() self.id = imgId self.pixMap = QPixmap(img) eliminateBackgroundColor(self.pixMap) self.backBrush = QBrush(QColor(img.pixel(0,0))) def paintEvent(self,event): super().paintEvent(event) painter = QPainter(self) painter.fillRect(4,4,frameWidth,frameHeight,self.backBrush) painter.drawPixmap(4+(frameWidth-self.pixMap.width())//2,4+(frameHeight-self.pixMap.height())//2,self.pixMap) if self.isChecked(): painter.setPen(self.checkedPen) painter.drawRect(3,3,self.width()-6,self.height()-6)
def createThemePreview(theme, screenRect, size=QSize(200, 120)):
"""
Generates a QPixmap preview for given theme.
Theme can be either a string containing the filename of the ini
file with the theme settings, or it can be a dict with the settings.
If theme is a filename, the result is cached.
"""
# Checking whether theme is a string or dict
if type(theme) == str and os.path.exists(theme):
# Theme is the path to an ini file
themeDatas = loadThemeDatas(theme)
fromFile = True
else:
themeDatas = theme
fromFile = False
# Check if item is in cache
if fromFile and theme in _thumbCache:
if _thumbCache[theme][0] == themeDatas:
return _thumbCache[theme][1]
pixmap = generateTheme(themeDatas, screenRect)
addThemePreviewText(pixmap, themeDatas, screenRect)
px = QPixmap(pixmap).scaled(size, Qt.KeepAspectRatio)
w = px.width() / 10
h = px.height() / 10
r = themeTextRect(themeDatas, screenRect)
painter = QPainter(px)
painter.drawPixmap(QRect(w, h, w * 4, h * 5), pixmap,
QRect(r.topLeft() - QPoint(w / 3, h / 3), QSize(w * 4, h * 5)))
painter.setPen(Qt.white)
painter.drawRect(QRect(w, h, w * 4, h * 5))
painter.end()
# If theme is a themefile, we keep it in cache
if fromFile:
_thumbCache[theme] = [themeDatas, px]
return px
def textureRect(self, rect_tile):
tile_info = rect_tile.data(0)
if tile_info is None:
return False
pm = QPixmap(self.__tiler.tile_to_path(tile_info))
if pm.width() != 256:
#print("Probably didn't get tile:", next_tile_info.x, next_tile_info.y, "\n")
#TODO: Attempt to texture with a lower res tile
#Bear in mind that you will have to take Mercator projection into
#account on the lower res tile.
#First Attempt: didn't work
#if tile_info.zoom <= self.__tiler.get_min_zoom():
# return False
#
#find colocated lower res tile
#(lat,lon) = tile_info.coord()
#tile_info2 = self.__tiler.coord_to_tile(lat,lon, tile_info.zoom-1)
#rect_tile.setData(0, tile_info2)
#print("prev tile: ", tile_info.tile, tile_info.coord())
#return self.textureRect(rect_tile, depth + 1)
#until such time as we can pull lower res tiles and figure out
#which area to render on a rectangle, skip:
return False
topLeft = rect_tile.boundingRect().topLeft()
bottomRight = rect_tile.boundingRect().bottomRight()
width = bottomRight.x() - topLeft.x()
height = bottomRight.y() - topLeft.y()
brush_trans = QTransform()
brush_trans.translate(topLeft.x(), topLeft.y())
brush_trans.scale(width/256.0, height/256.0)
qb = QBrush(pm)
qb.setTransform(brush_trans)
rect_tile.setBrush(qb)
return True
class QImageArea(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
def loadImage(self, path):
self.picture_label = QLabel(self)
hbox = QHBoxLayout(self)
self.picture = QPixmap(path)
self.picture_label.setPixmap(self.picture)
hbox.addWidget(self.picture_label)
hbox.setContentsMargins(0, 0, 0, 0)
self.setLayout(hbox)
def getImageWidth(self):
return self.picture.width()
def getImageHeight(self):
return self.picture.height()
def setColor(self, color):
if type(color)!=QColor:
color = QColor(color)
if (self.mColor == color or not color.isValid()):
return
self.mColor = color
size = QSize(self.iconSize())
size.setWidth(size.width()-2)
size.setHeight(size.height()-2)
pixmap = QPixmap(size)
pixmap.fill(self.mColor)
painter = QPainter(pixmap)
border = QColor(Qt.black)
border.setAlpha(128)
painter.setPen(border)
painter.drawRect(0, 0, pixmap.width() - 1, pixmap.height() - 1)
painter.end()
self.setIcon(QIcon(pixmap))
self.colorChanged.emit(color)
def setSampleImage(self, pathToFile):
self.graphicsView.hide()
#clear scene
self.graphicsScene.clear()
#load file
tmpImage = QImage(pathToFile)
self.originalHeight = tmpImage.height()
self.originalWidth = tmpImage.width()
tmpPixmap = QPixmap(1)
tmpPixmap.convertFromImage(tmpImage.scaledToWidth(300))
self.scaledHeight = tmpPixmap.height()
self.scaledWidth = tmpPixmap.width()
#add to scene and show
self.graphicsScene.addPixmap(tmpPixmap)
self.graphicsView.show()
def set_paragraph(self, h2='', h3='', text='', img=None):
if h2 != '':
lbl_h2 = QLabel(h2, self.inner)
fnt = lbl_h2.font()
fnt.setPointSize(self.H2_FONT_SIZE)
lbl_h2.setFont(fnt)
lbl_h2.setFixedHeight(self.H2_HEIGHT)
lbl_h2.setAlignment(Qt.AlignBottom)
lbl_h2.setMargin(self.SIDE_MARGIN)
self.vbox.addWidget(lbl_h2)
frm = QFrame(self.inner)
frm.setFrameShape(QFrame.HLine)
frm.setContentsMargins(self.SIDE_MARGIN, 0, self.SIDE_MARGIN, 0)
plt = frm.palette()
plt.setColor(QPalette.WindowText, Qt.darkGray)
frm.setPalette(plt)
self.vbox.addWidget(frm)
if text != '':
lbl_txt = QLabel(text, self.inner)
lbl_txt.setWordWrap(True)
fnt = lbl_txt.font()
fnt.setPointSize(self.TEXT_FONT_SIZE)
lbl_txt.setFont(fnt)
lbl_txt.setMargin(self.SIDE_MARGIN)
self.vbox.addWidget(lbl_txt)
if img is not None:
if self.params.lang == 'en':
img += '_en.png'
else:
img += '_jp.png'
pixmap = QPixmap(img)
if not pixmap.isNull():
lbl_img = QLabel(self.inner)
lbl_img.setPixmap(pixmap)
self.lbl_img_list.append(lbl_img)
self.pixmap_list.append(pixmap.scaledToWidth(pixmap.width()))
self.vbox.addWidget(lbl_img)
self.inner.setLayout(self.vbox)
def put_cv2_image(self, image, widget):
height, width = image.shape[0:2]
qImg = self.cv2toQImage(image)
pixmap = QPixmap(qImg)
if height > width:
if height > self.preview_size:
pixmap = pixmap.scaledToHeight(self.preview_size)
else:
if width > self.preview_size:
pixmap = pixmap.scaledToWidth(self.preview_size)
widget.setPixmap(pixmap)
#give hints to DrawableLabel() and MyLabel()
widget.perspective = self.perspective
widget.focus = self.focus
widget.slitpos = self.slitpos
w = pixmap.width()
h = pixmap.height()
x = ( self.preview_size - w ) // 2
y = ( self.preview_size - h ) // 2
widget.geometry = x,y,w,h
def startDrag(self, supportedActions):
item = self.currentItem()
itemData = QByteArray()
dataStream = QDataStream(itemData, QIODevice.WriteOnly)
pixmap = QPixmap(item.data(Qt.UserRole))
location = item.data(Qt.UserRole+1)
dataStream << pixmap << location
mimeData = QMimeData()
mimeData.setData('image/x-puzzle-piece', itemData)
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setHotSpot(QPoint(pixmap.width()/2, pixmap.height()/2))
drag.setPixmap(pixmap)
if drag.exec_(Qt.MoveAction) == Qt.MoveAction:
if self.currentItem() is not None:
self.takeItem(self.row(item))
def __init__(self, imagepath, binpath):
super().__init__()
QToolTip.setFont(QFont('SansSerif', 10))
self.setToolTip('This is a <b>QWidget</b> widget')
self.imageLabel = QLabel(self)
self.imageLabel.setBackgroundRole(QPalette.Base)
self.imageLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.imageLabel.setScaledContents(True)
self.overlay = Overlay(self.imageLabel, binpath)
self.setCentralWidget(self.overlay)
self.overlay.c.cropImage.connect(self.crop)
#self.overlay.setSizePolicy(QSizePolicy.Maximum,QSizePolicy.Maximum)
self.imagepath = imagepath
image = QPixmap(imagepath)
w = image.width()
h = image.height()
rec = QApplication.desktop().screenGeometry();
dsk_h = rec.height();
dsk_w = rec.width();
wdw_w = min(0.7 * dsk_w, w) # Window's width 85% of screen's size
self.ratio = wdw_w / w # Storing the ratio for later use
wdw_h = h * self.ratio # A simple proportion to get the height, because we want to mantain the aspect ratio
image = image.scaled(wdw_w, wdw_h, transformMode=QtCore.Qt.SmoothTransformation)
self.imageLabel.setPixmap(image)
self.imageLabel.adjustSize()
self.setGeometry(dsk_w/2 - wdw_w/2, dsk_h/2 - wdw_h/2, wdw_w, wdw_h)
self.setWindowTitle('Tooltips')
self.show()
def init(self):
self.window = loadUi(os.path.join(get_ui_path(),"splash.ui"))
self.window.setWindowFlags(Qt.FramelessWindowHint|Qt.WindowStaysOnTopHint)
self.center()
self.window.li.setText(notice()+"\n"+version())
self.window.setModal(Qt.WindowModal)
self.window.image.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.window.image.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
window_h=self.window.height()
window_w=self.window.width()
r=random.randint(2, 3)
image=QPixmap(os.path.join(get_image_file_path(),"splash"+str(r)+".png"))
image.scaledToHeight(window_h)
w=image.width()
h=image.height()
x_max=w-window_h-window_w/2
hour=float(time.strftime("%H"))*60
m=float(time.strftime("%m"))
tot=hour+m
my_max=float(24*60)
value=tot/my_max
xpos=int(x_max*value)+window_w/2
print("xpos=",xpos)
scene=QGraphicsScene();
scene.setSceneRect(xpos, 0, 0, h)
self.window.image.setScene(scene)
self.window.show()
scene.addPixmap(image);
QTimer.singleShot(1500, self.callback_destroy)
def initUI(self):
xkcd_array = requests.get("http://dynamic.xkcd.com/api-0/jsonp/comic/").json()
self.setGeometry(300, 300, 1000, 500)
title = xkcd_array['title'].encode("latin-1").decode("utf-8")
self.setWindowTitle('XKCD - '+title)
print(type(title))
alt = xkcd_array['alt'].encode("latin-1").decode("utf-8")
self.setToolTip(alt)
url = xkcd_array['img']
data = urllib.request.urlopen(url).read()
img = QPixmap()
img.loadFromData(data)
self.resize(img.width(), img.height())
lbl2 = QLabel('asd', self)
lbl2.setPixmap(img)
self.show()
class App(QMainWindow):
def __init__(self):
super().__init__()
uic.loadUi('interface_PillowUI.ui', self)
self.create_fileAction.triggered.connect(self.create_file)
self.open_fileAction.triggered.connect(self.open_file)
self.file_name = ''
self.temp_name = ''
self.load_image = Image
self.pixmap = QPixmap()
self.width = 0
self.height = 0
self.pixel = []
# Открытие файла
def open_file(self):
try:
while True:
self.file_name = \
QFileDialog.getOpenFileName(self, 'Открыть файл', '.')[0]
if self.file_name:
try:
self.load_image = Image.open(self.file_name)
self.width, self.height = self.load_image.size
self.pixel = self.load_image.load()
self.temp_image()
self.init_ui()
break
except OSError:
QMessageBox.question(
self, 'Предупреждение', 'Файл должен иметь '
'расширение графического файла, '
'поддерживаемого библиотекой PIL', QMessageBox.Ok,
QMessageBox.Ok)
else:
break
except Exception as e:
print(e)
# Сохранение файла
def save_file(self):
self.load_image.save(self.file_name)
# Сохранение файла как...
def save_file_as(self):
val, ok_btn_pressed = QInputDialog.getText(self, 'Сохранить файл',
'Введите название файла')
if ok_btn_pressed:
try:
self.load_image.save(val)
except Exception as e:
QMessageBox.question(self, 'Ошибка', str(e), QMessageBox.Ok,
QMessageBox.Ok)
# Создание файла
def create_file(self):
val, ok_btn_pressed = QInputDialog.getText(self, 'Создать',
'Введите название файла:')
if ok_btn_pressed:
# noinspection PyBroadException
try:
self.file_name = val
self.load_image = Image.new('RGB', (500, 500))
self.load_image.save(self.file_name)
self.temp_image()
except Exception as e:
QMessageBox.question(
self, 'Предупреждение',
'Упс... Что-то пошло не так, попробуйте снова',
QMessageBox.Ok, QMessageBox.Ok)
print(e)
# Показ изображения в QScrollArea
def show_image(self):
self.pixmap = QPixmap(self.temp_name)
self.lbl.setPixmap(self.pixmap)
self.lbl.resize(self.pixmap.width(), self.pixmap.height())
self.lbl.resize(self.pixmap.width(), self.pixmap.height())
self.scroll_image.setWidget(self.lbl)
# Создание временного изображения, с которым будет вестись работа,
# чтобы не испортить начальное изображение
def temp_image(self):
self.temp_name = 'temp_im.jpg'
self.load_image.save(self.temp_name)
self.pixel = self.load_image.load()
self.width, self.height = self.load_image.size
self.show_image()
# Инициализация UI
def init_ui(self):
# Подключение сигналов для меню "Фильтры"
self.shade_of_gray_action.triggered.connect(self.shade_of_gray)
self.white_and_black_action.triggered.connect(self.white_and_black)
self.sepia_action.triggered.connect(self.sepia)
self.negative_action.triggered.connect(self.negative)
self.noise_action.triggered.connect(self.noise)
self.brightness_action.triggered.connect(self.brightness)
# Подключение сигналов для кнопок
self.merge_image_btn.clicked.connect(self.merge_image)
self.show_image_in_window_btn.clicked.connect(
self.show_image_in_window)
self.set_transparency_btn.clicked.connect(self.set_transparency)
self.image_resize_btn.clicked.connect(self.image_resize)
self.cut_btn.clicked.connect(self.cut)
self.cut_background_btn.clicked.connect(self.cut_background)
self.palette_btn.clicked.connect(self.open_palette)
self.grid_btn.clicked.connect(self.grid)
self.random_color_btn.clicked.connect(self.random_color)
self.rotation_btn.clicked.connect(self.rotation)
self.flip_horizontally_btn.clicked.connect(self.flip_horizontally)
self.flip_vertical_btn.clicked.connect(self.flip_vertical)
self.show_channel_btn.clicked.connect(self.show_channel)
# Подключение кнопок меню "Файл"
self.save_file_asAction.triggered.connect(self.save_file_as)
self.save_fileAction.triggered.connect(self.save_file)
# Показать один из цветовых каналов
def show_channel(self):
# Создает копию текущего изображения для отображения каналов
channel_image_r = self.load_image.copy()
channel_image_g = self.load_image.copy()
channel_image_b = self.load_image.copy()
pixel_r = channel_image_r.load()
pixel_g = channel_image_g.load()
pixel_b = channel_image_b.load()
if self.radioButton_all.isChecked():
self.load_image.show()
# Показывает красный канал
elif self.radioButton_red.isChecked():
for i in range(self.width):
for j in range(self.height):
r, g, b = pixel_r[i, j]
pixel_r[i, j] = r, 0, 0
channel_image_r.show()
# Показывает синий канал
elif self.radioButton_blue.isChecked():
for i in range(self.width):
for j in range(self.height):
r, g, b = pixel_b[i, j]
pixel_b[i, j] = 0, 0, b
channel_image_b.show()
# Показывает зеленый канал
elif self.radioButton_green.isChecked():
for i in range(self.width):
for j in range(self.height):
r, g, b = pixel_g[i, j]
pixel_g[i, j] = 0, g, 0
channel_image_g.show()
# Слияние изображений
def merge_image(self):
load_image2 = ''
while True:
file_name2 = \
QFileDialog.getOpenFileName(self, 'Совместить файл', '.')[0]
if file_name2:
try:
load_image2 = Image.open(file_name2)
break
except OSError:
QMessageBox.question(
self, 'Предупреждение', 'Файл должен иметь '
'расширение графического файла, '
'поддерживаемого библиотекой PIL', QMessageBox.Ok,
QMessageBox.Ok)
else:
break
if load_image2:
# Установление прозрачности для файла,
# с которым производится слияние
val, ok_btn_pressed = QInputDialog.getInt(
self, 'Прозрачность', 'Укажите процент прозрачности:', 5, 0,
10, 1)
if ok_btn_pressed:
val = val / 10
# Проверка размеров изображения, если они отличаются,
# то второе изображения принимает размер первого
width2, height2 = load_image2.size
if self.width != width2 or self.height != height2:
load_image2 = load_image2.resize((self.width, self.height))
pixels2 = load_image2.load()
# Слияние пикселей изображений с учетом прозрачности
for i in range(self.width):
for j in range(self.height):
r1, g1, b1 = self.pixel[i, j]
r2, g2, b2 = pixels2[i, j]
r1 = r1 * (1 - val) + r2 * val
g1 = g1 * (1 - val) + g2 * val
b1 = b1 * (1 - val) + b2 * val
self.pixel[i, j] = int(r1), int(g1), int(b1)
self.temp_image()
# Показ изображения в отдельном окне
def show_image_in_window(self):
self.load_image.show()
# Изменение прозрачности
def set_transparency(self):
val, ok_btn_pressed = QInputDialog.getInt(
self, 'Прозрачность', 'Укажите процент прозрачности:', 5, 0, 10, 1)
if ok_btn_pressed:
val = val / 10
# Установление прзрачности для пикселей
for i in range(self.width):
for j in range(self.height):
r1, g1, b1 = self.pixel[i, j]
r1 = r1 * val
g1 = g1 * val
b1 = b1 * val
self.pixel[i, j] = int(r1), int(g1), int(b1)
self.temp_image()
# Изменение размера
def image_resize(self):
# Создание диалогового окна и проверка корректности значений
while True:
val, ok_btn_pressed = QInputDialog.getText(
self, 'Изменение размера изображения', 'Введите новый размер '
'изображения. размер '
'должен быть указан в '
'формате: "ширина";"высота"')
if ok_btn_pressed:
if ';' not in val:
QMessageBox.question(
self, 'Предупреждение', 'Ширина и высота, указанные в '
'диалоговом окне, должны быть '
'разделены этим символом: ";"', QMessageBox.Ok,
QMessageBox.Ok)
elif len(val.split(';')) > 2:
QMessageBox.question(
self, 'Предупреждение',
'Должно быть введено ТОЛЬКО два '
'аргумента. Разве это так сложно?', QMessageBox.Ok,
QMessageBox.Ok)
else:
try:
val = [int(item) for item in val.split(';')]
# Изменение размера
self.load_image = self.load_image.resize(val)
self.temp_image()
break
except ValueError:
QMessageBox.question(
self, 'Предупреждение',
'Введеные значения не соответствуют типу int',
QMessageBox.Ok, QMessageBox.Ok)
else:
break
# Обрезать изображение
def cut(self):
fl = False
# Получение значения для левого верхнего угла
while True:
val, ok_btn_pressed = QInputDialog.getText(
self, 'Обрезать', 'Введите координаты левого верхнего угла'
' в формате: x;y')
if ok_btn_pressed:
if ';' not in val:
QMessageBox.question(
self, 'Предупреждение', 'x и y, указанные в '
'диалоговом окне, должны быть '
'разделены этим символом: ";"', QMessageBox.Ok,
QMessageBox.Ok)
elif len(val.split(';')) > 2:
QMessageBox.question(
self, 'Предупреждение',
'Должно быть введено ТОЛЬКО два '
'аргумента. Разве это так сложно?', QMessageBox.Ok,
QMessageBox.Ok)
else:
try:
val = [int(item) for item in val.split(';')]
x_min, y_min = val
fl = True
break
except Exception as e:
QMessageBox.question(self, 'Предупреждение', str(e),
QMessageBox.Ok, QMessageBox.Ok)
else:
break
# Получение значения для правого нижнего и последующая обрезка
# изображения
if fl:
while True:
val, ok_btn_pressed = QInputDialog.getText(
self, 'Обрезать',
'Введите координаты правого нижнего угла '
'в формате: x;y')
if ok_btn_pressed:
if ';' not in val:
QMessageBox.question(
self, 'Предупреждение', 'x и y, указанные в '
'диалоговом окне, должны быть '
'разделены этим символом: ";"', QMessageBox.Ok,
QMessageBox.Ok)
elif len(val.split(';')) > 2:
QMessageBox.question(
self, 'Предупреждение', 'Должно быть введено'
''
'ТОЛЬКО два аргумента. '
'Разве это так сложно?', QMessageBox.Ok,
QMessageBox.Ok)
else:
try:
val = [int(item) for item in val.split(';')]
x_max, y_max = val
self.load_image = self.load_image.crop(
(x_min, y_min, x_max, y_max))
self.temp_image()
break
except Exception as e:
QMessageBox.question(self, 'Предупреждение',
str(e), QMessageBox.Ok,
QMessageBox.Ok)
else:
break
# Обрезать однотонное изображение
def cut_background(self):
QMessageBox.question(
self, 'Предупреждение',
'Данная функция корректно работает только, '
'если изображение окружено однотонным фоном со '
'всех сторон хотя бы на один пиксель.', QMessageBox.Ok,
QMessageBox.Ok)
# Поиска верхнего левого угла для нового изображения
fl = False
for i in range(self.width):
for j in range(self.height):
if self.pixel[i, j] != self.pixel[0, 0]:
x_min = i
fl = True
break
if fl:
break
fl = False
for i in range(self.height):
for j in range(self.width):
if self.pixel[i, j] != self.pixel[0, 0]:
y_min = i
fl = True
break
if fl:
break
# Поиска нижнего правого угла
fl = False
for i in range(self.width - 1, -1, -1):
for j in range(self.height - 1, -1, -1):
if self.pixel[i, j] != self.pixel[0, 0]:
x_max = i
fl = True
break
if fl:
break
fl = False
for i in range(self.height - 1, -1, -1):
for j in range(self.width - 1, -1, -1):
if self.pixel[j, i] != self.pixel[0, 0]:
y_max = i
fl = True
break
if fl:
break
self.load_image.crop((x_min, y_min, x_max, y_max))
self.temp_image()
# Открыть палитру
def open_palette(self):
color = QColorDialog.getColor()
if color.isValid():
color = color.name()
QMessageBox.question(self, 'Выбранный цвет', color, QMessageBox.Ok,
QMessageBox.Ok)
reply = QMessageBox.question(self, 'Сохранить?', 'Сохранить?',
QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if reply == QMessageBox.Yes:
# Запись значения цвета в файл
while True:
val, ok_btn_pressed = QInputDialog.getText(
self, 'Сохранить!', 'Введите название файла')
if ok_btn_pressed:
try:
f = open(val, 'w')
f.write(color)
f.close()
break
except Exception as e:
QMessageBox.question(self, 'Ошибка', str(e),
QMessageBox.Ok,
QMessageBox.Ok)
else:
break
# Добавить сетку
def grid(self):
# Создаем объект ImageDraw и передаем ему изображение
draw = ImageDraw.Draw(self.load_image)
# Рисуем вертикальные лини каждые 50 пикселей
for i in range(0, self.width, 50):
draw.line((i, 0, i + self.height, 0))
# Рисуем горизонталные линии каждые 50 пикселей
for j in range(0, self.height, 50):
draw.line((0, i, 0, i + self.width))
del draw
self.temp_image()
# Заполнить случайными цветами
def random_color(self):
for i in range(self.width):
for j in range(self.height):
r = randint(0, 255)
g = randint(0, 255)
b = randint(0, 255)
self.pixel[i, j] = r, g, b
self.temp_image()
# Поворот изображения
def rotation(self):
# Получение аргументов для поворота
val, ok_btn_pressed = QInputDialog.getInt(self, 'Поворот',
'Укажите градус поворота:',
45, 90, 270, 45)
if ok_btn_pressed:
direction, ok_btn_pressed = QInputDialog.getItem(
self, 'Поворот', 'Выберите направление поворота:',
('Влево', 'Вправо'), 0, False)
if ok_btn_pressed:
# Поворот
if direction == 'Влево':
self.load_image = self.load_image.rotate(val)
else:
self.load_image = self.load_image.rotate(360 - val)
self.temp_image()
# Отражение по горизонтали
def flip_horizontally(self):
self.load_image = self.load_image.transpose(Image.FLIP_TOP_BOTTOM)
self.temp_image()
# Отражение по вертикали
def flip_vertical(self):
self.load_image = self.load_image.transpose(Image.FLIP_LEFT_RIGHT)
self.temp_image()
# Фильтры
# Оттенок серого
def shade_of_gray(self):
for i in range(self.width):
for j in range(self.height):
r, g, b = self.pixel[i, j]
new_color = (r * 30 + g * 59 + b * 11) // 100
self.pixel[i, j] = (new_color, new_color, new_color)
self.temp_image()
# Черно-белое изображение
def white_and_black(self):
for i in range(self.width):
for j in range(self.height):
r, g, b = self.pixel[i, j]
new_color = r + g + b
if new_color > 531:
new_color = 255
else:
new_color = 0
self.pixel[i, j] = (new_color, new_color, new_color)
self.temp_image()
# Сепия
def sepia(self):
depth, ok_btn_pressed = QInputDialog.getInt(self, 'Сепия',
'Укажите глубину:', 5, 0,
10, 1)
if ok_btn_pressed:
depth *= 10
for i in range(self.width):
for j in range(self.height):
r, g, b = self.pixel[i, j]
new_color = (r + g + b) // 3
r = new_color + depth * 2
g = new_color + depth
b = new_color
self.pixel[i, j] = r, g, b
self.temp_image()
# Негатив
def negative(self):
for i in range(self.width):
for j in range(self.height):
r, g, b = self.pixel[i, j]
self.pixel[i, j] = (255 - r), (255 - g), (255 - b)
self.temp_image()
# Шумы изображения
def noise(self):
factor, ok_btn_pressed = QInputDialog.getInt(self, 'Шум',
'Укажите уровень шума:',
5, 0, 10, 1)
if ok_btn_pressed:
factor *= 10
for i in range(self.width):
for j in range(self.height):
r, g, b = self.pixel[i, j]
rand = randint(-factor, factor)
r += rand
g += rand
b += rand
if r < 0:
r = 0
if g < 0:
g = 0
if b < 0:
b = 0
if r > 255:
r = 255
if g > 255:
g = 255
if b > 255:
b = 255
self.pixel[i, j] = r, g, b
self.temp_image()
# Яркость
def brightness(self):
factor, ok_btn_pressed = QInputDialog.getInt(
self, 'Яркость', 'Укажите уровень яркости:', 5, -10, 10, 1)
if ok_btn_pressed:
factor *= 10
for i in range(self.width):
for j in range(self.height):
r, g, b = self.pixel[i, j]
r += factor
g += factor
b += factor
if r < 0:
r = 0
if g < 0:
g = 0
if b < 0:
b = 0
if r > 255:
r = 255
if g > 255:
g = 255
if b > 255:
b = 255
self.pixel[i, j] = r, g, b
self.temp_image()
def closeEvent(self, a0: QCloseEvent):
if self.temp_name:
os.remove(self.temp_name)
self.close()
app.setStyle('Fusion')
# app.setWindowIcon(QIcon(os.path.join(bundle_dir, 'logo.png')))
splash_pix = QPixmap(os.path.join(bundle_dir, 'loadingLogo.png'))
splash = QSplashScreen(splash_pix, Qt.WindowStaysOnTopHint)
# splash = MySplashScreen('chicken.gif', Qt.WindowStaysOnTopHint)
splash.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.FramelessWindowHint
| Qt.Tool)
splash.setEnabled(False)
# splash = QSplashScreen(splash_pix)
# adding progress bar
progressBar = QProgressBar(splash)
# progressBar.setMaximum(10)
progressBar.setGeometry(100,
splash_pix.height() - 50,
splash_pix.width() - 200, 20)
# progressBar.setGeometry(150, 320, 200, 18)
# splash.setMask(splash_pix.mask())
splash.show()
splash.showMessage("Expanding app", Qt.AlignBottom | Qt.AlignCenter,
Qt.black)
app.processEvents()
# initLoop = Qt.QEventLoop()
# pool = Pool(processes=1)
# pool.apply_async(longInitialization, [2], callback=lambda exitCode: initLoop.exit(exitCode))
# initLoop.exec_()
# app.processEvents()
# progressBar.setValue(1)
class Node:
width = 120
def __init__(self, icon: str):
super(Node, self)
self.windowRect = QRectF(0, 0, Node.width, 20)
self.item = None
self.inputs = []
self.icon = QPixmap(icon)
def setPos(self, pos: QPointF):
self.item.setPos(pos)
def GetTitle(self):
return ""
def Inputs(self):
return []
def Outputs(self):
return []
def GetInputPoint(self, ids: int):
ic = len(self.Inputs())
oc = len(self.Outputs())
m = max(ic, oc) * 10
io = 25 + m - ic * 10 + ids * 20
return self.item.pos() + QPointF(-5, io + 5)
def GetOutputPoint(self, ids: int):
ic = len(self.Inputs())
oc = len(self.Outputs())
m = max(ic, oc) * 10
io = 25 + m - oc * 10 + ids * 20
return self.item.pos() + QPointF(self.windowRect.width() + 5, io + 5)
def GetInputId(self, pos: QPointF):
pos = pos - self.item.pos()
ic = len(self.Inputs())
oc = len(self.Outputs())
m = max(ic, oc) * 10
io = 20 + m - ic * 10
ids = int((pos.y() - io) / 20.0)
if (ids < 0 or ids >= ic or pos.x() > self.windowRect.width() / 2):
return -1
return ids
def GetOutputId(self, pos: QPointF):
pos = pos - self.item.pos()
ic = len(self.Inputs())
oc = len(self.Outputs())
m = max(ic, oc) * 10
io = 20 + m - oc * 10
ids = int((pos.y() - io) / 20.0)
if (ids < 0 or ids >= oc or pos.x() < self.windowRect.width() / 2):
return -1
return ids
def ItemsInit(self, scene: QGraphicsScene):
ic = len(self.Inputs())
oc = len(self.Outputs())
m = max(ic, oc) * 10
self.windowRect.setHeight(m * 2 + 20)
ins = self.Inputs()
ino = 20 + m - ic * 10
ouo = 20 + m - oc * 10
pix = scene.addPixmap(self.icon)
pix.setPos(
(self.windowRect.width() - self.icon.width()) * 0.5,
20 + (self.windowRect.height() - 20 - self.icon.height()) * 0.5)
pix.setParentItem(self.item)
for i in range(0, ic):
ti = scene.addText(ins[i])
ti.setPos(0, i * 20 + ino)
ti.setParentItem(self.item)
ie = scene.addEllipse(
QRectF(QPointF(-5, i * 20 + 5 + ino), QSizeF(10, 10)))
ie.setParentItem(self.item)
ie.setFlag(QGraphicsItem.ItemNegativeZStacksBehindParent)
ie.setZValue(-1)
ins = self.Outputs()
for i in range(0, oc):
ti = scene.addText(ins[i])
ti.setPos(
QPointF(self.windowRect.width() - ti.boundingRect().width(),
i * 20 + ouo))
ti.setParentItem(self.item)
ie = scene.addEllipse(
QRectF(QPointF(self.windowRect.width() - 5, i * 20 + 5 + ouo),
QSizeF(10, 10)))
ie.setParentItem(self.item)
ie.setFlag(QGraphicsItem.ItemNegativeZStacksBehindParent)
ie.setZValue(-1)
self.inputs = []
for i in range(0, ic):
self.inputs.append(NodeConnector())
class MainWindow(QMainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.puzzleImage = QPixmap()
self.setupMenus()
self.setupWidgets()
self.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
self.setWindowTitle("Puzzle")
def openImage(self, path=None):
if not path:
path, _ = QFileDialog.getOpenFileName(
self, "Open Image", "", "Image Files (*.png *.jpg *.bmp)")
if path:
newImage = QPixmap()
if not newImage.load(path):
QMessageBox.warning(
self,
"Open Image",
"The image file could not be loaded.",
QMessageBox.Cancel,
)
return
self.puzzleImage = newImage
self.setupPuzzle()
def setCompleted(self):
QMessageBox.information(
self,
"Puzzle Completed",
"Congratulations! You have completed the puzzle!\nClick OK "
"to start again.",
QMessageBox.Ok,
)
self.setupPuzzle()
def setupPuzzle(self):
size = min(self.puzzleImage.width(), self.puzzleImage.height())
self.puzzleImage = self.puzzleImage.copy(
(self.puzzleImage.width() - size) / 2,
(self.puzzleImage.height() - size) / 2,
size,
size,
).scaled(400, 400, Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
random.seed(QCursor.pos().x() ^ QCursor.pos().y())
self.model.addPieces(self.puzzleImage)
self.puzzleWidget.clear()
def setupMenus(self):
fileMenu = self.menuBar().addMenu("&File")
openAction = fileMenu.addAction("&Open...")
openAction.setShortcut("Ctrl+O")
exitAction = fileMenu.addAction("E&xit")
exitAction.setShortcut("Ctrl+Q")
gameMenu = self.menuBar().addMenu("&Game")
restartAction = gameMenu.addAction("&Restart")
openAction.triggered.connect(self.openImage)
exitAction.triggered.connect(QApplication.instance().quit)
restartAction.triggered.connect(self.setupPuzzle)
def setupWidgets(self):
frame = QFrame()
frameLayout = QHBoxLayout(frame)
self.piecesList = QListView()
self.piecesList.setDragEnabled(True)
self.piecesList.setViewMode(QListView.IconMode)
self.piecesList.setIconSize(QSize(60, 60))
self.piecesList.setGridSize(QSize(80, 80))
self.piecesList.setSpacing(10)
self.piecesList.setMovement(QListView.Snap)
self.piecesList.setAcceptDrops(True)
self.piecesList.setDropIndicatorShown(True)
self.model = PiecesModel(self)
self.piecesList.setModel(self.model)
self.puzzleWidget = PuzzleWidget()
self.puzzleWidget.puzzleCompleted.connect(self.setCompleted,
Qt.QueuedConnection)
frameLayout.addWidget(self.piecesList)
frameLayout.addWidget(self.puzzleWidget)
self.setCentralWidget(frame)
def create_image(self):
self.lbl_scheme_image = QLabel(self)
pixmap = QPixmap('scheme.png')
self.lbl_scheme_image.setPixmap(pixmap)
self.lbl_scheme_image.move(225, 0)
self.lbl_scheme_image.resize(pixmap.width(), pixmap.height())
class Notification(QMainWindow):
'''Transparent window containing an image or animated gif, used to display notifications.'''
def __init__(self,
name,
notifier,
artPath,
link,
sound=None,
*args,
**kwargs):
'''- name : a string
- notifier : a Notifier object used to manage this notification
- artPath : a string containing the path to the image file to be displayed
- link : a string containing the link to be opened when left-clicking the notification
- sound : a string containing the path to the object or None. Set to None for silent notifiations.'''
super().__init__(*args, **kwargs)
self.setCursor(QCursor(Qt.PointingHandCursor))
self.name = name
self.notifier = notifier
self.link = link
self.artPath = artPath
self.isMovie = self.artPath.endswith(".gif")
if sound == None:
self.sound = None
else:
self.sound = QSoundEffect()
self.sound.setSource(QUrl.fromLocalFile(sound))
self.setWindowFlags(Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint
| Qt.Tool)
self.setAttribute(Qt.WA_TranslucentBackground)
imageLabel = QLabel()
self.setCentralWidget(imageLabel)
if self.isMovie:
self.art = QMovie(self.artPath)
self.art.jumpToNextFrame()
imageLabel.setMovie(self.art)
self.moveToBottomRight(self.art.frameRect().width(),
self.art.frameRect().height())
else:
self.art = QPixmap(self.artPath)
imageLabel.setPixmap(self.art)
self.moveToBottomRight(self.art.width(), self.art.height())
def moveToBottomRight(self, x, y):
'''Moves the notification window to the bottom-right of the screen, above the taskbar'''
screen = QDesktopWidget().availableGeometry()
x_pos = screen.width() - x
y_pos = screen.height() - y
self.move(x_pos, y_pos)
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.close()
webbrowser.open_new_tab(self.link)
elif event.button() == Qt.RightButton:
self.close()
def display(self, volume=1):
'''Show the notification window and plays the sound.'''
super().show()
if self.isMovie:
self.art.start()
if self.sound:
self.sound.setVolume(volume)
self.sound.play()
def close(self):
'''Updates notifier and closes window'''
super().close()
self.notifier.update()
class PixmapButton(QPushButton):
def __init__(self, parent):
QPushButton.__init__(self, parent)
self.fPixmapNormal = QPixmap()
self.fPixmapDown = QPixmap()
self.fPixmapHover = QPixmap()
self.fPixmapRect = QRectF(0, 0, 0, 0)
self.fIsHovered = False
self.fTopText = ""
self.fTopTextColor = QColor()
self.fTopTextFont = QFont()
self.setText("")
def setPixmaps(self, normal, down, hover):
self.fPixmapNormal.load(normal)
self.fPixmapDown.load(down)
self.fPixmapHover.load(hover)
width = self.fPixmapNormal.width()
height = self.fPixmapNormal.height()
self.fPixmapRect = QRectF(0, 0, width, height)
self.setMinimumSize(width, height)
self.setMaximumSize(width, height)
def setTopText(self, text, color, font):
self.fTopText = text
self.fTopTextColor = color
self.fTopTextFont = font
def enterEvent(self, event):
self.fIsHovered = True
QPushButton.enterEvent(self, event)
def leaveEvent(self, event):
self.fIsHovered = False
QPushButton.leaveEvent(self, event)
def paintEvent(self, event):
painter = QPainter(self)
event.accept()
if not self.isEnabled():
painter.save()
painter.setOpacity(0.2)
painter.drawPixmap(self.fPixmapRect, self.fPixmapNormal,
self.fPixmapRect)
painter.restore()
elif self.isChecked() or self.isDown():
painter.drawPixmap(self.fPixmapRect, self.fPixmapDown,
self.fPixmapRect)
elif self.fIsHovered:
painter.drawPixmap(self.fPixmapRect, self.fPixmapHover,
self.fPixmapRect)
else:
painter.drawPixmap(self.fPixmapRect, self.fPixmapNormal,
self.fPixmapRect)
if not self.fTopText:
return
painter.save()
painter.setPen(self.fTopTextColor)
painter.setBrush(self.fTopTextColor)
painter.setFont(self.fTopTextFont)
painter.drawText(QPointF(10, 16), self.fTopText)
painter.restore()
class MyFirstScene(QWidget):
mainWindow = None
def __init__(self):
QWidget.__init__(self)
MyFirstScene.mainWindow = self
self.scene = scene(self)
self.setGeometry(100, 100, 400, 400)
self.background = QPixmap("./chessboard.png")
self.bg_height = self.background.height()
self.bg_width = self.background.width()
self.field = self.bg_width / 8
#self.background=QPixmap("./chessboard.png")
#self.scene.drawBackground(painter.drawPixmap)
#self.scene.addText("Hello, world!")
figure = Figure(1, 1, 1)
Blackpavn = [Pawns(6, i, 2) for i in range(8)]
Whitepavn = [WhitePawn(1, i, 1) for i in range(8)]
Blackrooks = [Rooks(7, 0, 2), Rooks(7, 7, 2)]
Whiterooks = [Rooks(0, 0, 1), Rooks(0, 7, 1)]
Blackkhnights = [Khnights(7, 1, 2), Khnights(7, 6, 2)]
Whitekhnights = [Khnights(0, 1, 1), Khnights(0, 6, 1)]
Blackbishops = [Bishops(7, 2, 2), Bishops(7, 5, 2)]
Whitebishops = [Bishops(0, 2, 1), Bishops(0, 5, 1)]
BlackKing = King(7, 4, 2)
WhiteKing = King(0, 4, 1)
BlackQuean = Quen(7, 3, 2)
WhiteQuean = Quen(0, 3, 1)
Piece.addGlobalScene(self.scene)
Piece.addGlobalSize(self.field)
self.scene.addItem(
Background(self.background, 0, 0, self.bg_width, self.bg_height,
False))
self.scene.addItem(
Piece(
QPixmap("./whiterook.png").scaled(self.field, self.field), 0,
0, self.field, self.field, Whiterooks[0]))
self.scene.addItem(
Piece(QPixmap("./whiterook.png").scaled(self.field, self.field),
self.field * 7,
0,
self.field,
self.field,
Whiterooks[1],
site='r'))
self.scene.addItem(
Piece(
QPixmap("./whiteknight.png").scaled(self.field, self.field),
self.field, 0, self.field, self.field, Whitekhnights[0]))
self.scene.addItem(
Piece(
QPixmap("./whiteknight.png").scaled(self.field, self.field),
self.field * 6, 0, self.field, self.field, Whitekhnights[1]))
self.scene.addItem(
Piece(
QPixmap("./whitebishop.png").scaled(self.field, self.field),
self.field * 2, 0, self.field, self.field, Whitebishops[0]))
self.scene.addItem(
Piece(
QPixmap("./whitebishop.png").scaled(self.field, self.field),
self.field * 5, 0, self.field, self.field, Whitebishops[1]))
self.scene.addItem(
Piece(
QPixmap("./whitequean.png").scaled(self.field, self.field),
self.field * 3, 0, self.field, self.field, WhiteQuean))
self.scene.addItem(
Piece(
QPixmap("./Chessking.png").scaled(self.field, self.field),
self.field * 4, 0, self.field, self.field, WhiteKing))
[
self.scene.addItem(
Piece(
QPixmap("./whitepawn.png").scaled(self.field, self.field),
self.field * i, self.field, self.field, self.field, pawn))
for i, pawn in enumerate(Whitepavn)
]
self.scene.addItem(
Piece(
QPixmap("./blackrook.png").scaled(self.field, self.field), 0,
self.field * 7, self.field, self.field, Blackrooks[0]))
self.scene.addItem(
Piece(QPixmap("./blackrook.png").scaled(self.field, self.field),
self.field * 7,
self.field * 7,
self.field,
self.field,
Blackrooks[1],
site='r'))
self.scene.addItem(
Piece(
QPixmap("./blackknight.png").scaled(self.field,
self.field), self.field,
self.field * 7, self.field, self.field, Blackkhnights[0]))
self.scene.addItem(
Piece(
QPixmap("./blackknight.png").scaled(self.field, self.field),
self.field * 6, self.field * 7, self.field, self.field,
Blackkhnights[1]))
self.scene.addItem(
Piece(
QPixmap("./blackbishop.png").scaled(self.field, self.field),
self.field * 2, self.field * 7, self.field, self.field,
Blackbishops[0]))
self.scene.addItem(
Piece(
QPixmap("./blackbishop.png").scaled(self.field, self.field),
self.field * 5, self.field * 7, self.field, self.field,
Blackbishops[1]))
self.scene.addItem(
Piece(
QPixmap("./blackquean.png").scaled(self.field,
self.field), self.field * 3,
self.field * 7, self.field, self.field, BlackQuean))
self.scene.addItem(
Piece(
QPixmap("./blackking.png").scaled(self.field,
self.field), self.field * 4,
self.field * 7, self.field, self.field, BlackKing))
[
self.scene.addItem(
Piece(
QPixmap("./blackpawn.png").scaled(self.field, self.field),
self.field * i, self.field * 6, self.field, self.field,
pawn)) for i, pawn in enumerate(Blackpavn)
]
#self.scene.addItem(Piece(QPixmap("./Chessking.png").scaled(self.bg_width / 8, self.bg_height / 8), 0, 0))
#height=QPixmap("./Chessking.png").height()
#item=self.selectedItems()
#print(QGraphicsScene.selectedItems(self.scene))
self.view = QGraphicsView(self.scene, self)
#self.view.setBackgroundBrush(self.background)
# selected=selectedThread(self.scene)
# selected.start()
#self.scene.selectedItems()
self.view.scene().update()
self.show()
# try:
# client = Client()
# client.start()
# except Exception as e:
# print(e)
@staticmethod
def showMessage(string):
QMessageBox.question(MyFirstScene.mainWindow, string, None)
class PixWindow(QWidget, UI_FORM.Ui_Form): # 不规则窗体
def __init__(self):
super().__init__()
self.setupUi(self)
self.initAppearance()
self.setMusic()
def initAppearance(self):
# 设置窗口的样式
self.pix = QPixmap('beijing.png') # 蒙版
windowWidth = 700
windowHeight = 700
self.resize(windowWidth, windowHeight)
self.pix = self.pix.scaled(int(windowWidth), int(windowHeight))
self.setMask(self.pix.mask())
# 设置无边框
self.setWindowFlags(Qt.FramelessWindowHint)
self.center()
# 设置按钮的样式
self.pushButton.setStyleSheet(
'QPushButton{border-image:url(button.png)}')
tempPixmap = QPixmap("button.png").scaled(self.pushButton.size())
self.pushButton.setMask(tempPixmap.mask())
def paintEvent(self, event): # 绘制窗口
paint = QPainter(self)
paint.drawPixmap(0, 0, self.pix.width(), self.pix.height(), self.pix)
def keyPressEvent(self, e):
if e.key() == Qt.Key_Escape:
self.close()
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.m_flag = True
self.m_Position = event.globalPos() - self.pos() # 获取鼠标相对窗口的位置
event.accept()
self.setCursor(QCursor(Qt.OpenHandCursor)) # 更改鼠标图标
def mouseMoveEvent(self, QMouseEvent):
if Qt.LeftButton and self.m_flag:
self.move(QMouseEvent.globalPos() - self.m_Position) # 更改窗口位置
QMouseEvent.accept()
def mouseReleaseEvent(self, QMouseEvent):
self.m_flag = False
self.setCursor(QCursor(Qt.ArrowCursor))
def contextMenuEvent(self, event):
cmenu = QMenu(self)
quitAct = cmenu.addAction("Quit")
action = cmenu.exec_(self.mapToGlobal(event.pos()))
if action == quitAct:
qApp.quit()
def setMusic(self):
pygame.mixer.init()
pygame.mixer.music.load(r"music.mp3")
pygame.mixer.music.play(loops=-1)
def center(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def showLove(self):
dialog1.pushButton_2.move(370, 240)
dialog1.show()
class NextWindow(QWidget, Next_UI.Ui_Form):
def __init__(self):
super().__init__()
self.setupUi(self)
self.initAppearance()
def initAppearance(self):
# 设置窗口的样式
self.pix = QPixmap('next.jpg')
windowWidth = 432
windowHeight = 768
self.resize(windowWidth, windowHeight)
self.pix = self.pix.scaled(int(windowWidth), int(windowHeight))
# 设置无边框
self.setWindowFlags(Qt.FramelessWindowHint)
self.center()
# 设置按钮的样式
self.pushButton.setStyleSheet(
'QPushButton{border-image:url(beijing.png)}')
tempPixmap = QPixmap("beijing.png").scaled(self.pushButton.size())
self.pushButton.setMask(tempPixmap.mask())
def paintEvent(self, event): # 绘制窗口
paint = QPainter(self)
paint.drawPixmap(0, 0, self.pix.width(), self.pix.height(), self.pix)
def keyPressEvent(self, e):
if e.key() == Qt.Key_Escape:
self.close()
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.m_flag = True
self.m_Position = event.globalPos() - self.pos() # 获取鼠标相对窗口的位置
event.accept()
self.setCursor(QCursor(Qt.OpenHandCursor)) # 更改鼠标图标
def mouseMoveEvent(self, QMouseEvent):
if Qt.LeftButton and self.m_flag:
self.move(QMouseEvent.globalPos() - self.m_Position) # 更改窗口位置
QMouseEvent.accept()
def mouseReleaseEvent(self, QMouseEvent):
self.m_flag = False
self.setCursor(QCursor(Qt.ArrowCursor))
def contextMenuEvent(self, event):
cmenu = QMenu(self)
quitAct = cmenu.addAction("Quit")
action = cmenu.exec_(self.mapToGlobal(event.pos()))
if action == quitAct:
qApp.quit()
def center(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def onClicked(self):
self.close()
pictureWin.show()
class MainWindow(QtWidgets.QMainWindow):
def __init__(self, *args, obj=None, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
self.worker = None
self.stop_ruleVar = 0
self.centralwidget = QtWidgets.QWidget(self)
self.label = QtWidgets.QLabel()
self.lineEdit = QtWidgets.QLineEdit(
"https://www.njuskalo.hr/prodaja-stanova/zagreb")
self.siteURL = self.lineEdit.text()
print(self.siteURL)
self.go = QtWidgets.QPushButton()
self.go.clicked.connect(self.gourl)
self.lineEdit.returnPressed.connect(self.gourl)
self.tabWidget = QtWidgets.QTabWidget()
self.gridLayout = QtWidgets.QGridLayout(self.centralwidget)
self.gridLayout.addWidget(self.label, 0, 0, 1, 1)
self.gridLayout.addWidget(self.lineEdit, 0, 1, 1, 1)
self.gridLayout.addWidget(self.go, 0, 2, 1, 1)
self.gridLayout.addWidget(self.tabWidget, 1, 0, 1, 3)
# Tabs
self.tabWidget.setEnabled(True)
#Web tab
self.webview = Browser()
self.tabWidget.addTab(self.webview, "")
#Datatab
self.centralwidgetDT = QtWidgets.QWidget(self)
self.lineEditDT = QtWidgets.QLineEdit(self.centralwidgetDT)
self.pdtable = QtWidgets.QTableView(self.centralwidgetDT)
self.comboBoxDT = QtWidgets.QComboBox(self.centralwidgetDT)
self.labelDT = QtWidgets.QLabel(self.centralwidgetDT)
self.gridLayoutDT = QtWidgets.QGridLayout(self.centralwidgetDT)
self.gridLayoutDT.addWidget(self.labelDT, 0, 0, 1, 1)
self.gridLayoutDT.addWidget(self.lineEditDT, 0, 1, 1, 1)
self.gridLayoutDT.addWidget(self.comboBoxDT, 0, 2, 1, 1)
self.gridLayoutDT.addWidget(self.pdtable, 1, 0, 1, 3)
self.tabWidget.addTab(self.centralwidgetDT, "")
self.pdtable.horizontalHeader().setCascadingSectionResizes(True)
self.pdtable.horizontalHeader().setStretchLastSection(True)
# Pandas model
self.model = getPandas.PandasTableModel(pd.DataFrame())
self.go.clicked.connect(self.getPageInfo)
self.lineEdit.returnPressed.connect(self.getPageInfo)
#Proxy model for filter
self.proxy = QtCore.QSortFilterProxyModel(self)
self.lineEditDT.textChanged.connect(self.on_lineEdit_textChanged)
self.comboBoxDT.currentIndexChanged.connect(
self.on_comboBox_currentIndexChanged)
self.horizontalHeader = self.pdtable.horizontalHeader()
self.horizontalHeader.sectionClicked.connect(
self.on_view_horizontalHeader_sectionClicked)
######## NOTIFICATION TAB
self.notifwidget = QtWidgets.QWidget(self)
self.gridLayout_2 = QtWidgets.QGridLayout(self.notifwidget)
self.gridLayout_2.columnStretch(0)
### TEXT LINES
# 0 line - First Label
self.label0NT = QtWidgets.QLabel(self.notifwidget)
self.gridLayout_2.addWidget(self.label0NT, 0, 0, 1, 2)
self.label0NT.setText(
"Obavijesti me kada se pojavi oglas koji zadovoljava uvijete:")
self.label0NT.setFixedHeight(20)
# 1,0 - combobox
self.comboBoxNT = QtWidgets.QComboBox(self.notifwidget)
self.comboBoxNT.setObjectName("comboBoxNT")
self.gridLayout_2.addWidget(self.comboBoxNT, 1, 0, 1, 2)
# 1,2 - label
self.label1NT = QtWidgets.QLabel(self.notifwidget)
self.gridLayout_2.addWidget(self.label1NT, 1, 2, 1, 1)
# 1,3 - lineEdit
self.lineEditNT = QtWidgets.QLineEdit(self.notifwidget)
self.lineEditNT.setAlignment(QtCore.Qt.AlignLeft)
self.gridLayout_2.addWidget(self.lineEditNT, 1, 3, 1, 2)
# 2,0 - combobox
self.comboBoxNT_2 = QtWidgets.QComboBox(self.notifwidget)
self.comboBoxNT_2.setObjectName("comboBoxNT_2")
self.gridLayout_2.addWidget(self.comboBoxNT_2, 2, 0, 1, 2)
#2,2 - label
self.label1NT_2 = QtWidgets.QLabel(self.notifwidget)
self.gridLayout_2.addWidget(self.label1NT_2, 2, 2, 1, 1)
# 2,3 - lineEdit
self.lineEditNT_2 = QtWidgets.QLineEdit(self.notifwidget)
self.gridLayout_2.addWidget(self.lineEditNT_2, 2, 3, 1, 2)
# 3,0 - combobox
self.comboBoxNT_3 = QtWidgets.QComboBox(self.notifwidget)
self.comboBoxNT_3.setObjectName("comboBoxNT_3")
self.gridLayout_2.addWidget(self.comboBoxNT_3, 3, 0, 1, 2)
# 3,2 - label
self.label1NT_3 = QtWidgets.QLabel(self.notifwidget)
self.gridLayout_2.addWidget(self.label1NT_3, 3, 2, 1, 1)
# 3,3 - lineEdit
self.lineEditNT_3 = QtWidgets.QLineEdit(self.notifwidget)
self.gridLayout_2.addWidget(self.lineEditNT_3, 3, 3, 1, 2)
### INTEGER LINES
# 4,0 - combobox
self.comboBoxNT_4 = QtWidgets.QComboBox(self.notifwidget)
self.comboBoxNT_4.setObjectName("comboBoxNT_4")
self.gridLayout_2.addWidget(self.comboBoxNT_4, 4, 0, 1, 2)
# 4,2 - label
self.label1NT_4 = QtWidgets.QLabel(self.notifwidget)
self.gridLayout_2.addWidget(self.label1NT_4, 4, 2, 1, 1)
# 4,3 - lineEdit (int)
self.lineEditNT_4 = QtWidgets.QLineEdit(self.notifwidget)
self.gridLayout_2.addWidget(self.lineEditNT_4, 4, 3, 1, 1)
# 4,4 - label
self.label1NT_5 = QtWidgets.QLabel(self.notifwidget)
self.label1NT_5.setAlignment(QtCore.Qt.AlignCenter)
self.gridLayout_2.addWidget(self.label1NT_5, 4, 4, 1, 1)
# 4,5 - lineEdit (int)
self.lineEditNT_5 = QtWidgets.QLineEdit(self.notifwidget)
self.gridLayout_2.addWidget(self.lineEditNT_5, 4, 5, 1, 1)
# 5,0 - combobox
self.comboBoxNT_5 = QtWidgets.QComboBox(self.notifwidget)
self.gridLayout_2.addWidget(self.comboBoxNT_5, 5, 0, 1, 2)
# 5,2 - label
self.label1NT_6 = QtWidgets.QLabel(self.notifwidget)
self.gridLayout_2.addWidget(self.label1NT_6, 5, 2, 1, 1)
# 5,3 - lineEdit (int)
self.lineEditNT_7 = QtWidgets.QLineEdit(self.notifwidget)
self.gridLayout_2.addWidget(self.lineEditNT_7, 5, 3, 1, 1)
# 5,4 - label
self.label1NT_7 = QtWidgets.QLabel(self.notifwidget)
self.label1NT_7.setAlignment(QtCore.Qt.AlignCenter)
self.gridLayout_2.addWidget(self.label1NT_7, 5, 4, 1, 1)
# 5,5 - lineEdit (int)
self.lineEditNT_6 = QtWidgets.QLineEdit(self.notifwidget)
self.gridLayout_2.addWidget(self.lineEditNT_6, 5, 5, 1, 1)
# 6,0 - combobox
self.comboBoxNT_6 = QtWidgets.QComboBox(self.notifwidget)
self.gridLayout_2.addWidget(self.comboBoxNT_6, 6, 0, 1, 2)
# 6,2 - label
self.label1NT_8 = QtWidgets.QLabel(self.notifwidget)
self.gridLayout_2.addWidget(self.label1NT_8, 6, 2, 1, 1)
# 6,3 - line edit (int)
self.lineEditNT_9 = QtWidgets.QLineEdit(self.notifwidget)
self.gridLayout_2.addWidget(self.lineEditNT_9, 6, 3, 1, 1)
# 6,4 - label
self.label1NT_9 = QtWidgets.QLabel(self.notifwidget)
self.label1NT_9.setAlignment(QtCore.Qt.AlignCenter)
self.gridLayout_2.addWidget(self.label1NT_9, 6, 4, 1, 1)
# 6,5 - line edit (int)
self.lineEditNT_8 = QtWidgets.QLineEdit(self.notifwidget)
self.gridLayout_2.addWidget(self.lineEditNT_8, 6, 5, 1, 1)
## DATETIME LINE
# 7,0 - combobox
self.comboBoxNT_8 = QtWidgets.QComboBox()
# self.gridLayout_2.addWidget(self.comboBoxNT_8, 7, 0, 1, 2)
#
# # 7,2 - label
# self.label1NT_19 = QtWidgets.QLabel(self.notifwidget)
# self.gridLayout_2.addWidget(self.label1NT_19, 7, 2, 1, 1)
#
# # 7,3 - datetime from
# self.dateTimeEditNT = QtWidgets.QDateTimeEdit(self.notifwidget)
# self.dateTimeEditNT.setDateTime(QtCore.QDateTime.currentDateTime().addSecs(-(self.frequency)))
# self.gridLayout_2.addWidget(self.dateTimeEditNT, 7, 3, 1, 1)
#
# # 7,4 - label
# self.label1NT_20 = QtWidgets.QLabel(self.notifwidget)
# self.label1NT_20.setAlignment(QtCore.Qt.AlignCenter)
# self.gridLayout_2.addWidget(self.label1NT_20, 7, 4, 1, 1)
#
# # 7,5 - datetime end
# self.dateTimeEditNT_2 = QtWidgets.QDateTimeEdit(self.notifwidget)
# self.dateTimeEditNT_2.setDateTime(QtCore.QDateTime.currentDateTime())
# self.gridLayout_2.addWidget(self.dateTimeEditNT_2, 7, 5, 1, 1)
# 8,0 - label
self.label1NT_22 = QtWidgets.QLabel(self.notifwidget)
self.label1NT_22.setObjectName("label1NT_22")
self.gridLayout_2.addWidget(self.label1NT_22, 8, 0, 1, 2)
self.label1NT_22.setText("Dohvati nove oglase svakih: ")
# 8,2 - combobox - minutes list
self.comboBoxNT_MIN = QtWidgets.QComboBox(self.notifwidget)
comboBoxNT_MIN_list = [str(x) for x in range(5, 125, 5)]
self.comboBoxNT_MIN.clear()
self.comboBoxNT_MIN.addItems(comboBoxNT_MIN_list)
self.gridLayout_2.addWidget(self.comboBoxNT_MIN, 8, 2, 1, 1)
# 8,3 - label
self.label1NT_27 = QtWidgets.QLabel(self.notifwidget)
self.label1NT_27.setObjectName("label1NT_27")
self.gridLayout_2.addWidget(self.label1NT_27, 8, 3, 1, 1)
#### sati
# 9,0 - label
self.label1NT_23 = QtWidgets.QLabel(self.notifwidget)
self.gridLayout_2.addWidget(self.label1NT_23, 9, 0, 1, 2)
self.label1NT_23.setText("Neka se ovo pravilo izvršava idućih:")
# 9,2 - combobox - sati
self.comboBoxNT_HOUR = QtWidgets.QComboBox(self.notifwidget)
comboBoxNT_HOUR_list = [str(x) for x in range(2, 125, 2)]
self.comboBoxNT_HOUR.clear()
self.comboBoxNT_HOUR.addItems(comboBoxNT_HOUR_list)
self.gridLayout_2.addWidget(self.comboBoxNT_HOUR, 9, 2, 1, 1)
# 9,3 - label
self.label1NT_28 = QtWidgets.QLabel(self.notifwidget)
self.label1NT_28.setObjectName("label1NT_28")
self.gridLayout_2.addWidget(self.label1NT_28, 9, 3, 1, 1)
# EMAIL
# 10,0 - label
self.label1NT_26 = QtWidgets.QLabel(self.notifwidget)
self.gridLayout_2.addWidget(self.label1NT_26, 10, 0, 1, 2)
self.label1NT_26.setText("Obavijesti me na ovu E-mail adresu:")
# 10,2 - Email adresa input
self.lineEditNT_Email = QtWidgets.QLineEdit(self.notifwidget)
self.gridLayout_2.addWidget(self.lineEditNT_Email, 10, 2, 1, 1)
# 10,3 - Lozinka label
self.userEmailPsswdLabel = QtWidgets.QLabel(self.notifwidget)
self.userEmailPsswdLabel.setText("Lozinka za email adresu:")
self.userEmailPsswdLabel.setAlignment(QtCore.Qt.AlignRight
| QtCore.Qt.AlignVCenter)
# self.userEmailPsswdLabel.setMinimumWidth(400)
self.gridLayout_2.addWidget(self.userEmailPsswdLabel, 10, 3, 1, 1)
#10,4 - Lozinka input
self.lineEditNT_EmailPsswd = QtWidgets.QLineEdit(self.notifwidget)
self.lineEditNT_EmailPsswd.setEchoMode(QLineEdit.Password)
self.lineEditNT_EmailPsswd.setMinimumWidth(200)
self.gridLayout_2.addWidget(self.lineEditNT_EmailPsswd, 10, 4, 1, 2)
# loading image
self.userEmailWarningLB = QtWidgets.QLabel(self.notifwidget)
# 10,5 Image warning
self.emailWarningIMG = QPixmap(':/icons/emailWarning.ico')
self.userEmailWarningLB.setPixmap(self.emailWarningIMG)
# Optional, resize label to image size
self.userEmailWarningLB.resize(self.emailWarningIMG.width(),
self.emailWarningIMG.height())
# warning image info on hover
self.userEmailWarningLB.move(0, 0)
self.userEmailWarningLB.setStyleSheet("border :3px solid black;")
self.userEmailWarningLB.setToolTip(
"Mora biti omogućen pristup za Manje sigurne aplikacije (Less secure apps opcija na vašem Google računu), molimo vas kliknite na <b>\"Upute\"</b> na meniju kako biste saznali zašto ili kliknite na <b>\"Omogući manje sigurne aplikacije\"</b> na meniju i odmah uključite tu opciju ako ne želite čitati upute."
)
self.userEmailWarningLB.setToolTipDuration(10000000)
self.gridLayout_2.addWidget(self.userEmailWarningLB, 10, 6, 1, 1)
# 11 INFO
boldLabel = QtGui.QFont()
boldLabel.setBold(True)
self.label.setFont(boldLabel)
# 11,0 - label
self.ruleTimes = QtWidgets.QLabel(self.notifwidget)
self.ruleTimes.setText("")
self.ruleTimes.setFont(boldLabel)
self.gridLayout_2.addWidget(self.ruleTimes, 11, 2, 1, 4)
self.ruleTimes.setFixedHeight(20)
self.ruleTimes.setMinimumWidth(400)
# 12 PRAVILO
# 12,0 - label
self.start = QtWidgets.QLabel(self.notifwidget)
self.start.setText("Pravilo nije pokrenuto.")
self.start.setFont(boldLabel)
self.gridLayout_2.addWidget(self.start, 12, 2, 1, 2)
self.start.setFixedHeight(20)
self.start.setMinimumWidth(400)
# 12,1 - label
self.countToNext = QtWidgets.QLabel(self.notifwidget)
self.countToNext.setText("Brojač.")
self.countToNext.setFont(boldLabel)
self.gridLayout_2.addWidget(self.countToNext, 12, 3, 1, 2)
self.countToNext.setFixedHeight(20)
# 13 - BUTTONS (POKRENI - ZAUSTAVI)
self.testEmailBT = QPushButton("Pošalji test mail")
self.testEmailBT.pressed.connect(self.testEmail)
self.gridLayout_2.addWidget(self.testEmailBT, 13, 2, 1, 1)
self.startRule = QPushButton("Pokreni")
self.gridLayout_2.addWidget(self.startRule, 13, 3, 1, 1)
self.endRule = QPushButton("Zaustavi")
self.gridLayout_2.addWidget(self.endRule, 13, 4, 1, 1)
self.tabWidget.addTab(self.notifwidget, "Obaviještavanje")
self.setCentralWidget(self.centralwidget)
# Create a statusbar.
self.status = self.statusBar()
self.progress = QProgressBar()
self.status.addPermanentWidget(self.progress)
# Menu
toolbar = QToolBar("Glavni Toolbar")
toolbar.setIconSize(QSize(16, 16))
self.addToolBar(toolbar)
# UPUTE
uputeAction = QAction("Upute", self)
uputeAction.triggered.connect(self.openUrl)
uputeAction.setCheckable(True)
toolbar.addAction(uputeAction)
dopustiManjeSigurne = QAction("Omogući manje sigurne aplikacije", self)
dopustiManjeSigurne.triggered.connect(self.openUrlManjeSigurne)
dopustiManjeSigurne.setCheckable(True)
toolbar.addAction(dopustiManjeSigurne)
# O aplikaciji
aboutAction = QAction("O aplikaciji", self)
aboutAction.triggered.connect(self.aboutapp)
aboutAction.setCheckable(True)
toolbar.addAction(aboutAction)
# Thread and timer
self.threadpool = QThreadPool()
self.startRule.pressed.connect(self.start_rule)
self.endRule.pressed.connect(self.stop_rule)
self.timer = QTimer()
self.timer.setInterval(1000)
self.retranslateUi()
self.tabWidget.setCurrentIndex(0)
QtCore.QMetaObject.connectSlotsByName(self)
def aboutapp(self):
QMessageBox.about(
self, "Njuškalo Poštar info",
"Aplikacija za dohvat, analizu i obaviještavanje na temelju"
" podataka sa njuškalo.hr stranice. <br>"
"Trebate više informacije, želite izraditi sličnu aplikaciju, želite licencirati enterprise verziju aplikacije ili imate neki drugi upit - obratite se na [email protected]"
)
return
def openUrl(self, url):
QDesktopServices.openUrl(
QUrl(
"https://njuskalo-postar-dokumentacija.readthedocs.io/hr/latest/contents.html"
))
def openUrlManjeSigurne(self):
QDesktopServices.openUrl(
QUrl(
"https://njuskalo-postar-dokumentacija.readthedocs.io/hr/latest/contents.html#kako-dopustiti-manje-sigurnim-aplikacijama-da-mi-salju-email"
))
def testEmail(self):
sendtoEmail = self.lineEditNT_Email.text()
emailPsswd = self.lineEditNT_EmailPsswd.text()
if not sendtoEmail or not emailPsswd:
QMessageBox.about(self, "Email polje ili lozinka je prazno!",
"Niste unijeli email adresu i/ili lozinku.")
return
SendToGmail(destination=sendtoEmail,
df=self.pageDF[0:10],
serverLogin=sendtoEmail,
serverPss=emailPsswd)
QMessageBox.about(
self, "Mail poslan!",
"Poslano je prvih 10 stanova iz <br> \"Podaci iz web stranice\". Provjerite email koji ste unijeli."
)
self.testEmailBT.setText("Test mail poslan")
return
def convert(self, seconds):
seconds = seconds % (24 * 3600)
days = seconds // (24 * 3600)
hour = seconds // 3600
seconds %= 3600
minutes = seconds // 60
seconds %= 60
return "%d:%d:%02d:%02d" % (days, hour, minutes, seconds)
def progress_fn(self, n):
self.progress.setValue(n)
if self.stop_ruleVar == 0:
self.start.setText("Izvršeno " + str(n) + "%")
def start_rule(self):
worker = Worker(
self.execute_rule
) # Any other args, kwargs are passed to the run function
worker.signals.progress.connect(self.progress_fn)
self.threadpool.start(worker)
def execute_rule(self, progress_callback):
sendtoEmail = self.lineEditNT_Email.text()
emailPsswd = self.lineEditNT_EmailPsswd.text()
if not sendtoEmail or not emailPsswd:
QMessageBox.about(self, "Email polje ili lozinka je prazno!",
"Niste unijeli email adresu i/ili lozinku.")
self.timer.stop()
return
self.timer.start()
self.startRule.setEnabled(False)
self.start.setText("Pravilo pokrenuto.")
self.counter = int(self.comboBoxNT_HOUR.currentText()) * 3600
self.frequency = int(self.comboBoxNT_MIN.currentText()) * 60
freq = self.frequency
counter = self.counter
self.ruleTimes.setText("Izvršavam pravilo još - " +
str(display_time(counter, 4)))
for n in range(1, counter + 1):
if self.stop_ruleVar == 1:
self.timer.stop()
progress_callback.emit(0)
self.startRule.setEnabled(True)
self.stop_ruleVar = 0
return
if freq == 1:
freq = self.frequency
else:
freq -= 1
counter -= 1
time.sleep(1)
if n % self.frequency == 0 and self.stop_ruleVar != 1:
self.countToNext.setText(
"Dohvaćam nove podatke i šaljem obavijest.")
self.getInfoFromForm()
if not self.filteredpageDF.empty:
SendToGmail(destination=sendtoEmail,
df=self.filteredpageDF,
serverLogin=sendtoEmail,
serverPss=emailPsswd)
prog_prct = (n / self.counter) * 100
progress_callback.emit(prog_prct)
if self.stop_ruleVar != 1:
self.countToNext.setText("Dohvaćam nove podatke za " +
str(self.convert(int(freq))))
if counter == 0:
self.start.setText("Zadatak izvršen.")
self.countToNext.setText("")
progress_callback.emit(100)
self.timer.stop()
self.startRule.setEnabled(True)
return
def stop_rule(self):
self.start.setText("Zadatak zaustavljen.")
self.ruleTimes.setText("")
self.countToNext.setText("")
self.stop_ruleVar = 1
def shutdown(self):
if self.worker: # set self.worker=None in your __init__ so it's always defined.
self.worker.kill()
self.stop_ruleVar = 1
#########################################
def gourl(self):
self.siteURL = self.lineEdit.text()
self.webview.load(QUrl(self.siteURL))
def getPageInfo(self):
self.siteURL = self.lineEdit.text()
getPage = GetPage(self.siteURL, "data", "page")
self.pageDF = getPage.getAdInfo()
if self.pageDF.empty:
msg = QMessageBox()
msg.setWindowTitle("Greška!")
msg.setText(
"Unosite isključivo stranice koje na početku imaju https://www.njuskalo.hr/prodaja-stanova/ i koje postoje na njuskalo.hr"
)
msg.setIcon(QMessageBox.Critical)
msg.exec_()
# print(self.pageDF.columns)
self.model = getPandas.PandasTableModel(self.pageDF)
self.pdtable.setModel(self.model)
self.pdtable.doubleClicked.connect(self.OpenLink)
self.proxy.setSourceModel(self.model)
self.pdtable.setModel(self.proxy)
self.comboBoxDT.clear()
self.comboBoxDT.addItems(self.pageDF.columns)
# Combo TEXT boxes
comboBoxNT_listText = [
'Naslov', 'Tip', 'Lokacija', 'ID', 'URL', 'TipOglasa'
]
self.comboBoxNT.clear()
self.comboBoxNT.addItems(comboBoxNT_listText)
self.comboBoxNT.setCurrentText(comboBoxNT_listText[0])
self.comboBoxNT_2.clear()
self.comboBoxNT_2.addItems(comboBoxNT_listText)
self.comboBoxNT_2.setCurrentText(comboBoxNT_listText[1])
self.comboBoxNT_3.clear()
self.comboBoxNT_3.addItems(comboBoxNT_listText)
self.comboBoxNT_3.setCurrentText(comboBoxNT_listText[2])
# Combo NUM boxes
comboBoxNT_listNums = ['Kvadratura', 'CijenaKN', 'CijenaEUR']
self.comboBoxNT_4.clear()
self.comboBoxNT_4.addItems(comboBoxNT_listNums)
self.comboBoxNT_4.setCurrentText(comboBoxNT_listNums[0])
self.comboBoxNT_5.clear()
self.comboBoxNT_5.addItems(comboBoxNT_listNums)
self.comboBoxNT_5.setCurrentText(comboBoxNT_listNums[1])
self.comboBoxNT_6.clear()
self.comboBoxNT_6.addItems(comboBoxNT_listNums)
self.comboBoxNT_6.setCurrentText(comboBoxNT_listNums[2])
# DATETIME Boxes
self.comboBoxNT_8.clear()
self.comboBoxNT_8.addItems(['VrijemeObjave'])
self.comboBoxNT_8.setCurrentText('VrijemeObjave')
def mk_int_0(self, s):
s = s.strip()
return int(s) if s else 0
def mk_int_max(self, s):
s = s.strip()
return int(s) if s else 1073741824
def getInfoFromForm(self):
userQuery = []
# Combobox - text lines
userFormQuery = {}
## Pandas dataframe filtering dictionary
datetimeFormat = '%d.%m.%Y %H:%M:%S'
self.startTime = (
datetime.now() -
timedelta(seconds=int(self.comboBoxNT_MIN.currentText()) *
60)).strftime(datetimeFormat)
self.endTime = datetime.now().strftime(datetimeFormat)
# Text values
userFormQuery[self.comboBoxNT.currentText()] = self.lineEditNT.text()
userFormQuery[
self.comboBoxNT_2.currentText()] = self.lineEditNT_2.text()
userFormQuery[
self.comboBoxNT_3.currentText()] = self.lineEditNT_3.text()
# Int values
userFormQuery[self.comboBoxNT_4.currentText()] = [
self.mk_int_0(self.lineEditNT_4.text()),
self.mk_int_max(self.lineEditNT_5.text())
]
userFormQuery[self.comboBoxNT_5.currentText()] = [
self.mk_int_0(self.lineEditNT_7.text()),
self.mk_int_max(self.lineEditNT_6.text())
]
userFormQuery[self.comboBoxNT_6.currentText()] = [
self.mk_int_0(self.lineEditNT_9.text()),
self.mk_int_max(self.lineEditNT_8.text())
]
# DateTime values
userFormQuery[self.comboBoxNT_8.currentText()] = [
self.startTime, self.endTime
]
self.filteredpageDF = pd.DataFrame()
self.filteredpageDF = self.pageDF
for key, value in list(userFormQuery.items()):
if 'str' in str(type(value)):
if not value: del userFormQuery[key]
commands = []
for key, value in userFormQuery.items():
if 'list' in str(type(value)):
if 'int' in str(type(value[0])):
command = "self.pageDF[\"{}\"] > {}) & (self.pageDF[\"{}\"] < {}".format(
key, value[0], key, value[1])
commands.append((command))
else: # This part takes care of datetime comparison - list contains 2 datetime strings
command = "self.pageDF[\"{}\"] > \"{}\") & (self.pageDF[\"{}\"] < \"{}\"".format(
key, value[0], key, value[1])
commands.append((command))
if 'str' in str(type(value)):
command = "self.pageDF[\"{}\"].str.contains(\"{}\", flags=re.IGNORECASE)".format(
key, value)
commands.append((command))
commandFinal = ''
for command in commands:
commandFinal = commandFinal + ("({}) & ".format(command))
commandFinal = "self.pageDF[" + commandFinal[:-3] + "]"
self.filteredpageDF = eval(commandFinal)
# Cast datetime to str in desired format for showing on front end
# self.pageDF['VrijemeObjave'] = pd.to_datetime(self.pageDF['VrijemeObjave'], format='%d.%m.%Y %H:%M:%S').dt.strftime('%d.%m.%Y %H:%M:%S')
# print(self.filteredpageDF.shape)
# if not self.filteredpageDF.empty:
# self.filteredpageDF['VrijemeObjave'] = pd.to_datetime(self.filteredpageDF['VrijemeObjave'],
# format='%d.%m.%Y %H:%M:%S').dt.strftime('%d.%m.%Y %H:%M:%S')
def OpenLink(self, item):
for index in self.pdtable.selectionModel().selectedIndexes():
value = str(self.pageDF.iloc[index.row()][index.column()])
if value.startswith("http://") or value.startswith("https://"):
webbrowser.open(value)
def retranslateUi(self):
_translate = QtCore.QCoreApplication.translate
self.setWindowTitle(_translate("main", "Njuškalo Poštar"))
self.label.setText(_translate("main", "Unesite URL:"))
self.go.setText(_translate("main", "Kreni"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.webview),
_translate("main", "Web stranica"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.centralwidgetDT),
_translate("main", "Podaci iz web stranice"))
self.labelDT.setText(_translate("main", " Pretraga: "))
self.comboBoxDT.setPlaceholderText(_translate("main", "Odaberite"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.notifwidget),
_translate("main", "Obaviještavanje"))
self.label1NT_4.setText(_translate("main", "između:"))
self.label1NT_28.setText(_translate("main", "sati"))
self.label1NT_8.setText(_translate("main", "između:"))
self.label1NT_27.setText(_translate("main", "minuta"))
self.label1NT_5.setText(_translate("main", "i"))
self.label1NT_7.setText(_translate("main", "i"))
self.label1NT.setText(_translate("main", "sadrži tekst:"))
self.label1NT_9.setText(_translate("main", "i"))
self.label1NT_6.setText(_translate("main", "između:"))
self.label1NT_3.setText(_translate("main", "sadrži tekst:"))
self.label1NT_2.setText(_translate("main", "sadrži tekst:"))
@QtCore.pyqtSlot(int)
def on_view_horizontalHeader_sectionClicked(self, logicalIndex):
self.logicalIndex = logicalIndex
self.menuValues = QtWidgets.QMenu(self)
self.signalMapper = QtCore.QSignalMapper(self)
self.comboBoxDT.blockSignals(True)
self.comboBoxDT.setCurrentIndex(self.logicalIndex)
self.comboBoxDT.blockSignals(True)
valuesUnique = [
self.model.item(row, self.logicalIndex).text()
for row in range(self.model.rowCount())
]
actionAll = QtWidgets.QAction("All", self)
actionAll.triggered.connect(self.on_actionAll_triggered)
self.menuValues.addAction(actionAll)
self.menuValues.addSeparator()
for actionNumber, actionName in enumerate(
sorted(list(set(valuesUnique)))):
action = QtWidgets.QAction(actionName, self)
self.signalMapper.setMapping(action, actionNumber)
action.triggered.connect(self.signalMapper.map)
self.menuValues.addAction(action)
self.signalMapper.mapped.connect(self.on_signalMapper_mapped)
headerPos = self.pdtable.mapToGlobal(self.horizontalHeader.pos())
posY = headerPos.y() + self.horizontalHeader.height()
posX = headerPos.x() + self.horizontalHeader.sectionViewportPosition(
self.logicalIndex)
self.menuValues.exec_(QtCore.QPoint(posX, posY))
@QtCore.pyqtSlot()
def on_actionAll_triggered(self):
filterColumn = self.logicalIndex
filterString = QtCore.QRegExp("", QtCore.Qt.CaseSensitive,
QtCore.QRegExp.RegExp)
self.proxy.setFilterRegExp(filterString)
self.proxy.setFilterKeyColumn(filterColumn)
@QtCore.pyqtSlot(int)
def on_signalMapper_mapped(self, i):
stringAction = self.signalMapper.mapping(i).text()
filterColumn = self.logicalIndex
filterString = QtCore.QRegExp(stringAction, QtCore.Qt.CaseInsensitive,
QtCore.QRegExp.FixedString)
self.proxy.setFilterRegExp(filterString)
self.proxy.setFilterKeyColumn(filterColumn)
@QtCore.pyqtSlot(str)
def on_lineEdit_textChanged(self, text):
search = QtCore.QRegExp(text, QtCore.Qt.CaseInsensitive,
QtCore.QRegExp.RegExp)
self.proxy.setFilterRegExp(search)
@QtCore.pyqtSlot(int)
def on_comboBox_currentIndexChanged(self, index):
self.proxy.setFilterKeyColumn(index)
class Data():
def __init__(self, file_name=None, work_dir=None):
"""
Init Data class (images and annotation per image)
:param file_name: annotation file
:param work_dir: working directory for images
"""
self.img_size = 0
self.work_dir = work_dir
if file_name == None:
self.file_name = "untitled.json"
self.no_anno_file = True
else:
self.file_name = file_name
self.no_anno_file = False
self.changed = False
# Sorting part
self.sort_points = False
self.images_origin = None
self.points_origin = None
self.init_images()
def init_images(self):
self.images = []
self.pt_names = set()
self.seg_names = set()
self.img_props = {}
if self.work_dir is not None:
# Get list of images
extensions = [
'.%s' % fmt.data().decode("ascii").lower()
for fmt in QImageReader.supportedImageFormats()
]
work_dir_file_names = [
os.path.basename(file_name)
for file_name in Path(self.work_dir).glob('*')
if str(file_name).lower().endswith(tuple(extensions))
]
if not self.no_anno_file:
# Has annotation file
with open(self.file_name, "r") as read_file:
data = json.load(read_file)
# Init images list
for entry in data:
if entry['file_name'] in work_dir_file_names:
image = Image(entry['file_name'],
entry.get('points', None),
entry.get('outlines', None),
entry.get("outlines_cv", None),
entry.get("property", None))
self.images.append(image)
# Update points names of all
for pt in entry['points']:
self.pt_names.add(pt['name'])
#Update seg name for all seg
for key, _ in entry['outlines_cv'].items():
self.seg_names.add(key)
#Update outline names
for key, item in entry['property'].items():
if type(item) is str:
# Categorical
if key in self.img_props:
self.img_props[key].append(item)
else:
self.img_props[key] = [item]
else:
# Numerical
if key not in self.img_props:
self.img_props[key] = None
else:
# without annotation file
for name in work_dir_file_names:
image = Image(name)
self.images.append(image)
self.current_image_id = 0
self.img_size = len(self.images)
if self.img_size != 0:
self.current_pixmap = QPixmap(
os.path.join(self.work_dir, self.get_current_image_name()))
self.set_scale_fit_limit()
self.filter_idx = list(range(0, self.img_size))
self.sort_idx = list(range(0, self.img_size))
self.flagged_img_idx = []
def sort(self, value):
if value == True:
self.images_origin = self.images.copy()
self.images.sort(key=lambda x: x.img_name, reverse=False)
elif self.images_origin is not None:
self.images = self.images_origin
def set_image_id(self, idx):
self.current_image_id = idx
# Reset scale and current pixmap
self.current_pixmap = QPixmap(
os.path.join(self.work_dir, self.get_current_image_name()))
self.set_scale_fit_limit()
def set_work_dir(self, work_dir):
self.work_dir = work_dir
self.init_images()
def set_file_name(self, file_name):
self.no_anno_file = False
self.file_name = file_name
self.init_images()
def set_scale(self, scale):
temp = self.scale * scale
if temp <= 7 * self.origin_scale and temp >= self.origin_scale / 2:
self.scale = temp
def reset_scale(self):
self.scale = self.origin_scale
def set_scale_fit_limit(self):
# Setting the maximum scale limit
if self.current_pixmap.width() > pixmap_max_size_limit.width(
) or self.current_pixmap.height() > pixmap_max_size_limit.height():
width_scale = ceil(self.current_pixmap.width() /
pixmap_max_size_limit.width())
height_scale = ceil(self.current_pixmap.height() /
pixmap_max_size_limit.height())
self.origin_scale = 1 / max(width_scale, height_scale)
elif self.current_pixmap.width() < pixmap_min_size_limit.width(
) or self.current_pixmap.height() < pixmap_min_size_limit.height():
width_scale = ceil(pixmap_min_size_limit.width() /
self.current_pixmap.width())
height_scale = ceil(pixmap_min_size_limit.height() /
self.current_pixmap.height())
self.origin_scale = max(width_scale, height_scale)
else:
self.origin_scale = 1
self.scale = self.origin_scale
size = self.current_pixmap.size()
# The width length
self.length = int(rect_length_prop * max(size.width(), size.height()))
if self.length < min_rect_length:
self.length = min_rect_length
self.get_current_image().set_points_width(self.length)
def set_current_pt_of_current_img(self,
pt_name=None,
x=None,
y=None,
error=None,
absence=None,
info=None,
scaled_coords=False):
if scaled_coords:
if y is not None:
y = int(y / self.scale)
if x is not None:
x = int(x / self.scale)
if self.get_current_pt_of_current_img().check_diff(pt_name=pt_name,
x=x,
y=y,
error=error,
absence=absence,
info=info):
self.get_current_pt_of_current_img().set_point(pt_name=pt_name,
x=x,
y=y,
error=error,
absence=absence,
info=info)
self.changed = True
return True
else:
return False
def check_new_name_in_current_point_dict(self, name):
if name in list(self.get_current_image().points_dict.keys()):
return False
else:
current_key = self.get_current_image().current_pt_key
self.get_current_image().points_dict[
name] = self.get_current_image().points_dict[current_key]
# self.get_current_image().points_dict[current_key] = None
self.get_current_image().points_dict.pop(current_key)
self.get_current_image().set_current_pt_key(name)
return True
def set_current_pt_of_current_img_dict(self, pt_prop):
self.set_current_pt_of_current_img(
pt_name=pt_prop.get('pt_name', None),
x=pt_prop.get('x', None),
y=pt_prop.get('y', None),
absence=pt_prop.get('absence', None),
error=pt_prop.get('error', None))
def add_pt_for_current_img(self, pt_name, x, y, scaled_coords=True):
"""
Add point if the name if not duplicate
:param pt_name: pt name
:param x: x
:param y: y
:param scaled_coords: if it need to scale back to real coords
:return: If it is possible to add point
"""
cur_pt_names = list(self.get_current_image_points().keys())
if pt_name not in cur_pt_names:
# if the point name is not duplicate add
if scaled_coords:
y = int(y / self.scale)
x = int(x / self.scale)
temp = Point(pt_name, x, y, width=self.length, absence=False)
self.get_current_image().points_dict[pt_name] = temp
self.pt_names.add(pt_name)
self.changed = True
return True
else:
return False
def add_seg_for_current_img(self, seg_name):
"""
Add the segmentation name
"""
cur_seg_names = list(self.get_current_image_segments_cv().keys())
if seg_name not in cur_seg_names:
self.get_current_image_segments_cv()[seg_name] = {"contours": None}
self.seg_names.add(seg_name)
return True
else:
return False
# Deprecated
def trans_current_segment_to_contour(self, segment, segment_name):
#turn canvas into images
image = segment.toImage()
print(image.format())
image = image.convertToFormat(QImage.Format_RGBA8888)
print(image.format())
s = image.bits().asstring(image.width() * image.height() * 4)
arr = np.fromstring(s, dtype=np.uint8).reshape(
(image.height(), image.width(), 4))
# arr_255 = np.interp(arr,[np.min(arr),np.max(arr)],[0,255]).astype(np.uint8)
mask = arr[:, :, 3]
print(np.max(mask), np.min(mask))
print(arr[arr[:, :, 0] != 0, :0])
print(np.sum(arr[:, :, :3] == np.array([220, 20, 60])))
_, thresh = cv2.threshold(mask, 2, 255, 0)
_, contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
# cv2.drawContours(arr, contours, -1, (0,255,0), 3)
# cv2.imwrite(os.path.join("mat_test/contour" , "contour.jpg") , arr)
segments = self.get_current_image_segments()
# key_0 = list(segments.keys())[0]
scale = self.origin_scale
# example of setting 0 index outline
segment = segments[segment_name]
new_contours = {}
levels = find_hierarchy_level(hierarchy[0])
for idx, contour in enumerate(contours):
# children = None
# find_children(idx, hierarchy[0], children)
children = find_all_children(idx, hierarchy[0])
if children is not None:
children = [int(child) for child in children]
new_contours[str(idx)] = {
"child":
children,
"level":
levels[idx],
"coords": [{
"x": round(pt[0][0] / scale),
"y": round(pt[0][1] / scale)
} for pt in contour]
}
# Turn opencv contours into relabel contour format
segments[segment_name].set_segment(segment.segment_name,
new_contours,
hierarchy=None,
error=segment.error,
info=segment.info,
absence=segment.absence)
def trans_current_segment_to_contour_cv(self, segment, segment_name,
contour_colour):
"""
Convert the segmentaion from images to
:param canvas:
:param contour_name:
:return:
"""
image = segment.toImage()
image = image.convertToFormat(QImage.Format_RGBA8888)
s = image.bits().asstring(image.width() * image.height() * 4)
arr = np.fromstring(s, dtype=np.uint8).reshape(
(image.height(), image.width(), 4))
# arr_255 = np.interp(arr,[np.min(arr),np.max(arr)],[0,255]).astype(np.uint8)
## only the mask for the current category
cv_colour = (contour_colour.red(), contour_colour.green(),
contour_colour.blue(), contour_colour.alpha())
img_mask = arr[:, :, :3] != cv_colour[:3]
mask_final = np.logical_and(img_mask[..., 0], img_mask[..., 1],
img_mask[..., 2])
arr[mask_final, 3] = 0
mask = arr[:, :, 3]
_, thresh = cv2.threshold(mask, 2, 255, 0)
height = self.get_current_origin_pixmap().height()
width = self.get_current_origin_pixmap().width()
thresh = cv2.resize(thresh, (width, height))
_, contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
contours = [contour.tolist() for contour in contours]
self.get_current_image_segments_cv(
)[segment_name]['contours'] = contours
def remove_pt_for_current_img(self, key=None):
"""
Remove the current point or point with key given
:param idx:
:return:
"""
if key is None:
key = self.get_current_image().current_pt_key
pt = self.get_current_image_points().pop(key)
self.get_current_image().set_current_pt_key_to_start()
return pt
def remove_seg_for_current_img(self, key=None):
"""
Remove the current segmentation or segmentation with key given
:param idx:
:return:
"""
if key is None:
key = self.get_current_image().current_pt_key
seg = self.get_current_image_segments_cv().pop(key, None)
return seg
def get_current_pt_of_current_img(self):
return self.images[self.current_image_id].get_current_pt()
def get_current_image(self):
if self.images:
return self.images[self.current_image_id]
else:
return None
def get_current_image_points(self):
# if self.images:
# return self.images[self.current_image_id].points
# else:
# return None
if self.images:
return self.images[self.current_image_id].points_dict
else:
return None
def get_current_image_segments(self):
if self.images:
return self.images[self.current_image_id].segments
else:
return None
def get_current_image_scaled_segments(self):
outlines = self.get_current_image_segments()
if outlines:
return {
key: outline * self.scale
for key, outline in outlines.items()
}
else:
return None
def get_current_image_segments_cv(self):
if self.images:
return self.images[self.current_image_id].segments_cv
else:
return None
def get_current_image_name(self):
return self.images[self.current_image_id].img_name
def get_current_image_abs_path(self):
path = os.path.join(self.work_dir,
self.images[self.current_image_id].img_name)
path = os.path.abspath(path)
return path
def get_current_scaled_pixmap(self):
return self.current_pixmap.scaled(
self.scale * self.current_pixmap.size(), Qt.KeepAspectRatio)
def get_current_origin_pixmap(self):
return self.current_pixmap
def get_current_scaled_points(self):
if self.images:
return [
pt * self.scale
for key, pt in self.get_current_image_points().items()
]
else:
return None
def has_images(self):
if self.images:
return True
else:
return False
def has_points_current_image(self):
if self.images and self.images[self.current_image_id].points_dict:
return True
else:
return False
def toggle_flag_img(self, state):
"""
Set the data as flagged mode
Intersect ( flag idx, self.filter_idx)
Change the current image into first flagged image
:param state: Flag mode is True or False
:return: indices of flagged images
"""
if state == True:
self.flagged_img_idx = [
idx for idx, img in enumerate(self.images)
if img.attention_flag == True
]
self.flagged_img_idx = list(
set(self.filter_idx) & set(self.flagged_img_idx))
if self.flagged_img_idx:
self.current_image_id = self.flagged_img_idx[0]
else:
self.current_image_id = 0
# self.images = self.images_backup
# self.images_backup = None
# if self.current_image_id >= len(self.images):
# self.current_image_id =len(self.images)-1
return self.flagged_img_idx
def filter_imgs_by_review_assist(self, filtered_dict):
"""
Change the current image into first flagged image
Intersect ( flag idx, self.filter_idx)
:return: indices of ticked images.
"""
all_idx = list(range(0, self.img_size))
for prop_key, filtered_items in filtered_dict.items():
filter_idx = list(
np.where(
np.isin(self.img_props[prop_key], filtered_items) == True)
[0])
all_idx = list(set(all_idx) & set(filter_idx))
print("all idx", all_idx)
self.filter_idx = all_idx
# self.filter_idx = list(set(self.filter_idx) & set(self.flagged_img_idx))
if self.filter_idx:
self.current_image_id = self.filter_idx[0]
return self.filter_idx
def write_json(self, save_name=None):
# Create data form to save
image_list = []
for image in self.images:
entry = {'file_name': image.img_name}
# points list
points = []
for key, pt in image.points_dict.items():
pt_data = {
"name": pt.pt_name,
"x": pt.x,
"y": pt.y,
"info": pt.info,
"error": pt.error,
"absence": pt.absence
}
points.append(pt_data)
entry['points'] = points
entry['outlines_cv'] = image.segments_cv
# Use the segmentation cv instead
# segments = []
# for key, seg in image.segments.items():
# # contour_data =
# seg_data = {"name": seg.segment_name, "contours": seg.contours}
# segments.append(seg_data)
# entry['outlines'] = segments
image_list.append(entry)
if save_name is None:
save_name = self.file_name
with open(save_name, 'w') as write:
json.dump(image_list, write, default=convert)
self.changed = False
def refreshData(self):
file = self.getAbsFile()
self._size = os.path.getsize(file)
map = QPixmap(file)
self._width = map.height()
self._height = map.width()
def printViaQCursor(self):
dialog = QPrintDialog(self.printer, self)
if not dialog.exec_():
return
logo = QPixmap(":/logo.png")
headFormat = QTextBlockFormat()
headFormat.setAlignment(Qt.AlignLeft)
headFormat.setTextIndent(self.printer.pageRect().width() -
logo.width() - 216)
bodyFormat = QTextBlockFormat()
bodyFormat.setAlignment(Qt.AlignJustify)
lastParaBodyFormat = QTextBlockFormat(bodyFormat)
lastParaBodyFormat.setPageBreakPolicy(
QTextFormat.PageBreak_AlwaysAfter)
rightBodyFormat = QTextBlockFormat()
rightBodyFormat.setAlignment(Qt.AlignRight)
headCharFormat = QTextCharFormat()
headCharFormat.setFont(QFont("Helvetica", 10))
bodyCharFormat = QTextCharFormat()
bodyCharFormat.setFont(QFont("Times", 11))
redBodyCharFormat = QTextCharFormat(bodyCharFormat)
redBodyCharFormat.setForeground(Qt.red)
tableFormat = QTextTableFormat()
tableFormat.setBorder(1)
tableFormat.setCellPadding(2)
document = QTextDocument()
cursor = QTextCursor(document)
mainFrame = cursor.currentFrame()
page = 1
for statement in self.statements:
cursor.insertBlock(headFormat, headCharFormat)
cursor.insertImage(":/logo.png")
for text in ("Greasy Hands Ltd.",
"New Lombard Street", "London", "WC13 4PX",
QDate.currentDate().toString(DATE_FORMAT)):
cursor.insertBlock(headFormat, headCharFormat)
cursor.insertText(text)
for line in statement.address.split(", "):
cursor.insertBlock(bodyFormat, bodyCharFormat)
cursor.insertText(line)
cursor.insertBlock(bodyFormat)
cursor.insertBlock(bodyFormat, bodyCharFormat)
cursor.insertText("Dear {0},".format(statement.contact))
cursor.insertBlock(bodyFormat)
cursor.insertBlock(bodyFormat, bodyCharFormat)
balance = statement.balance()
cursor.insertText(
"The balance of your account is $ {0:,.2f}.".format(
float(balance)))
if balance < 0:
cursor.insertBlock(bodyFormat, redBodyCharFormat)
cursor.insertText("Please remit the amount owing "
"immediately.")
else:
cursor.insertBlock(bodyFormat, bodyCharFormat)
cursor.insertText("We are delighted to have done "
"business with you.")
cursor.insertBlock(bodyFormat, bodyCharFormat)
cursor.insertText("Transactions:")
table = cursor.insertTable(len(statement.transactions), 3,
tableFormat)
row = 0
for date, amount in statement.transactions:
cellCursor = table.cellAt(row, 0).firstCursorPosition()
cellCursor.setBlockFormat(rightBodyFormat)
cellCursor.insertText(date.toString(DATE_FORMAT),
bodyCharFormat)
cellCursor = table.cellAt(row, 1).firstCursorPosition()
if amount > 0:
cellCursor.insertText("Credit", bodyCharFormat)
else:
cellCursor.insertText("Debit", bodyCharFormat)
cellCursor = table.cellAt(row, 2).firstCursorPosition()
cellCursor.setBlockFormat(rightBodyFormat)
format = bodyCharFormat
if amount < 0:
format = redBodyCharFormat
cellCursor.insertText("$ {0:,.2f}".format(float(amount)),
format)
row += 1
cursor.setPosition(mainFrame.lastPosition())
cursor.insertBlock(bodyFormat, bodyCharFormat)
cursor.insertText("We hope to continue doing business "
"with you,")
cursor.insertBlock(bodyFormat, bodyCharFormat)
cursor.insertText("Yours sincerely")
cursor.insertBlock(bodyFormat)
if page == len(self.statements):
cursor.insertBlock(bodyFormat, bodyCharFormat)
else:
cursor.insertBlock(lastParaBodyFormat, bodyCharFormat)
cursor.insertText("K. Longrey, Manager")
page += 1
document.print_(self.printer)
def scaledPixmap(path: str, scale: float) -> QPixmap:
pixmap = QPixmap(path)
if scale > 1.0:
pixmap = pixmap.scaledToWidth(pixmap.width() * scale, Qt.SmoothTransformation)
pixmap.setDevicePixelRatio(scale)
return pixmap
def initUI(self):
self.setGeometry(800 - WIDTH // 2, 450 - HEIGHT // 2, WIDTH, HEIGHT)
p = self.palette()
p.setColor(self.backgroundRole(), QColor(40, 40, 40))
self.setPalette(p)
validator = QDoubleValidator()
validator.setLocale(QLocale("Russia"))
self.parameters = [QLineEdit(self) for _ in range(3)]
offset = 120
for i in range(len(self.parameters)):
self.parameters[i].setGeometry(80, offset + 40 * i, 100, 30)
self.parameters[i].setValidator(validator)
self.parameters[i].setText("1")
label = QLabel(self)
label.setText("{} = ".format(chr(i + ord('a'))))
label.setGeometry(50, offset + 40 * i, 70, 30)
label.setStyleSheet("color: white")
self.parameters[0].textChanged.connect(self.update_a_field)
self.parameters[1].textChanged.connect(self.update_b_field)
self.parameters[2].textChanged.connect(self.update_c_field)
label = QLabel(self)
label.setGeometry(65, 450, 60, 30)
label.setText("alpha = ")
label.setStyleSheet('color: white')
self.alpha_field = QLineEdit(self)
self.alpha_field.setGeometry(120, 450, 60, 30)
self.alpha_field.setValidator(validator)
self.alpha_field.setText(str(self.alpha))
self.alpha_field.textChanged.connect(self.update_alpha_field)
label = QLabel(self)
label.setGeometry(65, 500, 60, 30)
label.setText("beta = ")
label.setStyleSheet('color: white')
self.beta_field = QLineEdit(self)
self.beta_field.setGeometry(120, 500, 60, 30)
self.beta_field.setValidator(validator)
self.beta_field.setText(str(self.beta))
self.beta_field.textChanged.connect(self.update_beta_field)
combo = QComboBox(self)
combo.addItems(["Task {}".format(i) for i in range(1, 4)])
combo.move(60, 15)
combo.activated[str].connect(self.onSelect)
self.label = QLabel(self)
pixmap = QPixmap('formula{}.png'.format(self.task_number))
self.label.setPixmap(pixmap)
self.label.move((self.panelWidth - pixmap.width()) / 2, 50)
# self.label.move(0, 100)
self.label.setGeometry((self.panelWidth - pixmap.width()) / 2, 50,
pixmap.width() + 100, pixmap.height())
label = QLabel(self)
label.setGeometry(40, 275, 60, 30)
label.setText("left")
label.setStyleSheet('color: white')
self.left_x_text_field = QLineEdit(self)
self.left_x_text_field.setGeometry(40, 300, 60, 30)
self.left_x_text_field.setText(str(self.t_left_top.x()))
self.left_x_text_field.setValidator(validator)
self.left_x_text_field.textChanged.connect(self.update_left_x_field)
label = QLabel(self)
label.setGeometry(120, 275, 60, 30)
label.setText("top")
label.setStyleSheet('color: white')
self.left_y_text_field = QLineEdit(self)
self.left_y_text_field.setGeometry(120, 380, 60, 30)
self.left_y_text_field.setText(str(self.t_left_top.y()))
self.left_y_text_field.setValidator(validator)
self.left_y_text_field.textChanged.connect(self.update_left_y_field)
label = QLabel(self)
label.setGeometry(40, 355, 60, 30)
label.setText("right")
label.setStyleSheet('color: white')
self.right_x_text_field = QLineEdit(self)
self.right_x_text_field.setGeometry(40, 380, 60, 30)
self.right_x_text_field.setText(str(self.t_right_bottom.x()))
self.right_x_text_field.setValidator(validator)
self.right_x_text_field.textChanged.connect(self.update_right_x_field)
label = QLabel(self)
label.setGeometry(120, 355, 60, 30)
label.setText("bottom")
label.setStyleSheet('color: white')
self.right_y_text_field = QLineEdit(self)
self.right_y_text_field.setGeometry(120, 300, 60, 30)
self.right_y_text_field.setText(str(self.t_right_bottom.y()))
self.right_y_text_field.setValidator(validator)
self.right_y_text_field.textChanged.connect(self.update_right_y_field)
self.setWindowTitle('Points')
self.show()
def __init__(self):
load_model()
voice_set()
setWalkingPathLoaction()
super(MainWindow, self).__init__()
self.resize(640, 1000) # smart phone size 960
'''palette = QPalette()
palette.setBrush(QPalette.Background,QBrush(QPixmap("D:\\Project\\ui\\background.jpg")))
self.setPalette(palette)'''
self.setStyleSheet("background-color:#2D4080;")
self.title = "Indoor Navigation"
self.setWindowTitle(self.title)
#title label
self.label1 = QLabel(self)
pixmap = QPixmap(filename + 'cover\\title.png')
self.label1.setPixmap(pixmap)
self.label1.resize(pixmap.width(), pixmap.height())
self.label1.move(195, 130)
self.label1.setAlignment(QtCore.Qt.AlignCenter)
self.label1.setStyleSheet("border:none; background:transparent")
#map
self.label2 = QLabel(self)
pixmap = QPixmap(filename + 'building_map.jpg')
self.label2.setPixmap(pixmap)
self.label2.resize(pixmap.width(), pixmap.height())
self.label2.move(15, 110)
self.label2.setAlignment(QtCore.Qt.AlignCenter)
self.label2.setStyleSheet("border:none; background:transparent")
self.label2.setVisible(False)
#destination
self.label3 = QLabel(self)
pixmap = QPixmap(filename + 'des.png')
self.label3.setPixmap(pixmap)
self.label3.resize(316, 58)
self.label3.move(162, 550)
self.label3.setStyleSheet("border:none; background:transparent")
self.label3.setVisible(False)
#departure
self.label4 = QLabel(self)
pixmap = QPixmap(filename + 'depa.png')
self.label4.setPixmap(pixmap)
self.label4.resize(316, 58)
self.label4.move(162, 640)
self.label4.setStyleSheet("border:none; background:transparent")
self.label4.setVisible(False)
#video
self.label6 = QLabel(self)
t = QTransform()
t.rotate(90)
pixmap1 = QPixmap(filename + 'building_map_4.jpg')
pixmap1 = pixmap1.transformed(t)
self.label6.resize(pixmap1.width(), pixmap1.height())
self.label6.setScaledContents(True)
self.label6.move(30, 100)
self.label6.setAlignment(QtCore.Qt.AlignCenter)
self.label6.setPixmap(pixmap1)
self.label6.setStyleSheet("border:none; background:transparent")
self.label6.setVisible(False)
# destination text
self.label7 = QLabel(self)
self.label7.setStyleSheet("border:none; background:transparent")
self.label7.resize(100, 24)
self.label7.move(300, 567)
self.label7.setVisible(False)
# departure text
self.label8 = QLabel(self)
self.label8.setStyleSheet("border:none; background:transparent")
self.label8.resize(100, 24)
self.label8.move(300, 657)
self.label8.setVisible(False)
# cover picture
self.label9 = QLabel(self)
pixmap = QPixmap(filename + 'cover\\pic.png')
self.label9.setPixmap(pixmap)
self.label9.resize(pixmap.width(), pixmap.height())
self.label9.move(195, 290)
self.label9.setAlignment(QtCore.Qt.AlignCenter)
self.label9.setStyleSheet("border:none; background:transparent")
# cover slogan
self.label10 = QLabel(self)
pixmap = QPixmap(filename + 'cover\\Start Your Indoor Discovery.png')
self.label10.setPixmap(pixmap)
self.label10.resize(pixmap.width(), pixmap.height())
self.label10.move(185, 570)
self.label10.setStyleSheet("border:none; background:transparent")
# walk
self.label12 = QLabel(self)
pixmap = QPixmap(filename + 'walk1.png')
self.label12.setPixmap(pixmap)
self.label12.resize(pixmap.width(), pixmap.height())
self.label12.setStyleSheet("border:none; background:transparent")
self.label12.setVisible(False)
# introduction
self.label13 = QLabel(self)
pixmap = QPixmap(filename + 'dest_icon.png')
self.label13.setPixmap(pixmap)
self.label13.resize(pixmap.width(), pixmap.height())
self.label13.setStyleSheet("border:none; background:transparent")
self.label13.setVisible(False)
#error message
self.label5 = QLabel(self)
self.label5.setAlignment(QtCore.Qt.AlignCenter)
self.label5.resize(298, 37)
self.label5.move(171, 480)
self.label5.setStyleSheet("border:none; background:transparent")
self.label5.setVisible(False)
self.button1 = QPushButton(self) #RESET
self.button1.setIcon(QIcon(filename + 'reset.png'))
self.button1.setIconSize(QtCore.QSize(40, 40)) # 建立名字
self.button1.setStyleSheet("border:none")
self.button1.resize(40, 40)
self.button1.move(10, 15) # 移動位置
self.button1.clicked.connect(self.button1Clicked)
self.button1.setVisible(False)
self.button2 = QPushButton(self) #語音
self.button2.setIcon(QIcon(filename + 'record.png'))
self.button2.setIconSize(QtCore.QSize(85, 85))
self.button2.resize(85, 85)
self.button2.setStyleSheet("border:none")
self.button2.move(460, 805) # 移動位置
self.button2.clicked.connect(self.button2Clicked)
self.button2.setVisible(False)
self.button3 = QPushButton(self) #camera
self.button3.setIcon(QIcon(filename + 'camera.png'))
self.button3.setIconSize(QtCore.QSize(70, 70))
self.button3.resize(70, 70)
self.button3.setStyleSheet("border:none")
self.button3.move(110, 820) # 移動位置
self.button3.clicked.connect(self.button3Clicked)
self.button3.setVisible(False)
self.button4 = QPushButton(self) # START
self.button4.setIcon(QIcon(filename + 'group_start.png'))
self.button4.setIconSize(QtCore.QSize(100, 100))
self.button4.resize(100, 100)
self.button4.setStyleSheet("border:none")
self.button4.move(270, 800) # 移動位置
self.button4.clicked.connect(self.button4Clicked)
self.button4.setVisible(False)
self.button5 = QPushButton(self) # home
self.button5.setIcon(QIcon(filename + 'home.png'))
self.button5.setIconSize(QtCore.QSize(40, 40)) # 建立名字
self.button5.setStyleSheet("border:none")
self.button5.resize(40, 40)
self.button5.move(590, 15) # 移動位置
self.button5.clicked.connect(self.button5Clicked)
self.button5.setVisible(False)
self.button6 = QPushButton(self) # get start
self.button6.setIcon(QIcon(filename + 'cover\\start button.png'))
self.button6.setIconSize(QtCore.QSize(200, 76)) # 建立名字
self.button6.setStyleSheet("border:none; background:transparent")
self.button6.resize(200, 76)
self.button6.move(220, 670) # 移動位置
self.button6.clicked.connect(self.button6Clicked)
self.button7 = QPushButton(self) # question
self.button7.setIcon(QIcon(filename + 'cover\\question.png'))
self.button7.setIconSize(QtCore.QSize(60, 60)) # 建立名字
self.button7.setStyleSheet("border:none; background:transparent")
self.button7.resize(60, 60)
self.button7.move(80, 850) # 移動位置
self.button7.clicked.connect(self.button7Clicked)
self.button8 = QPushButton(self) # find
self.button8.setIcon(QIcon(filename + 'cover\\find.png'))
self.button8.setIconSize(QtCore.QSize(60, 60)) # 建立名字
self.button8.setStyleSheet("border:none; background:transparent")
self.button8.resize(60, 60)
self.button8.move(500, 850) # 移動位置
self.button8.clicked.connect(self.button8Clicked)
# introduction
self.label11 = QLabel(self)
self.label11.resize(394, 539)
self.label11.setStyleSheet("border:none; background:transparent")
self.label11.setVisible(False)
self.button9 = QPushButton(self) # close introduction
self.button9.setIcon(QIcon(filename + 'cover\\x.png'))
self.button9.setIconSize(QtCore.QSize(22, 23)) # 建立名字
self.button9.setStyleSheet("border:none; background:transparent")
self.button9.resize(22, 23)
self.button9.move(475, 120) # 移動位置
self.button9.clicked.connect(self.button9Clicked)
self.button9.setVisible(False)
def onSelect(self, text):
self.task_number = int(text[-1])
pixmap = QPixmap('formula{}.png'.format(self.task_number))
self.label.setPixmap(pixmap)
self.label.move((self.panelWidth - pixmap.width()) / 2, 50)
self.update()
def initDevice(self, flag, num):
metric_width = GetSystemMetrics(0)
metric_height = GetSystemMetrics(1) # 获取电脑分辨率
self.width = metric_width # 图片宽度
self.height = metric_height # 图片高度
self.pic_x = 40
self.pic_y = 200 # 图片起始点
# 设置信息显示区域
self.setWindowTitle("Cement Kiln")
self.widget = QWidget()
self.table = QTableWidget(0, 2) # 以表格形式显示数据
self.table.setMinimumHeight(100)
self.messageView = QTabWidget()
self.messageView.setMinimumHeight(100)
# self.resize(self.width,self.height)
self.table.horizontalHeader().setDefaultSectionSize(150)
self.messageSplitter = QSplitter(Qt.Vertical)
self.messageSplitter.addWidget(self.table)
self.messageSplitter.addWidget(self.messageView)
# self.messageSplitter.addWidget(self.functionList)
self.mainSplitter = QSplitter(Qt.Horizontal)
self.mainSplitter.addWidget(self.widget)
self.mainSplitter.addWidget(self.messageSplitter)
self.setCentralWidget(self.mainSplitter)
self.table.setMaximumHeight(300)
self.tab1 = QLabel()
self.tab2 = QLabel()
self.messageView.addTab(self.tab1, '温度')
self.messageView.addTab(self.tab2, '压强')
self.pic1 = QVBoxLayout(self.tab1)
self.pic2 = QVBoxLayout(self.tab2)
self.click_flag = 0 # 切换图片标志
xft_dl = QPixmap('picture\\xft_dl.png') # 旋风筒
xft_zuo = QPixmap('picture\\xft_zuo.png') # 旋风筒左管
xft_you = QPixmap('picture\\xft_you.png') # 旋风筒右管
fjl = QPixmap('picture\\fjl.png') # 分解炉
blj = QPixmap('picture\\blj.png') # 篦冷机
fjl_yao = QPixmap('picture\\fjl_yao') # 分解炉与窑之间的连接部件
mfc = QPixmap('picture\\mfc.png') # 煤粉仓
gwfj = QPixmap('picture\\gwfj.png') # 高温风机
yao = QPixmap('picture\\yao.png')
ratio = 0.3 # 图片放大倍数
self.widget.autoFillBackground()
number = int(num)
self.xft = {}
self.xft[0] = MyLabel()
self.xft[0].setPixmap(
xft_dl.scaled(xft_dl.width() * ratio,
xft_dl.height() * ratio))
self.xft[0].setObjectName('%d级筒A' % 1)
self.xft[0].changeindex.connect(self.change_pic)
# print(self.xft[0].objectName())
self.xft[number] = MyLabel()
self.xft[number].setPixmap(
xft_dl.scaled(xft_dl.width() * ratio,
xft_dl.height() * ratio))
self.xft[number].setObjectName('%d级筒A' % number)
self.xft[number].changeindex.connect(self.change_pic)
for i in arange(1, number, 2): # 不会取到number,奇数旋风筒为右管
self.xft[i] = MyLabel()
self.xft[i].setPixmap(
xft_you.scaled(xft_you.width() * ratio,
xft_you.height() * ratio))
self.xft[i].setObjectName('%d级筒A' % i)
self.xft[i].changeindex.connect(self.change_pic)
for i in arange(2, number, 2): # 偶数旋风筒为左管
self.xft[i] = MyLabel()
self.xft[i].setPixmap(
xft_zuo.scaled(xft_zuo.width() * ratio,
xft_zuo.height() * ratio))
self.xft[i].setObjectName('%d级筒A' % i)
self.xft[i].changeindex.connect(self.change_pic)
if flag == 2: # 双系列
self.xft[number + 1] = MyLabel()
self.xft[number + 1].setPixmap(
xft_dl.scaled(xft_dl.width() * ratio,
xft_dl.height() * ratio))
self.xft[number + 1].setObjectName('%d级筒B' % 1)
self.xft[number + 1].changeindex.connect(self.change_pic)
# print(self.xft[0].objectName())
self.xft[2 * number + 1] = MyLabel()
self.xft[2 * number + 1].setPixmap(
xft_dl.scaled(xft_dl.width() * ratio,
xft_dl.height() * ratio))
self.xft[2 * number + 1].setObjectName('%d级筒B' % number)
self.xft[2 * number + 1].changeindex.connect(self.change_pic)
for i in arange(number + 2, 2 * number + 1,
2): # 不会取到2*number,奇数旋风筒为左管
print(i)
self.xft[i] = MyLabel()
self.xft[i].setPixmap(
xft_zuo.scaled(xft_zuo.width() * ratio,
xft_zuo.height() * ratio))
self.xft[i].setObjectName('%d级筒B' % (i % (number + 1)))
self.xft[i].changeindex.connect(self.change_pic)
for i in arange(number + 3, 2 * number + 1, 2): # 偶数旋风筒为右管
print(i)
self.xft[i] = MyLabel()
self.xft[i].setPixmap(
xft_you.scaled(xft_you.width() * ratio,
xft_you.height() * ratio))
self.xft[i].setObjectName('%d级筒B' % (i % (number + 1)))
self.xft[i].changeindex.connect(self.change_pic)
self.lab_fjl = MyLabel()
if number % 2 == 0:
self.lab_fjl.setPixmap(
fjl.scaled(xft_dl.width() * 5 * ratio,
xft_dl.height() * 3 * ratio))
else:
self.lab_fjl.setPixmap(
fjl.scaled(xft_dl.width() * 7 * ratio,
xft_dl.height() * 3 * ratio))
self.lab_fjl.setObjectName('分解炉')
self.lab_fjl.changeindex.connect(self.change_pic)
self.lab_yao = MyLabel()
self.lab_yao.setPixmap(
yao.scaled(xft_dl.width() * 9 * ratio,
yao.height() * ratio))
self.lab_yao.setObjectName('窑')
self.lab_yao.changeindex.connect(self.change_pic)
self.lab_blj = MyLabel()
self.lab_blj.setPixmap(
blj.scaled(blj.width() * ratio,
blj.height() * ratio))
self.lab_blj.setObjectName('篦冷机')
self.lab_blj.changeindex.connect(self.change_pic)
self.fjl_yao = MyLabel()
self.fjl_yao.setPixmap(
fjl_yao.scaled(xft_dl.width() * ratio,
fjl_yao.height() * ratio))
self.fjl_yao.setObjectName('分解炉--窑')
lay = QGridLayout()
xft_row = 1 # 旋风筒所占行数
xft_col = 2 # 旋风筒所占列数
fjl_row = 3 # 分解炉所占行数
fjl_col = 5 # 分解炉所占列数
lay.addWidget(self.xft[0], 0, 0)
for i in arange(1, number):
lay.addWidget(self.xft[i], i - 1, 1, xft_row, xft_col)
if number % 2 == 0:
lay.addWidget(self.lab_fjl, number - 2, 2, fjl_row, fjl_col) # 分解炉
lay.addWidget(self.xft[number], number - 1, 2)
lay.addWidget(self.fjl_yao, number - 2 + fjl_row,
(fjl_col - 1) / 2 + 2) # 连接件
lay.addWidget(self.lab_yao, number - 2 + fjl_row,
(fjl_col - 1) / 2 + 3, 2, 9) # 窑
lay.addWidget(self.lab_blj, number - 2 + fjl_row, 16, 2, 3) # 篦冷机
else:
lay.addWidget(self.lab_fjl, number - 2, 1, fjl_row,
fjl_col + 2) # 分解炉
lay.addWidget(self.xft[number], number - 1, 1)
lay.addWidget(self.fjl_yao, number - 2 + fjl_row,
(fjl_col - 1) / 2 + 2) # 连接件
lay.addWidget(self.lab_yao, number - 2 + fjl_row,
(fjl_col - 1) / 2 + 3, 2, 9) # 窑
lay.addWidget(self.lab_blj, number - 2 + fjl_row, 16, 2, 3) # 篦冷机
if flag == 2:
lay.addWidget(self.xft[number + 1], 0, 10 - flag)
for i in arange(number + 2, 2 * number + 1):
# print(i)
lay.addWidget(self.xft[i], (i - 2) % number, 8 - flag, xft_row,
xft_col)
if number % 2 == 0:
lay.addWidget(self.xft[number * 2 + 1], number - 1, 8 - flag)
else:
lay.addWidget(self.xft[number * 2 + 1], number - 1, 9 - flag)
lay.setSpacing(0)
lay.setAlignment(Qt.AlignLeft | Qt.AlignCenter)
self.widget.setLayout(lay)
self.initBtn() # 初始化时间选择控件
class RemMainWindow(QWidget):
def __init__(self):
super().__init__()
rem_bk_pic_path = './source/pic/rem_bk.png'
rem_ico_path = './source/pic/rem.png'
self.pix = QPixmap(rem_bk_pic_path)
self.resize(self.pix.width(), self.pix.height())
self.pix = self.pix.scaled(int(self.pix.width()),
int(self.pix.height()))
self.setMask(self.pix.mask())
screen = QDesktopWidget().screenGeometry()
self.move(screen.width() - self.pix.width() * 2,
screen.height() - self.pix.height() * 2)
self.setWindowFlags(Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint)
self.setAttribute(Qt.WA_TranslucentBackground)
self.rem_icon = QIcon(QPixmap(rem_ico_path))
self.setWindowIcon(self.rem_icon)
self.m_DragPosition = None
self.tool = ToolWindow(self.x() + self.width(), self.y())
self.tool_enable = False
self.monitor = Monitor()
def paintEvent(self, event):
paint = QPainter(self)
paint.drawPixmap(0, 0, self.pix.width(), self.pix.height(), self.pix)
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.m_drag = True
self.m_DragPosition = event.globalPos() - self.pos()
event.accept()
self.setCursor(QCursor(Qt.OpenHandCursor))
if self.tool_enable:
self.tool.raise_()
if event.button() == Qt.RightButton:
if self.tool_enable == True:
self.tool.close()
self.tool_enable = False
self.trayEvent()
def mouseMoveEvent(self, event):
if Qt.LeftButton and self.m_drag:
self.move(event.globalPos() - self.m_DragPosition)
self.tool.move(self.x() + self.width(), self.y())
event.accept()
def mouseReleaseEvent(self, event):
self.m_drag = False
self.setCursor(QCursor(Qt.ArrowCursor))
def mouseDoubleClickEvent(self, event):
if self.tool_enable == False:
self.tool.show()
self.tool_enable = True
else:
self.tool.close()
self.tool_enable = False
def closeEvent(self, event):
if self.tool_enable == True:
self.tool.close()
def trayEvent(self):
self.hide()
self.mSysTrayIcon = QSystemTrayIcon(self)
self.mSysTrayIcon.setIcon(self.rem_icon)
self.mSysTrayIcon.setToolTip("追番小工具")
self.mSysTrayIcon.activated.connect(self.onActivated)
self.tray_menu = QMenu(QApplication.desktop())
self.quitAction = QAction(u'退出', self, triggered=qApp.quit)
self.tray_menu.addAction(self.quitAction)
self.mSysTrayIcon.setContextMenu(self.tray_menu)
self.mSysTrayIcon.show()
def onActivated(self, reason):
if reason == self.mSysTrayIcon.Trigger:
self.show()
self.mSysTrayIcon.hide()
class PixmapKeyboard(QWidget):
# signals
noteOn = pyqtSignal(int)
noteOff = pyqtSignal(int)
notesOn = pyqtSignal()
notesOff = pyqtSignal()
def __init__(self, parent):
QWidget.__init__(self, parent)
self.fEnabledKeys = []
self.fLastMouseNote = -1
self.fStartOctave = 0
self.fPcKeybOffset = 2
self.fInitalizing = True
self.fFont = self.font()
self.fFont.setFamily("Monospace")
self.fFont.setPixelSize(12)
self.fFont.setBold(True)
self.fPixmapNormal = QPixmap(":/bitmaps/kbd_normal.png")
self.fPixmapDown = QPixmap(":/bitmaps/kbd_down-blue.png")
self.fHighlightColor = kValidColors[0]
self.fkPcKeyLayout = "qwerty"
self.fkPcKeys = kPcKeysLayouts["qwerty"]
self.fKey2RectMap = kMidiKey2RectMapHorizontal
self.fWidth = self.fPixmapNormal.width()
self.fHeight = self.fPixmapNormal.height()
self.setCursor(Qt.PointingHandCursor)
self.setStartOctave(0)
self.setOctaves(6)
self.loadSettings()
self.fInitalizing = False
def saveSettings(self):
if self.fInitalizing:
return
settings = QSafeSettings("falkTX", "CarlaKeyboard")
settings.setValue("PcKeyboardLayout", self.fkPcKeyLayout)
settings.setValue("PcKeyboardOffset", self.fPcKeybOffset)
settings.setValue("HighlightColor", self.fHighlightColor)
del settings
def loadSettings(self):
settings = QSafeSettings("falkTX", "CarlaKeyboard")
self.setPcKeyboardLayout(
settings.value("PcKeyboardLayout", self.fkPcKeyLayout, str))
self.setPcKeyboardOffset(
settings.value("PcKeyboardOffset", self.fPcKeybOffset, int))
self.setColor(
settings.value("HighlightColor", self.fHighlightColor, str))
del settings
def allNotesOff(self, sendSignal=True):
self.fEnabledKeys = []
if sendSignal:
self.notesOff.emit()
self.update()
def sendNoteOn(self, note, sendSignal=True):
if 0 <= note <= 127 and note not in self.fEnabledKeys:
self.fEnabledKeys.append(note)
if sendSignal:
self.noteOn.emit(note)
self.update()
if len(self.fEnabledKeys) == 1:
self.notesOn.emit()
def sendNoteOff(self, note, sendSignal=True):
if 0 <= note <= 127 and note in self.fEnabledKeys:
self.fEnabledKeys.remove(note)
if sendSignal:
self.noteOff.emit(note)
self.update()
if len(self.fEnabledKeys) == 0:
self.notesOff.emit()
def setColor(self, color):
if color not in kValidColors:
return
if self.fHighlightColor == color:
return
self.fHighlightColor = color
self.fPixmapDown.load(":/bitmaps/kbd_down-{}.png".format(
color.lower()))
self.saveSettings()
def setPcKeyboardLayout(self, layout):
if layout not in kPcKeysLayouts.keys():
return
if self.fkPcKeyLayout == layout:
return
self.fkPcKeyLayout = layout
self.fkPcKeys = kPcKeysLayouts[layout]
self.saveSettings()
def setPcKeyboardOffset(self, offset):
if offset < 0:
offset = 0
elif offset > 9:
offset = 9
if self.fPcKeybOffset == offset:
return
self.fPcKeybOffset = offset
self.saveSettings()
def setOctaves(self, octaves):
if octaves < 1:
octaves = 1
elif octaves > 10:
octaves = 10
self.fOctaves = octaves
self.setMinimumSize(self.fWidth * self.fOctaves, self.fHeight)
self.setMaximumSize(self.fWidth * self.fOctaves, self.fHeight)
def setStartOctave(self, octave):
if octave < 0:
octave = 0
elif octave > 9:
octave = 9
if self.fStartOctave == octave:
return
self.fStartOctave = octave
self.update()
def handleMousePos(self, pos):
if pos.x() < 0 or pos.x() > self.fOctaves * self.fWidth:
return
octave = int(pos.x() / self.fWidth)
keyPos = QPointF(pos.x() % self.fWidth, pos.y())
if self.fKey2RectMap[1].contains(keyPos): # C#
note = 1
elif self.fKey2RectMap[3].contains(keyPos): # D#
note = 3
elif self.fKey2RectMap[6].contains(keyPos): # F#
note = 6
elif self.fKey2RectMap[8].contains(keyPos): # G#
note = 8
elif self.fKey2RectMap[10].contains(keyPos): # A#
note = 10
elif self.fKey2RectMap[0].contains(keyPos): # C
note = 0
elif self.fKey2RectMap[2].contains(keyPos): # D
note = 2
elif self.fKey2RectMap[4].contains(keyPos): # E
note = 4
elif self.fKey2RectMap[5].contains(keyPos): # F
note = 5
elif self.fKey2RectMap[7].contains(keyPos): # G
note = 7
elif self.fKey2RectMap[9].contains(keyPos): # A
note = 9
elif self.fKey2RectMap[11].contains(keyPos): # B
note = 11
else:
note = -1
if note != -1:
note += (self.fStartOctave + octave) * 12
if self.fLastMouseNote != note:
self.sendNoteOff(self.fLastMouseNote)
self.sendNoteOn(note)
elif self.fLastMouseNote != -1:
self.sendNoteOff(self.fLastMouseNote)
self.fLastMouseNote = note
def showOptions(self, event):
event.accept()
menu = QMenu()
menu.addAction("Note: restart carla to apply globally").setEnabled(
False)
menu.addSeparator()
menuColor = QMenu("Highlight color", menu)
menuLayout = QMenu("PC Keyboard layout", menu)
actColors = []
actLayouts = []
for color in kValidColors:
act = menuColor.addAction(color)
act.setCheckable(True)
if self.fHighlightColor == color:
act.setChecked(True)
actColors.append(act)
for pcKeyLayout in kPcKeysLayouts.keys():
act = menuLayout.addAction(pcKeyLayout)
act.setCheckable(True)
if self.fkPcKeyLayout == pcKeyLayout:
act.setChecked(True)
actLayouts.append(act)
menu.addMenu(menuColor)
menu.addMenu(menuLayout)
menu.addSeparator()
actOctaveUp = menu.addAction("PC Keyboard octave up")
actOctaveDown = menu.addAction("PC Keyboard octave down")
if self.fPcKeybOffset == 0:
actOctaveDown.setEnabled(False)
actSelected = menu.exec_(event.screenPos().toPoint())
if not actSelected:
return
if actSelected in actColors:
return self.setColor(actSelected.text())
if actSelected in actLayouts:
return self.setPcKeyboardLayout(actSelected.text())
if actSelected == actOctaveUp:
return self.setPcKeyboardOffset(self.fPcKeybOffset + 1)
if actSelected == actOctaveDown:
return self.setPcKeyboardOffset(self.fPcKeybOffset - 1)
def minimumSizeHint(self):
return QSize(self.fWidth, self.fHeight)
def sizeHint(self):
return QSize(self.fWidth * self.fOctaves, self.fHeight)
def keyPressEvent(self, event):
if not event.isAutoRepeat():
try:
qKey = str(event.key())
index = self.fkPcKeys.index(qKey)
except:
pass
else:
self.sendNoteOn(index + (self.fPcKeybOffset * 12))
QWidget.keyPressEvent(self, event)
def keyReleaseEvent(self, event):
if not event.isAutoRepeat():
try:
qKey = str(event.key())
index = self.fkPcKeys.index(qKey)
except:
pass
else:
self.sendNoteOff(index + (self.fPcKeybOffset * 12))
QWidget.keyReleaseEvent(self, event)
def mousePressEvent(self, event):
if event.button() == Qt.RightButton:
self.showOptions(event)
else:
self.fLastMouseNote = -1
self.handleMousePos(event.pos())
self.setFocus()
QWidget.mousePressEvent(self, event)
def mouseMoveEvent(self, event):
if event.button() != Qt.RightButton:
self.handleMousePos(event.pos())
QWidget.mouseMoveEvent(self, event)
def mouseReleaseEvent(self, event):
if self.fLastMouseNote != -1:
self.sendNoteOff(self.fLastMouseNote)
self.fLastMouseNote = -1
QWidget.mouseReleaseEvent(self, event)
def paintEvent(self, event):
painter = QPainter(self)
event.accept()
# -------------------------------------------------------------
# Paint clean keys (as background)
for octave in range(self.fOctaves):
target = QRectF(self.fWidth * octave, 0, self.fWidth, self.fHeight)
source = QRectF(0, 0, self.fWidth, self.fHeight)
painter.drawPixmap(target, self.fPixmapNormal, source)
if not self.isEnabled():
painter.setBrush(QColor(0, 0, 0, 150))
painter.setPen(QColor(0, 0, 0, 150))
painter.drawRect(0, 0, self.width(), self.height())
return
# -------------------------------------------------------------
# Paint (white) pressed keys
paintedWhite = False
for note in self.fEnabledKeys:
pos = self._getRectFromMidiNote(note)
if self._isNoteBlack(note):
continue
if note < 12:
octave = 0
elif note < 24:
octave = 1
elif note < 36:
octave = 2
elif note < 48:
octave = 3
elif note < 60:
octave = 4
elif note < 72:
octave = 5
elif note < 84:
octave = 6
elif note < 96:
octave = 7
elif note < 108:
octave = 8
elif note < 120:
octave = 9
elif note < 132:
octave = 10
else:
# cannot paint this note
continue
octave -= self.fStartOctave
target = QRectF(pos.x() + (self.fWidth * octave), 0, pos.width(),
pos.height())
source = QRectF(pos.x(), 0, pos.width(), pos.height())
paintedWhite = True
painter.drawPixmap(target, self.fPixmapDown, source)
# -------------------------------------------------------------
# Clear white keys border
if paintedWhite:
for octave in range(self.fOctaves):
for note in kBlackNotes:
pos = self._getRectFromMidiNote(note)
target = QRectF(pos.x() + (self.fWidth * octave), 0,
pos.width(), pos.height())
source = QRectF(pos.x(), 0, pos.width(), pos.height())
painter.drawPixmap(target, self.fPixmapNormal, source)
# -------------------------------------------------------------
# Paint (black) pressed keys
for note in self.fEnabledKeys:
pos = self._getRectFromMidiNote(note)
if not self._isNoteBlack(note):
continue
if note < 12:
octave = 0
elif note < 24:
octave = 1
elif note < 36:
octave = 2
elif note < 48:
octave = 3
elif note < 60:
octave = 4
elif note < 72:
octave = 5
elif note < 84:
octave = 6
elif note < 96:
octave = 7
elif note < 108:
octave = 8
elif note < 120:
octave = 9
elif note < 132:
octave = 10
else:
# cannot paint this note
continue
octave -= self.fStartOctave
target = QRectF(pos.x() + (self.fWidth * octave), 0, pos.width(),
pos.height())
source = QRectF(pos.x(), 0, pos.width(), pos.height())
painter.drawPixmap(target, self.fPixmapDown, source)
# Paint C-number note info
painter.setFont(self.fFont)
painter.setPen(Qt.black)
for i in range(self.fOctaves):
octave = self.fStartOctave + i - 1
painter.drawText(i * 168 + (4 if octave == -1 else 3), 35, 20, 20,
Qt.AlignCenter, "C{}".format(octave))
def _isNoteBlack(self, note):
baseNote = note % 12
return bool(baseNote in kBlackNotes)
def _getRectFromMidiNote(self, note):
baseNote = note % 12
return self.fKey2RectMap[baseNote]
class MyWindow(QMainWindow):
def __init__(self):
super(MyWindow, self).__init__()
self.setWindowTitle("Processamento Digital de Imagens - IFTM")
self.icon = self.setWindowIcon(QIcon("icones/icon.jpg"))
self.setGeometry(450, 150, 800, 600)
self.initUI()
self.listaFiltrosUsados = []
self.show()
def initUI(self):
self.criarWidgets()
self.gerarLayouts()
def criarWidgets(self):
# Criar a barra de menu
self.barraMenu = self.menuBar()
# Criar menus
self.menuArquivo = self.barraMenu.addMenu("&Arquivo")
self.menuTransformacao = self.barraMenu.addMenu("&Transformações")
self.menuSobre = self.barraMenu.addMenu("So&bre")
# Crias as actions
self.opcaoAbrir = self.menuArquivo.addAction("A&brir")
self.opcaoAbrir.triggered.connect(self.abrirImagem)
self.opcaoAbrir.setShortcut("Ctrl+A")
self.opcaoRecente = self.menuArquivo.addMenu("Abrir &Recente")
self.abrirRecente = self.opcaoRecente.addAction("arquivos...")
self.abrirRecente.setDisabled(True)
self.opcaoSalvarComo = self.menuArquivo.addAction("&Salvar como")
self.opcaoSalvarComo.triggered.connect(self.salvarImagemComo)
self.opcaoSalvarComo.setShortcut("Ctrl+S")
self.opcaoSalvarComo.setDisabled(True)
self.menuArquivo.addSeparator()
self.opcaoFechar = self.menuArquivo.addAction("F&echar")
self.opcaoFechar.setShortcut("Ctrl+X")
self.opcaoFechar.triggered.connect(self.close)
self.criarSubmenus()
self.opcaoSobre = self.menuSobre.addAction("S&obre o Aplicativo")
self.opcaoSobre.triggered.connect(self.mostrarInformacoesSobre)
self.opcaoInfoImagem = self.menuSobre.addAction(
"&Informacões da Imagem")
self.opcaoInfoImagem.triggered.connect(self.mostrarInformacoesSobre)
self.opcaoInfoImagem.setVisible(False)
# Criar barra de status
self.barraStatus = self.statusBar()
self.barraStatus.showMessage("Seja bem-vindo(a) ao meu aplicativo",
3000)
# Criando a barra de progresso
self.barraProgresso = QProgressBar()
# Timer
self.timer = QTimer()
# self.timer.setInterval(1000)
# Criando Labels
self.barraProgressoTexto = QLabel("Progresso da Transformação...")
# Criando imagens
self.imagemOriginal = QLabel()
self.endImagemOriginal = ''
self.endImagemResultado = ''
def criarSubmenus(self):
self.criarSubmenuAjustarNitidez()
self.criarSubmenuConversao()
self.criarSubmenuDecomporCanaisRGB()
self.criarSubmenuDesfocar()
self.criarSubmenuDeteccaoDeBordas()
self.criarSubmenuInverterCores()
self.criarSubmenuRealcarIntensidade()
self.criarSubmenuMorfologicas()
self.criarListasChecagemFiltros()
def criarSubmenuAjustarNitidez(self):
# Submenu
self.submenuAjustarNitidez = self.menuTransformacao.addMenu(
"Ajustar Nitide&z")
self.submenuAjustarNitidez.setDisabled(True)
# Actions do submenu
self.criarActionFiltroSharpen()
def criarSubmenuRealcarIntensidade(self):
# Submenu
self.submenuRealcarIntensidade = self.menuTransformacao.addMenu(
"Real&çar Intensidade")
self.submenuRealcarIntensidade.setDisabled(True)
# Actions do submenu
self.criarActionCorrecaoGama()
self.criarActionTransformacaoLogaritmica()
def criarSubmenuConversao(self):
# Submenu
self.submenuConversao = self.menuTransformacao.addMenu("Con&verter")
self.submenuConversao.setDisabled(True)
# Actions do submenu
self.criarActionConverterParaEscalaCinza()
self.criarActionConverterParaPretoBranco()
def criarSubmenuDecomporCanaisRGB(self):
# Submenu
self.submenuDecomposicaoCanaisRGB = self.menuTransformacao.addMenu(
"Decomposição &Canais RGB")
self.submenuDecomposicaoCanaisRGB.setDisabled(True)
# Actions do submenu
self.criarActionDecomporCanalR()
self.criarActionDecomporCanalG()
self.criarActionDecomporCanalB()
def criarSubmenuDesfocar(self):
# Submenu
self.submenuFiltrosDesfocar = self.menuTransformacao.addMenu(
"Des&focar")
self.submenuFiltrosDesfocar.setDisabled(True)
# Criar novo submenu
self.criarSubmenuFiltroGaussiano()
# Actions do submenu
self.criarActionFiltroMediana()
def criarSubmenuDeteccaoDeBordas(self):
# Submenu
self.submenuFiltrosDeteccaoBordas = self.menuTransformacao.addMenu(
"&Detectar Bordas")
self.submenuFiltrosDeteccaoBordas.setDisabled(True)
# Actions do submenu
self.criarActionEdgeDetection()
self.criarActionFiltroSobel()
self.criarActionDeteccaoDeBordasDilatacao()
self.criarActionDeteccaoDeBordasErosao()
def criarSubmenuFiltroGaussiano(self):
# Submenu
self.submenuFiltroGaussiano = self.submenuFiltrosDesfocar.addMenu(
"Filtro Ga&ussiano")
self.submenuFiltroGaussiano.setDisabled(True)
# Actions do submenu
self.criarActionKernelGaussiano3x3()
self.criarActionKernelGaussiano5x5()
self.criarActionKernelGaussiano7x7()
def criarSubmenuInverterCores(self):
# Submenu
self.submenuInverterCores = self.menuTransformacao.addMenu(
"Inverter Cores")
self.submenuInverterCores.setDisabled(True)
# Actions do submenu
self.criarActionInverterNegativo()
def criarSubmenuMorfologicas(self):
# Submenu
self.submenuMorfologicas = self.menuTransformacao.addMenu(
"&Morfológicas")
self.submenuMorfologicas.setDisabled(True)
# Actions do submenu
self.criarActionFiltroAbertura()
self.criarActionFiltroDilatacao()
self.criarActionFiltroErosao()
self.criarActionFiltroFechamento()
def criarActionFiltroAbertura(self):
self.filtroAbertura = self.submenuMorfologicas.addAction("&Abertura")
self.filtroAbertura.setShortcut("Ctrl+Alt+A")
self.filtroAbertura.setDisabled(True)
self.filtroAbertura.setCheckable(True)
self.filtroAbertura.setChecked(False)
self.filtroAbertura.triggered.connect(lambda: self.transformarImagem(
self.filtroAbertura, 'Abertura', '.pbm', 'ArgumentoVazio'))
def criarActionConverterParaEscalaCinza(self):
self.converterParaEscalaCinza = self.submenuConversao.addAction(
"&Cinza")
self.converterParaEscalaCinza.setShortcut("Ctrl+Alt+Z")
self.converterParaEscalaCinza.setDisabled(True)
self.converterParaEscalaCinza.setCheckable(True)
self.converterParaEscalaCinza.setChecked(False)
self.converterParaEscalaCinza.triggered.connect(
lambda: self.transformarImagem(self.converterParaEscalaCinza,
'ConverterEscalaDeCinza', '.pgm',
'ArgumentoVazio'))
def criarActionConverterParaPretoBranco(self):
self.converterParaPretoBranco = self.submenuConversao.addAction(
"Pre&to e Branco")
self.converterParaPretoBranco.setShortcut("Ctrl+Shift+T")
self.converterParaPretoBranco.setDisabled(True)
self.converterParaPretoBranco.setCheckable(True)
self.converterParaPretoBranco.setChecked(False)
self.converterParaPretoBranco.triggered.connect(
self.janelaValorLimitePretoBranco)
def criarActionCorrecaoGama(self):
self.correcaoGama = self.submenuRealcarIntensidade.addAction(
"Correção &Gama")
self.correcaoGama.setShortcut("Ctrl+Shift+G")
self.correcaoGama.setDisabled(True)
self.correcaoGama.setCheckable(True)
self.correcaoGama.setChecked(False)
self.correcaoGama.triggered.connect(self.janelaValorCorrecaoGama)
def criarActionDecomporCanalR(self):
self.decomporCanalR = self.submenuDecomposicaoCanaisRGB.addAction(
"Vermelho")
self.decomporCanalR.setShortcut("Ctrl+Alt+R")
self.decomporCanalR.setCheckable(True)
self.decomporCanalR.setChecked(False)
self.decomporCanalR.triggered.connect(lambda: self.transformarImagem(
self.decomporCanalR, 'CamadaR', '.ppm', 'ArgumentoVazio'))
def criarActionDecomporCanalG(self):
self.decomporCanalG = self.submenuDecomposicaoCanaisRGB.addAction(
"Verde")
self.decomporCanalG.setShortcut("Ctrl+Alt+G")
self.decomporCanalG.setCheckable(True)
self.decomporCanalG.setChecked(False)
self.decomporCanalG.triggered.connect(lambda: self.transformarImagem(
self.decomporCanalG, 'CamadaG', '.ppm', 'ArgumentoVazio'))
def criarActionDecomporCanalB(self):
self.decomporCanalB = self.submenuDecomposicaoCanaisRGB.addAction(
"Azul")
self.decomporCanalB.setShortcut("Ctrl+Alt+B")
self.decomporCanalB.setCheckable(True)
self.decomporCanalB.setChecked(False)
self.decomporCanalB.triggered.connect(lambda: self.transformarImagem(
self.decomporCanalB, 'CamadaB', '.ppm', 'ArgumentoVazio'))
def criarActionEdgeDetection(self):
self.deteccaoDeBordasFiltroFloresta = self.submenuFiltrosDeteccaoBordas.addAction(
"Filtro &Floresta")
self.deteccaoDeBordasFiltroFloresta.setShortcut("Ctrl+Alt+C")
self.deteccaoDeBordasFiltroFloresta.setCheckable(True)
self.deteccaoDeBordasFiltroFloresta.setChecked(False)
self.deteccaoDeBordasFiltroFloresta.triggered.connect(
lambda: self.transformarImagem(
self.deteccaoDeBordasFiltroFloresta, 'EdgeDetection', self.
extensaoImagemOriginal, 'ArgumentoVazio'))
def criarActionDeteccaoDeBordasDilatacao(self):
self.deteccaoDeBordasDilatacao = self.submenuFiltrosDeteccaoBordas.addAction(
"Filtro Detecção com &Dilatação")
self.deteccaoDeBordasDilatacao.setShortcut("Ctrl+Alt+I")
self.deteccaoDeBordasDilatacao.setCheckable(True)
self.deteccaoDeBordasDilatacao.setChecked(False)
self.deteccaoDeBordasDilatacao.triggered.connect(
lambda: self.transformarImagem(
self.deteccaoDeBordasDilatacao, 'DeteccaoDeBordasDilatacao',
self.extensaoImagemOriginal, 'ArgumentoVazio'))
def criarActionDeteccaoDeBordasErosao(self):
self.deteccaoDeBordasErosao = self.submenuFiltrosDeteccaoBordas.addAction(
"Filtro Detecção com &Erosão")
self.deteccaoDeBordasErosao.setShortcut("Ctrl+Alt+O")
self.deteccaoDeBordasErosao.setCheckable(True)
self.deteccaoDeBordasErosao.setChecked(False)
self.deteccaoDeBordasErosao.triggered.connect(
lambda: self.transformarImagem(
self.deteccaoDeBordasErosao, 'DeteccaoDeBordasErosao', self.
extensaoImagemOriginal, 'ArgumentoVazio'))
def criarActionKernelGaussiano3x3(self):
self.kernelGaussiano3x3 = self.submenuFiltroGaussiano.addAction(
"Matriz 3x3")
self.kernelGaussiano3x3.setShortcut("Ctrl+Alt+3")
self.kernelGaussiano3x3.setCheckable(True)
self.kernelGaussiano3x3.setChecked(False)
self.kernelGaussiano3x3.triggered.connect(
lambda: self.transformarImagem(
self.kernelGaussiano3x3, 'Gaussiano3x3', self.
extensaoImagemOriginal, 'ArgumentoVazio'))
def criarActionKernelGaussiano5x5(self):
self.kernelGaussiano5x5 = self.submenuFiltroGaussiano.addAction(
"Matriz 5x5")
self.kernelGaussiano5x5.setShortcut("Ctrl+Alt+5")
self.kernelGaussiano5x5.setCheckable(True)
self.kernelGaussiano5x5.setChecked(False)
self.kernelGaussiano5x5.triggered.connect(
lambda: self.transformarImagem(
self.kernelGaussiano5x5, 'Gaussiano5x5', self.
extensaoImagemOriginal, 'ArgumentoVazio'))
def criarActionKernelGaussiano7x7(self):
self.kernelGaussiano7x7 = self.submenuFiltroGaussiano.addAction(
"Matriz 7x7")
self.kernelGaussiano7x7.setShortcut("Ctrl+Alt+7")
self.kernelGaussiano7x7.setCheckable(True)
self.kernelGaussiano7x7.setChecked(False)
self.kernelGaussiano7x7.triggered.connect(
lambda: self.transformarImagem(
self.kernelGaussiano7x7, 'Gaussiano7x7', self.
extensaoImagemOriginal, 'ArgumentoVazio'))
def criarActionFiltroDilatacao(self):
self.filtroDilatacao = self.submenuMorfologicas.addAction("&Dilatação")
self.filtroDilatacao.setShortcut("Ctrl+Alt+D")
self.filtroDilatacao.setDisabled(True)
self.filtroDilatacao.setCheckable(True)
self.filtroDilatacao.setChecked(False)
self.filtroDilatacao.triggered.connect(lambda: self.transformarImagem(
self.filtroDilatacao, 'Dilatacao', self.extensaoImagemOriginal,
'ArgumentoVazio'))
def criarActionFiltroErosao(self):
self.filtroErosao = self.submenuMorfologicas.addAction("&Erosão")
self.filtroErosao.setShortcut("Ctrl+Alt+E")
self.filtroErosao.setDisabled(True)
self.filtroErosao.setCheckable(True)
self.filtroErosao.setChecked(False)
self.filtroErosao.triggered.connect(lambda: self.transformarImagem(
self.filtroErosao, 'Erosao', self.extensaoImagemOriginal,
'ArgumentoVazio'))
def criarActionFiltroFechamento(self):
self.filtroFechamento = self.submenuMorfologicas.addAction(
"&Fechamento")
self.filtroFechamento.setShortcut("Ctrl+Alt+F")
self.filtroFechamento.setDisabled(True)
self.filtroFechamento.setCheckable(True)
self.filtroFechamento.setChecked(False)
self.filtroFechamento.triggered.connect(lambda: self.transformarImagem(
self.filtroFechamento, 'Fechamento', self.extensaoImagemOriginal,
'ArgumentoVazio'))
def criarActionFiltroMediana(self):
self.filtroMediana = self.submenuFiltrosDesfocar.addAction(
"Filtro &Mediana")
self.filtroMediana.setShortcut("Ctrl+Shift+M")
self.filtroMediana.setDisabled(True)
self.filtroMediana.setCheckable(True)
self.filtroMediana.setChecked(False)
self.filtroMediana.triggered.connect(lambda: self.transformarImagem(
self.filtroMediana, 'Mediana', self.extensaoImagemOriginal,
'ArgumentoVazio'))
def criarActionFiltroSharpen(self):
self.filtroSharpen = self.submenuAjustarNitidez.addAction(
"Filtro S&harpen")
self.filtroSharpen.setShortcut("Ctrl+Shift+H")
self.filtroSharpen.setDisabled(True)
self.filtroSharpen.setCheckable(True)
self.filtroSharpen.setChecked(False)
self.filtroSharpen.triggered.connect(lambda: self.transformarImagem(
self.filtroSharpen, 'Sharpen', self.extensaoImagemOriginal,
'ArgumentoVazio'))
def criarActionFiltroSobel(self):
self.filtroSobel = self.submenuFiltrosDeteccaoBordas.addAction(
"Filtro S&obel")
self.filtroSobel.setShortcut("Ctrl+Shift+O")
self.filtroSobel.setDisabled(True)
self.filtroSobel.setCheckable(True)
self.filtroSobel.setChecked(False)
self.filtroSobel.triggered.connect(self.janelaValorLimiteSobel)
def criarActionInverterNegativo(self):
self.filtroNegativo = self.submenuInverterCores.addAction("&Negativo")
self.filtroNegativo.setShortcut("Ctrl+Shift+N")
self.filtroNegativo.setDisabled(True)
self.filtroNegativo.setCheckable(True)
self.filtroNegativo.setChecked(False)
self.filtroNegativo.triggered.connect(lambda: self.transformarImagem(
self.filtroNegativo, 'Negativo', self.extensaoImagemOriginal,
'ArgumentoVazio'))
def criarActionTransformacaoLogaritmica(self):
self.transformacaoLogaritmica = self.submenuRealcarIntensidade.addAction(
"Transformação &Logarítmica")
self.transformacaoLogaritmica.setShortcut("Ctrl+Shift+L")
self.transformacaoLogaritmica.setDisabled(True)
self.transformacaoLogaritmica.setCheckable(True)
self.transformacaoLogaritmica.setChecked(False)
self.transformacaoLogaritmica.triggered.connect(
lambda: self.transformarImagem(
self.transformacaoLogaritmica, 'TransformacaoLogaritmica', self
.extensaoImagemOriginal, 'ArgumentoVazio'))
def criarListasChecagemFiltros(self):
self.listaFiltrosImgColoridaCinza = [
self.submenuAjustarNitidez, self.filtroSharpen,
self.submenuRealcarIntensidade, self.correcaoGama,
self.transformacaoLogaritmica, self.submenuConversao,
self.converterParaEscalaCinza, self.converterParaPretoBranco,
self.submenuFiltrosDesfocar, self.submenuFiltroGaussiano,
self.kernelGaussiano3x3, self.kernelGaussiano5x5,
self.kernelGaussiano7x7, self.filtroMediana,
self.submenuInverterCores, self.filtroNegativo,
self.submenuFiltrosDeteccaoBordas,
self.deteccaoDeBordasFiltroFloresta, self.filtroSobel,
self.submenuDecomposicaoCanaisRGB, self.decomporCanalR,
self.decomporCanalG, self.decomporCanalB
]
self.listaFiltrosImgPretoBranco = [
self.submenuFiltrosDeteccaoBordas,
self.deteccaoDeBordasFiltroFloresta,
self.deteccaoDeBordasDilatacao, self.deteccaoDeBordasErosao,
self.submenuMorfologicas, self.filtroAbertura,
self.filtroDilatacao, self.filtroErosao, self.filtroFechamento
]
def gerarLayouts(self):
# Criando janela
self.janelaAreaVisualizacao = QWidget(self)
self.setCentralWidget(self.janelaAreaVisualizacao)
# Criando os layouts
self.layoutPrincipal = QVBoxLayout()
self.layoutTopo = QVBoxLayout()
self.layoutRodape = QHBoxLayout()
# Adicionando os widgets
self.layoutTopo.addWidget(self.imagemOriginal)
self.layoutRodape.addWidget(self.barraProgressoTexto)
self.layoutRodape.addWidget(self.barraProgresso)
# Adicionando layouts filhos na janela principal
self.layoutPrincipal.addLayout(self.layoutTopo, 80)
self.layoutPrincipal.addLayout(self.layoutRodape, 20)
self.janelaAreaVisualizacao.setLayout(self.layoutPrincipal)
def abrirImagem(self):
global imagemResultado
ocultarDiretorioImgResultado()
global porcentagemProgresso
arquivoImagem, _ = QFileDialog.getOpenFileName(
self,
caption="Abrir Imagem",
directory=QtCore.QDir.currentPath(),
filter='Imagens(*.ppm; *.pgm; *.pbm)',
initialFilter='Imagens(*.ppm; *.pgm; *.pbm)')
if arquivoImagem:
excluirCopiaImgTransformada()
self.removerChecagemFiltrosUsados()
porcentagemProgresso = 0
self.barraProgresso.setValue(porcentagemProgresso)
self.endImagemOriginal = arquivoImagem
self.pixmapImagem = QPixmap(self.endImagemOriginal)
self.extensaoImagemOriginal = os.path.splitext(
os.path.basename(arquivoImagem))[1]
self.exibirImagem()
self.alterarVisibilidadeMenus()
def removerChecagemFiltrosUsados(self):
for filtro in self.listaFiltrosUsados:
filtro.setChecked(False)
self.listaFiltrosUsados.clear()
def alterarVisibilidadeMenus(self):
global extensaoImagemResultado
self.opcaoInfoImagem.setVisible(True)
self.opcaoSalvarComo.setDisabled(False)
if self.extensaoImagemOriginal == '.ppm':
if not self.listaFiltrosUsados:
for filtro in self.listaFiltrosImgColoridaCinza:
filtro.setDisabled(False)
self.submenuMorfologicas.setDisabled(True)
self.filtroAbertura.setDisabled(True)
self.filtroDilatacao.setDisabled(True)
self.deteccaoDeBordasDilatacao.setDisabled(True)
self.deteccaoDeBordasErosao.setDisabled(True)
elif self.extensaoImagemOriginal == '.pgm':
for filtro in self.listaFiltrosImgColoridaCinza:
filtro.setDisabled(False)
self.submenuDecomposicaoCanaisRGB.setDisabled(True)
self.decomporCanalR.setDisabled(True)
self.decomporCanalG.setDisabled(True)
self.decomporCanalB.setDisabled(True)
self.converterParaEscalaCinza.setDisabled(True)
self.submenuMorfologicas.setDisabled(True)
self.filtroAbertura.setDisabled(True)
self.filtroDilatacao.setDisabled(True)
self.deteccaoDeBordasDilatacao.setDisabled(True)
self.deteccaoDeBordasErosao.setDisabled(True)
elif self.extensaoImagemOriginal == '.pbm':
for filtro in self.listaFiltrosImgColoridaCinza:
filtro.setDisabled(True)
for filtro in self.listaFiltrosImgPretoBranco:
filtro.setDisabled(False)
def janelaValorCorrecaoGama(self):
self.janelaValorFatorGama = JanelaValorGama()
self.janelaValorFatorGama.enviarValor.clicked.connect(
self.pegarValorSliderGama)
def pegarValorSliderGama(self):
valorFatorGama = str(self.janelaValorFatorGama.valorSlider)
self.janelaValorFatorGama.close()
self.transformarImagem(self.correcaoGama, 'CorrecaoGama',
self.extensaoImagemOriginal, valorFatorGama)
def janelaValorLimiteSobel(self):
self.janelaValorLimiteSobel = JanelaValorLimiteSobel()
self.janelaValorLimiteSobel.enviarValor.clicked.connect(
self.pegarValorLimiteSobel)
def pegarValorLimiteSobel(self):
valorLimiteSobel = str(self.janelaValorLimiteSobel.valorSlider)
self.janelaValorLimiteSobel.close()
self.transformarImagem(self.filtroSobel, 'Sobel',
self.extensaoImagemOriginal, valorLimiteSobel)
def janelaValorLimitePretoBranco(self):
self.janelaValorLimitePretoBranco = JanelaValorLimitePretoBranco()
self.janelaValorLimitePretoBranco.enviarValor.clicked.connect(
self.pegarValorLimitePretoBranco)
def pegarValorLimitePretoBranco(self):
valorLimitePretoBranco = str(
self.janelaValorLimitePretoBranco.valorSlider)
self.janelaValorLimitePretoBranco.close()
self.transformarImagem(self.converterParaPretoBranco,
'ConverterImagemBinaria', '.pbm',
valorLimitePretoBranco)
def mostrarInformacoesSobre(self):
self.opcaoEscolhida = self.sender().text()
self.caixaMensagem = QMessageBox()
self.caixaMensagem.setIcon(QMessageBox.Information)
if self.opcaoEscolhida == "S&obre o Aplicativo":
self.caixaMensagem.setWindowTitle("Sobre o Aplicativo")
self.caixaMensagem.setText("Desenvolvido por Victor Rodrigues")
self.caixaMensagem.setInformativeText(
"Ipiaçu-MG, 01 de Agosto de 2020")
self.descricao = 'Este aplicativo tem como princípio a realização de transformações em imagens com extensão pgm, ppm e pbm e foi elaborado para o trabalho final da disciplina de Processamento Digital de Imagens no Curso Superior em Análise e Desenvolvimento de Sistemas do Instituto Federal de Educação, Ciência e Tecnologia do Triângulo Mineiro - IFTM'
self.caixaMensagem.setDetailedText(self.descricao)
self.caixaMensagem.exec_()
if self.opcaoEscolhida == "&Informacões da Imagem":
if self.endImagemOriginal != '':
self.caixaMensagem.setWindowTitle("Informações da Imagem")
self.extrairInfoImagem()
self.caixaMensagem.setText("Arquivo: " + self.nomeimagem + "\n" + "Tipo: " + self.tipoimagem +
"Comentário: " + self.comentarioimagem + "Largura: " + self.larguraimagem \
+ "\n" + "Altura: " + self.alturaimagem)
self.caixaMensagem.exec_()
def salvarImagemComo(self):
global extensaoImagemResultado
try:
if self.endImagemOriginal != '':
imagemSalvaComo, tipos = QFileDialog.getSaveFileName(
self,
caption='Salvar como',
directory=QtCore.QDir.currentPath(),
filter='Imagens(*.ppm; *.pgm; *.pbm)',
initialFilter='Imagens(*.ppm; *.pgm; *.pbm)')
if imagemSalvaComo:
self.parts = imagemSalvaComo.rpartition('/')
self.endereco = self.parts[0]
if self.endImagemResultado != '':
os.renames(
self.endImagemResultado,
self.endereco + '/' + os.path.splitext(
os.path.basename(imagemSalvaComo))[0] +
extensaoImagemResultado)
else:
os.renames(
self.endImagemOriginal,
self.endereco + '/' + os.path.splitext(
os.path.basename(imagemSalvaComo))[0] +
self.extensaoImagemOriginal)
except:
pass
def extrairInfoImagem(self):
try:
self.parts = self.endImagemOriginal.rpartition('/')
self.nomeimagem = self.parts[2]
self.leituraimagem = open(self.endImagemOriginal, "r+")
self.tipoimagem = self.leituraimagem.readline()
self.comentarioimagem = self.leituraimagem.readline()
self.dimensoesimagem = self.leituraimagem.readline()
self.dimensoesimagem = self.dimensoesimagem.split()
self.larguraimagem = self.dimensoesimagem[0]
self.alturaimagem = self.dimensoesimagem[1]
except:
pass
def transformarImagem(self, filtro, script, extensao, valorArgumento3):
global porcentagemProgresso
global imagemResultado
global extensaoImagemResultado
porcentagemProgresso = 0
self.barraProgresso.setValue(porcentagemProgresso)
self.filtroUsado = ''
if os.path.exists(imagemResultado + "Copia" + extensaoImagemResultado):
self.imagemEntrada = imagemResultado + "Copia" + extensaoImagemResultado
else:
self.imagemEntrada = self.endImagemOriginal
try:
if self.extensaoImagemOriginal == '.ppm':
self.script = 'filtrosDeTransformacao/colorida/' + script + '.py'
extensaoImagemResultado = extensao
self.filtroUsado = filtro
elif self.extensaoImagemOriginal == '.pgm':
self.script = 'filtrosDeTransformacao/escalaCinza/' + script + '.py'
extensaoImagemResultado = extensao
self.filtroUsado = filtro
elif self.extensaoImagemOriginal == '.pbm':
self.script = 'filtrosDeTransformacao/pretoBranco/' + script + '.py'
extensaoImagemResultado = extensao
self.filtroUsado = filtro
self.argumentos = 'python ' + self.script + ' \"' + self.imagemEntrada + '\" ' + \
imagemResultado + extensaoImagemResultado + ' \" ' + valorArgumento3
self.executarTransformacao = subprocess.run(self.argumentos,
shell=True)
while porcentagemProgresso < 100:
if self.executarTransformacao is not None:
porcentagemProgresso += 0.001
self.barraProgresso.setValue(int(porcentagemProgresso))
else:
break
self.endImagemResultado = imagemResultado + extensaoImagemResultado
self.pixmapImagem = QPixmap(self.endImagemResultado)
shutil.copyfile(
self.endImagemResultado,
imagemResultado + "Copia" + extensaoImagemResultado)
self.exibirImagem()
self.listaFiltrosUsados.append(self.filtroUsado)
self.extensaoImagemOriginal = extensaoImagemResultado
self.alterarVisibilidadeMenus()
self.barraStatus.showMessage(
"Aplicação " + self.filtroEscolhido.replace("&", "") +
" finalizada", 5000)
except:
pass
def exibirImagem(self):
if self.pixmapImagem.width() > int(GetSystemMetrics(0) / 2) or \
self.pixmapImagem.height() > int(GetSystemMetrics(1) / 2):
self.pixmapImagem = self.pixmapImagem.scaled(
int(GetSystemMetrics(0) / 2), int(GetSystemMetrics(1) / 2),
QtCore.Qt.KeepAspectRatio, QtCore.Qt.SmoothTransformation)
self.imagemOriginal.setPixmap(self.pixmapImagem)
self.imagemOriginal.setAlignment(QtCore.Qt.AlignCenter)
def closeEvent(self, event):
global listaFiltrosUsados
excluirCopiaImgTransformada()
class ScatterPlotItem(pg.PlotItem):
"""ScatterPlotItem.
Implemented based on pyqtgraph.ScatterPlotItem.
"""
@staticmethod
def createSymbols():
_names = [
'o', 's', 't', 't1', 't2', 't3', 'd', '+', 'x', 'p', 'h', 'star',
'arrow_up', 'arrow_right', 'arrow_down', 'arrow_left'
]
symbols = OrderedDict([(name, QPainterPath()) for name in _names])
symbols['o'].addEllipse(QRectF(-0.5, -0.5, 1., 1.))
symbols['s'].addRect(QRectF(-0.5, -0.5, 1., 1.))
_coords = {
't': [(-0.5, -0.5), (0, 0.5), (0.5, -0.5)],
't1': [(-0.5, 0.5), (0, -0.5), (0.5, 0.5)],
't2': [(-0.5, -0.5), (-0.5, 0.5), (0.5, 0)],
't3': [(0.5, 0.5), (0.5, -0.5), (-0.5, 0)],
'd': [(0., -0.5), (-0.4, 0.), (0, 0.5), (0.4, 0)],
'+': [(-0.5, -0.05), (-0.5, 0.05), (-0.05, 0.05), (-0.05, 0.5),
(0.05, 0.5), (0.05, 0.05), (0.5, 0.05), (0.5, -0.05),
(0.05, -0.05), (0.05, -0.5), (-0.05, -0.5), (-0.05, -0.05)],
'p': [(0, -0.5), (-0.4755, -0.1545), (-0.2939, 0.4045),
(0.2939, 0.4045), (0.4755, -0.1545)],
'h': [(0.433, 0.25), (0., 0.5), (-0.433, 0.25), (-0.433, -0.25),
(0, -0.5), (0.433, -0.25)],
'star': [(0, -0.5), (-0.1123, -0.1545), (-0.4755, -0.1545),
(-0.1816, 0.059), (-0.2939, 0.4045), (0, 0.1910),
(0.2939, 0.4045), (0.1816, 0.059), (0.4755, -0.1545),
(0.1123, -0.1545)],
'arrow_down': [(-0.125, 0.125), (0, 0), (0.125, 0.125),
(0.05, 0.125), (0.05, 0.5), (-0.05, 0.5),
(-0.05, 0.125)]
}
for k, c in _coords.items():
symbols[k].moveTo(*c[0])
for x, y in c[1:]:
symbols[k].lineTo(x, y)
symbols[k].closeSubpath()
del _coords
tr = QTransform()
tr.rotate(45)
symbols['x'] = tr.map(symbols['+'])
tr.rotate(45)
symbols['arrow_right'] = tr.map(symbols['arrow_down'])
symbols['arrow_up'] = tr.map(symbols['arrow_right'])
symbols['arrow_left'] = tr.map(symbols['arrow_up'])
return symbols
_symbol_map = createSymbols.__func__()
def __init__(self,
x=None,
y=None,
*,
symbol='o',
size=8,
pen=None,
brush=None,
name=None,
parent=None):
"""Initialization."""
super().__init__(name=name, parent=parent)
self._x = None
self._y = None
self._bounds = [None, None]
if pen is None and brush is None:
self._pen = FColor.mkPen(None)
self._brush = FColor.mkBrush('b')
else:
self._pen = FColor.mkPen(None) if pen is None else pen
self._brush = FColor.mkBrush(None) if brush is None else brush
self._size = size
self._symbol_path = self._symbol_map[symbol]
self._symbol_fragment = None
self._symbol_width = None
self._buildFragment()
self.setData(x, y)
def updateGraph(self):
"""Override."""
self.prepareGeometryChange()
self.informViewBoundsChanged()
self._bounds = [None, None]
def setData(self, x, y):
"""Override."""
self._parseInputData(x, y)
self.updateGraph()
def data(self):
"""Override."""
return self._x, self._y
def implements(self, interface=None):
ints = ['plotData']
if interface is None:
return ints
return interface in ints
def dataBounds(self, ax, frac=1.0, orthoRange=None):
if frac >= 1.0 and orthoRange is None and self._bounds[ax] is not None:
return self._bounds[ax]
if len(self._y) == 0:
return None, None
x, y = self.transformedData()
if ax == 0:
d = x
d2 = y
elif ax == 1:
d = y
d2 = x
if orthoRange is not None:
mask = (d2 >= orthoRange[0]) * (d2 <= orthoRange[1])
d = d[mask]
d2 = d2[mask]
if d.size == 0:
return None, None
if frac >= 1.0:
self._bounds[ax] = (np.nanmin(d), np.nanmax(d))
return self._bounds[ax]
elif frac <= 0.0:
raise Exception(
"Value for parameter 'frac' must be > 0. (got %s)" % str(frac))
else:
mask = np.isfinite(d)
d = d[mask]
return np.percentile(d, [50 * (1 - frac), 50 * (1 + frac)])
def pixelPadding(self):
return 0.7072 * self._symbol_width
def boundingRect(self):
"""Override."""
xmn, xmx = self.dataBounds(ax=0)
ymn, ymx = self.dataBounds(ax=1)
if xmn is None or xmx is None:
xmn = 0
xmx = 0
if ymn is None or ymx is None:
ymn = 0
ymx = 0
px = py = 0.0
pad = self.pixelPadding()
if pad > 0:
# determine length of pixel in local x, y directions
px, py = self.pixelVectors()
try:
px = 0 if px is None else px.length()
except OverflowError:
px = 0
try:
py = 0 if py is None else py.length()
except OverflowError:
py = 0
# return bounds expanded by pixel size
px *= pad
py *= pad
return QRectF(xmn - px, ymn - py, 2 * px + xmx - xmn,
2 * py + ymx - ymn)
def viewTransformChanged(self):
# FIXME: I am not sure whether this is needed
self.prepareGeometryChange()
self._bounds = [None, None]
def mapPointsToDevice(self, pts):
tr = self.deviceTransform()
if tr is None:
return None
pts = fn.transformCoordinates(tr, pts)
pts -= 0.5 * self._symbol_width
# prevent sluggish GUI and possibly Qt segmentation fault.
pts = np.clip(pts, -2**30, 2**30)
return pts
def getViewMask(self, pts):
vb = self.getViewBox()
if vb is None:
return None
rect = vb.mapRectToDevice(vb.boundingRect())
w = 0.5 * self._symbol_width
mask = ((pts[0] + w > rect.left()) & (pts[0] - w < rect.right()) &
(pts[1] + w > rect.top()) & (pts[1] - w < rect.bottom()))
return mask
def paint(self, p, *args):
"""Override."""
p.resetTransform()
x, y = self.transformedData()
pts = np.vstack([x, y])
pts = self.mapPointsToDevice(pts)
if pts is None:
return
masked_pts = pts[:, self.getViewMask(pts)]
width = self._symbol_width
source_rect = QRectF(self._symbol_fragment.rect())
for px, py in zip(masked_pts[0, :], masked_pts[1, :]):
p.drawPixmap(QRectF(px, py, width, width), self._symbol_fragment,
source_rect)
def drawSample(self, p):
"""Override."""
p.translate(10, 10)
self.drawSymbol(p)
def drawSymbol(self, p):
p.scale(self._size, self._size)
p.setPen(self._pen)
p.setBrush(self._brush)
p.drawPath(self._symbol_path)
def _buildFragment(self):
pen = self._pen
size = int(self._size + max(np.ceil(pen.widthF()), 1))
image = QImage(size, size, QImage.Format_ARGB32)
image.fill(0)
p = QPainter(image)
try:
# default is QPainter.TextAntialiasing
p.setRenderHint(QPainter.Antialiasing)
center = 0.5 * size
p.translate(center, center)
self.drawSymbol(p)
finally:
p.end()
self._symbol_fragment = QPixmap(image)
self._symbol_width = self._symbol_fragment.width()
class Overlay(QWidget):
def __init__(self, parent, binpath):
super().__init__(parent)
sizePolicy = QSizePolicy()
sizePolicy.setHorizontalPolicy(QSizePolicy.Maximum)
sizePolicy.setVerticalPolicy(QSizePolicy.Maximum)
#self.setSizePolicy(sizePolicy)
self.setMouseTracking(True)
self.on_selection = False
self.selected = False
self.c = Communicate()
self.start_position = QPoint(0,0)
self.last_position = QPoint(0,0)
image = (
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
b"\x00\x00\xFF\xFF\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\x00"
b"\x00\x00\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\x00\x00"
b"\x00\x00\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\x00\x00"
b"\x00\x00\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\x00\x00"
b"\x00\x00\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\x00\x00"
b"\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00\x00\xFF\xFF\x00\x00"
b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
im = QImage(image, 8,8, QImage.Format_RGB16)
im = im.scaled(64,64)
self.crop = QPixmap()
self.crop.convertFromImage(im)
def insideSelection(self, point):
width = self.last_position.x() - self.start_position.x()
height = self.last_position.y() - self.start_position.y()
return ( point.x() > self.start_position.x() and point.x() < self.start_position.x() + width and
point.y() > self.start_position.y() and point.y() < self.start_position.y() + height )
def mouseMoveEvent(self, event):
if self.on_selection:
self.last_position = event.pos()
self.update()
def mousePressEvent(self, QMouseEvent):
if not self.insideSelection(QMouseEvent.pos()):
self.on_selection = True
self.selected = True
self.start_position = QMouseEvent.pos()
self.last_position = QMouseEvent.pos()
self.update()
def mouseDoubleClickEvent(self, QMouseEvent):
if self.insideSelection(QMouseEvent.pos()):
width = self.last_position.x() - self.start_position.x()
height = self.last_position.y() - self.start_position.y()
self.c.cropImage.emit(self.start_position.x(), self.start_position.y(), width,height)
def mouseReleaseEvent(self, QMouseEvent):
self.on_selection = False
self.update()
def enterEvent(self, event):
return super().enterEvent(event)
def leaveEvent(self, event):
return super().enterEvent(event)
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
#self.drawWidget(qp)
if self.selected:
qp.setCompositionMode(QPainter.CompositionMode_HardLight)
qp.setBrush(QColor(0, 0, 0, 128))
qp.drawRect(0,0, self.width(), self.height())
qp.setCompositionMode(QPainter.CompositionMode_Overlay)
qp.setBrush(QColor(255, 255, 255, 255))
width = self.last_position.x() - self.start_position.x()
height = self.last_position.y()-self.start_position.y()
qp.drawRect(self.start_position.x(), self.start_position.y(), width, height)
qp.setCompositionMode(QPainter.CompositionMode_SourceOver)
image_w = min([abs(width), abs(height), self.crop.width()]) #self.crop.width()
image_h = image_w #self.crop.height()
qp.drawPixmap(self.start_position.x() + width/2 - image_w/2, self.start_position.y() + height/2 - image_h/2, image_w, image_h, self.crop)
qp.end()
def __init__(self, parent=None):
super(ThemePage, self).__init__(parent)
self.parent = parent
self.setObjectName('settingsthemepage')
mainLayout = QVBoxLayout()
mainLayout.setSpacing(10)
pen = QPen(
QColor('#4D5355' if self.parent.theme == 'dark' else '#B9B9B9'))
pen.setWidth(2)
theme_light = QPixmap(':/images/theme-light.png', 'PNG')
painter = QPainter(theme_light)
painter.setPen(pen)
painter.setBrush(Qt.NoBrush)
painter.drawRect(0, 0, theme_light.width(), theme_light.height())
theme_dark = QPixmap(':/images/theme-dark.png', 'PNG')
painter = QPainter(theme_dark)
painter.setPen(pen)
painter.setBrush(Qt.NoBrush)
painter.drawRect(0, 0, theme_dark.width(), theme_dark.height())
self.lightRadio = QRadioButton(self)
self.lightRadio.setIcon(QIcon(theme_light))
self.lightRadio.setIconSize(QSize(165, 121))
self.lightRadio.setCursor(Qt.PointingHandCursor)
self.lightRadio.clicked.connect(self.switchTheme)
self.lightRadio.setChecked(self.parent.theme == 'light')
self.darkRadio = QRadioButton(self)
self.darkRadio.setIcon(QIcon(theme_dark))
self.darkRadio.setIconSize(QSize(165, 121))
self.darkRadio.setCursor(Qt.PointingHandCursor)
self.darkRadio.clicked.connect(self.switchTheme)
self.darkRadio.setChecked(self.parent.theme == 'dark')
themeLayout = QGridLayout()
themeLayout.setColumnStretch(0, 1)
themeLayout.addWidget(self.lightRadio, 0, 1)
themeLayout.addWidget(self.darkRadio, 0, 3)
themeLayout.addWidget(QLabel('Light', self), 1, 1, Qt.AlignHCenter)
themeLayout.setColumnStretch(2, 1)
themeLayout.addWidget(QLabel('Dark', self), 1, 3, Qt.AlignHCenter)
themeLayout.setColumnStretch(4, 1)
themeGroup = QGroupBox('Theme')
themeGroup.setLayout(themeLayout)
mainLayout.addWidget(themeGroup)
index_leftRadio = QRadioButton('Clips on left')
index_leftRadio.setToolTip('Display Clip Index on the left hand side')
index_leftRadio.setCursor(Qt.PointingHandCursor)
index_leftRadio.setChecked(self.parent.parent.indexLayout == 'left')
index_rightRadio = QRadioButton('Clips on right')
index_rightRadio.setToolTip(
'Display Clip Index on the right hand side')
index_rightRadio.setCursor(Qt.PointingHandCursor)
index_rightRadio.setChecked(self.parent.parent.indexLayout == 'right')
index_buttonGroup = QButtonGroup(self)
index_buttonGroup.addButton(index_leftRadio, 1)
index_buttonGroup.addButton(index_rightRadio, 2)
# noinspection PyUnresolvedReferences
index_buttonGroup.buttonClicked[int].connect(
self.parent.parent.setClipIndexLayout)
indexLayout = QHBoxLayout()
indexLayout.addWidget(index_leftRadio)
indexLayout.addWidget(index_rightRadio)
layoutGroup = QGroupBox('Layout')
layoutGroup.setLayout(indexLayout)
mainLayout.addWidget(layoutGroup)
toolbar_labels = self.parent.settings.value('toolbarLabels',
'beside',
type=str)
toolbar_notextRadio = QRadioButton('No text (buttons only)', self)
toolbar_notextRadio.setToolTip('No text (buttons only)')
toolbar_notextRadio.setCursor(Qt.PointingHandCursor)
toolbar_notextRadio.setChecked(toolbar_labels == 'none')
toolbar_underRadio = QRadioButton('Text under buttons', self)
toolbar_underRadio.setToolTip('Text under buttons')
toolbar_underRadio.setCursor(Qt.PointingHandCursor)
toolbar_underRadio.setChecked(toolbar_labels == 'under')
toolbar_besideRadio = QRadioButton('Text beside buttons', self)
toolbar_besideRadio.setToolTip('Text beside buttons')
toolbar_besideRadio.setCursor(Qt.PointingHandCursor)
toolbar_besideRadio.setChecked(toolbar_labels == 'beside')
toolbar_buttonGroup = QButtonGroup(self)
toolbar_buttonGroup.addButton(toolbar_besideRadio, 1)
toolbar_buttonGroup.addButton(toolbar_underRadio, 2)
toolbar_buttonGroup.addButton(toolbar_notextRadio, 3)
# noinspection PyUnresolvedReferences
toolbar_buttonGroup.buttonClicked[int].connect(self.setLabelStyle)
toolbarLayout = QGridLayout()
toolbarLayout.addWidget(toolbar_besideRadio, 0, 0)
toolbarLayout.addWidget(toolbar_underRadio, 0, 1)
toolbarLayout.addWidget(toolbar_notextRadio, 1, 0)
toolbarGroup = QGroupBox('Toolbar')
toolbarGroup.setLayout(toolbarLayout)
mainLayout.addWidget(toolbarGroup)
nativeDialogsCheckbox = QCheckBox('Use native dialogs', self)
nativeDialogsCheckbox.setToolTip('Use native file dialogs')
nativeDialogsCheckbox.setCursor(Qt.PointingHandCursor)
nativeDialogsCheckbox.setChecked(self.parent.parent.nativeDialogs)
nativeDialogsCheckbox.stateChanged.connect(self.setNativeDialogs)
nativeDialogsLabel = QLabel(
'''
<b>ON:</b> use native dialog widgets as provided by your operating system
<br/>
<b>OFF:</b> use a generic file open & save dialog widget provided by the Qt toolkit
<br/><br/>
<b>NOTE:</b> native dialogs should always be used if working
''', self)
nativeDialogsLabel.setObjectName('nativedialogslabel')
nativeDialogsLabel.setTextFormat(Qt.RichText)
nativeDialogsLabel.setWordWrap(True)
advancedLayout = QVBoxLayout()
advancedLayout.addWidget(nativeDialogsCheckbox)
advancedLayout.addWidget(nativeDialogsLabel)
advancedGroup = QGroupBox('Advanced')
advancedGroup.setLayout(advancedLayout)
mainLayout.addWidget(advancedGroup)
mainLayout.addStretch(1)
self.setLayout(mainLayout)
class RackListWidget(QListWidget):
def __init__(self, parent):
QListWidget.__init__(self, parent)
self.host = None
self.fParent = None
if False:
# kdevelop likes this :)
from carla_backend import CarlaHostMeta
self.host = host = CarlaHostNull()
exts = gCarla.utils.get_supported_file_extensions()
self.fSupportedExtensions = tuple(("." + i) for i in exts)
self.fLastSelectedItem = None
self.fWasLastDragValid = False
self.fPixmapL = QPixmap(":/bitmaps/rack_interior_left.png")
self.fPixmapR = QPixmap(":/bitmaps/rack_interior_right.png")
self.fPixmapWidth = self.fPixmapL.width()
self.setMinimumWidth(RackListItem.kMinimumWidth)
self.setSelectionMode(QAbstractItemView.SingleSelection)
self.setSortingEnabled(False)
self.setDragEnabled(True)
self.setDragDropMode(QAbstractItemView.DropOnly)
self.setDropIndicatorShown(True)
self.viewport().setAcceptDrops(True)
self.setFrameShape(QFrame.NoFrame)
self.setFrameShadow(QFrame.Plain)
# --------------------------------------------------------------------------------------------------------
def createItem(self, pluginId):
return RackListItem(self, pluginId)
def getPluginCount(self):
return self.fParent.getPluginCount()
def setHostAndParent(self, host, parent):
self.host = host
self.fParent = parent
# --------------------------------------------------------------------------------------------------------
def customClearSelection(self):
self.setCurrentRow(-1)
self.clearSelection()
self.clearFocus()
def isDragUrlValid(self, filename):
if os.path.isdir(filename):
#if os.path.exists(os.path.join(filename, "manifest.ttl")):
#return True
if MACOS and filename.lower().endswith(".vst"):
return True
elif os.path.isfile(filename):
if filename.lower().endswith(self.fSupportedExtensions):
return True
return False
# --------------------------------------------------------------------------------------------------------
def dragEnterEvent(self, event):
urls = event.mimeData().urls()
for url in urls:
if self.isDragUrlValid(url.toLocalFile()):
self.fWasLastDragValid = True
event.acceptProposedAction()
return
self.fWasLastDragValid = False
QListWidget.dragEnterEvent(self, event)
def dragMoveEvent(self, event):
if not self.fWasLastDragValid:
QListWidget.dragMoveEvent(self, event)
return
event.acceptProposedAction()
tryItem = self.itemAt(event.pos())
if tryItem is not None:
self.setCurrentRow(tryItem.getPluginId())
else:
self.setCurrentRow(-1)
def dragLeaveEvent(self, event):
self.fWasLastDragValid = False
QListWidget.dragLeaveEvent(self, event)
# --------------------------------------------------------------------------------------------------------
# FIXME: this needs some attention
# if dropping project file over 1 plugin, load it in rack or patchbay
# if dropping regular files over 1 plugin, keep replacing plugins
def dropEvent(self, event):
event.acceptProposedAction()
urls = event.mimeData().urls()
if len(urls) == 0:
return
tryItem = self.itemAt(event.pos())
if tryItem is not None:
pluginId = tryItem.getPluginId()
else:
pluginId = -1
for url in urls:
if pluginId >= 0:
self.host.replace_plugin(pluginId)
pluginId += 1
if pluginId > self.host.get_current_plugin_count():
pluginId = -1
filename = url.toLocalFile()
if not self.host.load_file(filename):
CustomMessageBox(self, QMessageBox.Critical, self.tr("Error"),
self.tr("Failed to load file"),
self.host.get_last_error(), QMessageBox.Ok, QMessageBox.Ok)
if tryItem is not None:
self.host.replace_plugin(self.host.get_max_plugin_number())
#tryItem.widget.setActive(True, True, True)
# --------------------------------------------------------------------------------------------------------
def mousePressEvent(self, event):
if self.itemAt(event.pos()) is None and self.currentRow() != -1:
event.accept()
self.customClearSelection()
return
QListWidget.mousePressEvent(self, event)
def paintEvent(self, event):
painter = QPainter(self.viewport())
painter.drawTiledPixmap(0, 0, self.fPixmapWidth, self.height(), self.fPixmapL)
painter.drawTiledPixmap(self.width()-self.fPixmapWidth, 0, self.fPixmapWidth, self.height(), self.fPixmapR)
QListWidget.paintEvent(self, event)
# --------------------------------------------------------------------------------------------------------
def selectionChanged(self, selected, deselected):
for index in deselected.indexes():
item = self.itemFromIndex(index)
if item is not None:
item.setSelected(False)
for index in selected.indexes():
item = self.itemFromIndex(index)
if item is not None:
item.setSelected(True)
QListWidget.selectionChanged(self, selected, deselected)
class ImageBox(QWidget):
def __init__(self):
super(ImageBox, self).__init__()
self.controlPress = False
self.img = None
self.scaledImg = None
self.point = QPoint(0, 0)
self.startPos = None
self.endPos = None
self.leftClick = False
self.scale = 0.5
self.rotateAngle = 0
self.setWindowTitle("ImageBox")
# 控件开始捕获键盘，只有控件开始捕获键盘，控件的键盘事件才能收到消息
self.grabKeyboard()
LogUtil.d('ImageBox size {}'.format(self.size()))
# self.setContentsMargins(2, 2, 2, 2)
# self.setStyleSheet("border:2px solid #f00")
def setImage(self, imgPath):
"""
open image file
:param imgPath: image file path
:return:
"""
self.controlPress = False
self.scale = 0.5
self.rotateAngle = 0
self.img = QPixmap(imgPath)
ow = self.img.width()
oh = self.img.height()
boxWidth = self.size().width()
boxHeight = self.size().height()
self.scaledImg = self.img.scaled(boxWidth * 2, boxHeight * 2,
Qt.KeepAspectRatio,
Qt.SmoothTransformation)
scaledWidth = self.scaledImg.width()
scaledHeight = self.scaledImg.height()
self.point = QPoint(boxWidth, boxHeight)
LogUtil.d(
'setImage image size ({}, {}) box size {} scaledImg size ({}, {})'.
format(ow, oh, self.size(), scaledWidth, scaledHeight))
self.update()
def zoomIn(self):
if self.scale < PicturePreviewDialog.MAX_SCALE:
self.scale += 0.2
self.point = self.point * (self.scale - 0.2) / self.scale
self.adjustSize()
self.update()
LogUtil.d('zoomIn box size {}', self.size())
def zoomOut(self):
if self.scale > PicturePreviewDialog.MIN_SCALE:
self.scale -= 0.1
self.point = self.point * (self.scale + 0.1) / self.scale
self.adjustSize()
self.update()
LogUtil.d('zoomOut box size {}', self.size())
def rotateLeft(self):
self.rotateAngle -= 90
self.update()
def rotateRight(self):
self.rotateAngle += 90
self.update()
def paintEvent(self, e):
"""
receive paint events
:param e: QPaintEvent
:return:
"""
if self.scaledImg:
painter = QPainter()
painter.begin(self)
painter.translate(self.size().width() / 2,
self.size().height() / 2)
painter.rotate(self.rotateAngle)
painter.translate(-self.size().width() / 2,
-self.size().height() / 2)
painter.scale(self.scale, self.scale)
painter.translate(-self.scaledImg.width() / 2,
-self.scaledImg.height() / 2)
painter.drawPixmap(self.point, self.scaledImg)
painter.end()
def mouseMoveEvent(self, e):
"""
mouse move events for the widget
:param e: QMouseEvent
:return:
"""
if self.leftClick:
self.endPos = e.pos() - self.startPos
self.point = self.point + self.endPos
self.startPos = e.pos()
self.repaint()
def mousePressEvent(self, e):
"""
mouse press events for the widget
:param e: QMouseEvent
:return:
"""
if e.button() == Qt.LeftButton:
self.leftClick = True
self.startPos = e.pos()
def mouseReleaseEvent(self, e):
"""
mouse release events for the widget
:param e: QMouseEvent
:return:
"""
if e.button() == Qt.LeftButton:
self.leftClick = False
def keyPressEvent(self, e: QKeyEvent):
LogUtil.d('keyPressEvent', e.key())
if e.key() == Qt.Key_Control:
LogUtil.d('Control press')
self.controlPress = True
def keyReleaseEvent(self, e: QKeyEvent):
LogUtil.d('keyReleaseEvent', e.key())
if e.key() == Qt.Key_Control:
LogUtil.d('Control release')
self.controlPress = False
def wheelEvent(self, e: QtGui.QWheelEvent):
if self.controlPress:
# if event.delta() > 0: # 滚轮上滚,PyQt4
# This function has been deprecated, use pixelDelta() or angleDelta() instead.
angle = e.angleDelta() / 8 # 返回QPoint对象，为滚轮转过的数值，单位为1/8度
LogUtil.d('wheelEvent', e.pos(), e.x(), e.y())
angleX = angle.x() # 水平滚过的距离(此处用不上)
angleY = angle.y() # 竖直滚过的距离
step = 0.005
if self.scale > 1.5:
step = 0.01
if angleY > 0: # 滚轮上滚
if self.scale < PicturePreviewDialog.MAX_SCALE:
self.scale += step
self.point = self.point * (self.scale - step) / self.scale
self.update() # 重绘
elif angleY < 0: # 滚轮下滚
if self.scale > PicturePreviewDialog.MIN_SCALE:
self.scale -= step
self.point = self.point * (self.scale + step) / self.scale
self.update()
LogUtil.d('wheelEvent', e.pos(), e.x(), e.y())
class MandelbrotWidget(QWidget):
def __init__(self, parent=None):
super(MandelbrotWidget, self).__init__(parent)
self.thread = RenderThread()
self.pixmap = QPixmap()
self.pixmapOffset = QPoint()
self.lastDragPos = QPoint()
self.centerX = DefaultCenterX
self.centerY = DefaultCenterY
self.pixmapScale = DefaultScale
self.curScale = DefaultScale
self.thread.renderedImage.connect(self.updatePixmap)
self.setWindowTitle("Mandelbrot")
self.setCursor(Qt.CrossCursor)
self.resize(550, 400)
def paintEvent(self, event):
painter = QPainter(self)
painter.fillRect(self.rect(), Qt.black)
if self.pixmap.isNull():
painter.setPen(Qt.white)
painter.drawText(self.rect(), Qt.AlignCenter,
"Rendering initial image, please wait...")
return
if self.curScale == self.pixmapScale:
painter.drawPixmap(self.pixmapOffset, self.pixmap)
else:
scaleFactor = self.pixmapScale / self.curScale
newWidth = int(self.pixmap.width() * scaleFactor)
newHeight = int(self.pixmap.height() * scaleFactor)
newX = self.pixmapOffset.x() + (self.pixmap.width() - newWidth) / 2
newY = self.pixmapOffset.y() + (self.pixmap.height() - newHeight) / 2
painter.save()
painter.translate(newX, newY)
painter.scale(scaleFactor, scaleFactor)
exposed, _ = painter.matrix().inverted()
exposed = exposed.mapRect(self.rect()).adjusted(-1, -1, 1, 1)
painter.drawPixmap(exposed, self.pixmap, exposed)
painter.restore()
text = "Use mouse wheel or the '+' and '-' keys to zoom. Press and " \
"hold left mouse button to scroll."
metrics = painter.fontMetrics()
textWidth = metrics.width(text)
painter.setPen(Qt.NoPen)
painter.setBrush(QColor(0, 0, 0, 127))
painter.drawRect((self.width() - textWidth) / 2 - 5, 0, textWidth + 10,
metrics.lineSpacing() + 5)
painter.setPen(Qt.white)
painter.drawText((self.width() - textWidth) / 2,
metrics.leading() + metrics.ascent(), text)
def resizeEvent(self, event):
self.thread.render(self.centerX, self.centerY, self.curScale,
self.size())
def keyPressEvent(self, event):
if event.key() == Qt.Key_Plus:
self.zoom(ZoomInFactor)
elif event.key() == Qt.Key_Minus:
self.zoom(ZoomOutFactor)
elif event.key() == Qt.Key_Left:
self.scroll(-ScrollStep, 0)
elif event.key() == Qt.Key_Right:
self.scroll(+ScrollStep, 0)
elif event.key() == Qt.Key_Down:
self.scroll(0, -ScrollStep)
elif event.key() == Qt.Key_Up:
self.scroll(0, +ScrollStep)
else:
super(MandelbrotWidget, self).keyPressEvent(event)
def wheelEvent(self, event):
numDegrees = event.angleDelta().y() / 8
numSteps = numDegrees / 15.0
self.zoom(pow(ZoomInFactor, numSteps))
def mousePressEvent(self, event):
if event.buttons() == Qt.LeftButton:
self.lastDragPos = QPoint(event.pos())
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
self.pixmapOffset += event.pos() - self.lastDragPos
self.lastDragPos = QPoint(event.pos())
self.update()
def mouseReleaseEvent(self, event):
if event.button() == Qt.LeftButton:
self.pixmapOffset += event.pos() - self.lastDragPos
self.lastDragPos = QPoint()
deltaX = (self.width() - self.pixmap.width()) / 2 - self.pixmapOffset.x()
deltaY = (self.height() - self.pixmap.height()) / 2 - self.pixmapOffset.y()
self.scroll(deltaX, deltaY)
def updatePixmap(self, image, scaleFactor):
if not self.lastDragPos.isNull():
return
self.pixmap = QPixmap.fromImage(image)
self.pixmapOffset = QPoint()
self.lastDragPosition = QPoint()
self.pixmapScale = scaleFactor
self.update()
def zoom(self, zoomFactor):
self.curScale *= zoomFactor
self.update()
self.thread.render(self.centerX, self.centerY, self.curScale,
self.size())
def scroll(self, deltaX, deltaY):
self.centerX += deltaX * self.curScale
self.centerY += deltaY * self.curScale
self.update()
self.thread.render(self.centerX, self.centerY, self.curScale,
self.size())
def processUI(self):
### remove title bar
self.setWindowFlags(QtCore.Qt.FramelessWindowHint|QtCore.Qt.WindowStaysOnBottomHint)
### background image and Fixed Size
back_label = QLabel(self)
back = QPixmap('.\\img\\33_back.png')
back_label.setPixmap(back)
self.setFixedSize(back.width(),back.height())
### close Button
self.close_Btn = QPushButton('',self)
self.close_Btn.setIcon(QIcon('.\\img\\close_Btn.png'))
self.close_Btn.setFixedSize(20,20)
self.close_Btn.setIconSize(QtCore.QSize(30,30))
self.close_Btn.move(back.width()-40,20)
self.close_Btn.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
### GIF set
self.moviee = QLabel(self)
self.movie = QtGui.QMovie(".\\img\\Processing.gif")
self.moviee.setMovie(self.movie)
self.moviee.setGeometry(50,28,320,150)
self.movie.start()
### Pause Button
self.P_btn = QPushButton('',self)
self.P_btn.setIcon(QIcon('.\\img\\Pause.png'))
self.P_btn.setIconSize(QtCore.QSize(170,90))
self.P_btn.setFixedSize(150,70)
self.P_btn.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.P_btn.move(420,60)
### Continue Button
self.C_btn = QPushButton('',self)
self.C_btn.setIcon(QIcon('.\\img\\Continue.png'))
self.C_btn.setIconSize(QtCore.QSize(170,90))
self.C_btn.setFixedSize(150,70)
self.C_btn.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.C_btn.move(420,60)
### Cancel Button
self.Can_btn = QPushButton('',self)
self.Can_btn.setIcon(QIcon('.\\img\\Cancel.png'))
self.Can_btn.setIconSize(QtCore.QSize(170,90))
self.Can_btn.setFixedSize(150,70)
self.Can_btn.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.Can_btn.move(600,60)
### Start Button
self.S_btn = QPushButton('',self)
self.S_btn.setIcon(QIcon('.\\img\\Start.png'))
self.S_btn.setIconSize(QtCore.QSize(170,90))
self.S_btn.setFixedSize(150,70)
self.S_btn.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.S_btn.move(600,60)
### hide btn P & S
self.C_btn.setVisible(False)
self.S_btn.setVisible(False)
### Table Widget
self.tableWidget = QTableWidget(self)
self.tableWidget.setFixedSize(760, 370)
self.tableWidget.move(30, 200)
self.tableWidget.setColumnCount(3)
self.tableWidget.setColumnWidth(0, self.tableWidget.width()/5.5)
self.tableWidget.setColumnWidth(1, self.tableWidget.width()/2.5)
self.tableWidget.setColumnWidth(2, self.tableWidget.width()/2.5)
### Table Widget Label Warning, Notice set
self.warn = QLabel(self)
self.warn_img = QPixmap('.\\img\\Warning.png')
self.Notice = QLabel(self)
self.Notice_img = QPixmap('.\\img\\Notice.png')
### Btn Clicked
self.P_btn.clicked.connect(self.P_btn_clicked)
self.C_btn.clicked.connect(self.C_btn_clicked)
self.Can_btn.clicked.connect(self.Can_btn_clicked)
self.S_btn.clicked.connect(self.S_btn_clicked)
self.close_Btn.clicked.connect(self.close_Btn_clicked)
self.show()
### core thread
self.gipThread = get_ip_thread(self)
self.gipThread.gipEvent.connect(self.gipThreadEventHandler)
self.gipThreadStart()
self.gregThread = get_registry_thread(self)
self.gregThread.gregEvent.connect(self.gregThreadEventHandler)
self.gregThreadStart()
self.gprocThread = get_proc_thread(self)
self.gprocThread.gprocEvent.connect(self.gprocThreadEventHandler)
self.gprocThreadStart()
self.gfileThread = get_file_thread(self)
self.gfileThread.gfileEvent.connect(self.gfileThreadEventHandler)
self.gfileThreadStart()
### report thread
self.reportThread = send_report_thread(self)
self.reportThread.countEvent.connect(self.reportThreadEventHandler)
self.reportThreadStart()
class AnimeIndexWindow(QWidget):
def __init__(self):
super().__init__()
anime_bk_pic_path = './source/pic/anime_bk.png'
search_1_pic_path = './source/pic/next.png'
search_2_pic_path = './source/pic/next_1.png'
search_3_pic_path = './source/pic/next_2.png'
hgzy_font_path = './source/font/HGZYT_CNKI.TTF'
rem_ico_path = './source/pic/rem.png'
self.pix = QPixmap(anime_bk_pic_path)
self.resize(self.pix.width(),self.pix.height())
self.pix = self.pix.scaled(int(self.pix.width()), int(self.pix.height()))
self.setMask(self.pix.mask())
screen = QDesktopWidget().screenGeometry()
self.move((screen.width() - self.pix.width()) / 2, (screen.height() - self.pix.height()) / 2)
self.setWindowFlags(Qt.FramelessWindowHint) # | QtCore.Qt.WindowStaysOnTopHint
self.setAttribute(Qt.WA_TranslucentBackground) # 窗口透明抗锯齿
rem_icon = QIcon(QPixmap(rem_ico_path))
self.setWindowIcon(rem_icon)
self.m_DragPosition = None
fontId = QFontDatabase.addApplicationFont(hgzy_font_path)
fontName = QFontDatabase.applicationFontFamilies(fontId)[0]
self.animelist = QDListWidget(self)
self.animelist.setObjectName('AnimeListWidget')
self.animelist.setGeometry(17,280,self.pix.width()-34,self.pix.height()-280-50)
self.animelist.setStyleSheet('#AnimeListWidget{background:transparent;}')
self.animelist.setFont(QFont(fontName,15,QFont.Light))
self.animelist.setIconSize(QSize(100,100))
self.InitData()
ver = Version()
self.version = QDLabel(self, ver.cur_link)
self.version.setObjectName('VersionLabel')
self.version.setGeometry(15, self.pix.height() - 75, 600, 100)
self.version.setText('当前数据库版本号:' + ver.cur_version)
if ver.judge_version():
self.version.setToolTip('数据库为最新版本,无需更新')
else:
self.version.setToolTip('数据库版本已过期,请自行下载新数据库.(双击获取下载链接)')
self.version.setFont(QFont(fontName,10,QFont.Light))
self.search = QPushButton(self)
self.search.setObjectName('Search')
self.search.setStyleSheet("#Search{border-image: url(%s)}"
"#Search:hover{border-image: url(%s)}"
"#Search:pressed{border-image: url(%s)}"
% (search_1_pic_path,search_2_pic_path,search_3_pic_path))
self.search.setGeometry(self.pix.width()-self.search.width(),self.pix.height()-self.search.height()-10
,self.search.width()-20,self.search.height())
self.choose = Choose(self.x()+self.width(),self.y()+self.height())
self.choose_show = False
self.choose_info = {}
self.search.clicked.connect(self.SearchBt)
self.detail = Detail(self.x(),self.y())
self.detail_show = False
self.animelist.itemDoubleClicked.connect(self.DetailBt)
self.animelist.installEventFilter(self)
self.rightclick = Rightclick()
self.animeshow = False
def paintEvent(self, event):
paint = QPainter(self)
paint.drawPixmap(0,0,self.pix.width(),self.pix.height(),self.pix)
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.m_drag = True
self.m_DragPosition = event.globalPos() - self.pos()
if self.choose_show == True:
self.choose.raise_()
if self.detail_show == True:
self.detail.raise_()
event.accept()
elif event.button() == Qt.RightButton:
if self.detail_show == True:
self.detail.close()
self.detail_show = False
if self.choose_show == True:
self.choose.close()
self.choose_show = False
self.hide()
self.animeshow = False
event.accept()
def mouseMoveEvent(self, event):
if Qt.LeftButton and self.m_drag:
self.move(event.globalPos() - self.m_DragPosition)
self.choose.move(self.x() + self.width(), self.y()+self.height()-self.choose.pix.height())
self.detail.move(self.x()-self.detail.pix.width(),self.y())
event.accept()
def mouseReleaseEvent(self, event):
self.m_drag = False
def closeEvent(self, event):
self.detail.close()
self.detail_show = False
self.choose.close()
self.choose_show = False
self.animeshow = False
def InitData(self):
dbsql = AnimeData()
self.infos = dbsql.SqliteInfoSelect()
self.animelist.clear()
if self.infos:
for info in self.infos:
self.animelist.addItem(QListWidgetItem(QIcon('./source/pic/bili.png'), info[0]))
def ChooseData(self):
self.choose_info = {}
title = self.choose.titletext.text()
if title != '':
self.choose_info['title'] = title
order = self.choose.ordertext.text()
if order != '':
self.choose_info['order'] = int(order)
index_show = ''
index_season = self.choose.animecombo_season.currentText()
index_year = self.choose.timetext.text()
if index_year != '':
index_show += index_year + '年'
if index_season != '不筛选':
index_show += index_season
if index_show != '':
self.choose_info['index_show'] = index_show
novip = self.choose.animevip.checkState()
if novip == 1:
self.choose_info['vip'] = 1
elif novip == 2:
self.choose_info['vip'] = 0
finish = self.choose.animefinish.checkState()
if finish == 1:
self.choose_info['finish'] = 0
elif finish == 2:
self.choose_info['finish'] = 1
tags = []
for i in range(3):
tag = self.choose.animetags[i].currentText()
if tag != '不筛选':
tags.append(tag)
if tags != []:
self.choose_info['tag'] = tags
def ShowData(self):
dbsql = AnimeData()
self.infos = dbsql.SqliteInfoSearch(self.choose_info)
self.animelist.clear()
if self.infos:
for info in self.infos:
self.animelist.addItem(QListWidgetItem(QIcon('./source/pic/bili.png'), info[0]))
else:
self.InitData()
def SearchBt(self):
if self.choose_show == False:
self.choose.show()
self.choose_show = True
else:
self.choose.close()
self.ChooseData()
self.ShowData()
self.choose_show = False
def GetDetail(self,title):
dbsql = AnimeData()
infos = dbsql.SqliteInfoSearch({'title':title})
resinfo = []
if infos:
for info in infos:
resinfo.append(info[0])
resinfo.append(info[1])
resinfo.append(info[2])
resinfo.append(info[3])
resinfo.append(info[4])
resinfo.append(info[5])
resinfo.append(info[6])
resinfo.append(info[7])
return resinfo
def DelDetail(self):
self.detail.animetitle.setParent(None)
self.detail.animeintro.setParent(None)
self.detail.animetags.setParent(None)
self.detail.animeorder.setParent(None)
self.detail.animeindexshow.setParent(None)
self.detail.animeindexshowtext.setParent(None)
self.detail.animetagstext.setParent(None)
self.detail.animeordertext.setParent(None)
self.detail.animetitletext.setParent(None)
self.detail.animetagstext.setParent(None)
self.detail.pic_label.setParent(None)
def DetailBt(self):
if self.detail_show == False:
info = self.GetDetail(self.animelist.currentItem().text())
self.animelist.index = self.animelist.currentIndex()
self.detail.setInfo(info)
self.detail.show()
self.detail_show = True
elif self.detail_show == True and self.animelist.index != self.animelist.currentIndex():
self.detail.close()
self.DelDetail()
info = self.GetDetail(self.animelist.currentItem().text())
self.animelist.index = self.animelist.currentIndex()
self.detail.setInfo(info)
self.detail.show()
else:
self.detail.close()
self.DelDetail()
self.animelist.index = -1
self.detail_show = False
class TIFgrabGUI(QMainWindow):
def __init__(self, capcard_full, capcard_short, parent=None):
super(TIFgrabGUI, self).__init__(parent)
self.cleanup_side_captures()
# set up GUI from designer-made layout
self.ui = Ui_TIFgrabMW()
self.ui.setupUi(self)
# Temporarily? hard code the device definition
self.sys_device = "/dev/video0"
target_cam_serialnum = capcard_short[self.sys_device]
target_cam_label = capcard_full[self.sys_device]
print("Targeting camera device ", self.sys_device)
print("Labeling as ", target_cam_label)
self.picframe_width = self.ui.ThumbnailView.frameGeometry().width()
self.picframe_height = self.ui.ThumbnailView.frameGeometry().height()
#for device_name in QCamera.availableDevices():
# print("Looking at", device_name)
# if (device_name == target_cam_dev):
#self.camera_device = device_name
# self.camera_device = target_cam_dev.encode('utf-8')
self.camera_device = self.sys_device.encode('utf-8')
self.camera_label = target_cam_label
self.ui.Sourcename_Disp.setText(self.camera_label)
self.cam1 = QCamera(self.camera_device)
# self.cam1_info = QCameraInfo(self.cam1)
# self.cam1_nonhuman_name = self.cam1_info.deviceName()
# print("Description= ",self.cam1_info.description())
# print("Nonhuman= ", self.cam1_info.deviceName())
self.cam1_capture = QCameraImageCapture(self.cam1)
print("Still image capture from device %s, capture card %s)" %
(self.camera_device, self.camera_label))
self.cam1.setCaptureMode(QCamera.CaptureStillImage)
self.cam1_capture.setCaptureDestination(
QCameraImageCapture.CaptureToBuffer)
#### Assign a startup image ####
# print('Displaying startup image')
#self.tifimage = QPixmap('/home/scotty/src/GrabDev/tasman_island_lighthouse.tif', 'tif')
self.tifimage = QPixmap('./tasman_island_lighthouse.tif', 'tif')
self.thumb = self.tifimage.scaled(self.picframe_width,
self.picframe_height,
Qt.KeepAspectRatio)
self.ui.ThumbnailView.setScaledContents(True)
self.ui.ThumbnailView.setPixmap(self.thumb)
# Set event handlers
self.ui.grabButton.clicked.connect(self.on_grab_button)
self.ui.TimerRadio.toggled.connect(self.on_timerradio_button)
self.ui.quitButton.clicked.connect(self.on_quit_button)
self.cam1_capture.imageCaptured.connect(self.on_image_captured)
self.ui.FilenameDisp.setText("No image captured")
self.cam1.start()
def on_grab_button(self):
self.cam1.searchAndLock()
self.capture_time = systime()
self.capture_name = "./" + self.camera_label + "_" + self.capture_time + ".tif"
self.cam1_capture.capture()
self.cam1.unlock()
def on_image_captured(self, id, captured_image):
# The image to be displayed on screen
self.captured2pixmap = QPixmap()
success = self.captured2pixmap.convertFromImage(captured_image)
self.list_pic_stats()
self.thumb_scaled = self.captured2pixmap.scaled(
self.picframe_width, self.picframe_height, Qt.KeepAspectRatio)
self.ui.ThumbnailView.setScaledContents(True)
self.ui.ThumbnailView.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.ui.FilenameDisp.setText(self.capture_name)
self.ui.ThumbnailView.setPixmap(self.thumb_scaled)
# The image to be saved to file as TIF
# First confirm that the destination folder exists, create if it doesn't.
self.manage_daily_folder()
self.capture_fullpath = self.outdirname + "/" + self.capture_name
outimage = QPixmap()
outimage.convertFromImage(captured_image)
outfile = QFile(self.capture_fullpath)
outfile.open(QIODevice.WriteOnly)
outimage.save(outfile, "TIFF")
outfile.close()
def list_pic_stats(self):
sizestr = ("Size: %d X %d") % (self.captured2pixmap.width(),
self.captured2pixmap.height())
depthstr = ("Depth:%s ") % (self.captured2pixmap.depth())
bmapstr = ("Is Bitmap?:%s") % (self.captured2pixmap.isQBitmap())
alphastr = ("Has alpha?:%s") % (self.captured2pixmap.hasAlphaChannel())
self.ui.PicStats.setPlainText(self.sys_device)
self.ui.PicStats.appendPlainText(sizestr)
self.ui.PicStats.appendPlainText(depthstr)
def on_timerradio_button(self):
if self.ui.TimerRadio.isChecked():
self.ui.grabButton.setEnabled(False)
self.add_timer_groupbox()
if not self.ui.TimerRadio.isChecked():
if self.timergb:
self.timergb.grab_timer.stop()
self.ui.grabButton.setEnabled(True)
self.timergb.deleteLater()
self.timergb = None
def add_timer_groupbox(self):
self.timergb = TimerGB(75, 100)
self.timergb.grab_timeout.connect(self.on_grab_button)
self.timergb.gb_closed.connect(self.on_timergb_closed)
self.timergb.show()
def on_timergb_closed(self):
if self.ui.TimerRadio.isChecked():
if self.timergb:
# self.grab_timer.stop()
self.timergb.deleteLater()
self.timergb = None
self.ui.TimerRadio.setChecked(False)
self.ui.grabButton.setEnabled(True)
def cleanup_side_captures(self):
# Remove jpgs saved by QCameraImageCapture in default location
defaultlocation = "/home/jason/Pictures"
print("Removing all jpgs from ", defaultlocation)
fullpath = ("%s/*.jpg") % (defaultlocation)
for filename in glob(fullpath):
print("Removing ", filename)
os.remove(filename)
def on_quit_button(self):
self.cam1.stop()
try:
if self.timergb:
self.timergb.deleteLater()
self.timergb = None
except:
pass
self.cleanup_side_captures()
QCoreApplication.exit()
def sigint_handler(*args):
try:
if self.timergb:
self.timergb.deleteLater()
self.timergb = None
except:
pass
sys.stderr.write('\r')
QApplication.quit()
def do_init(ini_filename):
cf = ConfigParser()
cf.read(ini_filename)
def manage_daily_folder(self):
# Tests for existence of folder to hold the date's captures.
# If folder doesn't exist, creates it.
today = sysdate()
self.outdirname = "/data/capture_" + today
if not os.path.exists(self.outdirname):
os.makedirs(self.outdirname)
class QtVideoMockup(AbstractVideoDevice):
def __init__(self, name):
AbstractVideoDevice.__init__(self, name)
self.force_update = None
self.image_type = None
self.image = None
def init(self):
current_path = os.path.dirname(os.path.abspath(__file__)).split(os.sep)
current_path = os.path.join(*current_path[1:-2])
default_image_path = "/" + current_path + "/test/fakeimg.jpg"
image_path = self.getProperty("file_name", default_image_path)
self.image = QPixmap(image_path)
self.image_dimensions = (self.image.width(), self.image.height())
self.painter = QPainter(self.image)
custom_pen = QPen(Qt.SolidLine)
custom_pen.setColor(Qt.black)
custom_pen.setWidth(1)
self.painter.setPen(custom_pen)
custom_brush = QBrush(Qt.SolidPattern)
custom_brush.setColor(Qt.lightGray)
self.painter.setBrush(custom_brush)
self.setIsReady(True)
AbstractVideoDevice.init(self)
def get_new_image(self):
self.painter.drawRect(self.image.width() - 75, self.image.height() - 30, 70, 20)
self.painter.drawText(
self.image.width() - 70, self.image.height() - 15, time.strftime("%H:%M:%S")
)
self.emit("imageReceived", self.image)
def save_snapshot(self, filename, image_type="PNG"):
qimage = QImage(self.image)
qimage.save(filename, image_type)
def get_snapshot(self, bw=None, return_as_array=None):
qimage = QImage(self.image)
if return_as_array:
qimage = qimage.convertToFormat(4)
ptr = qimage.bits()
ptr.setsize(qimage.byteCount())
image_array = np.array(ptr).reshape(qimage.height(), qimage.width(), 4)
if bw:
return np.dot(image_array[..., :3], [0.299, 0.587, 0.144])
else:
return image_array
else:
if bw:
return qimage.convertToFormat(QImage.Format_Mono)
else:
return qimage
def get_contrast(self):
return 34
def set_contrast(self, contrast_value):
return
def get_brightness(self):
return 54
def set_brightness(self, brightness_value):
return
def get_gain(self):
return 32
def set_gain(self, gain_value):
return
def get_gamma(self):
return 22
def set_gamma(self, gamma_value):
return
def get_exposure_time(self):
return 0.23
def get_video_live(self):
return True
def get_raw_image_size(self):
return list(self.image_dimensions)
def __init__(self):
super(App, self).__init__()
config = GetConfig()
self.ui = Ui_mainWindow()
self.QtWidgets = QtWidgets
self.QtGui = QtGui
self.ui.setupUi(self)
self.ui.tabWidget.setCurrentIndex(0)
self.show()
logo = QPixmap(config.logo)
self.ui.logoView.setPixmap(logo)
self.ui.logoView.resize(logo.width(), logo.height())
home_img = QPixmap(config.img)
self.ui.imageView.setPixmap(home_img)
self.ui.imageView.resize(350, 220)
self.setWindowTitle(' ')
self.left = config.left
self.top = config.top
self.resize(QtCore.QSize(config.width, config.height))
self.height = config.height
self.ui.HeaderMenu.setText("OpenFOAM")
self.ui.appsFullscreen.clicked.connect(self.apps_fullscreen)
self.ui.appsFullscreen_back.clicked.connect(self.apps_fullscreen_back)
self.ui.appsFullscreen_back.hide()
self.ui.openfoamButton.clicked.connect(self.openfoam_clicked)
self.ui.patoButton.clicked.connect(self.pato_clicked)
self.ui.pumaButton.clicked.connect(self.puma_clicked)
self.ui.oplrButton.clicked.connect(self.dplr_clicked)
# OpenFOAM BUTTONS
self.ui.documentationButton.clicked.connect(self.documentation_clicked)
self.ui.installButton.clicked.connect(self.install_clicked)
self.ui.testButton.clicked.connect(self.test_clicked)
self.ui.runButton.clicked.connect(self.run_clicked)
self.ui.installListView.hide()
self.ui.startInstallButton.hide()
self.selectedMenu = 'openfoam'
self.documentation_clicked()
self.ui.openfoamButton.setStyleSheet("""
QPushButton:active{ background-color: #c1c1c1; }
""")
self.ui.documentationButton.setStyleSheet("""
QPushButton:active{ background-color: #c1c1c1; }
""")
self.ui.appsGroupBox.setStyleSheet("""
QPushButton:focus{ background-color: #c1c1c1; }
QPushButton:hover{ background-color: white; }
""")
self.ui.appsOpenfoamQframe.setStyleSheet("""
QPushButton:focus{ background-color: #a1a1a1; }
QPushButton:hover{ background-color: white; }
""")
