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): miscControl.MiscControl.__init__(self, parameters, parent) self.em_filter_pos = 0 self.em_filter_wheel = prior.Prior(port=hardware.get("port"), baudrate=hardware.get("baud_rate")) # Add parameters. misc_params = parameters.addSubSection("misc") misc_params.add( "em_checked", params.ParameterSetBoolean( "Change emission filter position during filming", "em_checked", False)) misc_params.add( "em_filter", params.ParameterRangeInt("Emission filter position", "em_filter", 0, 0, 5)) misc_params.add( "em_period", params.ParameterInt("Emission filter update period in frames", "em_period", 60)) # UI setup self.ui = miscControlsUi.Ui_Dialog() self.ui.setupUi(self) self.setWindowTitle(parameters.get("setup_name") + " Misc Control") # 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) # setup (emission) filter wheel # self.ui.emFilter6Button.hide() # self.ui.emFilter7Button.hide() # self.ui.emFilter8Button.hide() # self.ui.emFilter9Button.hide() # self.ui.emFilter10Button.hide() self.em_filters = [[self.ui.emFilter1Button, "Quad"], [self.ui.emFilter2Button, "750"], [self.ui.emFilter3Button, "647"], [self.ui.emFilter4Button, "560"], [self.ui.emFilter5Button, "488"], [self.ui.emFilter6Button, "Empty"]] for [afilter, name] in self.em_filters: afilter.clicked.connect(self.handleEmFilter) afilter.setText(name) if self.em_filter_wheel: self.em_filters[self.em_filter_wheel.getFilter() - 1][0].click() self.ui.emCheckBox.setChecked(parameters.get("misc.em_checked")) self.ui.emSpinBox.setValue(parameters.get("misc.em_period"))
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 __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 __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 __init__(self, parameters, hardware_config): # Create serial control thread try: self.serial_thread = W1SerialThread( hardware_config.get("com_port"), baudrate=115200, timeout=0.01, verbose=hardware_config.get("verbose", False)) except: print "Could not create serial port for spinning disk. Is it connected properly?" raise W1Exception("W1 Spinning Disk Initialization Error \n" + " Could not properly initialize com_port: " + str(hardware_config.get("com_port"))) # Connect error signal from serial control thread self.serial_thread.error.connect(self.handleSerialThreadError) # Start thread self.serial_thread.start(QtCore.QThread.NormalPriority) # Create a local copy of the current W1 configuration self.params = params.StormXMLObject( []) # Create empty parameters object # Record internal verbosity (debug purposes only) self.verbose = hardware_config.get("verbose") # Create dictionaries for the configuration of the filter wheels and two dichroic mirror sets self.filter_wheel_1_config = {} values = hardware_config.get("filter_wheel_1") filter_names = values.split(",") for pos, filter_name in enumerate(filter_names): self.filter_wheel_1_config[filter_name] = pos + 1 self.filter_wheel_2_config = {} values = hardware_config.get("filter_wheel_2") filter_names = values.split(",") for pos, filter_name in enumerate(filter_names): self.filter_wheel_2_config[filter_name] = pos + 1 self.dichroic_mirror_config = {} values = hardware_config.get("dichroic_mirror") dichroic_names = values.split(",") for pos, dichroic_name in enumerate(dichroic_names): self.dichroic_mirror_config[dichroic_name] = pos + 1 self.camera_dichroic_config = {} values = hardware_config.get("camera_dichroic") camera_dichroic_names = values.split(",") for pos, camera_dichroic in enumerate(camera_dichroic_names): self.camera_dichroic_config[camera_dichroic] = pos + 1 # Define error codes self.error_codes = { "30005": "Command name error", "30006": "Command argument number error", "30007": "Command argument value error", "30141": "Command argument value error", "30012": "Interlock alarm is on", "30133": "Interlock alarm is on", "30014": "Electricity alarm is on", "30015": "Shutter alarm is on", "30016": "Actuator alarm is on", "30017": "Disk alarm is on", "30018": "Data error alarm is on", "30019": "Other alarm is on", "30021": "Designated system is not defined", "30022": "Designated system does not exist", "30023": "Designated system is not detected", "30031": "Waiting for initialization to complete", "30032": "Under maintenance mode", "30201": "External SYNC signal is under use", "30204": "Disk rotation stopped", "30301": "Shutter error", "30302": "Shutter unopenable error", "1": "Unknown serial communication error" } # Initialize spinning disk parameters # Add spinning disk sub section sd_params = parameters.addSubSection("spinning_disk") # Add basic parameters sd_params.add( "bright_field_bypass", params.ParameterSetBoolean( "Bypass spinning disk for brightfield mode?", "bright_field_bypass", False)) sd_params.add( "spin_disk", params.ParameterSetBoolean("Spin the disk?", "spin_disk", True)) # Disk properties sd_params.add( "disk", params.ParameterSetString( "Disk pinhole size", "disk", "50-micron pinholes", ["50-micron pinholes", "25-micron pinholes"])) max_speed = self.getMaxSpeed() sd_params.add( "disk_speed", params.ParameterRangeInt("Disk speed (RPM)", "disk_speed", max_speed, 1, max_speed)) # Dichroic mirror position values = sorted(self.dichroic_mirror_config.keys()) sd_params.add( "dichroic_mirror", params.ParameterSetString("Dichroic mirror position", "dichroic_mirror", values[0], values)) # Filter wheel positions values = sorted(self.filter_wheel_1_config.keys()) sd_params.add( "filter_wheel_pos1", params.ParameterSetString("Camera 1 Filter Wheel Position (1-10)", "filter_wheel_pos1", values[0], values)) values = sorted(self.filter_wheel_2_config.keys()) sd_params.add( "filter_wheel_pos2", params.ParameterSetString("Camera 2 Filter Wheel Position (1-10)", "filter_wheel_pos2", values[0], values)) # Camera dichroic positions values = sorted(self.camera_dichroic_config.keys()) sd_params.add( "camera_dichroic_mirror", params.ParameterSetString("Camera dichroic mirror position (1-3)", "camera_dichroic_mirror", values[0], values)) # Aperature settings sd_params.add( "aperture", params.ParameterRangeInt("Aperture value (1-10; small to large)", "aperture", 10, 1, 10))
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=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)
def getSpeed(self): # FIXME: Need to figure out units for this.. return params.ParameterRangeInt("Stage speed in pulses per second", "stage_speed", 2564800, 2464800, 2564800)
def __init__(self, hardware, parameters, parent=None): miscControl.MiscControl.__init__(self, parameters, parent) self.em_filter_pos = 0 self.em_filter_wheel = filterWheel.QPriorFilterWheel() self.filter_wheel = filterWheel.QPriorFilterWheel() # Add parameters. misc_params = parameters.addSubSection("misc") misc_params.add( "filter_names", params.ParameterString("Filter names", "filter_names", "1,2,3,4,5,6")) misc_params.add( "filter_position", params.ParameterRangeInt("Filter position", "filter_position", 0, 0, 5)) misc_params.add( "em_checked", params.ParameterSetBoolean( "Change emission filter position during filming", "em_checked", False)) misc_params.add( "em_filter", params.ParameterRangeInt("Emission filter position", "em_filter", 0, 0, 5)) misc_params.add( "em_period", params.ParameterInt("Emission filter update period in frames", "em_period", 60)) # UI setup self.ui = miscControlsUi.Ui_Dialog() self.ui.setupUi(self) self.setWindowTitle(parameters.get("setup_name") + " Misc Control") # 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) # setup (turret) filter wheel self.filters = [ self.ui.filter1Button, self.ui.filter2Button, self.ui.filter3Button, self.ui.filter4Button, self.ui.filter5Button, self.ui.filter6Button ] for afilter in self.filters: afilter.clicked.connect(self.handleFilter) if self.filter_wheel: self.filters[self.filter_wheel.getPosition(1) - 1].click() # setup (emission) filter wheel self.ui.emFilter6Button.hide() self.ui.emFilter7Button.hide() self.ui.emFilter8Button.hide() self.ui.emFilter9Button.hide() self.ui.emFilter10Button.hide() self.em_filters = [ self.ui.emFilter1Button, self.ui.emFilter2Button, self.ui.emFilter3Button, self.ui.emFilter4Button, self.ui.emFilter5Button, self.ui.emFilter6Button, self.ui.emFilter7Button, self.ui.emFilter8Button, self.ui.emFilter9Button, self.ui.emFilter10Button ] for afilter in self.em_filters: afilter.clicked.connect(self.handleEmFilter) if self.em_filter_wheel: self.em_filters[self.filter_wheel.getPosition(2) - 1].click() self.ui.emCheckBox.setChecked(parameters.get("misc.em_checked")) self.ui.emSpinBox.setValue(parameters.get("misc.em_period"))
def __init__(self, hardware, parameters, parent=None): miscControl.MiscControl.__init__(self, parameters, parent) self.filter_wheel = filterWheel.QPriorFilterWheel() self.move_timer = QtCore.QTimer(self) self.move_timer.setInterval(50) self.smc100 = SMC100.SMC100(port="COM10") # Add parameters misc_params = parameters.addSubSection("misc") misc_params.add("jog_size", 0.01) misc_params.add("epi_position", 17.92) misc_params.add("tirf_position", 20.76) misc_params.add( "filter_names", params.ParameterString("Filter names", "filter_names", "1,2,3,4,5,6")) misc_params.add( "filter_position", params.ParameterRangeInt("Filter position", "filter_position", 0, 0, 5)) # UI setup self.ui = miscControlsUi.Ui_Dialog() self.ui.setupUi(self) self.setWindowTitle(parameters.get("setup_name") + " Misc Control") # 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) # setup epi/tir stage control self.ui.EPIButton.clicked.connect(self.goToEPI) self.ui.leftSmallButton.clicked.connect(self.smallLeft) self.ui.rightSmallButton.clicked.connect(self.smallRight) self.ui.leftLargeButton.clicked.connect(self.largeLeft) self.ui.rightLargeButton.clicked.connect(self.largeRight) self.ui.TIRFButton.clicked.connect(self.goToTIRF) self.ui.tirGoButton.clicked.connect(self.goToX) self.move_timer.timeout.connect(self.updatePosition) self.position = self.smc100.getPosition() self.setPositionText() # setup filter wheel self.filters = [ self.ui.filter1Button, self.ui.filter2Button, self.ui.filter3Button, self.ui.filter4Button, self.ui.filter5Button, self.ui.filter6Button ] for filter in self.filters: filter.clicked.connect(self.handleFilter) self.filters[self.filter_wheel.getPosition() - 1].click() # Imagine Eyes stuff self.ie_accumulate = False self.ie_accumulate_count = 0 self.ie_autosave = False self.ie_basename = "img.ch00." self.ie_capture = False self.ie_directory = "c:\\tif_directory\\" self.ie_index = 1 self.ie_start_x = 0 self.ie_start_y = 0 self.ie_stop_x = 0 self.ie_stop_y = 0 self.ui.iEyesLabel.setText(self.getIEName()) self.ui.iEyesLineEdit.setText(self.ie_basename) self.ui.iEyesAutoSaveButton.clicked.connect(self.handleAutoSave) self.ui.iEyesClearROIButton.clicked.connect(self.handleClearROI) self.ui.iEyesLineEdit.textChanged.connect(self.handleLineEdit) self.ui.iEyesResetButton.clicked.connect(self.handleReset) self.ui.iEyesSaveButton.clicked.connect(self.handleSave) self.newParameters(self.parameters)