def __init__(self, window):
super().__init__()
self.setupUi(self)
# API init.
self.control = api.control()
# Panel init.
self.setFixedSize(window.app.primaryScreen().virtualSize())
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground, True)
self.uiCalibratedOnTemplate = self.uiCalibratedOn.text()
# Button binding.
api.observe('cameraSerial', self.recieveSerial)
self.uiSetSerialBtn.clicked.connect(self.sendSerial)
self.uiCal.clicked.connect(self.runCal)
self.uiExportCalData.clicked.connect(self.runExportCalData)
self.uiImportCalData.clicked.connect(self.runImportCalData)
settings.observe('last factory cal', None, self.recieveFactoryCalDate)
settings.observe('debug controls enabled', False, lambda x:
self.uiShowDebugControls.setChecked(x) )
self.uiShowDebugControls.stateChanged.connect(lambda x:
settings.setValue('debug controls enabled', bool(x)) )
self.uiDone.clicked.connect(lambda: window.show('main'))
def updateMotionHeatmap(self) -> None:
"""Repaint the motion heatmap when we enter this screen.
We never record while on the playback screen, so we don't
have to live-update here. This is partially due to the
fact that the camera is modal around this, it can either
record xor playback."""
return #Heatmap got delayed. Just return for now…
heatmapHeight = 16
motionData = QByteArray.fromRawData(api.control('waterfallMotionMap', {'segment':'placeholder', 'startFrame':400})["heatmap"]) # 16×(n<1024) heatmap. motionData: {"startFrame": int, "endFrame": int, "heatmap": QByteArray}
assert len(motionData) % heatmapHeight == 0, f"Incompatible heatmap size {len(motionData)}; must be a multiple of {heatmapHeight}."
self.motionHeatmap = (
QImage( #Rotated 90°, since the data is packed line-by-line. We'll draw it counter-rotated.
heatmapHeight,
len(motionData)//heatmapHeight,
QImage.Format_Grayscale8)
.transformed(QTransform().rotate(-90).scale(-1,1))
.scaled(
self.uiTimelineVisualization.width(),
self.uiTimelineVisualization.height(),
transformMode=QtCore.Qt.SmoothTransformation)
)
self.uiTimelineVisualization.update() #Invokes self.paintMotionHeatmap if needed.
def __init__(self, window):
super().__init__()
self.setupUi(self)
# API init.
self.control = api.control()
# Shipping mode timer init
self.shippingModeStatusTimer = QTimer()
self.shippingModeStatusTimer.timeout.connect(self.shippingModeStatus)
self.shippingModeStatusTimer.setInterval(1000)
self.shippingModeStatusTimer.start()
# Panel init.
self.setFixedSize(window.app.primaryScreen().virtualSize())
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground, True)
self.window_ = window
self.uiPassword.setText('') #Clear placeholder text.
self.uiPassword.textChanged.connect(self.checkPassword)
self.uiShippingMode.setChecked(self.control.getSync('shippingMode'))
self.uiShippingMode.stateChanged.connect(self.setShippingMode)
self.uiDone.clicked.connect(window.back)
def __init__(self, window):
super().__init__()
self.setupUi(self)
# API init.
self.control = api.control()
# Panel init.
self.setFixedSize(window.app.primaryScreen().virtualSize())
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground, True)
self.window_ = window
self.state = 0
self.aShortPeriodOfTime = QtCore.QTimer()
self.aShortPeriodOfTime.timeout.connect(self.afterAShortPeriodOftime)
self.aShortPeriodOfTime.start(16) #One frame is a short period of time.
# Button binding.
self.uiDebug.clicked.connect(lambda: self and dbg()) #"self" is needed here, won't be available otherwise.
#self.uiDebug.clicked.connect(lambda: self.decimalspinbox_3.availableUnits()) #"self" is needed here, won't be available otherwise.
self.uiBack.clicked.connect(window.back)
rtl = self.control.callSync('getResolutionTimingLimits', self.control.getSync('resolution'))
self.uiSlider.setMaximum(rtl['exposureMax'])
self.uiSlider.setMinimum(rtl['exposureMin'])
self.uiSlider.debounce.sliderMoved.connect(self.onExposureChanged)
api.observe('exposurePeriod', self.updateExposureNs)
def __init__(self, window):
super().__init__()
self.setupUi(self)
# API init.
self.control = api.control()
# Panel init.
self.setFixedSize(window.app.primaryScreen().virtualSize())
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground, True)
#Color Temperature
try:
api.observe('wbTemperature', lambda temp:
self.uiColorTemperature.setValue(temp) )
self.uiColorTemperature.valueChanged.connect(lambda temp:
self.control.set('wbTemperature', temp) )
except AssertionError as e:
log.error(f'Could not connect widgets to wbTemperature.\n{e}')
#White Balance Matrix
try:
api.observe('wbColor', lambda color: (
self.uiWBRed.setValue(color[0]),
self.uiWBGreen.setValue(color[1]),
self.uiWBBlue.setValue(color[2]),
))
for wbInput in [self.uiWBRed, self.uiWBGreen, self.uiWBBlue]:
wbInput.valueChanged.connect(lambda *_:
self.control.set('wbColor', [
self.uiWBRed.value(),
self.uiWBGreen.value(),
self.uiWBBlue.value(),
]) )
except AssertionError as e:
log.error(f'Could not connect widgets to wbColor.\n{e}')
#Color Matrix Preset
self.uiColorMatrixPreset.clear()
self.uiColorMatrixPreset.insertItem(0, self.tr('CIECAM02/D55'), 'CIECAM02/D55')
self.uiColorMatrixPreset.insertItem(1, self.tr('CIECAM16/D55'), 'CIECAM16/D55')
self.uiColorMatrixPreset.insertItem(2, self.tr('Identity'), 'identity')
self.uiColorMatrixPreset.insertItem(3, self.tr('Custom'), None)
self.uiColorMatrixPreset.currentIndexChanged.connect(lambda index:
self.setCM(
presets[self.uiColorMatrixPreset.itemData(index)]
if self.uiColorMatrixPreset.itemData(index) else
settings.value('customColorMatrix', presets['identity'])
)
)
#Color Matrix
api.observe('colorMatrix', self.updateCMInputs)
for cmInput in self.colorMatrixInputs():
cmInput.valueChanged.connect(self.cmUpdated)
#Navigation
self.uiDone.clicked.connect(window.back)
def __init__(self, window):
super().__init__()
self.setupUi(self)
# API init.
self.control = api.control()
# Panel init.
self.setFixedSize(window.app.primaryScreen().virtualSize())
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground, True)
#Substitute constants into header bit.
self.control.get(['cameraModel', 'cameraMemoryGB', 'sensorColorPattern', 'cameraSerial', 'cameraApiVersion', 'cameraFpgaVersion']).then(
lambda values:
self.uiText.setText(
self.uiText.text()
.replace('{MODEL}', f"{values['cameraModel']}, {values['cameraMemoryGB']}, {'mono' if values['sensorColorPattern'] == 'mono' else 'color'}")
.replace('{SERIAL_NUMBER}', values['cameraSerial'])
.replace('{UI_VERSION}', appVersion)
.replace('{API_VERSION}', values['cameraApiVersion'])
.replace('{FPGA_VERSION}', values['cameraFpgaVersion'])
)
)
settings.observe('theme', 'dark', lambda name: (
self.uiScrollArea.setStyleSheet(f"""
color: {theme(name).text};
background: {theme(name).base};
border: 1px solid {theme(name).border};
"""),
self.uiText.setStyleSheet(f"""
border: none;
padding: 5px;
""")
))
# Set scroll bar to scroll all text content.
self.uiScroll.setMaximum(
self.uiText.height() - self.uiScrollArea.height() )
#Add drag-to-scroll to text content.
self.uiScrollArea.setFocusPolicy(QtCore.Qt.NoFocus)
QScroller.grabGesture(self.uiScrollArea.viewport(), QScroller.LeftMouseButtonGesture) #DDR 2019-01-15: Defaults to TouchGesture - which should work, according to WA_AcceptTouchEvents, but doesn't.
scroller = QScroller.scroller(self.uiScrollArea.viewport())
properties = scroller.scrollerProperties()
properties.setScrollMetric(properties.AxisLockThreshold, 0.0)
properties.setScrollMetric(properties.MousePressEventDelay, 0.0)
properties.setScrollMetric(properties.DragStartDistance, 0.0) #default: 0.005 - tweaked for "feel", the platform defaults are overly dramatic.
properties.setScrollMetric(properties.OvershootDragDistanceFactor, 0.3) #default: 1
properties.setScrollMetric(properties.OvershootScrollDistanceFactor, 0.3) #default: 1
properties.setScrollMetric(properties.OvershootScrollTime, 0.5) #default: 0.7
scroller.setScrollerProperties(properties)
# Button binding.
self.uiScroll.valueChanged.connect(self.scrollPane)
self.uiScrollArea.verticalScrollBar().valueChanged.connect(self.scrollKnob)
self.uiDone.clicked.connect(window.back)
def linkedValueName(self, newLinkedValueName):
self._linkedValueName = newLinkedValueName
if newLinkedValueName and api: #API may not load in Qt Designer if it's not been set up.
api.observe(newLinkedValueName, self.__updateValue)
if hasattr(self, 'setValue'): #Most inputs.
self.valueChanged.connect(
lambda val: api.control().set({
self._linkedValueName: self.realValue() }) )
elif hasattr(self, 'setChecked'): #Checkbox
self.stateChanged.connect(
lambda val: api.control().set({
self._linkedValueName: val != 0 }) )
elif hasattr(self, 'setText'): #Line edit
self.editingFinished.connect(
lambda: api.control().set({
self._linkedValueName: self.text() }) )
else:
raise ValueError(f'Unknown type of widget to observe. (send on ${self})')
def __init__(self, window):
super().__init__()
self.setupUi(self)
# API init.
self.control = api.control()
# Panel init.
self.setFixedSize(window.app.primaryScreen().virtualSize())
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground, True)
# Set up panel switching.
#DDR 2018-07-24: It's impossible to associate an identifier with anything in QT Designer. Painfully load the identifiers here. Also check everything because I will mess this up next time I add a trigger.
#DDR 2019-08-01: Aaaand the safety check paid off. Told myself.
if(self.uiRecordMode.count() != len(self.availableRecordModeIds)):
raise Exception("Record mode screen available record mode IDs does not match the number of textual entries in uiRecordMode.")
if(self.uiRecordModePanes.count() != len(self.availableRecordModeIds)):
raise Exception("Record mode screen available record mode IDs does not match the number of uiRecordModePanes panes.")
currentScreenId = settings.value('active record mode', self.availableRecordModeIds[0])
if(currentScreenId not in self.availableRecordModeIds):
print(f'{currentScreenId} is not a known record mode ID, defaulting to {self.availableRecordModeIds[0]}')
currentScreenId = self.availableRecordModeIds[0]
#Disable run-n-gun mode screen until it's added.
self.uiRecordMode.removeItem(self.availableRecordModeIds.index('runAndGun'))
self.uiRunNGunTimeInSeconds.template = self.uiRunNGunTimeInSeconds.text()
self.uiRunNGunTimeInFrames.template = self.uiRunNGunTimeInFrames.text()
self.uiRegularLengthInSeconds.template = self.uiRegularLengthInSeconds.text()
self.uiRegularLengthInFrames.template = self.uiRegularLengthInFrames.text()
self.uiBurstTimeInSeconds.template = self.uiBurstTimeInSeconds.text()
self.uiBurstTimeInFrames.template = self.uiBurstTimeInFrames.text()
# Widget behavour.
api.observe('recMode', self.setCurrentScreenIndexFromRecordMode)
self.uiRecordMode.currentIndexChanged.connect(self.changeShownTrigger)
api.observe('cameraMaxFrames', self.recalculateEverything)
api.observe('recSegments', self.recalculateEverything)
api.observe('recMaxFrames', self.recalculateEverything)
api.observe('framePeriod', self.recalculateEverything)
self.uiSegmentLengthInSeconds.valueChanged.connect(lambda sec:
self.uiSegmentLengthInFrames.setValue(
int(sec * 1e9 / api.apiValues.get('framePeriod') * api.apiValues.get('recSegments')) ) )
self.uiSegmentLengthNumSegments.valueChanged.connect(lambda segments:
self.control.setSync('recSegments', segments) )
self.uiSegmentLengthInFrames.valueChanged.connect(lambda frames:
self.control.setSync('recMaxFrames', frames * api.apiValues.get('recSegments')) )
self.uiDone.clicked.connect(window.back)
def report(tag: str, data: dict):
"""Report program statistics to an internal server, stats.node.js."""
assert tag
assert "tag" not in data
assert "serial_number" not in data
data["tag"] = tag
data["serial_number"] = api.control().getSync('cameraSerial')
try:
urlopen(report_url, bytes(json.dumps(data), 'utf-8'), 0.1)
except Exception:
global contact_warned
if not contact_warned:
contact_warned = True
log.warn(f'Could not contact the stats server at {report_url}.')
pass
def __init__(self, window):
super().__init__()
self.setupUi(self)
# API init.
self.control = api.control()
# Panel init.
self.setFixedSize(window.app.primaryScreen().virtualSize())
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground, True)
# Button binding.
self.window_ = window
#Side and rotated are not quite correct, as askBeforeDiscarding is, but they are correct enough for now. Having the final result come from two values confused things a bit.
self.uiInterfaceSide.setCurrentIndex(
int(settings.value('interface handedness', None) == 'left'))
self.uiInterfaceSide.currentIndexChanged.connect(lambda index:
settings.setValue('interface handedness', 'left' if index else 'right') )
settings.observe('interface handedness', None, self.updateInterfaceSide)
self.uiInterfaceRotated.setCurrentIndex(
int(settings.value('interface rotation', None) == '180'))
self.uiInterfaceRotated.currentIndexChanged.connect(lambda index:
settings.setValue('interface rotation', '180' if index else '0') )
settings.observe('interface rotation', None, self.updateInterfaceSide)
settings.observe('theme', 'dark', self.updateInterfaceSide)
#Note the operations attached here:
# - We must observe a silenced callback to update the state. This prevents an infinite loop.
# - We update the state from a callback attached to the widget.
settings.observe('ask before discarding', 'if not reviewed', self.updateAskBeforeDiscarding)
self.uiAskBeforeDiscarding.currentIndexChanged.connect(lambda index:
settings.setValue('ask before discarding',
["always", "if not reviewed", "never"][index] ) )
api.observe('dateTime', self.stopEditingDate) #When the date is changed, always display the update even if an edit is in progress. Someone probably set the date some other way instead of this, or this was being edited in error.
self.uiSystemTime.focusInEvent = self.sysTimeFocusIn
self.uiSystemTime.editingFinished.connect(self.sysTimeFocusOut)
self._timeUpdateTimer = QtCore.QTimer()
self._timeUpdateTimer.timeout.connect(self.updateDisplayedSystemTime)
self.uiDone.clicked.connect(window.back)
def __init__(self, window):
super().__init__()
self.setupUi(self)
# Panel init.
self.setFixedSize(window.app.primaryScreen().virtualSize())
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground, True)
# API init.
self.control = api.control()
self.video = api.video()
self.uiTriggerDelaySlider.setStyleSheet( #If this turns out to be too expensive to set, just fill in the tip and draw a red rectangle underneath.
self.uiTriggerDelaySlider.styleSheet() + '\n' + """
Slider::groove {
background: qlineargradient( x1:0 y1:0, x2:1 y2:0, stop:0 transparent, stop:0.4999 transparent, stop:0.5001 red, stop:1 red);
}
"""
)
# Value init.
self.availableDelayMultiplier = 1. #Used for "more" and "less" pre-record delay. Multiplies totalAvailableFrames.
relevantValues = self.control.getSync(['cameraMaxFrames', 'framePeriod', 'recTrigDelay'] )
self.cameraMaxFrames = relevantValues['cameraMaxFrames']
self.framePeriod = relevantValues['framePeriod']
self.recTrigDelay = relevantValues['recTrigDelay']
api.observe_future_only('cameraMaxFrames', self.updateTotalAvailableFrames)
api.observe_future_only('framePeriod', self.updateRecordingPeriod)
api.observe_future_only('recTrigDelay', self.updateTriggerDelay)
self.updateDisplayedValues()
# Button binding.
self.ui0Pct.clicked.connect(lambda:
self.control.set({'recTrigDelay': 0}) )
self.ui50Pct.clicked.connect(lambda:
self.control.set({'recTrigDelay': self.cameraMaxFrames//2}) )
self.ui100Pct.clicked.connect(lambda:
self.control.set({'recTrigDelay': self.cameraMaxFrames}) )
self.uiTriggerDelaySlider.valueChanged.connect(self.newSliderPosition)
self.uiPreRecordDelayFrames.valueChanged.connect(lambda frames:
self.control.set({'recTrigDelay': -frames}) )
self.uiPreRecordDelaySec.valueChanged.connect(lambda seconds:
self.control.set({'recTrigDelay': -self.secondsToFrames(seconds)}) )
self.uiPreTriggerRecordingFrames.valueChanged.connect(lambda frames:
self.control.set({'recTrigDelay': frames}) )
self.uiPreTriggerRecordingSec.valueChanged.connect(lambda seconds:
self.control.set({'recTrigDelay': self.secondsToFrames(seconds)}) )
self.uiPostTriggerRecordingFrames.valueChanged.connect(lambda frames:
self.control.set({'recTrigDelay': self.cameraMaxFrames - frames}) )
self.uiPostTriggerRecordingSec.valueChanged.connect(lambda seconds:
self.control.set({'recTrigDelay': self.cameraMaxFrames - self.secondsToFrames(seconds)}) )
self.uiDone.clicked.connect(window.back)
def __init__(self, window):
super().__init__()
self.setupUi(self)
self.window_ = window
# API init.
self.control = api.control()
self.video = api.video()
# Panel init.
self.setFixedSize(window.app.primaryScreen().virtualSize())
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground, True)
settings.observe('debug controls enabled', False, lambda show:
self.uiDebug.show() if show else self.uiDebug.hide() )
self.uiDebug.clicked.connect(lambda: self and dbg())
self.populatePresets()
self.uiPresets.currentIndexChanged.connect(self.applyPreset)
#Resolution & resolution preview
invariants = self.control.getSync([
'sensorVMax', 'sensorVMin', 'sensorVIncrement',
'sensorHMax', 'sensorHMin', 'sensorHIncrement',
])
self.uiHRes.setMinimum(invariants['sensorHMin'])
self.uiVRes.setMinimum(invariants['sensorVMin'])
self.uiHRes.setMaximum(invariants['sensorHMax'])
self.uiVRes.setMaximum(invariants['sensorVMax'])
self.uiHRes.setSingleStep(invariants['sensorHIncrement'])
self.uiVRes.setSingleStep(invariants['sensorVIncrement'])
self.uiHRes.valueChanged.connect(self.updateForSensorHRes)
self.uiVRes.valueChanged.connect(self.updateForSensorVRes)
self.uiHOffset.valueChanged.connect(self.updateForSensorHOffset) #Offset min implicit, max set by resolution. Offset set after res because 0 is a good default to set up res at.
self.uiVOffset.valueChanged.connect(self.updateForSensorVOffset)
self._lastResolution = defaultdict(lambda: None) #Set up for dispatchResolutionUpdate.
api.observe('resolution', self.dispatchResolutionUpdate)
#Frame rate fps/µs binding
self.uiFps.setMinimum(0.01)
self.uiFps.valueChanged.connect(self.updateFps)
self.uiFrameDuration.valueChanged.connect(self.updateFrameDuration)
api.observe('frameRate', self.updateFpsFromAPI)
#Analog gain
self.populateUiLuxAnalogGain()
api.observe('currentGain', self.setLuxAnalogGain)
self.uiAnalogGain.currentIndexChanged.connect(self.luxAnalogGainChanged)
# Button binding.
self.uiCenterRecording.clicked.connect(self.centerRecording)
self.uiCancel.clicked.connect(self.revertSettings)
self.uiDone.clicked.connect(self.applySettings)
self.uiDone.clicked.connect(lambda: self.window_.back())
api.observe('exposureMin', self.setMinExposure)
api.observe('exposureMax', self.setMaxExposure)
api.observe('exposurePeriod', self.updateExposure)
self.uiExposure.valueChanged.connect(
lambda val: self.control.set('exposurePeriod', val) )
self.uiMaximizeExposure.clicked.connect(lambda:
self.uiExposure.setValue(self.uiExposure.maximum()) )
self.uiMaximizeFramerate.clicked.connect(lambda:
self.uiFps.setValue(self.uiFps.maximum()) )
self.uiSavePreset.clicked.connect(self.savePreset)
self.uiDeletePreset.clicked.connect(self.deletePreset)
#Hack. Since we set each recording setting individually, we always
#wind up with a 'custom' entry on our preset list. Now, this might be
#legitimate - if we're still on Custom by this time, that's just the
#configuration the camera's in. However, if we're not, we can safely
#delete it, since it's just a garbage value from the time the second-
#to-last setting was set during setup.
if self.uiPresets.itemData(0)['temporary'] and not self.uiPresets.itemData(self.uiPresets.currentIndex())['temporary']:
self.uiPresets.removeItem(0)
#Set up ui writes after everything is done.
self._dirty = False
self.uiUnsavedChangesWarning.hide()
self.uiCancel.hide()
def markDirty(*_):
self._dirty = True
self.uiUnsavedChangesWarning.show()
self.uiCancel.show()
self.uiHRes.valueChanged.connect(markDirty)
self.uiVRes.valueChanged.connect(markDirty)
self.uiHOffset.valueChanged.connect(markDirty)
self.uiVOffset.valueChanged.connect(markDirty)
def __init__(self, window):
super().__init__()
self.setupUi(self)
# API init.
self.control = api.control()
self.video = api.video()
# Panel init.
self.setFixedSize(window.app.primaryScreen().virtualSize()) #This is not a responsive design.
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground, True)
self._window = window
#Hide the fake borders if the buttons don't have borders.
if self.uiBlackCal.hideBorder:
self.uiBottomHorizontalLine.hide()
self.uiBottomVerticalLine.hide()
else:
self.uiBottomHorizontalLine.show()
self.uiBottomVerticalLine.show()
self.uiFocusPeakingOriginalCustomStyleSheet = self.uiFocusPeaking.styleSheet()
self.uiZebraStripesOriginalCustomStyleSheet = self.uiZebraStripes.styleSheet()
settings.observe('theme', 'dark', lambda name: (
self.uiFocusPeaking.setStyleSheet(
self.uiFocusPeakingOriginalCustomStyleSheet + f"""
CheckBox {{ background-color: {theme(name).background} }}
"""
),
self.uiZebraStripes.setStyleSheet(
self.uiZebraStripesOriginalCustomStyleSheet + f"""
CheckBox {{ background-color: {theme(name).background} }}
"""
)
))
#Note start/end recording times, to display the timers.
recordingStartTime = 0
recordingEndTime = 0
def updateRecordingStartTime(state):
nonlocal recordingStartTime, recordingEndTime
if state == 'recording':
recordingStartTime = time()
recordingEndTime = 0
self.uiPlayAndSave.update()
self.uiRecord.update()
elif state == 'idle' and not recordingEndTime:
recordingEndTime = time()
self.uiPlayAndSave.update()
self.uiRecord.update()
api.observe('state', updateRecordingStartTime)
totalFrames = self.control.getSync('totalFrames')
if totalFrames == 0: #Set the length of the recording to 0, if nothing has been recorded. Otherwise, calculate what we've recorded.
recordingStartTime = recordingEndTime
else:
recordingEndTime = recordingStartTime + totalFrames/self.control.getSync('frameRate')
self.uiMenuBackground.hide()
self.uiMenuBackground.move(0,0)
lastOpenerButton = None
def showMenu(button: QWidget, menu: QWidget, *_):
nonlocal lastOpenerButton
lastOpenerButton = button
self.uiMenuBackground.show(),
self.uiMenuBackground.raise_(),
button.raise_(),
menu.show(),
menu.raise_(),
self.focusRing.raise_(),
self.showMenu = showMenu
def hideMenu(*_):
nonlocal lastOpenerButton
if not lastOpenerButton:
return
self.uiMenuBackground.hide()
self.uiFocusPeakingColorMenu.hide()
self.uiMenuDropdown.hide()
self.uiExposureMenu.hide()
self.uiWhiteBalanceMenu.hide()
lastOpenerButton.setFocus()
lastOpenerButton = None
self.hideMenu = hideMenu
self.uiMenuBackground.mousePressEvent = hideMenu
self.uiMenuBackground.focusInEvent = hideMenu
#############################
# Button action binding #
#############################
#Debug buttons. (These are toggled on the factory settings screen.)
self.uiDebugA.clicked.connect(self.screenshotAllScreens)
self.uiDebugB.clicked.connect(lambda: window.show('test'))
self.uiDebugC.setFocusPolicy(QtCore.Qt.TabFocus) #Break into debugger without loosing focus, so you can debug focus issues.
self.uiDebugC.clicked.connect(lambda: self and window and dbg()) #"self" is needed here, won't be available otherwise.
self.uiDebugD.clicked.connect(QApplication.closeAllWindows)
#Only show the debug controls if enabled in factory settings.
settings.observe('debug controls enabled', False, lambda show: (
self.uiDebugA.show() if show else self.uiDebugA.hide(),
self.uiDebugB.show() if show else self.uiDebugB.hide(),
self.uiDebugC.show() if show else self.uiDebugC.hide(),
self.uiDebugD.show() if show else self.uiDebugD.hide(),
))
#Occasionally, the touch screen seems to report a spurious touch event on the top-right corner. This should prevent that. (Since the record button is there now, this is actually very important!)
self.uiErrantClickCatcher.mousePressEvent = (lambda evt:
log.warn('Errant click blocked. [WpeWCY]'))
#Zeebs
api.observe('zebraLevel', lambda intensity:
self.uiZebraStripes.setCheckState(
0 if not intensity else 2 ) )
self.uiZebraStripes.stateChanged.connect(lambda state:
self.control.set({'zebraLevel': state/200}) )
#Focus peaking
#Use for focus peaking drop-down.
#api.observe('focusPeakingLevel', lambda intensity:
# self.uiFocusPeakingIntensity.setCurrentIndex(
# round((1-intensity) * (self.uiFocusPeakingIntensity.count()-1)) ) )
#
#self.uiFocusPeakingIntensity.currentIndexChanged.connect(lambda index:
# self.control.set({'focusPeakingLevel': 1-(index/(self.uiFocusPeakingIntensity.count()-1))} ) )
api.observe('focusPeakingLevel', lambda intensity:
self.uiFocusPeaking.setCheckState(
0 if not intensity else 2 ) )
self.uiFocusPeaking.stateChanged.connect(lambda state:
self.control.set({'focusPeakingLevel': (state/2) * 0.2}) )
#Focus peaking colour
focusColor = ''
def updateFocusColor(color):
nonlocal focusColor
target = getattr(self, f"ui{color.title()}FocusPeaking", None)
if target: #Find the colour of the panel to be highlighted.
match = regex_search(r'background:\s*?([#\w]+)', target.customStyleSheet)
assert match, f"Could not find background color of {target.objectName()}. Check the background property of it's customStyleSheet."
focusColor = match.group(1)
else: #Just pass through whatever the colour is.
focusColor = color
self.uiFocusPeakingColor.update()
api.observe('focusPeakingColor', updateFocusColor)
def uiFocusPeakingColorPaintEvent(evt, rectSize=24):
"""Draw the little coloured square on the focus peaking button."""
midpoint = self.uiFocusPeakingColor.geometry().size()/2 + QSize(0, self.uiFocusPeakingColor.touchMargins()['top']/2)
type(self.uiFocusPeakingColor).paintEvent(self.uiFocusPeakingColor, evt) #Invoke the superclass to - hopefully - paint the rest of the button before we deface it with our square.
p = QPainter(self.uiFocusPeakingColor)
p.setPen(QPen(QColor('black')))
p.setBrush(QBrush(QColor(focusColor)))
p.drawRect( #xywh
midpoint.width() - rectSize/2, midpoint.height() - rectSize/2,
rectSize, rectSize )
self.uiFocusPeakingColor.paintEvent = uiFocusPeakingColorPaintEvent
self.uiFocusPeakingColor.clicked.connect(
self.toggleFocusPeakingColorMenu)
self.uiFocusPeakingColorMenu.hide()
self.uiFocusPeakingColorMenu.move(360, 330)
#Loop focus peaking color menu focus, for the jog wheel.
self.uiMagentaFocusPeaking.nextInFocusChain = (lambda *_:
self.uiFocusPeakingColor
if self.uiFocusPeakingColorMenu.isVisible() else
type(self.uiMagentaFocusPeaking).nextInFocusChain(self.uiMagentaFocusPeaking, *_)
)
self.uiRedFocusPeaking.previousInFocusChain = (lambda *_:
self.uiFocusPeakingColor
if self.uiFocusPeakingColorMenu.isVisible() else
type(self.uiRedFocusPeaking).previousInFocusChain(self.uiRedFocusPeaking, *_)
)
self.uiFocusPeakingColor.nextInFocusChain = (lambda *_:
self.uiRedFocusPeaking
if self.uiFocusPeakingColorMenu.isVisible() else
type(self.uiFocusPeakingColor).nextInFocusChain(self.uiFocusPeakingColor, *_)
)
self.uiFocusPeakingColor.previousInFocusChain = (lambda *_:
self.uiMagentaFocusPeaking
if self.uiFocusPeakingColorMenu.isVisible() else
type(self.uiFocusPeakingColor).previousInFocusChain(self.uiFocusPeakingColor, *_)
)
#Focus peaking color menu
api.observe('focusPeakingColor', self.updateFocusPeakingColor)
for child in self.uiFocusPeakingColorMenu.children():
match = regex_match(r'^ui(.*?)FocusPeaking$', child.objectName())
match and child.clicked.connect(
(lambda color: #Capture color from for loop.
lambda: self.control.set({'focusPeakingColor': color})
)(match.group(1).lower()) )
#Black Cal
self.uiBlackCal.clicked.connect(lambda:
self.control.call('startCalibration', {
'blackCal': True ,
'saveCal': True }) )
#White Bal & Trigger/IO
whiteBalanceTemplate = self.uiWhiteBalance.text()
api.observe('wbTemperature', lambda temp:
self.uiWhiteBalance.setText(
whiteBalanceTemplate.format(temp) ))
self.uiTriggers.clicked.connect(lambda:
window.show('triggers_and_io') )
# You can't adjust the colour of a monochromatic image.
# Hide white balance in favour of trigger/io button.
if api.apiValues.get('sensorColorPattern') == 'mono':
self.uiWhiteBalance.hide()
else:
self.uiTriggers.hide()
self.uiWhiteBalanceMenu.hide()
self.uiWhiteBalanceMenu.move(
self.x(),
self.uiWhiteBalance.y() - self.uiWhiteBalanceMenu.height() + self.uiWhiteBalance.touchMargins()['top'],
)
self.uiWhiteBalance.clicked.connect(lambda *_:
hideMenu()
if self.uiWhiteBalanceMenu.isVisible() else
showMenu(self.uiWhiteBalance, self.uiWhiteBalanceMenu)
)
#Loop white balance menu focus, for the jog wheel.
self.uiFineTuneColor.nextInFocusChain = (lambda *_:
self.uiWhiteBalance
if self.uiWhiteBalanceMenu.isVisible() else
type(self.uiFineTuneColor).nextInFocusChain(self.uiFineTuneColor, *_)
)
self.uiWBPreset1.previousInFocusChain = (lambda *_:
self.uiWhiteBalance
if self.uiWhiteBalanceMenu.isVisible() else
type(self.uiWBPreset1).previousInFocusChain(self.uiWBPreset1, *_)
)
self.uiWhiteBalance.nextInFocusChain = (lambda *_:
self.uiWBPreset1
if self.uiWhiteBalanceMenu.isVisible() else
type(self.uiWhiteBalance).nextInFocusChain(self.uiWhiteBalance, *_)
)
self.uiWhiteBalance.previousInFocusChain = (lambda *_:
self.uiFineTuneColor
if self.uiWhiteBalanceMenu.isVisible() else
type(self.uiWhiteBalance).previousInFocusChain(self.uiWhiteBalance, *_)
)
self.uiWBPreset1.clicked.connect(lambda evt:
self.control.set('wbTemperature', self.uiWBPreset1.property('temp')) )
self.uiWBPreset2.clicked.connect(lambda evt:
self.control.set('wbTemperature', self.uiWBPreset2.property('temp')) )
self.uiWBPreset3.clicked.connect(lambda evt:
self.control.set('wbTemperature', self.uiWBPreset3.property('temp')) )
self.uiWBPreset4.clicked.connect(lambda evt:
self.control.set('wbTemperature', self.uiWBPreset4.property('temp')) )
self.uiWBPreset5.clicked.connect(lambda evt:
self.control.set('wbTemperature', self.uiWBPreset5.property('temp')) )
self.uiFineTuneColor.clicked.connect(lambda: window.show('color'))
#Exposure
def updateExposureSliderLimits():
"""Update exposure text to match exposure slider, and sets the slider step so clicking the gutter always moves 1%."""
step1percent = (self.uiExposureSlider.minimum() + self.uiExposureSlider.maximum()) // 100
self.uiExposureSlider.setSingleStep(step1percent)
self.uiExposureSlider.setPageStep(step1percent*10)
def onExposureSliderMoved(newExposureNs):
nonlocal exposureNs
linearRatio = (newExposureNs-self.uiExposureSlider.minimum()) / (self.uiExposureSlider.maximum()-self.uiExposureSlider.minimum())
newExposureNs = math.pow(linearRatio, 2) * self.uiExposureSlider.maximum()
self.control.call('set', {'exposurePeriod': newExposureNs})
#The signal takes too long to return, as it's masked by the new value the slider sets.
exposureNs = newExposureNs
updateExposureText()
def updateExposureMax(newExposureNs):
self.uiExposureSlider.setMaximum(newExposureNs)
updateExposureSliderLimits()
def updateExposureMin(newExposureNs):
self.uiExposureSlider.setMinimum(newExposureNs)
updateExposureSliderLimits()
#Must set slider min/max before value.
api.observe('exposureMax', updateExposureMax)
api.observe('exposureMin', updateExposureMin)
exposureUnit = 'µs' #One of 'µs', 'deg', or 'pct'.
exposureTemplate = self.uiExposure.text()
uiExposureInDegreesTemplate = self.uiExposureInDegrees.text()
uiExposureInMsTemplate = self.uiExposureInMs.text()
uiExposureInPercentTemplate = self.uiExposureInPercent.text()
exposureNsMin = 0
exposureNs = 0
exposureNsMax = 0
def updateExposureText(*_):
exposureDeg = exposureNs/api.apiValues.get('framePeriod')*360
exposurePct = exposureNs/(exposureNsMax or 1)*100
exposureMs = exposureNs/1e3
if exposurePct < 0:
dbg()
self.uiExposure.setText(
exposureTemplate.format(
name = {
'µs': 'Exposure',
'pct': 'Exposure',
'deg': 'Shutter Angle',
}[exposureUnit],
exposure = {
'deg': f'{exposureDeg:1.0f}°', #TODO DDR 2019-09-27: Is this actually the way to calculate shutter angle?
'pct': f'{exposurePct:1.1f}%',
'µs': f'{exposureMs:1.1f}µs',
}[exposureUnit],
)
)
self.uiExposureInDegrees.setText(
uiExposureInDegreesTemplate.format(
degrees = exposureDeg ) )
self.uiExposureInPercent.setText(
uiExposureInPercentTemplate.format(
percent = exposurePct ) )
self.uiExposureInMs.setText(
uiExposureInMsTemplate.format(
duration = exposureMs ) )
linearRatio = exposureNs/(exposureNsMax-exposureNsMin)
try:
exponentialRatio = math.sqrt(linearRatio)
except ValueError:
exponentialRatio = 0
if not self.uiExposureSlider.beingHeld:
self.uiExposureSlider.setValue(exponentialRatio * (self.uiExposureSlider.maximum()-self.uiExposureSlider.minimum()) + self.uiExposureSlider.minimum())
updateExposureSliderLimits()
# In Python 3.7: Use api.observe('exposureMin', lambda ns: exposureNSMin := ns) and give exposureNSMin a setter?
def updateExposureNsMin(ns):
nonlocal exposureNsMin
exposureNsMin = ns
updateExposureText()
api.observe('exposureMin', updateExposureNsMin)
def updateExposureNs(ns):
nonlocal exposureNs
exposureNs = ns
updateExposureText()
api.observe('exposurePeriod', updateExposureNs)
def updateExposureNsMax(ns):
nonlocal exposureNsMax
exposureNsMax = ns
updateExposureText()
api.observe('exposureMax', updateExposureNsMax)
api.observe('framePeriod', updateExposureText)
self.uiExposureMenu.hide()
self.uiExposureMenu.move(
self.x(),
self.uiExposure.y() - self.uiExposureMenu.height() + self.uiExposure.touchMargins()['top'],
)
self.uiExposure.clicked.connect(lambda *_:
hideMenu()
if self.uiExposureMenu.isVisible() else
showMenu(self.uiExposure, self.uiExposureMenu)
)
#Loop exposure menu focus, for the jog wheel.
self.uiExposureSlider.nextInFocusChain = (lambda *_:
self.uiExposure
if self.uiExposureMenu.isVisible() else
type(self.uiExposureSlider).nextInFocusChain(self.uiExposureSlider, *_)
)
self.uiExposureInDegrees.previousInFocusChain = (lambda *_:
self.uiExposure
if self.uiExposureMenu.isVisible() else
type(self.uiExposureInDegrees).previousInFocusChain(self.uiExposureInDegrees, *_)
)
self.uiExposure.nextInFocusChain = (lambda *_:
self.uiExposureInDegrees
if self.uiExposureMenu.isVisible() else
type(self.uiExposure).nextInFocusChain(self.uiExposure, *_)
)
self.uiExposure.previousInFocusChain = (lambda *_:
self.uiExposureSlider
if self.uiExposureMenu.isVisible() else
type(self.uiExposure).previousInFocusChain(self.uiExposure, *_)
)
def uiExposureInDegreesClicked(*_):
nonlocal exposureUnit
exposureUnit = 'deg'
updateExposureText()
self.uiExposureInDegrees.clicked.connect(
uiExposureInDegreesClicked )
def uiExposureInMsClicked(*_):
nonlocal exposureUnit
exposureUnit = 'µs'
updateExposureText()
self.uiExposureInMs.clicked.connect(
uiExposureInMsClicked )
def uiExposureInPercentClicked(*_):
nonlocal exposureUnit
exposureUnit = 'pct'
updateExposureText()
self.uiExposureInPercent.clicked.connect(
uiExposureInPercentClicked )
#Exposure Slider - copied from the original main.py.
self.uiExposureSlider.debounce.sliderMoved.connect(onExposureSliderMoved)
self.uiExposureSlider.touchMargins = lambda: {
"top": 10, "left": 10, "bottom": 10, "right": 10
}
#Resolution
resolutionTemplate = self.uiResolution.text()
hRes = 0
vRes = 0
fps = 0
def updateResolutionText():
self.uiResolution.setText(
resolutionTemplate.format(
hRes=hRes, vRes=vRes, fps=fps ) )
def updateFps(framePeriodNs):
nonlocal fps
fps = 1e9 / framePeriodNs
updateResolutionText()
api.observe('framePeriod', updateFps)
def updateResolution(resolution):
nonlocal hRes, vRes
hRes = resolution['hRes']
vRes = resolution['vRes']
updateResolutionText()
api.observe('resolution', updateResolution)
self.uiResolution.clicked.connect(lambda:
window.show('recording_settings') )
#Menu
self.uiMenuDropdown.hide()
self.uiMenuDropdown.move(
self.uiMenuButton.x(),
self.uiMenuButton.y() + self.uiMenuButton.height() - self.uiMenuButton.touchMargins()['bottom'] - self.uiMenuFilter.touchMargins()['top'] - 1, #-1 to merge margins.
)
self.uiMenuButton.clicked.connect((lambda:
hideMenu()
if self.uiMenuDropdown.isVisible() else
showMenu(self.uiMenuButton, self.uiMenuDropdown)
))
#Loop main menu focus, for the jog wheel.
self.uiMenuScroll.nextInFocusChain = (lambda *_: #DDR 2019-10-21: This doesn't work, and seems to break end-of-scroll progression in the menu scroll along the way.
self.uiMenuButton
if self.uiMenuDropdown.isVisible() else
type(self.uiMenuScroll).nextInFocusChain(self.uiMenuScroll, *_)
)
self.uiMenuFilter.previousInFocusChain = (lambda *_:
self.uiMenuButton
if self.uiMenuDropdown.isVisible() else
type(self.uiMenuFilter).previousInFocusChain(self.uiMenuFilter, *_)
)
self.uiMenuButton.nextInFocusChain = (lambda *_:
self.uiMenuFilter
if self.uiMenuDropdown.isVisible() else
type(self.uiMenuButton).nextInFocusChain(self.uiMenuButton, *_)
)
self.uiMenuButton.previousInFocusChain = (lambda *_:
self.uiMenuScroll
if self.uiMenuDropdown.isVisible() else
type(self.uiMenuButton).previousInFocusChain(self.uiMenuButton, *_)
)
# Populate uiMenuScroll from actions.
# Generally, anything which has a button on the main screen will be
# hidden in this menu, which means it won't come up unless we search
# for it. This should -- hopefully -- keep the clutter down without
# being confusing.
_whiteBalAvail = api.apiValues.get('sensorColorPattern') == 'mono' #Black and white models of the Chronos do not have colour to balance, so don't show that screen ever.
_scriptsHidden = not [f for f in iglob('/var/camera/scripts/*')][:1] #Only show the scripts screen if there will be a script on it to run.
log.debug(f'_scriptsHidden {_scriptsHidden}')
main_menu_items = [
{'name':"About Camera", 'open':lambda: window.show('about_camera'), 'hidden': False, 'synonyms':"kickstarter thanks name credits"},
{'name':"App & Internet", 'open':lambda: window.show('remote_access'), 'hidden': False, 'synonyms':"remote access web client network control api"},
{'name':"Battery & Power", 'open':lambda: window.show('power'), 'hidden': True, 'synonyms':"charge wake turn off power down"},
{'name':"Camera Settings", 'open':lambda: window.show('user_settings'), 'hidden': False, 'synonyms':"user operator save settings"},
{'name':"Custom Scripts", 'open':lambda: window.show('scripts'), 'hidden': _scriptsHidden, 'synonyms':"scripting bash python"},
{'name':"Factory Utilities", 'open':lambda: window.show('service_screen.locked'), 'hidden': False, 'synonyms':"utils"},
{'name':"Format Storage", 'open':lambda: window.show('storage'), 'hidden': True, 'synonyms':"file saving save media df mounts mounted devices thumb drive ssd sd card usb stick filesystem reformat"},
{'name':"Interface Options", 'open':lambda: window.show('primary_settings'), 'hidden': False, 'synonyms':"rotate rotation screen set time set date"},
{'name':"Play & Save Recording", 'open':lambda: window.show('play_and_save'), 'hidden': True, 'synonyms':"mark region saving"},
{'name':"Record Mode", 'open':lambda: window.show('record_mode'), 'hidden': False, 'synonyms':"segmented run n gun normal"},
{'name':"Recording Settings", 'open':lambda: window.show('recording_settings'), 'hidden': True, 'synonyms':"resolution framerate offset gain boost brightness exposure"},
{'name':"Review Saved Videos", 'open':lambda: window.show('replay'), 'hidden': False, 'synonyms':"playback show footage saved card movie replay"},
#{'name':"Stamp Overlay", 'open':lambda: window.show('stamp'), 'hidden': False, 'synonyms':"watermark"},
#{'name':"Trigger Delay", 'open':lambda: window.show('trigger_delay'), 'hidden': False, 'synonyms':"wait"}, #Removed because we use the trigger/io delay block now.
{'name':"Triggers & IO", 'open':lambda: window.show('triggers_and_io'), 'hidden': False, 'synonyms':"bnc green ~a1 ~a2 trig1 trig2 trig3 signal input output trigger delay gpio"},
{'name':"Update Camera", 'open':lambda: window.show('update_firmware'), 'hidden': False, 'synonyms':"firmware"},
{'name':"Video Save Settings", 'open':lambda: window.show('file_settings'), 'hidden': True, 'synonyms':"file saving"},
]
if(_whiteBalAvail):
main_menu_items += [
{'name':"Color", 'open':lambda: window.show('white_balance'), 'hidden': True, 'synonyms':"matrix colour white balance temperature"},
]
menuScrollModel = QStandardItemModel(
len(main_menu_items), 1, self.uiMenuScroll )
for i in range(len(main_menu_items)):
menuScrollModel.setItemData(menuScrollModel.index(i, 0), {
Qt.DisplayRole: main_menu_items[i]['name'],
Qt.UserRole: main_menu_items[i],
Qt.DecorationRole: None, #Icon would go here.
})
self.uiMenuScroll.setModel(menuScrollModel)
self.uiMenuScroll.clicked.connect(self.showOptionOnTap)
self.uiMenuScroll.jogWheelClick.connect(self.showOptionOnJogWheelClick)
self.uiMenuFilterIcon.setAttribute(Qt.WA_TransparentForMouseEvents) #Allow clicking on the filter icon, 🔎, to filter.
self.uiMenuFilter.textChanged.connect(self.filterMenu)
self.filterMenu()
self.uiMenuFilterX.clicked.connect(self.uiMenuFilter.clear)
#Battery
self._batteryCharge = 1
self._batteryCharging = 0
self._batteryPresent = 0
self._batteryBlink = False
self._theme = 'light'
self._batteryTemplate = self.uiBattery.text()
self._batteryPollTimer = QtCore.QTimer()
self._batteryPollTimer.timeout.connect(self.updateBatteryCharge)
self._batteryPollTimer.setTimerType(QtCore.Qt.VeryCoarseTimer) #Infrequent, wake as little as possible.
self._batteryPollTimer.setInterval(3600)
self._batteryBlinkTimer = QtCore.QTimer()
self._batteryBlinkTimer.timeout.connect(lambda: (
setattr(self, '_batteryBlink', not self._batteryBlink),
self.updateBatteryIcon(),
))
self._batteryBlinkTimer.setInterval(500) #We display percentages. We update in tenth-percentage increments.
self.uiBattery.clicked.connect(lambda: window.show('power'))
self.uiBatteryIcon.setAttribute(Qt.WA_TransparentForMouseEvents)
self.uiBatteryIcon.setStyleSheet('')
api.observe('externalPower', lambda state: (
setattr(self, '_batteryCharging', state),
state and (
self._batteryBlinkTimer.stop(),
setattr(self, '_batteryBlink', False),
),
self.updateBatteryIcon(),
) )
api.observe('batteryPresent', lambda state: (
setattr(self, '_batteryPresent', state),
state and (
self._batteryBlinkTimer.stop(),
setattr(self, '_batteryBlink', False),
),
self.updateBatteryIcon(),
) )
def uiBatteryIconPaintEvent(evt, rectSize=24):
"""Draw the little coloured square on the focus peaking button."""
if self._batteryPresent and (self._batteryCharging or not self._batteryBlink):
powerDownLevel = api.apiValues.get('powerOffWhenMainsLost') * self.uiPowerDownThreshold
warningLevel = powerDownLevel + 0.15
x,y,w,h = (
1,
1,
self.uiBatteryIcon.width() - 2,
self.uiBatteryIcon.height() - 1,
)
p = QPainter(self.uiBatteryIcon)
#Cut out the battery outline, so the battery fill level doesn't show by
#outside the "nub". Nextly, this was taken care of by an opaque box
#outside the battery nub in the SVG image, but this didn't work so well
#when the button was pressed or when themes were changed. We can't fill
#a polygon a percentage of the way very easily, and we can't just go in
#and muck with the SVG to achieve this either like we would in browser.
batteryOutline = QPainterPath()
batteryOutline.addPolygon(QPolygonF([
QPoint(x+3,y),
QPoint(x+3,y+2), #Left battery nub chunk.
QPoint(x,y+2),
QPoint(x,y+h), #Bottom
QPoint(x+w,y+h),
QPoint(x+w,y+2),
QPoint(x+w-3,y+2), #Right battery nub chunk.
QPoint(x+w-3,y),
]))
batteryOutline.closeSubpath() #Top of battery nub.
p.setClipPath(batteryOutline, Qt.IntersectClip)
p.setPen(QPen(QColor('transparent')))
if self._batteryCharge > warningLevel or self._batteryCharging:
p.setBrush(QBrush(QColor('#00b800')))
else:
p.setBrush(QBrush(QColor('#f20000')))
p.drawRect(
x, y + h * (1-self._batteryCharge),
w, h * self._batteryCharge )
type(self.uiBatteryIcon).paintEvent(self.uiBatteryIcon, evt) #Invoke the superclass to paint the battery overlay image on our new rect.
self.uiBatteryIcon.paintEvent = uiBatteryIconPaintEvent
#Record / stop
self.uiRecordTemplateWithTime = self.uiRecord.text()
self.uiRecordTemplateNoTime = self.uiRecordTemplateWithTime.split('\n')[0][2:]
self.uiRecord.clicked.connect(self.toggleRecording)
def uiRecordPaintEventRecord(evt, iconSize=24, offsetX=32):
midpoint = self.uiRecord.geometry().size()/2 - QSize(0, self.uiRecord.touchMargins()['bottom']/2)
p = QPainter(self.uiRecord)
p.setPen(QPen(QColor('#000000')))
p.setBrush(QBrush(QColor('#f20000')))
p.setRenderHint(QPainter.Antialiasing, True)
p.drawChord( #xy/wh
midpoint.width()-iconSize/2-offsetX, midpoint.height()-iconSize/2,
iconSize, iconSize,
0, 16*360, #start, end angle
)
def uiRecordPaintEventPause(evt, iconSize=20, offsetX=24):
midpoint = self.uiRecord.geometry().size()/2 - QSize(0, self.uiRecord.touchMargins()['bottom']/2)
p = QPainter(self.uiRecord)
p.setPen(QPen(QColor('#ffffff')))
p.setBrush(QBrush(QColor('#000000')))
p.drawRect( #xy/wh
midpoint.width()-iconSize/2-offsetX, midpoint.height()-iconSize/2,
iconSize/3, iconSize,
)
p.drawRect( #xy/wh
midpoint.width()-iconSize/2-offsetX+iconSize/3*2, midpoint.height()-iconSize/2,
iconSize/3, iconSize,
)
def uiRecordPaintEventStop(evt, iconSize=20, offsetX=24):
midpoint = self.uiRecord.geometry().size()/2 - QSize(0, self.uiRecord.touchMargins()['bottom']/2)
p = QPainter(self.uiRecord)
p.setPen(QPen(QColor('#ffffff')))
p.setBrush(QBrush(QColor('#000000')))
p.drawRect( #xy/wh
midpoint.width()-iconSize/2-offsetX, midpoint.height()-iconSize/2,
iconSize, iconSize,
)
self.uiRecord.setText( #Do the timer.
self.uiRecordTemplateWithTime.format(
state="Stop",
timeRecorded=(recordingEndTime or time()) - recordingStartTime,
)
)
def uiRecordPaintEvent(evt):
type(self.uiRecord).paintEvent(self.uiRecord, evt)
#TODO DDR 2019-10-07: Add pause icon, when we are able to pause recording and resume again, for run 'n' gun mode.
if self.uiRecord.isRecording:
uiRecordPaintEventRecord(evt)
else:
uiRecordPaintEventStop(evt)
self.uiRecord.paintEvent = uiRecordPaintEvent
api.observe('state', self.onStateChange)
#Play & save
#TODO DDR 2019-09-27 fill in play and save
uiPlayAndSaveTemplate = self.uiPlayAndSave.text()
self.uiPlayAndSave.setText("Play && Save\n-1s RAM\n-1s Avail.")
playAndSaveData = self.control.getSync(['cameraMaxFrames', 'frameRate', 'recSegments'])
def updatePlayAndSaveText(*_):
data = playAndSaveData
segmentMaxRecTime = data['cameraMaxFrames'] / data['frameRate'] / data['recSegments']
segmentCurrentRecTime = min(
segmentMaxRecTime,
(recordingEndTime or time()) - recordingStartTime
)
self.uiPlayAndSave.setText(
uiPlayAndSaveTemplate.format(
ramUsed=segmentCurrentRecTime, ramTotal=segmentMaxRecTime ) )
updatePlayAndSaveText()
def updatePlayAndSaveDataMaxFrames(value):
playAndSaveData['cameraMaxFrames'] = value
api.observe_future_only('cameraMaxFrames', updatePlayAndSaveDataMaxFrames)
api.observe_future_only('cameraMaxFrames', updatePlayAndSaveText)
def updatePlayAndSaveDataFrameRate(_):
playAndSaveData['frameRate'] = self.control.getSync('frameRate')
api.observe_future_only('framePeriod', updatePlayAndSaveDataFrameRate)
api.observe_future_only('framePeriod', updatePlayAndSaveText)
def updatePlayAndSaveDataRecSegments(value):
playAndSaveData['recSegments'] = value
api.observe_future_only('recSegments', updatePlayAndSaveDataRecSegments)
api.observe_future_only('recSegments', updatePlayAndSaveText)
def uiPlayAndSaveDraw(evt):
type(self.uiPlayAndSave).paintEvent(self.uiPlayAndSave, evt)
updatePlayAndSaveText() #Gotta schedule updates like this, because using a timer clogs the event pipeline full of repaints and updates wind up being extremely slow.
self.uiPlayAndSave.paintEvent = uiPlayAndSaveDraw
self.uiPlayAndSave.clicked.connect(lambda:
window.show('play_and_save')) #This should prompt to record if no footage is recorded, and explain itself.
#Storage media
uiExternalMediaTemplate = self.uiExternalMedia.text()
externalMediaUUID = ''
externalMediaRatioFull = -1 #Don't draw the bar if negative.
def updateExternalMediaPercentFull(percent):
nonlocal externalMediaRatioFull
if externalMediaRatioFull != percent:
externalMediaRatioFull = percent
self.uiExternalMedia.update()
self.uiExternalMedia.setText("No Save\nMedia Found") #Without this, there is an unavoidable FOUC unless we call df sychronously. So we lie and just don't detect it at first. 😬
def updateExternalMediaText():
"""Update the external media text. This will called every few seconds to update the %-free display. Also repaints %-bar."""
partitions = ([
partition
for partition in api.externalPartitions.list()
if partition['uuid'] == externalMediaUUID
] or api.externalPartitions.list())[:1]
if not partitions:
updateExternalMediaPercentFull(-1)
self.uiExternalMedia.setText(
"No Save\nMedia Found" )
else:
partition = partitions[0]
def updateExternalMediaTextCallback(space):
saved = estimateFile.duration(space['used'] * 1000)
total = estimateFile.duration(space['total'] * 1000)
updateExternalMediaPercentFull(space['used']/space['total']),
self.uiExternalMedia.setText(
uiExternalMediaTemplate.format(
externalStorageIdentifier = partition['name'] or f"{round(partition['size'] / 1e9):1.0f}GB Storage Media",
percentFull = round(space['used']/space['total'] * 100),
footageSavedDuration = '-1', #TODO: Calculate bits per second recorded and apply it here to the partition usage and total.
hoursSaved = saved.days*24 + saved.seconds/60/60,
minutesSaved = (saved.seconds/60) % 60,
secondsSaved = saved.seconds % 60,
hoursTotal = total.days*24 + total.seconds/60/60,
minutesTotal = (total.seconds/60) % 60,
secondsTotal = total.seconds % 60,
)
)
api.externalPartitions.usageFor(partition['device'],
updateExternalMediaTextCallback )
self.updateExternalMediaText = updateExternalMediaText #oops, assign this to self so we can pre-call the timer on show.
def updateExternalMediaUUID(uuid):
self.externalMediaUUID = uuid
updateExternalMediaText()
settings.observe('preferredFileSavingUUID', '', updateExternalMediaUUID)
api.externalPartitions.observe(lambda partitions:
updateExternalMediaText() )
self._externalMediaUsagePollTimer = QtCore.QTimer()
self._externalMediaUsagePollTimer.timeout.connect(updateExternalMediaText)
self._externalMediaUsagePollTimer.setTimerType(QtCore.Qt.VeryCoarseTimer) #Infrequent, wake as little as possible.
self._externalMediaUsagePollTimer.setInterval(15000) #This should almost never be needed, it just covers if another program is writing or deleting something from the disk.
def uiExternalMediaPaintEvent(evt, meterPaddingX=15, meterOffsetY=2, meterHeight=10):
"""Draw the disk usage bar on the external media button."""
type(self.uiExternalMedia).paintEvent(self.uiExternalMedia, evt) #Invoke the superclass to - hopefully - paint the rest of the button before we deface it with our square.
if externalMediaRatioFull == -1:
return
midpoint = self.uiExternalMedia.geometry().size()/2 + QSize(0, self.uiExternalMedia.touchMargins()['top']/2)
type(self.uiExternalMedia).paintEvent(self.uiExternalMedia, evt) #Invoke the superclass to - hopefully - paint the rest of the button before we deface it with our square.
p = QPainter(self.uiExternalMedia)
p.fillRect( #xywh
meterPaddingX,
midpoint.height() + meterOffsetY,
#TODO DDR 2019-09-27: When we know how long the current recorded clip is, in terms of external media capacity, add it as a white rectangle here.
0, #(midpoint.width() - meterPaddingX) * 2 * externalMediaRatioFull + ???,
meterHeight,
QColor('white')
)
p.fillRect( #xywh
meterPaddingX,
midpoint.height() + meterOffsetY,
(midpoint.width() - meterPaddingX) * 2 * externalMediaRatioFull,
meterHeight,
QColor('#00b800')
)
p.setPen(QPen(QColor('black')))
p.setBrush(QBrush(QColor('transparent')))
p.drawRect( #xywh
meterPaddingX,
midpoint.height() + meterOffsetY,
(midpoint.width() - meterPaddingX) * 2,
meterHeight
)
self.uiExternalMedia.paintEvent = uiExternalMediaPaintEvent
self.uiExternalMedia.clicked.connect(lambda:
window.show('file_settings') )
# -*- coding: future_fstrings -*-
"""Speed test PyQt5's D-Bus implementation."""
from PyQt5 import QtWidgets
from debugger import *; dbg
import chronosGui2.api as api
import time
TEST_ITERATIONS = 100
app = QtWidgets.QApplication(sys.argv)
t1 = time.perf_counter()
controlAPI = api.control()
print('test 1: simple calls to control api')
for x in range(TEST_ITERATIONS):
controlAPI.callSync('get', ['batteryVoltage'])
print('.', end='', flush=True)
print(f"""
Time: {time.perf_counter()-t1}s total, {(time.perf_counter()-t1)/TEST_ITERATIONS*1000}ms per call.
""")
t2 = time.perf_counter()
print('test 2: async calls to control api')
counter = 0
def configureValue(*_):
global counter
global t3
counter += 1
def __init__(self, window):
super().__init__()
self.setupUi(self)
self.video = api.video()
self.control = api.control()
self._window = window
self.recordedSegments = []
self.totalRecordedFrames = 0
self.videoState = None
self.regionBeingSaved = None
self.saveCancelled = False
#Use get and set marked regions, they redraw.
self.markedRegions = [
{'region id': 'aaaaaaaa', 'hue': 240, 'mark end': 19900, 'mark start': 13002, 'saved': 0.0, 'highlight': 0, 'segment ids': ['KxIjG09V'], 'region name': 'Clip 1'},
{'region id': 'aaaaaaab', 'hue': 300, 'mark end': 41797, 'mark start': 40597, 'saved': 0.0, 'highlight': 0, 'segment ids': ['KxIjG09V'], 'region name': 'Clip 2'},
{'region id': 'aaaaaaac', 'hue': 420, 'mark end': 43897, 'mark start': 41797, 'saved': 0.0, 'highlight': 0, 'segment ids': ['KxIjG09V'], 'region name': 'Clip 3'},
{'region id': 'aaaaaaad', 'hue': 180, 'mark end': 53599, 'mark start': 52699, 'saved': 0.0, 'highlight': 0, 'segment ids': ['KxIjG09V'], 'region name': 'Clip 4'},
{'region id': 'aaaaaaae', 'hue': 360, 'mark end': 52699, 'mark start': 51799, 'saved': 0.0, 'highlight': 0, 'segment ids': ['KxIjG09V'], 'region name': 'Clip 5'},
{'region id': 'aaaaaaaf', 'hue': 210, 'mark end': 80000, 'mark start': 35290, 'saved': 0.0, 'highlight': 0, 'segment ids': ['KxIjG09V'], 'region name': 'Clip 6'},
{'region id': 'aaaaaaag', 'hue': 390, 'mark end': 42587, 'mark start': 16716, 'saved': 0.0, 'highlight': 0, 'segment ids': ['KxIjG09V'], 'region name': 'Clip 7'},
{'region id': 'aaaaaaah', 'hue': 270, 'mark end': 25075, 'mark start': 17016, 'saved': 0.0, 'highlight': 0, 'segment ids': ['KxIjG09V'], 'region name': 'Clip 8'},
{'region id': 'aaaaaaai', 'hue': 330, 'mark end': 36617, 'mark start': 28259, 'saved': 0.0, 'highlight': 0, 'segment ids': ['KxIjG09V'], 'region name': 'Clip 9'},
{'region id': 'aaaaaaaj', 'hue': 240, 'mark end': 39005, 'mark start': 32637, 'saved': 0.0, 'highlight': 0, 'segment ids': ['KxIjG09V'], 'region name': 'Clip 10'},
{'region id': 'aaaaaaak', 'hue': 300, 'mark end': 39668, 'mark start': 36219, 'saved': 0.0, 'highlight': 0, 'segment ids': ['KxIjG09V'], 'region name': 'Clip 11'},
{'region id': 'aaaaaaal', 'hue': 420, 'mark end': 39068, 'mark start': 37868, 'saved': 0.0, 'highlight': 0, 'segment ids': ['KxIjG09V'], 'region name': 'Clip 12'},
{'region id': 'aaaaaaam', 'hue': 180, 'mark end': 13930, 'mark start': 0, 'saved': 0.0, 'highlight': 0, 'segment ids': ['ldPxTT5R', 'KxIjG09V'], 'region name': 'Clip 13'},
]
self.markedRegions = [
{'region id': 'aaaaaaaa', 'hue': 240, 'mark end': 199, 'mark start': 130, 'saved': 0.0, 'highlight': 0, 'segment ids': ['KxIjG09V'], 'region name': 'Clip 1'},
{'region id': 'aaaaaaab', 'hue': 300, 'mark end': 417, 'mark start': 105, 'saved': 0.0, 'highlight': 0, 'segment ids': ['KxIjG09V'], 'region name': 'Clip 2'},
]
self.markedRegions = []
self.markedStart = None #Note: Mark start/end are reversed if start is after end.
self.markedEnd = None
# Panel init.
self.setFixedSize(window.app.primaryScreen().virtualSize())
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground, True)
#Put the video here.
self.videoArea = self.uiVideoArea.geometry()
self.uiVideoArea.deleteLater() #Don't need this any more!
self.uiBatteryReadout.anchorPoint = self.uiBatteryReadout.rect()
self.uiBatteryReadout.formatString = self.uiBatteryReadout.text()
self.uiBatteryReadout.clicked.connect(lambda: window.show('power'))
self.updateBatteryTimer = QtCore.QTimer()
self.updateBatteryTimer.timeout.connect(self.updateBattery)
self.updateBatteryTimer.setInterval(2000) #ms
self.labelUpdateIdleDelayTimer = QtCore.QTimer() #Used to skip calling the api alltogether when seeking.
self.labelUpdateIdleDelayTimer.setInterval(32)
self.labelUpdateIdleDelayTimer.setSingleShot(True)
self.labelUpdateTimer = QtCore.QTimer()
self.labelUpdateTimer.setInterval(32) #ms, cap at 60fps. (Technically this is just a penalty, we need to *race* the timer and the dbus call but we can't easily do that because we need something like .~*Promise.all()*~. for that and it's a bit of a pain in the neck to construct right now.)
self.labelUpdateTimer.setSingleShot(True) #Start the timer again after the update.
lastKnownFrame = -1
lastKnownFilesaveStatus = False
iteration = 0
noLoopUpdateCounter = 0 #When < 0, don't update slider to avoid the following issue: 1) Slider is updated. 2) D-Bus message is sent. 3) Slider is updated several times more. 4) D-Bus message returns and updates slider. 5) Slider is updated from old position, producing a jerk or a jump.
def checkLastKnownFrame(status=None):
nonlocal iteration
nonlocal lastKnownFrame
nonlocal lastKnownFilesaveStatus
nonlocal noLoopUpdateCounter
if not self.isVisible(): #Stop updates if screen has been exited.
return
iteration += 1
noLoopUpdateCounter += 1
#log.debug(f'iteration {iteration} (f{lastKnownFrame}, {lastKnownFilesaveStatus})')
#log.debug(f'loop {noLoopUpdateCounter}')
if status and self.videoState in ('play', 'filesave'):
if status['position'] != lastKnownFrame:
lastKnownFrame = status['position']
self.uiCurrentFrame.setValue(lastKnownFrame)
if noLoopUpdateCounter > 0:
self.uiSeekSlider.blockSignals(True)
self.uiSeekSlider.setValue(lastKnownFrame)
self.uiSeekSlider.blockSignals(False)
if status['filesave'] != lastKnownFilesaveStatus:
lastKnownFilesaveStatus = status['filesave']
if not lastKnownFilesaveStatus:
#Restore the seek rate display to the manual play rate.
self.uiSeekRate.setValue(self.seekRate)
if self.videoState == 'filesave':
region = [r for r in self.markedRegions if r['region id'] == self.regionBeingSaved][:1]
if region: #Protect against resets in the middle of saving.
region = region[0]
region['saved'] = max( #We seem to get a few frames where we're incorrectly positioned before ending. Disallow negative progress.
region['saved'],
(lastKnownFrame - region['mark start']) / (region['mark end'] - region['mark start'])
)
#Set the seek rate counter back to what the camera operator set it to.
if lastKnownFilesaveStatus:
self.uiSeekRate.setValue(status['framerate'])
#Loop after a short timeout, if the screen is still visible.
if noLoopUpdateCounter > 0:
self.labelUpdateTimer.start()
else:
self.labelUpdateIdleDelayTimer.start()
self.labelUpdateIdleDelayTimer.timeout.connect(checkLastKnownFrame)
self.labelUpdateTimer.timeout.connect(lambda: #Now, the timer is not running, so we can't just stop it to stop this process. We may be waiting on the dbus call instead.
self.video.call('status').then(checkLastKnownFrame) )
self.uiCurrentFrame.suffixFormatString = self.uiCurrentFrame.suffix()
self.uiCurrentFrame.valueChanged.connect(lambda f:
self.uiCurrentFrame.hasFocus() and self.video.call('playback', {'position':f}) )
self.seekRate = 60
self.uiSeekRate.setValue(self.seekRate)
self.uiSeekBackward.pressed.connect( lambda: self.video.call('playback', {'framerate': -self.seekRate}))
self.uiSeekBackward.released.connect(lambda: self.video.call('playback', {'framerate': 0}))
self.uiSeekForward.pressed.connect( lambda: self.video.call('playback', {'framerate': +self.seekRate}))
self.uiSeekForward.released.connect( lambda: self.video.call('playback', {'framerate': 0}))
self.uiSeekFaster.clicked.connect(self.seekFaster)
self.uiSeekSlower.clicked.connect(self.seekSlower)
self.uiMarkStart.clicked.connect(self.markStart)
self.uiMarkEnd.clicked.connect(self.markEnd)
self.uiSave.clicked.connect(self.onSaveClicked)
self.uiSaveCancel.clicked.connect(self.cancelSave)
self.uiSaveCancel.hide()
self.uiSavedFileSettings.clicked.connect(lambda: window.show('file_settings'))
self.uiDone.clicked.connect(window.back)
self.uiSeekSliderBaseStyleSheet = self.uiSeekSlider.styleSheet()
settings.observe('theme', 'dark', lambda name:
self.uiSeekSlider.setStyleSheet(
self.uiSeekSliderBaseStyleSheet + f"""
/* ----- Play And Save Screen Styling ----- */
Slider::handle:horizontal {{
image: url(:/assets/images/{theme(name).slider.videoSeekHandle}); /* File name fields: width x height + horizontal padding. */
margin: -200px -40px; /* y: -slider groove margin. x: touch padding outsidet the groove. Clipped by Slider width. Should be enough for most customizations if we move stuff around. */
}}
Slider::groove {{
border: none;
background-color: none;
}}
"""
)
)
#Heatmap got delayed. Don't report different size/touchMargins for heatmap styling.
self.uiSeekSlider.sliderSize = lambda: QtCore.QSize(156, 61) #Line up focus ring.
#self.uiSeekSlider.touchMargins = lambda: { "top": 10, "left": 10, "bottom": 10, "right": 10, } #Report real margins.
#self.uiSeekSlider.focusGeometryNudge = (0,0,0,0)
self.uiSeekSlider.touchMargins = lambda: { "top": 10, "left": 0, "bottom": 10, "right": 0, } #Report real margins.
self.uiSeekSlider.debounce.sliderMoved.connect(lambda frame:
self.video.callSync('playback', {'position': frame}) )
self.uiSeekSlider.debounce.sliderMoved.connect(lambda frame:
self.uiCurrentFrame.setValue(frame) )
#last_perf = perf_counter()
#def countPerfs(*_):
# nonlocal last_perf
# log.debug(f'update took {(perf_counter() - last_perf)*1000}ms')
# last_perf = perf_counter()
#self.uiSeekSlider.debounce.sliderMoved.connect(countPerfs)
def updateNoLoopUpdateCounter(*_):
nonlocal noLoopUpdateCounter
noLoopUpdateCounter = -10 #Delay updating until the d-bus call has had a chance to return.
self.uiSeekSlider.debounce.sliderMoved.connect(updateNoLoopUpdateCounter)
self.motionHeatmap = QImage() #Updated by updateMotionHeatmap, used by self.paintMotionHeatmap.
self.uiTimelineVisualization.paintEvent = self.paintMotionHeatmap
self.uiTimelineVisualization.hide() #Heatmap got delayed. Hide for now, some logic still depends on it.
#Set up for marked regions.
self._tracks = [] #Used as cache for updateMarkedRegions / paintMarkedRegions.
self.uiEditMarkedRegions.formatString = self.uiEditMarkedRegions.text()
self.uiMarkedRegionVisualization.setAttribute(QtCore.Qt.WA_TransparentForMouseEvents, True)
self.uiMarkedRegionVisualization.paintEvent = self.paintMarkedRegions
self.regionsListModel = QStandardItemModel(parent=self.uiMarkedRegions)
self.uiMarkedRegions.setModel(self.regionsListModel)
self.regionsListModel.rowsRemoved.connect(self.regionListElementDeleted)
self.regionsListModel.dataChanged.connect(self.regionListElementChanged)
self.updateMarkedRegions()
self.markedRegionMenu = MenuToggle(
menu = self.uiMarkedRegionsPanel,
button = self.uiEditMarkedRegions,
focusTarget = self.uiMarkedRegions,
xRange = (-self.uiMarkedRegionsPanel.width(), -1),
duration = 30,
)
#delay(self, 1, self.markedRegionMenu.toggle) #mmm, just like a crappy javascript app - work around a mysterious black bar appearing on the right-hand side of the window.
#This doesn't work, never fires.
#self.uiMarkedRegionsPanel.focusInEvent = self.uiMarkedRegions.setFocus
self.uiMarkedRegionsPanelHeader.setAttribute(QtCore.Qt.WA_TransparentForMouseEvents)
self.uiMarkedRegionsPanelHeaderX.setAttribute(QtCore.Qt.WA_TransparentForMouseEvents)
self.uiMarkedRegionPanelClose.clicked.connect(self.markedRegionMenu.forceHide)
self.uiMarkedRegions.setItemDelegate(EditMarkedRegionsItemDelegate())
self.lastSelectedRegion = None
self.uiMarkedRegions.clicked.connect(self.selectMarkedRegion)
api.observe('videoState', self.onVideoStateChangeAlways)
api.observe('state', self.onStateChangeAlways)
api.signal.observe('sof', self.onSOF)
api.signal.observe('eof', self.onEOF)
def __init__(self, window):
super().__init__()
self.setupUi(self)
# Panel init.
self.setFixedSize(window.app.primaryScreen().virtualSize())
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground, True)
# API init.
self.control = api.control()
self.video = api.video()
# State init, screen loads in superposition.
self.markStateClean()
#Only needed when trigger for action is set to Never, because the index changed event will never fire then and we'll be stuck with whatever index was set in the .ui file. Ideally, this would not be set in the .ui file in the first place, but realistically since it's set when we change "panels" with the little arrows at the top of the pane we're not gonna remember to clear it every time in the property editor and it'll just be a stupid recurring bug. So fix it here.
self.uiIndividualTriggerConfigurationPanes.setCurrentIndex(0)
self.load(actions=actionData, triggers=triggerData)
self.oldIOMapping = defaultdict(lambda: defaultdict(lambda: None)) #Set part and parcel to whatever the most recent mapping is.
self.newIOMapping = defaultdict(lambda: defaultdict(lambda: None)) #Set piece-by-piece to the new mapping.
api.observe('ioMapping', self.onNewIOMapping)
self.uiActionList.selectionModel().selectionChanged.connect(
self.onActionChanged)
self.uiTriggerList.currentIndexChanged.connect(lambda index:
self.uiIndividualTriggerConfigurationPanes.setCurrentIndex(
self.uiTriggerList.itemData(index) ) )
self.uiActionList.selectionModel().setCurrentIndex(
self.uiActionList.model().index(0,0),
QItemSelectionModel.ClearAndSelect )
self.uiActionList.selectionModel().selectionChanged.connect(
self.uiPreview.update )
self.uiTriggerList.currentIndexChanged.connect(self.onTriggerChanged)
self.uiTriggerList.currentIndexChanged.connect(self.uiPreview.update)
self.uiInvertCondition.stateChanged.connect(self.onInvertChanged)
self.uiDebounce.stateChanged.connect(self.onDebounceChanged)
#When we change an input, mark the current state dirty until we save.
self.uiTriggerList .currentIndexChanged.connect(self.markStateDirty)
self.uiInvertCondition .stateChanged.connect(self.markStateDirty)
self.uiDebounce .stateChanged.connect(self.markStateDirty)
self.uiIo1ThresholdVoltage .valueChanged.connect(self.markStateDirty)
self.uiIo11MAPullup .stateChanged.connect(self.markStateDirty)
self.uiIo120MAPullup .stateChanged.connect(self.markStateDirty)
self.uiIo2ThresholdVoltage .valueChanged.connect(self.markStateDirty)
self.uiIo220MAPullup .stateChanged.connect(self.markStateDirty)
#self.uiAudioTriggerDB .valueChanged.connect(self.markStateDirty)
#self.uiAudioTriggerPercent .valueChanged.connect(self.markStateDirty)
#self.uiAudioTriggerDuration.valueChanged.connect(self.markStateDirty)
self.uiDelayAmount .valueChanged.connect(self.markStateDirty)
#Set the appropriate value in the newIOMapping when a custom updates.
self.uiIo1ThresholdVoltage .valueChanged.connect(self.onIo1ThresholdVoltageChanged)
self.uiIo11MAPullup .stateChanged.connect(self.onIo11MAPullupChanged)
self.uiIo120MAPullup .stateChanged.connect(self.onIo120MAPullupChanged)
self.uiIo2ThresholdVoltage .valueChanged.connect(self.onIo2ThresholdVoltageChanged)
self.uiIo220MAPullup .stateChanged.connect(self.onIo220MAPullupChanged)
#self.uiAudioTriggerDB .valueChanged.connect(self.onAudioTriggerDBChanged)
#self.uiAudioTriggerPercent .valueChanged.connect(self.onAudioTriggerPercentChanged)
#self.uiAudioTriggerDuration.valueChanged.connect(self.onAudioTriggerDurationChanged)
self.uiDelayAmount .valueChanged.connect(self.onDelayAmountChanged)
self.uiSave.clicked.connect(self.saveChanges)
self.uiCancel.clicked.connect(self.resetChanges)
self.uiCancel.clicked.connect(self.markStateClean)
self.uiDone.clicked.connect(window.back)
settings.observe('debug controls enabled', False, lambda show:
self.uiDebug.show() if show else self.uiDebug.hide() )
self.uiDebug.clicked.connect(self.debug)
#TODO: Add little visualisation showing what connects and what is connected to the current action.
self.uiPreview.paintEvent = self.paintPreview
# Live IO status update timer
self.liveIoTimer = QTimer()
self.liveIoTimer.timeout.connect(self.updateLiveIoStatus)
self.liveIoTimer.setInterval(100)
self.liveIoTimer.start()
def __init__(self, window):
super().__init__()
self.setupUi(self)
# API init.
self.control = api.control()
self.video = api.video()
# Panel init.
self.move(0, 0)
self.setFixedSize(800, 480) #hide menus, which are defined off-screen to the right
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground, True)
self._window = window
self.control.set('cameraTallyMode', 'auto')
#Set the kerning to false because it looks way better.
#Doesn't seem to be working? --DDR 2019-05-29
font = self.uiResolutionOverlay.font()
font.setKerning(False)
self.uiResolutionOverlay.setFont(font)
self.uiExposureOverlay.setFont(font)
self.uiResolutionOverlayTemplate = self.uiResolutionOverlay.text()
self.uiExposureOverlayTemplate = self.uiExposureOverlay.text()
# Widget behavour.
self.uiRecord.clicked.connect(self.toggleRecording)
self.uiRecord.pressed.connect(lambda: self.setVirtualTrigger(True))
self.uiRecord.released.connect(lambda: self.setVirtualTrigger(False))
api.observe('state', self.onStateChange)
self.uiDebugA.clicked.connect(self.makeFailingCall)
self.uiDebugB.clicked.connect(lambda: window.show('test'))
self.uiDebugC.setFocusPolicy(QtCore.Qt.NoFocus) #Break into debugger without loosing focus, so you can debug focus issues.
self.uiDebugC.clicked.connect(lambda: self and window and dbg()) #"self" is needed here, won't be available otherwise.
self.uiClose.clicked.connect(QApplication.closeAllWindows)
#Only show the debug controls if enabled in factory settings.
settings.observe('debug controls enabled', False, lambda show:
self.uiDebugControls.show() if show else self.uiDebugControls.hide() )
self.uiBattery.clicked.connect(lambda: window.show('power'))
self.uiPrefsAndUtils.clicked.connect(lambda: window.show('primary_settings'))
closeRecordingAndTriggersMenu = self.linkButtonToMenu(
self.uiRecordingAndTriggers,
self.uiRecordingAndTriggersMenu )
self.uiRecordModes.clicked.connect(closeRecordingAndTriggersMenu)
self.uiRecordingSettings.clicked.connect(closeRecordingAndTriggersMenu)
self.uiTriggerDelay.clicked.connect(closeRecordingAndTriggersMenu)
self.uiTriggerIOSettings.clicked.connect(closeRecordingAndTriggersMenu)
closeShotAssistMenu = self.linkButtonToMenu(
self.uiShotAssist,
self.uiShotAssistMenu )
self.uiShotAssist.clicked.connect(closeRecordingAndTriggersMenu)
self.uiShowWhiteClipping.stateChanged.connect(
lambda state: self.control.set(
{'zebraLevel': state/200} ) )
api.observe('zebraLevel', self.updateWhiteClipping)
api.observe('focusPeakingLevel', self.updateFocusPeakingIntensity)
self.uiFocusPeakingIntensity.currentIndexChanged.connect(
lambda index: self.control.set(
{'focusPeakingLevel': index/(self.uiFocusPeakingIntensity.count()-1) } ) )
self.uiFocusPeakingIntensity.currentIndexChanged.connect(
self.uiShotAssistMenu.setFocus )
api.observe('focusPeakingColor', self.updateFocusPeakingColor)
self.uiBlueFocusPeaking.clicked.connect(lambda:
self.control.set({'focusPeakingColor': 'blue'} ) )
self.uiPinkFocusPeaking.clicked.connect(lambda:
self.control.set({'focusPeakingColor': 'magenta'} ) )
self.uiRedFocusPeaking.clicked.connect(lambda:
self.control.set({'focusPeakingColor': 'red'} ) )
self.uiYellowFocusPeaking.clicked.connect(lambda:
self.control.set({'focusPeakingColor': 'yellow'} ) )
self.uiGreenFocusPeaking.clicked.connect(lambda:
self.control.set({'focusPeakingColor': 'green'} ) )
self.uiCyanFocusPeaking.clicked.connect(lambda:
self.control.set({'focusPeakingColor': 'cyan'} ) )
self.uiBlackFocusPeaking.clicked.connect(lambda:
self.control.set({'focusPeakingColor': 'black'} ) )
self.uiWhiteFocusPeaking.clicked.connect(lambda:
self.control.set({'focusPeakingColor': 'white'} ) )
self.uiBlueFocusPeaking.clicked.connect(self.uiShotAssistMenu.setFocus)
self.uiPinkFocusPeaking.clicked.connect(self.uiShotAssistMenu.setFocus)
self.uiRedFocusPeaking.clicked.connect(self.uiShotAssistMenu.setFocus)
self.uiYellowFocusPeaking.clicked.connect(self.uiShotAssistMenu.setFocus)
self.uiGreenFocusPeaking.clicked.connect(self.uiShotAssistMenu.setFocus)
self.uiCyanFocusPeaking.clicked.connect(self.uiShotAssistMenu.setFocus)
#Twiddle the calibration menu so it shows the right thing. It's pretty context-sensitive - you can't white-balance a black-and-white camera, and you can't do motion trigger calibration when there's no motion trigger set up.
#I think the sanest approach is to duplicate the button, one for each menu, since opening the menu is pretty complex and I don't want to try dynamically rebind menus.
if self.control.getSync('sensorColorPattern') == 'mono':
self.uiCalibration = self.uiCalibrationOrBlackCal
self.uiBlackCal0 = Button(parent=self.uiCalibrationOrBlackCal.parent())
self.copyButton(src=self.uiCalibrationOrBlackCal, dest=self.uiBlackCal0)
self.uiBlackCal0.setText(self.uiBlackCal1.text())
self.closeCalibrationMenu = self.linkButtonToMenu(
self.uiCalibration,
self.uiCalibrationMenu )
self.uiCalibration.clicked.connect(self.closeShotAssistMenu)
self.uiCalibration.clicked.connect(self.closeRecordingAndTriggersMenu)
self.uiRecordingAndTriggers.clicked.connect(self.closeCalibrationMenu)
self.uiShotAssist.clicked.connect(self.closeCalibrationMenu)
#WB is either removed or becomes recalibrate motion trigger in this mode.
self.uiWhiteBalance1.setText(self.uiRecalibrateMotionTrigger.text())
self.uiWhiteBalance1.clicked.connect(self.closeCalibrationMenu)
self.uiWhiteBalance1.clicked.connect(self.closeShotAssistMenu)
self.uiWhiteBalance1.clicked.connect(self.closeRecordingAndTriggersMenu)
self.uiWhiteBalance1.clicked.connect(lambda: self.control.call('startAutoWhiteBalance', {}))
self.uiBlackCal0.clicked.connect(self.closeCalibrationMenu)
self.uiBlackCal0.clicked.connect(lambda:
self.control.call('startCalibration', {'blackCal': True}) ) #may time out if already in progress - check state is 'idle' before issuing call!
self.uiBlackCal1.clicked.connect(self.closeCalibrationMenu)
self.uiBlackCal1.clicked.connect(lambda:
self.control.call('startCalibration', {'blackCal': True}) )
self.updateBaWTriggers()
else:
self.uiCalibration1 = self.uiCalibrationOrBlackCal
self.uiCalibration2 = Button(parent=self.uiCalibrationOrBlackCal.parent())
self.copyButton(src=self.uiCalibration1, dest=self.uiCalibration2)
self.closeCalibrationMenu1 = self.linkButtonToMenu(
self.uiCalibration1,
self.uiCalibrationMenu )
self.closeCalibrationMenu2 = self.linkButtonToMenu(
self.uiCalibration2,
self.uiCalibrationMenuWithMotion )
#Calibration either opens the uiCalibrationMenu or the uiCalibrationMenuWithMotion [trigger button].
self.uiWhiteBalance1.clicked.connect(self.closeCalibrationMenu1)
self.uiWhiteBalance1.clicked.connect(self.closeCalibrationMenu2)
self.uiWhiteBalance1.clicked.connect(lambda: self.control.call('startAutoWhiteBalance', {}))
self.uiWhiteBalance2.clicked.connect(self.closeCalibrationMenu1)
self.uiWhiteBalance2.clicked.connect(self.closeCalibrationMenu2)
self.uiWhiteBalance2.clicked.connect(lambda: self.control.call('startAutoWhiteBalance', {}))
self.uiBlackCal1.clicked.connect(self.closeCalibrationMenu1)
self.uiBlackCal1.clicked.connect(self.closeCalibrationMenu2)
self.uiBlackCal1.clicked.connect(lambda: self.control.call('startCalibration', {'blackCal': True}))
self.uiBlackCal2.clicked.connect(self.closeCalibrationMenu1)
self.uiBlackCal2.clicked.connect(self.closeCalibrationMenu2)
self.uiBlackCal2.clicked.connect(lambda: self.control.call('startCalibration', {'blackCal': True}))
self.uiRecalibrateMotionTrigger.clicked.connect(self.closeCalibrationMenu1)
self.uiRecalibrateMotionTrigger.clicked.connect(self.closeCalibrationMenu2)
#self.uiRecalibrateMotionTrigger.clicked.connect(lambda: self.control('takeStillReferenceForMotionTriggering'))
#Close other menus and vice-versa when menu opened.
self.uiRecordingAndTriggers.clicked.connect(self.closeCalibrationMenu1)
self.uiRecordingAndTriggers.clicked.connect(self.closeCalibrationMenu2)
self.uiRecordingAndTriggers.clicked.connect(closeShotAssistMenu)
self.uiShotAssist.clicked.connect(self.closeCalibrationMenu1)
self.uiShotAssist.clicked.connect(self.closeCalibrationMenu2)
self.uiCalibration1.clicked.connect(closeRecordingAndTriggersMenu)
self.uiCalibration2.clicked.connect(closeRecordingAndTriggersMenu)
self.uiCalibration1.clicked.connect(closeShotAssistMenu)
self.uiCalibration2.clicked.connect(closeShotAssistMenu)
#[TODO DDR 2018-09-13] This widget needs to support being clicked on / focussed in on, so it can close all the menus.
#self.uiPinchToZoomGestureInterceptionPanel.clicked.connect(self.closeCalibrationMenu1)
#self.uiPinchToZoomGestureInterceptionPanel.clicked.connect(self.closeCalibrationMenu2)
#self.uiPinchToZoomGestureInterceptionPanel.clicked.connect(closeRecordingAndTriggersMenu)
#self.uiPinchToZoomGestureInterceptionPanel.clicked.connect(closeShotAssistMenu)
self.updateColorTriggers()
self.uiRecordModes.clicked.connect(lambda: window.show('record_mode'))
self.uiRecordingSettings.clicked.connect(lambda: window.show('recording_settings'))
self.uiTriggerIOSettings.clicked.connect(lambda: window.show('triggers_and_io'))
self.uiTriggerDelay.clicked.connect(lambda: window.show('trigger_delay'))
self.uiPlayAndSave.clicked.connect(lambda: window.show('play_and_save'))
# Polling-based updates.
self.updateBatteryCharge()
self._batteryChargeUpdateTimer = QtCore.QTimer()
self._batteryChargeUpdateTimer.timeout.connect(self.updateBatteryCharge)
self._batteryChargeUpdateTimer.setTimerType(QtCore.Qt.VeryCoarseTimer)
self._batteryChargeUpdateTimer.setInterval(3600) #We display percentages. We update in tenth-percentage increments.
#Set up exposure slider.
# This slider is significantly more responsive to mouse than to touch. 🤔
api.observe('exposureMax', self.updateExposureMax)
api.observe('exposureMin', self.updateExposureMin)
api.observe('exposurePeriod', self.updateExposureNs)
#[TODO DDR 2018-09-13] This valueChanged event is really quite slow, for some reason.
self.uiExposureSlider.debounce.sliderMoved.connect(self.onExposureSliderMoved)
self.uiExposureSlider.touchMargins = lambda: {
"top": 10, "left": 30, "bottom": 10, "right": 30
}
self.uiExposureSlider.focusGeometryNudge = (1,1,1,1)
self._framerate = None
self._resolution = None
api.observe('exposurePeriod', lambda ns:
setattr(self, '_framerate', self.control.getSync('frameRate')) )
api.observe('resolution', lambda res:
setattr(self, '_resolution', res) )
api.observe('exposurePeriod', self.updateResolutionOverlay)
api.observe('resolution', self.updateResolutionOverlay)
#Oh god this is gonna mess up scroll wheel selection so badly. ðŸ˜
self.uiShowWhiteClipping.stateChanged.connect(self.uiShotAssistMenu.setFocus)
class RecordingSettings(QtWidgets.QDialog, Ui_RecordingSettings):
"""The recording settings is one of the few windows that doesn't update
the camera settings directly. Instead, it has a preview which utilizes
these settings under the hood, and the settings are actually only
applied when the "done" button is pressed. The camera is strictly modal
in its configuration, so there will be some weirdness around this.
"""
def __init__(self, window):
super().__init__()
self.setupUi(self)
self.window_ = window
# API init.
self.control = api.control()
self.video = api.video()
# Panel init.
self.setFixedSize(window.app.primaryScreen().virtualSize())
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground, True)
settings.observe('debug controls enabled', False, lambda show:
self.uiDebug.show() if show else self.uiDebug.hide() )
self.uiDebug.clicked.connect(lambda: self and dbg())
self.populatePresets()
self.uiPresets.currentIndexChanged.connect(self.applyPreset)
#Resolution & resolution preview
invariants = self.control.getSync([
'sensorVMax', 'sensorVMin', 'sensorVIncrement',
'sensorHMax', 'sensorHMin', 'sensorHIncrement',
])
self.uiHRes.setMinimum(invariants['sensorHMin'])
self.uiVRes.setMinimum(invariants['sensorVMin'])
self.uiHRes.setMaximum(invariants['sensorHMax'])
self.uiVRes.setMaximum(invariants['sensorVMax'])
self.uiHRes.setSingleStep(invariants['sensorHIncrement'])
self.uiVRes.setSingleStep(invariants['sensorVIncrement'])
self.uiHRes.valueChanged.connect(self.updateForSensorHRes)
self.uiVRes.valueChanged.connect(self.updateForSensorVRes)
self.uiHOffset.valueChanged.connect(self.updateForSensorHOffset) #Offset min implicit, max set by resolution. Offset set after res because 0 is a good default to set up res at.
self.uiVOffset.valueChanged.connect(self.updateForSensorVOffset)
self._lastResolution = defaultdict(lambda: None) #Set up for dispatchResolutionUpdate.
api.observe('resolution', self.dispatchResolutionUpdate)
#Frame rate fps/µs binding
self.uiFps.setMinimum(0.01)
self.uiFps.valueChanged.connect(self.updateFps)
self.uiFrameDuration.valueChanged.connect(self.updateFrameDuration)
api.observe('frameRate', self.updateFpsFromAPI)
#Analog gain
self.populateUiLuxAnalogGain()
api.observe('currentGain', self.setLuxAnalogGain)
self.uiAnalogGain.currentIndexChanged.connect(self.luxAnalogGainChanged)
# Button binding.
self.uiCenterRecording.clicked.connect(self.centerRecording)
self.uiCancel.clicked.connect(self.revertSettings)
self.uiDone.clicked.connect(self.applySettings)
self.uiDone.clicked.connect(lambda: self.window_.back())
api.observe('exposureMin', self.setMinExposure)
api.observe('exposureMax', self.setMaxExposure)
api.observe('exposurePeriod', self.updateExposure)
self.uiExposure.valueChanged.connect(
lambda val: self.control.set('exposurePeriod', val) )
self.uiMaximizeExposure.clicked.connect(lambda:
self.uiExposure.setValue(self.uiExposure.maximum()) )
self.uiMaximizeFramerate.clicked.connect(lambda:
self.uiFps.setValue(self.uiFps.maximum()) )
self.uiSavePreset.clicked.connect(self.savePreset)
self.uiDeletePreset.clicked.connect(self.deletePreset)
#Hack. Since we set each recording setting individually, we always
#wind up with a 'custom' entry on our preset list. Now, this might be
#legitimate - if we're still on Custom by this time, that's just the
#configuration the camera's in. However, if we're not, we can safely
#delete it, since it's just a garbage value from the time the second-
#to-last setting was set during setup.
if self.uiPresets.itemData(0)['temporary'] and not self.uiPresets.itemData(self.uiPresets.currentIndex())['temporary']:
self.uiPresets.removeItem(0)
#Set up ui writes after everything is done.
self._dirty = False
self.uiUnsavedChangesWarning.hide()
self.uiCancel.hide()
def markDirty(*_):
self._dirty = True
self.uiUnsavedChangesWarning.show()
self.uiCancel.show()
self.uiHRes.valueChanged.connect(markDirty)
self.uiVRes.valueChanged.connect(markDirty)
self.uiHOffset.valueChanged.connect(markDirty)
self.uiVOffset.valueChanged.connect(markDirty)
__potentialPresetGeometries = [
[1920, 1080],
[1280, 1024],
[1280, 720],
[1280, 512],
[1280, 360],
[1280, 240],
[1280, 120],
[1280, 96],
[1024, 768],
[1024, 576],
[800, 600],
[800, 480],
[640, 480],
[640, 360],
[640, 240],
[640, 120],
[640, 96],
[336, 240],
[336, 120],
[336, 96],
]
presets = []
for geometry_ in __potentialPresetGeometries: #Fix bug where this overrode the screen's geometry property, preventing any keyboard from opening.
hRes, vRes = geometry_[0], geometry_[1]
geometryTimingLimits = api.control().callSync('getResolutionTimingLimits', {'hRes':hRes, 'vRes':vRes})
if 'error' not in geometryTimingLimits:
presets += [{
'hRes': hRes,
'vRes': vRes,
'framerate': 1e9/geometryTimingLimits['minFramePeriod'],
}]
else:
log.debug(f'Rejected preset resolution {hRes}×{vRes}.')
allRecordingGeometrySettings = ['uiHRes', 'uiVRes', 'uiHOffset', 'uiVOffset', 'uiFps'] #'uiFrameDuration' and 'uiAnalogGain' are not part of the preset, since they're not geometries.
#The following usually crashes the HDVPSS core, which is responsible for
#back-of-camera video. (Specifically, in this case, the core crashes if told
#to render video smaller than 96px tall.) This function was intended to put
#the recorded image inside the passepartout, to show you what you've got and
#what you'll be getting.
def __disabled__onShow(self):
pos = self.uiPassepartoutInnerBorder.mapToGlobal(
self.uiPassepartoutInnerBorder.pos() )
self.video.call('configure', {
'xoff': pos.x(),
'yoff': pos.y(),
'hres': self.uiPassepartoutInnerBorder.width(),
'vres': self.uiPassepartoutInnerBorder.height(),
})
def dispatchResolutionUpdate(self, newResolution):
for key, callbacks in (
('hRes', [self.updateUiHRes, self.updateForSensorHRes]),
('vRes', [self.updateUiVRes, self.updateForSensorVRes]),
('hOffset', [self.updateUiHOffset, self.updateForSensorHOffset]),
('vOffset', [self.updateUiVOffset, self.updateForSensorVOffset]),
('minFrameTime', [self.updateMaximumFramerate]),
):
if self._lastResolution[key] == newResolution[key]:
continue
self._lastResolution[key] = newResolution[key]
for callback in callbacks:
callback(newResolution[key])
def populatePresets(self):
formatString = self.uiPresets.currentText()
self.uiPresets.clear()
for preset in settings.value('customRecordingPresets', []):
self.uiPresets.insertItem(9999, preset['name'], preset)
#Load from API.
for preset in self.presets:
self.uiPresets.insertItem(
9999,
formatString % (preset["hRes"], preset["vRes"], preset["framerate"]),
{
'custom': False, #Indicates value was saved by user.
'temporary': False, #Indicates the "custom", the unsaved, preset.
'values': {
'uiHRes': preset["hRes"],
'uiVRes': preset["vRes"],
'uiFps': preset["framerate"],
},
}
)
def applyPreset(self, presetNumber: int):
preset = self.uiPresets.itemData(presetNumber)
#Maximum may be constrained. Disable maximums for preset read-in.
#Maximums are restored by updateOffsetFromResolution.
self.uiHOffset.setMaximum(999999)
self.uiVOffset.setMaximum(999999)
self.uiFps.setMaximum(999999)
self.uiFrameDuration.setMinimum(0) #TODO: This gets re-set, right?
for key, value in preset.get('values', {}).items():
elem = getattr(self, key)
elem.blockSignals(True) #Don't fire around a bunch of updates as we set values.
elem.setValue(value)
elem.blockSignals(False)
self.updateMaximumFramerate()
self.updateOffsetFromResolution()
preset['custom'] or self.centerRecording() #All non-custom presets are assumed centered.
self.updatePresetDropdownButtons()
self.updatePassepartout()
#Update frame duration and exposure from frame rate, which we just updated.
self.uiFrameDuration.setValue(1/self.uiFps.value())
self.updateExposureLimits()
self._dirty = True
self.uiUnsavedChangesWarning.show()
self.uiCancel.show()
def updatePresetDropdownButtons(self):
if self.uiPresets.currentData()['custom']:
if self.uiPresets.currentData()['temporary']: #The "Custom" preset. Shows when resolution/offset/framerate do not match a preset.
self.uiSavePreset.show()
self.uiDeletePreset.hide()
else: #Saved presets can be deleted.
self.uiSavePreset.hide()
self.uiDeletePreset.show()
else:
self.uiSavePreset.hide()
self.uiDeletePreset.hide()
def selectCorrectPreset(self):
try:
self.uiPresets.blockSignals(True) #When selecting a preset, don't try to apply it. This causes framerate to not track to maximum.
#Select the first available preset.
for index in range(self.uiPresets.count()):
itemData = self.uiPresets.itemData(index)
if itemData['temporary']: #Ignore the fake "Custom" preset.
continue
#Check preset values equal what's on screen. If anything isn't, this isn't our preset index.
if False in [
abs(int(getattr(self, key).value()) - int(value)) <= 1
for key, value in itemData['values'].items()
]:
continue
self.uiPresets.setCurrentIndex(index)
return
#OK, not one of the available presets.
#Add the "custom" preset if it doesn't exist. This is expected to always be in slot 0.
if not self.uiPresets.itemData(0)['temporary']:
log.info('adding temporary')
self.uiPresets.insertItem(0, 'Custom', {
'custom': True, #Indicates value was saved by user.
'temporary': True, #Indicates the "custom", the unsaved, preset.
})
#Mogrify the custom values to match what is set.
itemData = self.uiPresets.itemData(0) #read modify write, no in-place merging
itemData['values'] = {
elem: getattr(self, elem).value()
for elem in self.allRecordingGeometrySettings
}
self.uiPresets.setItemData(0, itemData)
#Select the custom preset and check for changes to the save/load preset buttons.
self.uiPresets.setCurrentIndex(0)
finally:
self.updatePresetDropdownButtons()
self.uiPresets.blockSignals(False)
def savePreset(self):
itemData = self.uiPresets.currentData()
itemData['temporary'] = False
itemData['name'] = f"{self.uiHRes.value()}×{self.uiVRes.value()} @ {int(self.uiFps.value())}fps" #Store name, probably will be editable one day.
presets = [itemData] + settings.value('customRecordingPresets', [])
settings.setValue('customRecordingPresets', presets)
self.uiPresets.setItemData(self.uiPresets.currentIndex(), itemData)
self.uiPresets.setItemText(self.uiPresets.currentIndex(), itemData['name'])
self.updatePresetDropdownButtons()
def deletePreset(self, *_):
settings.setValue('customRecordingPresets', [
setting
for setting in settings.value('customRecordingPresets', [])
if setting != self.uiPresets.currentData()
])
self.uiPresets.removeItem(self.uiPresets.currentIndex())
self.selectCorrectPreset() #Select Custom again.
#xywh accessor callbacks, just update the spin box values since these values require a lengthy pipeline rebuild.
@pyqtSlot(int, name="updateUiHRes")
def updateUiHRes(self, px: int):
self.uiHRes.setValue(px)
@pyqtSlot(int, name="updateUiVRes")
def updateUiVRes(self, px: int):
self.uiVRes.setValue(px)
self.updateMaximumFramerate()
@pyqtSlot(int, name="updateUiHOffset")
def updateUiHOffset(self, px: int):
self.uiHOffset.setValue(px)
@pyqtSlot(int, name="updateUiVOffset")
def updateUiVOffset(self, px: int):
self.uiVOffset.setValue(px)
#side-effect callbacks, update everything *but* the spin box values
@pyqtSlot(int, name="updateForSensorHOffset")
def updateForSensorHOffset(self, px: int):
self.updatePassepartout()
self.selectCorrectPreset()
@pyqtSlot(int, name="updateForSensorVOffset")
def updateForSensorVOffset(self, px: int):
self.updatePassepartout()
self.selectCorrectPreset()
@pyqtSlot(int, name="updateForSensorHRes")
def updateForSensorHRes(self, px: int):
wasCentered = self.uiHOffset.value() == self.uiHOffset.maximum()//2
self.uiHOffset.setMaximum(self.uiHRes.maximum() - px) #Can't capture off-sensor.
wasCentered and self.uiHOffset.setValue(self.uiHOffset.maximum()//2)
self.updateMaximumFramerate()
self.updatePassepartout()
self.selectCorrectPreset()
@pyqtSlot(int, name="updateForSensorVRes")
def updateForSensorVRes(self, px: int):
wasCentered = self.uiVOffset.value() == self.uiVOffset.maximum()//2
self.uiVOffset.setMaximum(self.uiVRes.maximum() - px) #Can't capture off-sensor.
wasCentered and self.uiVOffset.setValue(self.uiVOffset.maximum()//2)
self.updateMaximumFramerate()
self.updatePassepartout()
self.selectCorrectPreset()
def updateOffsetFromResolution(self):
self.uiHOffset.setMaximum(self.uiHRes.maximum() - self.uiHRes.value())
self.uiVOffset.setMaximum(self.uiVRes.maximum() - self.uiVRes.value())
_lastKnownFramerateOverheadNs = 5000
def updateMaximumFramerate(self, minFrameTime=None):
if minFrameTime:
#Shortcut. We can do this because the exposure values set below by the real call are not required when an API-driven update is fired, since the API-driven update will also update the exposure. I think. 🤞
limits = {'minFramePeriod': minFrameTime*1e9}
else:
limits = self.control.callSync('getResolutionTimingLimits', {
'hRes': self.uiHRes.value(),
'vRes': self.uiVRes.value(),
})
if 'error' in limits:
log.error(f"Error retrieving maximum framerate for {hRes}×{vRes}: {limits['error']}")
return
#Note this down for future use by `updateExposureLimits`.
self._lastKnownFramerateOverheadNs = limits['minFramePeriod'] - limits['exposureMax']
self.uiExposure.setMinimum(limits['exposureMin'])
log.debug(f"Framerate for {self.uiHRes.value()}×{self.uiVRes.value()}: {1e9 / limits['minFramePeriod']}")
framerateIsMaxed = abs(self.uiFps.maximum() - self.uiFps.value()) <= 1 #There is a bit of uncertainty here, occasionally, of about 0.1 fps.
self.uiFps.setMaximum(1e9 / limits['minFramePeriod'])
self.uiFrameDuration.setMinimum(limits['minFramePeriod'] / 1e9) #ns→s
framerateIsMaxed and self.uiFps.setValue(self.uiFps.maximum())
framerateIsMaxed and self.uiFrameDuration.setValue(1/self.uiFps.maximum())
self.updateExposureLimits()
_sensorWidth = api.control().getSync('sensorHMax')
_sensorHeight = api.control().getSync('sensorVMax')
def updatePassepartout(self):
previewTop = 1
previewLeft = 1
previewWidth = self.uiPreviewPanel.geometry().right() - self.uiPreviewPanel.geometry().left()
previewHeight = self.uiPreviewPanel.geometry().bottom() - self.uiPreviewPanel.geometry().top()
recordingTop = self.uiVOffset.value()
recordingLeft = self.uiHOffset.value()
recordingRight = self.uiHOffset.value() + self.uiHRes.value()
recordingBottom = self.uiVOffset.value() + self.uiVRes.value()
passepartoutTop = round(recordingTop / self._sensorHeight * previewHeight)
passepartoutLeft = round(recordingLeft / self._sensorWidth * previewWidth)
passepartoutWidth = round((recordingRight - recordingLeft) / self._sensorWidth * previewWidth)
passepartoutHeight = round((recordingBottom - recordingTop) / self._sensorHeight * previewHeight)
self.uiPassepartoutTop.setGeometry(
previewLeft,
previewTop,
previewWidth - 1,
passepartoutTop )
self.uiPassepartoutLeft.setGeometry(
previewLeft,
passepartoutTop + 1,
passepartoutLeft - 1,
passepartoutHeight - 1 )
self.uiPassepartoutRight.setGeometry(
passepartoutLeft + passepartoutWidth + 1,
passepartoutTop + 1,
previewWidth - passepartoutLeft - passepartoutWidth - 1,
passepartoutHeight - 1 )
self.uiPassepartoutBottom.setGeometry(
previewLeft,
passepartoutTop + passepartoutHeight,
previewWidth - 1,
previewHeight - passepartoutTop - passepartoutHeight )
self.uiPassepartoutInnerBorder.setGeometry(
passepartoutLeft,
passepartoutTop,
passepartoutWidth + 1,
passepartoutHeight + 1 )
@pyqtSlot(float, name="updateFps")
def updateFps(self, fps: float):
self.uiFrameDuration.setValue(1/fps)
self.selectCorrectPreset()
self._dirty = True
self.uiUnsavedChangesWarning.show()
self.uiCancel.show()
self.updateExposureLimits()
@pyqtSlot(float, name="updateFrameDuration")
def updateFrameDuration(self, seconds: float):
self.uiFps.setValue(1/seconds)
self.selectCorrectPreset()
self._dirty = True
self.uiUnsavedChangesWarning.show()
self.uiCancel.show()
self.updateExposureLimits()
@pyqtSlot(float, name="updateFpsFromAPI")
def updateFpsFromAPI(self, fps):
self.uiFps.setValue(fps)
self.uiFrameDuration.setValue(1/fps)
self.selectCorrectPreset()
self.updateExposureLimits()
def updateExposureLimits(self):
exposureIsMaxed = self.uiExposure.value() == self.uiExposure.maximum()
self.uiExposure.setMaximum(
self.uiFrameDuration.value()*1e9 - self._lastKnownFramerateOverheadNs )
exposureIsMaxed and self.uiExposure.setValue(self.uiExposure.maximum())
def centerRecording(self):
self.uiHOffset.setValue(self.uiHOffset.maximum() // 2)
self.uiVOffset.setValue(self.uiVOffset.maximum() // 2)
self.selectCorrectPreset()
luxRecordingAnalogGains = [{'multiplier':2**i, 'dB':6*i} for i in range(0,5)]
def populateUiLuxAnalogGain(self):
formatString = self.uiAnalogGain.currentText()
self.uiAnalogGain.clear()
self.uiAnalogGain.insertItems(0, [
formatString.format(multiplier=gain['multiplier'], dB=gain['dB'])
for gain in self.luxRecordingAnalogGains
])
def luxAnalogGainChanged(self, index):
self.uiAnalogGain.setCurrentIndex(index)
self.control.set({'currentGain':
self.luxRecordingAnalogGains[index]['multiplier']})
@pyqtSlot(int, name="setLuxAnalogGain")
def setLuxAnalogGain(self, gainMultiplier):
self.uiAnalogGain.setCurrentIndex(
list(map(lambda availableGain: availableGain['multiplier'],
self.luxRecordingAnalogGains))
.index(floor(gainMultiplier))
)
@pyqtSlot(int, name="setMaxExposure")
def setMaxExposure(self, ns):
self.uiExposure.setMaximum(ns)
@pyqtSlot(int, name="setMinExposure")
def setMinExposure(self, ns):
self.uiExposure.setMaximum(ns)
@pyqtSlot(int, name="updateExposure")
def updateExposure(self, ns):
self.uiExposure.setValue(ns)
def applySettings(self):
"""Save all setting to the API, which will take some time applying them."""
if self._dirty:
self._dirty = False
self.uiUnsavedChangesWarning.hide()
self.uiCancel.hide()
self.control.call('set', {
'resolution': {
#'vDarkRows': 0, #Don't reset what we don't show. That's annoying if you did manually set it.
'hRes': self.uiHRes.value(),
'vRes': self.uiVRes.value(),
'hOffset': self.uiHOffset.value(),
'vOffset': self.uiVOffset.value(),
'minFrameTime': 1/self.uiFps.value(), #This locks the fps in at the lower framerate until you reset it.
},
'framePeriod': self.uiFrameDuration.value()*1e9, #s→ns
})
def revertSettings(self):
"""Set resolution settings back to the API."""
self.updateUiHRes(api.apiValues.get('resolution')['hRes'])
self.updateUiVRes(api.apiValues.get('resolution')['vRes'])
self.updateUiHOffset(api.apiValues.get('resolution')['hOffset'])
self.updateUiVOffset(api.apiValues.get('resolution')['vOffset'])
self.updateMaximumFramerate(api.apiValues.get('resolution')['minFrameTime'])
self.updateFpsFromAPI(api.apiValues.get('frameRate'))
self._dirty = False
self.uiUnsavedChangesWarning.hide()
self.uiCancel.hide()
