class AutomatonStateManager(QWidget):
signalStateIdsRequest = Signal()
signalSetStartingStateRequest = Signal(str)
signalSetCurrentStateRequest = Signal(str)
def __init__(self, parent):
super(AutomatonStateManager, self).__init__(parent)
self.startingStateButton = QPushButton('Set starting state: ', self)
self.startingStateButton.clicked.connect(self.setStartingState)
self.startingSelect = QComboBox(self)
self.currentStateButton = QPushButton('Set current state: ', self)
self.currentStateButton.clicked.connect(self.setCurrentState)
self.currentSelect = QComboBox(self)
self.signalStateIdsRequest.emit()
layout = QHBoxLayout()
layout.addWidget(self.startingStateButton)
layout.addWidget(self.startingSelect)
layout.addWidget(self.currentStateButton)
layout.addWidget(self.currentSelect)
layout.setSizeConstraint(QLayout.SetMaximumSize)
self.setLayout(layout)
@Slot(list)
def populateStateSelect(self, stateIds):
self.startingSelect.clear()
self.currentSelect.clear()
for stateId in stateIds:
self.startingSelect.addItem('q{}'.format(stateIds.index(stateId)),
stateId)
self.currentSelect.addItem('q{}'.format(stateIds.index(stateId)),
stateId)
self.startingSelect.setCurrentIndex(0)
self.currentSelect.setCurrentIndex(0)
@Slot()
def setStartingState(self):
stateId = self.startingSelect.currentData()
self.signalSetStartingStateRequest.emit(stateId)
@Slot()
def setCurrentState(self):
stateId = self.currentSelect.currentData()
self.signalSetCurrentStateRequest.emit(stateId)
@Slot()
def disableEdit(self):
self.startingSelect.setDisabled(True)
self.startingStateButton.setDisabled(True)
self.currentSelect.setDisabled(True)
self.currentStateButton.setDisabled(True)
@Slot()
def enableEdit(self):
self.startingSelect.setDisabled(False)
self.startingStateButton.setDisabled(False)
self.currentSelect.setDisabled(False)
self.currentStateButton.setDisabled(False)
class ComboboxTreeItemDelegate(QStyledItemDelegate):
def __init__(self, adapter, *args):
super().__init__(*args)
self.adapter = adapter
self.combobox = None
## Create the combobox and fill it with labels
def createEditor(self, parent, option, index):
self.combobox = QComboBox(parent)
for sft in [4, 5, 6]:
self.combobox.addItem(mode_labels[1 << sft], 1 << sft)
return self.combobox
## Render the editor based on the data in the model
def setEditorData(self, editor, index):
val = index.model().data(index, role=Qt.UserRole)
self.combobox.setCurrentText(mode_labels[val])
## Write back newly selected items into the model
def setModelData(self, editor, model, index):
model.setData(index, self.combobox.currentData(), role=Qt.UserRole)
model.setData(index, self.combobox.currentText())
self.adapter.update(model.data(index, role=Qt.UserRole + 1),
mode=self.combobox.currentData())
def _on_default_item_updated(self, category: ItemCategory, combo: QtWidgets.QComboBox, _):
with self._editor as editor:
new_config = editor.major_items_configuration
new_config = new_config.replace_default_item(category, combo.currentData())
new_config = new_config.replace_state_for_item(combo.currentData(),
MajorItemState(num_included_in_starting_items=1))
editor.major_items_configuration = new_config
class DatatypeSelector(QGroupBox):
def __init__(self,
title: str,
datatype_to_widget,
parent: "QWidget" = None):
super().__init__(title, parent)
# Maps a datatype with its respective widget. The widget is optional
self._datatype_to_widget = datatype_to_widget
self._datatype_combobox = QComboBox()
self._stacked_widgets = QStackedWidget()
for (i, (name, datatype_factory)) in enumerate(
DataTypeContainer.providers.items()):
datatype_instance = datatype_factory()
self._datatype_combobox.addItem(name, datatype_instance)
if datatype_factory in self._datatype_to_widget:
self._stacked_widgets.insertWidget(
i, self._datatype_to_widget[datatype_factory](
datatype_instance))
self._main_layout = QVBoxLayout()
self._main_layout.addWidget(self._datatype_combobox)
self._main_layout.addWidget(self._stacked_widgets)
self.setLayout(self._main_layout)
self._datatype_combobox.currentIndexChanged[int].connect(
self._change_active_widget)
@property
def selected_datatype(self):
return self._datatype_combobox.currentData()
def change_current_datatype(self, new_datatype_dict: dict):
index = self._datatype_combobox.findText(new_datatype_dict["class"])
if index != -1:
self._datatype_combobox.setCurrentIndex(index)
self._datatype_combobox.currentData().from_dict(new_datatype_dict)
self._stacked_widgets.currentWidget().reload()
def _change_active_widget(self, index):
self._stacked_widgets.setCurrentIndex(index)
# Hide the `stacked_widgets` when the current datatype doesn't needs to display
# a widget
if self._stacked_widgets.currentIndex() != index:
self._stacked_widgets.setVisible(False)
else:
self._stacked_widgets.setVisible(True)
def to_dict(self):
return self.selected_datatype.to_dict()
def _on_ammo_type_combo_changed(self, beam: str, combo: QComboBox, is_ammo_b: bool, _):
with self._editor as editor:
beam_configuration = editor.layout_configuration.beam_configuration
old_config: BeamAmmoConfiguration = getattr(beam_configuration, beam)
if is_ammo_b:
new_config = dataclasses.replace(old_config, ammo_b=combo.currentData())
else:
new_config = dataclasses.replace(old_config, ammo_a=combo.currentData())
editor.set_layout_configuration_field("beam_configuration",
dataclasses.replace(beam_configuration, **{beam: new_config}))
class QFlightStartType(QGroupBox):
def __init__(self, package_model: PackageModel, flight: Flight):
super().__init__()
self.package_model = package_model
self.flight = flight
self.layout = QVBoxLayout()
self.main_row = QHBoxLayout()
self.start_type_label = QLabel("Start type:")
self.start_type = QComboBox()
for start_type in StartType:
self.start_type.addItem(start_type.value, start_type)
self.start_type.setCurrentText(flight.start_type.value)
self.start_type.currentTextChanged.connect(
self._on_start_type_selected)
self.main_row.addWidget(self.start_type_label)
self.main_row.addWidget(self.start_type)
self.layout.addLayout(self.main_row)
self.layout.addWidget(
QLabel(
"Any option other than Cold will make this flight non-targetable "
+ "by OCA/Aircraft missions. This will affect game balance."))
self.setLayout(self.layout)
def _on_start_type_selected(self):
selected = self.start_type.currentData()
self.flight.start_type = selected
self.package_model.update_tot()
class StateManager(QWidget):
signalStateIdsRequest = Signal()
signalStateAdded = Signal()
signalStateRemoveRequest = Signal(object)
def __init__(self, parent):
super(StateManager, self).__init__(parent)
self.addButton = QPushButton('Add state...', self)
self.addButton.clicked.connect(self.addState)
self.removeButton = QPushButton('Remove state: ', self)
self.removeButton.clicked.connect(self.removeState)
self.stateSelect = QComboBox(self)
layout = QHBoxLayout()
layout.addWidget(self.addButton)
layout.addWidget(self.removeButton)
layout.addWidget(self.stateSelect)
layout.setSizeConstraint(QLayout.SetMaximumSize)
self.setLayout(layout)
@Slot(list)
def populateStateSelect(self, stateIds):
self.stateSelect.clear()
for stateId in stateIds:
self.stateSelect.addItem('q{}'.format(stateIds.index(stateId)),
stateId)
self.stateSelect.setCurrentIndex(0)
@Slot()
def addState(self):
self.signalStateAdded.emit()
@Slot()
def removeState(self):
stateId = self.stateSelect.currentData()
self.signalStateRemoveRequest.emit(stateId)
@Slot()
def disableEdit(self):
self.stateSelect.setDisabled(True)
self.addButton.setDisabled(True)
self.removeButton.setDisabled(True)
@Slot()
def enableEdit(self):
self.stateSelect.setDisabled(False)
self.addButton.setDisabled(False)
self.removeButton.setDisabled(False)
def _determine_field(self, option):
def slot(value):
self.check_and_apply(option, value)
if isinstance(option.range, Mapping):
field = QComboBox()
for name, item in option.range.items():
field.addItem(name, item)
if item == option.value:
field.setCurrentText(name)
field.currentIndexChanged.connect(
lambda: self.check_and_apply(option, field.currentData()))
elif option.type is str and isinstance(option.range, Collection):
field = QComboBox()
for name in option.range:
field.addItem(str(name))
if name == option.value:
field.setCurrentText(name)
field.currentIndexChanged.connect(
lambda: self.check_and_apply(option, field.currentText()))
elif option.type is bool:
field = QCheckBox()
field.setChecked(option.value)
field.stateChanged[int].connect(slot)
elif option.type is float:
field = QDoubleSpinBox()
field.setValue(option.value)
if isinstance(option.range, range):
field.setRange(option.range.start, option.range.stop)
field.valueChanged[float].connect(slot)
elif option.type is int:
field = QSpinBox()
field.setValue(option.value)
if isinstance(option.range, range):
field.setRange(option.range.start, option.range.stop)
field.setSingleStep(option.range.step)
field.valueChanged[int].connect(slot)
else:
field = QLineEdit(str(option.value), self)
field.textChanged[str].connect(slot)
field.setToolTip(option.description)
return field
class MainWidget(QWidget):
def __init__(self):
QWidget.__init__(self)
self.__text = QLabel("Enter the code below:")
self.__text_edit = QTextEdit()
self.__text.setAlignment(Qt.AlignCenter)
self.__lint_button = QPushButton("Validate")
self.__lint_button.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred)
self.__file_types_combo_box = QComboBox()
self.__file_types_combo_box.addItem(FileType.JSON.name,
userData=JsonValidator())
self.__file_types_combo_box.addItem(FileType.YAML.name,
userData=YamlValidator())
self.__hbox_layout = QHBoxLayout()
self.__hbox_layout.addWidget(self.__lint_button)
self.__hbox_layout.addWidget(self.__file_types_combo_box)
self.__vbox_layout = QVBoxLayout()
self.__vbox_layout.addWidget(self.__text)
self.__vbox_layout.addWidget(self.__text_edit)
self.__vbox_layout.addLayout(self.__hbox_layout)
self.setLayout(self.__vbox_layout)
# Connecting the signal
self.__lint_button.clicked.connect(self.on_lint_button_clicked)
@Slot()
def on_lint_button_clicked(self):
self.validate()
# TODO
def validate(self):
validator = self.__file_types_combo_box.currentData()
validator.validate()
class QFlightStartType(QGroupBox):
def __init__(self, flight:Flight):
super(QFlightStartType, self).__init__()
self.flight = flight
self.layout = QHBoxLayout()
self.start_type_label = QLabel("Start type : ")
self.start_type = QComboBox()
for i, st in enumerate([b for b in ["Cold", "Warm", "Runway", "In Flight"]]):
self.start_type.addItem(st, st)
if flight.start_type == st:
self.start_type.setCurrentIndex(i)
self.start_type.currentTextChanged.connect(self._on_start_type_selected)
self.layout.addWidget(self.start_type_label)
self.layout.addWidget(self.start_type)
self.setLayout(self.layout)
def _on_start_type_selected(self):
selected = self.start_type.currentData()
self.flight.start_type = selected
class QFlightCreator(QDialog):
def __init__(self, game: Game, from_cp:ControlPoint, possible_aircraft_type:List[UnitType], flight_view=None):
super(QFlightCreator, self).__init__()
self.game = game
self.from_cp = from_cp
self.flight_view = flight_view
self.planner = self.game.planners[from_cp.id]
self.available = self.planner.get_available_aircraft()
self.setWindowFlags(Qt.WindowStaysOnTopHint)
self.setModal(True)
self.setWindowTitle("Create flight")
self.setWindowIcon(EVENT_ICONS["strike"])
self.select_type_aircraft = QComboBox()
for aircraft_type in self.planner.get_available_aircraft().keys():
print(aircraft_type)
print(aircraft_type.name)
self.select_type_aircraft.addItem(aircraft_type.id, userData=aircraft_type)
self.select_type_aircraft.setCurrentIndex(0)
self.select_flight_type = QComboBox()
self.select_flight_type.addItem("CAP [Combat Air Patrol]", userData=FlightType.CAP)
self.select_flight_type.addItem("BARCAP [Barrier Combat Air Patrol]", userData=FlightType.BARCAP)
self.select_flight_type.addItem("TARCAP [Target Combat Air Patrol]", userData=FlightType.TARCAP)
self.select_flight_type.addItem("INTERCEPT [Interception]", userData=FlightType.INTERCEPTION)
self.select_flight_type.addItem("CAS [Close Air Support]", userData=FlightType.CAS)
self.select_flight_type.addItem("BAI [Battlefield Interdiction]", userData=FlightType.BAI)
self.select_flight_type.addItem("SEAD [Suppression of Enemy Air Defenses]", userData=FlightType.SEAD)
self.select_flight_type.addItem("DEAD [Destruction of Enemy Air Defenses]", userData=FlightType.DEAD)
self.select_flight_type.addItem("STRIKE [Strike]", userData=FlightType.STRIKE)
self.select_flight_type.addItem("ANTISHIP [Antiship Attack]", userData=FlightType.ANTISHIP)
self.select_flight_type.setCurrentIndex(0)
self.select_count_of_aircraft = QSpinBox()
self.select_count_of_aircraft.setMinimum(1)
self.select_count_of_aircraft.setMaximum(4)
self.select_count_of_aircraft.setValue(2)
self.add_button = QPushButton("Add")
self.add_button.clicked.connect(self.create_flight)
self.init_ui()
def init_ui(self):
layout = QVBoxLayout()
type_layout = QHBoxLayout()
type_layout.addWidget(QLabel("Type of Aircraft : "))
type_layout.addStretch()
type_layout.addWidget(self.select_type_aircraft, alignment=Qt.AlignRight)
count_layout = QHBoxLayout()
count_layout.addWidget(QLabel("Count : "))
count_layout.addStretch()
count_layout.addWidget(self.select_count_of_aircraft, alignment=Qt.AlignRight)
flight_type_layout = QHBoxLayout()
flight_type_layout.addWidget(QLabel("Task : "))
flight_type_layout.addStretch()
flight_type_layout.addWidget(self.select_flight_type, alignment=Qt.AlignRight)
layout.addLayout(type_layout)
layout.addLayout(count_layout)
layout.addLayout(flight_type_layout)
layout.addStretch()
layout.addWidget(self.add_button, alignment=Qt.AlignRight)
self.setLayout(layout)
def create_flight(self):
aircraft_type = self.select_type_aircraft.currentData()
count = self.select_count_of_aircraft.value()
if self.available[aircraft_type] < count:
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("Not enough aircraft of this type are available. Only " + str(self.available[aircraft_type]) + " available.")
msg.setWindowTitle("Not enough aircraft")
msg.setStandardButtons(QMessageBox.Ok)
msg.setWindowFlags(Qt.WindowStaysOnTopHint)
msg.exec_()
return
else:
flight = Flight(aircraft_type, count, self.from_cp, self.select_flight_type.currentData())
self.planner.flights.append(flight)
self.planner.custom_flights.append(flight)
if self.flight_view is not None:
self.flight_view.set_flight_planner(self.planner, len(self.planner.flights)-1)
self.close()
def _init_widgets(self):
layout = QGridLayout()
row = 0
validation_failures = set()
# name
name_label = QLabel(self)
name_label.setText("Name")
name_box = QLineEdit(self)
name_box.setText(NameGenerator.random_name())
def handle_name(txt):
nonlocal validation_failures
key = {'name'}
if txt and not any(s.gui_data.name == txt
for s in self.instance.states):
validation_failures -= key
else:
validation_failures |= key
validation_update()
name_box.textEdited.connect(handle_name)
layout.addWidget(name_label, row, 0)
layout.addWidget(name_box, row, 1)
row += 1
# address
address_label = QLabel(self)
address_label.setText("Address")
address_box = QLineEdit(self)
address_box.setText(
hex(self.instance.project.entry
) if self._addr is None else hex(self._addr))
def handle_address(_):
nonlocal validation_failures
key = {'addr'}
if parse_address() is not None:
validation_failures -= key
else:
validation_failures |= key
validation_update()
def parse_address():
txt = address_box.text()
try:
return self.instance.project.kb.labels.lookup(txt)
except KeyError:
pass
try:
return int(txt, 16)
except ValueError:
return None
address_box.textEdited.connect(handle_address)
layout.addWidget(address_label, row, 0)
layout.addWidget(address_box, row, 1)
row += 1
# template
template_label = QLabel(self)
template_label.setText("Template")
template_combo = QComboBox()
template_combo.addItem("Blank State", 'blank')
template_combo.addItem("Call state", 'call')
template_combo.addItem("Entry state", 'entry')
template_combo.addItem("Full-init state", 'full')
def handle_template(_):
base_allowed = template_combo.currentData() in ('blank', 'call')
base_state_combo.setHidden(not base_allowed)
base_state_label.setHidden(not base_allowed)
template_combo.currentIndexChanged.connect(handle_template)
layout.addWidget(template_label, row, 0)
layout.addWidget(template_combo, row, 1)
row += 1
# base state
base_state_label = QLabel(self)
base_state_label.setText('Base state')
base_state_combo = QStateComboBox(self.instance, self)
self._base_state_combo = base_state_combo
layout.addWidget(base_state_label, row, 0)
layout.addWidget(base_state_combo, row, 1)
row += 1
# mode
mode_label = QLabel(self)
mode_label.setText("Mode")
mode_combo = QComboBox(self)
mode_combo.addItem("Symbolic", "symbolic")
mode_combo.addItem("Static", "static")
mode_combo.addItem("Fast-path", "fastpath")
mode_combo.addItem("Tracing", "tracing")
self._mode_combo = mode_combo
def mode_changed():
self._options.clear()
self._options.update(
angr.sim_options.modes[mode_combo.currentData()])
for child in children_items:
child.setCheckState(
0, Qt.Checked
if child.text(0) in self._options else Qt.Unchecked)
mode_combo.currentIndexChanged.connect(mode_changed)
self._options.clear()
self._options.update(angr.sim_options.modes[mode_combo.currentData()])
layout.addWidget(mode_label, row, 0)
layout.addWidget(mode_combo, row, 1)
row += 1
# options tree
options_label = QLabel(self)
options_label.setText("Options")
options_tree = QTreeWidget(self)
options_tree.setHeaderHidden(True)
children_items = []
for name, members in angr.sim_options.__dict__.items():
if type(members) is not set:
continue
if name == 'resilience_options':
continue
parent = QTreeWidgetItem(options_tree)
parent.setText(0, name)
parent.setFlags(parent.flags() | Qt.ItemIsTristate
| Qt.ItemIsUserCheckable)
for option in members:
child = QTreeWidgetItem(parent)
child.setText(0, option)
child.setFlags(child.flags() | Qt.ItemIsUserCheckable)
child.setCheckState(
0, Qt.Checked if option in self._options else Qt.Unchecked)
children_items.append(child)
parent = QTreeWidgetItem(options_tree)
parent.setText(0, "All options")
parent.setFlags(parent.flags() | Qt.ItemIsTristate
| Qt.ItemIsUserCheckable)
for option in {
x
for x in angr.sim_options.__dict__.values()
if type(x) is str and is_option(x)
}:
child = QTreeWidgetItem(parent)
child.setText(0, option)
child.setFlags(child.flags() | Qt.ItemIsUserCheckable)
child.setCheckState(
0, Qt.Checked if option in self._options else Qt.Unchecked)
children_items.append(child)
def maintain_model(item: QTreeWidgetItem, _):
option = item.text(0)
if not is_option(option):
return
checked = item.checkState(0)
if (option in self._options) == checked:
return
if checked:
self._options.add(option)
else:
self._options.remove(option)
for child in children_items:
if child is not item and child.text(0) == option:
child.setCheckState(0, checked)
options_tree.itemChanged.connect(maintain_model)
layout.addWidget(options_label, row, 0)
layout.addWidget(options_tree, row, 1)
row += 1
# options filter
options_filter_label = QLabel(self)
options_filter_label.setText("")
options_filter_box = QLineEdit(self)
options_filter_box.setPlaceholderText("Filter")
def do_filter(text):
for child in children_items:
child.setHidden(text.upper() not in child.text(0))
options_filter_box.textEdited.connect(do_filter)
layout.addWidget(options_filter_label, row, 0)
layout.addWidget(options_filter_box, row, 1)
row += 1
# buttons
ok_button = QPushButton(self)
ok_button.setText('OK')
def do_ok():
name = name_box.text()
template = template_combo.currentData()
addr = parse_address()
base_state = base_state_combo.state
mode = mode_combo.currentData()
if template in ('blank', 'call') and base_state is not None:
if template == 'blank':
self.state = self.instance.project.factory.blank_state(
addr=addr,
base_state=base_state,
options=self._options)
else:
self.state = self.instance.project.factory.call_state(
addr, base_state=base_state, options=self._options)
self.state.gui_data.base_name = base_state.gui_data.name
else:
if template == 'blank':
self.state = self.instance.project.factory.blank_state(
addr=addr, mode=mode, options=self._options)
elif template == 'call':
self.state = self.instance.project.factory.call_state(
addr, mode=mode, options=self._options)
elif template == 'entry':
self.state = self.instance.project.factory.entry_state(
mode=mode, options=self._options)
else:
self.state = self.instance.project.factory.full_init_state(
mode=mode, options=self._options)
self.state.gui_data.base_name = name
self.state.gui_data.is_base = True
self.state.gui_data.name = name
self.state.gui_data.is_original = True
if self._create_simgr:
self.instance.workspace.create_simulation_manager(
self.state, name)
self.close()
ok_button.clicked.connect(do_ok)
def validation_update():
ok_button.setDisabled(bool(validation_failures))
cancel_button = QPushButton(self)
cancel_button.setText('Cancel')
def do_cancel():
self.close()
cancel_button.clicked.connect(do_cancel)
buttons_layout = QHBoxLayout()
buttons_layout.addWidget(ok_button)
buttons_layout.addWidget(cancel_button)
self.main_layout.addLayout(layout)
self.main_layout.addLayout(buttons_layout)
class WidgetConfig(QGroupBox):
def __init__(self):
super(WidgetConfig, self).__init__()
HEIGHT = 40
grid = QGridLayout()
# 使用默认摄像头复选框
self.check_camera = QCheckBox('Use default camera')
self.check_camera.setChecked(False)
self.check_camera.stateChanged.connect(self.slot_check_camera)
grid.addWidget(self.check_camera, 0, 0, 1, 3) # 一行三列
# 选择视频文件
label_video = QLabel('Detect File')
self.line_video = QLineEdit()
if 'video' in GLOBAL.config:
self.line_video.setText(GLOBAL.config['video'])
self.line_video.setFixedHeight(HEIGHT)
self.line_video.setEnabled(False)
self.line_video.editingFinished.connect(
lambda: GLOBAL.record_config({'video': self.line_video.text()}))
self.btn_video = QPushButton('Choose')
self.btn_video.setFixedHeight(HEIGHT)
self.btn_video.setEnabled(False)
self.btn_video.clicked.connect(self.choose_video_file)
self.slot_check_camera()
grid.addWidget(label_video, 1, 0)
grid.addWidget(self.line_video, 1, 1)
grid.addWidget(self.btn_video, 1, 2)
# 选择权重文件
label_weights = QLabel('Weights File')
self.line_weights = QLineEdit()
if 'weights' in GLOBAL.config:
self.line_weights.setText(GLOBAL.config['weights'])
self.line_weights.setFixedHeight(HEIGHT)
self.line_weights.editingFinished.connect(lambda: GLOBAL.record_config(
{'weights': self.line_weights.text()}))
self.btn_weights = QPushButton('Choose')
self.btn_weights.setFixedHeight(HEIGHT)
self.btn_weights.clicked.connect(self.choose_weights_file)
grid.addWidget(label_weights, 2, 0)
grid.addWidget(self.line_weights, 2, 1)
grid.addWidget(self.btn_weights, 2, 2)
# 是否使用GPU
label_device = QLabel('CUDA device')
self.line_device = QLineEdit('gpu')
if 'device' in GLOBAL.config:
self.line_device.setText(GLOBAL.config['device'])
else:
self.line_device.setText('cpu')
self.line_device.setPlaceholderText('cpu or 0 or 0,1,2,3')
self.line_device.setFixedHeight(HEIGHT)
self.line_device.editingFinished.connect(
lambda: GLOBAL.record_config({'device': self.line_device.text()}))
grid.addWidget(label_device, 3, 0)
grid.addWidget(self.line_device, 3, 1, 1, 2)
# 设置图像大小
label_size = QLabel('Img Size')
self.combo_size = QComboBox()
self.combo_size.setFixedHeight(HEIGHT)
self.combo_size.setStyleSheet(
'QAbstractItemView::item {height: 40px;}')
self.combo_size.setView(QListView())
self.combo_size.addItem('320', 320)
self.combo_size.addItem('416', 416)
self.combo_size.addItem('480', 480)
self.combo_size.addItem('544', 544)
self.combo_size.addItem('640', 640)
self.combo_size.setCurrentIndex(2)
self.combo_size.currentIndexChanged.connect(
lambda: GLOBAL.record_config(
{'img_size': self.combo_size.currentData()}))
grid.addWidget(label_size, 4, 0)
grid.addWidget(self.combo_size, 4, 1, 1, 2)
#choose net camera
label_stream = QLabel('NetVedioStream')
self.combo_stream = QComboBox()
self.combo_stream.setFixedHeight(HEIGHT)
self.combo_stream.setStyleSheet(
'QAbstractItemView::item {height: 40px;}')
self.combo_stream.setView(QListView())
self.combo_stream.addItem('rtsp://*****:*****@192.168.0.65/',
'rtsp://*****:*****@192.168.0.65/')
self.combo_stream.addItem('rtsp://*****:*****@192.168.0.66/',
'rtsp://*****:*****@192.168.0.66/')
self.combo_stream.addItem('rtsp://*****:*****@192.168.0.67/',
'rtsp://*****:*****@192.168.0.67/')
self.combo_stream.addItem('rtsp://*****:*****@192.168.0.68/',
'rtsp://*****:*****@192.168.0.68/')
self.combo_stream.addItem('rtsp://*****:*****@192.168.0.65/',
'rtsp://*****:*****@192.168.0.65/')
self.combo_stream.setCurrentIndex(0)
self.combo_stream.currentIndexChanged.connect(
lambda: GLOBAL.record_config(
{'netstreamvedio': self.combo_stream.currentData()}))
grid.addWidget(label_stream, 5, 0)
grid.addWidget(self.combo_stream, 5, 1, 1, 2)
# 设置置信度阈值
label_conf = QLabel('Confidence')
self.spin_conf = QDoubleSpinBox()
self.spin_conf.setFixedHeight(HEIGHT)
self.spin_conf.setDecimals(1)
self.spin_conf.setRange(0.1, 0.9)
self.spin_conf.setSingleStep(0.1)
if 'conf_thresh' in GLOBAL.config:
self.spin_conf.setValue(GLOBAL.config['conf_thresh'])
else:
self.spin_conf.setValue(0.4) # 默认值
GLOBAL.record_config({'conf_thresh': 0.4})
self.spin_conf.valueChanged.connect(lambda: GLOBAL.record_config(
{'conf_thresh': round(self.spin_conf.value(), 1)}))
grid.addWidget(label_conf, 6, 0)
grid.addWidget(self.spin_conf, 6, 1, 1, 2)
# 设置IOU阈值
label_iou = QLabel('IOU')
self.spin_iou = QDoubleSpinBox()
self.spin_iou.setFixedHeight(HEIGHT)
self.spin_iou.setDecimals(1)
self.spin_iou.setRange(0.1, 0.9)
self.spin_iou.setSingleStep(0.1)
if 'iou_thresh' in GLOBAL.config:
self.spin_iou.setValue(GLOBAL.config['iou_thresh'])
else:
self.spin_iou.setValue(0.5) # 默认值
GLOBAL.record_config({'iou_thresh': 0.5})
self.spin_iou.valueChanged.connect(lambda: GLOBAL.record_config(
{'iou_thresh': round(self.spin_iou.value(), 1)}))
grid.addWidget(label_iou, 7, 0)
grid.addWidget(self.spin_iou, 7, 1, 1, 2)
# class-agnostic NMS
self.check_agnostic = QCheckBox('Agnostic')
if 'agnostic' in GLOBAL.config:
self.check_agnostic.setChecked(GLOBAL.config['agnostic'])
else:
self.check_agnostic.setChecked(True)
self.check_agnostic.stateChanged.connect(lambda: GLOBAL.record_config(
{'agnostic': self.check_agnostic.isChecked()}))
grid.addWidget(self.check_agnostic, 8, 0, 1, 3) # 一行三列
# augmented inference
self.check_augment = QCheckBox('Augment')
if 'augment' in GLOBAL.config:
self.check_augment.setChecked(GLOBAL.config['augment'])
else:
self.check_augment.setChecked(True)
self.check_augment.stateChanged.connect(lambda: GLOBAL.record_config(
{'augment': self.check_augment.isChecked()}))
grid.addWidget(self.check_augment, 9, 0, 1, 3) # 一行三列
self.setLayout(grid) # 设置布局
def slot_check_camera(self):
check = self.check_camera.isChecked()
GLOBAL.record_config({'use_camera': check}) # 保存配置
if check:
self.line_video.setEnabled(False)
self.btn_video.setEnabled(False)
else:
self.line_video.setEnabled(True)
self.btn_video.setEnabled(True)
def choose_weights_file(self):
"""从系统中选择权重文件"""
file = QFileDialog.getOpenFileName(
self, "Pre-trained YOLOv5 Weights", "./",
"Weights Files (*.pt);;All Files (*)")
if file[0] != '':
self.line_weights.setText(file[0])
GLOBAL.record_config({'weights': file[0]})
def choose_video_file(self):
"""从系统中选择视频文件"""
file = QFileDialog.getOpenFileName(self, "Video Files", "./",
"Video Files (*)")
if file[0] != '':
self.line_video.setText(file[0])
GLOBAL.record_config({'video': file[0]})
def save_config(self):
"""保存当前的配置到配置文件"""
config = {
'use_camera': self.check_camera.isChecked(),
'video': self.line_video.text(),
'weights': self.line_weights.text(),
'device': self.line_device.text(),
'img_size': self.combo_size.currentData(),
'conf_thresh': round(self.spin_conf.value(), 1),
'iou_thresh': round(self.spin_iou.value(), 1),
'agnostic': self.check_agnostic.isChecked(),
'augment': self.check_augment.isChecked(),
'netstreamvedio': self.combo_stream.currentData()
}
GLOBAL.record_config(config)
def _on_gate_combo_box_changed(self, combo: QComboBox, new_index: int):
with self._editor as editor:
editor.set_configuration_field(
"translator_configuration",
editor.configuration.translator_configuration.
replace_requirement_for_gate(combo.gate, combo.currentData()))
class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
# 设置时间
self.__time = QDateTime()
# 创建图形界面
self.__SetupUI()
self.__ConfigureFileToolBar()
self.__ConfigureTranslateToolBar()
self.__ConfigureMainLayout()
# 设置ComboBox的显示内容
self.__ConfigureComboBox()
# 设置保存文件的信息
self.__currentPath = QDir.currentPath()
self.__ConfigureSysIniFile()
self.__ConfigureHistoryFile()
salt = random.randint(1466000000, 1467000000)
self.__salt = str(salt)
self.__httpClient = None
self.__statusBar.showMessage(
self.__GetCurrentTime() + " - Please choose a file or enter data!",
2000)
self.show()
def __del__(self):
self.__historyFile.close()
def __SetupUI(self):
self.__mainWidget = QWidget()
self.setCentralWidget(self.__mainWidget)
self.__fileToolBar = QToolBar("File")
self.addToolBar(self.__fileToolBar)
self.__translateToolBar = QToolBar("Translate")
self.addToolBar(self.__translateToolBar)
self.__statusBar = QStatusBar()
self.setStatusBar(self.__statusBar)
self.setWindowIcon(QIcon("./image/translate.png"))
def __ConfigureFileToolBar(self):
self.__openFileAction = QAction(QIcon("./image/open.png"), "Open File")
self.__fileToolBar.addAction(self.__openFileAction)
self.__openFileAction.triggered.connect(
self.__on_triggered_openFileAction)
self.__saveFileAction = QAction(QIcon("./image/save.png"), "Save File")
self.__fileToolBar.addAction(self.__saveFileAction)
self.__saveFileAction.triggered.connect(
self.__on_triggered_saveFileAction)
def __ConfigureTranslateToolBar(self):
self.__translateAction = QAction(QIcon("./image/translate.png"),
"Translate")
self.__translateToolBar.addAction(self.__translateAction)
self.__translateAction.triggered.connect(
self.__on_triggered_translateAction)
self.__clearAction = QAction(QIcon("./image/clear.png"), "Clear")
self.__translateToolBar.addAction(self.__clearAction)
self.__clearAction.triggered.connect(self.__on_triggered_clearAction)
def __ConfigureMainLayout(self):
self.__appIDLabel = QLabel("AppID:")
self.__appIDLineEdit = QLineEdit(self)
self.__appIDLineEdit.returnPressed.connect(
self.__on_returnPressed_appIDLineEdit)
self.__keyLabel = QLabel("Key:")
self.__keyLineEdit = QLineEdit(self)
self.__keyLineEdit.returnPressed.connect(
self.__on_returnPressed_keyLineEdit)
self.__fromLabel = QLabel("From:")
self.__fromComboBox = QComboBox(self)
self.__toLabel = QLabel("To:")
self.__toComboBox = QComboBox(self)
self.__srcLabel = QLabel("Src Text:")
self.__srcTextEdit = QTextEdit(self)
self.__translateLabel = QLabel("Translate Text:")
self.__translateTextEdit = QTextEdit(self)
self.__mainLayout = QGridLayout()
self.__mainLayout.addWidget(self.__appIDLabel, 0, 0)
self.__mainLayout.addWidget(self.__appIDLineEdit, 0, 1, 1, 3)
self.__mainLayout.addWidget(self.__keyLabel, 1, 0)
self.__mainLayout.addWidget(self.__keyLineEdit, 1, 1, 1, 3)
self.__mainLayout.addWidget(self.__fromLabel, 2, 0)
self.__mainLayout.addWidget(self.__fromComboBox, 2, 1)
self.__mainLayout.addWidget(self.__toLabel, 2, 2)
self.__mainLayout.addWidget(self.__toComboBox, 2, 3)
self.__mainLayout.addWidget(self.__srcLabel, 3, 0)
self.__mainLayout.addWidget(self.__srcTextEdit, 3, 1, 1, 3)
self.__mainLayout.addWidget(self.__translateLabel, 4, 0)
self.__mainLayout.addWidget(self.__translateTextEdit, 4, 1, 1, 3)
self.__mainWidget.setLayout(self.__mainLayout)
def __ConfigureComboBox(self):
self.__fromComboBox.clear()
self.__fromComboBox.addItem("English", "en")
self.__fromComboBox.addItem("Chinese", "zh")
self.__fromComboBox.addItem("Auto", "auto")
self.__fromComboBox.setCurrentIndex(2)
self.__toComboBox.clear()
self.__toComboBox.addItem("English", "en")
self.__toComboBox.addItem("Chinese", "zh")
self.__toComboBox.setCurrentIndex(1)
def __ConfigureSysIniFile(self):
iniFile = QFile("info.ini")
if iniFile.exists():
self.__infoSettings = QSettings("info.ini", QSettings.IniFormat)
self.__appIDLineEdit.setText(
self.__infoSettings.value("info/appid"))
self.__keyLineEdit.setText(self.__infoSettings.value("info/key"))
else:
if iniFile.open(QFile.ReadWrite):
self.__infoSettings = QSettings("info.ini",
QSettings.IniFormat)
self.__infoSettings.beginGroup("info")
self.__infoSettings.setValue("appid", "00000000000000000")
self.__infoSettings.setValue("key", "00000000000000000")
self.__infoSettings.endGroup()
iniFile.close()
self.__appIDLineEdit.setText("00000000000000000")
self.__keyLineEdit.setText("00000000000000000")
def __ConfigureHistoryFile(self):
self.__historyFile = QFile("history.txt")
if self.__historyFile.open(QFile.ReadWrite or QFile.Append):
self.__historyFileStream = QTextStream(self.__historyFile)
else:
self.__statusBar.showMessage(
self.__GetCurrentTime() + " - History fie create failed!",
2000)
def __GetCurrentTime(self, format="hh:mm:ss"):
return self.__time.currentDateTime().toString(format)
def __GetSign(self, srcData, appid, key):
sign = appid + srcData + self.__salt + key
mymd5 = hashlib.md5(sign.encode()).hexdigest()
return mymd5
def __on_triggered_openFileAction(self):
filePath = QFileDialog.getOpenFileName(self, "open",
self.__currentPath, "* txt")
if filePath[0].strip():
file = QFile(filePath[0])
if file.open(QFile.ReadOnly):
readData = str(file.readAll())
fileData = readData[2:readData.__len__() - 1].replace(
r"\r\n", r" ")
self.__srcTextEdit.insertPlainText(fileData)
else:
self.__statusBar.showMessage(
self.__GetCurrentTime() + " - open file failed!", 2000)
else:
self.__statusBar.showMessage(
self.__GetCurrentTime() + " - Choose file failed!", 2000)
return
def __on_triggered_saveFileAction(self):
self.__historyFile.close()
self.__historyFile.open(QFile.ReadWrite or QFile.Append)
self.__statusBar.showMessage(
self.__GetCurrentTime() + " - Save file successful!", 2000)
def __on_triggered_translateAction(self):
srcData = self.__srcTextEdit.toPlainText()
if srcData.strip():
self.__translateTextEdit.clear()
self.__translateTextEdit.document().clear()
dstData = srcData.replace("\n", " ")
else:
self.__statusBar.showMessage(
self.__GetCurrentTime() + " - There is no data!", 2000)
return
myurl = "/api/trans/vip/translate"
appid = self.__appIDLineEdit.text()
key = self.__keyLineEdit.text()
strFrom = self.__fromComboBox.currentData()
strTo = self.__toComboBox.currentData()
mymd5 = self.__GetSign(dstData, appid, key)
myurl = myurl + "?appid=" + appid + "&q=" + urllib.parse.quote(
srcData
) + "&from=" + strFrom + "&to=" + strTo + "&salt=" + self.__salt + "&sign=" + mymd5
httpClient = http.client.HTTPConnection("api.fanyi.baidu.com")
httpClient.request("GET", myurl)
response = httpClient.getresponse()
jsonResponse = response.read().decode("utf-8")
js = json.loads(jsonResponse)
translate = str(js["trans_result"][0]["dst"])
self.__translateTextEdit.insertPlainText(translate)
self.__historyFileStream << translate + "\r\n"
self.__statusBar.showMessage(
self.__GetCurrentTime() + " - Translate successful!", 2000)
def __on_triggered_clearAction(self):
self.__srcTextEdit.clear()
self.__translateTextEdit.clear()
self.__statusBar.showMessage(
self.__GetCurrentTime() + " - Clear successful!", 2000)
def __on_returnPressed_appIDLineEdit(self):
appid = self.__appIDLineEdit.text()
if not appid.strip():
self.__statusBar.showMessage(
self.__GetCurrentTime() + " - There is no appid!", 2000)
return
self.__infoSettings.beginGroup("info")
self.__infoSettings.setValue("appid", appid)
self.__infoSettings.endGroup()
self.__statusBar.showMessage(
self.__GetCurrentTime() + " - Enter appid successful!", 2000)
def __on_returnPressed_keyLineEdit(self):
key = self.__keyLineEdit.text()
if not key.strip():
self.__statusBar.showMessage(
self.__GetCurrentTime() + " - There is no key!", 2000)
return
self.__infoSettings.beginGroup("info")
self.__infoSettings.setValue("key", key)
self.__infoSettings.endGroup()
self.__statusBar.showMessage(
self.__GetCurrentTime() + " - Enter key successful!", 2000)
class ItemRow:
def __init__(self, parent: QWidget, parent_layout: QVBoxLayout,
resource_database: ResourceDatabase,
item: ResourceRequirement, rows: List["ItemRow"]):
self.parent = parent
self.resource_database = resource_database
self._rows = rows
rows.append(self)
self.layout = QHBoxLayout()
self.layout.setObjectName(f"Box layout for {item.resource.long_name}")
parent_layout.addLayout(self.layout)
self.resource_type_combo = _create_resource_type_combo(
item.resource.resource_type, parent)
self.resource_type_combo.setMinimumWidth(75)
self.resource_type_combo.setMaximumWidth(75)
self.resource_name_combo = _create_resource_name_combo(
self.resource_database, item.resource.resource_type, item.resource,
self.parent)
self.negate_combo = QComboBox(parent)
self.negate_combo.addItem("≥", False)
self.negate_combo.addItem("<", True)
self.negate_combo.setCurrentIndex(int(item.negate))
self.negate_combo.setMinimumWidth(40)
self.negate_combo.setMaximumWidth(40)
self.amount_edit = QLineEdit(parent)
self.amount_edit.setValidator(QIntValidator(1, 10000))
self.amount_edit.setText(str(item.amount))
self.amount_edit.setMinimumWidth(45)
self.amount_edit.setMaximumWidth(45)
self.remove_button = QPushButton(parent)
self.remove_button.setText("X")
self.remove_button.setMaximumWidth(20)
self.layout.addWidget(self.resource_type_combo)
self.layout.addWidget(self.resource_name_combo)
self.layout.addWidget(self.negate_combo)
self.layout.addWidget(self.amount_edit)
self.layout.addWidget(self.remove_button)
self.resource_type_combo.currentIndexChanged.connect(self._update_type)
self.remove_button.clicked.connect(self._delete_row)
def _update_type(self):
old_combo = self.resource_name_combo
self.resource_name_combo = _create_resource_name_combo(
self.resource_database, self.resource_type_combo.currentData(),
None, self.parent)
self.layout.replaceWidget(old_combo, self.resource_name_combo)
old_combo.deleteLater()
def _delete_row(self):
self.resource_type_combo.deleteLater()
self.resource_name_combo.deleteLater()
self.negate_combo.deleteLater()
self.amount_edit.deleteLater()
self.remove_button.deleteLater()
self.layout.deleteLater()
self._rows.remove(self)
@property
def current_individual(self) -> ResourceRequirement:
return ResourceRequirement(self.resource_name_combo.currentData(),
int(self.amount_edit.text()),
self.negate_combo.currentData())
class RequirementEditor:
_editor: Union[None, ResourceRequirementEditor, ArrayRequirementEditor,
TemplateRequirementEditor]
def __init__(self,
parent: QWidget,
parent_layout: QVBoxLayout,
resource_database: ResourceDatabase,
*,
on_remove=None):
self.parent = parent
self.parent_layout = parent_layout
self.resource_database = resource_database
self._editor = None
self._last_resource = None
self._last_items = ()
self.line_layout = QHBoxLayout()
self.line_layout.setAlignment(Qt.AlignLeft)
self.parent_layout.addLayout(self.line_layout)
if on_remove is not None:
self.remove_button = QtWidgets.QToolButton(parent)
self.remove_button.setText("X")
self.remove_button.setMaximumWidth(20)
self.remove_button.clicked.connect(on_remove)
self.line_layout.addWidget(self.remove_button)
else:
self.remove_button = None
self.requirement_type_combo = QComboBox(parent)
self.requirement_type_combo.addItem("Resource", ResourceRequirement)
self.requirement_type_combo.addItem("Or", RequirementOr)
self.requirement_type_combo.addItem("And", RequirementAnd)
if resource_database.requirement_template:
self.requirement_type_combo.addItem("Template",
RequirementTemplate)
self.requirement_type_combo.setMaximumWidth(75)
self.requirement_type_combo.activated.connect(
self._on_change_requirement_type)
self.line_layout.addWidget(self.requirement_type_combo)
def create_specialized_editor(self, requirement: Requirement):
self.requirement_type_combo.setCurrentIndex(
self.requirement_type_combo.findData(type(requirement)))
if isinstance(requirement, ResourceRequirement):
self._editor = ResourceRequirementEditor(self.parent,
self.line_layout,
self.resource_database,
requirement)
elif isinstance(requirement, (RequirementOr, RequirementAnd)):
self._editor = ArrayRequirementEditor(self.parent,
self.parent_layout,
self.resource_database,
requirement)
elif isinstance(requirement, RequirementTemplate):
self._editor = TemplateRequirementEditor(self.parent,
self.line_layout,
self.resource_database,
requirement)
else:
raise RuntimeError(
f"Unknown requirement type: {type(requirement)} - {requirement}"
)
def _on_change_requirement_type(self):
current_requirement = self.current_requirement
self._editor.deleteLater()
if isinstance(current_requirement, ResourceRequirement):
self._last_resource = current_requirement
elif isinstance(current_requirement, (RequirementOr, RequirementAnd)):
self._last_items = current_requirement.items
elif isinstance(current_requirement, RequirementTemplate):
pass
else:
raise RuntimeError(
f"Unknown requirement type: {type(current_requirement)} - {current_requirement}"
)
new_class = self.requirement_type_combo.currentData()
if new_class == ResourceRequirement:
if self._last_resource is None:
new_requirement = _create_default_resource_requirement(
self.resource_database)
else:
new_requirement = self._last_resource
elif new_class == RequirementTemplate:
new_requirement = _create_default_template_requirement(
self.resource_database)
else:
new_requirement = new_class(self._last_items)
self.create_specialized_editor(new_requirement)
def deleteLater(self):
if self.remove_button is not None:
self.remove_button.deleteLater()
self.requirement_type_combo.deleteLater()
if self._editor is not None:
self._editor.deleteLater()
@property
def current_requirement(self) -> Requirement:
return self._editor.current_requirement
class QSettingsWindow(QDialog):
def __init__(self, game: Game):
super(QSettingsWindow, self).__init__()
self.game = game
self.pluginsPage = None
self.pluginsOptionsPage = None
self.campaign_management_page = QWidget()
self.setModal(True)
self.setWindowTitle("Settings")
self.setWindowIcon(CONST.ICONS["Settings"])
self.setMinimumSize(600, 250)
self.initUi()
def initUi(self):
self.layout = QGridLayout()
self.categoryList = QListView()
self.right_layout = QStackedLayout()
self.categoryList.setMaximumWidth(175)
self.categoryModel = QStandardItemModel(self.categoryList)
self.categoryList.setIconSize(QSize(32, 32))
self.initDifficultyLayout()
difficulty = QStandardItem("Difficulty")
difficulty.setIcon(CONST.ICONS["Missile"])
difficulty.setEditable(False)
difficulty.setSelectable(True)
self.categoryModel.appendRow(difficulty)
self.right_layout.addWidget(self.difficultyPage)
self.init_campaign_management_layout()
campaign_management = QStandardItem("Campaign Management")
campaign_management.setIcon(CONST.ICONS["Money"])
campaign_management.setEditable(False)
campaign_management.setSelectable(True)
self.categoryModel.appendRow(campaign_management)
self.right_layout.addWidget(self.campaign_management_page)
self.initGeneratorLayout()
generator = QStandardItem("Mission Generator")
generator.setIcon(CONST.ICONS["Generator"])
generator.setEditable(False)
generator.setSelectable(True)
self.categoryModel.appendRow(generator)
self.right_layout.addWidget(self.generatorPage)
self.initCheatLayout()
cheat = QStandardItem("Cheat Menu")
cheat.setIcon(CONST.ICONS["Cheat"])
cheat.setEditable(False)
cheat.setSelectable(True)
self.categoryModel.appendRow(cheat)
self.right_layout.addWidget(self.cheatPage)
self.pluginsPage = PluginsPage()
plugins = QStandardItem("LUA Plugins")
plugins.setIcon(CONST.ICONS["Plugins"])
plugins.setEditable(False)
plugins.setSelectable(True)
self.categoryModel.appendRow(plugins)
self.right_layout.addWidget(self.pluginsPage)
self.pluginsOptionsPage = PluginOptionsPage()
pluginsOptions = QStandardItem("LUA Plugins Options")
pluginsOptions.setIcon(CONST.ICONS["PluginsOptions"])
pluginsOptions.setEditable(False)
pluginsOptions.setSelectable(True)
self.categoryModel.appendRow(pluginsOptions)
self.right_layout.addWidget(self.pluginsOptionsPage)
self.categoryList.setSelectionBehavior(QAbstractItemView.SelectRows)
self.categoryList.setModel(self.categoryModel)
self.categoryList.selectionModel().setCurrentIndex(
self.categoryList.indexAt(QPoint(1, 1)),
QItemSelectionModel.Select)
self.categoryList.selectionModel().selectionChanged.connect(
self.onSelectionChanged)
self.layout.addWidget(self.categoryList, 0, 0, 1, 1)
self.layout.addLayout(self.right_layout, 0, 1, 5, 1)
self.setLayout(self.layout)
def init(self):
pass
def initDifficultyLayout(self):
self.difficultyPage = QWidget()
self.difficultyLayout = QVBoxLayout()
self.difficultyLayout.setAlignment(Qt.AlignTop)
self.difficultyPage.setLayout(self.difficultyLayout)
# DCS AI difficulty settings
self.aiDifficultySettings = QGroupBox("AI Difficulty")
self.aiDifficultyLayout = QGridLayout()
self.playerCoalitionSkill = QComboBox()
self.enemyCoalitionSkill = QComboBox()
self.enemyAASkill = QComboBox()
for skill in CONST.SKILL_OPTIONS:
self.playerCoalitionSkill.addItem(skill)
self.enemyCoalitionSkill.addItem(skill)
self.enemyAASkill.addItem(skill)
self.playerCoalitionSkill.setCurrentIndex(
CONST.SKILL_OPTIONS.index(self.game.settings.player_skill))
self.enemyCoalitionSkill.setCurrentIndex(
CONST.SKILL_OPTIONS.index(self.game.settings.enemy_skill))
self.enemyAASkill.setCurrentIndex(
CONST.SKILL_OPTIONS.index(self.game.settings.enemy_vehicle_skill))
self.player_income = TenthsSpinSlider(
"Player income multiplier",
0,
50,
int(self.game.settings.player_income_multiplier * 10),
)
self.player_income.spinner.valueChanged.connect(self.applySettings)
self.enemy_income = TenthsSpinSlider(
"Enemy income multiplier",
0,
50,
int(self.game.settings.enemy_income_multiplier * 10),
)
self.enemy_income.spinner.valueChanged.connect(self.applySettings)
self.playerCoalitionSkill.currentIndexChanged.connect(
self.applySettings)
self.enemyCoalitionSkill.currentIndexChanged.connect(
self.applySettings)
self.enemyAASkill.currentIndexChanged.connect(self.applySettings)
# Mission generation settings related to difficulty
self.missionSettings = QGroupBox("Mission Difficulty")
self.missionLayout = QGridLayout()
self.manpads = QCheckBox()
self.manpads.setChecked(self.game.settings.manpads)
self.manpads.toggled.connect(self.applySettings)
self.noNightMission = QCheckBox()
self.noNightMission.setChecked(self.game.settings.night_disabled)
self.noNightMission.toggled.connect(self.applySettings)
# DCS Mission options
self.missionRestrictionsSettings = QGroupBox("Mission Restrictions")
self.missionRestrictionsLayout = QGridLayout()
self.difficultyLabel = QComboBox()
[self.difficultyLabel.addItem(t) for t in CONST.LABELS_OPTIONS]
self.difficultyLabel.setCurrentIndex(
CONST.LABELS_OPTIONS.index(self.game.settings.labels))
self.difficultyLabel.currentIndexChanged.connect(self.applySettings)
self.mapVisibiitySelection = QComboBox()
self.mapVisibiitySelection.addItem("All", ForcedOptions.Views.All)
if self.game.settings.map_coalition_visibility == ForcedOptions.Views.All:
self.mapVisibiitySelection.setCurrentIndex(0)
self.mapVisibiitySelection.addItem("Fog of War",
ForcedOptions.Views.Allies)
if self.game.settings.map_coalition_visibility == ForcedOptions.Views.Allies:
self.mapVisibiitySelection.setCurrentIndex(1)
self.mapVisibiitySelection.addItem("Allies Only",
ForcedOptions.Views.OnlyAllies)
if (self.game.settings.map_coalition_visibility ==
ForcedOptions.Views.OnlyAllies):
self.mapVisibiitySelection.setCurrentIndex(2)
self.mapVisibiitySelection.addItem("Own Aircraft Only",
ForcedOptions.Views.MyAircraft)
if (self.game.settings.map_coalition_visibility ==
ForcedOptions.Views.MyAircraft):
self.mapVisibiitySelection.setCurrentIndex(3)
self.mapVisibiitySelection.addItem("Map Only",
ForcedOptions.Views.OnlyMap)
if self.game.settings.map_coalition_visibility == ForcedOptions.Views.OnlyMap:
self.mapVisibiitySelection.setCurrentIndex(4)
self.mapVisibiitySelection.currentIndexChanged.connect(
self.applySettings)
self.ext_views = QCheckBox()
self.ext_views.setChecked(self.game.settings.external_views_allowed)
self.ext_views.toggled.connect(self.applySettings)
self.aiDifficultyLayout.addWidget(QLabel("Player coalition skill"), 0,
0)
self.aiDifficultyLayout.addWidget(self.playerCoalitionSkill, 0, 1,
Qt.AlignRight)
self.aiDifficultyLayout.addWidget(QLabel("Enemy coalition skill"), 1,
0)
self.aiDifficultyLayout.addWidget(self.enemyCoalitionSkill, 1, 1,
Qt.AlignRight)
self.aiDifficultyLayout.addWidget(
QLabel("Enemy AA and vehicles skill"), 2, 0)
self.aiDifficultyLayout.addWidget(self.enemyAASkill, 2, 1,
Qt.AlignRight)
self.aiDifficultyLayout.addLayout(self.player_income, 3, 0)
self.aiDifficultyLayout.addLayout(self.enemy_income, 4, 0)
self.aiDifficultySettings.setLayout(self.aiDifficultyLayout)
self.difficultyLayout.addWidget(self.aiDifficultySettings)
self.missionLayout.addWidget(QLabel("Manpads on frontlines"), 0, 0)
self.missionLayout.addWidget(self.manpads, 0, 1, Qt.AlignRight)
self.missionLayout.addWidget(QLabel("No night missions"), 1, 0)
self.missionLayout.addWidget(self.noNightMission, 1, 1, Qt.AlignRight)
self.missionSettings.setLayout(self.missionLayout)
self.difficultyLayout.addWidget(self.missionSettings)
self.missionRestrictionsLayout.addWidget(QLabel("In Game Labels"), 0,
0)
self.missionRestrictionsLayout.addWidget(self.difficultyLabel, 0, 1,
Qt.AlignRight)
self.missionRestrictionsLayout.addWidget(
QLabel("Map visibility options"), 1, 0)
self.missionRestrictionsLayout.addWidget(self.mapVisibiitySelection, 1,
1, Qt.AlignRight)
self.missionRestrictionsLayout.addWidget(
QLabel("Allow external views"), 2, 0)
self.missionRestrictionsLayout.addWidget(self.ext_views, 2, 1,
Qt.AlignRight)
self.missionRestrictionsSettings.setLayout(
self.missionRestrictionsLayout)
self.difficultyLayout.addWidget(self.missionRestrictionsSettings)
def init_campaign_management_layout(self) -> None:
campaign_layout = QVBoxLayout()
campaign_layout.setAlignment(Qt.AlignTop)
self.campaign_management_page.setLayout(campaign_layout)
general = QGroupBox("General")
campaign_layout.addWidget(general)
general_layout = QGridLayout()
general.setLayout(general_layout)
def set_restict_weapons_by_date(value: bool) -> None:
self.game.settings.restrict_weapons_by_date = value
restrict_weapons = QCheckBox()
restrict_weapons.setChecked(
self.game.settings.restrict_weapons_by_date)
restrict_weapons.toggled.connect(set_restict_weapons_by_date)
tooltip_text = (
"Restricts weapon availability based on the campaign date. Data is "
"extremely incomplete so does not affect all weapons.")
restrict_weapons.setToolTip(tooltip_text)
restrict_weapons_label = QLabel("Restrict weapons by date (WIP)")
restrict_weapons_label.setToolTip(tooltip_text)
general_layout.addWidget(restrict_weapons_label, 0, 0)
general_layout.addWidget(restrict_weapons, 0, 1, Qt.AlignRight)
def set_old_awec(value: bool) -> None:
self.game.settings.disable_legacy_aewc = value
old_awac = QCheckBox()
old_awac.setChecked(self.game.settings.disable_legacy_aewc)
old_awac.toggled.connect(set_old_awec)
old_awec_info = (
"If checked, the invulnerable friendly AEW&C aircraft that begins "
"the mission in the air will not be spawned. AEW&C missions must "
"be planned in the ATO and will take time to arrive on-station.")
old_awac.setToolTip(old_awec_info)
old_awac_label = QLabel(
"Disable invulnerable, always-available AEW&C (WIP)")
old_awac_label.setToolTip(old_awec_info)
general_layout.addWidget(old_awac_label, 1, 0)
general_layout.addWidget(old_awac, 1, 1, Qt.AlignRight)
automation = QGroupBox("HQ Automation")
campaign_layout.addWidget(automation)
automation_layout = QGridLayout()
automation.setLayout(automation_layout)
def set_runway_automation(value: bool) -> None:
self.game.settings.automate_runway_repair = value
def set_front_line_automation(value: bool) -> None:
self.game.settings.automate_front_line_reinforcements = value
def set_aircraft_automation(value: bool) -> None:
self.game.settings.automate_aircraft_reinforcements = value
runway_repair = QCheckBox()
runway_repair.setChecked(self.game.settings.automate_runway_repair)
runway_repair.toggled.connect(set_runway_automation)
automation_layout.addWidget(QLabel("Automate runway repairs"), 0, 0)
automation_layout.addWidget(runway_repair, 0, 1, Qt.AlignRight)
front_line = QCheckBox()
front_line.setChecked(
self.game.settings.automate_front_line_reinforcements)
front_line.toggled.connect(set_front_line_automation)
automation_layout.addWidget(QLabel("Automate front-line purchases"), 1,
0)
automation_layout.addWidget(front_line, 1, 1, Qt.AlignRight)
aircraft = QCheckBox()
aircraft.setChecked(
self.game.settings.automate_aircraft_reinforcements)
aircraft.toggled.connect(set_aircraft_automation)
automation_layout.addWidget(QLabel("Automate aircraft purchases"), 2,
0)
automation_layout.addWidget(aircraft, 2, 1, Qt.AlignRight)
def initGeneratorLayout(self):
self.generatorPage = QWidget()
self.generatorLayout = QVBoxLayout()
self.generatorLayout.setAlignment(Qt.AlignTop)
self.generatorPage.setLayout(self.generatorLayout)
self.gameplay = QGroupBox("Gameplay")
self.gameplayLayout = QGridLayout()
self.gameplayLayout.setAlignment(Qt.AlignTop)
self.gameplay.setLayout(self.gameplayLayout)
self.supercarrier = QCheckBox()
self.supercarrier.setChecked(self.game.settings.supercarrier)
self.supercarrier.toggled.connect(self.applySettings)
self.generate_marks = QCheckBox()
self.generate_marks.setChecked(self.game.settings.generate_marks)
self.generate_marks.toggled.connect(self.applySettings)
self.generate_dark_kneeboard = QCheckBox()
self.generate_dark_kneeboard.setChecked(
self.game.settings.generate_dark_kneeboard)
self.generate_dark_kneeboard.toggled.connect(self.applySettings)
self.never_delay_players = QCheckBox()
self.never_delay_players.setChecked(
self.game.settings.never_delay_player_flights)
self.never_delay_players.toggled.connect(self.applySettings)
self.never_delay_players.setToolTip(
"When checked, player flights with a delayed start time will be "
"spawned immediately. AI wingmen may begin startup immediately.")
self.gameplayLayout.addWidget(QLabel("Use Supercarrier Module"), 0, 0)
self.gameplayLayout.addWidget(self.supercarrier, 0, 1, Qt.AlignRight)
self.gameplayLayout.addWidget(QLabel("Put Objective Markers on Map"),
1, 0)
self.gameplayLayout.addWidget(self.generate_marks, 1, 1, Qt.AlignRight)
dark_kneeboard_label = QLabel(
"Generate Dark Kneeboard <br />"
"<strong>Dark kneeboard for night missions.<br />"
"This will likely make the kneeboard on the pilot leg unreadable.</strong>"
)
self.gameplayLayout.addWidget(dark_kneeboard_label, 2, 0)
self.gameplayLayout.addWidget(self.generate_dark_kneeboard, 2, 1,
Qt.AlignRight)
spawn_players_immediately_tooltip = (
"Always spawns player aircraft immediately, even if their start time is "
"more than 10 minutes after the start of the mission. <strong>This does "
"not alter the timing of your mission. Your TOT will not change. This "
"option only allows the player to wait on the ground.</strong>")
spawn_immediately_label = QLabel(
"Player flights ignore TOT and spawn immediately<br />"
"<strong>Does not adjust package waypoint times.<br />"
"Should not be used if players have runway or in-air starts.</strong>"
)
spawn_immediately_label.setToolTip(spawn_players_immediately_tooltip)
self.gameplayLayout.addWidget(spawn_immediately_label, 3, 0)
self.gameplayLayout.addWidget(self.never_delay_players, 3, 1,
Qt.AlignRight)
start_type_label = QLabel(
"Default start type for AI aircraft<br /><strong>Warning: "
"Any option other than Cold breaks OCA/Aircraft missions.</strong>"
)
start_type_label.setToolTip(START_TYPE_TOOLTIP)
start_type = StartTypeComboBox(self.game.settings)
start_type.setCurrentText(self.game.settings.default_start_type)
self.gameplayLayout.addWidget(start_type_label, 4, 0)
self.gameplayLayout.addWidget(start_type, 4, 1)
self.performance = QGroupBox("Performance")
self.performanceLayout = QGridLayout()
self.performanceLayout.setAlignment(Qt.AlignTop)
self.performance.setLayout(self.performanceLayout)
self.smoke = QCheckBox()
self.smoke.setChecked(self.game.settings.perf_smoke_gen)
self.smoke.toggled.connect(self.applySettings)
self.red_alert = QCheckBox()
self.red_alert.setChecked(self.game.settings.perf_red_alert_state)
self.red_alert.toggled.connect(self.applySettings)
self.arti = QCheckBox()
self.arti.setChecked(self.game.settings.perf_artillery)
self.arti.toggled.connect(self.applySettings)
self.moving_units = QCheckBox()
self.moving_units.setChecked(self.game.settings.perf_moving_units)
self.moving_units.toggled.connect(self.applySettings)
self.infantry = QCheckBox()
self.infantry.setChecked(self.game.settings.perf_infantry)
self.infantry.toggled.connect(self.applySettings)
self.destroyed_units = QCheckBox()
self.destroyed_units.setChecked(
self.game.settings.perf_destroyed_units)
self.destroyed_units.toggled.connect(self.applySettings)
self.culling = QCheckBox()
self.culling.setChecked(self.game.settings.perf_culling)
self.culling.toggled.connect(self.applySettings)
self.culling_distance = QSpinBox()
self.culling_distance.setMinimum(10)
self.culling_distance.setMaximum(10000)
self.culling_distance.setValue(
self.game.settings.perf_culling_distance)
self.culling_distance.valueChanged.connect(self.applySettings)
self.culling_do_not_cull_carrier = QCheckBox()
self.culling_do_not_cull_carrier.setChecked(
self.game.settings.perf_do_not_cull_carrier)
self.culling_do_not_cull_carrier.toggled.connect(self.applySettings)
self.performanceLayout.addWidget(
QLabel("Smoke visual effect on frontline"), 0, 0)
self.performanceLayout.addWidget(self.smoke,
0,
1,
alignment=Qt.AlignRight)
self.performanceLayout.addWidget(
QLabel("SAM starts in RED alert mode"), 1, 0)
self.performanceLayout.addWidget(self.red_alert,
1,
1,
alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QLabel("Artillery strikes"), 2, 0)
self.performanceLayout.addWidget(self.arti,
2,
1,
alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QLabel("Moving ground units"), 3, 0)
self.performanceLayout.addWidget(self.moving_units,
3,
1,
alignment=Qt.AlignRight)
self.performanceLayout.addWidget(
QLabel("Generate infantry squads along vehicles"), 4, 0)
self.performanceLayout.addWidget(self.infantry,
4,
1,
alignment=Qt.AlignRight)
self.performanceLayout.addWidget(
QLabel("Include destroyed units carcass"), 6, 0)
self.performanceLayout.addWidget(self.destroyed_units,
6,
1,
alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QHorizontalSeparationLine(), 7, 0, 1,
2)
self.performanceLayout.addWidget(
QLabel("Culling of distant units enabled"), 8, 0)
self.performanceLayout.addWidget(self.culling,
8,
1,
alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QLabel("Culling distance (km)"), 9, 0)
self.performanceLayout.addWidget(self.culling_distance,
9,
1,
alignment=Qt.AlignRight)
self.performanceLayout.addWidget(
QLabel("Do not cull carrier's surroundings"), 10, 0)
self.performanceLayout.addWidget(self.culling_do_not_cull_carrier,
10,
1,
alignment=Qt.AlignRight)
self.generatorLayout.addWidget(self.gameplay)
self.generatorLayout.addWidget(
QLabel(
"Disabling settings below may improve performance, but will impact the overall quality of the experience."
))
self.generatorLayout.addWidget(self.performance)
def initCheatLayout(self):
self.cheatPage = QWidget()
self.cheatLayout = QVBoxLayout()
self.cheatPage.setLayout(self.cheatLayout)
self.cheat_options = CheatSettingsBox(self.game, self.applySettings)
self.cheatLayout.addWidget(self.cheat_options)
self.moneyCheatBox = QGroupBox("Money Cheat")
self.moneyCheatBox.setAlignment(Qt.AlignTop)
self.moneyCheatBoxLayout = QGridLayout()
self.moneyCheatBox.setLayout(self.moneyCheatBoxLayout)
cheats_amounts = [25, 50, 100, 200, 500, 1000, -25, -50, -100, -200]
for i, amount in enumerate(cheats_amounts):
if amount > 0:
btn = QPushButton("Cheat +" + str(amount) + "M")
btn.setProperty("style", "btn-success")
else:
btn = QPushButton("Cheat " + str(amount) + "M")
btn.setProperty("style", "btn-danger")
btn.clicked.connect(self.cheatLambda(amount))
self.moneyCheatBoxLayout.addWidget(btn, i / 2, i % 2)
self.cheatLayout.addWidget(self.moneyCheatBox, stretch=1)
def cheatLambda(self, amount):
return lambda: self.cheatMoney(amount)
def cheatMoney(self, amount):
logging.info("CHEATING FOR AMOUNT : " + str(amount) + "M")
self.game.budget += amount
if amount > 0:
self.game.informations.append(
Information(
"CHEATER",
"You are a cheater and you should feel bad",
self.game.turn,
))
else:
self.game.informations.append(
Information("CHEATER", "You are still a cheater !",
self.game.turn))
GameUpdateSignal.get_instance().updateGame(self.game)
def applySettings(self):
self.game.settings.player_skill = CONST.SKILL_OPTIONS[
self.playerCoalitionSkill.currentIndex()]
self.game.settings.enemy_skill = CONST.SKILL_OPTIONS[
self.enemyCoalitionSkill.currentIndex()]
self.game.settings.enemy_vehicle_skill = CONST.SKILL_OPTIONS[
self.enemyAASkill.currentIndex()]
self.game.settings.player_income_multiplier = self.player_income.value
self.game.settings.enemy_income_multiplier = self.enemy_income.value
self.game.settings.manpads = self.manpads.isChecked()
self.game.settings.labels = CONST.LABELS_OPTIONS[
self.difficultyLabel.currentIndex()]
self.game.settings.night_disabled = self.noNightMission.isChecked()
self.game.settings.map_coalition_visibility = (
self.mapVisibiitySelection.currentData())
self.game.settings.external_views_allowed = self.ext_views.isChecked()
self.game.settings.generate_marks = self.generate_marks.isChecked()
self.game.settings.never_delay_player_flights = (
self.never_delay_players.isChecked())
self.game.settings.supercarrier = self.supercarrier.isChecked()
self.game.settings.generate_dark_kneeboard = (
self.generate_dark_kneeboard.isChecked())
self.game.settings.perf_red_alert_state = self.red_alert.isChecked()
self.game.settings.perf_smoke_gen = self.smoke.isChecked()
self.game.settings.perf_artillery = self.arti.isChecked()
self.game.settings.perf_moving_units = self.moving_units.isChecked()
self.game.settings.perf_infantry = self.infantry.isChecked()
self.game.settings.perf_destroyed_units = self.destroyed_units.isChecked(
)
self.game.settings.perf_culling = self.culling.isChecked()
self.game.settings.perf_culling_distance = int(
self.culling_distance.value())
self.game.settings.perf_do_not_cull_carrier = (
self.culling_do_not_cull_carrier.isChecked())
self.game.settings.show_red_ato = self.cheat_options.show_red_ato
self.game.settings.enable_frontline_cheats = (
self.cheat_options.show_frontline_cheat)
self.game.settings.enable_base_capture_cheat = (
self.cheat_options.show_base_capture_cheat)
self.game.compute_conflicts_position()
GameUpdateSignal.get_instance().updateGame(self.game)
def onSelectionChanged(self):
index = self.categoryList.selectionModel().currentIndex().row()
self.right_layout.setCurrentIndex(index)
class ParametersComponent(QGroupBox):
def __init__(self):
super().__init__()
self.setTitle("Paramètres")
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum)
# Main layout
main_layout = QHBoxLayout(self)
main_layout.setSpacing(20)
left_layout = QFormLayout()
left_layout.setHorizontalSpacing(20)
left_layout.setVerticalSpacing(14)
self._threshold_sbox = QSpinBox()
self._threshold_sbox.setRange(1, 99)
self._threshold_sbox.setSuffix(" %")
self._threshold_sbox.setMaximumWidth(250)
left_layout.addRow("Seuil de détection :", self._threshold_sbox)
self._devices_list = QComboBox()
self._devices_list.setMaximumWidth(250)
self._setDevicesList()
left_layout.addRow("Processeur à utiliser :", self._devices_list)
morphotype_layout = QGridLayout()
morphotype_layout.setSpacing(5)
morphotype_layout.addWidget(QLabel("Morphotypes à détecter :"), 0, 0, 1, 4)
self._tab_cbox = {}
for k,m in Loader.SpongesMorphotypes().items():
sponge_cbox = QCheckBox(m.name())
self._tab_cbox[k] = sponge_cbox
x = k%2 + 1
y = k//2 + 1
morphotype_layout.addWidget(sponge_cbox, x, y)
morphotype_layout.setColumnMinimumWidth(0, 15)
morphotype_layout.setColumnStretch(0, 0)
main_layout.addLayout(left_layout)
main_layout.addLayout(morphotype_layout)
self.setLayout(main_layout)
def _setDevicesList(self):
self._devices_list.clear()
available_devices = NeuralNetwork.getAvailableCalculationDevices()
for device_id, device_name in available_devices.items():
self._devices_list.addItem(device_name, device_id)
if len(available_devices) == 1:
self._devices_list.addItem("GPU (Indisponible)", None)
self._devices_list.model().item(1).setEnabled(False)
else:
self._devices_list.setCurrentIndex(1)
def reset(self, parameters: Parameters):
self._threshold_sbox.setValue(parameters.threshold()*100)
for k,v in parameters.morphotypes().items():
self._tab_cbox[k].setChecked(v)
def updateParameters(self, parameters: Parameters):
parameters.setThreshold(self._threshold_sbox.value()/100)
parameters.setDeviceId(self._devices_list.currentData())
for k in parameters.morphotypes():
parameters.morphotypes()[k] = self._tab_cbox[k].isChecked()
class QSettingsWindow(QDialog):
def __init__(self, game: Game):
super(QSettingsWindow, self).__init__()
self.game = game
self.setModal(True)
self.setWindowTitle("Settings")
self.setWindowIcon(CONST.ICONS["Settings"])
self.setMinimumSize(600, 250)
self.initUi()
def initUi(self):
self.layout = QGridLayout()
self.categoryList = QListView()
self.right_layout = QStackedLayout()
self.categoryList.setMaximumWidth(175)
self.categoryModel = QStandardItemModel(self.categoryList)
difficulty = QStandardItem("Difficulty")
difficulty.setIcon(CONST.ICONS["Missile"])
difficulty.setEditable(False)
difficulty.setSelectable(True)
generator = QStandardItem("Mission Generator")
generator.setIcon(CONST.ICONS["Generator"])
generator.setEditable(False)
generator.setSelectable(True)
cheat = QStandardItem("Cheat Menu")
cheat.setIcon(CONST.ICONS["Cheat"])
cheat.setEditable(False)
cheat.setSelectable(True)
self.categoryList.setIconSize(QSize(32, 32))
self.categoryModel.appendRow(difficulty)
self.categoryModel.appendRow(generator)
self.categoryModel.appendRow(cheat)
self.categoryList.setSelectionBehavior(QAbstractItemView.SelectRows)
self.categoryList.setModel(self.categoryModel)
self.categoryList.selectionModel().setCurrentIndex(self.categoryList.indexAt(QPoint(1,1)), QItemSelectionModel.Select)
self.categoryList.selectionModel().selectionChanged.connect(self.onSelectionChanged)
self.initDifficultyLayout()
self.initGeneratorLayout()
self.initCheatLayout()
self.right_layout.addWidget(self.difficultyPage)
self.right_layout.addWidget(self.generatorPage)
self.right_layout.addWidget(self.cheatPage)
self.layout.addWidget(self.categoryList, 0, 0, 1, 1)
self.layout.addLayout(self.right_layout, 0, 1, 5, 1)
self.setLayout(self.layout)
def init(self):
pass
def initDifficultyLayout(self):
self.difficultyPage = QWidget()
self.difficultyLayout = QGridLayout()
self.difficultyLayout.setAlignment(Qt.AlignTop)
self.difficultyPage.setLayout(self.difficultyLayout)
self.playerCoalitionSkill = QComboBox()
self.enemyCoalitionSkill = QComboBox()
self.enemyAASkill = QComboBox()
for skill in CONST.SKILL_OPTIONS:
self.playerCoalitionSkill.addItem(skill)
self.enemyCoalitionSkill.addItem(skill)
self.enemyAASkill.addItem(skill)
self.playerCoalitionSkill.setCurrentIndex(CONST.SKILL_OPTIONS.index(self.game.settings.player_skill))
self.enemyCoalitionSkill.setCurrentIndex(CONST.SKILL_OPTIONS.index(self.game.settings.enemy_skill))
self.enemyAASkill.setCurrentIndex(CONST.SKILL_OPTIONS.index(self.game.settings.enemy_vehicle_skill))
self.playerCoalitionSkill.currentIndexChanged.connect(self.applySettings)
self.enemyCoalitionSkill.currentIndexChanged.connect(self.applySettings)
self.enemyAASkill.currentIndexChanged.connect(self.applySettings)
self.difficultyLayout.addWidget(QLabel("Player coalition skill"), 0, 0)
self.difficultyLayout.addWidget(self.playerCoalitionSkill, 0, 1, Qt.AlignRight)
self.difficultyLayout.addWidget(QLabel("Enemy skill"), 1, 0)
self.difficultyLayout.addWidget(self.enemyCoalitionSkill, 1, 1, Qt.AlignRight)
self.difficultyLayout.addWidget(QLabel("Enemy AA and vehicles skill"), 2, 0)
self.difficultyLayout.addWidget(self.enemyAASkill, 2, 1, Qt.AlignRight)
self.difficultyLabel = QComboBox()
[self.difficultyLabel.addItem(t) for t in CONST.LABELS_OPTIONS]
self.difficultyLabel.setCurrentIndex(CONST.LABELS_OPTIONS.index(self.game.settings.labels))
self.difficultyLabel.currentIndexChanged.connect(self.applySettings)
self.difficultyLayout.addWidget(QLabel("In Game Labels"), 3, 0)
self.difficultyLayout.addWidget(self.difficultyLabel, 3, 1, Qt.AlignRight)
self.noNightMission = QCheckBox()
self.noNightMission.setChecked(self.game.settings.night_disabled)
self.noNightMission.toggled.connect(self.applySettings)
self.difficultyLayout.addWidget(QLabel("No night missions"), 4, 0)
self.difficultyLayout.addWidget(self.noNightMission, 4, 1, Qt.AlignRight)
self.mapVisibiitySelection = QComboBox()
self.mapVisibiitySelection.addItem("All", ForcedOptions.Views.All)
if self.game.settings.map_coalition_visibility == ForcedOptions.Views.All:
self.mapVisibiitySelection.setCurrentIndex(0)
self.mapVisibiitySelection.addItem("Fog of War", ForcedOptions.Views.Allies)
if self.game.settings.map_coalition_visibility == ForcedOptions.Views.Allies:
self.mapVisibiitySelection.setCurrentIndex(1)
self.mapVisibiitySelection.addItem("Allies Only", ForcedOptions.Views.OnlyAllies)
if self.game.settings.map_coalition_visibility == ForcedOptions.Views.OnlyAllies:
self.mapVisibiitySelection.setCurrentIndex(2)
self.mapVisibiitySelection.addItem("Own Aircraft Only", ForcedOptions.Views.MyAircraft)
if self.game.settings.map_coalition_visibility == ForcedOptions.Views.MyAircraft:
self.mapVisibiitySelection.setCurrentIndex(3)
self.mapVisibiitySelection.addItem("Map Only", ForcedOptions.Views.OnlyMap)
if self.game.settings.map_coalition_visibility == ForcedOptions.Views.OnlyMap:
self.mapVisibiitySelection.setCurrentIndex(4)
self.mapVisibiitySelection.currentIndexChanged.connect(self.applySettings)
self.difficultyLayout.addWidget(QLabel("Map visibility options"), 5, 0)
self.difficultyLayout.addWidget(self.mapVisibiitySelection, 5, 1, Qt.AlignRight)
self.ext_views = QCheckBox()
self.ext_views.setChecked(self.game.settings.external_views_allowed)
self.ext_views.toggled.connect(self.applySettings)
self.difficultyLayout.addWidget(QLabel("Allow external views"), 6, 0)
self.difficultyLayout.addWidget(self.ext_views, 6, 1, Qt.AlignRight)
def initGeneratorLayout(self):
self.generatorPage = QWidget()
self.generatorLayout = QVBoxLayout()
self.generatorLayout.setAlignment(Qt.AlignTop)
self.generatorPage.setLayout(self.generatorLayout)
self.gameplay = QGroupBox("Gameplay")
self.gameplayLayout = QGridLayout();
self.gameplayLayout.setAlignment(Qt.AlignTop)
self.gameplay.setLayout(self.gameplayLayout)
self.supercarrier = QCheckBox()
self.supercarrier.setChecked(self.game.settings.supercarrier)
self.supercarrier.toggled.connect(self.applySettings)
self.generate_marks = QCheckBox()
self.generate_marks.setChecked(self.game.settings.generate_marks)
self.generate_marks.toggled.connect(self.applySettings)
if not hasattr(self.game.settings, "include_jtac_if_available"):
self.game.settings.include_jtac_if_available = True
self.include_jtac_if_available = QCheckBox()
self.include_jtac_if_available.setChecked(self.game.settings.include_jtac_if_available)
self.include_jtac_if_available.toggled.connect(self.applySettings)
self.gameplayLayout.addWidget(QLabel("Use Supercarrier Module"), 0, 0)
self.gameplayLayout.addWidget(self.supercarrier, 0, 1, Qt.AlignRight)
self.gameplayLayout.addWidget(QLabel("Put Objective Markers on Map"), 1, 0)
self.gameplayLayout.addWidget(self.generate_marks, 1, 1, Qt.AlignRight)
self.gameplayLayout.addWidget(QLabel("Include JTAC (If available)"), 2, 0)
self.gameplayLayout.addWidget(self.include_jtac_if_available, 2, 1, Qt.AlignRight)
self.performance = QGroupBox("Performance")
self.performanceLayout = QGridLayout()
self.performanceLayout.setAlignment(Qt.AlignTop)
self.performance.setLayout(self.performanceLayout)
self.smoke = QCheckBox()
self.smoke.setChecked(self.game.settings.perf_smoke_gen)
self.smoke.toggled.connect(self.applySettings)
self.red_alert = QCheckBox()
self.red_alert.setChecked(self.game.settings.perf_red_alert_state)
self.red_alert.toggled.connect(self.applySettings)
self.arti = QCheckBox()
self.arti.setChecked(self.game.settings.perf_artillery)
self.arti.toggled.connect(self.applySettings)
self.moving_units = QCheckBox()
self.moving_units.setChecked(self.game.settings.perf_moving_units)
self.moving_units.toggled.connect(self.applySettings)
self.infantry = QCheckBox()
self.infantry.setChecked(self.game.settings.perf_infantry)
self.infantry.toggled.connect(self.applySettings)
self.ai_parking_start = QCheckBox()
self.ai_parking_start.setChecked(self.game.settings.perf_ai_parking_start)
self.ai_parking_start.toggled.connect(self.applySettings)
self.destroyed_units = QCheckBox()
self.destroyed_units.setChecked(self.game.settings.perf_destroyed_units)
self.destroyed_units.toggled.connect(self.applySettings)
self.culling = QCheckBox()
self.culling.setChecked(self.game.settings.perf_culling)
self.culling.toggled.connect(self.applySettings)
self.culling_distance = QSpinBox()
self.culling_distance.setMinimum(50)
self.culling_distance.setMaximum(10000)
self.culling_distance.setValue(self.game.settings.perf_culling_distance)
self.culling_distance.valueChanged.connect(self.applySettings)
self.performanceLayout.addWidget(QLabel("Smoke visual effect on frontline"), 0, 0)
self.performanceLayout.addWidget(self.smoke, 0, 1, alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QLabel("SAM starts in RED alert mode"), 1, 0)
self.performanceLayout.addWidget(self.red_alert, 1, 1, alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QLabel("Artillery strikes"), 2, 0)
self.performanceLayout.addWidget(self.arti, 2, 1, alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QLabel("Moving ground units"), 3, 0)
self.performanceLayout.addWidget(self.moving_units, 3, 1, alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QLabel("Generate infantry squads along vehicles"), 4, 0)
self.performanceLayout.addWidget(self.infantry, 4, 1, alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QLabel("AI planes parking start (AI starts in flight if disabled)"), 5, 0)
self.performanceLayout.addWidget(self.ai_parking_start, 5, 1, alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QLabel("Include destroyed units carcass"), 6, 0)
self.performanceLayout.addWidget(self.destroyed_units, 6, 1, alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QHorizontalSeparationLine(), 7, 0, 1, 2)
self.performanceLayout.addWidget(QLabel("Culling of distant units enabled"), 8, 0)
self.performanceLayout.addWidget(self.culling, 8, 1, alignment=Qt.AlignRight)
self.performanceLayout.addWidget(QLabel("Culling distance (km)"), 9, 0)
self.performanceLayout.addWidget(self.culling_distance, 9, 1, alignment=Qt.AlignRight)
self.generatorLayout.addWidget(self.gameplay)
self.generatorLayout.addWidget(QLabel("Disabling settings below may improve performance, but will impact the overall quality of the experience."))
self.generatorLayout.addWidget(self.performance)
def initCheatLayout(self):
self.cheatPage = QWidget()
self.cheatLayout = QGridLayout()
self.cheatPage.setLayout(self.cheatLayout)
self.moneyCheatBox = QGroupBox("Money Cheat")
self.moneyCheatBox.setAlignment(Qt.AlignTop)
self.moneyCheatBoxLayout = QGridLayout()
self.moneyCheatBox.setLayout(self.moneyCheatBoxLayout)
self.cheat25M = QPushButton("Cheat +25M")
self.cheat50M = QPushButton("Cheat +50M")
self.cheat100M = QPushButton("Cheat +100M")
self.cheat200M = QPushButton("Cheat +200M")
self.cheat500M = QPushButton("Cheat +500M")
self.cheat1000M = QPushButton("Cheat +1000M")
self.cheat25M.clicked.connect(lambda: self.cheatMoney(25))
self.cheat50M.clicked.connect(lambda: self.cheatMoney(50))
self.cheat100M.clicked.connect(lambda: self.cheatMoney(100))
self.cheat200M.clicked.connect(lambda: self.cheatMoney(200))
self.cheat500M.clicked.connect(lambda: self.cheatMoney(500))
self.cheat1000M.clicked.connect(lambda: self.cheatMoney(1000))
self.moneyCheatBoxLayout.addWidget(self.cheat25M, 0, 0)
self.moneyCheatBoxLayout.addWidget(self.cheat50M, 0, 1)
self.moneyCheatBoxLayout.addWidget(self.cheat100M, 1, 0)
self.moneyCheatBoxLayout.addWidget(self.cheat200M, 1, 1)
self.moneyCheatBoxLayout.addWidget(self.cheat500M, 2, 0)
self.moneyCheatBoxLayout.addWidget(self.cheat1000M, 2, 1)
self.cheatLayout.addWidget(self.moneyCheatBox, 0, 0)
def cheatMoney(self, amount):
self.game.budget += amount
self.game.informations.append(Information("CHEATER", "You are a cheater and you should feel bad", self.game.turn))
GameUpdateSignal.get_instance().updateGame(self.game)
def applySettings(self):
self.game.settings.player_skill = CONST.SKILL_OPTIONS[self.playerCoalitionSkill.currentIndex()]
self.game.settings.enemy_skill = CONST.SKILL_OPTIONS[self.enemyCoalitionSkill.currentIndex()]
self.game.settings.enemy_vehicle_skill = CONST.SKILL_OPTIONS[self.enemyAASkill.currentIndex()]
self.game.settings.labels = CONST.LABELS_OPTIONS[self.difficultyLabel.currentIndex()]
self.game.settings.night_disabled = self.noNightMission.isChecked()
self.game.settings.map_coalition_visibility = self.mapVisibiitySelection.currentData()
self.game.settings.external_views_allowed = self.ext_views.isChecked()
self.game.settings.generate_marks = self.generate_marks.isChecked()
self.game.settings.include_jtac_if_available = self.include_jtac_if_available.isChecked()
print(self.game.settings.map_coalition_visibility)
self.game.settings.supercarrier = self.supercarrier.isChecked()
self.game.settings.perf_red_alert_state = self.red_alert.isChecked()
self.game.settings.perf_smoke_gen = self.smoke.isChecked()
self.game.settings.perf_artillery = self.arti.isChecked()
self.game.settings.perf_moving_units = self.moving_units.isChecked()
self.game.settings.perf_infantry = self.infantry.isChecked()
self.game.settings.perf_ai_parking_start = self.ai_parking_start.isChecked()
self.game.settings.perf_destroyed_units = self.destroyed_units.isChecked()
self.game.settings.perf_culling = self.culling.isChecked()
self.game.settings.perf_culling_distance = int(self.culling_distance.value())
GameUpdateSignal.get_instance().updateGame(self.game)
def onSelectionChanged(self):
index = self.categoryList.selectionModel().currentIndex().row()
self.right_layout.setCurrentIndex(index)
class AddUserFace(QDialog):
def __init__(self, image):
super(AddUserFace, self).__init__()
self.setFixedSize(300, 275)
self.setWindowIcon(QIcon('icons/add.png'))
self.setWindowTitle('添加')
self.rb_select = QRadioButton("选择", self)
self.rb_select.setGeometry(70, 20, 50, 26)
self.rb_select.toggled.connect(self.toggle)
self.rb_new = QRadioButton('新建', self)
self.rb_new.setGeometry(120, 20, 50, 26)
self.rb_new.toggled.connect(self.toggle)
lbl_name = QLabel('名称', self)
lbl_name.setGeometry(10, 70, 50, 26)
lbl_name.setAlignment(Qt.AlignCenter)
users = DbHelper.query_users()
self.cb_user = QComboBox(self)
self.cb_user.setGeometry(70, 70, 200, 26)
self.le_user = QLineEdit(self)
self.le_user.setGeometry(70, 70, 200, 26)
if users is not None and len(users) > 0:
self.rb_select.setChecked(True)
for user in users:
self.cb_user.addItem(user[1], userData=user)
else:
self.rb_select.setDisabled(True)
self.rb_new.setChecked(True)
lbl_face = QLabel('人脸', self)
lbl_face.setGeometry(10, 140, 50, 26)
lbl_face.setAlignment(Qt.AlignCenter)
self.btn_save = QPushButton(self)
self.btn_save.setText('保存')
self.btn_save.setGeometry(10, 234, 280, 30)
self.btn_save.clicked.connect(self.save)
self.cache_faces = {}
self.face = None
faces = HaarcascadeDetective.get_faces(image)
index = 0
for face in faces:
viewer_face = QPushButton(self)
viewer_face.setGeometry(70 * (index + 1), 120, 60, 60)
viewer_face.setIconSize(QSize(56, 56))
img = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
image = QImage(img, img.shape[1], img.shape[0], img.shape[1] * 3,
QImage.Format_RGB888)
pix_map = QPixmap.fromImage(image)
viewer_face.setIcon(QIcon(pix_map))
viewer_face.clicked.connect(self.select_face)
self.cache_faces[viewer_face] = face
if index == 0:
self.face = face
viewer_face.setStyleSheet(
'border-color: rgb(255, 0, 0);border-style: outset;border-width: 2px;'
)
index += 1
if index > 3:
break
if index == 0:
Tool.show_msg_box("未检测到人脸信息")
def select_face(self):
sender = self.sender()
for btn in self.cache_faces:
btn.setStyleSheet('border-style: none')
sender.setStyleSheet(
"border-color: rgb(255, 0, 0);border-style: outset;border-width: 2px;"
)
self.face = self.cache_faces[btn]
def toggle(self):
if self.rb_new.isChecked():
self.cb_user.hide()
self.le_user.show()
elif self.rb_select.isChecked():
self.le_user.hide()
self.cb_user.show()
def save(self):
if self.face is None:
return
self.btn_save.setDisabled(True)
if self.rb_new.isChecked():
user_name = self.le_user.text().strip(' ')
if not user_name.replace(' ', '').encode("utf-8").isalpha():
Tool.show_msg_box('只支持英文字母和空格～')
self.le_name.setFocus()
return
user_id = DbHelper.insert_user(user_name)
else:
user_id = self.cb_user.currentData()[0]
if not os.path.exists("faces"):
os.mkdir("faces")
if not os.path.exists('faces/{}'.format(user_id)):
os.mkdir('faces/{}'.format(user_id))
face = 'faces/{}/{}.png'.format(user_id, time.time())
cv2.imwrite(face, self.face)
self.close()
class CategoricalImagesWidget(QWidget):
def __init__(self, parent: "QWidget" = None):
super().__init__(parent)
self._main_layout = QVBoxLayout()
self._main_layout.addWidget(QLabel("Not Implemented"))
self._train_dir_loader = FileLoaderGroup("Train",
pick_directories=True)
self._test_dir_loader = FileLoaderGroup("Test", pick_directories=True)
self._validation_dir_loader = FileLoaderGroup("Validation",
pick_directories=True)
self._organization_combobox = QComboBox()
self._organization_combobox.addItem(
"Use Folder name as category",
CategoricalImgDatasetIO.Organization.CategoryOnFolders,
)
self._organization_combobox.addItem(
"Use Filename as category",
CategoricalImgDatasetIO.Organization.CategoryOnFilename,
)
self._category_regex_extractor_group = QGroupBox(
"Category Extractor Regex")
self._category_regex_extractor_layout = QVBoxLayout()
self._category_regex_extractor_group.setLayout(
self._category_regex_extractor_layout)
self._category_regex_textbox = QLineEdit("(.*)")
self._category_regex_layout = QFormLayout()
self._category_regex_layout.addRow(
"Regex:",
self._category_regex_textbox,
)
self._regex_test_input_textbox = QLineEdit()
self._regex_test_output_textbox = QLineEdit()
self._regex_test_output_textbox.setReadOnly(True)
self._regex_test_layout = QHBoxLayout()
self._regex_test_layout.addWidget(QLabel("Test: (Filename) "))
self._regex_test_layout.addWidget(self._regex_test_input_textbox)
self._regex_test_layout.addWidget(QLabel(" => (Category): "))
self._regex_test_layout.addWidget(self._regex_test_output_textbox)
self._category_regex_extractor_layout.addLayout(
self._category_regex_layout)
self._category_regex_extractor_layout.addLayout(
self._regex_test_layout)
self._main_layout = QVBoxLayout()
self._main_layout.setContentsMargins(0, 0, 0, 0)
self._main_layout.addWidget(self._train_dir_loader)
self._main_layout.addWidget(self._test_dir_loader)
self._main_layout.addWidget(self._validation_dir_loader)
self._main_layout.addWidget(self._organization_combobox)
self._main_layout.addWidget(self._category_regex_extractor_group)
self.setLayout(self._main_layout)
self._category_regex_textbox.textChanged.connect(
lambda: self._reload_regex())
self._regex_test_input_textbox.textChanged.connect(
lambda: self._reload_regex())
self._organization_combobox.currentIndexChanged[int].connect(
lambda: self._update_organization_widgets())
self._reload_regex()
self._update_organization_widgets()
def load_ttv(self, name: str, x_type: DataType, y_type: DataType):
LOGGER.debug("Loading TTV %s", name)
def load_dataset(dataset_dir):
return (
# Subdir
# Organization
# Categories
CategoricalImgDatasetIO().set_x_type(x_type).set_y_type(
y_type).set_organization(
self._organization_combobox.currentData()
).set_filename_category_regex(
self._category_regex_textbox.text()
).load(dataset_dir) # Absolute path set on filename
)
train = load_dataset(self._train_dir_loader.path)
test = load_dataset(self._test_dir_loader.path)
validation = load_dataset(self._validation_dir_loader.path)
return TTVSets(name, train, test, validation)
def _reload_regex(self):
regex_string = self._category_regex_textbox.text()
input_text = self._regex_test_input_textbox.text()
match = re.match(regex_string, input_text)
if match:
try:
self._regex_test_output_textbox.setText(match.group(1))
except KeyError:
self._regex_test_output_textbox.setText(match.group(0))
else:
self._regex_test_output_textbox.setText("[No match]")
def update_widgets(self, ttv_dir: str, ttv_description: dict):
def update_file_loader_path(dir_loader, dataset_dir,
dataset_description):
if not dataset_dir:
dir_loader.path = ""
return
if self._organization_combobox.currentIndex() == 0:
dataset_dir_path = os.path.join(ttv_dir, dataset_dir)
else:
dataset_dir_path = ttv_dir
dir_loader.path = dataset_dir_path
update_file_loader_path(self._train_dir_loader, "train",
ttv_description["train"])
update_file_loader_path(self._test_dir_loader, "test",
ttv_description["test"])
update_file_loader_path(self._validation_dir_loader, "validation",
ttv_description["validation"])
self._update_organization_widgets()
def _update_organization_widgets(self):
if self._organization_combobox.currentIndex() == 1:
self._category_regex_extractor_group.setVisible(True)
else:
self._category_regex_extractor_group.setVisible(False)
class InputsLayout(QFormLayout):
# this signal is connected to print_output from output_layout class. Connection is done in center_layout
ga_result = Signal(
str
) # a signal that is emitted so it can transfer resulting string to the output_layout class
def __init__(self):
super(InputsLayout, self).__init__()
self.big_font = QFont()
self.medium_font = QFont()
self.header = QLabel()
self.header_general = QLabel()
self.header_fitness_remapping = QLabel()
self.header_stop = QLabel()
self.header_selection = QLabel()
self.header_pairing = QLabel()
self.header_crossover = QLabel()
self.header_mutation = QLabel()
self.inp_functions_combo = QComboBox()
self.inp_num_variables = QSpinBox()
self.inp_extrema_min = QRadioButton("Minimum")
self.inp_extrema_max = QRadioButton("Maximum")
self.inp_pop_size = QSpinBox()
self.inp_lower_bound = QDoubleSpinBox()
self.inp_upper_bound = QDoubleSpinBox()
# Stopping
self.inp_max_iter = QSpinBox()
self.inp_similarity_cb = QCheckBox()
self.inp_similarity = QSpinBox()
self.inp_best_result_cb = QCheckBox()
self.inp_best_result = QDoubleSpinBox()
self.inp_average_result_cb = QCheckBox()
self.inp_average_result = QDoubleSpinBox()
# Fitness remapping
self.inp_fitness_remapping = QComboBox()
# Selection
self.inp_selection_method = QComboBox()
self.inp_elitism = QDoubleSpinBox()
# Pairing
self.inp_pairing_method = QComboBox()
# Crossover
self.inp_crossover_method = QComboBox()
self.inp_crossover_fraction = QDoubleSpinBox()
self.intermediate_offset = QDoubleSpinBox()
# Mutation
self.inp_mutation_method = QComboBox()
self.inp_mutation_intensity = QDoubleSpinBox()
self.inp_mutation_intensity_final = QDoubleSpinBox()
self.init_fonts()
self.init_header()
self.init_row_functions()
self.init_row_general()
self.init_row_fitness_remapping()
self.init_row_stop()
self.init_row_selection()
self.init_row_pairing()
self.init_row_crossover()
self.init_row_mutation()
def init_fonts(self):
self.big_font.setPointSizeF(14)
self.medium_font.setPointSizeF(12)
def init_header(self):
self.header.setFont(self.big_font)
self.header.setAlignment(Qt.AlignCenter)
self.header.setText("Genetic Algorithm Continuous Optimization")
self.addRow(self.header)
self.addRow(QHLine())
def init_row_functions(self):
self.inp_functions_combo.addItem("Ackley", ackley)
self.inp_functions_combo.addItem("Griewank", griewank)
self.inp_functions_combo.addItem("Michalewicz", michalewicz)
self.inp_extrema_min.setChecked(True)
radio_box = QHBoxLayout()
radio_box.addWidget(self.inp_extrema_min)
radio_box.addWidget(self.inp_extrema_max)
self.addRow("Function:", self.inp_functions_combo)
self.inp_num_variables.setMaximum(10000)
self.inp_num_variables.setValue(10)
self.addRow("Number of variables:", self.inp_num_variables)
self.addRow("Find:", radio_box)
self.addRow(QHLine())
def init_row_general(self):
self.header_general.setFont(self.medium_font)
self.header_general.setText("General")
self.inp_pop_size.setMaximum(10000)
self.inp_pop_size.setValue(300)
self.inp_lower_bound.setMaximum(1000000)
self.inp_lower_bound.setMinimum(-1000000.0)
self.inp_lower_bound.setValue(-10)
self.inp_upper_bound.setMaximum(1000000)
self.inp_upper_bound.setMinimum(-1000000.0)
self.inp_upper_bound.setValue(10)
self.addRow(self.header_general)
self.addRow("Population size", self.inp_pop_size)
self.addRow("Lower Bound", self.inp_lower_bound)
self.addRow("Upper Bound", self.inp_upper_bound)
self.addRow(QHLine())
def init_row_fitness_remapping(self):
self.header_fitness_remapping.setFont(self.medium_font)
self.header_fitness_remapping.setText("Fitness Remapping")
self.inp_fitness_remapping.addItem("Rank Scaling", "Rank Scaling")
self.inp_fitness_remapping.addItem("Fitness Scaling",
"Fitness Scaling")
self.addRow(self.header_fitness_remapping)
self.addRow("Fitness remapping", self.inp_fitness_remapping)
self.addRow(QHLine())
def init_row_stop(self):
self.header_stop.setFont(self.medium_font)
self.header_stop.setText("Stopping Criteria")
self.inp_max_iter.setMaximum(100000)
self.inp_similarity.setMaximum(100000)
self.inp_best_result.setMinimum(-100000)
self.inp_best_result.setMaximum(100000)
self.inp_average_result.setMinimum(-100000)
self.inp_average_result.setMaximum(100000)
self.inp_max_iter.setValue(500)
self.inp_similarity.setValue(80)
self.inp_best_result.setValue(-10)
self.inp_average_result.setValue(-10000)
self.inp_similarity_cb.setText("Similar Results")
self.inp_best_result_cb.setText("Best Result")
self.inp_average_result_cb.setText("Average Result")
self.inp_similarity_cb.stateChanged.connect(self.cb_similarity_signal)
self.inp_best_result_cb.stateChanged.connect(
self.cb_best_result_signal)
self.inp_average_result_cb.stateChanged.connect(
self.cb_average_result_signal)
self.inp_similarity_cb.setChecked(False)
self.inp_best_result_cb.setChecked(False)
self.inp_average_result_cb.setChecked(False)
self.inp_similarity.setEnabled(True)
self.inp_best_result.setEnabled(False)
self.inp_best_result.setStyleSheet("background:#555")
self.inp_average_result.setEnabled(False)
self.inp_average_result.setStyleSheet("background:#555")
self.addRow(self.header_stop)
self.addRow("Max iter", self.inp_max_iter)
self.addRow(self.inp_similarity_cb, self.inp_similarity)
self.addRow(self.inp_best_result_cb, self.inp_best_result)
self.addRow(self.inp_average_result_cb, self.inp_average_result)
self.addRow(QHLine())
def init_row_selection(self):
self.header_selection.setFont(self.medium_font)
self.header_selection.setText("Selection")
self.inp_selection_method.addItem("Fittest Half", "Fittest Half")
self.inp_selection_method.addItem("Roulette Wheel", "Roulette Wheel")
self.inp_selection_method.addItem("Random", "Random")
self.inp_selection_method.addItem("Whole Population",
"Whole Population")
self.inp_elitism.setMaximum(1)
self.inp_elitism.setValue(0.01)
self.inp_elitism.setSingleStep(0.01)
self.addRow(self.header_selection)
self.addRow("Selection Method", self.inp_selection_method)
self.addRow("Elitism Percentage", self.inp_elitism)
self.addRow(QHLine())
def init_row_pairing(self):
self.header_pairing.setFont(self.medium_font)
self.header_pairing.setText("Pairing")
self.inp_pairing_method.addItem("Random", "Random")
self.inp_pairing_method.addItem("Roulette Wheel", "Roulette Wheel")
self.inp_pairing_method.addItem("Fittest", "Fittest")
self.addRow(self.header_pairing)
self.addRow("Pairing Method", self.inp_pairing_method)
self.addRow(QHLine())
def init_row_crossover(self):
self.header_crossover.setFont(self.medium_font)
self.header_crossover.setText("Crossover")
self.inp_crossover_method.addItem("Intermediate", "Intermediate")
self.inp_crossover_method.addItem("Line Intermediate",
"Line Intermediate")
self.inp_crossover_method.addItem("Heuristic", "Heuristic")
self.inp_crossover_method.addItem("One point", "One point")
self.inp_crossover_method.addItem("Two point", "Two point")
self.inp_crossover_method.addItem("Random", "Random")
self.inp_mutation_method.setCurrentIndex(2)
self.inp_crossover_fraction.setMaximum(1)
self.inp_crossover_fraction.setValue(0.7)
self.inp_crossover_fraction.setSingleStep(0.05)
self.intermediate_offset.setMaximum(20)
self.intermediate_offset.setValue(1.55)
self.intermediate_offset.setSingleStep(0.05)
self.addRow(self.header_crossover)
self.addRow("Crossover Method", self.inp_crossover_method)
self.addRow("Crossover Fraction", self.inp_crossover_fraction)
self.addRow("Intermediate Offset", self.intermediate_offset)
self.addRow(QHLine())
def init_row_mutation(self):
self.header_mutation.setFont(self.medium_font)
self.header_mutation.setText("Mutation")
self.inp_mutation_method.addItem("Gauss", "Gauss")
self.inp_mutation_method.addItem("Random", "Random")
self.inp_mutation_intensity.setMaximum(200)
self.inp_mutation_intensity.setValue(2)
self.inp_mutation_intensity.setDecimals(4)
self.inp_mutation_intensity.setSingleStep(0.01)
self.inp_mutation_intensity_final.setMaximum(200)
self.inp_mutation_intensity_final.setDecimals(4)
self.inp_mutation_intensity_final.setValue(0.001)
self.inp_mutation_intensity_final.setSingleStep(0.5)
self.addRow(self.header_mutation)
self.addRow("Mutation Method", self.inp_mutation_method)
self.addRow("Mutation Intensity", self.inp_mutation_intensity)
self.addRow("Final Mutation Intensity",
self.inp_mutation_intensity_final)
self.addRow(QHLine())
def get_options(self):
function = self.inp_functions_combo.currentData()
num_var = self.inp_num_variables.text()
if self.inp_extrema_min.isChecked():
extrem = 0
else:
extrem = 1
pop_size = self.inp_pop_size.text()
low_bound = self.inp_lower_bound.text()
upp_bound = self.inp_upper_bound.text()
max_iter = self.inp_max_iter.text()
sim_results = self.inp_similarity.text()
best_res = self.inp_best_result.text()
average_res = self.inp_average_result.text()
select_method = self.inp_selection_method.currentText()
elite_percent = self.inp_elitism.text()
pairing = self.inp_pairing_method.currentText()
crossover_method = self.inp_crossover_method.currentText()
crossover_fraction = self.inp_crossover_fraction.text()
intermediate_offset = self.intermediate_offset.text()
mutation_method = self.inp_mutation_method.currentText()
mutation_intensity = self.inp_mutation_intensity.text()
mutation_intensity_final = self.inp_mutation_intensity_final.text()
fitness_remapping = self.inp_fitness_remapping.currentText()
options = {
"function":
function,
"num_var":
num_var,
"pop_size":
int(pop_size),
"max_iter":
int(max_iter),
"lower_bound":
float(low_bound.replace(",", ".")),
"upper_bound":
float(upp_bound.replace(",", ".")),
"find_max":
extrem,
"prints":
0,
"average_result":
float(average_res.replace(",", ".")),
"best_result":
float(best_res.replace(",", ".")),
"similarity":
float(sim_results.replace(",", ".")),
"selection":
select_method,
"pairing":
pairing,
"crossover":
crossover_method,
"crossover_fraction":
float(crossover_fraction.replace(",", ".")),
"intermediate_offset":
float(intermediate_offset.replace(",", ".")),
# 0 mean child will be between parents, 1 mean offset is same as two parent distance
"mutation":
mutation_method,
"mutation_intensity":
float(mutation_intensity.replace(",", ".")),
"mutation_intensity_final":
float(mutation_intensity_final.replace(",", ".")),
"elitism":
float(elite_percent.replace(",", ".")),
"fitness_remapping":
fitness_remapping
}
if not self.inp_similarity_cb.isChecked():
options["similarity"] = None
if not self.inp_best_result_cb.isChecked():
options["best_result"] = None
if not self.inp_average_result_cb.isChecked():
options["average_result"] = None
return options
def cb_similarity_signal(self):
if self.inp_similarity_cb.isChecked():
self.inp_similarity.setEnabled(True)
self.inp_similarity.setStyleSheet("")
else:
self.inp_similarity.setEnabled(False)
self.inp_similarity.setStyleSheet("background:#555")
def cb_best_result_signal(self):
if self.inp_best_result_cb.isChecked():
self.inp_best_result.setEnabled(True)
self.inp_best_result.setStyleSheet("")
else:
self.inp_best_result.setEnabled(False)
self.inp_best_result.setStyleSheet("background:#555")
def cb_average_result_signal(self):
if self.inp_average_result_cb.isChecked():
self.inp_average_result.setEnabled(True)
self.inp_average_result.setStyleSheet("")
else:
self.inp_average_result.setEnabled(False)
self.inp_average_result.setStyleSheet("background:#555")
def _on_gate_combo_box_changed(self, combo: QComboBox, new_index: int):
with self._options as options:
options.set_layout_configuration_field(
"translator_configuration",
options.layout_configuration.translator_configuration.replace_requirement_for_gate(
combo.gate, combo.currentData()))
def _update_options_by_value(options: Options, combo: QComboBox, new_index: int):
with options:
setattr(options, combo.options_field_name, combo.currentData())
class StyleWidget(QWidget):
style_changed = Signal(SvgStyle)
def __init__(self, parent=None):
super(StyleWidget, self).__init__(parent)
self.label_line_length = QLabel(u'Длина линии')
self.spinbox_line_length = QSpinBox()
self.spinbox_line_length.setMinimum(10)
self.spinbox_line_length.setMaximum(250)
self.spinbox_line_length.setSingleStep(10)
self.spinbox_line_length.setValue(200)
self.label_line_width = QLabel(u'Толщина линии')
self.spinbox_line_width = QSpinBox()
self.spinbox_line_width.setMinimum(1)
self.spinbox_line_width.setMaximum(10)
self.spinbox_line_width.setSingleStep(1)
self.spinbox_line_width.setValue(2)
self.label_circle_rad = QLabel(u'Радиус круга')
self.spinbox_circle_rad = QSpinBox()
self.spinbox_circle_rad.setMinimum(1)
self.spinbox_circle_rad.setMaximum(30)
self.spinbox_circle_rad.setSingleStep(1)
self.spinbox_circle_rad.setValue(10)
self.label_line_color = QLabel(u'Цвет линии')
self.combobox_line_color = QComboBox()
self.combobox_line_color.addItem(u'черный', 'black')
self.combobox_line_color.addItem(u'красный', 'red')
self.combobox_line_color.addItem(u'зеленый', 'green')
self.combobox_line_color.addItem(u'синий', 'blue')
self.checkbox_normalize_circle_rad = QCheckBox(u'Круги одинакового размера')
layout = QGridLayout()
layout.addWidget(self.label_line_length, 0, 0, Qt.AlignRight)
layout.addWidget(self.spinbox_line_length, 0, 1)
layout.addWidget(self.label_line_width, 1, 0, Qt.AlignRight)
layout.addWidget(self.spinbox_line_width, 1, 1)
layout.addWidget(self.label_circle_rad, 2, 0, Qt.AlignRight)
layout.addWidget(self.spinbox_circle_rad, 2, 1)
layout.addWidget(self.label_line_color, 3, 0, Qt.AlignRight)
layout.addWidget(self.combobox_line_color, 3, 1)
layout.addWidget(self.checkbox_normalize_circle_rad, 4, 0, 1, 2)
layout.setRowStretch(5, 1)
self.setLayout(layout)
self.spinbox_line_length.valueChanged.connect(self.on_change)
self.spinbox_line_width.valueChanged.connect(self.on_change)
self.spinbox_circle_rad.valueChanged.connect(self.on_change)
self.combobox_line_color.activated.connect(self.on_change)
self.checkbox_normalize_circle_rad.stateChanged.connect(self.on_change)
self.on_change()
@Slot()
def on_change(self):
style = SvgStyle()
style.line_length = self.spinbox_line_length.value()
style.line_width = self.spinbox_line_width.value()
style.circle_stroke_width = self.spinbox_line_width.value()
style.circle_rad = self.spinbox_circle_rad.value()
style.line_color = self.combobox_line_color.currentData(Qt.UserRole)
style.circle_stroke_color = self.combobox_line_color.currentData(Qt.UserRole)
style.circle_rad_normalization = not self.checkbox_normalize_circle_rad.isChecked()
self.style_changed.emit(style)
class ResourceRequirementEditor:
def __init__(
self,
parent: QWidget,
layout: QHBoxLayout,
resource_database: ResourceDatabase,
item: ResourceRequirement,
):
self.parent = parent
self.layout = layout
self.resource_database = resource_database
self.resource_type_combo = _create_resource_type_combo(
item.resource.resource_type, parent, resource_database)
self.resource_type_combo.setMinimumWidth(75)
self.resource_type_combo.setMaximumWidth(75)
self.resource_name_combo = _create_resource_name_combo(
self.resource_database, item.resource.resource_type, item.resource,
self.parent)
self.negate_combo = QComboBox(parent)
self.negate_combo.addItem("≥", False)
self.negate_combo.addItem("<", True)
self.negate_combo.setCurrentIndex(int(item.negate))
self.negate_combo.setMinimumWidth(40)
self.negate_combo.setMaximumWidth(40)
self.amount_edit = QLineEdit(parent)
self.amount_edit.setValidator(QIntValidator(1, 10000))
self.amount_edit.setText(str(item.amount))
self.amount_edit.setMinimumWidth(45)
self.amount_edit.setMaximumWidth(45)
self.layout.addWidget(self.resource_type_combo)
self.layout.addWidget(self.resource_name_combo)
self.layout.addWidget(self.negate_combo)
self.layout.addWidget(self.amount_edit)
self.resource_type_combo.currentIndexChanged.connect(self._update_type)
def _update_type(self):
old_combo = self.resource_name_combo
self.resource_name_combo = _create_resource_name_combo(
self.resource_database, self.resource_type_combo.currentData(),
None, self.parent)
self.layout.replaceWidget(old_combo, self.resource_name_combo)
old_combo.deleteLater()
def deleteLater(self):
self.resource_type_combo.deleteLater()
self.resource_name_combo.deleteLater()
self.negate_combo.deleteLater()
self.amount_edit.deleteLater()
@property
def current_requirement(self) -> ResourceRequirement:
return ResourceRequirement(self.resource_name_combo.currentData(),
int(self.amount_edit.text()),
self.negate_combo.currentData())
class Window(QWidget):
def __init__(self):
super(Window, self).__init__()
self.proxyModel = QSortFilterProxyModel()
self.proxyModel.setDynamicSortFilter(True)
self.sourceGroupBox = QGroupBox("Original Model")
self.proxyGroupBox = QGroupBox("Sorted/Filtered Model")
self.sourceView = QTreeView()
self.sourceView.setRootIsDecorated(False)
self.sourceView.setAlternatingRowColors(True)
self.proxyView = QTreeView()
self.proxyView.setRootIsDecorated(False)
self.proxyView.setAlternatingRowColors(True)
self.proxyView.setModel(self.proxyModel)
self.proxyView.setSortingEnabled(True)
self.sortCaseSensitivityCheckBox = QCheckBox("Case sensitive sorting")
self.filterCaseSensitivityCheckBox = QCheckBox("Case sensitive filter")
self.filterPatternLineEdit = QLineEdit()
self.filterPatternLineEdit.setClearButtonEnabled(True)
self.filterPatternLabel = QLabel("&Filter pattern:")
self.filterPatternLabel.setBuddy(self.filterPatternLineEdit)
self.filterSyntaxComboBox = QComboBox()
self.filterSyntaxComboBox.addItem("Regular expression",
REGULAR_EXPRESSION)
self.filterSyntaxComboBox.addItem("Wildcard",
WILDCARD)
self.filterSyntaxComboBox.addItem("Fixed string",
FIXED_STRING)
self.filterSyntaxLabel = QLabel("Filter &syntax:")
self.filterSyntaxLabel.setBuddy(self.filterSyntaxComboBox)
self.filterColumnComboBox = QComboBox()
self.filterColumnComboBox.addItem("Subject")
self.filterColumnComboBox.addItem("Sender")
self.filterColumnComboBox.addItem("Date")
self.filterColumnLabel = QLabel("Filter &column:")
self.filterColumnLabel.setBuddy(self.filterColumnComboBox)
self.filterPatternLineEdit.textChanged.connect(self.filterRegExpChanged)
self.filterSyntaxComboBox.currentIndexChanged.connect(self.filterRegExpChanged)
self.filterColumnComboBox.currentIndexChanged.connect(self.filterColumnChanged)
self.filterCaseSensitivityCheckBox.toggled.connect(self.filterRegExpChanged)
self.sortCaseSensitivityCheckBox.toggled.connect(self.sortChanged)
sourceLayout = QHBoxLayout()
sourceLayout.addWidget(self.sourceView)
self.sourceGroupBox.setLayout(sourceLayout)
proxyLayout = QGridLayout()
proxyLayout.addWidget(self.proxyView, 0, 0, 1, 3)
proxyLayout.addWidget(self.filterPatternLabel, 1, 0)
proxyLayout.addWidget(self.filterPatternLineEdit, 1, 1, 1, 2)
proxyLayout.addWidget(self.filterSyntaxLabel, 2, 0)
proxyLayout.addWidget(self.filterSyntaxComboBox, 2, 1, 1, 2)
proxyLayout.addWidget(self.filterColumnLabel, 3, 0)
proxyLayout.addWidget(self.filterColumnComboBox, 3, 1, 1, 2)
proxyLayout.addWidget(self.filterCaseSensitivityCheckBox, 4, 0, 1, 2)
proxyLayout.addWidget(self.sortCaseSensitivityCheckBox, 4, 2)
self.proxyGroupBox.setLayout(proxyLayout)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.sourceGroupBox)
mainLayout.addWidget(self.proxyGroupBox)
self.setLayout(mainLayout)
self.setWindowTitle("Basic Sort/Filter Model")
self.resize(500, 450)
self.proxyView.sortByColumn(1, Qt.AscendingOrder)
self.filterColumnComboBox.setCurrentIndex(1)
self.filterPatternLineEdit.setText("Andy|Grace")
self.filterCaseSensitivityCheckBox.setChecked(True)
self.sortCaseSensitivityCheckBox.setChecked(True)
def setSourceModel(self, model):
self.proxyModel.setSourceModel(model)
self.sourceView.setModel(model)
def filterRegExpChanged(self):
syntax_nr = self.filterSyntaxComboBox.currentData()
pattern = self.filterPatternLineEdit.text()
if syntax_nr == WILDCARD:
pattern = QRegularExpression.wildcardToRegularExpression(pattern)
elif syntax_nr == FIXED_STRING:
pattern = QRegularExpression.escape(pattern)
regExp = QRegularExpression(pattern)
if not self.filterCaseSensitivityCheckBox.isChecked():
options = regExp.patternOptions()
options |= QRegularExpression.CaseInsensitiveOption
regExp.setPatternOptions(options)
self.proxyModel.setFilterRegularExpression(regExp)
def filterColumnChanged(self):
self.proxyModel.setFilterKeyColumn(self.filterColumnComboBox.currentIndex())
def sortChanged(self):
if self.sortCaseSensitivityCheckBox.isChecked():
caseSensitivity = Qt.CaseSensitive
else:
caseSensitivity = Qt.CaseInsensitive
self.proxyModel.setSortCaseSensitivity(caseSensitivity)
class DFATransitionEditor(QDialog):
signalEditedTransitionInfo = Signal(dict, dict)
signalTransitionDeletion = Signal(object, object)
def __init__(self, stateIds, symbols, initialInfo=None):
super(DFATransitionEditor, self).__init__()
self.setModal(True)
self.initialInfo = initialInfo
fromStateLabel = QLabel('from state: ')
self.fromStateComboBox = QComboBox(self)
toStateLabel = QLabel('to state: ')
self.toStateComboBox = QComboBox(self)
self.prepareDropdownLists(stateIds)
inputLabel = QLabel('on symbol: ')
self.inputComboBox = QComboBox(self)
for symbol in symbols:
self.inputComboBox.addItem(symbol, symbol)
self.fromStateComboBox.setCurrentIndex(0)
self.toStateComboBox.setCurrentIndex(0)
self.inputComboBox.setCurrentIndex(0)
self.deleteButton = QPushButton('Delete transition', self)
self.deleteButton.clicked.connect(self.deleteTransition)
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.sendCollectedInfo)
buttonBox.rejected.connect(self.reject)
layout = QGridLayout()
layout.addWidget(fromStateLabel, 0, 0)
layout.addWidget(toStateLabel, 1, 0)
layout.addWidget(inputLabel, 2, 0)
layout.addWidget(self.fromStateComboBox, 0, 1)
layout.addWidget(self.toStateComboBox, 1, 1)
layout.addWidget(self.inputComboBox, 2, 1)
layout.addWidget(self.deleteButton, 3, 0)
layout.addWidget(buttonBox, 4, 0)
self.setLayout(layout)
def prepareDropdownLists(self, stateIds):
for stateId in stateIds:
self.toStateComboBox.addItem('q{}'.format(stateIds.index(stateId)), stateId)
self.fromStateComboBox.addItem('q{}'.format(stateIds.index(stateId)), stateId)
def collectInfo(self):
return {'fromStateId': self.fromStateComboBox.currentData(), 'toStateId': self.toStateComboBox.currentData(),
'input': self.inputComboBox.currentData()}
def deleteTransition(self):
info = self.collectInfo()
self.signalTransitionDeletion.emit(info['fromStateId'], info['input'])
@Slot()
def sendCollectedInfo(self):
info = self.collectInfo()
self.signalEditedTransitionInfo.emit(info, self.initialInfo)
self.accept()
class TTVSetsExporterWidget(QWidget):
def __init__(
self,
dataset_io_providers=DatasetIORegistry,
parent: "QWidget" = None,
):
super().__init__(parent)
# Components
self._ttv: Optional["TTVSets"] = None
self._dataset_io_providers = dataset_io_providers
# Widgets
self._name_textbox = QLineEdit("Unnamed TTV")
self._name_textbox.setPlaceholderText("Name")
self._train_label = QLabel("")
self._test_label = QLabel("")
self._validation_label = QLabel("")
self._export_path_textbox = QLineEdit()
self._export_path_textbox.setReadOnly(True)
self._export_path_textbox.setPlaceholderText("Path...")
self._export_path_button = QPushButton("Directory...")
self._export_button = QPushButton("Export")
self._export_button.clicked.connect(self.export_ttv)
self._ttv_info_layout = QFormLayout()
self._ttv_info_layout.addRow("Name:", self._name_textbox)
self._ttv_info_layout.addRow("Train:", self._train_label)
self._ttv_info_layout.addRow("Test:", self._test_label)
self._ttv_info_layout.addRow("Validation:", self._validation_label)
self._export_path_layout = QHBoxLayout()
self._export_path_layout.addWidget(self._export_path_textbox)
self._export_path_layout.addWidget(self._export_path_button)
self._export_path_button.clicked.connect(self.pick_ttv_parent_dir)
self._ttv_info_layout.addRow("Export Path:", self._export_path_layout)
self._format_combobox = QComboBox()
for (name, dataset_io_factory
) in self._dataset_io_providers.providers.items():
self._format_combobox.addItem(name, dataset_io_factory())
self._ttv_info_layout.addRow("Format", self._format_combobox)
self._main_layout = QVBoxLayout()
self._main_layout.addLayout(self._ttv_info_layout)
self._main_layout.addWidget(self._export_button)
self.setLayout(self._main_layout)
def set_ttv(self, ttv: "TTVSets"):
"""Sets a new TTVSets object for exporting."""
self._ttv = ttv
self._update_labels_text()
LOGGER.info(f"TTVSets added to Export: {ttv}")
def pick_ttv_parent_dir(self):
LOGGER.debug("Picking a directory to export...")
ttv_parent_dir = QFileDialog.getExistingDirectory(
self, "Directory to export")
self._export_path_textbox.setText(ttv_parent_dir)
if ttv_parent_dir:
LOGGER.info("%s selected", ttv_parent_dir)
else:
LOGGER.debug("Selection cancelled.")
def export_ttv(self):
if not self._export_path_textbox.text():
LOGGER.info("TTV export parent directory not set!")
return
if not self._ttv:
LOGGER.info("TTV not set!")
return
self._ttv.name = self._name_textbox.text()
ttv_dir = self._export_path_textbox.text()
description_file_path = os.path.join(ttv_dir, "ttv_description.json")
dataset_io = self._format_combobox.currentData()
LOGGER.debug("Using %s formatter...", dataset_io)
ttv_description = TTVSetsIO.save_to_file(description_file_path,
dataset_io, self._ttv)
LOGGER.info("TTV Exported to %s", description_file_path)
LOGGER.debug(ttv_description)
def _update_labels_text(self):
"""Update the text labels to reflect the TTVSets information"""
self._name_textbox.setText(self._ttv.name)
self._train_label.setText(
f"{str(self._ttv.train if self._ttv else None)}")
self._test_label.setText(
f"{str(self._ttv.test if self._ttv else None)}")
self._validation_label.setText(
f"{str(self._ttv.validation if self._ttv else None)}")
