def unpack_csb_dummy():
res_path = Resource.icon_paths.get('DUMMY-Froebus')
if not res_path:
LOGGER.error('Resource paths did not contain CSB Material Dummy!')
return False
f = QFile(res_path)
out_file = Path(get_settings_dir()) / CSB_DUMMY_MATERIAL
if out_file.exists():
KnechtSettings.dg['csb_material_dummy_path'] = out_file.as_posix()
return True
try:
# Read resource data
f.open(QIODevice.ReadOnly)
data: QByteArray = f.readAll()
data: bytes = data.data()
# Write to file
with open(out_file, 'wb') as csb_file:
csb_file.write(data)
except Exception as e:
LOGGER.error(e)
return False
finally:
f.close()
LOGGER.debug('Unpacked CSB Material Dummy successfully.')
KnechtSettings.dg['csb_material_dummy_path'] = out_file.as_posix()
return True
def __init__(self, *args, **kwargs):
super(MenuWindow, self).__init__(*args, **kwargs)
# Loading Fonts
QFontDatabase.addApplicationFont("fonts/BebasNeue-Light.ttf")
# Window Settings
self.setFixedSize(1280, 720)
self.setWindowTitle("Systeme d'apprentissage base sur les reseaux de neurones")
#background = QPixmap("images/menu")
#palette = QPalette()
#palette.setBrush(QPalette.Background, background)
#self.setAttribute(Qt.WA_StyledBackground, True)
#self.setPalette(palette)
self.setAutoFillBackground(True)
background = QLabel(self)
movie = QMovie("images/menu")
background.setMovie(movie)
self.setCentralWidget(background)
movie.start()
# Stylesheet Settings
styleFile = QFile( "stylesheets/menu.qss" )
styleFile.open( QFile.ReadOnly )
style = str( styleFile.readAll() )
self.setStyleSheet( style )
# Title Settings
self.title = QLabel("Neural networks based learning system", self)
self.title.setFont(QFont("BebasNeue", 45, QFont.Bold))
self.title.setAlignment(Qt.AlignCenter)
self.title.setGeometry(0, 60, 1280, 120)
# Button Settings
self.buttons = []
for x in range(5) :
self.buttons.append(x)
self.buttons[x] = QPushButton(self)
self.buttons[x].setCursor(Qt.PointingHandCursor)
self.buttons[x].setObjectName("select")
self.buttons[x].setFont(QFont("BebasNeue", 15, QFont.Bold))
self.buttons[x].setGeometry(400, 210 + x * 100, 550, 80)
#self.buttons[x].clicked.connect(lambda : self.notifyMe(x))
self.buttons[0].setText("Image preprocessing")
self.buttons[1].setText("Text preprocessing")
self.buttons[2].setText("Learning")
self.buttons[3].setText("Testing")
self.buttons[4].setText("Quit")
#app = QApplication(sys.argv)
#window = MenuWindow()
#window.show()
#app.exec_()
def getFileBase64(self, path):
qfile = QFile(path)
if not qfile.open(QIODevice.ReadOnly):
return ""
else:
data = qfile.readAll()
qfile.close()
return str(data.toBase64().data().decode('utf-8'))
def load_qss(self):
path = os.path.join(os.path.dirname(__file__), "form.qss")
qss_file = QFile(path)
qss_file.open(QFile.ReadOnly)
if (qss_file.isOpen()):
styleArray = qss_file.readAll()
qss_file.close()
self.setStyleSheet(str(styleArray, encoding='utf-8'))
def importStyle():
file = QFile(':/qss/Resources/qss/ApplicationStyle.qss')
file.open(QIODevice.ReadOnly)
applicationStyle = file.readAll()
pyBytesStr = applicationStyle.data()
styleStr = pyBytesStr.decode('utf-8')
file.close()
return styleStr
def setup_styles(self):
file = QFile(":/styles/style.css")
file.open(QFile.ReadOnly)
byte_array = file.readAll()
file.close()
self.setStyleSheet(byte_array.data().decode())
def async_play_sound(self):
file = QFile(":/sounds/click.mp3")
file.open(QFile.ReadOnly)
byte_array = file.readAll()
file.close()
with tempfile.NamedTemporaryFile("wb", delete=True) as temp:
temp.write(byte_array.data())
playsound(temp.name)
def load_style(self):
"""
The style is a css-like file
"""
file = QFile(":/styles/style.qss")
file.open(QFile.ReadOnly)
style = file.readAll()
style = style.data().decode()
file.close()
self.setStyleSheet(style)
def testImage(self):
#Test loading of sample.png resource
f = open(adjust_filename('sample.png', __file__), "rb")
orig = f.read()
f.close()
f = QFile(':/sample.png')
f.open(QIODevice.ReadOnly)
copy = f.readAll()
f.close()
self.assertEqual(len(orig), len(copy))
self.assertEqual(orig, copy)
def testPhrase(self):
#Test loading of quote.txt resource
f = open(adjust_filename('quoteEnUS.txt', __file__), "r")
orig = f.read()
f.close()
f = QFile(':/quote.txt')
f.open(QIODevice.ReadOnly) #|QIODevice.Text)
print("Error:", f.errorString())
copy = f.readAll()
f.close()
self.assertEqual(orig, copy)
def testPhrase(self):
#Test loading of quote.txt resource
f = open(adjust_filename('quoteEnUS.txt', __file__), "r")
orig = f.read()
f.close()
f = QFile(':/quote.txt')
f.open(QIODevice.ReadOnly) #|QIODevice.Text)
print("Error:", f.errorString())
copy = f.readAll()
f.close()
self.assertEqual(orig, copy)
def testImage(self):
#Test loading of sample.png resource
f = open(adjust_filename('sample.png', __file__), "rb")
orig = f.read()
f.close()
f = QFile(':/sample.png')
f.open(QIODevice.ReadOnly)
copy = f.readAll()
f.close()
self.assertEqual(len(orig), len(copy))
self.assertEqual(orig, copy)
def _insert_alt1_api(self):
qwc_file = QFile(":/qtwebchannel/qwebchannel.js", parent=self)
if not qwc_file.open(QIODevice.ReadOnly):
raise IOError
src = bytes(qwc_file.readAll()).decode("utf8")
qwc_file.close()
src += "\n;;\n"
alt1_file = QFile(":/runekit/browser/alt1.js", parent=self)
if not alt1_file.open(QIODevice.ReadOnly):
raise IOError
src += bytes(alt1_file.readAll()).decode("utf8")
alt1_file.close()
script = QWebEngineScript()
script.setName("alt1.js")
script.setWorldId(QWebEngineScript.MainWorld)
script.setInjectionPoint(QWebEngineScript.DocumentCreation)
script.setSourceCode(src.replace("%%RPC_TOKEN%%", self.rpc_secret))
script.setRunsOnSubFrames(True)
self.scripts().insert(script)
def _load_default_pr_filter(self):
if self.PrDefaultFilter.interior:
# Filter already loaded
return
f = QFile(Resource.icon_paths.get('pr_data'))
try:
f.open(QIODevice.ReadOnly)
data: QByteArray = f.readAll()
data: bytes = data.data()
Settings.load_json_from_bytes(self.PrDefaultFilter, data)
except Exception as e:
LOGGER.error(e)
finally:
f.close()
def main(argv):
app = QApplication(argv)
file = QFile('style.txt')
if not file.open(QIODevice.ReadOnly):
print('Style sheet is not load')
return -1
w = MainWindow()
w.show()
stylesheet = file.readAll().data().decode()
app.setStyleSheet(stylesheet)
return app.exec_()
def save_default_parameters(self):
base_path = Path(__file__).parent
settings_path = str(
(base_path / '../resources/PRINTER_SETTINGS.json').resolve())
settings_file = QFile(settings_path)
file_data = {}
if settings_file.open(QIODevice.ReadOnly | QIODevice.Text):
file_data = QJsonDocument.fromJson(
settings_file.readAll()).object()
settings_file.close()
if settings_file.open(QIODevice.ReadWrite | QIODevice.Text
| QIODevice.Truncate):
file_data["printer_type"] = "DLP"
file_data["dlp_settings"] = self.__default_parameters
settings_file.write(QJsonDocument(file_data).toJson())
settings_file.close()
def init_model(self):
"""Init model that can be used to display all icons in a list."""
if self.searchterms:
return
qfile = QFile(":/fonts/fontawesome5-searchterms.json")
qfile.open(QIODevice.ReadOnly | QIODevice.Text)
data = str(qfile.readAll().data(), "utf-8")
qfile.close()
self.searchterms = json.loads(data)
items = []
for codepoint, searchterms in self.searchterms.items():
item = QStandardItem()
display_icon = int(codepoint, 16)
item.setData(display_icon, Qt.UserRole)
item.setData(searchterms, Qt.UserRole + 1)
items.append(item)
self.model.invisibleRootItem().appendRows(items)
def _load_template(self, file_key: str, display_file_path: Path):
f = QFile(Resource.icon_paths.get(file_key))
try:
f.open(QIODevice.ReadOnly)
data: QByteArray = f.readAll()
self.ui.main_menu.file_menu.load_save_mgr.load_start_time = time.time()
# noinspection PyTypeChecker
xml_worker = XmlWorkThread(
display_file_path,
self.ui.main_menu.file_menu.load_save_mgr.xml_worker_queue,
open_xml=False, # We want to load from bytes
xml_data=data.data() # The Qt docs are wrong... returns bytes and not str
)
xml_worker.xml_items_loaded.connect(self.ui.main_menu.file_menu.load_save_mgr.load_thread_finished)
xml_worker.start()
except Exception as e:
LOGGER.error(e)
def __load_settings__(self):
base_path = Path(__file__).parent
settings_path = str(
(base_path / '../resources/PRINTER_SETTINGS.json').resolve())
settings_file = QFile(settings_path)
if settings_file.open(QIODevice.ReadOnly | QIODevice.Text):
file_data = QJsonDocument.fromJson(
settings_file.readAll()).object()
if "metal_printer_settings" in file_data:
printer_setup = str(
file_data["metal_printer_settings"]["printer_setup"])
if printer_setup == self.supported_setups[0]:
self.__select_setup__(0)
else:
return False
return True
settings_file.close()
return False
def __on_triggered_openFileAction(self):
filePath = QFileDialog.getOpenFileName(self, "open",
self.__currentPath, "* txt")
if filePath[0].strip():
file = QFile(filePath[0])
if file.open(QFile.ReadOnly):
readData = str(file.readAll())
fileData = readData[2:readData.__len__() - 1].replace(
r"\r\n", r" ")
self.__srcTextEdit.insertPlainText(fileData)
else:
self.__statusBar.showMessage(
self.__GetCurrentTime() + " - open file failed!", 2000)
else:
self.__statusBar.showMessage(
self.__GetCurrentTime() + " - Choose file failed!", 2000)
return
def load_file(self):
"""加载外部文件获取文章"""
path = QFileDialog.getOpenFileName(self, "Open File", '',
"Any Files (*.*)")
if path:
try:
inFile = QFile(path[0])
if inFile.open(QFile.ReadOnly | QFile.Text):
text = str(inFile.readAll(), encoding='utf8')
_, filename = os.path.split(inFile.fileName())
self.refresh_control_post(
post_id=0,
title=filename,
url="",
data=text,
)
except Exception as ex:
self.statusBar().showMessage("文件读取错误:%s" % str(ex))
def restoreLayout(self):
if os.path.isfile(get_config_path("layout.dat")):
try:
f=open(get_config_path("layout.dat"), 'rb')
geometry, state=pickle.load(f)
self.restoreGeometry(geometry)
self.restoreState(state)
except Exception as e:
print("Exception on restoreLayout, {}".format(e))
else:
try:
f=QFile(':/default_layout.dat')
f.open(QIODevice.ReadOnly)
geometry, state=pickle.loads(f.readAll())
self.restoreGeometry(geometry)
self.restoreState(state)
except Exception as e:
print("Exception on restoreLayout, {}".format(e))
class Sender():
def __init__(self, socket, file_path, receiver):
self._socket = socket
self._transaction = None
self._receiver = receiver
self._file_path = file_path
self._file_name = os.path.split(self._file_path)[1]
self._file = QFile(self._file_path)
self._socket.connected.connect(self.send_file)
def start(self):
self._transaction = Transaction(self._file_path, self._file.size(),
self._receiver.get_name())
self._socket.connectToHost(self._receiver.get_ip_address(),
Setup().get_port())
self._socket.waitForConnected(3000)
print(self._socket.state())
def send_file(self):
self._transaction.set_status(TransactionStatus.SENDING)
file_to_byte_array = QByteArray()
data = QByteArray()
stream = QDataStream(data, QIODevice.WriteOnly)
QFile.open(self._file, QIODevice.ReadOnly)
stream.writeUInt32(0)
stream.writeString(self._file_name)
print("size of name ", getsizeof(self._file_name))
file_to_byte_array = self._file.readAll()
data.append(file_to_byte_array)
self._file.close()
stream.device().seek(0)
stream.writeUInt32(data.size() - getsizeof(self._file_name))
print("total ", data.size() - getsizeof(self._file_name))
x = 0
while (x < data.size()):
y = self._socket.write(data)
print("poslato ", y)
x += y
print("x ", x)
self._transaction.set_status(TransactionStatus.FINISHED)
def _load_default_filter(self):
""" Read Package default filter from qt resources """
f = QFile(Resource.icon_paths.get('pr_data'))
try:
f.open(QIODevice.ReadOnly)
data: QByteArray = f.readAll()
data: bytes = data.data()
Settings.load_json_from_bytes(PrJsonData, data)
except Exception as e:
LOGGER.error(e)
finally:
f.close()
self.data.pkg_filter = PrJsonData.package_filter[::]
self.automagic_filter = set(PrJsonData.wizard_automagic_filter)
# Update Start Page Package Widget
if hasattr(self.wizard, 'page_welcome'):
self.wizard.page_welcome.reload_pkg_filter()
def openFile(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.getOpenFileName(self, 'Abrir', docsPath,
self.fileFilter)
if not filename: return
self.filename = filename[0]
file = QFile(self.filename)
if not file.open(QIODevice.ReadOnly): return
data = file.readAll()
file.close()
self.textContent.clear()
self.textContent.setText(str(data, encoding='utf-8'))
self.setWindowTitle('{} - {}'.format(self.windowTitle(),
self.filename))
args = parser.parse_args(sys.argv[1:])
if args.debug:
print("Debug flag is set to:", args.debug)
clock = Clock_widget(args.frameless, web=args.web, debug=args.debug)
file = None
if args.style is None:
# file = QFile(":/Clock.qss")
file = QFile("Clock.qss")
else:
file = QFile(args.style)
file.open(QFile.ReadOnly)
style_sheet = file.readAll()
# print(style_sheet.data().decode("utf-8"))
app.setStyleSheet(style_sheet.data().decode("utf-8"))
if os.uname().sysname == "Linux":
f = open("/sys/class/backlight/rpi_backlight/brightness")
num = int(f.readline())
f.close()
else:
num = 40
clock.LCD_brightness = num
clock.Brightness.setSliderPosition(num)
setting_file = os.getenv("HOME") + "/.Qt_Clock"
loadfile = QFile(setting_file)
parser.add_argument("--size",
"-s",
type=int,
help="Size of the image to display",
default=216)
parser.add_argument("--web",
"-w",
action="store_true",
help="Get from web even if smaller than 500.")
parser.add_argument("--save",
"-sa",
action="store_true",
help="Save to file.")
args = parser.parse_args(sys.argv[1:])
file = None
if args.style is None:
file = QFile("Clock.qss")
else:
file = QFile(args.style)
file.open(QFile.ReadOnly)
style_sheet = file.readAll()
# print(style_sheet.data().decode("utf-8"))
app.setStyleSheet(style_sheet.data().decode("utf-8"))
moon = QMoon(size=args.size, debug=args.debug, save=True)
moon.show()
sys.exit(app.exec_())
def __init__(self, dataset, *args, **kwargs):
super(CreationWindow, self).__init__(*args, **kwargs)
# Initializing dataset
self.dataset = dataset
# Loading Fonts
QFontDatabase.addApplicationFont("fonts/BebasNeue-Light.ttf")
# Accepting drag & drops
self.setAcceptDrops(True)
# Window Settings
self.setFixedSize(1280, 720)
self.setWindowTitle("Neural network creation")
background = QPixmap("images/grid")
palette = QPalette()
palette.setBrush(QPalette.Background, background)
self.setPalette(palette)
self.setAttribute(Qt.WA_StyledBackground, True)
self.setAutoFillBackground(True)
# Enabling mouse tracking
self.setMouseTracking(True)
# Creating graphics scene
#self.__scene = QGraphicsScene(300, 120, 980, 600, self)
#self.__scene.addLine(400, 500, 600, 650, QPen(Qt.yellow, 10))
#self.__liveFeedView = QGraphicsView()
#self.__liveFeedView.setScene(self.__scene)
# Stylesheet Settings
styleFile = QFile("stylesheets/creation.qss")
styleFile.open(QFile.ReadOnly)
style = str(styleFile.readAll())
self.setStyleSheet(style)
# Network name line edit
self.networkName = QLineEdit(self)
self.networkName.setPlaceholderText("Enter neural network name")
# Netwok name label
self.__networkNameLabel = QLabel("Neural network name : ", self)
self.__networkNameLabel.setFont(QFont("BebasNeue", 20, QFont.Bold))
self.__networkNameLabel.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.__networkNameLabel.setBuddy(self.networkName)
# Accept/Reset buttons
self.__topRightButtons = []
for x in range(2):
self.__topRightButtons.append(x)
self.__topRightButtons[x] = QPushButton("Bouton ici", self)
self.__topRightButtons[x].setCursor(Qt.PointingHandCursor)
self.__topRightButtons[x].setIconSize(QSize(35, 35))
self.__topRightButtons[x].setFont(
QFont("BebasNeue", 10, QFont.Bold))
# Customising accept/reset buttons
self.__topRightButtons[0].setText("Reset")
self.__topRightButtons[0].setIcon(QIcon("images/reset_icon"))
self.__topRightButtons[1].setText("Confirm")
self.__topRightButtons[1].setIcon(QIcon("images/check_icon"))
# Connecting accept/reset buttons
self.__topRightButtons[0].clicked.connect(self.reset)
self.__topRightButtons[1].clicked.connect(self.confirm)
# Go back button
self.goBackButton = QPushButton("Back", self)
self.goBackButton.setObjectName("retour")
# Connecting go back button
self.goBackButton.clicked.connect(self.reset)
# Customising go back button
self.goBackButton.setCursor(Qt.PointingHandCursor)
self.goBackButton.setIcon(QIcon("images/goback_icon"))
self.goBackButton.setIconSize(QSize(30, 30))
self.goBackButton.setFont(QFont("BebasNeue", 20, QFont.Bold))
# Layer selection buttons
self.__layerButtons = []
for x in range(5):
self.__layerButtons.append(x)
self.__layerButtons[x] = QPushButton(self)
self.__layerButtons[x].setCursor(Qt.PointingHandCursor)
self.__layerButtons[x].setFont(QFont("BebasNeue", 10, QFont.Bold))
self.__layerButtons[x].clicked.connect(self.createLayer)
# Layer buttons names
self.__layerButtons[0].setText("Input layer")
self.__layerButtons[1].setText("Output layer")
self.__layerButtons[2].setText("Dense layer")
self.__layerButtons[3].setText("Flatten layer")
self.__layerButtons[4].setText("Convolutional layer")
# Layer buttons icons
for x in range(5):
icon = "images/layer_icon_"
self.__layerButtons[x].setIcon(QIcon(icon + str(x)))
self.__layerButtons[x].setIconSize(QSize(45, 45))
# Top buttons layout settings
self.__buttonLayout = QHBoxLayout(self)
self.__buttonGroupBox = QGroupBox(self)
self.__buttonGroupBox.setGeometry(780, -15, 500, 120)
self.__buttonLayout.addWidget(self.__topRightButtons[0])
self.__buttonLayout.addWidget(self.__topRightButtons[1])
self.__buttonGroupBox.setLayout(self.__buttonLayout)
# Network name form layout settings
self.__networkNameLayout = QFormLayout(self)
self.__networkNameGroupBox = QGroupBox(self)
self.__networkNameGroupBox.setGeometry(300, -15, 480, 120)
self.__networkNameLayout.addWidget(self.__networkNameLabel)
self.__networkNameLayout.addWidget(self.networkName)
self.__networkNameGroupBox.setLayout(self.__networkNameLayout)
# Layer buttons layout settings
self.__layerButtonLayout = QVBoxLayout(self)
self.__layerButtonGroupBox = QGroupBox("Layer selection", self)
self.__layerButtonGroupBox.setGeometry(0, -15, 300, 735)
for x in range(5):
self.__layerButtonLayout.addWidget(self.__layerButtons[x])
self.__layerButtonLayout.addWidget(self.goBackButton)
self.__layerButtonGroupBox.setLayout(self.__layerButtonLayout)
# Parameters window settings
# Layer output label
self.__layerOutputLabel = QLabel("Output number", self)
self.__layerOutputLabel.setFont(QFont("BebasNeue", 20, QFont.Bold))
# Layer output line edit
self.__layerOutputLineEdit = QLineEdit(self)
self.__layerOutputLineEdit.setValidator(QIntValidator(0, 1000, self))
# Layer output form settings
self.__layerOutputLayout = QFormLayout(self)
self.__layerOutputGroupBox = QGroupBox(self)
self.__layerOutputLayout.addWidget(self.__layerOutputLabel)
self.__layerOutputLayout.addWidget(self.__layerOutputLineEdit)
self.__layerOutputGroupBox.setLayout(self.__layerOutputLayout)
# Activation function label
self.__activationLabel = QLabel("Activation function", self)
self.__activationLabel.setFont(QFont("BebasNeue", 20, QFont.Bold))
# Activation function menu
self.__activationMenu = QComboBox(self)
self.__activationMenu.addItems(
['Sigmoid', 'Tanh', 'Rectified Linear Unit', 'Softmax'])
# Activation function form settings
self.__activationLayout = QFormLayout(self)
self.__activationGroupBox = QGroupBox(self)
self.__activationLayout.addWidget(self.__activationLabel)
self.__activationLayout.addWidget(self.__activationMenu)
self.__activationGroupBox.setLayout(self.__activationLayout)
# Close window button
self.__closeButton = QPushButton(self)
self.__closeButton.setObjectName("close")
self.__closeButton.setCursor(Qt.PointingHandCursor)
self.__closeButton.setIcon(QIcon("images/close_icon"))
self.__closeButton.setIconSize(QSize(35, 35))
self.__closeButton.clicked.connect(self.closeParameters)
# Accept changes button
self.__acceptButton = QPushButton(self)
self.__acceptButton.setObjectName("accept")
self.__acceptButton.setCursor(Qt.PointingHandCursor)
self.__acceptButton.setIcon(QIcon("images/accept_icon"))
self.__acceptButton.setIconSize(QSize(35, 35))
self.__acceptButton.clicked.connect(self.acceptParameters)
# Close/Accept buttons layout
self.__bottomButtonsLayout = QHBoxLayout(self)
self.__bottomButtonsGroupBox = QGroupBox(self)
self.__bottomButtonsLayout.addWidget(self.__closeButton)
self.__bottomButtonsLayout.addWidget(self.__acceptButton)
self.__bottomButtonsGroupBox.setLayout(self.__bottomButtonsLayout)
# Kernel rows label
self.__kernelRowsLabel = QLabel("Kernel rows", self)
self.__kernelRowsLabel.setFont(QFont("BebasNeue", 20, QFont.Bold))
# Kernel rows line edit
self.__kernelRowsLineEdit = QLineEdit(self)
self.__kernelRowsLineEdit.setValidator(QIntValidator(0, 1000, self))
# Kernel rows form layout
self.__kernelRowsLayout = QFormLayout(self)
self.__kernelRowsLayout.addWidget(self.__kernelRowsLabel)
self.__kernelRowsLayout.addWidget(self.__kernelRowsLineEdit)
# Kernel rows group box
self.__kernelRowsGroupBox = QGroupBox(self)
self.__kernelRowsGroupBox.setLayout(self.__kernelRowsLayout)
self.__kernelRowsGroupBox.hide()
# Kernel columns label
self.__kernelColumnLabel = QLabel("Kernel columns", self)
self.__kernelColumnLabel.setFont(QFont("BebasNeue", 20, QFont.Bold))
# Kernel columns line edit
self.__kernelColumnLineEdit = QLineEdit(self)
self.__kernelColumnLineEdit.setValidator(QIntValidator(0, 1000, self))
# Kernel columns form layout
self.__kernelColumnLayout = QFormLayout(self)
self.__kernelColumnLayout.addWidget(self.__kernelColumnLabel)
self.__kernelColumnLayout.addWidget(self.__kernelColumnLineEdit)
# Kernel columns group box
self.__kernelColumnGroupBox = QGroupBox(self)
self.__kernelColumnGroupBox.setLayout(self.__kernelColumnLayout)
self.__kernelColumnGroupBox.hide()
# Layer parameters group box
self.__layerParametersGroupBox = QGroupBox(self)
self.__layerParametersGroupBox.setObjectName("parameters")
self.__layerParametersGroupBox.setGeometry(960, 88, 320, 550)
self.__layerParametersLayout = QVBoxLayout(self)
self.__layerParametersLayout.addWidget(self.__layerOutputGroupBox)
self.__layerParametersLayout.addWidget(self.__activationGroupBox)
self.__layerParametersLayout.addWidget(self.__kernelRowsGroupBox)
self.__layerParametersLayout.addWidget(self.__kernelColumnGroupBox)
self.__layerParametersLayout.addWidget(self.__bottomButtonsGroupBox)
self.__layerParametersGroupBox.setLayout(self.__layerParametersLayout)
self.__layerParametersGroupBox.hide()
self.__layerParametersGroupBox.raise_()
def __init__(self, *args, **kwargs):
super(TestingWindow, self).__init__(*args, **kwargs)
# Loading Fonts
QFontDatabase.addApplicationFont("fonts/BebasNeue-Light.ttf")
# Window Settings
self.setFixedSize(1280, 720)
self.setWindowTitle("TestingWindow")
background = QPixmap("images/testing")
palette = QPalette()
palette.setBrush(QPalette.Background, background)
self.setAttribute(Qt.WA_StyledBackground, True)
self.setPalette(palette)
self.setAutoFillBackground(True)
# Stylesheet Settings
styleFile = QFile("stylesheets/testing.qss")
styleFile.open(QFile.ReadOnly)
style = str(styleFile.readAll())
self.setStyleSheet(style)
# Title Settings
self.__title = QLabel("Testing", self)
self.__title.setFont(QFont("BebasNeue", 45, QFont.Bold))
self.__title.setAlignment(Qt.AlignCenter)
self.__title.setGeometry(0, 30, 1280, 100)
# Button Settings
self.buttons = []
for x in range(4):
self.buttons.append(x)
self.buttons[x] = QPushButton(self)
self.buttons[x].setCursor(Qt.PointingHandCursor)
self.buttons[x].setObjectName("select")
self.buttons[x].setFont(QFont("BebasNeue", 10, QFont.Bold))
self.buttons[x].setGeometry(80, 100 + x * 120, 80, 80)
# Connecting buttons
self.buttons[0].clicked.connect(self.loadNetwork)
self.buttons[1].clicked.connect(self.loadTestFile)
self.buttons[2].clicked.connect(self.startTest)
# Buttons Icons
self.buttons[0].setIcon(QIcon("images/brain_icon"))
self.buttons[0].setIconSize(QSize(35, 35))
self.buttons[1].setIcon(QIcon("images/upload_icon"))
self.buttons[1].setIconSize(QSize(35, 35))
self.buttons[2].setIcon(QIcon("images/test_icon"))
self.buttons[2].setIconSize(QSize(35, 35))
self.buttons[3].setIcon(QIcon("images/goback_icon"))
self.buttons[3].setIconSize(QSize(35, 35))
# Return Button
self.buttons[3].setText("Back")
self.buttons[3].setObjectName("retour")
self.buttons[3].setGeometry(1100, 620, 120, 120)
self.buttons[3].setIcon(QIcon("images/goback_icon"))
self.buttons[3].setIconSize(QSize(35, 35))
# Labels Settings
self.__labels = []
for x in range(3):
self.__labels.append(x)
self.__labels[x] = QLabel(self)
self.__labels[x].setGeometry(200, 110 + x * 120, 300, 80)
self.__labels[x].setFont(QFont("BebasNeue", 20, QFont.Bold))
self.__labels[0].setText("Load a neural network")
self.__labels[1].setText("Load the test file")
self.__labels[2].setText("Start the test")
# Main
#app = QApplication(sys.argv)
#window = TestingWindow()
#window.show()
#app.exec_()
def __init__(self, filename, image, parent=None):
super(DigestWidget, self).__init__(parent)
table = []
file_info = QFileInfo(filename)
table.append(
[self.tr('File'),
self.tr('File name'),
file_info.fileName()])
table.append([
None,
self.tr('Parent folder'),
str(file_info.dir().absolutePath())
])
table.append(
[None,
self.tr('MIME type'),
magic.from_file(filename, mime=True)])
table.append([
None,
self.tr('File size'),
'{} bytes ({})'.format(QLocale().toString(file_info.size()),
human_size(file_info.size()))
])
table.append([None, self.tr('File owner'), file_info.owner()])
table.append([
None,
self.tr('Permissions'),
str(oct(os.stat(filename).st_mode)[-3:])
])
table.append([
None,
self.tr('Creation time'),
file_info.birthTime().toLocalTime().toString()
])
table.append([
None,
self.tr('Last access'),
file_info.lastRead().toLocalTime().toString()
])
table.append([
None,
self.tr('Last modified'),
file_info.lastModified().toLocalTime().toString()
])
table.append([
None,
self.tr('Metadata changed'),
file_info.metadataChangeTime().toLocalTime().toString()
])
file = QFile(filename)
if not file.open(QIODevice.ReadOnly):
QMessageBox.warning(self, self.tr('Warning'),
self.tr('Unable to read file from disk!'))
return
data = file.readAll()
md5 = QCryptographicHash.hash(data, QCryptographicHash.Md5).toHex()
table.append([
self.tr('CryptoHash'),
self.tr('MD5'),
str(md5, encoding='utf-8')
])
sha1 = QCryptographicHash.hash(data, QCryptographicHash.Sha1).toHex()
table.append([None, self.tr('SHA2-1'), str(sha1, encoding='utf-8')])
sha224 = QCryptographicHash.hash(data,
QCryptographicHash.Sha224).toHex()
table.append(
[None, self.tr('SHA2-224'),
str(sha224, encoding='utf-8')])
sha256 = QCryptographicHash.hash(data,
QCryptographicHash.Sha256).toHex()
table.append(
[None, self.tr('SHA2-256'),
str(sha256, encoding='utf-8')])
sha384 = QCryptographicHash.hash(data,
QCryptographicHash.Sha384).toHex()
table.append(
[None, self.tr('SHA2-384'),
str(sha384, encoding='utf-8')])
sha512 = QCryptographicHash.hash(data,
QCryptographicHash.Sha512).toHex()
table.append(
[None, self.tr('SHA2-512'),
str(sha512, encoding='utf-8')])
sha3_224 = QCryptographicHash.hash(
data, QCryptographicHash.Sha3_224).toHex()
table.append(
[None, self.tr('SHA3-224'),
str(sha3_224, encoding='utf-8')])
sha3_256 = QCryptographicHash.hash(
data, QCryptographicHash.Sha3_256).toHex()
table.append(
[None, self.tr('SHA3-256'),
str(sha3_256, encoding='utf-8')])
sha3_384 = QCryptographicHash.hash(
data, QCryptographicHash.Sha3_384).toHex()
table.append(
[None, self.tr('SHA3-384'),
str(sha3_384, encoding='utf-8')])
sha3_512 = QCryptographicHash.hash(
data, QCryptographicHash.Sha3_512).toHex()
table.append(
[None, self.tr('SHA3-512'),
str(sha3_512, encoding='utf-8')])
table.append([
self.tr('ImageHash'),
self.tr('Average'),
str(cv.img_hash.averageHash(image)[0])
])
# table_widget.item(15, 0).setToolTip(self.tr('Average hash'))
table.append([
None,
self.tr('Block mean'),
str(cv.img_hash.blockMeanHash(image)[0])
])
# table_widget.item(16, 0).setToolTip(self.tr('Block mean hash'))
table.append([
None,
self.tr('Color moments'),
str(cv.img_hash.colorMomentHash(image)[0])
])
# table_widget.item(17, 0).setToolTip(self.tr('Color moments hash'))
table.append([
None,
self.tr('Marr-Hildreth'),
str(cv.img_hash.marrHildrethHash(image)[0])
])
# table_widget.item(18, 0).setToolTip(self.tr('Marr-Hildreth hash'))
table.append(
[None,
self.tr('Perceptual'),
str(cv.img_hash.pHash(image)[0])])
# table_widget.item(19, 0).setToolTip(self.tr('Perceptual hash'))
table.append([
None,
self.tr('Radial variance'),
str(cv.img_hash.radialVarianceHash(image)[0])
])
# table_widget.item(20, 0).setToolTip(self.tr('Radial variance hash'))
headers = [self.tr('Group'), self.tr('Property'), self.tr('Value')]
table_widget = TableWidget(table, headers)
main_layout = QVBoxLayout()
main_layout.addWidget(table_widget)
self.setLayout(main_layout)
self.setMinimumSize(620, 520)
def __init__(self, filename, image, parent=None):
super(DigestWidget, self).__init__(parent)
table = []
file_info = QFileInfo(filename)
table.append([
self.tr("PhysicalFile"),
self.tr("File name"),
file_info.fileName()
])
table.append([
None,
self.tr("Parent folder"),
str(file_info.dir().absolutePath())
])
table.append(
[None,
self.tr("MIME type"),
magic.from_file(filename, mime=True)])
table.append([
None,
self.tr("File size"),
f"{QLocale().toString(file_info.size())} bytes ({human_size(file_info.size())})",
])
table.append([None, self.tr("File owner"), file_info.owner()])
table.append([
None,
self.tr("Permissions"),
str(oct(os.stat(filename).st_mode)[-3:])
])
table.append([
None,
self.tr("Creation time"),
file_info.birthTime().toLocalTime().toString()
])
table.append([
None,
self.tr("Last access"),
file_info.lastRead().toLocalTime().toString()
])
table.append([
None,
self.tr("Last modified"),
file_info.lastModified().toLocalTime().toString()
])
table.append([
None,
self.tr("Metadata changed"),
file_info.metadataChangeTime().toLocalTime().toString()
])
table.append([
None,
self.tr("Name ballistics"),
ballistics(file_info.fileName())
])
file = QFile(filename)
if not file.open(QIODevice.ReadOnly):
QMessageBox.warning(self, self.tr("Warning"),
self.tr("Unable to read file from disk!"))
return
data = file.readAll()
md5 = QCryptographicHash.hash(data, QCryptographicHash.Md5).toHex()
table.append([
self.tr("CryptoHash"),
self.tr("MD5"),
str(md5, encoding="utf-8")
])
sha1 = QCryptographicHash.hash(data, QCryptographicHash.Sha1).toHex()
table.append([None, self.tr("SHA2-1"), str(sha1, encoding="utf-8")])
sha224 = QCryptographicHash.hash(data,
QCryptographicHash.Sha224).toHex()
table.append(
[None, self.tr("SHA2-224"),
str(sha224, encoding="utf-8")])
sha256 = QCryptographicHash.hash(data,
QCryptographicHash.Sha256).toHex()
table.append(
[None, self.tr("SHA2-256"),
str(sha256, encoding="utf-8")])
sha384 = QCryptographicHash.hash(data,
QCryptographicHash.Sha384).toHex()
table.append(
[None, self.tr("SHA2-384"),
str(sha384, encoding="utf-8")])
sha512 = QCryptographicHash.hash(data,
QCryptographicHash.Sha512).toHex()
table.append(
[None, self.tr("SHA2-512"),
str(sha512, encoding="utf-8")])
sha3_224 = QCryptographicHash.hash(
data, QCryptographicHash.Sha3_224).toHex()
table.append(
[None, self.tr("SHA3-224"),
str(sha3_224, encoding="utf-8")])
sha3_256 = QCryptographicHash.hash(
data, QCryptographicHash.Sha3_256).toHex()
table.append(
[None, self.tr("SHA3-256"),
str(sha3_256, encoding="utf-8")])
sha3_384 = QCryptographicHash.hash(
data, QCryptographicHash.Sha3_384).toHex()
table.append(
[None, self.tr("SHA3-384"),
str(sha3_384, encoding="utf-8")])
sha3_512 = QCryptographicHash.hash(
data, QCryptographicHash.Sha3_512).toHex()
table.append(
[None, self.tr("SHA3-512"),
str(sha3_512, encoding="utf-8")])
table.append([
self.tr("ImageHash"),
self.tr("Average"),
str(cv.img_hash.averageHash(image)[0])
])
# table_widget.item(15, 0).setToolTip(self.tr('Average hash'))
table.append([
None,
self.tr("Block mean"),
str(cv.img_hash.blockMeanHash(image)[0])
])
# table_widget.item(16, 0).setToolTip(self.tr('Block mean hash'))
table.append([
None,
self.tr("Color moments"),
str(cv.img_hash.colorMomentHash(image)[0])
])
# table_widget.item(17, 0).setToolTip(self.tr('Color moments hash'))
table.append([
None,
self.tr("Marr-Hildreth"),
str(cv.img_hash.marrHildrethHash(image)[0])
])
# table_widget.item(18, 0).setToolTip(self.tr('Marr-Hildreth hash'))
table.append(
[None,
self.tr("Perceptual"),
str(cv.img_hash.pHash(image)[0])])
# table_widget.item(19, 0).setToolTip(self.tr('Perceptual hash'))
table.append([
None,
self.tr("Radial variance"),
str(cv.img_hash.radialVarianceHash(image)[0])
])
# table_widget.item(20, 0).setToolTip(self.tr('Radial variance hash'))
headers = [self.tr("Group"), self.tr("Property"), self.tr("Value")]
table_widget = TableWidget(table, headers)
main_layout = QVBoxLayout()
main_layout.addWidget(table_widget)
self.setLayout(main_layout)
self.setMinimumSize(700, 520)
if parents[-1].childCount() > 0:
parents.append(parents[-1].child(parents[-1].childCount() - 1))
indentations.append(position)
else:
while position < indentations[-1] and len(parents) > 0:
parents.pop()
indentations.pop()
# Append a new item to the current parent's list of children.
parents[-1].appendChild(TreeItem(columnData, parents[-1]))
number += 1
if __name__ == '__main__':
import sys
app = QApplication(sys.argv)
f = QFile('tree_data.txt')
f.open(QIODevice.ReadOnly)
model = TreeModel(f.readAll())
f.close()
view = QTreeView()
view.setModel(model)
view.setWindowTitle("Simple Tree Model")
view.show()
sys.exit(app.exec_())
