def __init__(self, hardware, parameters, parent=None):
# None specific focus lock parameters
lock_params = parameters.addSubSection("focuslock")
lock_params.add(
"qpd_zcenter",
params.ParameterRangeFloat("Piezo center position in microns",
"qpd_zcenter", 50.0, 0.0, 100.0))
lock_params.add(
"qpd_scale",
params.ParameterRangeFloat("Offset to nm calibration value",
"qpd_scale", 50.0, 0.0, 10000.0))
lock_params.add("qpd_sum_min", 50.0)
lock_params.add("qpd_sum_max", 1500.0)
lock_params.add("is_locked_buffer_length", 10)
lock_params.add("is_locked_offset_thresh", 0.01)
# None Initialization.
qpd = noneWidgets.QPD()
stage = noneWidgets.NanoP()
lock_fn = lambda (x): 0.0 * x
control_thread = stageOffsetControl.StageQPDThread(
qpd, stage, lock_fn, lock_params.get("qpd_sum_min"),
lock_params.get("qpd_zcenter"),
lock_params.get("is_locked_buffer_length"),
lock_params.get("is_locked_offset_thresh"))
ir_laser = noneWidgets.IRLaser()
focusLockZ.FocusLockZQPD.__init__(self, parameters, control_thread,
ir_laser, parent)
def __init__(self, hardware, parameters, parent = None):
# STORM1 specific focus lock parameters.
lock_params = parameters.addSubSection("focuslock")
lock_params.add("qpd_zcenter", params.ParameterRangeFloat("Piezo center position in microns",
"qpd_zcenter",
30.0, 0.0, 100.0))
lock_params.add("qpd_scale", params.ParameterRangeFloat("Offset to nm calibration value",
"qpd_scale",
3200.0, 0.1, 6000.0))
lock_params.add("qpd_sum_min", 50.0)
lock_params.add("qpd_sum_max", 1500.0)
lock_params.add("is_locked_buffer_length", 10)
lock_params.add("is_locked_offset_thresh", 0.01)
# STORM1 Initialization.
qpd = phreshQPD.PhreshQPDPRISM2()
stage = mclController.MCLStage("c:/Program Files/Mad City Labs/NanoDrive/")
lock_fn = lambda (x): -1.75 * x
control_thread = stageOffsetControl.StageQPDThread(qpd,
stage,
lock_fn,
parameters.get("focuslock.qpd_sum_min", 50.0),
parameters.get("focuslock.qpd_zcenter"),
parameters.get("focuslock.is_locked_buffer_length", 10),
parameters.get("focuslock.is_locked_offset_thresh", 0.01))
ir_laser = LDC210.LDC210("PCIe-6321", 1)
focusLockZ.FocusLockZQPD.__init__(self,
parameters,
control_thread,
ir_laser,
parent)
def __init__(self, parameters, joystick, parent = None):
QtCore.QObject.__init__(self, parent)
halModule.HalModule.__init__(self, parent)
self.button_timer = QtCore.QTimer(self)
self.jstick = joystick
self.old_right_joystick = [0, 0]
self.old_left_joystick = [0, 0]
self.to_emit = False
# Add joystick specific parameters.
js_params = parameters.addSubSection("joystick")
js_params.add("joystick_gain_index", params.ParameterInt("",
"joystick_gain_index",
0,
is_mutable = False,
is_saved = False))
js_params.add("multiplier", params.ParameterInt("",
"multiplier",
1,
is_mutable = False,
is_saved = False))
js_params.add("hat_step", params.ParameterRangeFloat("Step size in um for hat button press",
"hat_step",
1.0, 0.0, 10.0))
js_params.add("joystick_gain", [25.0, 250.0, 2500.0])
js_params.add("joystick_multiplier_value", params.ParameterRangeFloat("X button multiplier for joystick and focus lock",
"joystick_multiplier_value",
5.0, 0.0, 50.0))
js_params.add("joystick_mode", params.ParameterSetString("Response mode",
"joystick_mode",
"quadratic",
["linear", "quadratic"]))
js_params.add("joystick_signx", params.ParameterSetFloat("Sign for x motion",
"joystick_signx",
1.0, [-1.0, 1.0]))
js_params.add("joystick_signy", params.ParameterSetFloat("Sign for y motion",
"joystick_signy",
1.0, [-1.0, 1.0]))
js_params.add("lockt_step", params.ParameterRangeFloat("Focus lock step size in um",
"lockt_step",
0.025, 0.0, 1.0))
js_params.add("min_offset", params.ParameterRangeFloat("Minimum joystick offset to be non-zero",
"min_offset",
0.1, 0.0, 1.0))
js_params.add("xy_swap", params.ParameterSetBoolean("Swap x and y axises",
"xy_swap",
False))
self.parameters = js_params
self.jstick.start(self.joystickHandler)
self.button_timer.setInterval(100)
self.button_timer.setSingleShot(True)
self.button_timer.timeout.connect(self.buttonDownHandler)
def __init__(self, hardware, parameters, parent=None):
# Scope1 specific focus lock parameters
lock_params = parameters.addSubSection("focuslock")
lock_params.add("qpd_zcenter",
params.ParameterRangeFloat(
"Piezo center position in microns", "qpd_zcenter",
150.0, 0.0, 300.0)) # range of z-piezo
lock_params.add("qpd_scale",
params.ParameterRangeFloat(
"Offset to nm calibration value", "qpd_scale", 1.0,
0.1, 1000.0)) # 50, 0.1 to 1000
lock_params.add("qpd_sum_min", 50.0)
lock_params.add("qpd_sum_max", 256.0)
lock_params.add("is_locked_buffer_length", 3)
lock_params.add("is_locked_offset_thresh", 1)
lock_params.add(
"ir_power", params.ParameterInt("",
"ir_power",
6,
is_mutable=False))
offset_file = "cam_offsets_scope1.txt"
cam = uc480Cam.CameraQPD(
camera_id=0,
x_width=180,
y_width=
200, # x_width = 680, y_width = 200, 5/31/17 x_width = 540, y_width = 150 / 1280 x 1040
sigma=4.0,
offset_file=offset_file) # sigma = 4.0
stage = MCLVZC.MCLVZControl("USB-6002", 0)
# stage = noneWidgets.NanoP() # use this to bypass the stage
lock_fn = lambda (x): -0.02 * x
control_thread = stageOffsetControl.StageCamThread(
cam,
stage,
lock_fn,
parameters.get("focuslock.qpd_sum_min", 50.0),
parameters.get("focuslock.qpd_zcenter"), #add a 0
parameters.get("focuslock.is_locked_buffer_length", 3),
parameters.get("focuslock.is_locked_offset_thresh", 1))
ir_laser = LDC210.LDC210PWMNI(
"PCIe-6353", 1
) # Inputs here are (DAQ-card name, counter number). (was 0, switched to 1 and changed wiring 8/11/16)
focusLockZ.FocusLockZCam.__init__(self, parameters, control_thread,
ir_laser, parent)
print 'focus lock started'
def __init__(self, parameters, parent):
QtGui.QDialog.__init__(self, parent)
halModule.HalModule.__init__(self)
if parent:
self.have_parent = True
else:
self.have_parent = False
# General.
self.offset_file = 0
self.parameters = parameters
self.jumpsize = 0.0
self.tcp_message = None
# Qt timer for checking focus lock
self.focus_check_timer = QtCore.QTimer()
self.focus_check_timer.setSingleShot(True)
self.focus_check_timer.timeout.connect(self.tcpPollFocusStatus)
self.num_focus_checks = 0
self.accum_focus_checks = 0
# Focus lock specific parameters.
flock_params = self.parameters.get("focuslock")
flock_params.add("qpd_mode", params.ParameterRangeInt("Current mode",
"qpd_mode",
0, 0, 6,
is_mutable = False,
is_saved = False))
flock_params.add("cal_frames_to_pause", params.ParameterRangeInt("Frames to pause between steps (z-calibration)",
"cal_frames_to_pause", 2, 1, 100))
flock_params.add("cal_deadtime", params.ParameterRangeInt("Frames before to pause at start (z-calibration)",
"cal_deadtime", 20, 1, 100))
flock_params.add("cal_range", params.ParameterRangeFloat("Distance +- z to move in nanometers (z-calibration)",
"cal_range", 600, 100, 5000))
flock_params.add("cal_step_size", params.ParameterRangeFloat("Step size in z in nanometers (z-calibration)",
"cal_step_size", 10, 1, 100))
flock_params.add("olock_bracket_step", params.ParameterRangeFloat("Distance +- z in nanometers (optimal lock)",
"olock_bracket_step", 1000.0, 10.0, 10000.0))
flock_params.add("olock_quality_threshold", params.ParameterRangeFloat("Minimum 'quality' signal (optimal lock)",
"olock_quality_threshold", 0.0, 0.0, 1000.0))
flock_params.add("olock_scan_step", params.ParameterRangeFloat("Step size in z in nanometers (optimal lock)",
"olock_scan_step", 100.0, 10.0, 1000.0))
flock_params.add("olock_scan_hold", params.ParameterRangeInt("Frames to pause between steps (optimal lock)",
"olock_scan_hold", 10, 1, 100))
flock_params.add("zscan_focus_lock", params.ParameterSetBoolean("Lock focus between steps (z-scan)",
"zscan_focus_lock", False))
flock_params.add("zscan_frames_to_pause", params.ParameterRangeInt("Frames to pause between steps (z-scan)",
"zscan_frames_to_pause", 100, 1, 100000))
flock_params.add("zscan_start", params.ParameterRangeFloat("Piezo starting position in micros (z-scan)",
"zscan_start", 50.0, 0.0, 1000.0))
flock_params.add("zscan_step", params.ParameterRangeFloat("Piezo step size in microns (z-scan)",
"zscan_step", 0.1, 0.0, 100.0))
flock_params.add("zscan_stop", params.ParameterRangeFloat("Piezo stopping position (z-scan)",
"zscan_stop", 51.0, 0.0, 1000.0))
def __init__(self, hardware, parameters, parent=None):
# STORM4 specific focus lock parameters
lock_params = parameters.addSubSection("focuslock")
lock_params.add(
"qpd_zcenter",
params.ParameterRangeFloat("Piezo center position in microns",
"qpd_zcenter", 50.0, 0.0, 100.0))
lock_params.add(
"qpd_scale",
params.ParameterRangeFloat("Offset to nm calibration value",
"qpd_scale", 50.0, 0.1, 1000.0))
lock_params.add("qpd_sum_min", 50.0)
lock_params.add("qpd_sum_max", 256.0)
lock_params.add("is_locked_buffer_length", 3)
lock_params.add("is_locked_offset_thresh", 1)
lock_params.add(
"ir_power", params.ParameterInt("",
"ir_power",
6,
is_mutable=False))
# STORM4 Initialization
cam = uc480Cam.CameraQPD(camera_id=1,
x_width=300,
y_width=50,
offset_file="cam_offsets_storm4_1.txt",
background=15250)
stage = mclController.MCLStage(
"c:/Program Files/Mad City Labs/NanoDrive/")
lock_fn = lambda (x): 0.09 * x
control_thread = stageOffsetControl.StageCamThread(
cam, stage, lock_fn, parameters.get("focuslock.qpd_sum_min", 50.0),
parameters.get("focuslock.qpd_zcenter"),
parameters.get("focuslock.is_locked_buffer_length", 3),
parameters.get("focuslock.is_locked_offset_thresh", 1))
ir_laser = LDC210.LDC210PWMLJ()
focusLockZ.FocusLockZCam.__init__(self, parameters, control_thread,
ir_laser, parent)
def __init__(self, hardware, parameters, parent=None):
# STORM3 specific focus lock parameters
lock_params = parameters.addSubSection("focuslock")
lock_params.add(
"qpd_zcenter",
params.ParameterRangeFloat("Piezo center position in microns",
"qpd_zcenter", 100.0, 0.0, 200.0))
lock_params.add(
"qpd_scale",
params.ParameterRangeFloat("Offset to nm calibration value",
"qpd_scale", -700.0, 0.1, 1000.0))
lock_params.add("qpd_sum_min", 50.0)
lock_params.add("qpd_sum_max", 100000.0)
lock_params.add("is_locked_buffer_length", 3)
lock_params.add("is_locked_offset_thresh", 0.1)
lock_params.add(
"ir_power", params.ParameterInt("",
"ir_power",
6,
is_mutable=False))
# Create camera
cam = uc480Cam.CameraQPD(camera_id=1,
x_width=1000,
y_width=70,
sigma=4.0,
offset_file="cam_offsets_jfocal_1.txt",
background=125000)
stage = MCLVZC.MCLVZControl("PCIe-6351", 0, scale=10.0 / 200.0)
lock_fn = lambda (x): 0.1 * x
control_thread = stageOffsetControl.StageCamThread(
cam, stage, lock_fn, parameters.get("focuslock.qpd_sum_min", 50.0),
parameters.get("focuslock.qpd_zcenter"),
parameters.get("focuslock.is_locked_buffer_length", 3),
parameters.get("focuslock.is_locked_offset_thresh", 0.1))
ir_laser = LDC210.LDC210PWMNI("PCIe-6351", 0)
focusLockZ.FocusLockZCam.__init__(self, parameters, control_thread,
ir_laser, parent)
def __init__(self, hardware, parameters, parent=None):
# STORM2 specific focus lock parameters.
lock_params = parameters.addSubSection("focuslock")
lock_params.add(
"qpd_zcenter",
params.ParameterRangeFloat("Piezo center position in microns",
"qpd_zcenter", 125.0, 0.0, 250.0))
lock_params.add(
"qpd_scale",
params.ParameterRangeFloat("Offset to nm calibration value",
"qpd_scale", 45.0, 0.1, 1000.0))
lock_params.add("qpd_sum_min", 50.0)
lock_params.add("qpd_sum_max", 256.0)
lock_params.add("is_locked_buffer_length", 10)
lock_params.add("is_locked_offset_thresh", 0.01)
lock_params.add(
"ir_power", params.ParameterInt("",
"ir_power",
6,
is_mutable=False))
# STORM2 Initialization.
cam = uc480Cam.CameraQPD(camera_id=1,
x_width=452,
y_width=80,
offset_file="cam_offsets_storm2_1.txt")
stage = MCLVZC.MCLVZControl("USB-6002", 0)
lock_fn = lambda (x): 0.07 * x
control_thread = stageOffsetControl.StageCamThread(
cam, stage, lock_fn, parameters.get("focuslock.qpd_sum_min", 50.0),
parameters.get("focuslock.qpd_zcenter"),
parameters.get("focuslock.is_locked_buffer_length", 10),
parameters.get("focuslock.is_locked_offset_thresh", 0.01))
ir_laser = LDC210.LDC210PWMNI("PCI-6601", 0)
focusLockZ.FocusLockZCam.__init__(self, parameters, control_thread,
ir_laser, parent)
def __init__(self, hardware, parameters, parent = None):
cameraControl.HWCameraControl.__init__(self, hardware, parameters, parent)
if hardware:
self.camera = hcam.HamamatsuCameraMR(hardware.get("camera_id", 0))
else:
self.camera = hcam.HamamatsuCameraMR(0)
# Add Hamatsu Flash4 specific camera parameters.
cam_params = parameters.get("camera1")
# FIXME: These should all be obtained by querying the camere.
cam_params.add("max_intensity", params.ParameterInt("",
"max_intensity",
4096,
is_mutable = False,
is_saved = False))
cam_params.add("x_start", params.ParameterRangeInt("AOI X start",
"x_start",
768, 0, 2046))
cam_params.add("x_end", params.ParameterRangeInt("AOI X end",
"x_end",
1279, 1, 2047))
cam_params.add("y_start", params.ParameterRangeInt("AOI Y start",
"y_start",
768, 0, 2046))
cam_params.add("y_end", params.ParameterRangeInt("AOI Y end",
"y_end",
1279, 1, 2047))
cam_params.add("x_bin", params.ParameterRangeInt("Binning in X",
"x_bin",
1, 1, 4))
cam_params.add("y_bin", params.ParameterRangeInt("Binning in Y",
"y_bin",
1, 1, 4))
cam_params.add("exposure_time", params.ParameterRangeFloat("Exposure time (seconds)",
"exposure_time",
0.01, 0.0, 60.0))
cam_params.add("defect_correct_mode", params.ParameterSetInt("Defect correction mode",
"defect_correct_mode",
1, [0, 1]))
cam_params.add("external_trigger", params.ParameterSetInt("Use external trigger",
"external_trigger",
0, [0, 1]))
def __init__(self, hardware, parameters, parent=None):
cameraControl.CameraControl.__init__(self, hardware, parameters,
parent)
self.fake_frame = 0
self.fake_frame_size = [0, 0]
self.parameters = parameters.get("camera1")
self.sleep_time = 100
# Add None Camera specific parameters.
self.parameters.add(
"max_intensity",
params.ParameterInt("",
"max_intensity",
10000,
is_mutable=False,
is_saved=False))
self.parameters.add(
"x_start",
params.ParameterRangeInt("X start pixel", "x_start", 1, 1, 512))
self.parameters.add(
"x_end",
params.ParameterRangeInt("X end pixel", "x_end", 512, 1, 512))
self.parameters.add(
"y_start",
params.ParameterRangeInt("Y start pixel", "y_start", 1, 1, 512))
self.parameters.add(
"y_end",
params.ParameterRangeInt("Y end pixel", "y_end", 512, 1, 512))
self.parameters.add(
"x_bin", params.ParameterRangeInt("Binning in X", "x_bin", 1, 1,
16))
self.parameters.add(
"y_bin", params.ParameterRangeInt("Binning in Y", "y_bin", 1, 1,
16))
self.parameters.add(
"exposure_time",
params.ParameterRangeFloat("Exposure time (seconds)",
"exposure_time", 0.01, 0.01, 10.0))
if hardware:
self.roll = hardware.get("roll")
else:
self.roll = 0
self.initCamera()
def getSpeed(self):
return params.ParameterRangeFloat("Stage speed in mm/sec",
"stage_speed", 2.0, 0.1, 50.0)
def __init__(self, hardware, parameters, parent = None):
cameraControl.HWCameraControl.__init__(self, hardware, parameters, parent)
if hardware and hardware.has("pci_card"):
self.initCamera(hardware.get("pci_card"))
else:
self.initCamera()
# Add Andor EMCCD specific parameters.
#
cam_params = parameters.get("camera1")
# FIXME: Need to get this value from the camera.
max_intensity = self.camera.getMaxIntensity()
cam_params.add("max_intensity", params.ParameterInt("",
"max_intensity",
max_intensity,
is_mutable = False,
is_saved = False))
# FIXME: Need to update based on the current EM gain mode.
[gain_low, gain_high] = self.camera.getEMGainRange()
cam_params.add("emccd_gain", params.ParameterRangeInt("EMCCD Gain",
"emccd_gain",
gain_low, gain_low, gain_high))
[x_size, y_size] = self.camera.getCameraSize()
cam_params.add("x_start", params.ParameterRangeInt("AOI X start",
"x_start",
1, 1, x_size))
cam_params.add("x_end", params.ParameterRangeInt("AOI X end",
"x_end",
x_size, 1, x_size))
cam_params.add("y_start", params.ParameterRangeInt("AOI Y start",
"y_start",
1, 1, y_size))
cam_params.add("y_end", params.ParameterRangeInt("AOI Y end",
"y_end",
y_size, 1, y_size))
[x_max_bin, y_max_bin] = self.camera.getMaxBinning()
cam_params.add("x_bin", params.ParameterRangeInt("Binning in X",
"x_bin",
1, 1, x_max_bin))
cam_params.add("y_bin", params.ParameterRangeInt("Binning in Y",
"y_bin",
1, 1, y_max_bin))
# FIXME: Need to check if camera supports frame transfer mode.
cam_params.add("frame_transfer_mode", params.ParameterSetInt("Frame transfer mode (0 = off, 1 = on)",
"frame_transfer_mode",
1, [0, 1]))
[mint, maxt] = self.camera.getTemperatureRange()
cam_params.add("temperature", params.ParameterRangeInt("Temperature",
"temperature",
-70, mint, maxt))
preamp_gains = self.camera.getPreampGains()
cam_params.add("preampgain", params.ParameterSetFloat("Pre-amplifier gain",
"preampgain",
preamp_gains[0], preamp_gains))
# FIXME: Need to update based on the AD channel.
hs_speeds = self.camera.getHSSpeeds()[0]
cam_params.add("hsspeed", params.ParameterSetFloat("Horizontal shift speed",
"hsspeed",
hs_speeds[0], hs_speeds))
vs_speeds = self.camera.getVSSpeeds()
cam_params.add("vsspeed", params.ParameterSetFloat("Vertical shift speed",
"vsspeed",
vs_speeds[-1], vs_speeds))
max_exposure = self.camera.getMaxExposure()
cam_params.add("exposure_time", params.ParameterRangeFloat("Exposure time (seconds)",
"exposure_time",
0.0, 0.0, max_exposure))
cam_params.add("kinetic_cycle_time", params.ParameterRangeFloat("Kinetic cycle time (seconds)",
"kinetic_cycle_time",
0.0, 0.0, 100.0))
ad_channels = range(self.camera.getNumberADChannels())
cam_params.add("adchannel", params.ParameterSetInt("Analog to digital converter channel",
"adchannel",
0, ad_channels))
n_modes = range(self.camera.getNumberEMGainModes())
cam_params.add("emgainmode", params.ParameterSetInt("EMCCD gain mode",
"emgainmode",
0, n_modes))
cam_params.add("baselineclamp", params.ParameterSetBoolean("Baseline clamp",
"baselineclamp",
True))
# FIXME: Need to get amplitudes from the camera.
cam_params.add("vsamplitude", params.ParameterSetInt("Vertical shift amplitude",
"vsamplitude",
0, [0, 1, 2]))
cam_params.add("off_during_filming", params.ParameterSetBoolean("Fan off during filming",
"off_during_filming",
False))
cam_params.add("low_during_filming", params.ParameterSetBoolean("Fan low during filming",
"low_during_filming",
False))
cam_params.add("external_trigger", params.ParameterSetBoolean("Use an external camera trigger",
"external_trigger",
False))
cam_params.add("head_model", params.ParameterString("Camera head model", "head_model", "",
is_mutable = False))
cam_params.add("isolated_cropmode", params.ParameterSetBoolean("Isolated crop mode",
"isolated_cropmode",
False))
def __init__(self, hardware, parameters, parent):
QtGui.QDialog.__init__(self, parent)
halModule.HalModule.__init__(self)
self.channels = False
self.exp_channels = False
self.linear_channels = False
self.file_channels = False
self.parameters = parameters
self.use_was_checked = False
self.which_checked = []
# Add progression parameters.
self.parameters.add(
"progressions.use_progressions",
params.ParameterSetBoolean("",
"use_progressions",
False,
is_mutable=False))
self.parameters.add(
"progressions.pstart_value",
params.ParameterRangeFloat("",
"pstart_value",
0.1,
0.0,
1.0,
is_mutable=False,
is_saved=False))
self.parameters.add(
"progressions.pinc_value",
params.ParameterRangeFloat("",
"pinc_value",
0.01,
0.0,
1.0,
is_mutable=False,
is_saved=False))
self.parameters.add(
"progressions.pfile_name",
params.ParameterStringFilename("Progression file name",
"pfile_name", "", False))
self.parameters.add(
"progressions.pframe_value",
params.ParameterRangeInt("",
"pframe_value",
1000,
100,
100000,
is_mutable=False,
is_saved=False))
if parent:
self.have_parent = 1
else:
self.have_parent = 0
# UI setup
self.ui = progressionUi.Ui_Dialog()
self.ui.setupUi(self)
self.setWindowTitle(
parameters.get("setup_name") + " Progression Control")
self.setWindowIcon(qtAppIcon.QAppIcon())
# connect signals
if self.have_parent:
self.ui.okButton.setText("Close")
self.ui.okButton.clicked.connect(self.handleOk)
else:
self.ui.okButton.setText("Quit")
self.ui.okButton.clicked.connect(self.handleQuit)
self.ui.progressionsCheckBox.stateChanged.connect(self.handleProgCheck)
self.ui.loadFileButton.clicked.connect(self.newPowerFile)
# set modeless
self.setModal(False)
def getSpeed(self):
# FIXME: Is this really um/s?
return params.ParameterRangeFloat("Stage speed in um/s", "stage_speed",
10000.0, 100.0, 10000.0)
def __init__(self, parameters, parent=None):
QtGui.QDialog.__init__(self, parent)
halModule.HalModule.__init__(self)
self.counters = [False, False]
self.filming = 0
self.filenames = [False, False]
self.frame_interval = parameters.get("spotcounter.interval", 1)
self.image_graphs = [False, False]
self.parameters = parameters
self.spot_counter = False
self.spot_graphs = [False, False]
if parent:
self.have_parent = True
else:
self.have_parent = False
# Add spot counter specific parameters.
#
# FIXME: We should just use a pixel length scale bar and drop the nm stuff, or
# we should get the nm_per_pixel from the mosaic settings and the current
# objective.
#
spotc_params = self.parameters.addSubSection("spotcounter")
spotc_params.add(
"cell_size",
params.ParameterRangeInt("Cell size for background subtraction",
"cell_size",
32,
8,
128,
is_mutable=False,
is_saved=False))
spotc_params.add(
"max_spots",
params.ParameterRangeInt(
"Maximum counts for the spotcounter graph",
"max_spots",
500,
0,
1000,
is_mutable=False,
is_saved=False))
spotc_params.add(
"min_spots",
params.ParameterRangeInt(
"Minimum counts for the spotcounter graph",
"min_spots",
0,
0,
1000,
is_mutable=False,
is_saved=False))
spotc_params.add(
"nm_per_pixel",
params.ParameterRangeFloat("Camera pixel size in nanometers",
"nm_per_pixel", 160, 10, 1000))
spotc_params.add(
"scale_bar_len",
params.ParameterRangeFloat("Scale bar length in nm",
"scale_bar_len", 1000, 100, 10000))
spotc_params.add(
"threshold",
params.ParameterRangeInt(
"Spot detection threshold (camera counts)", "threshold", 250,
1, 10000))
# UI setup.
self.ui.setupUi(self)
self.setWindowTitle(parameters.get("setup_name") + " Spot Counter")
self.setWindowIcon(qtAppIcon.QAppIcon())
# Setup Counter objects.
if (self.number_cameras == 1):
self.counters = [
Counter(self.ui.countsLabel1, self.ui.countsLabel2)
]
else:
self.counters = [
Counter(self.ui.countsLabel1, self.ui.countsLabel2),
Counter(self.ui.countsLabel3, self.ui.countsLabel4)
]
# Setup spot counter.
self.spot_counter = qtSpotCounter.QObjectCounter(
parameters.get("spotcounter"))
self.spot_counter.imageProcessed.connect(self.updateCounts)
# Setup spot counts graph(s).
if (self.number_cameras == 1):
parents = [self.ui.graphFrame]
else:
parents = [self.ui.graphFrame, self.ui.graphFrame2]
for i in range(self.number_cameras):
graph_w = parents[i].width() - 4
graph_h = parents[i].height() - 4
self.spot_graphs[i] = QSpotGraph(
graph_w,
graph_h,
parameters.get("spotcounter.min_spots"),
parameters.get("spotcounter.max_spots"),
parent=parents[i])
self.spot_graphs[i].setGeometry(2, 2, graph_w, graph_h)
self.spot_graphs[i].show()
# Setup STORM image(s).
if (self.number_cameras == 1):
parents = [self.ui.imageFrame]
else:
parents = [self.ui.imageFrame, self.ui.imageFrame2]
for i in range(self.number_cameras):
image_w = parents[i].width() - 4
image_h = parents[i].height() - 4
self.image_graphs[i] = QImageGraph(image_w,
image_h,
parent=parents[i])
self.image_graphs[i].setGeometry(2, 2, image_w, image_h)
self.image_graphs[i].blank()
self.image_graphs[i].show()
# Connect signals.
if self.have_parent:
self.ui.okButton.setText("Close")
self.ui.okButton.clicked.connect(self.handleOk)
else:
self.ui.okButton.setText("Quit")
self.ui.okButton.clicked.connect(self.handleQuit)
self.ui.maxSpinBox.valueChanged.connect(self.handleMaxChange)
self.ui.minSpinBox.valueChanged.connect(self.handleMinChange)
# Set modeless.
self.setModal(False)
def getSpeed(self):
# FIXME: Need to figure out units for this..
return params.ParameterRangeFloat("Stage speed in AU",
"stage_speed",
50.0, 1.0, 100.0)
def getSpeed(self):
# FIXME: Need to figure out units for this..
return params.ParameterRangeFloat("Stage speed in revolutions/second",
"stage_speed",
2.0, 0.01, 200.0)
def __init__(self, parameters, parent):
QtGui.QMainWindow.__init__(self, parent)
halModule.HalModule.__init__(self)
#self.setFocusPolicy(QtCore.Qt.ClickFocus)
self.directory = ""
self.drag_start_x = 0
self.drag_start_y = 0
self.move_timer = QtCore.QTimer()
self.stage_x = 0
self.stage_y = 0
self.stage_z = 0
self.tcp_message = False
self.translator = Translator()
# Add stage parameters.
parameters.add(
"stage.flip_axis",
params.ParameterSetBoolean("Switch X-Y stage axises", "flip_axis",
False))
parameters.add(
"stage.large_step_size",
params.ParameterRangeFloat("Large step size", "large_step_size",
25.0, 1.0, 500.0))
parameters.add(
"stage.small_step_size",
params.ParameterRangeFloat("Small step size", "small_step_size",
5.0, 1.0, 50.0))
parameters.add("stage.stage_speed", self.stage.getSpeed())
self.stage_speed = parameters.get("stage.stage_speed")
parameters.add(
"stage.x_sign",
params.ParameterSetInt("Reverse the sign of the X axis", "x_sign",
1, [-1, 1]))
parameters.add(
"stage.y_sign",
params.ParameterSetInt("Reverse the sign of the Y axis", "y_sign",
1, [-1, 1]))
if parent:
self.have_parent = True
else:
self.have_parent = False
# UI setup
self.ui = stageUi.Ui_Dialog()
self.ui.setupUi(self)
self.setWindowTitle(parameters.get("setup_name") + " Stage Control")
self.setWindowIcon(qtAppIcon.QAppIcon())
# UI motion buttons.
icon_path = "./icons/"
self.motion_buttons = [
MotionButton(self.ui.leftSButton, icon_path + "1leftarrow-128.png",
"small", 1, 0),
MotionButton(self.ui.leftLButton, icon_path + "2leftarrow-128.png",
"large", 1, 0),
MotionButton(self.ui.rightSButton,
icon_path + "1rightarrow-128.png", "small", -1, 0),
MotionButton(self.ui.rightLButton,
icon_path + "2rightarrow-128.png", "large", -1, 0),
MotionButton(self.ui.upSButton, icon_path + "1uparrow-128.png",
"small", 0, 1),
MotionButton(self.ui.upLButton, icon_path + "2uparrow-128.png",
"large", 0, 1),
MotionButton(self.ui.downSButton,
icon_path + "1downarrow1-128.png", "small", 0, -1),
MotionButton(self.ui.downLButton, icon_path + "2dowarrow-128.png",
"large", 0, -1)
]
for button in self.motion_buttons:
button.buttonClicked.connect(self.moveRelative)
# Configure timer.
self.move_timer.setSingleShot(True)
self.move_timer.timeout.connect(self.handleMoveTimer)
# Connect signals.
if self.have_parent:
self.ui.okButton.setText("Close")
self.ui.okButton.clicked.connect(self.handleOk)
else:
self.ui.okButton.setText("Quit")
self.ui.okButton.clicked.connect(self.handleQuit)
self.ui.addButton.clicked.connect(self.handleAdd)
self.ui.clearButton.clicked.connect(self.handleClear)
self.ui.goButton.clicked.connect(self.handleGo)
self.ui.homeButton.clicked.connect(self.handleHome)
self.ui.loadButton.clicked.connect(self.handleLoad)
self.ui.saveButton.clicked.connect(self.handleSave)
self.ui.saveComboBox.activated.connect(self.handleSaveIndexChange)
self.ui.zeroButton.clicked.connect(self.zero)
# set modeless
self.setModal(False)
# open connection to the stage
if not (self.stage.getStatus()):
print "Failed to connect to the microscope stage. Perhaps it is turned off?"
self.stage.shutDown()
self.stage = False
else:
self.stage.updatePosition.connect(self.handleUpdatePosition)
self.stage.setVelocity(self.stage_speed, self.stage_speed)
def __init__(self, hardware, parameters, parent = None):
cameraControl.HWCameraControl.__init__(self, hardware, parameters, parent)
andor.loadSDK3DLL("C:/Program Files/Andor SOLIS/")
if hardware:
self.camera = andor.SDK3Camera(hardware.get("camera_id", 0))
else:
self.camera = andor.SDK3Camera()
self.camera.setProperty("CycleMode", "enum", "Continuous")
self.parameters = params.StormXMLObject([]) # Create empty parameters object
# Add Andor SDK3 specific parameters.
#
cam_params = parameters.get("camera1")
max_intensity = 2**16
cam_params.add("max_intensity", params.ParameterInt("",
"max_intensity",
max_intensity,
is_mutable = False,
is_saved = False))
## [x_size, y_size] = [2048, 2048]
## cam_params.add("x_start", params.ParameterRangeInt("AOI X start",
## "x_start",
## 1, 1, x_size))
## cam_params.add("x_end", params.ParameterRangeInt("AOI X end",
## "x_end",
## x_size, 1, x_size))
## cam_params.add("y_start", params.ParameterRangeInt("AOI Y start",
## "y_start",
## 1, 1, y_size))
## cam_params.add("y_end", params.ParameterRangeInt("AOI Y end",
## "y_end",
## y_size, 1, y_size))
##
## [x_max_bin, y_max_bin] = [4,4]
## cam_params.add("x_bin", params.ParameterRangeInt("Binning in X",
## "x_bin",
## 1, 1, x_max_bin))
## cam_params.add("y_bin", params.ParameterRangeInt("Binning in Y",
## "y_bin",
## 1, 1, y_max_bin))
cam_params.add("AOIBinning", params.ParameterSetString("AOI Binning",
"AOIBinning",
"1x1",
["1x1", "2x2", "3x3", "4x4", "8x8"]))
cam_params.add("AOIWidth", params.ParameterRangeInt("AOI Width",
"AOIWidth",
2048,
128, 2048))
cam_params.add("AOIHeight", params.ParameterRangeInt("AOI Height",
"AOIHeight",
2048,
128, 2048))
cam_params.add("AOILeft", params.ParameterRangeInt("AOI Left",
"AOILeft",
1,
1, 1028))
cam_params.add("AOITop", params.ParameterRangeInt("AOI Top",
"AOITop",
1,
1, 1028))
cam_params.add("FanSpeed", params.ParameterSetString("Fan Speed",
"FanSpeed",
"On",
["On", "Off"]))
cam_params.add("SensorCooling", params.ParameterSetBoolean("Sensor cooling",
"SensorCooling",
True))
cam_params.add("SimplePreAmpGainControl", params.ParameterSetString("Pre-amp gain control",
"SimplePreAmpGainControl",
"16-bit (low noise & high well capacity)",
["16-bit (low noise & high well capacity)",
"Something else.."]))
cam_params.add("ExposureTime", params.ParameterRangeFloat("Exposure time (seconds)",
"ExposureTime",
0.1, 0.0, 10.0))
def __init__(self, hardware, parameters, parent):
QtCore.QThread.__init__(self, parent)
halModule.HalModule.__init__(self)
self.click_step = 1.0
self.click_timer = QtCore.QTimer(self)
self.click_x = 0.0
self.click_y = 0.0
self.client_sock = False
self.connected = False
self.default_image = QtGui.QImage("bt_image.png")
self.drag_gain = 1.0
self.drag_multiplier = 100.0
self.drag_x = 0.0
self.drag_y = 0.0
self.filming = False
self.image_is_new = True
self.images_sent = 0
self.is_down = False
self.is_drag = False
self.lock_jump_size = 0.025
self.messages = []
self.mutex = QtCore.QMutex()
self.send_pictures = hardware.get("send_pictures")
self.show_camera = True
self.start_time = 0
self.which_camera = "camera1"
parameters.add("bluetooth.z_step", params.ParameterRangeFloat("Z step size in um",
"z_step",
0.025, 0.0, 1.0))
# Set current image to default.
self.current_image = self.default_image
# Setup bluetooth socket.
have_bluetooth = True
try:
self.server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
self.server_sock.bind(("",bluetooth.PORT_ANY))
self.server_sock.listen(1)
port = self.server_sock.getsockname()[1]
hdebug.logText("Bluetooth: Listening on RFCOMM channel {0:d}".format(port))
uuid = "3e1f9ea8-9c11-11e3-b248-425861b86ab6"
bluetooth.advertise_service( self.server_sock, "halServer",
service_id = uuid,
service_classes = [ uuid, bluetooth.SERIAL_PORT_CLASS ],
profiles = [ bluetooth.SERIAL_PORT_PROFILE ],
)
except:
print traceback.format_exc()
hdebug.logText("Failed to start Bluetooth")
have_bluetooth = False
if have_bluetooth:
# Setup timer.
self.click_timer.setInterval(200)
self.click_timer.timeout.connect(self.handleClickTimer)
self.click_timer.setSingleShot(True)
# Connect signals.
self.newData.connect(self.handleNewData)
self.start(QtCore.QThread.NormalPriority)
def __init__(self, hardware, parameters, parent=None):
# Jfocal specific focus lock parameters
lock_params = parameters.addSubSection("focuslock")
lock_params.add(
"qpd_zcenter",
params.ParameterRangeFloat("Piezo center position in microns",
"qpd_zcenter", 100.0, 0.0, 200.0))
lock_params.add(
"qpd_scale",
params.ParameterRangeFloat("Offset to nm calibration value",
"qpd_scale", -1000.0, -10000, 10000.0))
lock_params.add("qpd_sum_min", 50.0)
lock_params.add("qpd_sum_max", 100000.0)
lock_params.add(
"is_locked_buffer_length",
params.ParameterRangeInt("Length of in focus buffer",
"is_locked_buffer_length", 3, 1, 100))
lock_params.add(
"is_locked_offset_thresh",
params.ParameterRangeFloat(
"Offset distance still considered in focus",
"is_locked_offset_thresh", 1, 0.001, 1000))
lock_params.add(
"focus_rate",
params.ParameterRangeFloat("Proportionality constant for focus",
"focus_rate", 0.1, -1000, 1000))
lock_params.add(
"ir_power", params.ParameterInt("",
"ir_power",
6,
is_mutable=False))
# Add parameters for hardware timed z offsets
lock_params.add(
"z_offsets",
params.ParameterString(
"Comma separated list of offset positions per frame",
"z_offsets", ""))
# Create camera
cam = uc480Cam.CameraQPD(camera_id=1,
x_width=900,
y_width=50,
sigma=4.0,
offset_file="cam_offsets_jfocal_1.txt",
background=50000)
stage = MCLVZC.MCLVZControl("PCIe-6351",
0,
scale=10.0 / 200.0,
trigger_source="PFI0")
lock_fn = lambda (x): lock_params.get("focus_rate") * x
control_thread = stageOffsetControl.StageCamThread(
cam, stage, lock_fn, parameters.get("focuslock.qpd_sum_min", 50.0),
parameters.get("focuslock.qpd_zcenter"),
parameters.get("focuslock.is_locked_buffer_length", 3),
parameters.get("focuslock.is_locked_offset_thresh", 0.1))
ir_laser = LDC210.LDC210PWMNI("PCIe-6351", 0)
focusLockZ.FocusLockZCam.__init__(self, parameters, control_thread,
ir_laser, parent)
