class PlayersWidget(QWidget):
def __init__(self):
factory = ApiRequestFactory.get_instance()
QWidget.__init__(self)
page_list = factory.get_players_from_page(1)
self.layout = QVBoxLayout()
label_widget = QWidget()
label_widget.layout = QVBoxLayout()
for page_obj in page_list[0]:
for pl in page_obj[1]:
lb_text = pl.first_name + ' ' + pl.last_name
if pl.position is not None and (pl.position is not ''
or pl.position is not ' '):
lb_text = lb_text + ': ' + pl.position
player_lb = QLabel(text=lb_text)
label_widget.layout.addWidget(player_lb)
label_widget.setLayout(label_widget.layout)
self.scroll_widget = QScrollArea()
self.scroll_widget.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.scroll_widget.setBackgroundRole(QPalette.Light)
self.scroll_widget.setWidgetResizable(True)
self.scroll_widget.setWidget(label_widget)
self.layout.addWidget(self.scroll_widget)
self.setLayout(self.layout)
def make_tab(self, title):
area = QScrollArea()
field = Field(area, title)
area.setBackgroundRole(QPalette.Mid)
area.setWidgetResizable(True)
area.setWidget(self.add_fields(self, title, field))
self.fields.append(field)
return area
def home(self):
"""
Add the GUI elements to the window that represent the home state of the application.
"""
toolbar = self.addToolBar("File")
save = QAction(QIcon("res/icon_save.png"), "Save", self)
save.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_S))
toolbar.addAction(save)
load = QAction(QIcon("res/icon_load.png"), "Load", self)
load.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_O))
toolbar.addAction(load)
toolbar.addSeparator()
undo = QAction(QIcon("res/icon_undo.png"), "Undo", self)
undo.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_Z))
toolbar.addAction(undo)
redo = QAction(QIcon("res/icon_redo.png"), "Redo", self)
redo.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_Y))
toolbar.addAction(redo)
toolbar.addSeparator()
zoom_in = QAction(QIcon("res/icon_zoom_in.png"), "Zoom In", self)
toolbar.addAction(zoom_in)
zoom_out = QAction(QIcon("res/icon_zoom_out.png"), "Zoom Out", self)
toolbar.addAction(zoom_out)
toolbar.addSeparator()
clear = QAction(QIcon("res/icon_clear.png"), "Clear", self)
toolbar.addAction(clear)
toolbar.addSeparator()
grid = QAction(QIcon("res/icon_grid.png"), "Grid", self)
toolbar.addAction(grid)
toolbar.actionTriggered[QAction].connect(self.toolbar_pressed)
splitter = QSplitter(self)
splitter.setOrientation(Qt.Vertical)
splitter.setHandleWidth(16)
self.tile_ed = TileEd(self.size, self.tile_size, self.pixmap, self)
scroll_area_tile_ed = QScrollArea()
scroll_area_tile_ed.setBackgroundRole(QPalette.Dark)
scroll_area_tile_ed.setWidgetResizable(True)
scroll_area_tile_ed.setWidget(self.tile_ed)
splitter.addWidget(scroll_area_tile_ed)
self.tile_sel = TileSelector(self.tile_size, self.pixmap, self)
scroll_area_tile_sel = QScrollArea()
scroll_area_tile_sel.setBackgroundRole(QPalette.Dark)
scroll_area_tile_sel.setWidgetResizable(True)
scroll_area_tile_sel.setWidget(self.tile_sel)
splitter.addWidget(scroll_area_tile_sel)
self.setCentralWidget(splitter)
class AdjustChunkBrightContrastDlg(QtWidgets.QDialog):
# path = ''
# image = Image
def __init__(self, parent):
QtWidgets.QDialog.__init__(self, parent)
self.setWindowTitle(
"ADJUST PHOTOS BRIGHTNESS - CONTRAST, CMG (MAROC)")
# self.adjustSize()
self.setMaximumHeight(880)
self.createParamsGridLayout()
self.createButtonsGridLayout()
self.createProgressBar()
self.createImageViewerLayout()
vbox = QtWidgets.QVBoxLayout()
vbox.addWidget(self.groupBoxParams)
vbox.addWidget(self.groupBoxViewer)
vbox.addWidget(self.groupBoxProgressBar)
vbox.addWidget(self.groupBoxButtons)
self.setLayout(vbox)
self.exec()
def createImageViewerLayout(self):
self.groupBoxViewer = QtWidgets.QGroupBox()
gridViewerLayout = QtWidgets.QGridLayout()
self.scaleFactor = 0.0
self.imageLabel = QtWidgets.QLabel(self)
self.imageLabel.setBackgroundRole(QtGui.QPalette.Base)
self.imageLabel.setSizePolicy(
QtWidgets.QSizePolicy.Ignored, QtWidgets.QSizePolicy.Ignored)
self.imageLabel.setScaledContents(True)
self.scrollArea = QScrollArea()
self.scrollArea.setBackgroundRole(QPalette.Dark)
self.scrollArea.setWidget(self.imageLabel)
self.scrollArea.setMinimumHeight(605)
# self.scrollArea.setMaximumHeight(605)
self.scrollArea.setMinimumWidth(830)
self.scrollArea.setMaximumWidth(830)
self.getChunk()
self.getPaths()
self.getImage(0)
self.scrollArea.setWidgetResizable(False)
self.normalSize()
self.scaleImage(0.16)
gridViewerLayout.addWidget(self.scrollArea, 1, 0)
self.createViewerButtons()
gridViewerLayout.addWidget(self.groupBoxViewerBtn, 0, 0)
self.groupBoxViewer.setLayout(gridViewerLayout)
def createViewerButtons(self):
self.groupBoxViewerBtn = QtWidgets.QGroupBox()
gridViewerBtnLayout = QtWidgets.QGridLayout()
self.btnNextPhoto = QtWidgets.QPushButton("->")
self.btnNextPhoto.setFixedSize(23, 23)
self.btnPreviousPhoto = QtWidgets.QPushButton("<-")
self.btnPreviousPhoto.setFixedSize(23, 23)
self.btnZoomIn = QtWidgets.QPushButton("+")
self.btnZoomIn.setFixedSize(23, 23)
self.btnZoomOut = QtWidgets.QPushButton("-")
self.btnZoomOut.setFixedSize(23, 23)
# self.btnZoomOut = QtWidgets.QPushButton("-")
# self.btnZoomOut.setFixedSize(23, 23)
gridViewerBtnLayout.addWidget(self.btnZoomIn, 0, 0)
gridViewerBtnLayout.addWidget(self.btnZoomOut, 0, 1)
gridViewerBtnLayout.addWidget(self.btnPreviousPhoto, 0, 3)
gridViewerBtnLayout.addWidget(self.btnNextPhoto, 0, 4)
QtCore.QObject.connect(
self.btnZoomIn, QtCore.SIGNAL("clicked()"), self.zoomIn)
QtCore.QObject.connect(
self.btnZoomOut, QtCore.SIGNAL("clicked()"), self.zoomOut)
QtCore.QObject.connect(
self.btnNextPhoto, QtCore.SIGNAL("clicked()"), self.nextPhoto)
QtCore.QObject.connect(
self.btnPreviousPhoto, QtCore.SIGNAL("clicked()"), self.previousPhoto)
self.groupBoxViewerBtn.setLayout(gridViewerBtnLayout)
def createButtonsGridLayout(self):
self.groupBoxButtons = QtWidgets.QGroupBox()
gridBtnLayout = QtWidgets.QGridLayout()
self.btnQuit = QtWidgets.QPushButton("Cancel")
self.btnQuit.setFixedSize(150, 23)
self.btnSubmit = QtWidgets.QPushButton("OK")
self.btnSubmit.setFixedSize(150, 23)
gridBtnLayout.addWidget(self.btnSubmit, 0, 0)
gridBtnLayout.addWidget(self.btnQuit, 0, 1)
self.btnSubmit.setEnabled(False)
QtCore.QObject.connect(self.btnQuit, QtCore.SIGNAL(
"clicked()"), self, QtCore.SLOT("reject()"))
QtCore.QObject.connect(
self.btnSubmit, QtCore.SIGNAL("clicked()"), self.adjustChunkPhotos)
self.groupBoxButtons.setLayout(gridBtnLayout)
def createParamsGridLayout(self):
self.groupBoxParams = QtWidgets.QGroupBox('Adjustment parameters')
gridParamsLayout = QtWidgets.QGridLayout()
gridParamsLayout.setHorizontalSpacing(50)
self.label_chunk = QtWidgets.QLabel('Chunk : ')
self.chunksBox = QtWidgets.QComboBox()
self.chunksBox.resize(200, 23)
self.getChunks()
for chunk in self.chunks:
self.chunksBox.addItem(chunk.label, chunk.key)
self.label_brightness = QtWidgets.QLabel('Image brightness (%): ')
self.brightness = QtWidgets.QSpinBox()
self.brightness.setMaximum(500)
self.brightness.setSingleStep(20)
self.brightness.setMinimum(0)
self.brightness.setValue(100)
self.label_contrast = QtWidgets.QLabel('Image contrast (%): ')
self.contrast = QtWidgets.QSpinBox()
self.contrast.setMaximum(500)
self.contrast.setSingleStep(20)
self.contrast.setMinimum(0)
self.contrast.setValue(100)
self.label_folder = QtWidgets.QLabel('Select folder : ')
self.btn_select_folder = QtWidgets.QPushButton("Select...")
self.btn_select_folder.setFixedSize(150, 23)
self.path_label = QtWidgets.QLabel('Selected Path : ...')
self.space = QtWidgets.QLabel(' ')
self.chunk_create_label = QtWidgets.QLabel("Create new Chunk")
self.chkCreateChunk = QtWidgets.QCheckBox()
self.chkCreateChunk.setChecked(True)
# adding widget
gridParamsLayout.addWidget(self.label_chunk, 0, 0)
gridParamsLayout.addWidget(self.chunksBox, 0, 1)
gridParamsLayout.addWidget(self.label_folder, 0, 2)
gridParamsLayout.addWidget(self.btn_select_folder, 0, 3)
gridParamsLayout.addWidget(self.label_brightness, 1, 0)
gridParamsLayout.addWidget(self.brightness, 1, 1)
gridParamsLayout.addWidget(self.path_label, 1, 2)
gridParamsLayout.addWidget(self.label_contrast, 2, 0)
gridParamsLayout.addWidget(self.contrast, 2, 1)
gridParamsLayout.addWidget(self.chunk_create_label, 2, 2)
gridParamsLayout.addWidget(self.chkCreateChunk, 2, 3)
QtCore.QObject.connect(
self.btn_select_folder, QtCore.SIGNAL("clicked()"), self.selectFolder)
self.chunksBox.currentIndexChanged.connect(self.getChunk)
self.brightness.valueChanged.connect(self.getPixmapFromEnhance)
self.contrast.valueChanged.connect(self.getPixmapFromEnhance)
self.groupBoxParams.setLayout(gridParamsLayout)
def createProgressBar(self):
self.groupBoxProgressBar = QtWidgets.QGroupBox()
gridProgressBar = QtWidgets.QGridLayout()
self.progressBar = QtWidgets.QProgressBar()
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(100)
gridProgressBar.addWidget(self.progressBar, 0, 0)
self.groupBoxProgressBar.setLayout(gridProgressBar)
def zoomIn(self):
self.scaleImage(1.25)
def zoomOut(self):
self.scaleImage(0.8)
def normalSize(self):
self.imageLabel.adjustSize()
self.scaleFactor = 1.0
def scaleImage(self, factor):
self.scaleFactor *= factor
self.imageLabel.resize(
self.scaleFactor * self.imageLabel.pixmap().size())
self.adjustScrollBar(self.scrollArea.horizontalScrollBar(), factor)
self.adjustScrollBar(self.scrollArea.verticalScrollBar(), factor)
def adjustScrollBar(self, scrollBar, factor):
scrollBar.setValue(int(factor * scrollBar.value()
+ ((factor - 1) * scrollBar.pageStep()/2)))
def fitToWindow(self, fitToWindow):
self.scrollArea.setWidgetResizable(fitToWindow)
if not fitToWindow:
self.normalSize()
def getChunks(self):
self.chunks = Metashape.app.document.chunks
if len(self.chunks) == 0:
Metashape.app.messageBox('No chunk in project')
def getChunk(self):
chunk_key = self.chunksBox.currentData()
self.chunk = doc.findChunk(chunk_key)
self.brightness.setValue(100)
self.contrast.setValue(100)
self.getPaths()
self.getImage(0)
def selectFolder(self):
directoryPath = QtWidgets.QFileDialog.getExistingDirectory(
self, "Select Directory")
dossier = directoryPath.split('/')[-1]
path = 'Selected Path : {}'.format(directoryPath)
self.path_label.setText(path)
self.btnSubmit.setEnabled(True)
self.path_folder = directoryPath
def getPaths(self):
self.paths = []
for c in self.chunk.cameras:
path = c.photo.path
self.paths.append(path)
if len(self.paths) == 0:
Metashape.app.messageBox('No photos in this chunk')
def getImage(self, index):
self.path_photo = self.paths[index]
self.image = QtGui.QPixmap(self.path_photo)
self.imageLabel.setPixmap(self.image)
def nextPhoto(self):
index = self.paths.index(self.path_photo)
if index == len(self.paths) - 1:
index = 0
else:
index = index + 1
self.path_photo = self.paths[index]
self.getPixmapFromEnhance()
def previousPhoto(self):
index = self.paths.index(self.path_photo)
if index == 0:
index = len(self.paths) - 1
else:
index = index - 1
self.path_photo = self.paths[index]
self.getPixmapFromEnhance()
def adjustImage(self, image):
brghitness = self.brightness.value() / 100
contrast = self.contrast.value() / 100
imageEnhancer = ImageEnhance.Brightness(image)
imgBright = imageEnhancer.enhance(brghitness)
imageEnhancer = ImageEnhance.Contrast(imgBright)
imgContrast = imageEnhancer.enhance(contrast)
return imgContrast
def getPixmapFromEnhance(self):
image = Image.open(self.path_photo)
img = self.adjustImage(image)
self.image = img.toqimage()
self.image = QtGui.QPixmap(self.image)
self.imageLabel.setPixmap(self.image)
image.close()
def get_exif(self, image):
exif = image._getexif()
return exif
def add_new_chunk(self, images):
doc = Metashape.app.document
new_chunk = doc.addChunk()
new_chunk.label = 'Adjusted ' + self.chunk.label
new_chunk.addPhotos(images)
def copyPhots(self, c):
self.i = self.i + 1
self.progressBar.setValue(self.i)
source = c.photo.path
destination = self.path_folder
path_without_drive = os.path.splitdrive(source)[1]
subfolder = os.path.splitext(path_without_drive)[0]
path_to_photo = os.path.split(path_without_drive)[0]
folders = path_to_photo.split('/')
path_dist = destination + path_to_photo
path_dist = path_dist.replace(self.commun_without_drive, '')
try:
if not os.path.exists(path_dist):
os.makedirs(path_dist)
image = Image.open(source)
exif = self.get_exif(image)
enhancer = self.adjustImage(image)
path = path_dist + '/' + c.label + '.jpg'
enhancer.save(
path, exif=image.info["exif"])
self.imageList.append(path)
image.close()
except RuntimeError:
Metashape.app.messageBox('error')
def adjustChunkPhotos(self):
print("Import Adjust Photos Script started...")
self.imageList = []
commun = os.path.commonpath(self.paths)
commun_without_drive = os.path.splitdrive(commun)[1]
self.commun_without_drive = commun_without_drive.replace('\\', '/')
total = len(self.chunk.cameras)
self.progressBar.setMaximum(total)
self.i = 0
# with concurrent.futures.ThreadPoolExecutor() as executor:
# executor.map(self.copyPhots, self.chunk.cameras)
for c in self.chunk.cameras:
self.copyPhots(c)
QtWidgets.QApplication.processEvents()
if self.chkCreateChunk.isChecked():
self.add_new_chunk(self.imageList)
self.close()
print("Script finished!")
# Metashape.app.messageBox('Adjusting and Copy successful !')
return True
class PrettySL(QWidget):
"""
This is the base widget to contain the graph view of the cutscene.
:param MainFrame mainframe: application mainframe
:param QWidget op: parent widget
"""
def __init__(self, mainframe, op):
QWidget.__init__(self)
self.mainframe = mainframe
self.op = op
self.graph = self.op.link
self.table = self.op.link.items
self.lastButtonPressed = None
self.needsRefresh = False
self.tree = None
self.subtree = []
self.delete = None
# View initializations...
self.lab = None
self.idLabel = None
self.edit = None
self.lkst = None
self.rels = None
self.initData()
self.initUI()
def initData(self):
"""
Initialize the data to be used.
"""
self.lab = None
self.actionIDs = self.graph.getIDs()
self.actionObjs = []
for act in self.table:
self.actionObjs.append(act[0])
def initUI(self):
"""
Initializes the GUI.
Does lots of stuff.
"""
self.grid = QGridLayout()
self.setLayout(self.grid)
self.tree = TreeWidget(self, self.actionObjs, self.actionIDs,
self.table)
self.scrollArea = QScrollArea()
self.scrollArea.setBackgroundRole(QPalette.Dark)
self.scrollArea.setWidget(self.tree)
if self.tree.rect().width() < 600:
self.scrollArea.setFixedWidth(self.tree.rect().width() + 25)
else:
self.scrollArea.setFixedWidth(600)
if self.tree.rect().height() < 600:
self.scrollArea.setFixedHeight(self.tree.rect().height())
else:
self.scrollArea.setFixedHeight(600)
self.scrollArea.ensureWidgetVisible(self.tree, 500, 500)
self.grid.addWidget(self.scrollArea, 0, 0, 10, 3)
self.legend = Legend(self)
self.grid.addWidget(self.legend, 0, 3, 1, 2)
self.setWindowModality(Qt.ApplicationModal)
self.show()
def trackIndex(self, index):
"""
Update the Tree and info views with a new index.
:param int index: the new index
"""
self.needsRefresh = True
self.lastButtonPressed = index
self.subtree = self.graph.subTree(index)
# Request all the lines and boxes be redrawn.
self.tree.update()
self.initInfoUI(index)
def deleteSubtree(self):
"""
Delete the subtree of the current selected index.
"""
if not popup(
"Are you certain you want to delete this item and it's subtree?\n(Everything in red and"
" yellow will be deleted)", "Warning"):
return
self.graph.delItem(self.lastButtonPressed)
self.lab.close()
self.initData()
self.lastButtonPressed = None
self.delete.close()
self.delete = None
self.subtree = []
self.needsRefresh = True
self.idLabel.close()
self.edit.clicked.disconnect()
self.edit.close()
self.op.linkstored.save()
self.tree.close()
self.tree = TreeWidget(self, self.actionObjs, self.actionIDs,
self.table)
self.grid.addWidget(self.tree, 0, 0, 10, 3)
def initInfoUI(self, index):
"""
Initialize the node info GUI.
Does a lot of stuff.
:param int index: index of node to display info for
"""
if not self.lab:
self.lab = QLabel(self, text="Selected element summary:")
self.grid.addWidget(self.lab, 2, 3, 1, 2)
idt = ""
if isinstance(self.table[index][0], Speak):
idt += self.table[index][0].speaker + " says:\n\n"
idt += self.actionIDs[index]
self.idLabel = QLabel(self, text=idt)
self.idLabel.setFixedSize(300, 40)
self.idLabel.setWordWrap(True)
self.grid.addWidget(self.idLabel, 3, 3, 1, 2)
self.edit = QPushButton(self, text="Edit")
self.edit.clicked.connect(lambda: self.enter(index))
self.grid.addWidget(self.edit, 4, 3, 1, 2)
self.lkst = QLabel(self, text="Selected element links to:")
self.grid.addWidget(self.lkst, 5, 3, 1, 2)
self.rels = QLabel(self)
self.rels.setMaximumWidth(300)
text = ""
for relation in self.table[index][1:len(self.table[index])]:
text += "(" + str(relation) + ") " + self.graph.getOneID(
self.table[relation][0]) + "\n\n"
self.rels.setText(text)
self.grid.addWidget(self.rels, 6, 3, 1, 2)
else:
text = ""
idt = ""
if isinstance(self.table[index][0], Speak):
idt += self.table[index][0].speaker + " says:\n\n"
idt += self.actionIDs[index]
self.idLabel.setText(idt)
for relation in self.table[index][1:len(self.table[index])]:
text += "(" + str(relation) + ") " + self.graph.getOneID(
self.table[relation][0]) + "\n\n"
self.rels.setText(text)
self.edit.clicked.disconnect()
self.edit.clicked.connect(lambda: self.enter(index))
if not self.delete:
self.delete = QPushButton(self, text="Delete element and subtree")
self.delete.clicked.connect(self.deleteSubtree)
self.grid.addWidget(self.delete, 1, 3, 1, 2)
def enter(self, index):
"""
Leave the graph view and edit a node.
:param int index: index of node to edit
"""
load = self.graph.getItem(index)
self.close()
self.op.view.setText("Graphic View")
self.op.view.clicked.disconnect()
self.op.view.clicked.connect(lambda: self.op.viewF(True))
self.op.listview.changeFrame(load, index)
class DatasheetView(QMainWindow):
def __init__(self, pdfPath=None, openPages=[1]):
super().__init__()
if pdfPath:
self.myPdfContext = PDFContext(pdfPath, openPages)
# store diretory for debugging purposes
self.svgDirectory = self.myPdfContext.directory
# window dimensions
self.top = 300
self.left = 800
self.width = 860
self.height = 980
self.setGeometry(self.left, self.top, self.width, self.height)
# window title
self.setWindowTitle("BetterSheets")
# sets up main layout -- splitters
self.initUILayout()
self.initUIToolbar()
self.initToC()
# self.initPdfViewer() # must be called after initUI to ensure PDFContext object exists
self.show()
print(self.mainDisplay.getVisibleChild())
def initUILayout(self):
# set left-side, Dynamic View
self.dynamicViewDisplay = QLabel()
self.vBoxA = QVBoxLayout()
self.vBoxA.addWidget(self.dynamicViewDisplay)
self.groupA = QGroupBox()
self.groupA.setTitle("Dynamic Veiw")
self.groupA.setLayout(self.vBoxA)
# set left-side, Static View
self.staticViewDisplay = QLabel()
self.vBoxB = QVBoxLayout()
self.vBoxB.addWidget(self.staticViewDisplay)
self.groupB = QGroupBox()
self.groupB.setTitle("Static View")
self.groupB.setLayout(self.vBoxB)
# add Dynamic and Static Views to resizeable left-side Splitter
self.altViewSplit = QSplitter(Qt.Vertical)
self.altViewSplit.addWidget(self.groupA)
self.altViewSplit.addWidget(self.groupB)
# set up Tools View section
self.toolsTabView = QTabWidget()
self.toolsTabView.setTabsClosable(True)
self.toolsTabView.setMovable(True)
self.toolsTabView.setDocumentMode(True)
# self.toolsTabView.setTabBarAutoHide(True)
# add attribute for storing page notes
self.notesDB = []
self.notesDisplay = QListWidget(self)
self.notesDisplay.setMaximumHeight(200)
# add ToC to Tools View
self.ToCListView = QListWidget()
self.toolsTabView.addTab(self.ToCListView, "Table of Contents")
# add notes list to tools view
self.toolsTabView.addTab(self.notesDisplay, "Notes")
# add tools view to the left-side splitter
self.altViewSplit.addWidget(self.toolsTabView)
# set up main viewport
self.mainDisplay = QDatasheetPageDisplayWidget(self.myPdfContext)
self.mainDisplay.renderPages(1, 4)
self.mainScroller = QScrollArea(self)
self.mainScroller.setWidget(self.mainDisplay)
self.mainScroller.setWidgetResizable(True)
self.mainScroller.setBackgroundRole(QtGui.QPalette.Dark)
self.mainScroller.setFixedHeight(800)
print(self.mainScroller.viewport().childrenRect())
# set up document tools
self.hBoxDocTools = QHBoxLayout()
self.searchLabel = QLabel("Search: ")
self.searchBox = QLineEdit()
self.searchBox.setPlaceholderText("Search")
# self.
self.vBoxMain = QVBoxLayout()
self.vBoxMain.addWidget(self.mainScroller)
self.notesArea = QLineEdit()
self.notesArea.setPlaceholderText("Add a note about this page...")
self.notesArea.returnPressed.connect(self.onAddNote)
self.vBoxMain.addWidget(self.notesArea)
self.mainViewGroup = QGroupBox()
self.mainViewGroup.setTitle("Main View")
self.mainViewGroup.setLayout(self.vBoxMain)
# join both sides together
self.leftRightSplit = QSplitter(Qt.Horizontal)
self.leftRightSplit.addWidget(self.altViewSplit)
self.leftRightSplit.addWidget(self.mainViewGroup)
self.setCentralWidget(self.leftRightSplit)
def initUIToolbar(self):
mainMenu = self.menuBar(
) # get the menu bar already in use by this QMainWindow subclass
fileMenu = mainMenu.addMenu("File")
editMenu = mainMenu.addMenu("Edit")
LayoutMenu = mainMenu.addMenu("Layout")
AboutMenu = mainMenu.addMenu("About")
saveAction = fileMenu.addAction("Save")
quitAction = fileMenu.addAction("Exit Bettersheets")
quitAction.triggered.connect(self.quitApp)
copyAction = editMenu.addAction("Copy")
resetAction = LayoutMenu.addAction("Reset Default Layout")
self.toolBar = self.addToolBar("Tools")
self.toolBar.addAction(saveAction)
self.toolBar.addAction(copyAction)
def contextMenuEvent(self, event):
# return super().contextMenuEvent(event)
contextMenu = QMenu()
selectAction = contextMenu.addAction("Select Area")
extractAction = contextMenu.addAction("Extract Content")
openAction = contextMenu.addAction("Open PDF")
closeAction = contextMenu.addAction("Close PDF")
quitAction = contextMenu.addAction("Quit")
triggered_action = contextMenu.exec_(self.mapToGlobal(event.pos()))
if triggered_action == quitAction:
self.quitApp()
def quitApp(self):
self.close()
def onAddNote(self):
print("note added")
text = self.notesArea.text()
if text:
self.notesDB.append(text)
self.notesDisplay.clear()
self.notesDisplay.addItems(self.notesDB)
self.notesArea.clear()
def initPdfViewer(self, openPages: int):
pass
def initToC(self):
# get table of contents
ToC = self.myPdfContext.getToC()
ToC_headings_list = [x[1] for x in ToC]
self.ToCListView.clear()
self.ToCListView.addItems(ToC_headings_list)
class MainApp(QWidget):
def __init__(self):
QWidget.__init__(self)
self.initial_x = 100
self.initial_y = 100
self.video_size = QSize(640, 480)
self.scale = 1.0
self.pause = False
self.setup_ui()
self.setup_camera()
def setup_ui(self):
"""Initialize widgets.
"""
# self.setStyleSheet('background-color: rgb(50, 50, 50);')
self.image_label = QLabel()
self.image_label.setGeometry(self.initial_x, self.initial_y,
self.initial_x + self.video_size.width(),
self.initial_y + self.video_size.height())
self.image_label.setMinimumSize(640, 480)
self.scrolling_image_label = QScrollArea()
self.scrolling_image_label.setBackgroundRole(QPalette.Dark)
self.scrolling_image_label.setWidget(self.image_label)
self.img = cv2.imread('test_imgs/4.jpg')
_, self.save_video_button, _, self.quit_and_save_layout = ui.create_save_and_quit(
self.capture_photo, self.capture_video, self.close)
self.photo = PhotoViewer(self)
self.photo.setMinimumSize(640, 480)
self.contrast_slider, self.contrast_layout = ui.create_slider(
'contrast', 33, 99, self.change_contrast)
self.brightness_slider, self.brightness_layout = ui.create_slider(
'brightness', 1, 100, self.change_brightness)
self.trace_slider, self.trace_layout = ui.create_slider(
'trace', 20, 300, self.change_trace_threshold)
self.sharpen_button, self.enhance_button, self.trace_button, self.pause_button, self.toggle_layout = ui.create_toggle(
self.change_sharpen, self.change_enhance, self.change_trace,
self.pause_stream)
self.main_layout = QVBoxLayout()
self.main_layout.addWidget(self.photo)
self.main_layout.addLayout(self.quit_and_save_layout)
self.main_layout.addLayout(self.contrast_layout)
self.main_layout.addLayout(self.brightness_layout)
self.main_layout.addLayout(self.trace_layout)
self.main_layout.addLayout(self.toggle_layout)
self.setLayout(self.main_layout)
def setup_camera(self):
"""Initialize camera.
"""
self.capture = cv2.VideoCapture(0)
self.capture.set(cv2.CAP_PROP_FRAME_WIDTH, self.video_size.width())
self.capture.set(cv2.CAP_PROP_FRAME_HEIGHT, self.video_size.height())
self.contrast = 1.0
self.brightness = 1.0
self.trace_threshold = 20.0
self.sharpen = False
self.enhance = False
self.trace = False
self.timer = QTimer()
self.timer.timeout.connect(self.display_video_stream)
self.timer.start(30)
# self.timer.timeout.connect(self.display_image_stream)
# self.timer.start(1000)
def display_image_stream(self):
# self.beta = (self.beta + 10) % 100
self.frame = p.process_contrast_frame(self.img,
self.contrast,
self.brightness,
enhance=self.enhance,
sharpen=self.sharpen,
trace=self.trace)
image = QImage(
self.frame,
self.frame.shape[1],
self.frame.shape[0],
# self.frame.strides[0], self.QImage.Format_RGB888)
self.frame.strides[0],
QImage.Format_Grayscale8)
pixmap = QPixmap.fromImage(image).scaledToWidth(
self.video_size.width())
self.scrolling_image_label.setGeometry(
self.initial_x, self.initial_y,
self.initial_x + self.video_size.width(),
self.initial_y + self.video_size.height())
self.scrolling_image_label.setPixmap(pixmap)
self.photo.setPhoto(pixmap)
def display_video_stream(self):
"""Read frame from camera and repaint QLabel widget.
"""
if not self.pause:
_, self.raw_img = self.capture.read()
self.frame = p.process_contrast_frame(self.raw_img,
self.contrast,
self.brightness,
self.trace_threshold,
enhance=self.enhance,
sharpen=self.sharpen,
trace=self.trace)
if self.save_video_button.is_recording:
self.save_video_button.write_img(self.frame)
image = QImage(
self.frame,
self.frame.shape[1],
self.frame.shape[0],
# self.frame.strides[0], self.QImage.Format_RGB888)
self.frame.strides[0],
QImage.Format_Grayscale8)
pixmap = QPixmap.fromImage(image).scaledToWidth(
self.video_size.width())
# self.image_label.setGeometry(self.initial_x, self.initial_y, self.initial_x + self.video_size.width(), self.initial_y + self.video_size.height())
# self.image_label.setPixmap(pixmap)
# self.photo._photo.setPixmap(pixmap)
self.photo.setPhotoContinuous(pixmap)
def resizeEvent(self, event):
# Resize the video_size based on the current window size
# Don't set the size here directly, though
self.video_size = QSize(self.frameGeometry().width() - 40,
self.frameGeometry().height() - 96)
def capture_photo(self):
im = Image.fromarray(self.frame)
fname = QFileDialog.getSaveFileName(self, 'Save File As',
"Captures/untitled.png",
"Images (*.png *.jpg)")
im.save(fname[0])
def capture_video(self):
pass # empty function
def pause_stream(self):
self.pause = not self.pause
def change_contrast(self):
self.contrast = self.contrast_slider.value()
self.contrast = self.contrast / 33.0 # keep range in 1.0-3.0
def change_brightness(self):
self.brightness = self.brightness_slider.value()
def change_trace_threshold(self):
self.trace_threshold = self.trace_slider.value()
def change_sharpen(self):
self.sharpen = not self.sharpen
def change_enhance(self):
self.enhance = not self.enhance
def change_trace(self):
self.trace = not self.trace
class PipedImagerPQ(QMainWindow):
'''
A PyQt graphics viewer that receives images and commands through
a pipe.
A command is a dictionary with string keys. For example,
{ "action":"save",
"filename":"ferret.png",
"fileformat":"png" }
The command { "action":"exit" } will shutdown the viewer.
'''
def __init__(self, cmndpipe, rspdpipe):
'''
Create a PyQt viewer which reads commands from the Pipe
cmndpipe and writes responses back to rspdpipe.
'''
super(PipedImagerPQ, self).__init__()
self.__cmndpipe = cmndpipe
self.__rspdpipe = rspdpipe
# ignore Ctrl-C
signal.signal(signal.SIGINT, signal.SIG_IGN)
# unmodified image for creating the scene
self.__sceneimage = None
# bytearray of data for the above image
self.__scenedata = None
# flag set if in the process of reading image data from commands
self.__loadingimage = False
# width and height of the unmodified scene image
# when the image is defined
# initialize the width and height to values that will create
# a viewer (mainWindow) of the right size
self.__scenewidth = int(10.8 * self.physicalDpiX())
self.__sceneheight = int(8.8 * self.physicalDpiY())
# by default pay attention to any alpha channel values in colors
self.__noalpha = False
# initial default color for the background (opaque white)
self.__lastclearcolor = QColor(0xFFFFFF)
self.__lastclearcolor.setAlpha(0xFF)
# scaling factor for creating the displayed scene
self.__scalefactor = 1.0
# automatically adjust the scaling factor to fit the window frame?
self.__autoscale = True
# minimum label width and height (for minimum scaling factor)
# and minimum image width and height (for error checking)
self.__minsize = 128
# create the label, that will serve as the canvas, in a scrolled area
self.__scrollarea = QScrollArea(self)
self.__label = QLabel(self.__scrollarea)
# set the initial label size and other values for the scrolled area
self.__label.setMinimumSize(self.__scenewidth, self.__sceneheight)
self.__label.resize(self.__scenewidth, self.__sceneheight)
# setup the scrolled area
self.__scrollarea.setWidget(self.__label)
self.__scrollarea.setBackgroundRole(QPalette.Dark)
self.setCentralWidget(self.__scrollarea)
# default file name and format for saving the image
self.__lastfilename = "ferret.png"
self.__lastformat = "png"
# command helper object
self.__helper = CmndHelperPQ(self)
# create the menubar
self.__scaleact = QAction(
self.tr("&Scale"),
self,
shortcut=self.tr("Ctrl+S"),
statusTip=self.tr(
"Scale the image (canvas and image change size)"),
triggered=self.inquireSceneScale)
self.__saveact = QAction(self.tr("Save &As..."),
self,
shortcut=self.tr("Ctrl+A"),
statusTip=self.tr("Save the image to file"),
triggered=self.inquireSaveFilename)
self.__redrawact = QAction(
self.tr("&Redraw"),
self,
shortcut=self.tr("Ctrl+R"),
statusTip=self.tr("Clear and redraw the image"),
triggered=self.redrawScene)
self.__aboutact = QAction(
self.tr("&About"),
self,
statusTip=self.tr("Show information about this viewer"),
triggered=self.aboutMsg)
self.__aboutqtact = QAction(
self.tr("About &Qt"),
self,
statusTip=self.tr("Show information about the Qt library"),
triggered=self.aboutQtMsg)
self.createMenus()
# set the initial size of the viewer
self.__framedelta = 4
mwwidth = self.__scenewidth + self.__framedelta
mwheight = self.__sceneheight + self.__framedelta \
+ self.menuBar().height() \
+ self.statusBar().height()
self.resize(mwwidth, mwheight)
# check the command queue any time there are no window events to deal with
self.__timer = QTimer(self)
self.__timer.timeout.connect(self.checkCommandPipe)
self.__timer.setInterval(0)
self.__timer.start()
def createMenus(self):
'''
Create the menu items for the viewer
using the previously created actions.
'''
menuBar = self.menuBar()
sceneMenu = menuBar.addMenu(menuBar.tr("&Image"))
sceneMenu.addAction(self.__scaleact)
sceneMenu.addAction(self.__saveact)
sceneMenu.addAction(self.__redrawact)
helpMenu = menuBar.addMenu(menuBar.tr("&Help"))
helpMenu.addAction(self.__aboutact)
helpMenu.addAction(self.__aboutqtact)
def resizeEvent(self, event):
'''
Monitor resizing in case auto-scaling of the image is selected.
'''
if self.__autoscale:
if self.autoScaleScene():
# continue with the window resize
event.accept()
else:
# another resize coming in, so ignore this one
event.ignore()
else:
# continue with the window resize
event.accept()
def closeEvent(self, event):
'''
Clean up and send the WINDOW_CLOSED_MESSAGE on the response pipe
before closing the window.
'''
self.__timer.stop()
self.__cmndpipe.close()
try:
try:
self.__rspdpipe.send(WINDOW_CLOSED_MESSAGE)
finally:
self.__rspdpipe.close()
except Exception:
pass
event.accept()
def exitViewer(self):
'''
Close and exit the viewer.
'''
self.close()
def aboutMsg(self):
QMessageBox.about(self, self.tr("About PipedImagerPQ"),
self.tr("\n" \
"PipedImagerPQ is a graphics viewer application that receives its " \
"displayed image and commands primarily from another application " \
"through a pipe. A limited number of commands are provided by the " \
"viewer itself to allow saving and some manipulation of the " \
"displayed image. The controlling application, however, may be " \
"unaware of these modifications made to the image. " \
"\n\n" \
"PipedImagerPQ was developed by the Thermal Modeling and Analysis " \
"Project (TMAP) of the National Oceanographic and Atmospheric " \
"Administration's (NOAA) Pacific Marine Environmental Lab (PMEL). "))
def aboutQtMsg(self):
QMessageBox.aboutQt(self, self.tr("About Qt"))
def ignoreAlpha(self):
'''
Return whether the alpha channel in colors should always be ignored.
'''
return self.__noalpha
def updateScene(self):
'''
Clear the displayed scene using self.__lastclearcolor,
then draw the scaled current image.
'''
# get the scaled scene size
labelwidth = int(self.__scalefactor * self.__scenewidth + 0.5)
labelheight = int(self.__scalefactor * self.__sceneheight + 0.5)
# Create the new pixmap for the label to display
newpixmap = QPixmap(labelwidth, labelheight)
newpixmap.fill(self.__lastclearcolor)
if self.__sceneimage != None:
# Draw the scaled image to the pixmap
mypainter = QPainter(newpixmap)
trgrect = QRectF(0.0, 0.0, float(labelwidth), float(labelheight))
srcrect = QRectF(0.0, 0.0, float(self.__scenewidth),
float(self.__sceneheight))
mypainter.drawImage(trgrect, self.__sceneimage, srcrect,
Qt.AutoColor)
mypainter.end()
# Assign the new pixmap to the label
self.__label.setPixmap(newpixmap)
# set the label size and values
# so the scrollarea knows of the new size
self.__label.setMinimumSize(labelwidth, labelheight)
self.__label.resize(labelwidth, labelheight)
# update the label from the new pixmap
self.__label.update()
def clearScene(self, bkgcolor=None):
'''
Deletes the scene image and fills the label with bkgcolor.
If bkgcolor is None or an invalid color, the color used is
the one used from the last clearScene or redrawScene call
with a valid color (or opaque white if a color has never
been specified).
'''
# get the color to use for clearing (the background color)
if bkgcolor:
if bkgcolor.isValid():
self.__lastclearcolor = bkgcolor
# Remove the image and its bytearray
self.__sceneimage = None
self.__scenedata = None
# Update the scene label using the current clearing color and image
self.updateScene()
def redrawScene(self, bkgcolor=None):
'''
Clear and redraw the displayed scene.
'''
# get the background color
if bkgcolor:
if bkgcolor.isValid():
self.__lastclearcolor = bkgcolor
# Update the scene label using the current clearing color and image
QApplication.setOverrideCursor(Qt.WaitCursor)
self.statusBar().showMessage(self.tr("Redrawing image"))
try:
self.updateScene()
finally:
self.statusBar().clearMessage()
QApplication.restoreOverrideCursor()
def resizeScene(self, width, height):
'''
Resize the scene to the given width and height in units of pixels.
If the size changes, this deletes the current image and clear the
displayed scene.
'''
newwidth = int(width + 0.5)
if newwidth < self.__minsize:
newwidth = self.__minsize
newheight = int(height + 0.5)
if newheight < self.__minsize:
newheight = self.__minsize
if (newwidth != self.__scenewidth) or (newheight !=
self.__sceneheight):
# set the new size for the empty scene
self.__scenewidth = newwidth
self.__sceneheight = newheight
# If auto-scaling, set scaling factor to 1.0 and resize the window
if self.__autoscale:
self.__scalefactor = 1.0
barheights = self.menuBar().height() + self.statusBar().height(
)
self.resize(newwidth + self.__framedelta,
newheight + self.__framedelta + barheights)
# clear the scene with the last clearing color
self.clearScene(None)
def loadNewSceneImage(self, imageinfo):
'''
Create a new scene image from the information given in this
and subsequent dictionaries imageinfo. The image is created
from multiple calls to this function since there is a limit
on the size of a single object passed through a pipe.
The first imageinfo dictionary given when creating an image
must define the following key and value pairs:
"width": width of the image in pixels
"height": height of the image in pixels
"stride": number of bytes in one line of the image
in the bytearray
The scene image data is initialized to all zero (transparent)
at this time.
This initialization call must be followed by (multiple) calls
to this method with imageinfo dictionaries defining the key
and value pairs:
"blocknum": data block number (1, 2, ... numblocks)
"numblocks": total number of image data blocks
"startindex": index in the bytearray of image data
where this block of image data starts
"blockdata": this block of data as a bytearray
On receipt of the last block of data (blocknum == numblocks)
the scene image will be created and the scene will be updated.
Raises:
KeyError - if one of the above keys is not given
ValueError - if a value for a key is not valid
'''
if not self.__loadingimage:
# prepare for a new image data from subsequent calls
# get dimensions of the new image
myimgwidth = int(imageinfo["width"])
myimgheight = int(imageinfo["height"])
myimgstride = int(imageinfo["stride"])
if (myimgwidth < self.__minsize) or (myimgheight < self.__minsize):
raise ValueError(
"image width and height cannot be less than %s" %
str(self.__minsize))
# Newer PyQt versions allow separate specification of the stride
if myimgstride != 4 * myimgwidth:
raise ValueError(
"image stride is not four times the image width")
# create the bytearray to contain the new scene data
# automatically initialized to zero
self.__scenedata = bytearray(myimgstride * myimgheight)
self.__scenewidth = myimgwidth
self.__sceneheight = myimgheight
# set the flag for subsequent calls to this method
self.__loadingimage = True
# change the cursor to warn the user this may take some time
QApplication.setOverrideCursor(Qt.WaitCursor)
# put up an appropriate status message
self.statusBar().showMessage(self.tr("Loading new image"))
return
# loading an image; add the next block of data
myblocknum = int(imageinfo["blocknum"])
mynumblocks = int(imageinfo["numblocks"])
mystartindex = int(imageinfo["startindex"])
myblockdata = imageinfo["blockdata"]
if (myblocknum < 1) or (myblocknum > mynumblocks):
self.statusBar().clearMessage()
QApplication.restoreOverrideCursor()
raise ValueError(
"invalid image data block number or number of blocks")
if (mystartindex < 0) or (mystartindex >= len(self.__scenedata)):
self.statusBar().clearMessage()
QApplication.restoreOverrideCursor()
raise ValueError("invalid start index for an image data block")
myblocksize = len(myblockdata)
myendindex = mystartindex + myblocksize
if (myblocksize < 1) or (myendindex > len(self.__scenedata)):
self.statusBar().clearMessage()
QApplication.restoreOverrideCursor()
raise ValueError("invalid length of an image data block")
# update the status message to show progress
self.statusBar().showMessage( self.tr("Loading new image (block %s of %s)" % \
(str(myblocknum),str(mynumblocks))) )
# assign the data
self.__scenedata[mystartindex:myendindex] = myblockdata
# if this is the last block of data, create and display the scene image
if myblocknum == mynumblocks:
self.__loadingimage = False
self.statusBar().showMessage(self.tr("Creating new image"))
try:
self.__sceneimage = QImage(self.__scenedata, self.__scenewidth,
self.__sceneheight,
QImage.Format_ARGB32_Premultiplied)
self.statusBar().showMessage(self.tr("Drawing new image"))
# update the displayed scene in the label
self.updateScene()
finally:
# clear the status message
self.statusBar().clearMessage()
# restore the cursor back to normal
QApplication.restoreOverrideCursor()
def inquireSceneScale(self):
'''
Prompt the user for the desired scaling factor for the scene.
'''
labelwidth = int(self.__scenewidth * self.__scalefactor + 0.5)
labelheight = int(self.__sceneheight * self.__scalefactor + 0.5)
scaledlg = ScaleDialogPQ(self.__scalefactor, labelwidth, labelheight,
self.__minsize, self.__minsize,
self.__autoscale, self)
if scaledlg.exec_():
(newscale, autoscale, okay) = scaledlg.getValues()
if okay:
if autoscale:
self.__autoscale = True
self.autoScaleScene()
else:
self.__autoscale = False
self.scaleScene(newscale, False)
def autoScaleScene(self):
'''
Selects a scaling factor that maximizes the scene within the window
frame without requiring scroll bars. Intended to be called when
the window size is changed by the user and auto-scaling is turn on.
Returns:
True if scaling of this scene is done (no window resize)
False if the a window resize command was issued
'''
barheights = self.menuBar().height() + self.statusBar().height()
# get the size for the central widget
cwheight = self.height() - barheights - self.__framedelta
heightsf = float(cwheight) / float(self.__sceneheight)
cwwidth = self.width() - self.__framedelta
widthsf = float(cwwidth) / float(self.__scenewidth)
if heightsf < widthsf:
factor = heightsf
else:
factor = widthsf
newcwheight = int(factor * self.__sceneheight + 0.5)
newcwwidth = int(factor * self.__scenewidth + 0.5)
# if the window does not have the correct aspect ratio, resize it so
# it will; this will generate another call to this method. Otherwise,
# scale the scene and be done.
if self.isMaximized() or \
( (abs(cwheight - newcwheight) <= self.__framedelta) and \
(abs(cwwidth - newcwwidth) <= self.__framedelta) ):
self.scaleScene(factor, False)
return True
else:
self.resize(newcwwidth + self.__framedelta,
newcwheight + self.__framedelta + barheights)
return False
def scaleScene(self, factor, resizewin):
'''
Scales both the horizontal and vertical directions by factor.
Scaling factors are not accumulative. So if the scene was
already scaled, that scaling is "removed" before this scaling
factor is applied. If resizewin is True, the main window is
resized to accommodate this new scaled scene size.
If factor is zero, just switch to auto-scaling at the current
window size. If factor is negative, rescale using the absolute
value (possibly resizing the window) then switch to auto-scaling.
'''
fltfactor = float(factor)
if fltfactor != 0.0:
if resizewin:
# from command - turn off autoscaling for the following
# then turn back on if appropriate
self.__autoscale = False
newfactor = abs(fltfactor)
newlabwidth = int(newfactor * self.__scenewidth + 0.5)
newlabheight = int(newfactor * self.__sceneheight + 0.5)
if (newlabwidth < self.__minsize) or (newlabheight <
self.__minsize):
# Set to minimum size
if self.__scenewidth <= self.__sceneheight:
newfactor = float(self.__minsize) / float(
self.__scenewidth)
else:
newfactor = float(self.__minsize) / float(
self.__sceneheight)
newlabwidth = int(newfactor * self.__scenewidth + 0.5)
newlabheight = int(newfactor * self.__sceneheight + 0.5)
oldlabwidth = int(self.__scalefactor * self.__scenewidth + 0.5)
oldlabheight = int(self.__scalefactor * self.__sceneheight + 0.5)
if (newlabwidth != oldlabwidth) or (newlabheight != oldlabheight):
# Set the new scaling factor
self.__scalefactor = newfactor
# Update the scene label using the current clearing color and image
QApplication.setOverrideCursor(Qt.WaitCursor)
self.statusBar().showMessage(self.tr("Scaling image"))
try:
self.updateScene()
finally:
self.statusBar().clearMessage()
QApplication.restoreOverrideCursor()
if resizewin:
# resize the main window (if possible)
barheights = self.menuBar().height() + self.statusBar().height(
)
mwheight = newlabheight + barheights + self.__framedelta
mwwidth = newlabwidth + self.__framedelta
# Do not exceed the available real estate on the screen.
# If autoscaling is in effect, the resize will trigger
# any required adjustments.
scrnrect = QApplication.desktop().availableGeometry()
if mwwidth > 0.95 * scrnrect.width():
mwwidth = int(0.9 * scrnrect.width() + 0.5)
if mwheight > 0.95 * scrnrect.height():
mwheight = int(0.9 * scrnrect.height() + 0.5)
self.resize(mwwidth, mwheight)
if fltfactor <= 0.0:
# From command - turn on autoscaling
self.__autoscale = True
self.autoScaleScene()
def inquireSaveFilename(self):
'''
Prompt the user for the name of the file into which to save the scene.
The file format will be determined from the filename extension.
'''
formattypes = [
("png", "PNG - Portable Networks Graphics (*.png)"),
("jpeg",
"JPEG - Joint Photographic Experts Group (*.jpeg *.jpg *.jpe)"),
("tiff", "TIFF - Tagged Image File Format (*.tiff *.tif)"),
("bmp", "BMP - Windows Bitmap (*.bmp)"),
("ppm", "PPM - Portable Pixmap (*.ppm)"),
("xpm", "XPM - X11 Pixmap (*.xpm)"),
("xbm", "XBM - X11 Bitmap (*.xbm)"),
]
filters = ";;".join([t[1] for t in formattypes])
if PYTHONQT_VERSION == 'PyQt4':
# getSaveFileNameAndFilter; tr returns QStrings in PyQt4 (Python2)
(fileName, fileFilter) = QFileDialog.getSaveFileNameAndFilter(
self, self.tr("Save the current image as "),
self.tr(self.__lastfilename), self.tr(filters))
else:
# getSaveFileName; tr returns Python unicode strings in PySide2 and PyQt5 (Python3)
(fileName, fileFilter) = QFileDialog.getSaveFileName(
self, self.tr("Save the current image as "),
self.tr(self.__lastfilename), self.tr(filters))
if fileName:
for (fmt, fmtQName) in formattypes:
if self.tr(fmtQName) == fileFilter:
fileFormat = fmt
break
else:
raise RuntimeError("Unexpected file format name '%s'" %
fileFilter)
self.saveSceneToFile(fileName, fileFormat, None, None)
self.__lastfilename = fileName
self.__lastformat = fileFormat
def saveSceneToFile(self, filename, imageformat, transparent, rastsize):
'''
Save the current scene to the named file.
If imageformat is empty or None, the format is guessed from
the filename extension.
If transparent is False, the entire scene is initialized
to the last clearing color.
If given, rastsize is the pixels size of the saved image.
If rastsize is not given, the saved image will be saved
at the current scaled image size.
'''
# This could be called when there is no image present.
# If this is the case, ignore the call.
if (self.__sceneimage == None):
return
if not imageformat:
# Guess the image format from the filename extension
# This is only done to silently change gif to png
fileext = (os.path.splitext(filename)[1]).lower()
if fileext == '.gif':
myformat = 'gif'
else:
# let QImage figure out the format
myformat = None
else:
myformat = imageformat.lower()
if myformat == 'gif':
# Silently convert gif filename and format to png
myformat = 'png'
myfilename = os.path.splitext(filename)[0] + ".png"
else:
myfilename = filename
# set the cursor and status message to indicate a save is happending
QApplication.setOverrideCursor(Qt.WaitCursor)
self.statusBar().showMessage(self.tr("Saving image"))
try:
if rastsize:
imagewidth = int(rastsize.width() + 0.5)
imageheight = int(rastsize.height() + 0.5)
else:
imagewidth = int(self.__scenewidth * self.__scalefactor + 0.5)
imageheight = int(self.__sceneheight * self.__scalefactor +
0.5)
myimage = QImage(QSize(imagewidth, imageheight),
QImage.Format_ARGB32_Premultiplied)
# Initialize the image
if not transparent:
# Clear the image with self.__lastclearcolor
fillint = self.__helper.computeARGB32PreMultInt(
self.__lastclearcolor)
else:
fillint = 0
myimage.fill(fillint)
# draw the scaled scene to this QImage
mypainter = QPainter(myimage)
trgrect = QRectF(0.0, 0.0, float(imagewidth), float(imageheight))
srcrect = QRectF(0.0, 0.0, float(self.__scenewidth),
float(self.__sceneheight))
mypainter.drawImage(trgrect, self.__sceneimage, srcrect,
Qt.AutoColor)
mypainter.end()
# save the image to file
if not myimage.save(myfilename, myformat):
raise ValueError("Unable to save the plot as " + myfilename)
finally:
self.statusBar().clearMessage()
QApplication.restoreOverrideCursor()
def checkCommandPipe(self):
'''
Get and perform commands waiting in the pipe.
Stop when no more commands or if more than 50
milliseconds have passed.
'''
try:
if (sys.version_info[0] >= 3) and (sys.version_info[1] >= 3):
starttime = time.process_time()
else:
starttime = time.clock()
# Wait up to 2 milliseconds waiting for a command.
# This prevents unchecked spinning when there is
# nothing to do (Qt immediately calling this method
# again only for this method to immediately return).
while self.__cmndpipe.poll(0.002):
cmnd = self.__cmndpipe.recv()
self.processCommand(cmnd)
# Continue to try to process commands until
# more than 50 milliseconds have passed.
# This reduces Qt overhead when there are lots
# of commands waiting in the queue.
if (sys.version_info[0] >= 3) and (sys.version_info[1] >= 3):
elapsed = time.process_time() - starttime
else:
elapsed = time.clock() - starttime
if elapsed > 0.050:
break
except EOFError:
# Assume PyFerret has shut down
self.exitViewer()
except Exception:
# Some problem, but presumably still functional
(exctype, excval) = sys.exc_info()[:2]
try:
if excval:
self.__rspdpipe.send("**ERROR %s: %s" %
(str(exctype), str(excval)))
else:
self.__rspdpipe.send("**ERROR %s" % str(exctype))
except Exception:
pass
def processCommand(self, cmnd):
'''
Examine the action of cmnd and call the appropriate
method to deal with this command. Raises a KeyError
if the "action" key is missing.
'''
try:
cmndact = cmnd["action"]
except KeyError:
raise ValueError("Unknown command '%s'" % str(cmnd))
if cmndact == "clear":
try:
bkgcolor = self.__helper.getColorFromCmnd(cmnd)
except KeyError:
bkgcolor = None
self.clearScene(bkgcolor)
elif cmndact == "exit":
self.exitViewer()
elif cmndact == "hide":
self.showMinimized()
elif cmndact == "screenInfo":
scrnrect = QApplication.desktop().availableGeometry()
info = (self.physicalDpiX(), self.physicalDpiY(), scrnrect.width(),
scrnrect.height())
self.__rspdpipe.send(info)
elif cmndact == "redraw":
try:
bkgcolor = self.__helper.getColorFromCmnd(cmnd)
except KeyError:
bkgcolor = None
self.redrawScene(bkgcolor)
elif cmndact == "rescale":
self.scaleScene(float(cmnd["factor"]), True)
elif cmndact == "resize":
mysize = self.__helper.getSizeFromCmnd(cmnd)
self.resizeScene(mysize.width(), mysize.height())
elif cmndact == "newImage":
self.loadNewSceneImage(cmnd)
elif cmndact == "save":
filename = cmnd["filename"]
fileformat = cmnd.get("fileformat", None)
try:
bkgcolor = self.__helper.getColorFromCmnd(cmnd)
except KeyError:
bkgcolor = None
rastsize = self.__helper.getSizeFromCmnd(cmnd["rastsize"])
self.saveSceneToFile(filename, fileformat, bkgcolor, rastsize)
elif cmndact == "setTitle":
self.setWindowTitle(cmnd["title"])
elif cmndact == "imgname":
myvalue = cmnd.get("name", None)
if myvalue:
self.__lastfilename = myvalue
myvalue = cmnd.get("format", None)
if myvalue:
self.__lastformat = myvalue.lower()
elif cmndact == "show":
if not self.isVisible():
self.show()
elif cmndact == "noalpha":
# ignore any alpha channel values in colors
self.__noalpha = True
else:
raise ValueError("Unknown command action %s" % str(cmndact))
class MyWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.thread = SerialMonitorThread()
self.thread.dataReady.connect(self.get_data, Qt.QueuedConnection)
self.thread.setTerminationEnabled(True)
#Menu
self.setPalette(get_verifone_color())
collapsible = CollapsibleWidget()
self.init_logging(collapsible)
self.init_download(collapsible)
self.init_analyser(collapsible)
collapsible.add_sections()
# Scroll Area
self.createLoggingDisplayLabel()
self.scrollArea = QScrollArea()
self.scrollArea.setBackgroundRole(QPalette.Dark)
self.scrollArea.setWidget(self.text)
self.scrollArea.setWidgetResizable(True)
hLayout = QHBoxLayout()
#hLayout.addLayout(vLayout)
hLayout.addWidget(collapsible)
hLayout.addWidget(self.scrollArea)
self.setLayout(hLayout)
def init_logging(self, collapsible):
self.logger = QPushButton("Start Logging", self)
self.logger.setFont(QFont("Times", 14, QFont.Bold))
self.logger.clicked.connect(lambda: self.display_log_data())
self.logger.setStyleSheet("background-color: white")
#self.filterLayout = QtWidgets.QHBoxLayout()
self.logFilterLabel = QLabel('Filter', self)
self.logFilterLabel.setFont(QFont("Times", 14, QFont.Bold))
self.logFilterLabel.setPalette(get_white_color_text())
self.logFilterLabel.setFixedWidth(60)
self.logFilter = QLineEdit(self)
self.logFilter.setPalette(get_white_color())
self.logFilter.setStyleSheet("background-color: white")
self.logFilter.setFixedWidth(200)
#self.filterLayout.addWidget(self.logFilterLabel, QtCore.Qt.AlignLeft)
#self.filterLayout.addWidget(self.logFilter, QtCore.Qt.AlignLeft)
self.serialList = QComboBox()
ports = get_available_serial_ports()
if (len(ports) == 1):
self.serialList.addItem(ports[0])
self.thread.set_comport(self.serialList.currentText())
else:
self.serialList.addItem("Select")
for port in ports:
self.serialList.addItem(port)
self.serialList.currentIndexChanged.connect(
lambda: self.set_serial_port())
self.serialList.setStyleSheet("background-color: white")
self.clear = QPushButton("Clear Log File", self)
self.clear.setStyleSheet("background-color: white")
self.clear.setFont(QFont("Times", 14, QFont.Bold))
self.clear.clicked.connect(lambda: self.clear_data())
widget = QFrame(collapsible.get_tree())
widget.setPalette(get_verifone_color())
title = "Logging"
self.loggerGrid = QGridLayout(widget)
self.loggerGrid.addWidget(self.logger, 0, 0, 1, 2)
self.loggerGrid.addWidget(self.logFilterLabel, 1, 0, 1, 1)
self.loggerGrid.addWidget(self.logFilter, 1, 1, 1, 1)
self.loggerGrid.addWidget(self.serialList, 2, 0, 1, 2)
self.loggerGrid.addWidget(self.clear, 3, 0, 1, 2)
collapsible.include_section(title, widget)
def init_download(self, collapsible):
self.download = QPushButton("Download Package", self)
self.download.setFont(QFont("Times", 14, QFont.Bold))
self.download.clicked.connect(lambda: self.send_file())
self.download.setStyleSheet("background-color: white")
self.loadDownloadFile = QPushButton("Load File", self)
self.loadDownloadFile.setFont(QFont("Times", 14, QFont.Bold))
self.loadDownloadFile.clicked.connect(self.loadFromFile)
self.loadDownloadFile.setStyleSheet("background-color: white")
self.downloadFileName = QLineEdit("File name", self)
self.downloadFileName.setStyleSheet("background-color: white")
self.downloadFileName.setFixedWidth(300)
self.downloadAddress = QLineEdit("IP Address", self)
self.downloadAddress.setStyleSheet("background-color: white")
self.downloadAddress.setFixedWidth(300)
self.downloadStatus = QLabel("Download Status", self)
self.downloadStatus.setStyleSheet(
"background-color: rgba(3, 169, 229, 0); color : white")
self.downloadStatus.setFixedWidth(300)
widget = QFrame(collapsible.get_tree())
title = "Download"
self.downloadGrid = QGridLayout(widget)
self.downloadGrid.addWidget(self.download, 0, 0, 1, 2)
self.downloadGrid.addWidget(self.loadDownloadFile, 1, 0, 1, 2)
self.downloadGrid.addWidget(self.downloadFileName, 2, 0, 1, 2)
self.downloadGrid.addWidget(self.downloadAddress, 3, 0, 1, 2)
self.downloadGrid.addWidget(self.downloadStatus, 4, 0, 1, 2)
collapsible.include_section(title, widget)
def init_analyser(self, collapsible):
self.performanceData = QPushButton("View Performance Data", self)
self.performanceData.setFont(QFont("Times", 14, QFont.Bold))
self.performanceData.clicked.connect(
lambda: self.display_performance_data())
self.performanceData.setStyleSheet("background-color: white")
self.performanceChart = QPushButton("View Performance Chart", self)
self.performanceChart.setFont(QFont("Times", 14, QFont.Bold))
self.performanceChart.clicked.connect(
lambda: self.display_performance_chart())
self.performanceChart.setStyleSheet("background-color: white")
widget = QFrame(collapsible.get_tree())
title = "Analyser"
self.analyserGrid = QGridLayout(widget)
self.analyserGrid.addWidget(self.performanceData, 0, 0, 1, 2)
self.analyserGrid.addWidget(self.performanceChart, 1, 0, 1, 2)
collapsible.include_section(title, widget)
def loadFromFile(self):
fileName, _ = QFileDialog.getOpenFileName(
self, "Load Package", '', "Download Files (*.tgz);;All Files (*)")
if not fileName:
return
try:
in_file = open(str(fileName), 'rb')
except IOError:
QMessageBox.information(
self, "Unable to open file",
"There was an error opening \"%s\"" % fileName)
return
in_file.close()
self.downloadFileName.setText(fileName)
def createLoggingDisplayLabel(self):
# Display Area
self.text = QPlainTextEdit(self)
self.text.setReadOnly(True)
self.text.setFont(QFont("Times", 12, QFont.Bold))
self.text.setTextInteractionFlags(Qt.TextSelectableByMouse
| Qt.TextSelectableByKeyboard)
def clear_data(self):
self.text.clear()
os.remove(logfile_path, dir_fd=None)
def display_log_data(self):
#send_file()
if ('COM' in self.serialList.currentText()):
self.createLoggingDisplayLabel()
self.scrollArea.setWidget(self.text)
self.thread.stop()
self.thread.start()
data = get_data_from_file(logfile_path)
if (len(data) > 0 and data != None):
self.text.appendPlainText(data)
self.logger.setDisabled(True)
def get_data(self, data):
if (len(data) > 0):
logFile = open(logfile_path, "a")
logFile.write(data)
logFile.close()
filterText = self.logFilter.text()
if filterText in data.rstrip():
self.text.appendPlainText(data.rstrip())
vbar = self.scrollArea.verticalScrollBar()
vbar.setValue(vbar.maximum())
def display_performance_data(self):
self.thread.stop()
data = get_data_from_file(logfile_path)
jsonData = translate_data_to_json(data)
self.performanceData = DisplayPerformanceData()
self.performanceData.loadCsv(
os.path.join(base_log_path, "performance_data.csv"))
self.scrollArea.setWidget(self.performanceData)
self.logger.setDisabled(False)
def display_performance_chart(self):
self.thread.stop()
self.scrollArea.setWidget(get_performace_chart())
self.logger.setDisabled(False)
def set_serial_port(self):
self.thread.set_comport(self.serialList.currentText())
def send_file(self):
base_path = os.path.join("c:/", "VFI", 'wks',
'global-payment-application', 'GPA', 'output',
'vos2', 'gpa', 'dl.gpa-1.0.0.0-000.tgz')
fileName = self.downloadFileName.text()
try:
in_file = open(str(fileName), 'rb')
except IOError:
QMessageBox.information(
self, "Unable to open file",
"There was an error opening \"%s\"" % fileName)
return
in_file.close()
load_vos_package_ip('192.168.0.104', fileName, self.downloadStatus)
