def _removeInterface(self, iface):
print("======== remove", iface)
print(self.interfaces)
name = None
if isinstance(iface, CameraModuleInterface):
for k,v in self.interfaces.items():
if v is iface:
name = k
break
elif isinstance(iface, str):
name = iface
else:
raise TypeError("string or CameraModuleInterface argument required.")
if name is None:
raise ValueError("Interface %s not found." % iface)
iface = self.interfaces.pop(name)
if hasattr(iface, 'sigNewFrame'):
pg.disconnect(iface.sigNewFrame, self.newFrame)
if hasattr(iface, 'sigTransformChanged'):
pg.disconnect(iface.sigTransformChanged, self.ifaceTransformChanged)
dock = self.docks.pop(name, None)
if dock is not None:
dock.close()
self.sigInterfaceRemoved.emit(name, iface)
def processFrame(self, frame):
self.frames.append(frame)
index = self.index
# update index for next iteration
self.index += 1
# decide whether to move the stage
finished = self.index >= self.positions.shape[0]
if not finished:
self.move = self.stage.moveTo(self.positions[self.index], 'slow')
# calculate offset (while stage moves no next location)
if index == 0:
offset = (0, 0)
else:
compareIndex = max(0, index - 10)
offset, _ = imreg_dft.translation(
frame.getImage(), self.frames[compareIndex].getImage())
px = self.camera.getPixelSize()
offset = self.offsets[compareIndex] + offset.astype(
float) * [px.x(), px.y()]
self.offsets[index] = offset
# finish up if there are no more positions
if finished:
pg.disconnect(self.camera.sigNewFrame, self.newFrame)
self.analyze()
def stateChanged(self, name, value):
if name == 'deviceCombo':
if self.imager is not None:
pg.disconnect(self.imager.sigNewFrame, self.newFrame)
imager = self.selectedImager()
if imager is not None:
imager.sigNewFrame.connect(self.newFrame)
self.imager = imager
self.updateStatus()
def newFrame(self, frame):
try:
if self.move is not None and not self.move.isDone():
# stage is still moving; discard frame
return
if self.framedelay is None:
# stage has stopped; discard 2 more frames to be sure
# we get the right image.
self.framedelay = pg.ptime.time() + 1. / frame.info()['fps']
elif self.framedelay < frame.info()['time']:
# now we are ready to keep this frame.
self.framedelay = None
self.processFrame(frame)
except Exception:
pg.disconnect(self.camera.sigNewFrame, self.newFrame)
raise
def setTargetToggled(self, b):
cammod = getManager().getModule('Camera')
self._cammod = cammod
pips = self.selectedPipettes()
if b is True:
self.ui.calibrateBtn.setChecked(False)
if len(pips) == 0:
self.ui.setTargetBtn.setChecked(False)
return
# start calibration of selected pipettes
cammod.window().getView().scene().sigMouseClicked.connect(
self.cameraModuleClicked_setTarget)
self._setTargetPips = pips
else:
# stop calibration
pg.disconnect(cammod.window().getView().scene().sigMouseClicked,
self.cameraModuleClicked_setTarget)
self._setTargetPips = []
def transformChanged(self):
"""
Report that the tranform has changed, which might include the objective, or
perhaps the stage position, etc. This needs to be obtained to re-align
the scanner ROI
"""
prof = pg.debug.Profiler()
globalTr = self.scannerDev.globalTransform()
pt1 = globalTr.map(self.currentRoi.scannerCoords[0])
pt2 = globalTr.map(self.currentRoi.scannerCoords[1])
diff = pt2 - pt1
pg.disconnect(self.currentRoi.sigRegionChangeFinished, self.roiChanged)
try:
self.currentRoi.setState({'pos': pt1, 'size': diff, 'angle': 0})
finally:
self.currentRoi.sigRegionChangeFinished.connect(self.roiChanged)
self.setScanPosFromRoi()
if self.imagingThread.isRunning():
self.updateImagingProtocol()
def devStateChanged(self, state=None):
if state is None:
state = self.dev.getState()
pg.disconnect(self.state.sigChanged, self.uiStateChanged)
try:
if state['mode'] == 'I=0':
self.ui.i0Radio.setChecked(True)
self.ui.icHoldingLabel.setText('')
self.ui.vcHoldingLabel.setText('')
else:
hold = self.dev.getParam('HoldingEnable')
if hold:
hval = self.dev.getParam('Holding')
sign = '+' if hval > 0 else '-'
hval = abs(hval)
else:
hval = 0
sign = '+'
if state['mode'] == 'IC':
self.ui.icRadio.setChecked(True)
self.ui.vcHoldingLabel.setText('')
self.ui.icHoldingLabel.setText('%s %0.0f pA' %
(sign, hval * 1e12))
else:
self.ui.vcRadio.setChecked(True)
self.ui.icHoldingLabel.setText('')
self.ui.vcHoldingLabel.setText('%s %0.0f mV' %
(sign, hval * 1e3))
istate = self.dev.getLastState('IC')
vstate = self.dev.getLastState('VC')
self.ui.icHoldingSpin.setValue(istate['holding'])
self.ui.vcHoldingSpin.setValue(vstate['holding'])
finally:
self.state.sigChanged.connect(self.uiStateChanged)
def getNextFrame(self, imager=None):
"""Return the next frame available from the imager.
Note: the frame may have been exposed before this method was called.
"""
imager = self._getImager(imager)
self.__nextFrame = None
def newFrame(newFrame):
self.__nextFrame = newFrame
imager.sigNewFrame.connect(newFrame)
try:
start = pg.ptime.time()
while pg.ptime.time() < start + 5.0:
pg.QtGui.QApplication.processEvents()
frame = self.__nextFrame
if frame is not None:
self.__nextFrame = None
return frame
time.sleep(0.01)
raise RuntimeError("Did not receive frame from imager.")
finally:
pg.disconnect(imager.sigNewFrame, newFrame)
