def createSequencerControls(self):
widget = QWidget()
layout = QVBoxLayout()
layout.addWidget(self.createSequencerSections(1))
layout.addWidget(self.createSequencerSections(2))
layout.addWidget(self.createRhythmSection())
hbox = Qtw.QHBoxLayout()
hbox.setContentsMargins(0, 0, 0, 0)
hbox.addWidget(self.createTransportSection())
hbox.addWidget(self.createEnvSection())
hbox.setStretch(0, 1)
hbox.setStretch(1, 1)
layout.addLayout(hbox)
layout.setContentsMargins(0, 0, 0, 0)
widget.setContentsMargins(0, 0, 0, 0)
layout.setStretch(0, 2)
layout.setStretch(1, 2)
layout.setStretch(2, 4)
layout.setStretch(3, 2)
widget.setLayout(layout)
return widget
def createBottomControls(self):
widget = QWidget()
layout = QHBoxLayout()
layout.addWidget(self.createGeneralSection())
layout.addWidget(self.createFilterSection())
layout.setContentsMargins(0, 0, 0, 0)
widget.setContentsMargins(0, 0, 0, 0)
widget.setLayout(layout)
return widget
def createMainSection(self):
widget = QWidget()
layout = QVBoxLayout()
layout.addWidget(self.createTopControls())
layout.addWidget(self.createBottomControls())
layout.setStretch(0, 5)
layout.setStretch(1, 1)
widget.setLayout(layout)
layout.setContentsMargins(0, 0, 0, 0)
widget.setContentsMargins(0, 0, 0, 0)
return widget
def createTopControls(self):
widget = QWidget()
layout = QHBoxLayout()
layout.addWidget(self.createSequencerControls())
layout.addStretch(1)
layout.addWidget(self.createVcoSection())
layout.setContentsMargins(0, 0, 0, 0)
layout.setStretch(0, 8)
layout.setStretch(2, 8)
widget.setContentsMargins(0, 0, 0, 0)
widget.setLayout(layout)
return widget
class UIBuilder(object):
"""Constructs the UI for a main application window"""
def setup(self, main_window: QMainWindow) -> None:
"""
Initialize the UI.
:param main_window: An instance of the `QMainWindow` class.
:type main_window: :class:`QMainWindow`
"""
main_window.setObjectName("main_window")
main_window.setWindowTitle("TeaseAI")
main_window.resize(1137, 751)
main_window.setSizePolicy(*EXP_EXP)
main_window.setTabShape(QTabWidget.Rounded)
self.menubar = QMenuBar(main_window)
self.menubar.setObjectName("menubar")
self.menubar.setGeometry(0, 0, 1137, 23)
self.file_menu = QMenu("File", self.menubar)
self.file_menu.setObjectName("file_men")
self.server_menu = QMenu("Server", self.menubar)
self.server_menu.setObjectName("server_men")
self.options_menu = QMenu("Options", self.menubar)
self.options_menu.setObjectName("options_men")
self.media_menu = QMenu("Media", self.menubar)
self.media_menu.setObjectName("media_men")
main_window.setMenuBar(self.menubar)
self.exit = QAction("Exit", main_window)
self.exit.setObjectName("exit")
self.start_server = QAction("Start Server", main_window)
self.start_server.setObjectName("start_server")
self.connect_server = QAction("Connect to Server", main_window)
self.connect_server.setObjectName("connect_server")
self.kill_server = QAction("Kill Server", main_window)
self.kill_server.setObjectName("kill_server")
self.options = QAction("Options", main_window)
self.options.setObjectName("options")
self.start_webcam = QAction("Start Webcam", main_window)
self.start_webcam.setObjectName("start_webcam")
self.start_webcam.setCheckable(False)
self.centralwidget = QWidget(main_window)
self.centralwidget.setObjectName("centralwidget")
self.centralwidget.setContentsMargins(QMargins(0, 0, 0, 0))
self.centralwidget.setSizePolicy(*EXP_EXP)
self.grid_layout = QGridLayout(self.centralwidget)
self.media = QFrame(self.centralwidget)
self.media.setObjectName("media")
self.media.setSizePolicy(*EXP_EXP)
self.media.setMinimumSize(200, 200)
self.media.setStyleSheet("background: #000;")
self.grid_layout.addWidget(self.media, 0, 0, 5, 1)
self.users_label = QLabel(" Online users:", self.centralwidget)
self.users_label.setObjectName("users_label")
self.users_label.setMinimumSize(300, 15)
self.users_label.setMaximumSize(300, 15)
self.grid_layout.addWidget(self.users_label, 0, 1, 1, 2)
self.online = QPlainTextEdit("", self.centralwidget)
self.online.setObjectName("online")
self.online.setSizePolicy(*FIX_FIX)
self.online.setMinimumSize(300, 50)
self.online.setMaximumSize(300, 50)
self.online.setStyleSheet("margin-left: 3px;" + SUNKEN)
self.online.setLineWidth(2)
self.online.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.online.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.online.setSizeAdjustPolicy(QAbstractScrollArea.AdjustIgnored)
self.online.setReadOnly(True)
self.grid_layout.addWidget(self.online, 1, 1, 1, 2)
self.chat = QPlainTextEdit("", self.centralwidget)
self.chat.setObjectName("chat")
self.chat.setSizePolicy(*FIX_EXP)
self.chat.setMinimumSize(300, 0)
self.chat.setMaximumSize(300, INFINITE)
self.chat.setStyleSheet("margin-bottom: 3px; margin-top: 8px;" +
SUNKEN)
self.chat.setLineWidth(2)
self.chat.setReadOnly(True)
self.chat.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.grid_layout.addWidget(self.chat, 2, 1, 1, 2)
self.input = QLineEdit(self.centralwidget)
self.input.setObjectName("input")
self.input.setSizePolicy(*FIX_FIX)
self.input.setMinimumSize(224, 30)
self.input.setMaximumSize(224, 30)
self.input.setStyleSheet(SUNKEN)
self.input.setEchoMode(QLineEdit.Normal)
self.input.setClearButtonEnabled(True)
self.grid_layout.addWidget(self.input, 3, 1, 1, 1)
self.submit = QPushButton("Submit", self.centralwidget)
self.submit.setObjectName("submit")
self.submit.setSizePolicy(*FIX_FIX)
self.submit.setMinimumSize(70, 30)
self.submit.setMaximumSize(70, 30)
self.grid_layout.addWidget(self.submit, 3, 2, 1, 1)
self.tabs = QTabWidget(self.centralwidget)
self.tabs.setObjectName("tabs")
self.tabs.setSizePolicy(*FIX_FIX)
self.tabs.setMinimumSize(300, 150)
self.tabs.setMaximumSize(300, 150)
self.tab = QWidget()
self.tab.setObjectName("tab")
self.tabs.addTab(self.tab, "Actions")
self.tab2 = QWidget()
self.tab2.setObjectName("tab2")
self.tabs.addTab(self.tab2, "My Media")
self.tab3 = QWidget()
self.tab3.setObjectName("tab3")
self.tab3.setSizePolicy(*FIX_FIX)
self.grid_layout2 = QGridLayout(self.tab3)
self.grid_layout2.setHorizontalSpacing(0)
self.grid_layout2.setVerticalSpacing(3)
self.grid_layout2.setContentsMargins(3, -1, 3, -1)
self.server_folder = QLineEdit(self.tab3)
self.server_folder.setObjectName("server_folder")
self.grid_layout2.addWidget(self.server_folder, 0, 0, 1, 3)
self.srv_browse = QPushButton("BROWSE", self.tab3)
self.srv_browse.setObjectName("srv_browse")
self.srv_browse.setStyleSheet("background: transparent;\n"
" color: #4d4940;\n"
" font-size: 8pt;\n"
" font-weight: 450;\n"
" padding: 6px;\n")
self.grid_layout2.addWidget(self.srv_browse, 0, 3, 1, 1)
self.back_button = QPushButton("", self.tab3)
self.back_button.setObjectName("back_button")
self.back_button.setSizePolicy(*FIX_FIX)
self.back_button.setMaximumSize(SEVENTY_FIVE)
self.back_button.setCursor(QCursor(Qt.PointingHandCursor))
self.back_button.setStyleSheet("border: 0;\n"
"background: transparent;")
icon = QIcon()
icon.addFile(":/newPrefix/back_button.png", SIXTY_FOUR, QIcon.Normal,
QIcon.Off)
self.back_button.setIcon(icon)
self.back_button.setIconSize(SIXTY_FOUR)
self.grid_layout2.addWidget(self.back_button, 1, 0, 1, 1)
self.play_button = QPushButton("", self.tab3)
self.play_button.setObjectName("play_button")
self.play_button.setSizePolicy(*FIX_FIX)
self.play_button.setMaximumSize(SEVENTY_FIVE)
self.play_button.setCursor(QCursor(Qt.PointingHandCursor))
self.play_button.setStyleSheet("border: 0;\n"
"background: transparent;")
icon1 = QIcon()
icon1.addFile(":/newPrefix/play_button.png", SIXTY_FOUR, QIcon.Normal,
QIcon.Off)
self.play_button.setIcon(icon1)
self.play_button.setIconSize(SIXTY_FOUR)
self.grid_layout2.addWidget(self.play_button, 1, 1, 1, 1)
self.stop_button = QPushButton("", self.tab3)
self.stop_button.setObjectName("stop_button")
self.stop_button.setSizePolicy(*FIX_FIX)
self.stop_button.setMaximumSize(SEVENTY_FIVE)
self.stop_button.setCursor(QCursor(Qt.PointingHandCursor))
self.stop_button.setStyleSheet("border: 0;\n"
"background: transparent;")
icon2 = QIcon()
icon2.addFile(":/newPrefix/stop_button.png", SIXTY_FOUR, QIcon.Normal,
QIcon.Off)
self.stop_button.setIcon(icon2)
self.stop_button.setIconSize(SIXTY_FOUR)
self.grid_layout2.addWidget(self.stop_button, 1, 2, 1, 1)
self.fast_forward = QPushButton("", self.tab3)
self.fast_forward.setObjectName("fast_forward")
self.fast_forward.setSizePolicy(*FIX_FIX)
self.fast_forward.setMaximumSize(SEVENTY_FIVE)
self.fast_forward.setCursor(QCursor(Qt.PointingHandCursor))
self.fast_forward.setStyleSheet("border: 0;\n"
"background: transparent;")
icon3 = QIcon()
icon3.addFile(":/newPrefix/fast_forward.png", SIXTY_FOUR, QIcon.Normal,
QIcon.Off)
self.fast_forward.setIcon(icon3)
self.fast_forward.setIconSize(SIXTY_FOUR)
self.grid_layout2.addWidget(self.fast_forward, 1, 3, 1, 1)
self.tabs.addTab(self.tab3, "Server Media")
self.grid_layout.addWidget(self.tabs, 4, 1, 1, 2)
main_window.setCentralWidget(self.centralwidget)
self.statusbar = QStatusBar(main_window)
self.statusbar.setObjectName("statusbar")
self.statusbar.setEnabled(True)
self.statusbar.setStyleSheet("margin-bottom: 5px;")
self.statusbar.setSizePolicy(*EXP_FIX)
self.statusbar.setMinimumSize(INFINITE, 30)
self.statusbar.setMaximumSize(INFINITE, 30)
self.statusbar.setSizeGripEnabled(False)
main_window.setStatusBar(self.statusbar)
self.menubar.addAction(self.file_menu.menuAction())
self.menubar.addAction(self.server_menu.menuAction())
self.menubar.addAction(self.options_menu.menuAction())
self.menubar.addAction(self.media_menu.menuAction())
self.file_menu.addAction(self.exit)
self.server_menu.addAction(self.start_server)
self.server_menu.addAction(self.connect_server)
self.server_menu.addAction(self.kill_server)
self.options_menu.addAction(self.options)
self.media_menu.addAction(self.start_webcam)
self.exit.triggered.connect(main_window.close)
self.tabs.setCurrentIndex(0)
QMetaObject.connectSlotsByName(main_window)
self.exit.setStatusTip("Exit the program.")
self.start_server.setStatusTip("Initialize a local server instance.")
self.connect_server.setStatusTip("Connect to a remote server.")
self.kill_server.setStatusTip("Shut down a running local server.")
self.options.setStatusTip("Open the options menu.")
self.start_webcam.setStatusTip("Start webcam feed.")
self.tooltip = QLabel("", self.statusbar)
tooltip_policy = QSizePolicy(*EXP_FIX)
tooltip_policy.setHorizontalStretch(100)
self.tooltip.setSizePolicy(tooltip_policy)
self.tooltip.setMinimumSize(INFINITE, 26)
self.tooltip.setMaximumSize(INFINITE, 26)
self.server_status = QLabel("Server status:", self.statusbar)
self.server_status.setSizePolicy(*FIX_FIX)
self.server_status.setMinimumSize(300, 26)
self.server_status.setMaximumSize(300, 26)
self.client_status = QLabel("Client status:", self.statusbar)
self.client_status.setSizePolicy(*FIX_FIX)
self.client_status.setMinimumSize(302, 26)
self.client_status.setMaximumSize(302, 26)
self.statusbar.addPermanentWidget(self.tooltip)
self.statusbar.addPermanentWidget(self.server_status)
self.statusbar.addPermanentWidget(self.client_status)
self.tooltip.setStyleSheet(SUNKEN + "margin-left: 4px;\
margin-right: 0px;")
self.client_status.setStyleSheet(SUNKEN + "margin-right: 7px;")
self.server_status.setStyleSheet(SUNKEN + "margin-right: 2px;\
margin-left: 2px;")
self.statusbar.messageChanged.connect(main_window.status_tip)
class MainWindow(QMainWindow):
"""Main application window"""
def __init__(self) -> None:
QMainWindow.__init__(self)
self.setSizePolicy(
QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum))
self.setMaximumSize(QSize(1920, 1080))
self.setStyleSheet("padding: 0px; margin: 0px;")
self.setIconSize(QSize(32, 32))
self.setWindowTitle("BossyBot 2000 - Image Tagger")
self.setWindowIcon(self.load_icon(icon))
self.menubar = QMenuBar(self)
self.menubar.setSizePolicy(EXP_MAX)
self.menubar.setMaximumSize(QSize(INFINITE, 30))
self.menu_file = QMenu('File', self.menubar)
self.menu_options = QMenu('Options', self.menubar)
self.menu_help = QMenu('Help', self.menubar)
self.menubar.addAction(self.menu_file.menuAction())
self.menubar.addAction(self.menu_options.menuAction())
self.menubar.addAction(self.menu_help.menuAction())
self.open = QAction('Open', self)
self.menu_file.addAction(self.open)
self.open.triggered.connect(self.open_file)
self.exit_button = QAction('Exit', self)
self.exit_button.triggered.connect(lambda: sys.exit(0),
Qt.QueuedConnection)
self.menu_file.addAction(self.exit_button)
self.setMenuBar(self.menubar)
self.previous_button = QAction(self.load_icon(previous), '<<', self)
self.next_button = QAction(self.load_icon(next_icon), '>>', self)
self.rotate_left_button = QAction(self.load_icon(left), '', self)
self.rotate_right_button = QAction(self.load_icon(right), '', self)
self.play_button = QAction(self.load_icon(play), '', self)
self.play_button.setCheckable(True)
self.delete_button = QAction(self.load_icon(delete), '', self)
self.reload_button = QAction(self.load_icon(reload), '', self)
self.mirror_button = QAction('Mirror', self)
self.actual_size_button = QAction('Actual Size', self)
self.browser_button = QAction('Browser', self)
self.browser_button.setCheckable(True)
self.browser_button.setChecked(True)
self.crop_button = QAction('Crop', self)
self.crop_button.setCheckable(True)
self.toolbuttons = {
self.rotate_left_button: {
'shortcut':
',',
'connect':
lambda: self.pixmap.setRotation(self.pixmap.rotation() - 90)
},
self.rotate_right_button: {
'shortcut':
'.',
'connect':
lambda: self.pixmap.setRotation(self.pixmap.rotation() + 90)
},
self.delete_button: {
'shortcut': 'Del',
'connect': self.delete
},
self.previous_button: {
'shortcut': 'Left',
'connect': self.previous
},
self.play_button: {
'shortcut': 'Space',
'connect': self.play
},
self.next_button: {
'shortcut': 'Right',
'connect': self.next
},
self.reload_button: {
'shortcut': 'F5',
'connect': self.reload
}
}
self.toolbar = QToolBar(self)
self.toolbar.setSizePolicy(EXP_MAX)
self.toolbar.setMaximumSize(QSize(INFINITE, 27))
for _ in (self.browser_button, self.crop_button, self.mirror_button,
self.actual_size_button):
self.toolbar.addAction(_)
self.addToolBar(Qt.TopToolBarArea, self.toolbar)
for button in self.toolbuttons:
button.setShortcut(self.toolbuttons[button]['shortcut'])
button.triggered.connect(self.toolbuttons[button]['connect'])
self.toolbar.addAction(button)
self.centralwidget = QWidget(self)
self.centralwidget.setSizePolicy(EXP_EXP)
self.setCentralWidget(self.centralwidget)
self.grid = QGridLayout(self.centralwidget)
self.media = QGraphicsScene(self)
self.media.setItemIndexMethod(QGraphicsScene.NoIndex)
self.media.setBackgroundBrush(QBrush(Qt.black))
self.view = MyView(self.media, self)
self.view.setSizePolicy(EXP_EXP)
self.media.setSceneRect(0, 0, self.view.width(), self.view.height())
self.grid.addWidget(self.view, 0, 0, 1, 1)
self.frame = QFrame(self.centralwidget)
self.frame.setSizePolicy(
QSizePolicy(QSizePolicy.Fixed, QSizePolicy.MinimumExpanding))
self.frame.setMinimumSize(QSize(325, 500))
self.frame.setStyleSheet(
"QFrame { border: 4px inset #222; border-radius: 10; }")
self.layout_widget = QWidget(self.frame)
self.layout_widget.setGeometry(QRect(0, 400, 321, 91))
self.layout_widget.setContentsMargins(15, 15, 15, 15)
self.grid2 = QGridLayout(self.layout_widget)
self.grid2.setContentsMargins(0, 0, 0, 0)
self.save_button = QPushButton('Yes (Save)', self.layout_widget)
self.save_button.setSizePolicy(FIX_FIX)
self.save_button.setMaximumSize(QSize(120, 26))
self.save_button.setVisible(False)
self.grid2.addWidget(self.save_button, 1, 0, 1, 1)
self.no_save_button = QPushButton('No (Reload)', self.layout_widget)
self.no_save_button.setSizePolicy(FIX_FIX)
self.no_save_button.setMaximumSize(QSize(120, 26))
self.no_save_button.setVisible(False)
self.grid2.addWidget(self.no_save_button, 1, 1, 1, 1)
self.label = QLabel("Current image modified, save it?",
self.layout_widget)
self.label.setSizePolicy(FIX_FIX)
self.label.setMaximumSize(QSize(325, 60))
self.label.setVisible(False)
self.label.setAlignment(Qt.AlignCenter)
self.grid2.addWidget(self.label, 0, 0, 1, 2)
self.layout_widget = QWidget(self.frame)
self.layout_widget.setGeometry(QRect(0, 0, 321, 213))
self.ass = QRadioButton('Ass', self.layout_widget)
self.ass_exposed = QRadioButton('Ass (exposed)', self.layout_widget)
self.ass_reset = QRadioButton(self.frame)
self.ass_group = QButtonGroup(self)
self.breasts = QRadioButton('Breasts', self.layout_widget)
self.breasts_exposed = QRadioButton('Breasts (exposed)',
self.layout_widget)
self.breasts_reset = QRadioButton(self.frame)
self.breasts_group = QButtonGroup(self)
self.pussy = QRadioButton('Pussy', self.layout_widget)
self.pussy_exposed = QRadioButton('Pussy (exposed)',
self.layout_widget)
self.pussy_reset = QRadioButton(self.frame)
self.pussy_group = QButtonGroup(self)
self.fully_clothed = QRadioButton('Fully Clothed', self.layout_widget)
self.fully_nude = QRadioButton('Fully Nude', self.layout_widget)
self.nudity_reset = QRadioButton(self.frame)
self.nudity = QButtonGroup(self)
self.smiling = QRadioButton('Smiling', self.layout_widget)
self.glaring = QRadioButton('Glaring', self.layout_widget)
self.expression_reset = QRadioButton(self.frame)
self.expression = QButtonGroup(self)
self.grid3 = QGridLayout(self.layout_widget)
self.grid3.setVerticalSpacing(15)
self.grid3.setContentsMargins(0, 15, 0, 0)
self.radios = {
self.ass: {
'this': 'ass',
'that': 'ass_exposed',
'group': self.ass_group,
'reset': self.ass_reset,
'grid': (0, 0, 1, 1)
},
self.ass_exposed: {
'this': 'ass_exposed',
'that': 'ass',
'group': self.ass_group,
'reset': self.ass_reset,
'grid': (0, 1, 1, 1)
},
self.breasts: {
'this': 'breasts',
'that': 'breasts_exposed',
'group': self.breasts_group,
'reset': self.breasts_reset,
'grid': (1, 0, 1, 1)
},
self.breasts_exposed: {
'this': 'breasts_exposed',
'that': 'breasts',
'group': self.breasts_group,
'reset': self.breasts_reset,
'grid': (1, 1, 1, 1)
},
self.pussy: {
'this': 'pussy',
'that': 'pussy_exposed',
'group': self.pussy_group,
'reset': self.pussy_reset,
'grid': (2, 0, 1, 1)
},
self.pussy_exposed: {
'this': 'pussy_exposed',
'that': 'pussy',
'group': self.pussy_group,
'reset': self.pussy_reset,
'grid': (2, 1, 1, 1)
},
self.fully_clothed: {
'this': 'fully_clothed',
'that': 'fully_nude',
'group': self.nudity,
'reset': self.nudity_reset,
'grid': (3, 0, 1, 1)
},
self.fully_nude: {
'this': 'fully_nude',
'that': 'fully_clothed',
'group': self.nudity,
'reset': self.nudity_reset,
'grid': (3, 1, 1, 1)
},
self.smiling: {
'this': 'smiling',
'that': 'glaring',
'group': self.expression,
'reset': self.expression_reset,
'grid': (4, 0, 1, 1)
},
self.glaring: {
'this': 'glaring',
'that': 'smiling',
'group': self.expression,
'reset': self.expression_reset,
'grid': (4, 1, 1, 1)
},
}
for radio in self.radios:
radio.setSizePolicy(FIX_FIX)
radio.setMaximumSize(QSize(150, 22))
self.radios[radio]['reset'].setGeometry(QRect(0, 0, 0, 0))
self.grid3.addWidget(radio, *self.radios[radio]['grid'])
if self.radios[radio]['group'] != self.nudity:
radio.toggled.connect(
lambda x=_, y=radio: self.annotate(self.radios[y]['this']))
self.radios[radio]['group'].addButton(radio)
self.radios[radio]['group'].addButton(self.radios[radio]['reset'])
self.save_tags_button = QPushButton('Save Tags', self.layout_widget)
self.save_tags_button.setSizePolicy(FIX_FIX)
self.save_tags_button.setMaximumSize(QSize(120, 26))
self.grid3.addWidget(self.save_tags_button, 5, 1, 1, 1)
self.grid.addWidget(self.frame, 0, 1, 1, 1)
self.browse_bar = QLabel(self.centralwidget)
self.browse_bar.setSizePolicy(EXP_FIX)
self.browse_bar.setMinimumSize(QSize(0, 100))
self.browse_bar.setMaximumSize(QSize(INFINITE, 100))
self.browse_bar.setStyleSheet("background: #000;")
self.browse_bar.setAlignment(Qt.AlignCenter)
self.h_box2 = QHBoxLayout(self.browse_bar)
self.h_box2.setContentsMargins(4, 0, 0, 0)
self.grid.addWidget(self.browse_bar, 1, 0, 1, 2)
hiders = [
self.no_save_button.clicked, self.save_button.clicked,
self.reload_button.triggered
]
for hider in hiders:
hider.connect(self.save_button.hide)
hider.connect(self.no_save_button.hide)
hider.connect(self.label.hide)
showers = [
self.mirror_button.triggered, self.rotate_right_button.triggered,
self.rotate_left_button.triggered
]
for shower in showers:
shower.connect(self.save_button.show)
shower.connect(self.no_save_button.show)
shower.connect(self.label.show)
self.no_save_button.clicked.connect(self.reload)
self.browser_button.toggled.connect(self.browse_bar.setVisible)
self.play_button.toggled.connect(lambda: self.frame.setVisible(
(True, False)[self.frame.isVisible()]))
self.reload_button.triggered.connect(self.reload)
self.mirror_button.triggered.connect(lambda: self.pixmap.setScale(-1))
self.save_button.clicked.connect(self.save_image)
self.play_button.toggled.connect(
lambda: self.browser_button.setChecked(
(True, False)[self.browse_bar.isVisible()]))
self.crop_button.toggled.connect(self.view.reset)
self.actual_size_button.triggered.connect(self.actual_size)
self.browser_button.triggered.connect(self.browser)
self.save_tags_button.clicked.connect(self.save_tags)
self.view.got_rect.connect(self.set_rect)
self.crop_rect = QRect(QPoint(0, 0), QSize(0, 0))
self.dir_now = os.getcwd()
self.files = []
self.index = 0
self.refresh_files()
self.pixmap_is_scaled = False
self.pixmap = QGraphicsPixmapItem()
self.active_tag = ''
self.reset_browser = False
self.txt = PngInfo()
def set_rect(self, rect: tuple[QPointF, QPointF]):
"""Converts the crop rectangle to a QRect after a crop action"""
self.crop_rect = QRect(rect[0].toPoint(), rect[1].toPoint())
def keyPressEvent(self, event: QKeyEvent): # pylint: disable=invalid-name;
"""Keyboard event handler."""
if event.key() == Qt.Key_Escape and self.play_button.isChecked():
self.play_button.toggle()
self.browser_button.setChecked((True, False)[self.reset_browser])
elif (event.key() in [16777220, 16777221]
and self.view.g_rect.rect().width() > 0):
self.view.got_rect.emit((self.view.g_rect.rect().topLeft(),
self.view.g_rect.rect().bottomRight()))
if self.view.g_rect.pen().color() == Qt.red:
new_pix = self.pixmap.pixmap().copy(self.crop_rect)
if self.pixmap_is_scaled:
new_pix = new_pix.transformed(
self.view.transform().inverted()[0],
Qt.SmoothTransformation)
self.update_pixmap(new_pix)
elif self.view.g_rect.pen().color() == Qt.magenta:
self.annotate_rect()
self.view.annotation = False
for _ in (self.label, self.save_button, self.no_save_button):
_.show()
self.view.reset()
def play(self):
"""Starts a slideshow."""
if self.play_button.isChecked():
if self.browser_button.isChecked():
self.reset_browser = True
else:
self.reset_browser = False
QTimer.singleShot(3000, self.play)
self.next()
def _yield_radio(self):
"""Saves code connecting signals from all the radio buttons."""
yield from self.radios.keys().__str__()
def load_icon(self, icon_file):
"""Loads an icon from Base64 encoded strings in icons.py."""
pix = QPixmap()
pix.loadFromData(icon_file)
return QIcon(pix)
def open_file(self, file: str) -> None:
"""
Open an image file and display it.
:param file: The filename of the image to open
"""
if not os.path.isfile(file):
file = QFileDialog(self, self.dir_now,
self.dir_now).getOpenFileName()[0]
self.dir_now = os.path.dirname(file)
self.refresh_files()
for i, index_file in enumerate(self.files):
if file.split('/')[-1] == index_file:
self.index = i
self.view.setTransform(QTransform())
self.update_pixmap(QPixmap(file))
self.browser()
self.load_tags()
def refresh_files(self) -> list[str]:
"""Updates the file list when the directory is changed.
Returns a list of image files available in the current directory."""
files = os.listdir(self.dir_now)
self.files = [
file for file in sorted(files, key=lambda x: x.lower())
if file.endswith((".png", ".jpg", ".gif", ".bmp", ".jpeg"))
]
def next(self) -> None:
"""Opens the next image in the file list."""
self.index = (self.index + 1) % len(self.files)
self.reload()
def previous(self) -> None:
"""Opens the previous image in the file list."""
self.index = (self.index + (len(self.files) - 1)) % len(self.files)
self.reload()
def save_image(self) -> None:
"""
Save the modified image file. If the current pixmap has been
scaled, we need to load a non-scaled pixmap from the original file and
re-apply the transformations that have been performed to prevent it
from being saved as the scaled-down image.
"""
if self.pixmap_is_scaled:
rotation = self.pixmap.rotation()
mirror = self.pixmap.scale() < 0
pix = QPixmap(self.files[self.index])
pix = pix.transformed(QTransform().rotate(rotation))
if mirror:
pix = pix.transformed(QTransform().scale(-1, 1))
pix.save(self.files[self.index], quality=-1)
else:
self.pixmap.pixmap().save(self.files[self.index], quality=-1)
self.save_tags()
def delete(self) -> None:
"""Deletes the current image from the file system."""
with suppress(OSError):
os.remove(f"{self.dir_now}/{self.files.pop(self.index)}")
self.refresh_files()
def reload(self) -> None:
"""Reloads the current pixmap; used to update the screen when the
current file is changed."""
self.open_file(f"{self.dir_now}/{self.files[self.index]}")
def annotate(self, tag):
"""Starts an annotate action"""
self.txt = PngInfo()
self.view.annotation = True
self.active_tag = tag
self.view.reset()
def wheelEvent(self, event: QWheelEvent) -> None: # pylint: disable=invalid-name
"""With Ctrl depressed, zoom the current image, otherwise fire the
next/previous functions."""
modifiers = QApplication.keyboardModifiers()
if event.angleDelta().y() == 120 and modifiers == Qt.ControlModifier:
self.view.scale(0.75, 0.75)
elif event.angleDelta().y() == 120:
self.previous()
elif event.angleDelta().y(
) == -120 and modifiers == Qt.ControlModifier:
self.view.scale(1.25, 1.25)
elif event.angleDelta().y() == -120:
self.next()
def actual_size(self) -> None:
"""Display the current image at its actual size, rather than scaled to
fit the viewport."""
self.update_pixmap(QPixmap(self.files[self.index]), False)
self.view.setDragMode(QGraphicsView.ScrollHandDrag)
def mousePressEvent(self, event: QMouseEvent) -> None: # pylint: disable=invalid-name
"""Event handler for mouse button presses."""
if event.button() == Qt.MouseButton.ForwardButton:
self.next()
elif event.button() == Qt.MouseButton.BackButton:
self.previous()
def update_pixmap(self, new: QPixmap, scaled: bool = True) -> None:
"""
Updates the currently displayed image.
:param new: The new `QPixmap` to be displayed.
:param scaled: If False, don't scale the image to fit the viewport.
"""
self.pixmap_is_scaled = scaled
self.media.clear()
self.pixmap = self.media.addPixmap(new)
self.pixmap.setTransformOriginPoint(
self.pixmap.boundingRect().width() / 2,
self.pixmap.boundingRect().height() / 2)
if scaled and (new.size().width() > self.view.width()
or new.size().height() > self.view.height()):
self.view.fitInView(self.pixmap, Qt.KeepAspectRatio)
self.media.setSceneRect(self.pixmap.boundingRect())
def annotate_rect(self):
"""Creates image coordinate annotation data."""
self.txt.add_itxt(
f'{str(self.active_tag)}-rect',
f'{str(self.crop_rect.x())}, {str(self.crop_rect.y())}, {str(self.crop_rect.width())}, {str(self.crop_rect.height())}'
)
def browser(self):
"""Slot function to initialize image thumbnails for the
'browse mode.'"""
while self.h_box2.itemAt(0):
self.h_box2.takeAt(0).widget().deleteLater()
index = (self.index + (len(self.files) - 2)) % len(self.files)
for i, file in enumerate(self.files):
file = self.dir_now + '/' + self.files[index]
label = ClickableLabel(self, file)
self.h_box2.addWidget(label)
pix = QPixmap(file)
if (pix.size().width() > self.browse_bar.width() / 5
or pix.size().height() > 100):
pix = pix.scaled(self.browse_bar.width() / 5, 100,
Qt.KeepAspectRatio)
label.setPixmap(pix)
index = (index + 1) % len(self.files)
if i == 4:
break
def save_tags(self):
"""Save tags for currently loaded image into its iTxt data."""
file = self.files[self.index]
img = Image.open(file)
img.load()
for key, value, in img.text.items():
self.txt.add_itxt(key, value)
for key in self.radios:
if key.isChecked():
self.txt.add_itxt(self.radios[key]['this'], 'True')
self.txt.add_itxt(self.radios[key]['that'], 'False')
img.save(file, pnginfo=self.txt)
def load_tags(self):
"""Load tags from iTxt data."""
for radio in self.radios:
if radio.isChecked():
self.radios[radio]['reset'].setChecked(True)
filename = self.files[self.index]
fqp = filename
img = Image.open(fqp)
img.load()
with suppress(AttributeError):
for key, value in img.text.items():
if value == 'True':
for radio in self.radios:
if key == self.radios[radio]['this']:
radio.setChecked(True)
self.view.annotation = False
self.active_tag = ''
self.view.reset()
for key, value in img.text.items():
if key.endswith('-rect'):
btn = [
radio for radio in self.radios
if self.radios[radio]['this'] == key.split('-')[0]
]
print(key, value)
if btn[0].isChecked():
coords = [int(coord) for coord in value.split(', ')]
rect = QGraphicsRectItem(*coords)
rect.setPen(QPen(Qt.magenta, 1, Qt.SolidLine))
rect.setBrush(QBrush(Qt.magenta, Qt.Dense4Pattern))
self.view.scene().addItem(rect)
text = self.view.scene().addText(
key.split('-')[0],
QFont('monospace', 20, 400, False))
text.font().setPointSize(text.font().pointSize() * 2)
text.update()
text.setX(rect.rect().x() + 10)
text.setY(rect.rect().y() + 10)
print(f'set {key}')
class MainWidget(TritonWidget):
def __init__(self, base):
TritonWidget.__init__(self, base)
self.addOTP = None
self.closeEvent = self.widgetDeleted
self.setWindowTitle('TritonAuth')
self.setBackgroundColor(self, Qt.white)
self.menu = QMenuBar()
self.addMenu = self.menu.addMenu('Add')
self.authAction = QAction('Authenticator', self)
self.authAction.triggered.connect(self.openAddOTP)
self.steamAction = QAction('Steam', self)
self.steamAction.triggered.connect(self.openAddSteam)
self.addMenu.addAction(self.authAction)
self.addMenu.addAction(self.steamAction)
self.sortMenu = self.menu.addMenu('Sort')
self.nameAction = QAction('Sort by name', self)
self.nameAction.triggered.connect(self.sortByName)
self.sortMenu.addAction(self.nameAction)
self.exportMenu = self.menu.addMenu('Export')
self.andOTPAction = QAction('Export to andOTP', self)
self.andOTPAction.triggered.connect(self.exportToAndOTP)
self.exportMenu.addAction(self.andOTPAction)
self.widget = QWidget()
self.widget.setContentsMargins(10, 10, 10, 10)
self.scrollArea = QScrollArea()
self.scrollArea.setFixedSize(400, 495)
self.scrollArea.setWidgetResizable(True)
self.scrollWidget = QWidget()
self.scrollLayout = QVBoxLayout(self.scrollWidget)
self.scrollLayout.setAlignment(Qt.AlignTop)
self.createAccounts()
self.scrollArea.setWidget(self.scrollWidget)
self.widgetLayout = QVBoxLayout(self.widget)
self.widgetLayout.addWidget(self.scrollArea)
self.boxLayout = QVBoxLayout(self)
self.boxLayout.setContentsMargins(0, 5, 0, 0)
self.boxLayout.addWidget(self.menu)
self.boxLayout.addWidget(self.widget)
self.setFixedSize(self.sizeHint())
self.center()
self.show()
def keyPressEvent(self, event):
if type(event) != QKeyEvent:
return
letter = event.text().strip().lower()
for i in range(self.scrollLayout.count()):
widget = self.scrollLayout.itemAt(i).widget()
if widget is not None and widget.name[0].lower() == letter:
self.scrollArea.verticalScrollBar().setValue(
widget.geometry().top())
return
def widgetDeleted(self, arg):
self.closeAddOTP()
def closeAddOTP(self):
if self.addOTP:
self.addOTP.close()
self.addOTP = None
def addAccount(self, account):
entry = EntryWidget(self.base, account)
self.scrollLayout.addWidget(entry)
def deleteAccount(self, account):
for i in range(self.scrollLayout.count()):
widget = self.scrollLayout.itemAt(i).widget()
if widget.account == account:
widget.close()
def clearAccounts(self):
for i in range(self.scrollLayout.count()):
self.scrollLayout.itemAt(i).widget().close()
def createAccounts(self):
for account in self.base.getAccounts():
self.addAccount(account)
def openAddOTP(self):
self.closeAddOTP()
self.addOTP = AddOTPWidget(self.base)
def openAddSteam(self):
self.closeAddOTP()
self.addOTP = AddSteamWidget(self.base)
def sortByName(self):
self.base.sortAccountsByName()
self.clearAccounts()
self.createAccounts()
def exportToAndOTP(self):
accounts = []
for account in self.base.getAccounts():
type = account['type']
if type == Globals.OTPAuth:
accounts.append({
'secret': account['key'],
'digits': 6,
'period': 30,
'label': account['name'],
'type': 'TOTP',
'algorithm': 'SHA1',
'thumbnail': 'Default',
'last_used': 0,
'tags': []
})
elif type == Globals.SteamAuth:
accounts.append({
'secret':
base64.b32encode(base64.b64decode(
account['sharedSecret'])).decode('utf-8'),
'digits':
5,
'period':
30,
'label':
account['name'],
'type':
'STEAM',
'algorithm':
'SHA1',
'thumbnail':
'Default',
'last_used':
0,
'tags': []
})
accounts = json.dumps(accounts)
filename, _ = QFileDialog.getSaveFileName(
self, 'Export to andOTP JSON file', '', 'All Files (*)')
if filename:
with open(filename, 'w') as file:
file.write(accounts)
class UIManipulateROIWindow:
def setup_ui(self, manipulate_roi_window_instance, rois, dataset_rtss,
roi_color, signal_roi_manipulated):
self.patient_dict_container = PatientDictContainer()
self.rois = rois
self.dataset_rtss = dataset_rtss
self.signal_roi_manipulated = signal_roi_manipulated
self.roi_color = roi_color
self.roi_names = [] # Names of selected ROIs
self.all_roi_names = [] # Names of all existing ROIs
for roi_id, roi_dict in self.rois.items():
self.all_roi_names.append(roi_dict['name'])
# Operation names
self.single_roi_operation_names = [
"Expand", "Contract", "Inner Rind (annulus)",
"Outer Rind (annulus)"
]
self.multiple_roi_operation_names = [
"Union", "Intersection", "Difference"
]
self.operation_names = self.multiple_roi_operation_names + \
self.single_roi_operation_names
self.new_ROI_contours = None
self.manipulate_roi_window_instance = manipulate_roi_window_instance
self.dicom_view = DicomAxialView(metadata_formatted=True,
is_four_view=True)
self.dicom_preview = DicomAxialView(metadata_formatted=True,
is_four_view=True)
self.dicom_view.slider.valueChanged.connect(
self.dicom_view_slider_value_changed)
self.dicom_preview.slider.valueChanged.connect(
self.dicom_preview_slider_value_changed)
self.init_layout()
QtCore.QMetaObject.connectSlotsByName(manipulate_roi_window_instance)
def retranslate_ui(self, manipulate_roi_window_instance):
_translate = QtCore.QCoreApplication.translate
manipulate_roi_window_instance.setWindowTitle(
_translate("ManipulateRoiWindowInstance",
"OnkoDICOM - Draw Region Of Interest"))
self.first_roi_name_label.setText(
_translate("FirstROINameLabel", "ROI 1: "))
self.first_roi_name_dropdown_list.setPlaceholderText("ROI 1")
self.first_roi_name_dropdown_list.addItems(self.all_roi_names)
self.operation_name_label.setText(
_translate("OperationNameLabel", "Operation"))
self.operation_name_dropdown_list.setPlaceholderText("Operation")
self.operation_name_dropdown_list.addItems(self.operation_names)
self.second_roi_name_label.setText(
_translate("SecondROINameLabel", "ROI 2: "))
self.second_roi_name_dropdown_list.setPlaceholderText("ROI 2")
self.second_roi_name_dropdown_list.addItems(self.all_roi_names)
self.manipulate_roi_window_instance_draw_button.setText(
_translate("ManipulateRoiWindowInstanceDrawButton", "Draw"))
self.manipulate_roi_window_instance_save_button.setText(
_translate("ManipulateRoiWindowInstanceSaveButton", "Save"))
self.manipulate_roi_window_instance_cancel_button.setText(
_translate("ManipulateRoiWindowInstanceCancelButton", "Cancel"))
self.margin_label.setText(_translate("MarginLabel", "Margin (mm): "))
self.new_roi_name_label.setText(
_translate("NewROINameLabel", "New ROI Name"))
self.ROI_view_box_label.setText("ROI")
self.preview_box_label.setText("Preview")
def init_layout(self):
"""
Initialize the layout for the DICOM View tab.
Add the view widget and the slider in the layout.
Add the whole container 'tab2_view' as a tab in the main page.
"""
# Initialise a ManipulateROIWindow
if platform.system() == 'Darwin':
self.stylesheet_path = "res/stylesheet.qss"
else:
self.stylesheet_path = "res/stylesheet-win-linux.qss"
stylesheet = open(resource_path(self.stylesheet_path)).read()
window_icon = QIcon()
window_icon.addPixmap(QPixmap(resource_path("res/images/icon.ico")),
QIcon.Normal, QIcon.Off)
self.manipulate_roi_window_instance.setObjectName(
"ManipulateRoiWindowInstance")
self.manipulate_roi_window_instance.setWindowIcon(window_icon)
# Creating a form box to hold all buttons and input fields
self.manipulate_roi_window_input_container_box = QFormLayout()
self.manipulate_roi_window_input_container_box.setObjectName(
"ManipulateRoiWindowInputContainerBox")
self.manipulate_roi_window_input_container_box.setLabelAlignment(
Qt.AlignLeft)
# Create a label for denoting the first ROI name
self.first_roi_name_label = QLabel()
self.first_roi_name_label.setObjectName("FirstROINameLabel")
self.first_roi_name_dropdown_list = QComboBox()
# Create an dropdown list for ROI name
self.first_roi_name_dropdown_list.setObjectName(
"FirstROINameDropdownList")
self.first_roi_name_dropdown_list.setSizePolicy(
QSizePolicy.Minimum, QSizePolicy.Minimum)
self.first_roi_name_dropdown_list.resize(
self.first_roi_name_dropdown_list.sizeHint().width(),
self.first_roi_name_dropdown_list.sizeHint().height())
self.first_roi_name_dropdown_list.activated.connect(
self.update_selected_rois)
self.manipulate_roi_window_input_container_box.addRow(
self.first_roi_name_label, self.first_roi_name_dropdown_list)
# Create a label for denoting the operation
self.operation_name_label = QLabel()
self.operation_name_label.setObjectName("OperationNameLabel")
self.operation_name_dropdown_list = QComboBox()
# Create an dropdown list for operation name
self.operation_name_dropdown_list.setObjectName(
"OperationNameDropdownList")
self.operation_name_dropdown_list.setSizePolicy(
QSizePolicy.Minimum, QSizePolicy.Minimum)
self.operation_name_dropdown_list.resize(
self.operation_name_dropdown_list.sizeHint().width(),
self.operation_name_dropdown_list.sizeHint().height())
self.operation_name_dropdown_list.activated.connect(
self.operation_changed)
self.manipulate_roi_window_input_container_box.addRow(
self.operation_name_label, self.operation_name_dropdown_list)
# Create a label for denoting the second ROI name
self.second_roi_name_label = QLabel()
self.second_roi_name_label.setObjectName("SecondROINameLabel")
self.second_roi_name_label.setVisible(False)
self.second_roi_name_dropdown_list = QComboBox()
# Create an dropdown list for ROI name
self.second_roi_name_dropdown_list.setObjectName(
"SecondROINameDropdownList")
self.second_roi_name_dropdown_list.setSizePolicy(
QSizePolicy.Minimum, QSizePolicy.Minimum)
self.second_roi_name_dropdown_list.resize(
self.second_roi_name_dropdown_list.sizeHint().width(),
self.second_roi_name_dropdown_list.sizeHint().height())
self.second_roi_name_dropdown_list.setVisible(False)
self.second_roi_name_dropdown_list.activated.connect(
self.update_selected_rois)
self.manipulate_roi_window_input_container_box.addRow(
self.second_roi_name_label, self.second_roi_name_dropdown_list)
# Create a label for denoting the margin
self.margin_label = QLabel()
self.margin_label.setObjectName("MarginLabel")
self.margin_label.setVisible(False)
# Create input for the new ROI name
self.margin_line_edit = QLineEdit()
self.margin_line_edit.setObjectName("MarginInput")
self.margin_line_edit.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Minimum)
self.margin_line_edit.resize(self.margin_line_edit.sizeHint().width(),
self.margin_line_edit.sizeHint().height())
self.margin_line_edit.setVisible(False)
self.margin_line_edit.setValidator(
QRegularExpressionValidator(
QRegularExpression("^[0-9]*[.]?[0-9]*$")))
self.manipulate_roi_window_input_container_box.addRow(
self.margin_label, self.margin_line_edit)
# Create a label for denoting the new ROI name
self.new_roi_name_label = QLabel()
self.new_roi_name_label.setObjectName("NewROINameLabel")
# Create input for the new ROI name
self.new_roi_name_line_edit = QLineEdit()
self.new_roi_name_line_edit.setObjectName("NewROINameInput")
self.new_roi_name_line_edit.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Minimum)
self.new_roi_name_line_edit.resize(
self.new_roi_name_line_edit.sizeHint().width(),
self.new_roi_name_line_edit.sizeHint().height())
self.manipulate_roi_window_input_container_box.addRow(
self.new_roi_name_label, self.new_roi_name_line_edit)
# Create a spacer between inputs and buttons
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
spacer.setFocusPolicy(Qt.NoFocus)
self.manipulate_roi_window_input_container_box.addRow(spacer)
# Create a warning message when missing inputs
self.warning_message = QWidget()
self.warning_message.setContentsMargins(8, 5, 8, 5)
warning_message_layout = QHBoxLayout()
warning_message_layout.setAlignment(QtCore.Qt.AlignLeft
| QtCore.Qt.AlignLeft)
warning_message_icon = QLabel()
warning_message_icon.setPixmap(
QtGui.QPixmap(
resource_path("res/images/btn-icons/alert_icon.png")))
warning_message_layout.addWidget(warning_message_icon)
self.warning_message_text = QLabel()
self.warning_message_text.setStyleSheet("color: red")
warning_message_layout.addWidget(self.warning_message_text)
self.warning_message.setLayout(warning_message_layout)
self.warning_message.setVisible(False)
self.manipulate_roi_window_input_container_box.addRow(
self.warning_message)
# Create a draw button
self.manipulate_roi_window_instance_draw_button = QPushButton()
self.manipulate_roi_window_instance_draw_button.setObjectName(
"ManipulateRoiWindowInstanceDrawButton")
self.manipulate_roi_window_instance_draw_button.setSizePolicy(
QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum))
self.manipulate_roi_window_instance_draw_button.resize(
self.manipulate_roi_window_instance_draw_button.sizeHint().width(),
self.manipulate_roi_window_instance_draw_button.sizeHint().height(
))
self.manipulate_roi_window_instance_draw_button.setCursor(
QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.manipulate_roi_window_instance_draw_button.clicked.connect(
self.onDrawButtonClicked)
self.manipulate_roi_window_input_container_box.addRow(
self.manipulate_roi_window_instance_draw_button)
# Create a horizontal box for saving and cancel the drawing
self.manipulate_roi_window_cancel_save_box = QHBoxLayout()
self.manipulate_roi_window_cancel_save_box.setObjectName(
"ManipulateRoiWindowCancelSaveBox")
# Create an exit button to cancel the drawing
# Add a button to go back/exit from the application
self.manipulate_roi_window_instance_cancel_button = QPushButton()
self.manipulate_roi_window_instance_cancel_button.setObjectName(
"ManipulateRoiWindowInstanceCancelButton")
self.manipulate_roi_window_instance_cancel_button.setSizePolicy(
QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum))
self.manipulate_roi_window_instance_cancel_button.resize(
self.manipulate_roi_window_instance_cancel_button.sizeHint().width(
),
self.manipulate_roi_window_instance_cancel_button.sizeHint().
height())
self.manipulate_roi_window_instance_cancel_button.setCursor(
QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.manipulate_roi_window_instance_cancel_button.clicked.connect(
self.onCancelButtonClicked)
self.manipulate_roi_window_instance_cancel_button.setProperty(
"QPushButtonClass", "fail-button")
icon_cancel = QtGui.QIcon()
icon_cancel.addPixmap(
QtGui.QPixmap(
resource_path('res/images/btn-icons/cancel_icon.png')))
self.manipulate_roi_window_instance_cancel_button.setIcon(icon_cancel)
self.manipulate_roi_window_cancel_save_box.addWidget(
self.manipulate_roi_window_instance_cancel_button)
# Create a save button to save all the changes
self.manipulate_roi_window_instance_save_button = QPushButton()
self.manipulate_roi_window_instance_save_button.setObjectName(
"ManipulateRoiWindowInstanceSaveButton")
self.manipulate_roi_window_instance_save_button.setSizePolicy(
QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum))
self.manipulate_roi_window_instance_save_button.resize(
self.manipulate_roi_window_instance_save_button.sizeHint().width(),
self.manipulate_roi_window_instance_save_button.sizeHint().height(
))
self.manipulate_roi_window_instance_save_button.setProperty(
"QPushButtonClass", "success-button")
icon_save = QtGui.QIcon()
icon_save.addPixmap(
QtGui.QPixmap(resource_path('res/images/btn-icons/save_icon.png')))
self.manipulate_roi_window_instance_save_button.setIcon(icon_save)
self.manipulate_roi_window_instance_save_button.clicked.connect(
self.onSaveClicked)
self.manipulate_roi_window_cancel_save_box.addWidget(
self.manipulate_roi_window_instance_save_button)
self.manipulate_roi_window_input_container_box.addRow(
self.manipulate_roi_window_cancel_save_box)
# Creating a horizontal box to hold the ROI view and the preview
self.manipulate_roi_window_instance_view_box = QHBoxLayout()
self.manipulate_roi_window_instance_view_box.setObjectName(
"ManipulateRoiWindowInstanceViewBoxes")
# Font for the ROI view and preview's labels
font = QFont()
font.setBold(True)
font.setPixelSize(20)
# Creating the ROI view
self.ROI_view_box_layout = QVBoxLayout()
self.ROI_view_box_label = QLabel()
self.ROI_view_box_label.setFont(font)
self.ROI_view_box_label.setAlignment(Qt.AlignHCenter)
self.ROI_view_box_layout.addWidget(self.ROI_view_box_label)
self.ROI_view_box_layout.addWidget(self.dicom_view)
self.ROI_view_box_widget = QWidget()
self.ROI_view_box_widget.setLayout(self.ROI_view_box_layout)
# Creating the preview
self.preview_box_layout = QVBoxLayout()
self.preview_box_label = QLabel()
self.preview_box_label.setFont(font)
self.preview_box_label.setAlignment(Qt.AlignHCenter)
self.preview_box_layout.addWidget(self.preview_box_label)
self.preview_box_layout.addWidget(self.dicom_preview)
self.preview_box_widget = QWidget()
self.preview_box_widget.setLayout(self.preview_box_layout)
# Add View and Slider into horizontal box
self.manipulate_roi_window_instance_view_box.addWidget(
self.ROI_view_box_widget)
self.manipulate_roi_window_instance_view_box.addWidget(
self.preview_box_widget)
# Create a widget to hold the image slice box
self.manipulate_roi_window_instance_view_widget = QWidget()
self.manipulate_roi_window_instance_view_widget.setObjectName(
"ManipulateRoiWindowInstanceActionWidget")
self.manipulate_roi_window_instance_view_widget.setLayout(
self.manipulate_roi_window_instance_view_box)
# Create a horizontal box for containing the input fields and the
# viewports
self.manipulate_roi_window_main_box = QHBoxLayout()
self.manipulate_roi_window_main_box.setObjectName(
"ManipulateRoiWindowMainBox")
self.manipulate_roi_window_main_box.addLayout(
self.manipulate_roi_window_input_container_box, 1)
self.manipulate_roi_window_main_box.addWidget(
self.manipulate_roi_window_instance_view_widget, 11)
# Create a new central widget to hold the horizontal box layout
self.manipulate_roi_window_instance_central_widget = QWidget()
self.manipulate_roi_window_instance_central_widget.setObjectName(
"ManipulateRoiWindowInstanceCentralWidget")
self.manipulate_roi_window_instance_central_widget.setLayout(
self.manipulate_roi_window_main_box)
self.retranslate_ui(self.manipulate_roi_window_instance)
self.manipulate_roi_window_instance.setStyleSheet(stylesheet)
self.manipulate_roi_window_instance.setCentralWidget(
self.manipulate_roi_window_instance_central_widget)
QtCore.QMetaObject.connectSlotsByName(
self.manipulate_roi_window_instance)
def dicom_view_slider_value_changed(self):
"""
Display selected ROIs in dropbox when moving to another image slice
"""
self.display_selected_roi()
if self.dicom_preview.slider.value() != self.dicom_view.slider.value():
self.dicom_preview.slider.setValue(self.dicom_view.slider.value())
def dicom_preview_slider_value_changed(self):
"""
Display generated ROI when moving to another image slice
"""
self.draw_roi()
if self.dicom_preview.slider.value() != self.dicom_view.slider.value():
self.dicom_view.slider.setValue(self.dicom_preview.slider.value())
def onCancelButtonClicked(self):
"""
This function is used for canceling the drawing
"""
self.close()
def onDrawButtonClicked(self):
"""
Function triggered when the Draw button is pressed from the menu.
"""
# Hide warning message
self.warning_message.setVisible(False)
# Check inputs
selected_operation = self.operation_name_dropdown_list.currentText()
roi_1 = self.first_roi_name_dropdown_list.currentText()
roi_2 = self.second_roi_name_dropdown_list.currentText()
new_roi_name = self.new_roi_name_line_edit.text()
# Check the selected inputs and execute the operations
if roi_1 != "" and new_roi_name != "" and \
self.margin_line_edit.text() != "" and \
selected_operation in self.single_roi_operation_names:
# Single ROI operations
dict_rois_contours = ROI.get_roi_contour_pixel(
self.patient_dict_container.get("raw_contour"), [roi_1],
self.patient_dict_container.get("pixluts"))
roi_geometry = ROI.roi_to_geometry(dict_rois_contours[roi_1])
margin = float(self.margin_line_edit.text())
if selected_operation == self.single_roi_operation_names[0]:
new_geometry = ROI.scale_roi(roi_geometry, margin)
elif selected_operation == self.single_roi_operation_names[1]:
new_geometry = ROI.scale_roi(roi_geometry, -margin)
elif selected_operation == self.single_roi_operation_names[2]:
new_geometry = ROI.rind_roi(roi_geometry, -margin)
else:
new_geometry = ROI.rind_roi(roi_geometry, margin)
self.new_ROI_contours = ROI.geometry_to_roi(new_geometry)
self.draw_roi()
return True
elif roi_1 != "" and roi_2 != "" and new_roi_name != "" and \
selected_operation in self.multiple_roi_operation_names:
# Multiple ROI operations
dict_rois_contours = ROI.get_roi_contour_pixel(
self.patient_dict_container.get("raw_contour"), [roi_1, roi_2],
self.patient_dict_container.get("pixluts"))
roi_1_geometry = ROI.roi_to_geometry(dict_rois_contours[roi_1])
roi_2_geometry = ROI.roi_to_geometry(dict_rois_contours[roi_2])
# Execute the selected operation
new_geometry = ROI.manipulate_rois(roi_1_geometry, roi_2_geometry,
selected_operation.upper())
self.new_ROI_contours = ROI.geometry_to_roi(new_geometry)
self.draw_roi()
return True
self.warning_message_text.setText("Not all values are specified.")
self.warning_message.setVisible(True)
return False
def onSaveClicked(self):
""" Save the new ROI """
# Get the name of the new ROI
new_roi_name = self.new_roi_name_line_edit.text()
# If the new ROI hasn't been drawn, draw the new ROI. Then if the new
# ROI is drawn successfully, proceed to save the new ROI.
if self.new_ROI_contours is None:
if not self.onDrawButtonClicked():
return
# Get a dict to convert SOPInstanceUID to slice id
slice_ids_dict = get_dict_slice_to_uid(PatientDictContainer())
# Transform new_ROI_contours to a list of roi information
rois_to_save = {}
for uid, contour_sequence in self.new_ROI_contours.items():
slider_id = slice_ids_dict[uid]
location = self.patient_dict_container.filepaths[slider_id]
ds = pydicom.dcmread(location)
slice_info = {'coords': contour_sequence, 'ds': ds}
rois_to_save[slider_id] = slice_info
roi_list = ROI.convert_hull_list_to_contours_data(
rois_to_save, self.patient_dict_container)
connectSaveROIProgress(self, roi_list, self.dataset_rtss, new_roi_name,
self.roi_saved)
def draw_roi(self):
""" Draw the new ROI """
# Get the new ROI's name
new_roi_name = self.new_roi_name_line_edit.text()
# Check if the new ROI contour is None
if self.new_ROI_contours is None:
return
# Get the info required to draw the new ROI
slider_id = self.dicom_preview.slider.value()
curr_slice = self.patient_dict_container.get("dict_uid")[slider_id]
# Calculate the new ROI's polygon
dict_ROI_contours = {}
dict_ROI_contours[new_roi_name] = self.new_ROI_contours
polygons = ROI.calc_roi_polygon(new_roi_name, curr_slice,
dict_ROI_contours)
# Set the new ROI color
color = QtGui.QColor()
color.setRgb(90, 250, 175, 200)
pen_color = QtGui.QColor(color.red(), color.green(), color.blue())
pen = QtGui.QPen(pen_color)
pen.setStyle(QtCore.Qt.PenStyle(1))
pen.setWidthF(2.0)
# Draw the new ROI
self.dicom_preview.update_view()
for i in range(len(polygons)):
self.dicom_preview.scene.addPolygon(polygons[i], pen,
QtGui.QBrush(color))
def update_selected_rois(self):
""" Get the names of selected ROIs """
# Hide warning message
self.warning_message.setVisible(False)
self.roi_names = []
if self.first_roi_name_dropdown_list.currentText() != "":
self.roi_names.append(
self.first_roi_name_dropdown_list.currentText())
if self.second_roi_name_dropdown_list.currentText() != "" and \
self.second_roi_name_dropdown_list.isVisible():
self.roi_names.append(
self.second_roi_name_dropdown_list.currentText())
self.dict_rois_contours_axial = ROI.get_roi_contour_pixel(
self.patient_dict_container.get("raw_contour"), self.roi_names,
self.patient_dict_container.get("pixluts"))
self.display_selected_roi()
def display_selected_roi(self):
""" Display selected ROIs """
# Get the info required to display the selected ROIs
slider_id = self.dicom_view.slider.value()
curr_slice = self.patient_dict_container.get("dict_uid")[slider_id]
self.rois = self.patient_dict_container.get("rois")
# Display the selected ROIs
self.dicom_view.update_view()
for roi_id, roi_dict in self.rois.items():
roi_name = roi_dict['name']
if roi_name in self.roi_names:
polygons = ROI.calc_roi_polygon(roi_name, curr_slice,
self.dict_rois_contours_axial)
self.dicom_view.draw_roi_polygons(roi_id, polygons,
self.roi_color)
def operation_changed(self):
""" Change the form when users select different operations """
# Hide warning message
self.warning_message.setVisible(False)
selected_operation = self.operation_name_dropdown_list.currentText()
if selected_operation in self.single_roi_operation_names:
self.second_roi_name_label.setVisible(False)
self.second_roi_name_dropdown_list.setVisible(False)
self.margin_label.setVisible(True)
self.margin_line_edit.setVisible(True)
self.update_selected_rois()
else:
self.second_roi_name_label.setVisible(True)
self.second_roi_name_dropdown_list.setVisible(True)
self.margin_label.setVisible(False)
self.margin_line_edit.setVisible(False)
self.update_selected_rois()
def roi_saved(self, new_rtss):
""" Create a new ROI in Structure Tab and notify user """
new_roi_name = self.new_roi_name_line_edit.text()
self.signal_roi_manipulated.emit((new_rtss, {"draw": new_roi_name}))
QMessageBox.about(self.manipulate_roi_window_instance, "Saved",
"New contour successfully created!")
self.close()
