def get_frame(
self,
value: Union[
Component,
ComponentInfo,
Transformation,
LinkTransformation,
TransformationsList,
FileWriterModule,
],
):
frame = QFrame()
frame.setAutoFillBackground(True)
SizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
SizePolicy.setHorizontalStretch(0)
SizePolicy.setVerticalStretch(0)
frame.setSizePolicy(SizePolicy)
frame.setLayout(QVBoxLayout())
frame.layout().setContentsMargins(0, 0, 0, 0)
if isinstance(value, Group):
get_group_frame(frame, value)
elif isinstance(value, TransformationsList):
get_transformations_list_frame(frame)
elif isinstance(value, ComponentInfo):
get_group_info_frame(frame, value)
elif isinstance(value, Transformation):
get_transformation_frame(frame, self.model, value)
elif isinstance(value, LinkTransformation):
get_link_transformation_frame(frame, self.model, value)
elif isinstance(value, FileWriterModule):
get_module_frame(frame, self.model, value, self._use_simple_tree_view)
return frame
def add_tag_to_bar(self, text):
tag = QFrame()
tag.setStyleSheet(
'border:1px solid rgb(192, 192, 192); border-radius: 4px;')
tag.setContentsMargins(2, 2, 2, 2)
tag.setFixedHeight(28)
hbox = QHBoxLayout()
hbox.setContentsMargins(4, 4, 4, 4)
hbox.setSpacing(10)
tag.setLayout(hbox)
label = QLabel(text)
label.setStyleSheet('border:0px')
label.setFixedHeight(16)
hbox.addWidget(label)
x_button = QPushButton('x')
x_button.setFixedSize(20, 20)
x_button.setStyleSheet('border:0px; font-weight:bold')
x_button.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
x_button.clicked.connect(partial(self.delete_tag, text))
hbox.addWidget(x_button)
tag.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Preferred)
self.hLayout.addWidget(tag)
def get_frame(
self,
value: Union[
Component,
ComponentInfo,
Transformation,
LinkTransformation,
TransformationsList,
],
):
frame = QFrame()
frame.setAutoFillBackground(True)
SizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
SizePolicy.setHorizontalStretch(0)
SizePolicy.setVerticalStretch(0)
frame.setSizePolicy(SizePolicy)
frame.setLayout(QVBoxLayout())
frame.layout().setContentsMargins(0, 0, 0, 0)
if isinstance(value, Component):
get_component_frame(frame, value)
elif isinstance(value, TransformationsList):
get_transformations_list_frame(frame)
elif isinstance(value, ComponentInfo):
get_component_info_frame(frame)
elif isinstance(value, Transformation):
get_transformation_frame(frame, self.instrument, value)
elif isinstance(value, LinkTransformation):
get_link_transformation_frame(frame, self.instrument, value)
return frame
def _create_vertical_line():
vertical_line = QFrame()
vertical_line.setFixedWidth(20)
vertical_line.setFrameShape(QFrame.VLine)
vertical_line.setFrameShadow(QFrame.Sunken)
vertical_line.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred)
vertical_line.setMinimumHeight(300)
return vertical_line
def __init__(self, master, enigma_api):
"""
Settings menu for settings UKW-D wiring pairs
:param master: Qt parent object
:param enigma_api: {EnigmaAPI}
"""
super().__init__(master, enigma_api, "UKW-D pairs")
self._banned = ["J", "Y"]
self._apply_plug = self.refresh_apply
plug_frame = QFrame(self)
plug_layout = QVBoxLayout(plug_frame)
for group in "ABCDEF", "GHIKLM", "NOPQRS", "TUVWXZ":
col_frame = QFrame(plug_frame)
col_layout = QHBoxLayout(col_frame)
col_layout.setMargin(0)
for letter in group:
socket = Socket(self, letter, self.connect_sockets,
self._enigma_api.charset())
col_layout.addWidget(socket)
self._plugs[letter] = socket
plug_layout.addWidget(col_frame)
btn_frame = QFrame(self)
btn_frame.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
btn_layout = QHBoxLayout(btn_frame)
btn_layout.setAlignment(Qt.AlignRight)
self.__reset_all = QPushButton("Clear pairs")
self.__reset_all.clicked.connect(self.clear_pairs)
self.__apply_btn = QPushButton("Apply")
self.__apply_btn.clicked.connect(self.apply)
storno = QPushButton("Storno")
storno.clicked.connect(self.storno)
btn_layout.addWidget(self.__reset_all)
btn_layout.addWidget(storno)
btn_layout.addWidget(self.__apply_btn)
self._main_layout.addWidget(plug_frame)
self._main_layout.addWidget(btn_frame)
self.refresh_apply()
def __init__(self, controller, parent=None):
super(CommandParser, self).__init__(parent)
self.controller = controller
cmnd2send_label = QLabel('Command:')
cmnd2send_label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.cmnd2send_editor = QLineEdit()
# cmnd2send_editor.setKeyboardTracking(False)
self.cmnd2send_editor.setAlignment(Qt.AlignLeft)
self.cmnd2send_editor.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed)
# cmnd2send_editor.setClearButtonEnabled()
send_button = QPushButton('Send')
send_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
separator = QFrame()
separator.setFrameShape(QFrame.HLine)
separator.setFrameShadow(QFrame.Sunken)
separator.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed)
scrollbar = QScrollBar()
cmnd_received_label = QLabel('RESPONSE:')
self.cmnd_received_window = QTextEdit()
# self.cmnd_received_window.moveCursor(QTextCursor.Down)
self.cmnd_received_window.setReadOnly(True)
self.cmnd_received_window.setVerticalScrollBar(scrollbar)
# Layout
editor_layout = QGridLayout()
editor_layout.addWidget(cmnd2send_label, 0, 0)
editor_layout.addWidget(self.cmnd2send_editor, 0, 1)
editor_layout.addWidget(send_button, 0, 2)
editor_layout.addWidget(separator, 1, 0, 1, 3)
editor_layout.addWidget(cmnd_received_label, 2, 0, 1, 3)
editor_layout.addWidget(self.cmnd_received_window, 3, 0, 1, 3)
layout = QHBoxLayout()
layout.addLayout(editor_layout)
self.setLayout(layout)
# Signals and slots
send_button.clicked.connect(self.parse_cmnd)
class Camera(QWidget):
modes = (('Manual', 0, 0), ('Optimize for traffic (aggressive)', 60, 10),
('Optimize for traffic (moderate)', 120,
25), ('Optimize for latency (aggressive)', 60,
80), ('Optimize for latency (moderate)', 120,
80), ('Optimize for video quality', 480, 30))
def __init__(self, id, app: QApplication, *args, **kwargs):
super().__init__(*args, **kwargs)
self.id = id
self.image_quality = CONFIGURATIONS['cameras']['cam%d' % id]['quality']
self.image_resolution = CONFIGURATIONS['cameras']['cam%d' %
id]['resolution']
self.box = QVBoxLayout()
self.setLayout(self.box)
self.tabs = QTabWidget()
self.camera_feed = CameraFeed(self.id, app)
self.status_frame = QFrame()
self.status_frame.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.status_frame.setMinimumSize(250, 340)
self.status = QScrollArea()
self.status.setWidget(self.status_frame)
self.initStatus()
self.network_graphs = pg.GraphicsLayoutWidget()
self.traffic_graphs = pg.GraphicsLayoutWidget()
self.frame_rate_graphs = pg.GraphicsLayoutWidget()
self.initGraphs()
self.box.addWidget(self.tabs)
self.tabs.addTab(self.camera_feed, 'Camera')
self.tabs.addTab(self.status, 'Status')
self.tabs.addTab(self.traffic_graphs, "Traffic")
self.tabs.addTab(self.network_graphs, "Latency")
self.tabs.addTab(self.frame_rate_graphs, "Video")
self.setMinimumSize(1, 1)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.timer = QTimer()
self.timer.timeout.connect(self.updateAllGraphs)
self.timer.start(100)
def initStatus(self):
self.status_layout = QGridLayout()
self.status_frame.setLayout(self.status_layout)
self.serverTime = QLabel()
self.clientTime = QLabel()
self.totalTime = QLabel()
self.networkTime = QLabel()
self.clientTime.setText('0.000 ms')
self.serverTime.setText('0.000 ms')
self.totalTime.setText('0.000 ms')
self.networkTime.setText('0.000 ms')
self.fps = QLabel()
self.fps.setText('0.000 FPS')
self.traffic = QLabel()
self.traffic.setText('0.000 KB/s')
self.frame_drop = QLabel()
self.frame_drop.setText('0 FPS')
# self.status_layout.addWidget(self.fps, 0, 0)
self.status_layout.addWidget(QLabel("Frame Rate"), 0, 0)
self.status_layout.addWidget(self.fps, 0, 1)
self.status_layout.addWidget(QLabel("Frame Drop"), 1, 0)
self.status_layout.addWidget(self.frame_drop, 1, 1)
self.status_layout.addWidget(QLabel("Server"), 2, 0)
self.status_layout.addWidget(self.serverTime, 2, 1)
self.status_layout.addWidget(QLabel("Client"), 3, 0)
self.status_layout.addWidget(self.clientTime, 3, 1)
self.status_layout.addWidget(QLabel("Network"), 4, 0)
self.status_layout.addWidget(self.networkTime, 4, 1)
self.status_layout.addWidget(QLabel("Total"), 5, 0)
self.status_layout.addWidget(self.totalTime, 5, 1)
self.status_layout.addWidget(QLabel("Traffic"), 6, 0)
self.status_layout.addWidget(self.traffic, 6, 1)
self.mode_selection = QComboBox()
self.mode_selection.wheelEvent = self.status.wheelEvent # Monkey patch it so the selection doesn't change
self.mode_selection.setEnabled(False)
self.mode_selection.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Fixed)
for i, mode in enumerate(self.modes):
self.mode_selection.addItem(mode[0])
if self.image_resolution == mode[1] and self.image_quality == mode[
2]:
self.mode_selection.setCurrentIndex(i)
self.status_layout.addWidget(self.mode_selection, 7, 0, columnspan=2)
self.mode_selection.currentIndexChanged.connect(self.updateMode)
self.quality_slider = QSlider(Qt.Horizontal)
self.quality_slider.setMinimum(1)
self.quality_slider.setMaximum(80)
self.quality_slider.setSingleStep(1)
self.quality_slider.setValue(self.image_quality)
self.quality_slider.wheelEvent = self.status.wheelEvent
self.quality_slider.setEnabled(False)
self.quality_label = QLabel(str(self.image_quality))
self.quality_slider.valueChanged.connect(
lambda n: self.quality_label.setText(str(n)))
self.resolution_slider = QSlider(Qt.Horizontal, )
self.resolution_slider.setMinimum(60)
self.resolution_slider.setMaximum(1080)
self.resolution_slider.setSingleStep(120)
self.resolution_slider.setValue(self.image_resolution)
self.resolution_slider.wheelEvent = self.status.wheelEvent
self.resolution_slider.setEnabled(False)
self.resolution_label = QLabel(str(self.image_resolution))
self.resolution_slider.valueChanged.connect(
lambda n: self.resolution_label.setText(str(n)))
self.status_layout.addWidget(QLabel("Image Quality"),
8,
0,
columnspan=2)
self.status_layout.addWidget(self.quality_slider, 9, 0)
self.status_layout.addWidget(self.quality_label, 9, 1)
self.status_layout.addWidget(QLabel("Image Resolution"),
10,
0,
columnspan=2)
self.status_layout.addWidget(self.resolution_slider, 11, 0)
self.status_layout.addWidget(self.resolution_label, 11, 1)
self.apply_button = QPushButton("Apply")
self.apply_button.setEnabled(False)
self.status_layout.addWidget(self.apply_button, 12, 0)
self.apply_button.clicked.connect(self.updateConfiguration)
def updateMode(self, index):
mode_name, resolution, quality = self.modes[index]
if mode_name == 'Manual':
self.apply_button.setEnabled(True)
self.resolution_slider.setEnabled(True)
self.quality_slider.setEnabled(True)
else:
self.apply_button.setEnabled(False)
self.resolution_slider.setEnabled(False)
self.quality_slider.setEnabled(False)
self.resolution_slider.setValue(resolution)
self.quality_slider.setValue(quality)
self.updateConfiguration()
def updateConfiguration(self):
try:
Configuration().update_config(self.id,
self.resolution_slider.value(),
self.quality_slider.value())
except (ConnectionResetError, BrokenPipeError):
Configuration().reconnect()
def initGraphs(self):
self.traffic_plot = StatusPlotItem()
self.traffic_plot.setTitle("Traffic")
self.traffic_plot.setLabel("left", 'Data Transmitted', 'KB/s')
self.traffic_graphs.addItem(self.traffic_plot, row=0, col=0)
self.network_plot = StatusPlotItem()
self.network_plot.setTitle("Network Time")
self.network_plot.setLabel(
"left",
"Latency (ms)",
)
self.network_graphs.addItem(self.network_plot, row=0, col=2)
self.client_time_plot = StatusPlotItem()
self.client_time_plot.setTitle("Client Time")
self.client_time_plot.setLabel(
"left",
"Latency (ms)",
)
self.network_graphs.addItem(self.client_time_plot, row=0, col=1)
self.total_time_plot = StatusPlotItem()
self.total_time_plot.setTitle("Total Latency")
self.total_time_plot.setLabel(
"left",
"Latency (ms)",
)
self.network_graphs.addItem(self.total_time_plot, row=0, col=0)
self.frame_rate_plot = StatusPlotItem()
self.frame_rate_plot.setLabel('left', 'Frame Per Second')
self.frame_rate_plot.setTitle("Frame Rate")
self.frame_rate_graphs.addItem(self.frame_rate_plot, row=0, col=0)
self.frame_drop_plot = StatusPlotItem()
self.frame_rate_plot.setLabel('left', 'Frame Per Second')
self.frame_drop_plot.setTitle('Frame Drop')
self.frame_rate_graphs.addItem(self.frame_drop_plot, row=0, col=1)
def updateStatus(self, total, server, client):
self.totalTime.setText('{: <4} ms'.format(str(total)))
self.total_time_plot.value = total
self.serverTime.setText('{: <4} ms'.format(str(server)))
self.clientTime.setText('{: <4} ms'.format(str(client)))
self.client_time_plot.value = client
self.networkTime.setText('{: <4} ms'.format(
str(round(total - server - client, 2))))
self.network_plot.value = total - server - client
self.traffic.setText('{: <4} KB/s'.format(
str(round(getattr(TrafficMonitor(), 'cam%d' % self.id) / 1024,
1))))
self.traffic_plot.value = getattr(TrafficMonitor(),
'cam%d' % self.id) / 1024
self.fps.setText('{: <4} FPS'.format(
str(round(getattr(FrameRateMonitor(), 'cam%d' % self.id), 1))))
self.frame_rate_plot.value = getattr(FrameRateMonitor(),
'cam%d' % self.id)
self.frame_drop_plot.value = getattr(FrameDropMonitor(),
'cam%d' % self.id)
self.frame_drop.setText('{: <4} FPS'.format(
str(round(getattr(FrameDropMonitor(), 'cam%d' % self.id), 1))))
# self.updateAllGraphs()
def updateAllGraphs(self):
self.total_time_plot.update()
self.client_time_plot.update()
self.frame_rate_plot.update()
self.frame_drop_plot.update()
self.network_plot.update()
self.traffic_plot.update()
def startReceiving(self):
self.camera_feed.startReceiving()
self.time_started = time.time()
self.camera_feed.feed_receiver.signals.updateStatus.connect(
self.updateStatus)
class Central(QFrame):
'''Initializes, styles, and connects the various classes'''
def __init__(self):
super().__init__()
# Objects
self.overallLayout = QVBoxLayout(self)
self.contentLayout = QHBoxLayout()
self.dropShadow = QGraphicsDropShadowEffect(self)
self.boxManager = BoxManager.BoxManager()
self.topBar = TopBar.TopBar()
self.selectorArea = QFrame()
self.selectorLayout = QVBoxLayout(self.selectorArea)
self.folderArea = QFrame()
self.folderLayout = QHBoxLayout(self.folderArea)
self.folderList = FolderList.FolderList()
self.folderBar = ScrollBar.ScrollBar(self.folderList)
self.canvas = Canvas.Canvas(self.boxManager)
self.imageArea = QFrame()
self.imageList = ImageList.ImageList()
self.imageLayout = QHBoxLayout(self.imageArea)
self.imageBar = ScrollBar.ScrollBar(self.imageList)
# Styling
self.setStyleSheet('Central { background: transparent; }')
self.overallLayout.setMargin(20)
self.overallLayout.setSpacing(0)
self.dropShadow.setOffset(QPointF(0,4))
self.dropShadow.setColor(QColor(0,0,0,100))
self.dropShadow.setBlurRadius(10)
self.setGraphicsEffect(self.dropShadow)
self.contentLayout.setAlignment(Qt.AlignCenter)
self.contentLayout.setMargin(0)
self.contentLayout.setSpacing(0)
self.selectorLayout.setMargin(0)
self.selectorLayout.setSpacing(0)
self.folderLayout.setMargin(0)
self.folderLayout.setSpacing(0)
self.imageLayout.setMargin(0)
self.imageLayout.setSpacing(0)
self.folderList.setVerticalScrollBar(self.folderBar)
self.imageList.setVerticalScrollBar(self.imageBar)
self.selectorArea.setMaximumWidth(400)
self.selectorArea.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
# Layout
self.folderLayout.addWidget(self.folderList)
self.folderLayout.addSpacerItem(QSpacerItem(-7, 0))
self.folderLayout.addWidget(self.folderBar)
self.imageLayout.addWidget(self.imageList)
self.imageLayout.addSpacerItem(QSpacerItem(-7, 0))
self.imageLayout.addWidget(self.imageBar)
self.selectorLayout.addWidget(self.folderArea, 15)
self.selectorLayout.addWidget(self.imageArea, 85)
self.contentLayout.addWidget(self.selectorArea, 30)
self.contentLayout.addWidget(self.canvas, 70)
self.overallLayout.addLayout(self.contentLayout)
self.overallLayout.insertWidget(0, self.topBar)
# Connections
self.folderList.selectedFolderChanged.connect(self.handleSelectedFolderChanged)
self.imageList.selectedImageChanged.connect(self.handleSelectedImageChanged)
def handleSelectedFolderChanged(self, folder):
self.imageList.populate(folder)
self.canvas.changeImage(None)
self.canvas.setMessage('Switching Folders - {}'.format(folder.data(role=Qt.DisplayRole)))
self.topBar.setSelectedFolder(str(folder.data(role=Qt.UserRole+1)))
self.topBar.setSelectedImage('')
def handleSelectedImageChanged(self, image):
self.canvas.changeImage(image)
self.canvas.setMessage('Switching Images - {}'.format(image.data(role=Qt.DisplayRole)))
self.topBar.setSelectedImage(str(image.data(role=Qt.DisplayRole)))
class DLPPrinterGUI(QWidget):
closing_window_event = Signal()
spinboxValueChanged = Signal(float)
def __init__(self,
dlp_controller=None,
parent=None,
printer_setup='BOTTOM-UP'):
QWidget.__init__(self, parent)
if dlp_controller:
self.dlp_controller = dlp_controller
else:
self.dlp_controller = DLPMainController(printer_setup)
self.dlp_controller.block_parameters_signal.connect(
self.block_parameters_signals)
self.dlp_controller.reactivate_parameters_signal.connect(
self.reactivate_parameters_signals)
self.dlp_controller.motor_changed_signal.connect(
self.update_motor_parameters)
self.closing_window_event.connect(self.dlp_controller.close_projector)
self.parent = parent
self.main_layout = QHBoxLayout()
self.__init_widget__()
self.setLayout(self.main_layout)
def __init_widget__(self):
self.__left_widget = QWidget()
self.__left_widget.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.MinimumExpanding)
self.__right_widget = QWidget()
self.__right_widget.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.__init_printer_options_widget__(self.__left_widget)
self.__init_projector_widget__(self.__left_widget)
self.__init_support_widget__(self.__left_widget)
self.__init_features_widget__(self.__left_widget)
self.__init_advanced_features_widget__(self.__left_widget)
# self.__init_expected_time_widget__(self.__left_widget)
self.__left_layout = QGridLayout()
self.__left_layout.addWidget(self.__printer_options_widget, 0, 0, 1, 2)
self.__left_layout.addWidget(self.__projector_widget, 1, 0, 1, 2)
self.__left_layout.addWidget(self.__support_widget, 2, 0, 1, 1)
self.__left_layout.addWidget(self.__features_widget, 2, 1, 1, 1)
self.__left_layout.addWidget(self.__advanced_widget, 3, 0, 1, 2)
# self.__left_layout.addWidget(self.__expected_time_widget, 4,0)
self.__left_widget.setLayout(self.__left_layout)
self.__left_widget.show()
self.__init_start_stop_widget__(self.__right_widget)
self.__init_preview_widget__(self.__right_widget)
self.__init_console_widget__(self.__right_widget)
self.__init_username_jobname_widget__()
self.__right_layout = QVBoxLayout()
self.__right_layout.addWidget(self.__start_stop_widget)
self.__right_layout.addWidget(self.__username_jobname_widget)
self.__right_layout.addWidget(self.__preview_widget)
self.__right_layout.addWidget(self.__console_widget)
self.__right_widget.setLayout(self.__right_layout)
# print(self.__left_layout.sizeHint(), self.__right_layout.sizeHint())
self.main_layout.addWidget(self.__left_widget)
self.main_layout.addWidget(self.__right_widget)
def __init_printer_options_widget__(self, parent=None):
self.__printer_options_widget = QGroupBox("Printer Options", parent)
# self.__printer_options_widget.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
port_label = QLabel("Port:", self.__printer_options_widget)
self.port_list = MyQComboBox(self.__printer_options_widget)
self.port_list.addItems(self.dlp_controller.available_ports())
self.port_list.currentIndexChanged.connect(
self.dlp_controller.select_port)
self.port_list.combo_box_clicked.connect(self.update_port_list)
connect_button = QPushButton("Connect", self.__printer_options_widget)
connect_button.clicked.connect(self.dlp_controller.connect_printer)
disconnect_button = QPushButton("Disconnect",
self.__printer_options_widget)
disconnect_button.clicked.connect(
self.dlp_controller.disconnect_printer)
reset_button = QPushButton("Reset", self.__printer_options_widget)
reset_button.clicked.connect(self.dlp_controller.reset_printer)
move_button = QPushButton("Move Building Plate",
self.__printer_options_widget)
self.move_edit = MyDiscreteStepsSpinBox(
self.dlp_controller.get_step_length_microns() / 1000.0,
self.__printer_options_widget)
self.move_edit.setSuffix("mm")
self.move_edit.setMaximum(1000)
self.move_edit.setMinimum(-1000)
self.move_edit.setDecimals(6)
self.move_edit.my_value_changed_signal.connect(
self.dlp_controller.update_building_plate_distance)
move_button.clicked.connect(self.dlp_controller.move_building_plate)
set_origin_button = QPushButton("Set Building Plate Origin",
self.__printer_options_widget)
set_origin_button.clicked.connect(
self.dlp_controller.set_building_plate_origin)
home_button = QPushButton("Home Building Plate",
self.__printer_options_widget)
home_button.clicked.connect(self.dlp_controller.home_building_plate)
origin_button = QPushButton("Send Building Plate to Origin",
self.__printer_options_widget)
origin_button.clicked.connect(
self.dlp_controller.move_building_plate_to_origin)
options_layout = QGridLayout(self.__printer_options_widget)
# options_layout.addWidget(options_label, 0, 0, 1, 5)
options_layout.addWidget(port_label, 0, 0)
options_layout.addWidget(self.port_list, 0, 1)
options_layout.addWidget(connect_button, 0, 2)
options_layout.addWidget(disconnect_button, 0, 3)
options_layout.addWidget(reset_button, 0, 4)
options_layout.addWidget(move_button, 1, 0, 1, 2)
options_layout.addWidget(self.move_edit, 1, 2)
options_layout.addWidget(set_origin_button, 1, 3, 1, 2)
options_layout.addWidget(home_button, 2, 0, 1, 2)
options_layout.addWidget(origin_button, 2, 2, 1, 2)
self.__printer_options_widget.setLayout(options_layout)
def __init_projector_widget__(self, parent=None):
self.__projector_widget = QGroupBox("Projector Options", parent)
# self.__projector_widget.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
mirror_x = QCheckBox("Mirror X")
mirror_x.setChecked(self.dlp_controller.is_horizontal_mirrored())
mirror_x.toggled.connect(self.dlp_controller.set_horizontal_mirroring)
mirror_y = QCheckBox("Mirror Y")
mirror_y.setChecked(self.dlp_controller.is_vertical_mirrored())
mirror_y.toggled.connect(self.dlp_controller.set_vertical_mirroring)
start_projector_button = QPushButton("Start Projector",
self.__projector_widget)
start_projector_button.clicked.connect(
self.dlp_controller.start_projector)
project_pattern_button = QPushButton("Project Pattern",
self.__projector_widget)
project_pattern_button.clicked.connect(
self.dlp_controller.project_calibration_pattern)
print_position_button = QPushButton("Print Position",
self.__projector_widget)
print_position_button.clicked.connect(
self.dlp_controller.print_motor_position)
home_projector_button = QPushButton("Home Projector",
self.__projector_widget)
home_projector_button.clicked.connect(
self.dlp_controller.home_projector)
move_projector_button = QPushButton("Move Projector",
self.__projector_widget)
move_projector_button.clicked.connect(
self.dlp_controller.move_projector)
move_projector_edit = QDoubleSpinBox(self.__projector_widget)
move_projector_edit.setSuffix("mm")
move_projector_edit.setMaximum(10000)
move_projector_edit.setMinimum(-10000)
move_projector_edit.setDecimals(3)
move_projector_edit.setSingleStep(0.001)
move_projector_edit.valueChanged.connect(
self.dlp_controller.update_projector_distance)
set_amplitude_button = QPushButton("Set Projector Amplitude",
self.__projector_widget)
set_amplitude_button.clicked.connect(
self.dlp_controller.set_projector_amplitude)
set_amplitude_edit = QSpinBox(self.__projector_widget)
set_amplitude_edit.setMaximum(1000)
set_amplitude_edit.setMinimum(0)
set_amplitude_edit.setValue(self.dlp_controller.projector_amplitude)
set_amplitude_edit.valueChanged.connect(
self.dlp_controller.update_projector_amplitude)
lock_unlock_projector_button = QPushButton("Lock/Unlock Projector",
self.__projector_widget)
lock_unlock_projector_button.clicked.connect(
self.dlp_controller.lock_unlock_projector)
projector_layout = QGridLayout(self.__projector_widget)
# projector_layout.addWidget(projector_label, 0, 0)
projector_layout.addWidget(mirror_x, 0, 1)
projector_layout.addWidget(mirror_y, 0, 2)
projector_layout.addWidget(start_projector_button, 1, 0, 1, 1)
projector_layout.addWidget(project_pattern_button, 1, 1, 1, 1)
projector_layout.addWidget(print_position_button, 1, 2, 1, 1)
projector_layout.addWidget(home_projector_button, 2, 0, 1, 1)
projector_layout.addWidget(move_projector_button, 2, 1, 1, 1)
projector_layout.addWidget(move_projector_edit, 2, 2)
projector_layout.addWidget(set_amplitude_button, 3, 0, 1, 1)
projector_layout.addWidget(set_amplitude_edit, 3, 1)
projector_layout.addWidget(lock_unlock_projector_button, 3, 2, 1, 1)
self.__projector_widget.setLayout(projector_layout)
def __init_support_widget__(self, parent=None):
self.__support_widget = QGroupBox("Support Layers Parameters", parent)
# self.__support_widget.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
thickness_label = QLabel("Layer Thickness", self.__support_widget)
self.support_thickness_edit = MyDiscreteStepsSpinBox(
self.dlp_controller.get_step_length_microns(),
self.__support_widget)
self.support_thickness_edit.setSuffix(str('\u03BCm'))
self.support_thickness_edit.setMaximum(1000000)
self.support_thickness_edit.setMinimum(0)
self.support_thickness_edit.setDecimals(3)
self.support_thickness_edit.my_value_changed_signal.connect(
self.dlp_controller.set_support_thickness)
self.support_thickness_edit.setValue(
self.dlp_controller.support_thickness * 1000)
exposure_label = QLabel("Exposure Time", self.__support_widget)
exposure_edit = QDoubleSpinBox(self.__support_widget)
exposure_edit.setSuffix(str('ms'))
exposure_edit.setMaximum(10000000)
exposure_edit.setMinimum(0)
exposure_edit.setDecimals(1)
exposure_edit.setSingleStep(0.1)
exposure_edit.setValue(self.dlp_controller.support_exposure)
exposure_edit.valueChanged.connect(
self.dlp_controller.set_support_exposure_time)
amplitude_label = QLabel("Light Amplitude", self.__support_widget)
amplitude_edit = QSpinBox(self.__support_widget)
amplitude_edit.setMaximum(1600)
amplitude_edit.setMinimum(0)
amplitude_edit.setSingleStep(1)
amplitude_edit.setValue(self.dlp_controller.support_amplitude)
amplitude_edit.valueChanged.connect(
self.dlp_controller.set_support_amplitude)
burn_layers_label = QLabel("Burn Layers", self.__support_widget)
burn_layers_edit = QSpinBox(self.__support_widget)
burn_layers_edit.setMaximum(1000)
burn_layers_edit.setMinimum(0)
burn_layers_edit.setSingleStep(1)
burn_layers_edit.setValue(self.dlp_controller.support_burn_layers)
burn_layers_edit.valueChanged.connect(
self.dlp_controller.set_support_burning_layers)
burn_exposure_label = QLabel("Burn Exposure", self.__support_widget)
burn_exposure_edit = QDoubleSpinBox(self.__support_widget)
burn_exposure_edit.setSuffix(str('ms'))
burn_exposure_edit.setMaximum(100000)
burn_exposure_edit.setMinimum(0)
burn_exposure_edit.setDecimals(1)
burn_exposure_edit.setSingleStep(0.1)
burn_exposure_edit.setValue(self.dlp_controller.support_burn_exposure)
burn_exposure_edit.valueChanged.connect(
self.dlp_controller.set_support_burning_exposure_time)
burn_amplitude_label = QLabel("Burn Amplitude", self.__support_widget)
burn_amplitude_edit = QSpinBox(self.__support_widget)
burn_amplitude_edit.setMaximum(1600)
burn_amplitude_edit.setMinimum(0)
burn_amplitude_edit.setSingleStep(1)
burn_amplitude_edit.setValue(
self.dlp_controller.support_burn_amplitude)
burn_amplitude_edit.valueChanged.connect(
self.dlp_controller.set_support_burning_amplitude)
select_layers_button = QPushButton("Select Support Images")
select_layers_button.clicked.connect(self.load_support_images)
support_layout = QGridLayout(self.__support_widget)
support_layout.addWidget(thickness_label, 1, 0)
support_layout.addWidget(self.support_thickness_edit, 1, 1)
support_layout.addWidget(exposure_label, 2, 0)
support_layout.addWidget(exposure_edit, 2, 1)
support_layout.addWidget(amplitude_label, 3, 0)
support_layout.addWidget(amplitude_edit, 3, 1)
support_layout.addWidget(burn_layers_label, 4, 0)
support_layout.addWidget(burn_layers_edit, 4, 1)
support_layout.addWidget(burn_exposure_label, 5, 0)
support_layout.addWidget(burn_exposure_edit, 5, 1)
support_layout.addWidget(burn_amplitude_label, 6, 0)
support_layout.addWidget(burn_amplitude_edit, 6, 1)
support_layout.addWidget(select_layers_button, 7, 0, 1, 2)
self.__support_widget.setLayout(support_layout)
def __init_features_widget__(self, parent=None):
self.__features_widget = QGroupBox("Features Layers Parameters",
parent)
# self.__features_widget.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
thickness_label = QLabel("Layer Thickness", self.__features_widget)
self.features_thickness_edit = MyDiscreteStepsSpinBox(
self.dlp_controller.get_step_length_microns(),
self.__features_widget)
self.features_thickness_edit.setSuffix(str('\u03BCm'))
self.features_thickness_edit.setMaximum(1000000)
self.features_thickness_edit.setMinimum(0)
self.features_thickness_edit.setDecimals(3)
self.features_thickness_edit.my_value_changed_signal.connect(
self.dlp_controller.set_features_thickness)
self.features_thickness_edit.setValue(
self.dlp_controller.features_thickness * 1000)
exposure_label = QLabel("Exposure Time", self.__features_widget)
exposure_edit = QDoubleSpinBox(self.__features_widget)
exposure_edit.setSuffix(str('ms'))
exposure_edit.setMaximum(10000000)
exposure_edit.setMinimum(0)
exposure_edit.setDecimals(1)
exposure_edit.setSingleStep(0.1)
exposure_edit.setValue(self.dlp_controller.features_exposure)
exposure_edit.valueChanged.connect(
self.dlp_controller.set_features_exposure_time)
amplitude_label = QLabel("Light Amplitude", self.__features_widget)
amplitude_edit = QSpinBox(self.__features_widget)
amplitude_edit.setMaximum(1600)
amplitude_edit.setMinimum(0)
amplitude_edit.setSingleStep(1)
amplitude_edit.setValue(self.dlp_controller.features_amplitude)
amplitude_edit.valueChanged.connect(
self.dlp_controller.set_features_amplitude)
burn_layers_label = QLabel("Burn Layers", self.__features_widget)
burn_layers_edit = QSpinBox(self.__features_widget)
burn_layers_edit.setMaximum(1000)
burn_layers_edit.setMinimum(0)
burn_layers_edit.setSingleStep(1)
burn_layers_edit.setValue(self.dlp_controller.features_burn_layers)
burn_layers_edit.valueChanged.connect(
self.dlp_controller.set_features_burning_layers)
burn_exposure_label = QLabel("Burn Exposure", self.__features_widget)
burn_exposure_edit = QDoubleSpinBox(self.__features_widget)
burn_exposure_edit.setSuffix(str('ms'))
burn_exposure_edit.setMaximum(100000)
burn_exposure_edit.setMinimum(0)
burn_exposure_edit.setDecimals(1)
burn_exposure_edit.setSingleStep(0.1)
burn_exposure_edit.setValue(self.dlp_controller.features_burn_exposure)
burn_exposure_edit.valueChanged.connect(
self.dlp_controller.set_features_burning_exposure_time)
burn_amplitude_label = QLabel("Burn Amplitude", self.__features_widget)
burn_amplitude_edit = QSpinBox(self.__features_widget)
burn_amplitude_edit.setMaximum(1600)
burn_amplitude_edit.setMinimum(0)
burn_amplitude_edit.setSingleStep(1)
burn_amplitude_edit.setValue(
self.dlp_controller.features_burn_amplitude)
burn_amplitude_edit.valueChanged.connect(
self.dlp_controller.set_features_burning_amplitude)
select_layers_button = QPushButton("Select Features Images")
select_layers_button.clicked.connect(self.load_features_images)
features_layout = QGridLayout(self.__features_widget)
features_layout.addWidget(thickness_label, 1, 0)
features_layout.addWidget(self.features_thickness_edit, 1, 1)
features_layout.addWidget(exposure_label, 2, 0)
features_layout.addWidget(exposure_edit, 2, 1)
features_layout.addWidget(amplitude_label, 3, 0)
features_layout.addWidget(amplitude_edit, 3, 1)
features_layout.addWidget(burn_layers_label, 4, 0)
features_layout.addWidget(burn_layers_edit, 4, 1)
features_layout.addWidget(burn_exposure_label, 5, 0)
features_layout.addWidget(burn_exposure_edit, 5, 1)
features_layout.addWidget(burn_amplitude_label, 6, 0)
features_layout.addWidget(burn_amplitude_edit, 6, 1)
features_layout.addWidget(select_layers_button, 7, 0, 1, 2)
self.__features_widget.setLayout(features_layout)
def __init_advanced_features_widget__(self, parent=None):
self.__advanced_widget = QGroupBox("Advanced Features Options", parent)
fixed_layer_check = QCheckBox("Fixed Layer", self.__advanced_widget)
fixed_layer_check.setChecked(self.dlp_controller.fixed_layer)
fixed_layer_check.toggled.connect(self.dlp_controller.set_fixed_layer)
incremental_amplitude_check = QCheckBox("Incremental Amplitude",
self.__advanced_widget)
incremental_amplitude_check.setChecked(
self.dlp_controller.incremental_amplitude)
incremental_amplitude_check.toggled.connect(
self.dlp_controller.set_incremental_amplitude)
starting_amplitude_label = QLabel("Starting Amplitude",
self.__advanced_widget)
starting_amplitude_edit = QSpinBox(self.__advanced_widget)
starting_amplitude_edit.setMaximum(1000)
starting_amplitude_edit.setMinimum(0)
starting_amplitude_edit.setSingleStep(1)
starting_amplitude_edit.setValue(
self.dlp_controller.starting_incremental_amplitude)
starting_amplitude_edit.valueChanged.connect(
self.dlp_controller.set_starting_incremental_amplitude)
amplitude_step_label = QLabel("Step Size", self.__advanced_widget)
amplitude_step_edit = QSpinBox(self.__advanced_widget)
amplitude_step_edit.setMaximum(1000)
amplitude_step_edit.setMinimum(0)
amplitude_step_edit.setSingleStep(1)
amplitude_step_edit.setValue(
self.dlp_controller.incremental_step_amplitude)
amplitude_step_edit.valueChanged.connect(
self.dlp_controller.set_incremental_step_amplitude)
incremental_exposure_check = QCheckBox("Incremental Exposure",
self.__advanced_widget)
incremental_exposure_check.setChecked(
self.dlp_controller.incremental_exposure)
incremental_exposure_check.toggled.connect(
self.dlp_controller.set_incremental_exposure)
starting_exposure_label = QLabel("Starting Exposure",
self.__advanced_widget)
starting_exposure_edit = QDoubleSpinBox(self.__advanced_widget)
starting_exposure_edit.setSuffix(str('ms'))
starting_exposure_edit.setMaximum(100000)
starting_exposure_edit.setMinimum(0)
starting_exposure_edit.setDecimals(1)
starting_exposure_edit.setSingleStep(0.1)
starting_exposure_edit.valueChanged.connect(
self.dlp_controller.set_starting_incremental_exposure)
starting_exposure_edit.setValue(
self.dlp_controller.starting_incremental_exposure)
exposure_step_label = QLabel("Step Size", self.__advanced_widget)
exposure_step_edit = QDoubleSpinBox(self.__advanced_widget)
exposure_step_edit.setSuffix(str('ms'))
exposure_step_edit.setMaximum(100000)
exposure_step_edit.setMinimum(0)
exposure_step_edit.setDecimals(1)
exposure_step_edit.setSingleStep(0.1)
exposure_step_edit.valueChanged.connect(
self.dlp_controller.set_incremental_step_exposure)
exposure_step_edit.setValue(
self.dlp_controller.incremental_step_exposure)
incremental_thickness_check = QCheckBox("Incremental Thickness",
self.__advanced_widget)
incremental_thickness_check.setChecked(
self.dlp_controller.incremental_thickness)
incremental_thickness_check.toggled.connect(
self.dlp_controller.set_incremental_thickness)
thickness_label = QLabel("Starting Thickness", self.__features_widget)
self.starting_thickness_edit = MyDiscreteStepsSpinBox(
self.dlp_controller.get_step_length_microns(),
self.__features_widget)
self.starting_thickness_edit.setSuffix(str('\u03BCm'))
self.starting_thickness_edit.setMaximum(1000000)
self.starting_thickness_edit.setMinimum(0)
self.starting_thickness_edit.setDecimals(3)
self.starting_thickness_edit.my_value_changed_signal.connect(
self.dlp_controller.set_starting_incremental_thickness)
self.starting_thickness_edit.setValue(
self.dlp_controller.starting_incremental_thickness * 1000)
thickness_step_label = QLabel("Step Size", self.__features_widget)
self.thickness_step_edit = MyDiscreteStepsSpinBox(
self.dlp_controller.get_step_length_microns(),
self.__features_widget)
self.thickness_step_edit.setSuffix(str('\u03BCm'))
self.thickness_step_edit.setMaximum(1000000)
self.thickness_step_edit.setMinimum(0)
self.thickness_step_edit.setDecimals(3)
self.thickness_step_edit.my_value_changed_signal.connect(
self.dlp_controller.set_incremental_step_thickness)
self.thickness_step_edit.setValue(
self.dlp_controller.incremental_step_thickness * 1000)
apply_grayscale_correction_check = QCheckBox("Grayscale Correction",
self.__advanced_widget)
apply_grayscale_correction_check.setChecked(
self.dlp_controller.grayscale_correction)
apply_grayscale_correction_check.toggled.connect(
self.dlp_controller.set_grayscale_correction)
grayscale_parameters_widget = QWidget(self.__features_widget)
a_parameter_label = QLabel("\u03B1", grayscale_parameters_widget)
alpha_parameter_edit = QDoubleSpinBox(grayscale_parameters_widget)
alpha_parameter_edit.setMaximum(1000)
alpha_parameter_edit.setMinimum(0)
alpha_parameter_edit.setDecimals(3)
alpha_parameter_edit.setSingleStep(0.001)
alpha_parameter_edit.valueChanged.connect(
self.dlp_controller.set_grayscale_alpha)
alpha_parameter_edit.setValue(self.dlp_controller.grayscale_alpha)
beta_parameter_label = QLabel("\u03B2", grayscale_parameters_widget)
beta_parameter_edit = QDoubleSpinBox(grayscale_parameters_widget)
beta_parameter_edit.setMaximum(1000)
beta_parameter_edit.setMinimum(0)
beta_parameter_edit.setDecimals(3)
beta_parameter_edit.setSingleStep(0.001)
beta_parameter_edit.valueChanged.connect(
self.dlp_controller.set_grayscale_beta)
beta_parameter_edit.setValue(self.dlp_controller.grayscale_beta)
gamma_parameter_label = QLabel("\u03B3", grayscale_parameters_widget)
gamma_parameter_edit = QDoubleSpinBox(grayscale_parameters_widget)
gamma_parameter_edit.setMaximum(1000)
gamma_parameter_edit.setMinimum(0)
gamma_parameter_edit.setDecimals(3)
gamma_parameter_edit.setSingleStep(0.001)
gamma_parameter_edit.valueChanged.connect(
self.dlp_controller.set_grayscale_gamma)
gamma_parameter_edit.setValue(self.dlp_controller.grayscale_gamma)
grayscale_parameters_layout = QHBoxLayout(grayscale_parameters_widget)
grayscale_parameters_layout.addWidget(a_parameter_label)
grayscale_parameters_layout.addWidget(alpha_parameter_edit)
grayscale_parameters_layout.addWidget(beta_parameter_label)
grayscale_parameters_layout.addWidget(beta_parameter_edit)
grayscale_parameters_layout.addWidget(gamma_parameter_label)
grayscale_parameters_layout.addWidget(gamma_parameter_edit)
grayscale_parameters_widget.setLayout(grayscale_parameters_layout)
advanced_features_layout = QGridLayout(self.__advanced_widget)
advanced_features_layout.addWidget(incremental_amplitude_check, 1, 0,
1, 2)
advanced_features_layout.addWidget(fixed_layer_check, 1, 3)
advanced_features_layout.addWidget(starting_amplitude_label, 2, 0)
advanced_features_layout.addWidget(starting_amplitude_edit, 2, 1)
advanced_features_layout.addWidget(amplitude_step_label, 2, 2)
advanced_features_layout.addWidget(amplitude_step_edit, 2, 3)
advanced_features_layout.addWidget(incremental_exposure_check, 3, 0, 1,
2)
advanced_features_layout.addWidget(starting_exposure_label, 4, 0)
advanced_features_layout.addWidget(starting_exposure_edit, 4, 1)
advanced_features_layout.addWidget(exposure_step_label, 4, 2)
advanced_features_layout.addWidget(exposure_step_edit, 4, 3)
advanced_features_layout.addWidget(incremental_thickness_check, 5, 0,
1, 2)
advanced_features_layout.addWidget(thickness_label, 6, 0)
advanced_features_layout.addWidget(self.starting_thickness_edit, 6, 1)
advanced_features_layout.addWidget(thickness_step_label, 6, 2)
advanced_features_layout.addWidget(self.thickness_step_edit, 6, 3)
advanced_features_layout.addWidget(apply_grayscale_correction_check, 7,
0, 1, 2)
advanced_features_layout.addWidget(grayscale_parameters_widget, 8, 0,
1, 4)
self.__advanced_widget.setLayout(advanced_features_layout)
def __init_start_stop_widget__(self, parent=None):
self.__start_stop_widget = QFrame(parent)
size = self.__left_layout.sizeHint()
start_button = QPushButton("START", self.__start_stop_widget)
start_button.setFixedSize(size.width() / 2, size.height() / 7)
start_button.clicked.connect(
self.dlp_controller.starting_printing_process)
stop_button = QPushButton("STOP", self.__start_stop_widget)
stop_button.setFixedSize(size.width() / 3, size.height() / 8)
stop_button.setStyleSheet(
"QPushButton {background-color: red; border-style: outset; border-width: 2px; "
"border-radius: 10px; border-color: beige; font: bold 20px; padding: 10px;}"
)
stop_button.clicked.connect(self.dlp_controller.stop_printing_process)
self.__start_stop_widget.setMinimumSize(size.width(),
size.height() / 6)
start_stop_layout = QGridLayout(self.__start_stop_widget)
start_stop_layout.addWidget(start_button, 0, 0)
start_stop_layout.addWidget(stop_button, 0, 1)
self.__start_stop_widget.setLayout(start_stop_layout)
def __init_preview_widget__(self, parent=None):
self.__preview_widget = QLabel(parent)
size = self.__left_layout.sizeHint()
self.dlp_controller.display_image_signal.connect(self.preview_image)
self.__preview_widget.setMinimumSize(size.width(), size.height() / 2.3)
# self.__preview_widget.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.__preview_widget.setScaledContents(True)
self.__preview_widget.setStyleSheet(
"QLabel { background-color : black}")
def __init_console_widget__(self, parent=None):
self.__console_widget = QPlainTextEdit(parent)
self.__console_widget.setReadOnly(True)
size = self.__left_layout.sizeHint()
# self.__console_widget.setFixedSize(size.width(), size.height()/3)
self.__console_widget.setStyleSheet(
"QPlainTextEdit { background-color : gray}")
palette = self.__console_widget.palette()
palette.setColor(QPalette.Text, QColor(255, 255, 255))
self.__console_widget.setPalette(palette)
self.dlp_controller.print_text_signal.connect(self.print_to_console)
def __init_username_jobname_widget__(self, parent=None):
self.__username_jobname_widget = QFrame(parent)
self.__username_jobname_widget.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.Maximum)
username_label = QLabel("Username",
parent=self.__username_jobname_widget)
username_edit = QLineEdit(parent=self.__username_jobname_widget)
username_edit.setText(self.dlp_controller.username)
username_edit.textChanged.connect(self.dlp_controller.set_username)
jobname_label = QLabel("Print Job Name",
parent=self.__username_jobname_widget)
jobname_edit = QLineEdit(parent=self.__username_jobname_widget)
jobname_edit.setText(self.dlp_controller.print_job_name)
jobname_edit.textChanged.connect(self.dlp_controller.set_printjob_name)
etc = self.dlp_controller.evaluate_time_estimate()
self.etc_label = QLabel(
"ETC: " +
QDateTime.fromTime_t(etc / 1000.0).toUTC().toString('hh:mm:ss'),
self.__username_jobname_widget)
self.dlp_controller.etc_updated_signal.connect(
self.update_time_estimate)
username_jobname_layout = QHBoxLayout(self.__username_jobname_widget)
username_jobname_layout.addWidget(self.etc_label)
username_jobname_layout.addWidget(username_label)
username_jobname_layout.addWidget(username_edit)
username_jobname_layout.addWidget(jobname_label)
username_jobname_layout.addWidget(jobname_edit)
self.__username_jobname_widget.setLayout(username_jobname_layout)
@Slot(QPixmap)
def preview_image(self, image):
image = image.scaled(self.__preview_widget.width(),
self.__preview_widget.height(),
Qt.IgnoreAspectRatio)
self.__preview_widget.setPixmap(image)
@Slot(str)
def print_to_console(self, txt):
self.__console_widget.appendPlainText(txt)
@Slot()
def closeEvent(self, event: QCloseEvent):
self.closing_window_event.emit()
event.accept()
@Slot()
def load_support_images(self):
file_names = QFileDialog.getOpenFileNames(
caption='Select images',
dir='../',
filter="Image Files (*.png *.jpg *.bmp)")
self.dlp_controller.set_support_images(file_names[0])
@Slot()
def load_features_images(self):
file_names = QFileDialog.getOpenFileNames(
caption='Select images',
dir='../',
filter="Image Files (*.png *.jpg *.bmp)")
self.dlp_controller.set_features_images(file_names[0])
@Slot()
def block_parameters_signals(self):
for widget in self.__left_widget.findChildren(QWidget):
widget.blockSignals(True)
@Slot()
def reactivate_parameters_signals(self):
for widget in self.__left_widget.findChildren(QWidget):
widget.blockSignals(False)
@Slot()
def update_time_estimate(self, etc_ms):
self.etc_label.setText(
"ETC: " +
QDateTime.fromTime_t(etc_ms / 1000.0).toUTC().toString('hh:mm:ss'))
@Slot()
def update_port_list(self):
self.dlp_controller.update_port_list()
self.port_list.clear()
self.port_list.addItems(self.dlp_controller.available_ports())
@Slot(bool)
def update_motor_parameters(self, is_changed):
self.move_edit.set_step_size(
self.dlp_controller.get_step_length_microns() / 1000.0)
self.support_thickness_edit.set_step_size(
self.dlp_controller.get_step_length_microns())
self.support_thickness_edit.spinbox_is_value_valid(
self.dlp_controller.support_thickness * 1000)
self.features_thickness_edit.set_step_size(
self.dlp_controller.get_step_length_microns())
self.features_thickness_edit.spinbox_is_value_valid(
self.dlp_controller.features_thickness * 1000)
self.starting_thickness_edit.set_step_size(
self.dlp_controller.get_step_length_microns())
self.starting_thickness_edit.spinbox_is_value_valid(
self.dlp_controller.starting_incremental_thickness * 1000)
self.thickness_step_edit.set_step_size(
self.dlp_controller.get_step_length_microns())
self.thickness_step_edit.spinbox_is_value_valid(
self.dlp_controller.incremental_step_thickness * 1000)
class FrmPanelMoveWidget(QWidget):
def __init__(self, parent: QWidget = None):
super(FrmPanelMoveWidget, self).__init__(parent)
self.btns: List[LightButton] = []
layout = QGridLayout()
self.btnClear = QPushButton('清除')
self.btnClear.setMinimumWidth(120)
self.btnShow = QPushButton('显示子元素坐标')
self.btnShow.setMinimumWidth(120)
self.checkBox = QCheckBox('可移动')
self.frame = QFrame()
self.frame.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Expanding)
self.frame.setMinimumHeight(100)
self.frame.setFrameShape(QFrame.StyledPanel)
self.frame.setFrameShadow(QFrame.Sunken)
self.horizontalSpacer = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.textEdit = QTextEdit()
self.textEdit.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred)
self.textEdit.setReadOnly(True)
layout.addWidget(self.frame, 0, 0)
layout.addWidget(self.textEdit, 1, 0)
layout2 = QHBoxLayout()
layout2.addItem(self.horizontalSpacer)
layout2.addWidget(self.checkBox)
layout2.addWidget(self.btnShow)
layout2.addWidget(self.btnClear)
layout.addLayout(layout2, 2, 0)
self.setLayout(layout)
self.initForm()
self.checkBox.stateChanged.connect(self.on_checkBox_stateChanged)
self.btnShow.clicked.connect(self.on_btnShow_clicked)
self.btnClear.clicked.connect(self.on_btnClear_clicked)
def initForm(self) -> None:
colors: List[QColor] = [
QColor(100, 184, 255),
QColor(255, 107, 107),
QColor(24, 189, 155),
QColor(1, 174, 103),
QColor(52, 73, 94)
]
x: int = 5
y: int = 5
radius: int = 50
for i in range(5):
btn: LightButton = LightButton(self.frame)
btn.setGeometry(x, y, radius, radius)
x = x + radius
btn.text = "0%d" % (i + 1)
btn.canMove = False
btn.showOverlay = False
btn.bgColor = colors[i]
self.btns.append(btn)
def on_checkBox_stateChanged(self, arg1: int) -> None:
canMove: bool = arg1 != 0
for btn in self.btns:
btn.canMove = canMove
def on_btnShow_clicked(self) -> None:
for btn in self.btns:
text: str = btn.text
x: int = btn.x()
y: int = btn.y()
self.textEdit.append("名称:%s\tx:%d\ty:%d" % (text, x, y))
def on_btnClear_clicked(self) -> None:
self.textEdit.clear()
def _add_process(self):
process_groupbox = QGroupBox("Process")
process_groupbox.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
process_layout = QVBoxLayout()
process_layout.setSpacing(0)
process_groupbox.setLayout(process_layout)
pbar_frame = QFrame()
pbar_frame.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
pbar_hbox = QHBoxLayout()
pbar_hbox.setContentsMargins(QtCore.QMargins(0, 0, 0, 16))
pbar_hbox.setSpacing(16)
# Run and stop buttons
hbox = QHBoxLayout()
hbox.setSpacing(8)
self.run_button = QPushButton()
# is only enabled when validation passes
self.run_button.setEnabled(False)
self.run_button.setText("Run")
self.run_button.setFixedWidth(100)
run_icon = qta.icon('fa.play', color='green')
self.run_button.setIcon(run_icon)
self.run_button.clicked.connect(self._click_run)
hbox.addWidget(self.run_button)
self.stop_button = QPushButton()
self.stop_button.setEnabled(False)
self.stop_button.setText("Stop")
self.stop_button.setFixedWidth(100)
stop_icon = qta.icon('fa.stop', color='red')
self.stop_button.setIcon(stop_icon)
self.stop_button.clicked.connect(self._click_stop)
hbox.addWidget(self.stop_button)
self.progress_bar = QProgressBar()
self.progress_bar.setTextVisible(True)
self.progress_bar.setAlignment(QtCore.Qt.AlignCenter)
self.progress_bar.setValue(0)
self.progress_bar.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
pbar_hbox.addLayout(hbox)
pbar_hbox.addWidget(self.progress_bar)
pbar_frame.setLayout(pbar_hbox)
process_layout.addWidget(pbar_frame)
self.warning_frame = QFrame()
self.warning_frame.setVisible(False)
self.warning_frame.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
hbox = QHBoxLayout()
warning_icon_widget = qta.IconWidget('fa.warning', color='red')
warning_icon_widget.setIconSize(QtCore.QSize(48, 48))
warning_icon_widget.update()
hbox.addWidget(warning_icon_widget)
warning_label = QLabel(
"Grid Transformer did not complete successfully. Please refer to "
"log output.")
warning_label.setStyleSheet("QLabel { color: red; }")
warning_label.setWordWrap(True)
warning_label.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred)
hbox.addWidget(warning_label)
self.warning_frame.setLayout(hbox)
process_layout.addWidget(self.warning_frame)
self.success_frame = QFrame()
self.success_frame.setVisible(False)
self.success_frame.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
hbox = QHBoxLayout()
success_icon_widget = qta.IconWidget('fa.check', color='green')
success_icon_widget.setIconSize(QtCore.QSize(48, 48))
success_icon_widget.update()
hbox.addWidget(success_icon_widget)
success_label = QLabel("Grid Transformer completed successfully.")
success_label.setStyleSheet("QLabel { color: green; }")
success_label.setWordWrap(True)
success_label.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred)
hbox.addWidget(success_label)
self.success_frame.setLayout(hbox)
process_layout.addWidget(self.success_frame)
log_layout = QVBoxLayout()
log_layout.setSpacing(4)
log_label = QLabel("Log messages")
log_label.setStyleSheet("QLabel { color: grey; }")
log_layout.addWidget(log_label)
self.log_messages = QPlainTextEdit()
log_font = QFont("monospace")
log_font.setStyleHint(QFont.TypeWriter)
self.log_messages.setFont(log_font)
self.log_messages.setReadOnly(True)
self.log_messages.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
# self.log_messages.sizePolicy.setVerticalStretch(1)
log_layout.addWidget(self.log_messages)
process_layout.addLayout(log_layout)
self.layout.addWidget(process_groupbox)
class GridTransformerDialog(QDialog):
def __init__(self, parent=None):
super(GridTransformerDialog, self).__init__(
parent, QtCore.Qt.WindowSystemMenuHint | QtCore.Qt.WindowTitleHint
| QtCore.Qt.WindowCloseButtonHint)
self.setWindowTitle("Grid Transformer")
self.setWindowIcon(qta.icon('fa.th'))
# dict to store inputs that will get passed to the grid transformer
# this gets validated to ensure all the bits of info are in it before
# the run button gets enabled
self.grid_transformer_inputs = {}
self.layout = QVBoxLayout()
self.setLayout(self.layout)
self._add_inputs()
self._add_output()
self._add_process()
close_layout = QHBoxLayout()
close_layout.addStretch()
button_close = QPushButton("Close")
button_close.clicked.connect(self.close_dialog)
close_layout.addWidget(button_close)
self.layout.addLayout(close_layout)
def _add_inputs(self):
inputs_groupbox = QGroupBox("Inputs")
inputs_groupbox.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
inputs_layout = QVBoxLayout()
inputs_layout.setSpacing(0)
inputs_groupbox.setLayout(inputs_layout)
for input_band_name in input_band_names:
inputband = GridTransformerInputBand(input_band_name)
inputs_layout.addWidget(inputband)
inputband.band_selected.connect(self._band_selected)
inputband.log_message.connect(self._log_message)
self.layout.addWidget(inputs_groupbox)
def _band_selected(self, band_details):
band_name, filename, band_index = band_details
self.grid_transformer_inputs[band_name] = (filename, band_index)
self.validate()
def validate(self):
self.run_button.setEnabled(self._is_valid())
def _is_valid(self) -> bool:
'''Is this ready to run, as in has the user specified all inputs needed
for the grid transformer'''
for band_name in input_band_names:
if band_name not in self.grid_transformer_inputs:
return False
if self.grid_transformer_inputs[band_name] is None:
return False
if 'output' not in self.grid_transformer_inputs:
return False
return True
def _log_message(self, message):
self.log_messages.appendPlainText(message)
def _add_output(self):
output_groupbox = QGroupBox("Output")
output_groupbox.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
output_layout = QVBoxLayout()
output_layout.setSpacing(0)
output_groupbox.setLayout(output_layout)
output_file_layout = QHBoxLayout()
output_file_layout.setSpacing(4)
self.output_file_input = QLineEdit()
self.output_file_input.textChanged.connect(
self._on_output_filename_changed)
self.output_file_input.setMinimumWidth(400)
self.output_file_input.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
output_file_layout.addWidget(self.output_file_input)
output_layout.addLayout(output_file_layout)
self.open_output_file_button = QPushButton()
output_file_layout.addWidget(self.open_output_file_button)
self.open_output_file_button.setIcon(qta.icon('fa.folder-open'))
self.open_output_file_button.setToolTip("Select output file location")
self.open_output_file_button.clicked.connect(self._click_open_output)
self.layout.addWidget(output_groupbox)
def _on_output_filename_changed(self, filename):
self.grid_transformer_inputs['output'] = filename
self.validate()
def _set_output_filename(self, filename):
self.output_file_input.setText(filename)
self.grid_transformer_inputs['output'] = filename
self.validate()
def _click_open_output(self):
filters = ("GeoTIFF (*.tif *.tiff)")
filename, _ = QFileDialog.getSaveFileName(
self, f"Select output file",
GuiSettings.settings().value(output_folder_settings), filters)
if filename is None:
return
last_open_folder = os.path.dirname(filename)
if os.path.exists(last_open_folder):
GuiSettings.settings().setValue(output_folder_settings,
last_open_folder)
self._set_output_filename(filename)
def _add_process(self):
process_groupbox = QGroupBox("Process")
process_groupbox.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
process_layout = QVBoxLayout()
process_layout.setSpacing(0)
process_groupbox.setLayout(process_layout)
pbar_frame = QFrame()
pbar_frame.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
pbar_hbox = QHBoxLayout()
pbar_hbox.setContentsMargins(QtCore.QMargins(0, 0, 0, 16))
pbar_hbox.setSpacing(16)
# Run and stop buttons
hbox = QHBoxLayout()
hbox.setSpacing(8)
self.run_button = QPushButton()
# is only enabled when validation passes
self.run_button.setEnabled(False)
self.run_button.setText("Run")
self.run_button.setFixedWidth(100)
run_icon = qta.icon('fa.play', color='green')
self.run_button.setIcon(run_icon)
self.run_button.clicked.connect(self._click_run)
hbox.addWidget(self.run_button)
self.stop_button = QPushButton()
self.stop_button.setEnabled(False)
self.stop_button.setText("Stop")
self.stop_button.setFixedWidth(100)
stop_icon = qta.icon('fa.stop', color='red')
self.stop_button.setIcon(stop_icon)
self.stop_button.clicked.connect(self._click_stop)
hbox.addWidget(self.stop_button)
self.progress_bar = QProgressBar()
self.progress_bar.setTextVisible(True)
self.progress_bar.setAlignment(QtCore.Qt.AlignCenter)
self.progress_bar.setValue(0)
self.progress_bar.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
pbar_hbox.addLayout(hbox)
pbar_hbox.addWidget(self.progress_bar)
pbar_frame.setLayout(pbar_hbox)
process_layout.addWidget(pbar_frame)
self.warning_frame = QFrame()
self.warning_frame.setVisible(False)
self.warning_frame.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
hbox = QHBoxLayout()
warning_icon_widget = qta.IconWidget('fa.warning', color='red')
warning_icon_widget.setIconSize(QtCore.QSize(48, 48))
warning_icon_widget.update()
hbox.addWidget(warning_icon_widget)
warning_label = QLabel(
"Grid Transformer did not complete successfully. Please refer to "
"log output.")
warning_label.setStyleSheet("QLabel { color: red; }")
warning_label.setWordWrap(True)
warning_label.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred)
hbox.addWidget(warning_label)
self.warning_frame.setLayout(hbox)
process_layout.addWidget(self.warning_frame)
self.success_frame = QFrame()
self.success_frame.setVisible(False)
self.success_frame.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
hbox = QHBoxLayout()
success_icon_widget = qta.IconWidget('fa.check', color='green')
success_icon_widget.setIconSize(QtCore.QSize(48, 48))
success_icon_widget.update()
hbox.addWidget(success_icon_widget)
success_label = QLabel("Grid Transformer completed successfully.")
success_label.setStyleSheet("QLabel { color: green; }")
success_label.setWordWrap(True)
success_label.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred)
hbox.addWidget(success_label)
self.success_frame.setLayout(hbox)
process_layout.addWidget(self.success_frame)
log_layout = QVBoxLayout()
log_layout.setSpacing(4)
log_label = QLabel("Log messages")
log_label.setStyleSheet("QLabel { color: grey; }")
log_layout.addWidget(log_label)
self.log_messages = QPlainTextEdit()
log_font = QFont("monospace")
log_font.setStyleHint(QFont.TypeWriter)
self.log_messages.setFont(log_font)
self.log_messages.setReadOnly(True)
self.log_messages.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
# self.log_messages.sizePolicy.setVerticalStretch(1)
log_layout.addWidget(self.log_messages)
process_layout.addLayout(log_layout)
self.layout.addWidget(process_groupbox)
def _on_progress(self, progress):
self.progress_bar.setValue(int(progress * 100))
def _on_complete(self, successful: bool):
self.warning_frame.setVisible(not successful)
self.success_frame.setVisible(successful)
self.stop_button.setEnabled(False)
self.run_button.setEnabled(True)
run_time = time.perf_counter() - self.start_time
self._log_message(
f"Total grid transformation time = {run_time:.2f} sec")
self._log_message("\n\n")
def _click_run(self):
self.warning_frame.setVisible(False)
self.success_frame.setVisible(False)
self.stop_button.setEnabled(True)
self.run_button.setEnabled(False)
self.gt_executor = QtGridTransformerThread(
self.grid_transformer_inputs)
self.gt_executor.progress.connect(self._on_progress)
self.gt_executor.message.connect(self._log_message)
self.gt_executor.complete.connect(self._on_complete)
self.start_time = time.perf_counter()
self._log_message("\n\nStarting Grid Transformer process")
self.gt_executor.start()
def _click_stop(self):
if self.gt_executor is not None:
self.gt_executor.stop()
def close_dialog(self):
self.close()
class RunTab(QtWidgets.QWidget):
run_checks = QtCore.Signal()
def __init__(self, prj: QAXProject):
super(RunTab, self).__init__()
self.prj = prj
self.check_executor = None
self.vbox = QtWidgets.QVBoxLayout()
self.setLayout(self.vbox)
self._add_check_outputs()
self._add_process()
# final setup
self.set_run_stop_buttons_enabled(False)
def _add_check_outputs(self):
co_groupbox = QGroupBox("Check outputs")
co_groupbox.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
co_layout = QVBoxLayout()
co_layout.setSpacing(16)
co_groupbox.setLayout(co_layout)
self.qajson_spatial_checkbox = QCheckBox(
"Include summary spatial output in QAJSON. "
"Supports QAX visualisation.")
self.qajson_spatial_checkbox.setCheckState(
QtCore.Qt.CheckState.Checked)
co_layout.addWidget(self.qajson_spatial_checkbox)
export_layout = QVBoxLayout()
export_layout.setSpacing(4)
self.export_spatial_checkbox = QCheckBox(
"Export detailed spatial outputs to file. "
"Supports visualisation in other geospatial applications.")
self.export_spatial_checkbox.stateChanged.connect(
self._on_export_spatial_changed)
export_layout.addWidget(self.export_spatial_checkbox)
output_folder_layout = QHBoxLayout()
output_folder_layout.setSpacing(4)
output_folder_layout.addSpacerItem(QtWidgets.QSpacerItem(37, 20))
self.output_folder_label = QLabel(
"Detailed spatial output folder location:")
output_folder_layout.addWidget(self.output_folder_label)
self.output_folder_input = QLineEdit()
self.output_folder_input.setText(
GuiSettings.settings().value("spatial_outputs"))
self.output_folder_input.setMinimumWidth(300)
self.output_folder_input.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
output_folder_layout.addWidget(self.output_folder_input)
self.open_output_folder_button = QPushButton()
output_folder_layout.addWidget(self.open_output_folder_button)
self.open_output_folder_button.setIcon(qta.icon('fa.folder-open'))
self.open_output_folder_button.setToolTip(
f"Select file containing data")
self.open_output_folder_button.clicked.connect(
self._click_open_spatial_export_folder)
export_layout.addLayout(output_folder_layout)
co_layout.addLayout(export_layout)
self._on_export_spatial_changed()
self.vbox.addWidget(co_groupbox)
def _click_open_spatial_export_folder(self):
output_folder = QFileDialog.getExistingDirectory(
self, f"Select folder for spatial outputs",
GuiSettings.settings().value("spatial_outputs"),
QFileDialog.ShowDirsOnly)
if os.path.exists(output_folder):
GuiSettings.settings().setValue("spatial_outputs", output_folder)
self.output_folder_input.setText(output_folder)
def _on_export_spatial_changed(self):
is_export = self.export_spatial_checkbox.isChecked()
self.output_folder_label.setEnabled(is_export)
self.output_folder_input.setEnabled(is_export)
self.open_output_folder_button.setEnabled(is_export)
def _add_process(self):
process_groupbox = QGroupBox("Process")
process_groupbox.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
process_layout = QVBoxLayout()
process_layout.setSpacing(0)
process_groupbox.setLayout(process_layout)
pbar_frame = QFrame()
pbar_frame.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
pbar_hbox = QHBoxLayout()
pbar_hbox.setContentsMargins(QtCore.QMargins(0, 0, 0, 16))
pbar_hbox.setSpacing(16)
# Run and stop buttons
hbox = QHBoxLayout()
hbox.setSpacing(8)
self.run_button = QPushButton()
# is only enabled when validation passes
self.run_button.setEnabled(False)
self.run_button.setText("Run")
self.run_button.setToolTip("Start check execution")
self.run_button.setFixedWidth(100)
run_icon = qta.icon('fa.play', color='green')
self.run_button.setIcon(run_icon)
self.run_button.clicked.connect(self._click_run)
hbox.addWidget(self.run_button)
self.stop_button = QPushButton()
self.stop_button.setEnabled(False)
self.stop_button.setText("Stop")
self.stop_button.setToolTip("Stop check execution")
self.stop_button.setFixedWidth(100)
stop_icon = qta.icon('fa.stop', color='red')
self.stop_button.setIcon(stop_icon)
self.stop_button.clicked.connect(self._click_stop)
hbox.addWidget(self.stop_button)
self.progress_bar = QProgressBar()
self.progress_bar.setTextVisible(True)
self.progress_bar.setAlignment(QtCore.Qt.AlignCenter)
self.progress_bar.setValue(0)
self.progress_bar.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
pbar_hbox.addLayout(hbox)
pbar_hbox.addWidget(self.progress_bar)
pbar_frame.setLayout(pbar_hbox)
process_layout.addWidget(pbar_frame)
vbox = QVBoxLayout()
vbox.setSpacing(8)
vbox.setContentsMargins(QtCore.QMargins(0, 0, 0, 16))
process_layout.addLayout(vbox)
hbox = QHBoxLayout()
vbox.addLayout(hbox)
check_name_label = QLabel("Check:")
check_name_label.setFixedWidth(80)
hbox.addWidget(check_name_label)
self.check_name_text_label = QLabel("n/a")
hbox.addWidget(self.check_name_text_label)
hbox = QHBoxLayout()
vbox.addLayout(hbox)
status_name_label = QLabel("Status:")
status_name_label.setFixedWidth(80)
hbox.addWidget(status_name_label)
self.status_name_text_label = QLabel("Not started")
hbox.addWidget(self.status_name_text_label)
self.warning_frame = QFrame()
self.warning_frame.setVisible(False)
self.warning_frame.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
hbox = QHBoxLayout()
warning_icon_widget = qta.IconWidget('fa.warning', color='red')
warning_icon_widget.setIconSize(QtCore.QSize(48, 48))
warning_icon_widget.update()
hbox.addWidget(warning_icon_widget)
warning_label = QLabel(
"Grid Transformer did not complete successfully. Please refer to "
"log output.")
warning_label.setStyleSheet("QLabel { color: red; }")
warning_label.setWordWrap(True)
warning_label.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred)
hbox.addWidget(warning_label)
self.warning_frame.setLayout(hbox)
process_layout.addWidget(self.warning_frame)
self.success_frame = QFrame()
self.success_frame.setVisible(False)
self.success_frame.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
hbox = QHBoxLayout()
success_icon_widget = qta.IconWidget('fa.check', color='green')
success_icon_widget.setIconSize(QtCore.QSize(48, 48))
success_icon_widget.update()
hbox.addWidget(success_icon_widget)
success_label = QLabel("All checks completed successfully.")
success_label.setStyleSheet("QLabel { color: green; }")
success_label.setWordWrap(True)
success_label.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred)
hbox.addWidget(success_label)
self.success_frame.setLayout(hbox)
process_layout.addWidget(self.success_frame)
log_layout = QVBoxLayout()
log_layout.setSpacing(4)
log_label = QLabel("Log messages")
log_label.setStyleSheet("QLabel { color: grey; }")
log_layout.addWidget(log_label)
self.log_messages = QPlainTextEdit()
log_font = QFont("monospace")
log_font.setStyleHint(QFont.TypeWriter)
self.log_messages.setFont(log_font)
self.log_messages.setReadOnly(True)
self.log_messages.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
log_layout.addWidget(self.log_messages)
process_layout.addLayout(log_layout)
self.vbox.addWidget(process_groupbox)
def set_run_stop_buttons_enabled(self, is_running: bool) -> NoReturn:
if is_running:
self.run_button.setEnabled(False)
self.stop_button.setEnabled(True)
else:
self.run_button.setEnabled(True)
self.stop_button.setEnabled(False)
def _log_message(self, message):
self.log_messages.appendPlainText(message)
def run_executor(self, check_executor: QtCheckExecutorThread):
# we pass the check_executor into the run tab as this is where the UI
# components are that will display the execution status.
self.set_run_stop_buttons_enabled(True)
self._log_message("Check execution started")
self.start_time = time.perf_counter()
self.check_executor = check_executor
self.check_executor.options = self.get_options()
self.check_executor.check_tool_started.connect(
self._on_check_tool_started)
self.check_executor.progress.connect(self._on_progress)
self.check_executor.qajson_updated.connect(self._on_qajson_update)
self.check_executor.checks_complete.connect(self._on_checks_complete)
self.check_executor.status_changed.connect(self._on_status_change)
self.check_executor.start()
def get_options(self) -> Dict:
''' Gets a list of options based on user entered data. eg; the spatial
output specifications.
'''
return {
CheckOption.spatial_output_qajson:
self.qajson_spatial_checkbox.isChecked(),
CheckOption.spatial_output_export:
self.export_spatial_checkbox.isChecked(),
CheckOption.spatial_output_export_location:
self.output_folder_input.text()
}
def _click_run(self):
self.run_checks.emit()
def _click_stop(self):
if self.check_executor is None:
logger.warn("Check executor does not exist, cannot stop")
return
self._log_message("Stopping check execution")
self.check_executor.stop()
@QtCore.Slot(float)
def _on_progress(self, progress):
self.progress_bar.setValue(int(progress * 100))
@QtCore.Slot()
def _on_qajson_update(self):
self.prj.qa_json = self.check_executor.qa_json
@QtCore.Slot(object)
def _on_check_tool_started(self, tpl):
check_tool_name, check_number, total_check_count = tpl
self.check_name_text_label.setText("{} ({}/{})".format(
check_tool_name, check_number, total_check_count))
@QtCore.Slot()
def _on_checks_complete(self):
run_time = time.perf_counter() - self.start_time
self._log_message(
f"Execution time for all checks = {run_time:.2f} sec")
self._log_message("\n\n")
self.set_run_stop_buttons_enabled(False)
self.prj.qa_json = self.check_executor.qa_json
@QtCore.Slot(str)
def _on_status_change(self, status):
self.status_name_text_label.setText(status)
class CameraPanel(QWidget):
__obj = None
def __init__(self, n_camera, app: QApplication, *args, **kwargs):
if CameraPanel.__obj is not None:
raise type(
'InstanceExists', (Exception, ),
{})('A CameraPanel instance has already been constructed.')
CameraPanel.__obj = self
super().__init__(*args, **kwargs)
self.cameras = []
self.box = QVBoxLayout()
self.setLayout(self.box)
Configuration(n_camera, self)
TrafficMonitor(n_camera)
FrameRateMonitor(n_camera)
FrameDropMonitor(n_camera)
self.connectButton = QPushButton("Connect")
self.connectButton.clicked.connect(self.connectRemote)
self.reconnecting = QLabel("Disconnected. Trying to reconnect")
self.reconnecting.setWordWrap(True)
self.total_traffic = QLabel("0.000 KB/s")
self.restart_remote = QPushButton("Restart Remote")
self.restart_remote.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.Expanding)
self.restart_remote.clicked.connect(self.restartRemote)
self.scan = QPushButton("Scan")
self.scan.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Expanding)
self.scan.clicked.connect(Configuration().scan)
self.top_frame = QFrame()
self.top_frame.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum)
self.top_grid = QGridLayout()
self.top_grid.setContentsMargins(0, 0, 0, 0)
self.top_frame.setLayout(self.top_grid)
self.top_grid.addWidget(self.connectButton, 0, 1)
self.top_grid.addWidget(self.reconnecting, 0, 1)
self.top_grid.addWidget(self.total_traffic, 0, 1)
self.top_grid.addWidget(self.restart_remote, 0, 2)
self.top_grid.addWidget(self.scan, 0, 0)
self.total_traffic.hide()
self.reconnecting.hide()
self.box.addWidget(self.top_frame)
self.timer = QTimer()
self.timer.timeout.connect(self.updateTraffic)
self.timer.start(100)
for i in range(n_camera):
self.cameras.append(Camera(i, app))
main_splitter = QSplitter(Qt.Horizontal)
main_splitter.addWidget(self.cameras[0])
if n_camera == 2:
main_splitter.addWidget(self.cameras[1])
elif n_camera == 3:
sub_splitter = QSplitter(Qt.Horizontal)
sub_splitter.addWidget(self.cameras[1])
sub_splitter.addWidget(self.cameras[2])
main_splitter.addWidget(sub_splitter)
elif n_camera == 4:
sub_splitter = QSplitter(Qt.Horizontal)
sub_sub_splitter = QSplitter(Qt.Horizontal)
sub_splitter.addWidget(sub_sub_splitter)
sub_sub_splitter.addWidget(self.cameras[1])
sub_sub_splitter.addWidget(self.cameras[2])
sub_splitter.addWidget(self.cameras[3])
main_splitter.addWidget(sub_splitter)
self.box.addWidget(main_splitter)
def connectRemote(self):
"""
This function blocks until TCP connection succeeds.
Call with caution
"""
if Configuration().connect():
self.connectButton.hide()
self.total_traffic.show()
for cam in self.cameras:
cam.startReceiving()
cam.mode_selection.setEnabled(True)
cam.updateMode(cam.mode_selection.currentIndex())
def restartRemote(self):
os.system(
f'ssh root@{REMOTE_IP_ADDR} systemctl restart vision-server.service'
)
if self.connectButton.isVisible():
self.connectRemote()
else:
Configuration().reconnect()
def updateTraffic(self):
self.total_traffic.setText('{:<4} KB/s'.format(
round(TrafficMonitor().total / 1024, 2)))
class PlugboardWindow(_AbstractPlugboard):
"""Plugboard for setting Plugboard plug pairs in normal and Uhr mode"""
def __init__(self, master, enigma_api):
"""
Allows choosing and viewing current plugboard pairs
:param master: Qt parent object
:param enigma_api: {EnigmaAPI} Shared EnigmaAPI instance
"""
super().__init__(master, enigma_api, "Plugboard")
self._apply_plug = self.refresh_apply
# GENERATE PAIRS =======================================================
frame = QFrame(self)
for row in enigma_api.data()["layout"]:
row_frame = QFrame(frame)
row_layout = QHBoxLayout(row_frame)
row_layout.setMargin(0)
for letter in row:
letter = enigma_api.charset()[letter]
socket = Socket(row_frame, letter, self.connect_sockets,
self._enigma_api.charset())
self._plugs[letter] = socket
row_layout.addWidget(socket)
self._main_layout.addWidget(row_frame)
# BUTTONS ==============================================================
self._button_frame = QFrame(self)
self._button_frame.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
self._button_layout = QHBoxLayout(self._button_frame)
self.__reset_all = QPushButton("Clear pairs")
self.__reset_all.clicked.connect(self.clear_pairs)
self.__apply_btn = QPushButton("Apply")
self.__apply_btn.clicked.connect(self.collect)
storno = QPushButton("Storno")
storno.clicked.connect(self.hide)
self.__uhr = QPushButton("Uhr")
self.__uhr_window = UhrWindow(self, enigma_api.uhr_position)
self.__uhr.clicked.connect(self.__uhr_window.exec)
self.__enable_uhr = QCheckBox(
"Enable Uhr"
) # In that case all plugs must be occupied! (and red/white)
self.__enable_uhr.setChecked(enigma_api.uhr())
self.__enable_uhr.stateChanged.connect(self.__change_uhr_status)
# CONNECTS SOCKETS =====================================================
self._enigma_api = enigma_api
self.__change_uhr_status(False)
try:
self.set_pairs(self._enigma_api.plug_pairs())
except ValueError:
pass
# SHOW WIDGETS =========================================================
self._button_layout.addWidget(self.__enable_uhr)
self._button_layout.addWidget(self.__uhr)
self._button_layout.addStretch()
self._button_layout.addWidget(self.__reset_all)
self._button_layout.addWidget(storno)
self._button_layout.addWidget(self.__apply_btn)
self._main_layout.addWidget(self._button_frame)
def refresh_apply(self):
"""Enables "Apply" button either if Uhr is disabled or Uhr is enabled and
10 pairs are set"""
pair_n = len(self.pairs())
if self.__enable_uhr.isChecked() and pair_n != 10:
logging.info(
"Uhr pre-requisites not met, keeping button disabled...")
self.__apply_btn.setDisabled(True)
self.__apply_btn.setToolTip(
"When using the Uhr, exactly 10 plug pairs "
"must be connected!\n%d pairs left to connect..." %
(10 - pair_n))
else:
logging.info("Apply conditions met, Apply button enabled...")
self.__apply_btn.setDisabled(False)
self.__apply_btn.setToolTip(None)
def __change_uhr_status(self, clear=True):
"""Enables "Uhr" button if the checkmark is enabled
:param clear: {bool} Whether or not the connected pairs should be cleared
"""
if clear:
self.clear_pairs()
self.refresh_apply()
self._uhr_enabled = bool(self.__enable_uhr.isChecked())
self.__uhr.setEnabled(self._uhr_enabled)
if not self._uhr_enabled:
self.__uhr.setToolTip('Check "Enable Uhr" to enter Uhr settings')
def collect(self):
"""Collects all unique letter pairs, enables and sets up Uhr if it's also checked"""
pairs = self.pairs()
if self.__enable_uhr.isChecked():
logging.info("Connecting Uhr, setting position to %d",
self.__uhr_window.position())
self._enigma_api.uhr("connect")
self._enigma_api.uhr_position(self.__uhr_window.position())
else:
try:
logging.info("Disconnecting Uhr...")
self._enigma_api.uhr("disconnect")
except ValueError:
pass
logging.info('Setting plug pairs to "%s"',
str(["".join(pair) for pair in pairs]))
self._enigma_api.plug_pairs(pairs)
self.close()
class Ui_Whatspy(object):
def setupUi(self, Ventana):
if not Ventana.objectName():
Ventana.setObjectName(u"Ventana")
Ventana.resize(424, 600)
Ventana.setAttribute(Qt.WA_TranslucentBackground)
Ventana.setWindowFlag(Qt.FramelessWindowHint)
Ventana.setStyleSheet(
u"*{\n"
" font-family: century gothic;\n"
"}\n"
"\n"
"QSizeGrip{\n"
" background: transparent;\n"
"}\n"
"\n"
"QLabel{\n"
" color: white;\n"
"}\n"
"\n"
"QScrollBar:vertical {\n"
" border: 1px solid #999999;\n"
" width:12px; \n"
" margin: 0px 0px 0px 0px;\n"
" }\n"
" QScrollBar::handle:vertical { \n"
" \n"
" min-height: 0px;\n"
" border: 0px solid red;\n"
" border-radius: 4px;\n"
" background-color: rgb(182, 182, 182);\n"
" }\n"
" QScrollBar::add-line:vertical { \n"
" height: 0px;\n"
" subcontrol-position: bottom;\n"
" subcontrol-origin: margin;\n"
" }\n"
" QScrollBar::sub-line:vertical {\n"
" height: 0 px;\n"
" subcontrol-position: top;\n"
" subcontrol-origin: margin;\n"
" }")
self.gridLayout = QGridLayout(Ventana)
self.gridLayout.setObjectName(u"gridLayout")
self.gridLayout.setContentsMargins(0, 0, 0, 0)
self.VentanaFrame = QFrame(Ventana)
self.VentanaFrame.setObjectName(u"VentanaFrame")
self.VentanaFrame.setStyleSheet(
u"QFrame#VentanaFrame{\n"
" background-color: qlineargradient(spread:pad, x1:0.953, y1:1, x2:1, y2:0, stop:0 #075E54, stop:1 #128C7E);\n"
" border-radius: 5px;\n"
"}")
self.VentanaFrame.setFrameShape(QFrame.StyledPanel)
self.VentanaFrame.setFrameShadow(QFrame.Raised)
self.gridLayout_2 = QGridLayout(self.VentanaFrame)
self.gridLayout_2.setObjectName(u"gridLayout_2")
self.gridLayout_2.setContentsMargins(-1, 0, -1, -1)
self.Contenedor = QFrame(self.VentanaFrame)
self.Contenedor.setObjectName(u"Contenedor")
self.Contenedor.setStyleSheet(u"QFrame#Contenedor{\n"
" background-color: #128C7E;\n"
" border-radius: 5px;\n"
"}")
self.Contenedor.setFrameShape(QFrame.StyledPanel)
self.Contenedor.setFrameShadow(QFrame.Raised)
self.gridLayout_5 = QGridLayout(self.Contenedor)
self.gridLayout_5.setObjectName(u"gridLayout_5")
self.gridLayout_5.setContentsMargins(0, 10, 0, 10)
self.frameAcciones = QFrame(self.Contenedor)
self.frameAcciones.setObjectName(u"frameAcciones")
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.frameAcciones.sizePolicy().hasHeightForWidth())
self.frameAcciones.setSizePolicy(sizePolicy)
self.frameAcciones.setStyleSheet(u"")
self.frameAcciones.setFrameShape(QFrame.StyledPanel)
self.frameAcciones.setFrameShadow(QFrame.Raised)
self.gridLayout_4 = QGridLayout(self.frameAcciones)
self.gridLayout_4.setObjectName(u"gridLayout_4")
self.btnExportar = QPushButton(self.frameAcciones)
self.btnExportar.setObjectName(u"btnExportar")
sizePolicy1 = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Minimum)
sizePolicy1.setHorizontalStretch(0)
sizePolicy1.setVerticalStretch(0)
sizePolicy1.setHeightForWidth(
self.btnExportar.sizePolicy().hasHeightForWidth())
self.btnExportar.setSizePolicy(sizePolicy1)
self.btnExportar.setMinimumSize(QSize(100, 30))
self.btnExportar.setCursor(QCursor(Qt.PointingHandCursor))
self.btnExportar.setStyleSheet(u"QPushButton#btnExportar{\n"
"background-color: #ecf0f1;\n"
"border-radius: 5px;\n"
"}\n"
"\n"
"QPushButton#btnExportar:hover{\n"
"background-color: #bdc3c7;\n"
"border-radius: 5px;\n"
"}")
icon1 = QIcon()
icon1.addFile(u":/logo/exportar.png", QSize(), QIcon.Normal, QIcon.Off)
self.btnExportar.setIcon(icon1)
self.btnExportar.setIconSize(QSize(16, 16))
self.gridLayout_4.addWidget(self.btnExportar, 0, 2, 1, 1)
self.btnAbrir = QPushButton(self.frameAcciones)
self.btnAbrir.setObjectName(u"btnAbrir")
sizePolicy1.setHeightForWidth(
self.btnAbrir.sizePolicy().hasHeightForWidth())
self.btnAbrir.setSizePolicy(sizePolicy1)
self.btnAbrir.setMinimumSize(QSize(100, 30))
self.btnAbrir.setCursor(QCursor(Qt.PointingHandCursor))
self.btnAbrir.setStyleSheet(u"QPushButton#btnAbrir{\n"
"background-color: #ecf0f1;\n"
"border-radius: 5px;\n"
"}\n"
"\n"
"QPushButton#btnAbrir:hover{\n"
"background-color: #bdc3c7;\n"
"}")
icon2 = QIcon()
icon2.addFile(u":/logo/anadir.png", QSize(), QIcon.Normal, QIcon.Off)
self.btnAbrir.setIcon(icon2)
self.btnAbrir.setIconSize(QSize(16, 16))
self.gridLayout_4.addWidget(self.btnAbrir, 0, 1, 1, 1)
self.horizontalSpacer_2 = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.gridLayout_4.addItem(self.horizontalSpacer_2, 0, 0, 1, 1)
self.horizontalSpacer_3 = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.gridLayout_4.addItem(self.horizontalSpacer_3, 0, 3, 1, 1)
self.gridLayout_5.addWidget(self.frameAcciones, 2, 0, 1, 1)
self.frameTabla = QFrame(self.Contenedor)
self.frameTabla.setObjectName(u"frameTabla")
sizePolicy2 = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
sizePolicy2.setHorizontalStretch(0)
sizePolicy2.setVerticalStretch(0)
sizePolicy2.setHeightForWidth(
self.frameTabla.sizePolicy().hasHeightForWidth())
self.frameTabla.setSizePolicy(sizePolicy2)
self.frameTabla.setStyleSheet(u"")
self.frameTabla.setFrameShape(QFrame.StyledPanel)
self.frameTabla.setFrameShadow(QFrame.Raised)
self.horizontalLayout_2 = QHBoxLayout(self.frameTabla)
self.horizontalLayout_2.setObjectName(u"horizontalLayout_2")
self.horizontalLayout_2.setContentsMargins(0, 0, 0, 0)
self.horizontalSpacer_4 = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout_2.addItem(self.horizontalSpacer_4)
self.tableWidget = QTableWidget(self.frameTabla)
if (self.tableWidget.columnCount() < 2):
self.tableWidget.setColumnCount(2)
__qtablewidgetitem = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(0, __qtablewidgetitem)
__qtablewidgetitem1 = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(1, __qtablewidgetitem1)
if (self.tableWidget.rowCount() < 50):
self.tableWidget.setRowCount(50)
__qtablewidgetitem2 = QTableWidgetItem()
self.tableWidget.setItem(0, 0, __qtablewidgetitem2)
self.tableWidget.setObjectName(u"tableWidget")
sizePolicy1.setHeightForWidth(
self.tableWidget.sizePolicy().hasHeightForWidth())
self.tableWidget.setSizePolicy(sizePolicy1)
self.tableWidget.setMinimumSize(QSize(350, 0))
self.tableWidget.setStyleSheet(u"QTableWidget#tableWidget:item{\n"
"color:white;\n"
"font-weight: bold;\n"
"}\n"
"\n"
"QTableWidget#tableWidget{\n"
"border-radius:4px;\n"
"background-color: #128C7E;\n"
"}")
self.tableWidget.setRowCount(50)
self.horizontalLayout_2.addWidget(self.tableWidget)
self.horizontalSpacer_5 = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout_2.addItem(self.horizontalSpacer_5)
self.gridLayout_5.addWidget(self.frameTabla, 3, 0, 1, 1)
self.header = QFrame(self.Contenedor)
self.header.setObjectName(u"header")
sizePolicy.setHeightForWidth(
self.header.sizePolicy().hasHeightForWidth())
self.header.setSizePolicy(sizePolicy)
self.header.setStyleSheet(u"")
self.header.setFrameShape(QFrame.StyledPanel)
self.header.setFrameShadow(QFrame.Raised)
self.horizontalLayout = QHBoxLayout(self.header)
self.horizontalLayout.setObjectName(u"horizontalLayout")
self.horizontalLayout.setContentsMargins(0, 0, 5, 0)
self.horizontalSpacer = QSpacerItem(0, 0, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout.addItem(self.horizontalSpacer)
self.btnVerde = QPushButton(self.header)
self.btnVerde.setObjectName(u"btnVerde")
self.btnVerde.setMaximumSize(QSize(16, 16))
self.btnVerde.setCursor(QCursor(Qt.PointingHandCursor))
self.btnVerde.setStyleSheet(u"QPushButton#btnVerde{\n"
" background-color: #27ae60;\n"
" border-radius: 8px;\n"
"}\n"
"\n"
"QPushButton#btnVerde:hover{\n"
" background-color: #10ac84;\n"
" border-radius: 8px;\n"
"}")
self.horizontalLayout.addWidget(self.btnVerde)
self.btnAmarillo = QPushButton(self.header)
self.btnAmarillo.setObjectName(u"btnAmarillo")
self.btnAmarillo.setMaximumSize(QSize(16, 16))
self.btnAmarillo.setCursor(QCursor(Qt.PointingHandCursor))
self.btnAmarillo.setStyleSheet(u"QPushButton#btnAmarillo{\n"
"background-color: yellow;\n"
"border-radius: 8px;\n"
"}\n"
"\n"
"QPushButton#btnAmarillo:hover{\n"
"background-color: #f1c40f;\n"
"border-radius: 8px;\n"
"}\n"
"")
self.horizontalLayout.addWidget(self.btnAmarillo)
self.btnRojo = QPushButton(self.header)
self.btnRojo.setObjectName(u"btnRojo")
self.btnRojo.setMaximumSize(QSize(16, 16))
self.btnRojo.setCursor(QCursor(Qt.PointingHandCursor))
self.btnRojo.setStyleSheet(u"QPushButton#btnRojo{\n"
"background-color: red;\n"
"border-radius: 8px;\n"
"}\n"
"\n"
"QPushButton#btnRojo:hover{\n"
"background-color: #e74c3c;\n"
"border-radius: 8px;\n"
"}")
self.horizontalLayout.addWidget(self.btnRojo)
self.gridLayout_5.addWidget(self.header, 0, 0, 1, 1)
self.frameLogo = QFrame(self.Contenedor)
self.frameLogo.setObjectName(u"frameLogo")
sizePolicy.setHeightForWidth(
self.frameLogo.sizePolicy().hasHeightForWidth())
self.frameLogo.setSizePolicy(sizePolicy)
self.frameLogo.setStyleSheet(u"")
self.frameLogo.setFrameShape(QFrame.StyledPanel)
self.frameLogo.setFrameShadow(QFrame.Raised)
self.gridLayout_3 = QGridLayout(self.frameLogo)
self.gridLayout_3.setObjectName(u"gridLayout_3")
self.lblWhatsPy = QLabel(self.frameLogo)
self.lblWhatsPy.setObjectName(u"lblWhatsPy")
font = QFont()
font.setFamily(u"century gothic")
font.setBold(True)
font.setWeight(75)
self.lblWhatsPy.setFont(font)
self.lblWhatsPy.setAlignment(Qt.AlignCenter)
self.gridLayout_3.addWidget(self.lblWhatsPy, 1, 0, 1, 1)
self.icon = QLabel(self.frameLogo)
self.icon.setObjectName(u"icon")
self.icon.setMaximumSize(QSize(70, 70))
self.icon.setPixmap(QPixmap(u":/logo/logo.png"))
self.icon.setScaledContents(True)
self.gridLayout_3.addWidget(self.icon, 0, 0, 1, 1)
self.gridLayout_5.addWidget(self.frameLogo, 1, 0, 1, 1)
self.label = QLabel(self.Contenedor)
self.label.setObjectName(u"label")
sizePolicy.setHeightForWidth(
self.label.sizePolicy().hasHeightForWidth())
self.label.setSizePolicy(sizePolicy)
self.label.setFont(font)
self.label.setAlignment(Qt.AlignCenter)
self.gridLayout_5.addWidget(self.label, 4, 0, 1, 1)
self.gridLayout_2.addWidget(self.Contenedor, 0, 0, 1, 1)
self.lblGrip = QLabel(self.VentanaFrame)
self.lblGrip.setObjectName(u"lblGrip")
sizePolicy.setHeightForWidth(
self.lblGrip.sizePolicy().hasHeightForWidth())
self.lblGrip.setSizePolicy(sizePolicy)
self.lblGrip.setMaximumSize(QSize(10, 10))
self.lblGrip.setCursor(QCursor(Qt.BusyCursor))
self.lblGrip.setLayoutDirection(Qt.RightToLeft)
self.lblGrip.setStyleSheet(
u"QLabel#lblGrip:hover{\n"
" background: rgb(18, 140, 126);\n"
" border-radius: 5px;\n"
"}\n"
"\n"
"QLabel#lblGrip{\n"
" background-color: qlineargradient(spread:pad, x1:0.953, y1:1, x2:1, y2:0, stop:0 #075E54, stop:1 #128C7E);\n"
" border-radius: 5px;\n"
"}")
self.gridLayout_2.addWidget(self.lblGrip, 1, 0, 1, 1)
self.gridLayout.addWidget(self.VentanaFrame, 0, 0, 1, 1)
self.retranslateUi(Ventana)
QMetaObject.connectSlotsByName(Ventana)
# setupUi
def retranslateUi(self, Ventana):
Ventana.setWindowTitle(
QCoreApplication.translate("Ventana", u"Form", None))
self.btnExportar.setText(
QCoreApplication.translate("Ventana", u"Exportar", None))
self.btnAbrir.setText(
QCoreApplication.translate("Ventana", u"Abrir TXT", None))
___qtablewidgetitem = self.tableWidget.horizontalHeaderItem(0)
___qtablewidgetitem.setText(
QCoreApplication.translate("Ventana", u"N\u00fameros", None))
___qtablewidgetitem1 = self.tableWidget.horizontalHeaderItem(1)
___qtablewidgetitem1.setText(
QCoreApplication.translate("Ventana", u"Mensajes", None))
__sortingEnabled = self.tableWidget.isSortingEnabled()
self.tableWidget.setSortingEnabled(False)
self.tableWidget.setSortingEnabled(__sortingEnabled)
self.btnVerde.setText("")
self.btnAmarillo.setText("")
self.btnRojo.setText("")
self.lblWhatsPy.setText(
QCoreApplication.translate("Ventana", u"WhatsPy", None))
self.icon.setText("")
self.label.setText(
QCoreApplication.translate(
"Ventana", u"Todav\u00eda no haz cargado ning\u00fan chat",
None))
self.lblGrip.setText("")
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
if not MainWindow.objectName():
MainWindow.setObjectName(u"MainWindow")
MainWindow.resize(787, 415)
self.centralwidget = QWidget(MainWindow)
self.centralwidget.setObjectName(u"centralwidget")
self.verticalLayout = QVBoxLayout(self.centralwidget)
self.verticalLayout.setSpacing(0)
self.verticalLayout.setObjectName(u"verticalLayout")
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.base = QFrame(self.centralwidget)
self.base.setObjectName(u"base")
self.base.setStyleSheet(u"QFrame{\n"
"\n"
" \n"
" background-color: rgb(97, 101, 157);\n"
"}")
self.base.setFrameShape(QFrame.StyledPanel)
self.base.setFrameShadow(QFrame.Raised)
self.horizontalLayout = QHBoxLayout(self.base)
self.horizontalLayout.setSpacing(0)
self.horizontalLayout.setObjectName(u"horizontalLayout")
self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
self.frame_for_widgets = QFrame(self.base)
self.frame_for_widgets.setObjectName(u"frame_for_widgets")
self.frame_for_widgets.setStyleSheet(
u"QFrame{\n"
"\n"
"border-radius:25px;\n"
"\n"
"\n"
"\n"
"background-color: rgb(24, 25, 39);\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"}")
self.frame_for_widgets.setFrameShape(QFrame.NoFrame)
self.frame_for_widgets.setFrameShadow(QFrame.Raised)
self.verticalLayout_4 = QVBoxLayout(self.frame_for_widgets)
self.verticalLayout_4.setSpacing(0)
self.verticalLayout_4.setObjectName(u"verticalLayout_4")
self.verticalLayout_4.setContentsMargins(0, 0, 0, 0)
self.frame = QFrame(self.frame_for_widgets)
self.frame.setObjectName(u"frame")
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.frame.sizePolicy().hasHeightForWidth())
self.frame.setSizePolicy(sizePolicy)
self.frame.setFrameShape(QFrame.StyledPanel)
self.frame.setFrameShadow(QFrame.Raised)
self.horizontalLayout_2 = QHBoxLayout(self.frame)
self.horizontalLayout_2.setObjectName(u"horizontalLayout_2")
self.select_zip_button = QPushButton(self.frame)
self.select_zip_button.setObjectName(u"select_zip_button")
self.select_zip_button.setMinimumSize(QSize(75, 75))
self.select_zip_button.setMaximumSize(QSize(75, 75))
font = QFont()
font.setFamily(u"Segoe UI Light")
font.setPointSize(24)
self.select_zip_button.setFont(font)
self.select_zip_button.setStyleSheet(
u"QPushButton{\n"
" color:rgb(30, 149, 198);\n"
" border: 2px solid black;\n"
"\n"
" border-color:rgb(240, 123, 255);\n"
" \n"
" background-color: rgb(42, 44, 68);\n"
" \n"
" border-radius:10px;\n"
"}\n"
"QPushButton:hover{\n"
"\n"
"\n"
"border-color:rgb(255, 37, 255);\n"
"\n"
"\n"
"}")
self.horizontalLayout_2.addWidget(self.select_zip_button)
self.horizontalSpacer = QSpacerItem(331, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout_2.addItem(self.horizontalSpacer)
self.verticalLayout_4.addWidget(self.frame)
self.frame_left_middle = QFrame(self.frame_for_widgets)
self.frame_left_middle.setObjectName(u"frame_left_middle")
self.frame_left_middle.setFrameShape(QFrame.StyledPanel)
self.frame_left_middle.setFrameShadow(QFrame.Raised)
self.verticalLayout_5 = QVBoxLayout(self.frame_left_middle)
self.verticalLayout_5.setSpacing(0)
self.verticalLayout_5.setObjectName(u"verticalLayout_5")
self.verticalLayout_5.setContentsMargins(0, 0, 0, 0)
self.frame_left_middle_up = QFrame(self.frame_left_middle)
self.frame_left_middle_up.setObjectName(u"frame_left_middle_up")
self.frame_left_middle_up.setFrameShape(QFrame.StyledPanel)
self.frame_left_middle_up.setFrameShadow(QFrame.Raised)
self.horizontalLayout_4 = QHBoxLayout(self.frame_left_middle_up)
self.horizontalLayout_4.setObjectName(u"horizontalLayout_4")
self.horizontalLayout_3 = QHBoxLayout()
self.horizontalLayout_3.setObjectName(u"horizontalLayout_3")
self.label = QLabel(self.frame_left_middle_up)
self.label.setObjectName(u"label")
font1 = QFont()
font1.setFamily(u"Arial Rounded MT Bold")
font1.setPointSize(11)
self.label.setFont(font1)
self.label.setStyleSheet(u"QLabel{\n"
" color:rgb(30, 149, 198);\n"
"\n"
" \n"
"\n"
" }")
self.label.setAlignment(Qt.AlignCenter)
self.horizontalLayout_3.addWidget(self.label)
self.lineEdit = QLineEdit(self.frame_left_middle_up)
self.lineEdit.setObjectName(u"lineEdit")
self.lineEdit.setStyleSheet(u"QLineEdit{\n"
"color:rgb(30, 149, 198);\n"
" background-color: rgb(65, 69, 106);\n"
"\n"
"border:2px solid black;\n"
"\n"
"border-radius:3px;\n"
"border-color:rgb(240, 123, 255);\n"
"\n"
"}")
self.horizontalLayout_3.addWidget(self.lineEdit)
self.same_as_zip_name_checkbox = QCheckBox(self.frame_left_middle_up)
self.same_as_zip_name_checkbox.setObjectName(
u"same_as_zip_name_checkbox")
font2 = QFont()
font2.setFamily(u"Arial Rounded MT Bold")
font2.setPointSize(10)
self.same_as_zip_name_checkbox.setFont(font2)
self.same_as_zip_name_checkbox.setStyleSheet(
u"QCheckBox{\n"
"color:rgb(30, 149, 198);\n"
"\n"
"}\n"
"QCheckBox:unchecked {\n"
" \n"
" color:rgb(30, 149, 198);\n"
"}\n"
"QCheckBox::indicator {\n"
" width: 13px;\n"
" height: 13px;\n"
" \n"
" color: rgb(30, 149, 198);\n"
" background-color: rgb(42, 44, 68);\n"
"}\n"
"QCheckBox::indicator:checked {\n"
" \n"
" \n"
" background-color: rgb(192, 98, 204);\n"
"}\n"
"QCheckBox:checked {\n"
"\n"
"color: rgb(38, 194, 255);\n"
" \n"
"}\n"
"\n"
"QCheckBox::indicator:checked {\n"
"color: rgb(253, 111, 54);\n"
" \n"
"}\n"
"")
self.horizontalLayout_3.addWidget(self.same_as_zip_name_checkbox)
self.horizontalLayout_4.addLayout(self.horizontalLayout_3)
self.horizontalSpacer_2 = QSpacerItem(85, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout_4.addItem(self.horizontalSpacer_2)
self.verticalLayout_5.addWidget(self.frame_left_middle_up)
self.frame_3 = QFrame(self.frame_left_middle)
self.frame_3.setObjectName(u"frame_3")
self.frame_3.setFrameShape(QFrame.StyledPanel)
self.frame_3.setFrameShadow(QFrame.Raised)
self.horizontalLayout_6 = QHBoxLayout(self.frame_3)
self.horizontalLayout_6.setObjectName(u"horizontalLayout_6")
self.horizontalLayout_5 = QHBoxLayout()
self.horizontalLayout_5.setObjectName(u"horizontalLayout_5")
self.label_2 = QLabel(self.frame_3)
self.label_2.setObjectName(u"label_2")
self.label_2.setMinimumSize(QSize(100, 0))
font3 = QFont()
font3.setFamily(u"Segoe UI")
font3.setPointSize(12)
self.label_2.setFont(font3)
self.label_2.setStyleSheet(u"QLabel{\n"
"\n"
" \n"
" \n"
" color:rgb(30, 149, 198);\n"
"\n"
" \n"
"\n"
" }")
self.label_2.setAlignment(Qt.AlignCenter)
self.horizontalLayout_5.addWidget(self.label_2)
self.algorithm_combobox = QComboBox(self.frame_3)
self.algorithm_combobox.addItem("")
self.algorithm_combobox.addItem("")
self.algorithm_combobox.addItem("")
self.algorithm_combobox.addItem("")
self.algorithm_combobox.setObjectName(u"algorithm_combobox")
self.algorithm_combobox.setMinimumSize(QSize(150, 0))
font4 = QFont()
font4.setFamily(u"Segoe UI")
font4.setPointSize(10)
font4.setBold(True)
font4.setWeight(75)
self.algorithm_combobox.setFont(font4)
self.algorithm_combobox.setStyleSheet(
u"QComboBox{\n"
"\n"
" \n"
" color:rgb(30, 149, 198);\n"
"\n"
" border:2px solid black;\n"
" border-color:rgb(240, 123, 255);\n"
" background-color: rgb(42, 44, 68);\n"
" \n"
"\n"
"}\n"
"QComboBox::down-arrow {\n"
" border:1px solid black;\n"
"border-color:rgb(30, 149, 198);\n"
"}\n"
"\n"
"ComboBox::drop-down {\n"
" \n"
" color: rgb(30, 149, 198);\n"
" background-color: rgb(56, 58, 91);\n"
"}\n"
"\n"
"\n"
"QComboBox::down-arrow:on { /* shift the arrow when popup is open */\n"
" top: 1px;\n"
" left: 1px;\n"
"}\n"
"")
self.horizontalLayout_5.addWidget(self.algorithm_combobox)
self.horizontalLayout_6.addLayout(self.horizontalLayout_5)
self.horizontalSpacer_3 = QSpacerItem(146, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout_6.addItem(self.horizontalSpacer_3)
self.verticalLayout_5.addWidget(self.frame_3)
self.verticalLayout_4.addWidget(self.frame_left_middle)
self.frame_left_bottom = QFrame(self.frame_for_widgets)
self.frame_left_bottom.setObjectName(u"frame_left_bottom")
self.frame_left_bottom.setFrameShape(QFrame.StyledPanel)
self.frame_left_bottom.setFrameShadow(QFrame.Raised)
self.verticalLayout_6 = QVBoxLayout(self.frame_left_bottom)
self.verticalLayout_6.setSpacing(0)
self.verticalLayout_6.setObjectName(u"verticalLayout_6")
self.verticalLayout_6.setContentsMargins(0, 0, 0, 0)
self.frame_for_start_button = QFrame(self.frame_left_bottom)
self.frame_for_start_button.setObjectName(u"frame_for_start_button")
self.frame_for_start_button.setFrameShape(QFrame.StyledPanel)
self.frame_for_start_button.setFrameShadow(QFrame.Raised)
self.horizontalLayout_8 = QHBoxLayout(self.frame_for_start_button)
self.horizontalLayout_8.setObjectName(u"horizontalLayout_8")
self.horizontalLayout_7 = QHBoxLayout()
self.horizontalLayout_7.setObjectName(u"horizontalLayout_7")
self.label_3 = QLabel(self.frame_for_start_button)
self.label_3.setObjectName(u"label_3")
self.label_3.setMinimumSize(QSize(100, 0))
self.label_3.setFont(font2)
self.label_3.setStyleSheet(u"QLabel{\n"
"\n"
" \n"
" color:rgb(30, 149, 198);\n"
"\n"
" \n"
"\n"
" }")
self.label_3.setAlignment(Qt.AlignCenter)
self.horizontalLayout_7.addWidget(self.label_3)
self.toolButton = QToolButton(self.frame_for_start_button)
self.toolButton.setObjectName(u"toolButton")
self.toolButton.setStyleSheet(u"QToolButton{\n"
" color:rgb(30, 149, 198);\n"
" border: 2px solid black;\n"
"\n"
" border-color:rgb(240, 123, 255);\n"
" \n"
" background-color: rgb(42, 44, 68);\n"
" \n"
" border-radius:1px;\n"
"}\n"
"QToolButton:hover{\n"
"\n"
"\n"
"border-color:rgb(255, 37, 255);\n"
"\n"
"\n"
"}")
self.horizontalLayout_7.addWidget(self.toolButton)
self.horizontalLayout_8.addLayout(self.horizontalLayout_7)
self.horizontalSpacer_4 = QSpacerItem(190, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout_8.addItem(self.horizontalSpacer_4)
self.start_button = QPushButton(self.frame_for_start_button)
self.start_button.setObjectName(u"start_button")
self.start_button.setMinimumSize(QSize(75, 75))
font5 = QFont()
font5.setFamily(u"Segoe UI Light")
font5.setPointSize(28)
self.start_button.setFont(font5)
self.start_button.setStyleSheet(u"QPushButton{\n"
" color:rgb(30, 149, 198);\n"
" border: 2px solid black;\n"
"\n"
" border-color:rgb(240, 123, 255);\n"
" \n"
" background-color: rgb(42, 44, 68);\n"
" \n"
" border-radius:10px;\n"
"}\n"
"QPushButton:hover{\n"
"\n"
"\n"
"border-color:rgb(255, 37, 255);\n"
"\n"
"\n"
"}")
self.horizontalLayout_8.addWidget(self.start_button)
self.verticalLayout_6.addWidget(self.frame_for_start_button)
self.frame_for_progressbar = QFrame(self.frame_left_bottom)
self.frame_for_progressbar.setObjectName(u"frame_for_progressbar")
self.frame_for_progressbar.setFrameShape(QFrame.StyledPanel)
self.frame_for_progressbar.setFrameShadow(QFrame.Raised)
self.horizontalLayout_10 = QHBoxLayout(self.frame_for_progressbar)
self.horizontalLayout_10.setObjectName(u"horizontalLayout_10")
self.horizontalSpacer_5 = QSpacerItem(13, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout_10.addItem(self.horizontalSpacer_5)
self.horizontalLayout_9 = QHBoxLayout()
self.horizontalLayout_9.setObjectName(u"horizontalLayout_9")
self.label_progress = QLabel(self.frame_for_progressbar)
self.label_progress.setObjectName(u"label_progress")
self.label_progress.setFont(font2)
self.label_progress.setStyleSheet(u"QLabel{\n"
"\n"
" color:rgb(30, 149, 198);\n"
" \n"
"\n"
" }")
self.label_progress.setAlignment(Qt.AlignCenter)
self.horizontalLayout_9.addWidget(self.label_progress)
self.progressBar = QProgressBar(self.frame_for_progressbar)
self.progressBar.setObjectName(u"progressBar")
self.progressBar.setMinimumSize(QSize(350, 20))
self.progressBar.setMaximumSize(QSize(450, 20))
font6 = QFont()
font6.setFamily(u"Segoe UI")
font6.setPointSize(9)
self.progressBar.setFont(font6)
self.progressBar.setStyleSheet(u"QProgressBar{\n"
"\n"
" \n"
" color:rgb(30, 149, 198);\n"
"\n"
" border: 1px solid black;\n"
"\n"
" border-color:rgb(240, 123, 255);\n"
" \n"
" background-color: rgb(42, 44, 68);\n"
" \n"
" border-radius:2px;\n"
"}\n"
"QProgressBar::chunk{\n"
"\n"
"border-radius:2px;\n"
"\n"
" background-color:rgb(30, 149, 198);\n"
"}\n"
"QProgressBar:hover{\n"
"border-color:rgb(255, 37, 255);\n"
"}")
self.progressBar.setMaximum(100)
self.progressBar.setValue(56)
self.progressBar.setAlignment(Qt.AlignRight | Qt.AlignTrailing
| Qt.AlignVCenter)
self.progressBar.setTextVisible(True)
self.progressBar.setInvertedAppearance(False)
self.horizontalLayout_9.addWidget(self.progressBar)
self.horizontalLayout_10.addLayout(self.horizontalLayout_9)
self.verticalLayout_6.addWidget(self.frame_for_progressbar)
self.verticalLayout_4.addWidget(self.frame_left_bottom)
self.horizontalLayout.addWidget(self.frame_for_widgets)
self.frame_for_textedit = QFrame(self.base)
self.frame_for_textedit.setObjectName(u"frame_for_textedit")
sizePolicy1 = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred)
sizePolicy1.setHorizontalStretch(0)
sizePolicy1.setVerticalStretch(0)
sizePolicy1.setHeightForWidth(
self.frame_for_textedit.sizePolicy().hasHeightForWidth())
self.frame_for_textedit.setSizePolicy(sizePolicy1)
self.frame_for_textedit.setMinimumSize(QSize(30, 0))
self.frame_for_textedit.setMaximumSize(QSize(350, 16777215))
self.frame_for_textedit.setFrameShape(QFrame.StyledPanel)
self.frame_for_textedit.setFrameShadow(QFrame.Raised)
self.verticalLayout_2 = QVBoxLayout(self.frame_for_textedit)
self.verticalLayout_2.setSpacing(0)
self.verticalLayout_2.setObjectName(u"verticalLayout_2")
self.verticalLayout_2.setContentsMargins(-1, 0, 0, 0)
self.terminal_output = QTextEdit(self.frame_for_textedit)
self.terminal_output.setObjectName(u"terminal_output")
self.terminal_output.setFont(font2)
self.terminal_output.setStyleSheet(
u"\n"
"QTextEdit, QListView {\n"
" color:rgb(255, 37, 255);\n"
" background-color:rgb(40, 41, 65);\n"
" border:3px solid black;\n"
" border-radius:10px;\n"
" border-color:rgb(30, 149, 198);\n"
" background-attachment: scroll;\n"
"}")
self.verticalLayout_2.addWidget(self.terminal_output)
self.horizontalLayout.addWidget(self.frame_for_textedit)
self.verticalLayout.addWidget(self.base)
MainWindow.setCentralWidget(self.centralwidget)
self.retranslateUi(MainWindow)
QMetaObject.connectSlotsByName(MainWindow)
# setupUi
def retranslateUi(self, MainWindow):
MainWindow.setWindowTitle(
QCoreApplication.translate("MainWindow", u"MainWindow", None))
self.select_zip_button.setText(
QCoreApplication.translate("MainWindow", u"Zip", None))
self.label.setText(
QCoreApplication.translate("MainWindow", u"Video Name :", None))
self.same_as_zip_name_checkbox.setText(
QCoreApplication.translate("MainWindow", u"Same as Zip name",
None))
self.label_2.setText(
QCoreApplication.translate("MainWindow", u"Algorithm", None))
self.algorithm_combobox.setItemText(
0, QCoreApplication.translate("MainWindow", u"Select", None))
self.algorithm_combobox.setItemText(
1,
QCoreApplication.translate("MainWindow", u"Very Fast - Good",
None))
self.algorithm_combobox.setItemText(
2, QCoreApplication.translate("MainWindow", u"Fast - Better",
None))
self.algorithm_combobox.setItemText(
3, QCoreApplication.translate("MainWindow", u"Slow - Best", None))
self.label_3.setText(
QCoreApplication.translate("MainWindow", u"Video Location", None))
self.toolButton.setText(
QCoreApplication.translate("MainWindow", u"...", None))
self.start_button.setText(
QCoreApplication.translate("MainWindow", u"Start", None))
self.label_progress.setText(
QCoreApplication.translate("MainWindow", u"Progress :", None))
self.terminal_output.setHtml(
QCoreApplication.translate(
"MainWindow",
u"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">\n"
"<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\">\n"
"p, li { white-space: pre-wrap; }\n"
"</style></head><body style=\" font-family:'Arial Rounded MT Bold'; font-size:10pt; font-weight:400; font-style:normal;\">\n"
"<p style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-family:'Segoe UI Light'; color:#f07bff;\">Zipvy Ready...</span></p></body></html>",
None))
