def __init__(self, lis, form, title="", parent=None):
self.title = title
self.lis = lis
self.form = form
self.widget = QtWidgets.QWidget(parent) # create a new widget
self.lay = QtWidgets.QVBoxLayout(
self.widget) # attach layout to that widget
self.label = QtWidgets.QLabel(self.title, self.widget)
self.subwidget = QtWidgets.QWidget(self.widget)
self.sublay = QtWidgets.QHBoxLayout(self.subwidget)
self.lay.addWidget(self.label)
self.lay.addWidget(self.subwidget)
self.subwidget.setSizePolicy(QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
self.lis.widget.setSizePolicy(QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Minimum)
self.lis.widget.setMaximumWidth(100)
# get widget from List and set its parent to widget
self.lis.widget.setParent(self.subwidget)
self.form.widget.setParent(self.subwidget)
# add List's internal widget to widget's layout
self.sublay.addWidget(self.lis.widget)
self.sublay.addWidget(self.form.widget)
self.lis.widget.currentItemChanged.connect(
self.form.chooseForm_slot) # connections between list and the form
self.form.signals.modified.connect(self.lis.update_slot)
self.modified = self.form.signals.modified # shorthand
def __init__(self, def_pixmap=None, parent=None):
QtWidgets.QWidget.__init__(self, parent)
self.signals = self.Signals()
self.pre = "NLineCrossingVideoWidget : "
self.lay = QtWidgets.QVBoxLayout(self)
self.canvas = NLineCrossingCanvasWidget(self.signals,
def_pixmap,
parent=self)
self.lay.addWidget(self.canvas)
# WARNING: the numerical constants are reversed between min/max...!
self.canvas.setSizePolicy(QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Minimum)
self.buttons = QtWidgets.QWidget(self)
self.lay.addWidget(self.buttons)
self.button1 = QtWidgets.QPushButton("Set 1", self.buttons)
self.linedef1 = QtWidgets.QSpinBox(self.buttons)
self.cbutton1 = QtWidgets.QPushButton("Clear 1", self.buttons)
self.button2 = QtWidgets.QPushButton("Set 2", self.buttons)
self.linedef2 = QtWidgets.QSpinBox(self.buttons)
self.cbutton2 = QtWidgets.QPushButton("Clear 2", self.buttons)
self.label1 = QtWidgets.QLabel("Min object size:")
self.sizedef = QtWidgets.QSpinBox(self.buttons)
self.linedef1.setRange(4, 60)
self.linedef2.setRange(4, 60)
self.sizedef.setRange(0, 200 * 200)
self.sizedef.setValue(50 * 100) # a nice predefined value
self.sizedef.setSingleStep(500)
for b in [
self.buttons, self.button1, self.linedef1, self.button2,
self.linedef2
]:
b.setSizePolicy(QtWidgets.QSizePolicy.Maximum,
QtWidgets.QSizePolicy.Maximum)
self.button_lay = QtWidgets.QHBoxLayout(self.buttons)
self.button_lay.addWidget(self.button1)
self.button_lay.addWidget(self.cbutton1)
self.button_lay.addWidget(self.linedef1)
self.button_lay.addWidget(self.button2)
self.button_lay.addWidget(self.cbutton2)
self.button_lay.addWidget(self.linedef2)
self.button_lay.addWidget(self.label1)
self.button_lay.addWidget(self.sizedef)
self.button1.clicked.connect(lambda: self.canvas.define_line_slot(0))
self.button2.clicked.connect(lambda: self.canvas.define_line_slot(1))
self.cbutton1.clicked.connect(lambda: self.canvas.clear_line_slot(0))
self.cbutton2.clicked.connect(lambda: self.canvas.clear_line_slot(1))
self.linedef1.valueChanged.connect(
lambda i: self.canvas.set_line_width_slot(0, i))
self.linedef2.valueChanged.connect(
lambda i: self.canvas.set_line_width_slot(1, i))
self.sizedef.valueChanged.connect(self.canvas.set_object_size_slot)
def makeWidget(self):
super().makeWidget()
self.button_row = QtWidgets.QWidget(self.widget)
self.button_lay = QtWidgets.QHBoxLayout(self.button_row)
self.lay.addWidget(self.button_row)
self.reset_button = QtWidgets.QPushButton("Reset", self.button_row)
self.save_button = QtWidgets.QPushButton("Save", self.button_row)
self.button_lay.addWidget(self.reset_button)
self.button_lay.addWidget(self.save_button)
self.save_button.setEnabled(False)
# row class instance => column (blocksize)=> corresponding widget
# ValkkaFSConfigRow has "blocksize" widget that is QSpinBox
self.row_instance["blocksize"].widget.valueChanged.connect(
self.mod_slot)
self.row_instance["n_blocks"].widget.valueChanged.connect(
self.mod_slot)
# should fix cutemongoforms: SpinBoxIntegerColumn should have
# getNotifySignal implemented..
st = (
"- Recording streams is experimental; please report bugs\n"
"- Modifying & saving the new parameters will clear all your recordings\n"
)
self.info_label = QtWidgets.QLabel(st, self.widget)
self.lay.addWidget(self.info_label)
self.reset_button.clicked.connect(self.row_instance.clear)
self.save_button.clicked.connect(self.save_slot)
def makeWidget(self):
"""Subclassed from Row : custom form. Add a total disk space field.
"""
self.widget = FormWidget()
self.lay = QtWidgets.QGridLayout(self.widget)
cc = 0
# self.placeWidget(cc, "record"); cc+=1
self.placeWidget(cc, "blocksize")
cc += 1
self.placeWidget(cc, "n_blocks")
cc += 1
self.label_total_size = QtWidgets.QLabel("Total Size (MB)",
self.widget)
self.label_total_size_value = QtWidgets.QLabel("", self.widget)
self.placeWidgetPair(
cc, (self.label_total_size, self.label_total_size_value))
cc += 1
#self.placeWidget(cc, "fs_flavor"); cc+=1
#self.placeWidget(cc, "partition_uuid"); cc+=1
self.connectNotifications()
def fs_size_changed():
total_size_mb = self["blocksize"].getValue(
) * self["n_blocks"].getValue()
self.label_total_size_value.setText(str(total_size_mb))
"""
def block_device_slot():
self["partition_uuid"].updateWidget()
n_devs = self["partition_uuid"].widget.count() # QComboBox.count()
if n_devs < 1:
self["fs_flavor"]["file"].setChecked(True)
"""
self["blocksize"].widget.valueChanged.connect(fs_size_changed)
self["n_blocks"].widget.valueChanged.connect(fs_size_changed)
# self["fs_flavor"]["valkkafs"].clicked.connect(block_device_slot)
fs_size_changed()
# block_device_slot()
"""
def getWidget(self):
"""Some ideas for your widget:
- Textual information (alert, license place number)
- Check boxes : if checked, send e-mail to your mom when the analyzer spots something
- .. or send an sms to yourself
- You can include the cv2.imshow window to the widget to see how the analyzer proceeds
"""
widget = QtWidgets.QLabel("nada de nada")
# widget.setStyleSheet(style.detector_test)
#self.signals.start_move.connect(lambda : widget.setText("MOVEMENT START"))
#self.signals.stop_move. connect(lambda : widget.setText("MOVEMENT STOP"))
return widget
def makeWidget(self):
super().makeWidget()
i = self.lay.count()
self.info_label = QtWidgets.QLabel(
("Cameralists and services are reinitiated\n"
"once you save & close this window\n"), self.widget)
self.lay.insertWidget(i, self.info_label)
# give a signal thats emitted once discovery has modified the camera list
self.discovery_win = QCapsulate(
DiscoveryWidget(sig=self.signals.modified), "Camera Discovery")
self.discovery_win.hide()
self.discovery_button = QtWidgets.QPushButton("Camera Search",
self.widget)
self.discovery_button.clicked.connect(self.discovery_slot)
self.lay.insertWidget(i + 1, self.discovery_button)
def makeWidget(self):
super().makeWidget()
self.button_row = QtWidgets.QWidget(self.widget)
self.button_lay = QtWidgets.QHBoxLayout(self.button_row)
self.lay.addWidget(self.button_row)
self.reset_button = QtWidgets.QPushButton("Reset", self.button_row)
self.save_button = QtWidgets.QPushButton("Save", self.button_row)
self.button_lay.addWidget(self.reset_button)
self.button_lay.addWidget(self.save_button)
self.info_label = QtWidgets.QLabel(
"Saving restarts all Valkka services", self.widget)
self.lay.addWidget(self.info_label)
self.reset_button.clicked.connect(self.row_instance.clear)
self.save_button.clicked.connect(self.save_slot)
def getWidget(self):
widget = QtWidgets.QLabel("NO TEXT YET")
widget.setStyleSheet(style.detector_test)
self.signals.text.connect(lambda message_object:\
widget.setText(message_object["message"]))
return widget
def setupUi(self):
rec = QtWidgets.QApplication.desktop().screenGeometry()
height = rec.height()
width = rec.width()
self.setGeometry(QtCore.QRect(0, 0, width, height // 2))
self.w = QtWidgets.QWidget(self)
self.setCentralWidget(self.w)
self.lay = QtWidgets.QVBoxLayout(self.w)
# return
# divide window into three parts
self.upper = QtWidgets.QWidget(self.w)
self.middle = QtWidgets.QWidget(self.w)
self.lower = QtWidgets.QWidget(self.w)
self.lowest = QtWidgets.QWidget(self.w)
self.lay.addWidget(self.upper)
self.lay.addWidget(self.middle)
self.lay.addWidget(self.lower)
self.lay.addWidget(self.lowest)
# upper part: detectors widget and the video itself
self.upperlay = QtWidgets.QHBoxLayout(self.upper)
# self.widget =QtWidgets.QTextEdit(self.upper)
self.widget = QtWidgets.QWidget(self.upper)
self.widget_lay = QtWidgets.QVBoxLayout(self.widget)
# self.widget = self.mvision_process.getWidget()
# self.widget.setParent(self.upper)
self.video_area = QtWidgets.QWidget(self.upper)
self.video_lay = QtWidgets.QGridLayout(self.video_area)
self.upperlay.addWidget(self.widget)
self.upperlay.addWidget(self.video_area)
self.widget.setSizePolicy(QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Minimum)
self.video_area.setSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding)
"""
[------|--------------------------------------]
[Open File] [Close Live] [Play] [Stop] [Rewind]
"""
self.middlelay = QtWidgets.QHBoxLayout(self.middle)
self.slider = QtWidgets.QSlider(QtCore.Qt.Orientation.Horizontal,
self.middle)
self.middlelay.addWidget(self.slider)
self.slider.setTracking(False)
self.lowerlay = QtWidgets.QHBoxLayout(self.lower)
self.open_file_button = QtWidgets.QPushButton("Open File", self.lower)
self.close_file_button = QtWidgets.QPushButton("Close File",
self.lower)
self.play_button = QtWidgets.QPushButton("Play", self.lower)
self.stop_button = QtWidgets.QPushButton("Stop", self.lower)
self.rewind_button = QtWidgets.QPushButton("<<", self.lower)
self.seek_label = QtWidgets.QLabel("<<", self.lower)
self.lowerlay.addWidget(self.open_file_button)
self.lowerlay.addWidget(self.close_file_button)
self.lowerlay.addWidget(self.play_button)
self.lowerlay.addWidget(self.stop_button)
self.lowerlay.addWidget(self.rewind_button)
self.lowerlay.addWidget(self.seek_label)
self.open_file_button.clicked.connect(self.open_file_button_slot)
self.close_file_button.clicked.connect(self.close_file_button_slot)
self.play_button.clicked.connect(self.play_button_slot)
self.stop_button.clicked.connect(self.stop_button_slot)
self.rewind_button.clicked.connect(self.rewind_button_slot)
self.slider.valueChanged.connect(self.slider_slot)
# lowest part: some text
self.lowestlay = QtWidgets.QVBoxLayout(self.lowest)
self.infotext = QtWidgets.QLabel("info text", self.lowest)
self.lowestlay.addWidget(self.infotext)
def __init__(self, ip, slot=1, max_slot=32, parent=None):
"""
ip corresponds to slot
max ip = ip + (max_slot - slot)
"""
super().__init__(parent)
self.setWindowTitle("Configuration Copy")
self.max_dn = max_slot - slot
assert(isinstance(slot, int))
ip_nums=[]
for part in ip.split("."):
ip_nums.append(int(part))
self.start_ip_text = ip
self.min_num = ip_nums.pop(-1) # take the last number
self.max_num = self.min_num + self.max_dn
self.min_slot = slot
self.stop_ip_text =""
for part in ip_nums:
self.stop_ip_text += str(part)+"."
self.lay = QtWidgets.QVBoxLayout(self)
self.field = QtWidgets.QWidget(self)
self.buttons = QtWidgets.QWidget(self)
self.lay.addWidget(self.field)
self.lay.addWidget(self.buttons)
self.field_lay = QtWidgets.QGridLayout(self.field)
self.buttons_lay = QtWidgets.QHBoxLayout(self.buttons)
self.ip_label = QtWidgets.QLabel("IP range", self.field)
self.slot_label = QtWidgets.QLabel("Slot range", self.field)
self.field_lay.addWidget(self.ip_label, 0, 0)
self.field_lay.addWidget(self.slot_label, 1, 0)
self.ip_field = QtWidgets.QWidget(self.field)
self.slot_field = QtWidgets.QWidget(self.field)
self.field_lay.addWidget(self.ip_field, 0, 1)
self.field_lay.addWidget(self.slot_field, 1, 1)
self.write_button = QtWidgets.QPushButton("Overwrite slots", self.buttons)
self.cancel_button = QtWidgets.QPushButton("Cancel", self.buttons)
# self.buttons_lay.addWidget(self.write_button, 2, 0)
# self.buttons_lay.addWidget(self.cancel_button, 3, 0)
self.buttons_lay.addWidget(self.write_button)
self.buttons_lay.addWidget(self.cancel_button)
self.ip_field_lay = QtWidgets.QHBoxLayout(self.ip_field)
self.slot_field_lay = QtWidgets.QHBoxLayout(self.slot_field)
self.ip_field_label = QtWidgets.QLabel(
self.start_ip_text +
" - " +
self.stop_ip_text)
self.ip_field_input = QtWidgets.QSpinBox(self.ip_field)
self.ip_field_lay.addWidget(self.ip_field_label)
self.ip_field_lay.addWidget(self.ip_field_input)
self.ip_field_input.setMinimum(self.min_num)
self.ip_field_input.setMaximum(self.max_num)
self.slot_field_label = QtWidgets.QLabel(self.slot_field)
self.slot_field_lay.addWidget(self.slot_field_label)
self.ip_field_input.valueChanged.connect(self.update_ip_slot)
self.write_button.clicked.connect(lambda: self.done(1))
self.cancel_button.clicked.connect(lambda: self.done(0))
self.update_ip_slot(self.min_num)
def makeWidget(self):
"""Subclassed from Row : custom form. Add a summary RTSP address in the end of the form, etc.
"""
# super().makeWidget() # do all by hand
self.widget = FormWidget()
self.lay = QtWidgets.QGridLayout(self.widget)
cc = 0
self.placeWidget(cc, "slot")
cc += 1
self.placeWidget(cc, "address")
cc += 1
self.placeWidget(cc, "username")
cc += 1
self.placeWidget(cc, "password")
cc += 1
self.placeWidget(cc, "port")
cc += 1
self.placeWidget(cc, "tail")
cc += 1
self.placeWidget(cc, "force_tcp")
cc += 1
self.placeWidget(cc, "record")
cc += 1
# self.setVisible("tail", False) # test
# Mainstream
self.label_mainstream = QtWidgets.QLabel("Mainstream", self.widget)
self.label_mainstream.setStyleSheet(style.form_highlight)
self.placeWidgetPair(cc, (self.label_mainstream, None))
cc += 1
self.placeWidget(cc, "subaddress_main")
cc += 1
# complete RTSP address
self.label_mainstream_address = QtWidgets.QLabel(
"RTSP address", self.widget)
self.mainstream_address = QtWidgets.QLabel("", self.widget)
self.placeWidgetPair(
cc, (self.label_mainstream_address, self.mainstream_address))
cc += 1
# live and rec
self.placeWidget(cc, "live_main")
cc += 1
self.placeWidget(cc, "rec_main")
cc += 1
# Substream
self.label_substream = QtWidgets.QLabel("Substream", self.widget)
self.label_substream.setStyleSheet(style.form_highlight)
self.placeWidgetPair(cc, (self.label_substream, None))
cc += 1
self.label_substream.setVisible(False) # hide for the moment
self.placeWidget(cc, "subaddress_sub")
cc += 1
# complete RTSP address
self.label_substream_address = QtWidgets.QLabel(
"RTSP address", self.widget)
self.substream_address = QtWidgets.QLabel("", self.widget)
self.placeWidgetPair(
cc, (self.label_substream_address, self.substream_address))
cc += 1
self.label_substream_address.setVisible(False)
self.substream_address.setVisible(False)
# .. hide for the moment
# live and rec
self.placeWidget(cc, "live_sub")
cc += 1
self.placeWidget(cc, "rec_sub")
cc += 1
""" # definitely NOT here!
# self.copy_label = QtWidgets.QLabel("Copy this camera", self.widget)
self.copy_button = QtWidgets.QPushButton("Copy", self.widget)
self.placeWidgetPair(cc, (self.copy_button, None))
self.copy_button.clicked.connect(self.copy_slot)
"""
self.connectNotifications()
def rec_main_clicked():
if not self["live_main"].widget.isChecked(): # rec requires live
print("live_main is NOT checked")
self["rec_main"].widget.setChecked(False)
if self["rec_main"].widget.isChecked(
): # rec main excludes rec sub
self["rec_sub"].widget.setChecked(False)
def rec_sub_clicked():
if not self["live_sub"].widget.isChecked(): # rec requires live
print("live_sub is NOT checked")
self["rec_sub"].widget.setChecked(False)
if self["rec_sub"].widget.isChecked(): # rec sub excludes rec main
self["rec_main"].widget.setChecked(False)
self["rec_main"].widget.clicked.connect(rec_main_clicked)
self["rec_sub"].widget.clicked.connect(rec_sub_clicked)
self.widget.signals.show.connect(self.show_slot)
# TODO: remove these restrictions once functional:
"""
self["subaddress_main"].widget.setEnabled(False)
self["subaddress_sub"].widget.setEnabled(False)
self["live_main"].widget.setEnabled(False)
self["rec_main"].widget.setEnabled(False)
self["live_sub"].widget.setEnabled(False)
self["rec_sub"].widget.setEnabled(False)
"""
self.setVisible("subaddress_main", False)
self.setVisible("subaddress_sub", False)
self.setVisible("live_main", False)
self.setVisible("rec_main", False)
self.setVisible("live_sub", False)
self.setVisible("rec_sub", False)
def setupUi(self):
self.setStyleSheet(style.main_gui)
self.setWindowTitle(singleton.program_name)
self.setGeometry(QtCore.QRect(100, 100, 500, 500))
self.w = QtWidgets.QWidget(self)
self.setCentralWidget(self.w)
self.filemenu = FileMenu(parent=self)
self.viewmenu = ViewMenu(parent=self) # grids up to 4x4
self.configmenu = ConfigMenu(parent=self)
if self.mvision:
mvision_elements = []
for cl in self.mvision_classes + self.mvision_client_classes:
if cl.auto_menu:
# # instead: all visible in menus
# # but if auto_menu is False, then must be connected
# # manually .. actually, we'd need auto_connect switch.
el = QuickMenuElement(title=cl.name, method_name=cl.name)
mvision_elements.append(el)
class MVisionMenu(QuickMenu):
title = "Machine Vision"
elements = mvision_elements
self.mvisionmenu = MVisionMenu(parent=self)
self.aboutmenu = AboutMenu(parent=self)
# create container and their windows
self.manage_cameras_container = singleton.data_model.getDeviceListAndForm(
None)
self.manage_memory_container = singleton.data_model.getConfigForm()
self.manage_memory_container.signals.save.connect(
self.config_modified_slot)
self.manage_cameras_container.getForm().signals.save_record.connect(
self.config_modified_slot)
tabs = [
(self.manage_cameras_container.widget, "Camera Configuration"),
(self.manage_memory_container.widget, "Memory Configuration"),
]
if singleton.use_playback:
self.manage_valkkafs_container = singleton.data_model.getValkkaFSForm(
)
self.manage_valkkafs_container.signals.save.connect(
self.valkkafs_modified_slot)
tabs.append((self.manage_valkkafs_container.widget,
"Recording Configuration"))
self.config_win = QTabCapsulate("Configuration", tabs)
self.config_win.signals.close.connect(self.config_dialog_close_slot)
self.config_win.signals.close.connect(
self.manage_cameras_container.close_slot)
# == inform ListAndForm that it has been closed => it knows to close any extra wins / dialogs present
# when the configuration dialog is reopened, inform the camera configuration form .. this way it can re-check if usb cams are available
self.config_win.signals.show.connect(
self.manage_cameras_container.getForm().show_slot)
self.config_win.signals.show.connect(
self.manage_cameras_container.choose_first_slot
) # so that we have at least one device chosen
self.makeCameraTree()
self.camera_list_win = QCapsulate(self.treelist, "Camera List")
self.wait_label = QtWidgets.QLabel("Restarting Valkka, please wait ..")
self.wait_window = QCapsulate(self.wait_label, "Wait", nude=True)