def load_settings(self, settings):
if settings is not None:
cue = Application().cue_model.get(settings['target_id'])
if cue is not None:
self.cue_id = settings['target_id']
self.seekEdit.setTime(
QTime.fromMSecsSinceStartOfDay(settings['time']))
self.seekEdit.setMaximumTime(
QTime.fromMSecsSinceStartOfDay(cue.media.duration))
self.cueLabel.setText(cue.name)
def load_settings(self, settings):
if settings is not None:
cue = Application().cue_model.get(settings.get('target_id'))
if cue is not None:
self.cue_id = settings['target_id']
self.seekEdit.setMaximumTime(
QTime.fromMSecsSinceStartOfDay(cue.media.duration))
self.cueLabel.setText(cue.name)
self.seekEdit.setTime(
QTime.fromMSecsSinceStartOfDay(settings.get('time', 0)))
def __init__(self, parent, document):
super(DlgProperties, self).__init__(parent)
self.setupUi(self)
self.document = document
self.setWindowTitle('{} Properties'.format(self.document.title))
# Sampling rate
self.tableWidget.item(0, 1).setText('{:} kHz ({:,} Hz)'.format(
self.document.sampling_rate / 1000.0, self.document.sampling_rate))
# Bit depth
self.tableWidget.item(1, 1).setText('{}-bit'.format(
self.document.bytes_per_sample * 8))
# Number of channels
self.tableWidget.item(2, 1).setText(str(self.document.channels))
# Duration
duration = QTime.fromMSecsSinceStartOfDay(1000 * self.document.frames /
self.document.sampling_rate)
self.tableWidget.item(3, 1).setText('{:02}:{:02}:{:02}.{:03}'.format(
duration.hour(), duration.minute(), duration.second(),
duration.msec()))
def select_cue(self):
if self.cueDialog.exec_() == self.cueDialog.Accepted:
cue = self.cueDialog.selected_cues()[0]
self.cue_id = cue.id
self.seekEdit.setMaximumTime(
QTime.fromMSecsSinceStartOfDay(cue.media.duration))
self.cueLabel.setText(cue.name)
def select_cue(self):
if self.cueDialog.exec_() == self.cueDialog.Accepted:
cue = self.cueDialog.selected_cue()
if cue is not None:
self.cue_id = cue.id
self.seekEdit.setMaximumTime(
QTime.fromMSecsSinceStartOfDay(cue.media.duration))
self.cueLabel.setText(cue.name)
def _selectReminder(self):
reminder: Reminder = self._getCurrentReminder()
if reminder is None:
self.ui.daysBox.setEnabled( False )
self.ui.hoursEdit.setEnabled( False )
self.ui.removePB.setEnabled( False )
return
self.ui.daysBox.setEnabled( True )
self.ui.hoursEdit.setEnabled( True )
self.ui.removePB.setEnabled( True )
timeOffset = reminder.splitTimeOffset()
self.ui.daysBox.setValue( timeOffset[0] )
time = QTime.fromMSecsSinceStartOfDay( timeOffset[1] * 1000 )
self.ui.hoursEdit.setTime( time )
def __init__(self, parent):
super(DlgNew, self).__init__(parent)
self.setupUi(self)
# Read configuration settings
settings = QSettings()
# TODO - need to figure out DDV/DDX
self.sampling_rate = settings.value(
Settings.DOC_SAMPLING_RATE,
defaultValue=Settings.DOC_SAMPLING_RATE_DFLT)
self.rate_comboBox.setCurrentText('{} Hz'.format(self.sampling_rate))
# TODO - need to figure out DDV/DDX
self.bytes_per_sample = settings.value(
Settings.DOC_BYTES_PER_SAMPLE,
defaultValue=Settings.DOC_BYTES_PER_SAMPLE_DFLT)
self.bitd_16bit_radioButton.setChecked(self.bytes_per_sample == 2)
self.bitd_24bit_radioButton.setChecked(self.bytes_per_sample == 3)
self.bitd_32bitfloat_radioButton.setChecked(self.bytes_per_sample == 4)
# TODO - need to figure out DDV/DDX
self.channels = settings.value(Settings.DOC_CHANNELS,
defaultValue=Settings.DOC_CHANNELS_DFLT)
self.chan_1_radioButton.setChecked(self.channels == 1)
self.chan_2_radioButton.setChecked(self.channels == 2)
# TODO - need to figure out DDV/DDX
self.frames = settings.value(Settings.DOC_FRAMES,
defaultValue=Settings.DOC_FRAMES_DFLT)
duration_msec = 1000 * self.frames / self.sampling_rate # TODO - fix this
duration = QTime.fromMSecsSinceStartOfDay(duration_msec)
self.idur_hrs_spinBox.setValue(duration.hour())
self.idur_mins_spinBox.setValue(duration.minute())
self.idur_secs_spinBox.setValue(duration.second())
self.idur_msec_spinBox.setValue(duration.msec())
self.max_freq_fmt = self.rate_maxfreq_label.text()
self.update_ui()
def _to_qtime(self, m_seconds):
return QTime.fromMSecsSinceStartOfDay(m_seconds)
def load_settings(self, settings):
self.functionCombo.setCurrentText(settings.get('preset', ''))
self.functionDuration.setTime(
QTime.fromMSecsSinceStartOfDay(settings.get('duration', 0)))
def _to_qtime(self, time):
return QTime.fromMSecsSinceStartOfDay(time * 100)
def _to_qtime(self, m_seconds):
return QTime.fromMSecsSinceStartOfDay(m_seconds)
def connectSignals():
# Print messages to statusbar and console
camera.device_status[str].connect(ui.statusbar.showMessage)
#camera.device_status[str].connect(print)
camera.device_name[str].connect(lambda val: ui.camLabel.setText("Preview (" + val + "):"))
#disposablecam.status[str].connect(print)
recordingcam.status[str].connect(ui.statusbar.showMessage)
extractcam.status[str].connect(ui.statusbar.showMessage)
if settingswatchdog.addPath("settings.json"):
def reloadSettings():
fimsettings.loadSettings()
pullSettings()
# Apparantly gedit rewrites text files when saving them,
# causing QFileSystemWatcher stopping to monitor them
# This re-adds the file after reloading the modified settings.
# This definitively does not happen on win32,
# not sure about darwin and other unixoids, though.
# Season to taste.
if sys.platform not in ["win32", "darwin"]:
settingswatchdog.addPath("settings.json")
settingswatchdog.fileChanged[str].connect(reloadSettings)
logger.info("Watching settings.json for changes.")
# Handle QActions
ui.actionSnapshot.triggered.connect(saveSnapshot)
ui.actionRefresh.triggered.connect(bootstrapCam)
ui.actionRecord.toggled[bool].connect(recordVideo)
ui.actionExtract_Frames_from_Video.toggled[bool].connect(extractFrames)
ui.actionLoad_Parameters.triggered.connect(openParamFile)
ui.actionSave_Parameters.triggered.connect(writeParamFile)
ui.actionSettings.triggered.connect(lambda: open_extern())
ui.actionSettings.triggered.connect(lambda: logger.info("Opening settings.json in external editor."))
# Handle pyloncom & pylonproc signals
recordingcam.timelimit_reached.connect(ui.actionRecord.toggle)
recordingcam.fimjson_path[str].connect(lambda val: pushSettings(os.path.dirname(val),
os.path.basename(val),
True
)
)
recordingcam.frame_written.connect(lambda: ui.progressBar.setValue(recordingcam.framecount))
recordingcam.frame_written.connect(lambda: ui.progressBar.setFormat(QTime.fromMSecsSinceStartOfDay(
math.floor(recordingcam.framecount /
recordingcam.fps *
1000)).toString()))
extractcam.max_frames.connect(ui.progressBar.setMaximum)
extractcam.timelimit_reached.connect(ui.actionExtract_Frames_from_Video.toggle)
extractcam.frame_written.connect(lambda: ui.progressBar.setValue(extractcam.framecount))
extractcam.frame_written.connect(lambda: ui.progressBar.setFormat(str(extractcam.framecount) +
'/' +
str(extractcam.maxframes)))
app.aboutToQuit.connect(pcthread.exit)
pcthread.started.connect(lambda: previewcam.startProcessing(camera.frame_grabbed))
# Connect widgets to cam classes and SettingsHandler
# Replace lambda by functools.partial?
ui.ExpTimeSpinBox.valueChanged[int].connect(
lambda val: camera.baslerace.setCamAttr(EXPOSURETIME, val)
)
ui.ExpTimeSpinBox.valueChanged[int].connect(
lambda val: fimsettings.parameters.__setitem__('Exposure Time', val)
)
# camera.is_grabbing.connect(lambda: ui.statusbar.showMessage("grabbing..."))
ui.ExpAutoChkBx.toggled[bool].connect(toggleExposureAuto)
#ui.FpsEnableChkBx.toggled[bool].connect(
# lambda val: camera.baslerace.setCamAttr('AcquisitionFrameRateEnable', int(val))
#)
ui.BgChkBx.toggled[bool].connect(
lambda val: setattr(camera.baslerace, 'subtractbg', val)
)
ui.CutoffChkBx.toggled[bool].connect(
lambda val: setattr(camera.baslerace, 'cutoff', val)
)
ui.StretchHistoChkBx.toggled[bool].connect(
lambda val: setattr(camera.baslerace, 'stretchhistogram', val)
)
ui.RecalcBgBtn.pressed.connect(
lambda: camera.baslerace.resetbackground(ui.BgSpinBox.value())
)
ui.FpsDSpinBox.valueChanged[float].connect(
lambda val: camera.baslerace.setCamAttr(ACQUISITIONFRAMERATE, val)
)
ui.GammaDSpinBox.valueChanged[float].connect(
lambda val: camera.baslerace.setCamAttr('Gamma', val)
)
if not camera.baslerace.emulated:
ui.GainDSpinBox.valueChanged[float].connect(
lambda val: camera.baslerace.setCamAttr('Gain', val)
)
ui.BlacklvlDSpinBox.valueChanged[float].connect(
lambda val: camera.baslerace.setCamAttr('BlackLevel', val)
)
ui.CutoffSpinBox.valueChanged[int].connect(
lambda val: setattr(camera.baslerace, 'threshold', val)
)
ui.CutoffSpinBox.valueChanged[int].connect(
lambda val: logger.debug("Cutoff Threshold: " + str(val))
)
ui.StretchHistoDSpinBox.valueChanged[float].connect(
lambda val: setattr(camera.baslerace, 'stretchfactor', val)
)
ui.StretchHistoDSpinBox.valueChanged[float].connect(
lambda val: logger.debug("Histogram Stretch Factor: " + str(val))
)
# Doesn't work without lambda? o.รด
ui.FpsDSpinBox.valueChanged[float].connect(lambda val: recordingcam.changeFps(val))
# Update recording duration when fps gets changed
ui.FpsDSpinBox.valueChanged.connect(lambda val: recordingcam.msecsToFrames(QTimeToMsecs(ui.RecDurTEdit.time())))
ui.RecDurTEdit.timeChanged.connect(lambda val: recordingcam.msecsToFrames(QTimeToMsecs(val)))
app.aboutToQuit.connect(pushSettings)
