def saveFileAs(self):
dir = QDir()
docsPath = '{}/Documents'.format(dir.homePath())
if not dir.exists(docsPath):
docsPath = '{}/Documentos'.format(dir.homePath())
#Regresa una tupla (filename, filter)
filename = QFileDialog.getSaveFileName(self, 'Guardar como', docsPath,
self.fileFilter)
if not filename: return
if self.filename:
windowTitle = self.windowTitle().split('-')[0]
self.setWindowTitle('{} - {}'.format(windowTitle, filename[0]))
else:
self.setWindowTitle('{} - {}'.format(self.windowTitle(),
filename[0]))
self.filename = filename[0]
file = QFile(self.filename)
if not file.open(QIODevice.WriteOnly): return
data = self.textContent.toPlainText()
stream = QTextStream(file)
stream.setCodec('UTF-8')
stream << data
file.flush()
file.close()
self.showMessage('Archivo guardado')
def PreprocessedQSS() -> str:
lines = []
qss_file = QFile(Loader.STYLE_FILE_PATH)
if qss_file.open(QIODevice.ReadOnly | QFile.Text):
stream = QTextStream(qss_file)
stream.setCodec("UTF-8")
while not stream.atEnd():
lines.append(stream.readLine().rstrip("\n"))
qss_file.close()
qss_vars = {}
qss_body = ""
for i, l in enumerate(lines):
l = l.strip()
if len(l) == 0:
continue
if l.startswith("//"):
continue
if l[0] == "@":
if not l.endswith(";"):
print(
"[WARNING] QSSPreprocessor : Parsing error at line %d for '%s' (missing semicolon)"
% (i, l))
l = l.rstrip(";")
s = l.split(":")
if len(s) < 2:
print(
"[WARNING] QSSPreprocessor : Parsing error at line %d for '%s' (missing colon)"
% (i, l))
continue
qss_vars[s[0].strip()] = s[1].strip()
else:
qss_body += l
qss_vars_names = list(qss_vars.keys())
qss_vars_names.sort()
qss_vars_names.reverse()
for k in qss_vars_names:
qss_body = qss_body.replace(k, qss_vars[k])
Loader._qss_variables[k] = qss_vars[k]
return qss_body
def SpongesMorphotypes() -> dict:
if len(Loader._sponges_morphotypes) == 0:
content = ""
file = QFile(Loader.MORPHOTYPES_FILE_PATH)
if file.open(QIODevice.ReadOnly | QFile.Text):
stream = QTextStream(file)
stream.setCodec("UTF-8")
content = stream.readAll()
file.close()
obj = json.loads(content)
for i, m in enumerate(obj):
Loader._sponges_morphotypes[i] = Morphotype(
m["name"], QColor(m["color"]))
return Loader._sponges_morphotypes
def saveFile(self):
if not self.filename:
self.saveFileAs()
return
file = QFile(self.filename)
if not file.open(QIODevice.WriteOnly): return
data = self.textContent.toPlainText()
stream = QTextStream(file)
stream.setCodec('UTF-8')
stream << data
file.flush()
file.close()
self.showMessage('Archivo guardado')
def _dependenciesComboBoxChanged(self, idx: int):
data = self._dependencies_list.currentData()
self._version.setText(data["version"])
self._license.setText(data["license"])
self._author.setText(data["author"])
self._link.setText("<a href='%s'>%s</a>" %
(data["link"], data["link"]))
license_file = QFile(":/documents/licenses/%s" % data["license-file"])
text = ""
if license_file.open(QIODevice.ReadOnly | QFile.Text):
stream = QTextStream(license_file)
stream.setCodec("UTF-8")
text = stream.readAll()
license_file.close()
self._license_area.setText(text)
class QTextStreamGetSet(unittest.TestCase):
def setUp(self):
self.obj = QTextStream()
def testCodec(self):
'''QTextStream set/get Codec'''
codec = QTextCodec.codecForName('ISO8859-1')
self.obj.setCodec(codec)
self.assertEqual(codec, self.obj.codec())
def testDevice(self):
'''QTextStream get/set Device'''
device = QFile()
self.obj.setDevice(device)
self.assertEqual(device, self.obj.device())
self.obj.setDevice(None)
self.assertEqual(None, self.obj.device())
class QTextStreamGetSet(unittest.TestCase):
def setUp(self):
self.obj = QTextStream()
def testCodec(self):
'''QTextStream set/get Codec'''
codec = QTextCodec.codecForName('ISO8859-1')
self.obj.setCodec(codec)
self.assertEqual(codec, self.obj.codec())
def testDevice(self):
'''QTextStream get/set Device'''
device = QFile()
self.obj.setDevice(device)
self.assertEqual(device, self.obj.device())
self.obj.setDevice(None)
self.assertEqual(None, self.obj.device())
class QSingleApplication(QApplication):
onMassageRecived = Signal(str) # Text Massege Event;
def init(self, uid: str) -> bool:
""" Try To Connect or Create : If Created Then Return True """
self._stream_str: Optional[QTextStream] = None
self._server: Optional[QLocalServer] = None
self._socket: Optional[QLocalSocket] = None
self._uid: str = uid
if not self.__connect():
self.__createServer()
return True
return False
def sendTextMassege(self, msg: str):
""" Send A Text Massege To Running Instance """
if self._socket and self._stream_str and not self._server:
self._stream_str << msg << '\n'
self._stream_str.flush()
return self._socket.waitForBytesWritten()
else:
return False
def __connect(self):
""" Create A Local Socket And Try To Connect """
if self._socket:
self._socket.close()
socket = QLocalSocket()
socket.connectToServer(self._uid)
connected = socket.waitForConnected()
if not connected:
socket.close()
return False
self._socket = socket
self._stream_str = QTextStream(self._socket)
self._stream_str.setCodec('UTF-8')
return True
def __createServer(self):
""" Create A Server & Listen as UID """
self._server = QLocalServer()
self._server.listen(self._uid)
self._server.newConnection.connect(self.__onNewConnection)
def __onNewConnection(self):
""" On New Socket Connection From Clint """
if self._socket:
self._socket.readyRead.disconnect(self.__onReadyRead)
self._socket = self._server.nextPendingConnection()
if not self._socket:
return
self._stream_str = QTextStream(self._socket)
self._stream_str.setCodec('UTF-8')
self._socket.readyRead.connect(self.__onReadyRead)
def __onReadyRead(self):
""" Stream Ready To Read """
while True:
msg = self._stream_str.readLine()
if not msg:
break
self.onMassageRecived.emit(msg)
class SingleApplication(QApplication):
messageReceived = Signal()
def __init__(self, id, *argv):
super(SingleApplication, self).__init__(*argv)
self._id = id
self._activationWindow = None
self._activateOnMessage = False
# Is there another instance running?
self._outSocket = QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected()
if self._isRunning:
# Yes, there is.
self._outStream = QTextStream(self._outSocket)
self._outStream.setCodec('UTF-8')
else:
# No, there isn't.
self._outSocket = None
self._outStream = None
self._inSocket = None
self._inStream = None
self._server = QLocalServer()
self._server.listen(self._id)
self._server.newConnection.connect(self._onNewConnection)
def isRunning(self):
return self._isRunning
def id(self):
return self._id
def activationWindow(self):
return self._activationWindow
def setActivationWindow(self, activationWindow, activateOnMessage=True):
self._activationWindow = activationWindow
self._activateOnMessage = activateOnMessage
def activateWindow(self):
if not self._activationWindow:
return
self._activationWindow.show()
self._activationWindow.setWindowState((
self._activationWindow.windowState() & ~Qt.WindowMinimized)
| Qt.WindowActive)
SetWindowPos(
self._activationWindow.winId(),
# = always on top. only reliable way to bring it to the front on windows
win32con.HWND_TOPMOST,
0,
0,
0,
0,
win32con.SWP_NOMOVE | win32con.SWP_NOSIZE
| win32con.SWP_SHOWWINDOW)
# Do not reset topmost; for monitor control this is set...
# SetWindowPos(self._activationWindow.winId(),
# # disable the always on top, but leave window at its top position
# win32con.HWND_NOTOPMOST,
# 0, 0, 0, 0,
# win32con.SWP_NOMOVE | win32con.SWP_NOSIZE | win32con.SWP_SHOWWINDOW)
# self._activationWindow.raise_()
self._activationWindow.activateWindow()
def sendMessage(self, msg):
if not self._outStream:
return False
self._outStream << msg << '\n'
self._outStream.flush()
return self._outSocket.waitForBytesWritten()
def _onNewConnection(self):
if self._inSocket:
self._inSocket.readyRead.disconnect(self._onReadyRead)
self._inSocket = self._server.nextPendingConnection()
if not self._inSocket:
return
self._inStream = QTextStream(self._inSocket)
self._inStream.setCodec('UTF-8')
self._inSocket.readyRead.connect(self._onReadyRead)
if self._activateOnMessage:
self.activateWindow()
def _onReadyRead(self):
while True:
msg = self._inStream.readLine()
if not msg:
break
self.messageReceived.emit(msg)
class QtSingleApplication(QApplication):
messageReceived = Signal()
def __init__(self, id, *argv):
super(QtSingleApplication, self).__init__(*argv)
self._id = id
self._activationWindow = None
self._activateOnMessage = False
# Is there another instance running?
self._outSocket = QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected()
if self._isRunning:
# Yes, there is.
self._outStream = QTextStream(self._outSocket)
self._outStream.setCodec('UTF-8')
else:
# No, there isn't.
self._outSocket = None
self._outStream = None
self._inSocket = None
self._inStream = None
self._server = QLocalServer()
self._server.listen(self._id)
self._server.newConnection.connect(self._onNewConnection)
def isRunning(self):
return self._isRunning
def id(self):
return self._id
def activationWindow(self):
return self._activationWindow
def setActivationWindow(self, activationWindow, activateOnMessage=True):
self._activationWindow = activationWindow
self._activateOnMessage = activateOnMessage
def activateWindow(self):
if not self._activationWindow:
return
self._activationWindow.setWindowState(
self._activationWindow.windowState() & ~Qt.WindowMinimized)
self._activationWindow.raise_()
self._activationWindow.activateWindow()
def sendMessage(self, msg):
if not self._outStream:
return False
self._outStream << msg << '\n'
self._outStream.flush()
return self._outSocket.waitForBytesWritten()
def _onNewConnection(self):
if self._inSocket:
self._inSocket.readyRead.disconnect(self._onReadyRead)
self._inSocket = self._server.nextPendingConnection()
if not self._inSocket:
return
self._inStream = QTextStream(self._inSocket)
self._inStream.setCodec('UTF-8')
self._inSocket.readyRead.connect(self._onReadyRead)
if self._activateOnMessage:
self.activateWindow()
def _onReadyRead(self):
while True:
msg = self._inStream.readLine()
if not msg:
break
self.messageReceived.emit(msg)
def text(self) -> str:
content = ""
file = QFile(":/documents/report_template.html")
if file.open(QIODevice.ReadOnly | QFile.Text):
stream = QTextStream(file)
stream.setCodec("UTF-8")
content = stream.readAll()
file.close()
# Summary
content = content.replace("{{TITLE}}", self._analysis._parameters.name())
content = content.replace("{{ANALYSED_IMAGES}}", str(self._analysis.imagesCount()))
content = content.replace("{{START_DATE}}", self._analysis.startDateTime().toString("dd/MM/yyyy 'à' hh:mm"))
content = content.replace("{{END_DATE}}", self._analysis.endDateTime().toString("dd/MM/yyyy 'à' hh:mm"))
# Parameters
selected_morphotypes_names = [m.name() for m in self._analysis.parameters().selectedMorphotypes().values()]
content = content.replace("{{ANALYSED_FOLDER}}", self._analysis.parameters().srcFolder())
content = content.replace("{{CONFIDENCE_THRESHOLD}}", "%.1f%%" % (self._analysis.parameters().threshold()*100))
content = content.replace("{{SELECTED_MORPHOTYPES}}", ", ".join(selected_morphotypes_names))
content = content.replace("{{OPT_SAVE_PROCESSED_IMAGES}}", str(self._analysis.parameters().saveProcessedImages()))
if self._analysis.parameters().saveProcessedImages():
content = content.replace("{{PROCESSED_IMAGES_FOLDER}}", self._analysis.parameters().destFolder())
# Detections
morphotypes_stats = ""
total_progress = ""
total = self._analysis.totalDetections()
div_by = total
if div_by == 0:
div_by = 1
for morphotype_id, morphotype in self._analysis.parameters().selectedMorphotypes().items():
detections = self._analysis.cumulativeDetectionsFor(morphotype_id)
morphotypes_stats += """
<div class="stat-item">
<div class="stat-item-header">
<span class="name">%s</span>
<span class="count">%s (%.1f%%)</span>
</div>
<div class="progress-container">
<div class="progress" style="width: %.1f%%; background-color: %s"></div>
</div>
</div>
""" % (morphotype.name(), detections, detections*100/div_by, detections*100/div_by, morphotype.color().name())
total_progress += """
<div class="progress" style="width: %.1f%%; background-color: %s"></div>
""" % (detections*100/div_by, morphotype.color().name())
content = content.replace("{{MORPHOTYPES_STATS}}", morphotypes_stats)
content = content.replace("{{TOTAL_PROGRESS}}", total_progress)
content = content.replace("{{TOTAL_DETECTIONS}}", str(total))
# Chart
content = content.replace("{{CHART_IMAGE}}", self._analysis.base64ChartImage())
legend_items = ""
for morphotype_id, morphotype in self._analysis.parameters().selectedMorphotypes().items():
legend_items += """
<div class="legend-item">
<div class="legend-item-color-container">
<div class="legend-item-color" style="background-color: %s"></div>
</div>
<div class="legend-item-name">%s</div>
</div>
""" % (morphotype.color().name(), morphotype.name())
content = content.replace("{{LEGEND_ITEMS}}", legend_items)
# Interest
image_items = ""
for processed_image_filename, base64_img in self._analysis.mostInterestingBase64Images().items():
image_items += """
<div class="images-item">
<div class="images-item-container">
<img src="%s">
<span>%s</span>
</div>
</div>
""" % (base64_img, processed_image_filename)
content = content.replace("{{IMAGE_ITEMS}}", image_items)
return content
class QtSingleApplication(QApplication):
messageReceived = Signal(str)
def __init__(self, id, *argv):
super(QtSingleApplication, self).__init__(*argv)
self._id = id
self._activationWindow = None
self._activateOnMessage = False
# Is there another instance running?
self._outSocket = QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected()
if self._isRunning:
# Yes, there is.
self._outStream = QTextStream(self._outSocket)
self._outStream.setCodec('UTF-8')
else:
# No, there isn't.
self._outSocket = None
self._outStream = None
self._inSocket = None
self._inStream = None
self._server = QLocalServer()
self._server.listen(self._id)
self._server.newConnection.connect(self._onNewConnection)
def isRunning(self):
return self._isRunning
def id(self):
return self._id
def activationWindow(self):
return self._activationWindow
def setActivationWindow(self, activationWindow, activateOnMessage=True):
self._activationWindow = activationWindow
self._activateOnMessage = activateOnMessage
def activateWindow(self):
if not self._activationWindow:
return
self._activationWindow.setWindowState(
self._activationWindow.windowState() & ~Qt.WindowMinimized)
self._activationWindow.raise_()
self._activationWindow.activateWindow()
def sendMessage(self, msg):
if not self._outStream:
return False
self._outStream << msg << '\n'
self._outStream.flush()
return self._outSocket.waitForBytesWritten()
def _onNewConnection(self):
if self._inSocket:
self._inSocket.readyRead.disconnect(self._onReadyRead)
self._inSocket = self._server.nextPendingConnection()
if not self._inSocket:
return
self._inStream = QTextStream(self._inSocket)
self._inStream.setCodec('UTF-8')
self._inSocket.readyRead.connect(self._onReadyRead)
if self._activateOnMessage:
self.activateWindow()
def _onReadyRead(self):
while True:
msg = self._inStream.readLine()
if not msg: break
self.messageReceived.emit(msg)
