def login(self):
login_dialog = Login(self.login_parameters)
if login_dialog.exec_() != QDialog.Accepted:
self.exit()
else:
self.file_writer_group.root_dir_entry.setText(
self.login_parameters['expdir'])
td = date.today()
tdstr = "{}.{}.{}".format(td.year, td.month, td.day)
logfname = os.path.join(self.login_parameters['expdir'],
'exp-log-' + tdstr + '.log')
if self.login_parameters.has_key('project'):
logfname = os.path.join(
self.login_parameters['expdir'],
'{}-log-{}-{}.log'.format(self.login_parameters['project'],
self.login_parameters['bl'],
tdstr))
try:
open(logfname, 'a').close()
except:
warning_message('Cannot create log file')
self._log = log
self._log.log_to_file(logfname, logging.DEBUG)
self.log = self._log.get_module_logger(__name__)
self.log.info("Start gui.py")
# add motors automatically on start
self.motor_control_group.connect_hor_mot_button.animateClick()
self.motor_control_group.connect_vert_mot_button.animateClick()
self.motor_control_group.connect_CT_mot_button.animateClick()
self.motor_control_group.connect_shutter_button.animateClick()
def check_data_overwrite(self):
if self.file_writer_group.isChecked():
if os.path.exists(os.path.join( \
self.file_writer_group.root_dir, \
self.file_writer_group.ctsetname.format(1))):
warning_message("Output directory exists. \n"
"Change root dir or name pattern"
"and start again")
self.abort()
def select_log_file_func(self):
f, fext = self.QFD.getSaveFileName(self, 'Select file',
self.file_writer_group.root_dir,
"log files (*.log)")
if f == '':
warning_message('Select file')
return
# use logging from EDC
self._log.log_to_file(f + '.log', logging.DEBUG)
self.log = self._log.get_module_logger(__name__)
return
def validate_velocity(self):
#taken from concert/imaging.py by T. Farago
# every pixel of the frame rotates no more than one pixel per rotation step
tomo_ang_step = np.arctan(2.0 / self.camera_controls_group.roi_width)
#minimum number of projections in order to provide enough
#data points for every distance from the axis of rotation
tomo_proj_num = int(np.ceil(np.pi / tomo_ang_step))
# speed at which motion blur will exceed one pixel
tomo_max_rot_velo = tomo_ang_step * self.camera_controls_group.fps
velocity = self.scan_controls_group.inner_range / \
(self.scan_controls_group.inner_steps / self.camera_controls_group.fps)
if velocity > tomo_max_rot_velo:
warning_message(
"Rotation speed is too large for this ROI width.\n"
"Consider increasing exposure time or num of projections to avoid blurring.\n"
"Experiment will continue.")
def dead_time(self):
try:
x = float(self.delay_entry.text())
except ValueError:
warning_message(
"{:}".format("Dead time must be a non-negative number"))
x = 0
self.delay_entry.setText('0')
self.all_cam_params_correct = False
if x < 0:
warning_message(
"{:}".format("Dead time must be a non-negative number"))
x = 0
self.delay_entry.setText('0')
self.all_cam_params_correct = False
return x
def fps(self):
try:
x = float(self.fps_entry.text())
except ValueError:
warning_message("{:}".format(
"FPS a positive number. Setting FPS based on exp. time"))
x = self.relate_fps_to_exptime()
if x < 0:
error_message("{:}".format("FPS must be positive"))
self.all_cam_params_correct = False
if self.camera_model_label.text() == 'PCO Dimax':
if x < 25:
warning_message(
"{:}".format("Dimax FPS must be greater than 25"))
x = 25
if self.trig_mode == "EXTERNAL" and \
int(x) < int(1000.0 / (self.exp_time + self.dead_time)):
warning_message("{:}".format(
"Dimax FPS must be greater than frequency of external triggers"
))
x = int(1000.0 / self.exp_time)
# if self.camera_model_label.text() == 'PCO Edge' and (x > 100):
# error_message("{:}".format("PCO Edge max FPS is 100"))
# self.all_cam_params_correct = False
# if int(x) < int(1000.0 / (self.exp_time + self.dead_time)): #because of round of errors
# #warning_message("FPS [Hz] cannot exceed 1/exp.time[s]; setting fps=1/exp.time")
# self.relate_fps_to_exptime()
elif self.trig_mode == "EXTERNAL":
x = self.relate_fps_to_exptime()
self.fps_entry.setText("{:.02f}".format(x))
return x
def load_from_yaml(self):
fname, _ = QFileDialog.getOpenFileName(
self, "Select yaml file with BMITgui params",
self.file_writer_group.root_dir, "Python Files (*.yaml)")
if fname == '':
warning_message('Select the file')
return
with open(fname) as f:
p = yaml.load(f, Loader=yaml.FullLoader)
if p['Camera'][
'Model'] != self.camera_controls_group.camera_model_label.text(
):
error_message('Selected params file is for different camera')
return
try: ####### CAMERA #######
self.camera_controls_group.ttl_scan.setChecked(
p['Camera']['External camera'])
self.camera_controls_group.exposure_entry.setText(
str(p['Camera']['Exposure time']))
self.camera_controls_group.fps_entry.setText(
str(p['Camera']['FPS']))
self.camera_controls_group.roi_y0_entry.setText(
str(p['Camera']['ROI first column']))
self.camera_controls_group.roi_width_entry.setText(
str(p['Camera']['ROI width']))
self.camera_controls_group.roi_x0_entry.setText(
str(p['Camera']['ROI first row']))
self.camera_controls_group.roi_height_entry.setText(
str(p['Camera']['ROI height']))
tmp = self.camera_controls_group.buffered_entry.findText(
str(p['Camera']['Buffered']))
self.camera_controls_group.buffered_entry.setCurrentIndex(tmp)
self.camera_controls_group.n_buffers_entry.setText(
str(p['Camera']['Number of buffers']))
tmp = self.camera_controls_group.trigger_entry.findText(
p['Camera']['Trigger'])
self.camera_controls_group.delay_entry.setText(
str(p['Camera']['Dead time']))
self.camera_controls_group.trigger_entry.setCurrentIndex(tmp)
tmp = self.camera_controls_group.sensor_pix_rate_entry.\
findText(p['Camera']['Sensor clocking'])
self.camera_controls_group.sensor_pix_rate_entry.setCurrentIndex(
tmp)
self.camera_controls_group.time_stamp.setChecked(
p['Camera']['Time stamp'])
except:
warning_message('Cannot enter all camera parameters correctly')
try: ####### Scans' settings #######
tmp = self.scan_controls_group.outer_loop_motor.\
findText(p['Outer loop']['Motor'])
self.scan_controls_group.outer_loop_motor.setCurrentIndex(tmp)
self.scan_controls_group.outer_loop_start_entry.setText(
str(p['Outer loop']['Start']))
self.scan_controls_group.outer_loop_steps_entry.setText(
str(p['Outer loop']['Steps']))
self.scan_controls_group.outer_loop_range_entry.setText(
str(p['Outer loop']['Range']))
self.scan_controls_group.outer_loop_flats_0.setChecked(
p['Outer loop']['Flats before'])
self.scan_controls_group.outer_loop_flats_1.setChecked(
p['Outer loop']['Flats after'])
tmp = self.scan_controls_group.inner_loop_motor. \
findText(p['Inner loop']['Motor'])
self.scan_controls_group.inner_loop_motor.setCurrentIndex(tmp)
self.scan_controls_group.inner_loop_start_entry.setText(
str(p['Inner loop']['Start']))
self.scan_controls_group.inner_loop_steps_entry.setText(
str(p['Inner loop']['Steps']))
self.scan_controls_group.inner_loop_range_entry.setText(
str(p['Inner loop']['Range']))
self.scan_controls_group.inner_loop_flats_0.setChecked(
p['Inner loop']['Flats before'])
self.scan_controls_group.inner_loop_flats_1.setChecked(
p['Inner loop']['Flats after'])
self.scan_controls_group.readout_intheend.setChecked(
p['Readout in the end']['Readout in the end'])
except:
warning_message('Cannot enter scan parameters correctly')
try: ####### FFC settings #######
tmp = self.ffc_controls_group.motor_options_entry.findText(
p['FFC']['Motor'])
self.ffc_controls_group.motor_options_entry.setCurrentIndex(tmp)
self.ffc_controls_group.radio_position_entry.setText(
p['FFC']['Radio position'])
self.ffc_controls_group.flat_position_entry.setText(
p['FFC']['Flat position'])
self.ffc_controls_group.numflats_entry.setText(
str(p['FFC']['Num flats']))
self.ffc_controls_group.numdarks_entry.setText(
str(p['FFC']['Num darks']))
except:
warning_message('Cannot enter flat-field parameters correctly')
try: ##### FILE WRITER ########
self.file_writer_group.setChecked(p['Writer']['Enabled'])
self.file_writer_group.root_dir_entry.setText(
p['Writer']['Data dir'])
self.file_writer_group.ctset_fmt_entry.setText(
p['Writer']['CT scan name'])
self.file_writer_group.dsetname_entry.setText(
p['Writer']['Filename'])
self.file_writer_group.bigtiff_checkbox.setChecked(
p['Writer']['Big tiffs'])
self.file_writer_group.separate_scans_checkbox.setChecked(
p['Writer']['Separate scans'])
except:
warning_message('Cannot enter file-writer settings correctly')
def dump2yaml(self):
f, fext = self.QFD.getSaveFileName(self, 'Select file',
self.file_writer_group.root_dir,
"YAML files (*.yaml)")
if f == '':
warning_message('Select file')
return
params = {
"Camera": {
'Model':
self.camera_controls_group.camera_model_label.text(),
'External camera':
self.camera_controls_group.ttl_scan.isChecked(),
'Exposure time':
self.camera_controls_group.exp_time,
'Dead time':
self.camera_controls_group.dead_time,
'FPS':
self.camera_controls_group.fps,
'ROI first row':
self.camera_controls_group.roi_x0,
'ROI width':
self.camera_controls_group.roi_width,
'ROI first column':
self.camera_controls_group.roi_y0,
'ROI height':
self.camera_controls_group.roi_height,
'Buffered':
self.camera_controls_group.buffered_entry.currentText(),
'Number of buffers':
self.camera_controls_group.buffnum,
'Trigger':
self.camera_controls_group.trig_mode,
'Sensor clocking':
self.camera_controls_group.sensor_pix_rate_entry.currentText(),
'Time stamp':
self.camera_controls_group.time_stamp.isChecked()
},
"Positions": {
'CT stage': self.motor_control_group.CT_mot_pos_move.value(),
'Vertical': self.motor_control_group.vert_mot_pos_move.value(),
'Horizontal':
self.motor_control_group.hor_mot_pos_move.value()
},
"Outer loop": {
'Motor':
self.scan_controls_group.outer_loop_motor.currentText(),
'Start':
self.scan_controls_group.outer_loop_start_entry.text(),
'Steps':
self.scan_controls_group.outer_loop_steps_entry.text(),
'Range':
self.scan_controls_group.outer_loop_range_entry.text(),
'Flats before': self.scan_controls_group.ffc_before_outer,
'Flats after': self.scan_controls_group.ffc_after_outer
},
"Inner loop": {
'Motor':
self.scan_controls_group.inner_loop_motor.currentText(),
'Start':
self.scan_controls_group.inner_loop_start_entry.text(),
'Steps':
self.scan_controls_group.inner_loop_steps_entry.text(),
'Range':
self.scan_controls_group.inner_loop_range_entry.text(),
'Flats before': self.scan_controls_group.ffc_before,
'Flats after': self.scan_controls_group.ffc_after
},
"Readout in the end": {
'Readout in the end':
self.scan_controls_group.readout_intheend.isChecked()
},
"FFC": {
'Motor':
self.ffc_controls_group.flat_motor,
'Radio position':
self.ffc_controls_group.radio_position_entry.text(),
'Flat position':
self.ffc_controls_group.flat_position_entry.text(),
'Num flats':
self.ffc_controls_group.num_flats,
'Num darks':
self.ffc_controls_group.num_darks
},
"Writer": {
'Enabled': self.file_writer_group.isChecked(),
'Data dir': self.file_writer_group.root_dir,
'CT scan name': self.file_writer_group.ctsetname,
'Filename': self.file_writer_group.dsetname,
'Big tiffs': self.file_writer_group.bigtiff,
'Separate scans': self.file_writer_group.separate_scans
}
}
def my_unicode_repr(data):
return self.represent_str(data.encode('utf-8'))
yaml.representer.Representer.add_representer(unicode, my_unicode_repr)
with open(f + '.yaml', 'w') as f:
yaml.safe_dump(params,
f,
allow_unicode=True,
default_flow_style=False)
def pix_rate(self):
try:
return int(self.sensor_pix_rate_entry.currentText())
except:
warning_message('Can not get read-out rate')
