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)