def on_new_frame(self, camera):
camera.image_locked = True
self.handler_busy = True
self.signal_new_frame_received.emit(
) # self.liveController.turn_off_illumination()
# measure real fps
timestamp_now = round(time.time())
if timestamp_now == self.timestamp_last:
self.counter = self.counter + 1
else:
self.timestamp_last = timestamp_now
self.fps_real = self.counter
self.counter = 0
print('real camera fps is ' + str(self.fps_real))
# crop image
image_cropped = utils.crop_image(camera.current_frame, self.crop_width,
self.crop_height)
image_cropped = np.squeeze(image_cropped)
# send image to display
time_now = time.time()
if time_now - self.timestamp_last_display >= 1 / self.fps_display:
# self.image_to_display.emit(cv2.resize(image_cropped,(round(self.crop_width*self.display_resolution_scaling), round(self.crop_height*self.display_resolution_scaling)),cv2.INTER_LINEAR))
self.image_to_display.emit(
utils.crop_image(
image_cropped,
round(self.crop_width * self.display_resolution_scaling),
round(self.crop_height * self.display_resolution_scaling)))
self.timestamp_last_display = time_now
# send image to array display
self.packet_image_for_array_display.emit(
image_cropped,
(camera.frame_ID - camera.frame_ID_offset_hardware_trigger - 1) %
VOLUMETRIC_IMAGING.NUM_PLANES_PER_VOLUME)
# send image to write
if self.save_image_flag and time_now - self.timestamp_last_save >= 1 / self.fps_save:
if camera.is_color:
image_cropped = cv2.cvtColor(image_cropped, cv2.COLOR_RGB2BGR)
self.packet_image_to_write.emit(image_cropped, camera.frame_ID,
camera.timestamp)
self.timestamp_last_save = time_now
# send image to track
if self.track_flag and time_now - self.timestamp_last_track >= 1 / self.fps_track:
# track is a blocking operation - it needs to be
# @@@ will cropping before emitting the signal lead to speedup?
self.packet_image_for_tracking.emit(image_cropped, camera.frame_ID,
camera.timestamp)
self.timestamp_last_track = time_now
self.handler_busy = False
camera.image_locked = False
def save_gallery(formset, place):
formset.save()
for inst, form in zip(formset.get_queryset(), formset):
if TempGallery.objects.filter(gallery=inst).exists():
temp = TempGallery.objects.get(gallery=inst)
inst.image = temp.image
inst.title = form.instance.title
inst.save()
if form.instance.id:
crop = [form.cleaned_data.pop(key)
for key in\
('crop_x', 'crop_y', 'crop_x2', 'crop_y2')]
if all(crop):
crop_image(inst.image, *crop)
def _run_single_acquisition(self):
self.single_acquisition_in_progress = True
self.FOV_counter = 0
print('multipoint acquisition - time point ' + str(self.time_point))
# stop live
if self.liveController.is_live:
self.liveController.was_live_before_multipoint = True
self.liveController.stop_live(
) # @@@ to do: also uncheck the live button
# disable callback
if self.camera.callback_is_enabled:
self.camera.callback_was_enabled_before_multipoint = True
self.camera.stop_streaming()
self.camera.disable_callback()
self.camera.start_streaming(
) # @@@ to do: absorb stop/start streaming into enable/disable callback - add a flag is_streaming to the camera class
# do the multipoint acquisition
# for each time point, create a new folder
current_path = os.path.join(self.base_path, self.experiment_ID,
str(self.time_point))
os.mkdir(current_path)
# along y
for i in range(self.NY):
# along x
for j in range(self.NX):
# z-stack
for k in range(self.NZ):
# perform AF only if when not taking z stack
if (self.NZ == 1) and (self.do_autofocus) and (
self.FOV_counter %
Acquisition.NUMBER_OF_FOVS_PER_AF == 0):
self.autofocusController.autofocus()
file_ID = str(i) + '_' + str(j) + '_' + str(k)
# take bf
if self.do_bfdf:
self.liveController.set_microscope_mode(
MicroscopeMode.BFDF)
self.liveController.turn_on_illumination()
print('take bf image')
self.camera.send_trigger()
image = self.camera.read_frame()
self.liveController.turn_off_illumination()
image = utils.crop_image(image, self.crop_width,
self.crop_height)
saving_path = os.path.join(
current_path,
file_ID + '_bf' + '.' + Acquisition.IMAGE_FORMAT)
# self.image_to_display.emit(cv2.resize(image,(round(self.crop_width*self.display_resolution_scaling), round(self.crop_height*self.display_resolution_scaling)),cv2.INTER_LINEAR))
self.image_to_display.emit(
utils.crop_image(
image,
round(self.crop_width *
self.display_resolution_scaling),
round(self.crop_height *
self.display_resolution_scaling)))
if self.camera.is_color:
image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
cv2.imwrite(saving_path, image)
QApplication.processEvents()
# take fluorescence
if self.do_fluorescence:
self.liveController.set_microscope_mode(
MicroscopeMode.FLUORESCENCE)
self.liveController.turn_on_illumination()
self.camera.send_trigger()
image = self.camera.read_frame()
print('take fluorescence image')
self.liveController.turn_off_illumination()
image = utils.crop_image(image, self.crop_width,
self.crop_height)
saving_path = os.path.join(
current_path, file_ID + '_fluorescence' + '.' +
Acquisition.IMAGE_FORMAT)
self.image_to_display.emit(
utils.crop_image(
image,
round(self.crop_width *
self.display_resolution_scaling),
round(self.crop_height *
self.display_resolution_scaling)))
# self.image_to_display.emit(cv2.resize(image,(round(self.crop_width*self.display_resolution_scaling), round(self.crop_height*self.display_resolution_scaling)),cv2.INTER_LINEAR))
if self.camera.is_color:
image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
cv2.imwrite(saving_path, image)
QApplication.processEvents()
if self.do_bfdf is not True and self.do_fluorescence is not True:
QApplication.processEvents()
# move z
if k < self.NZ - 1:
self.navigationController.move_z(self.deltaZ)
# move z back
self.navigationController.move_z(-self.deltaZ * (self.NZ - 1))
# update FOV counter
self.FOV_counter = self.FOV_counter + 1
# move x
if j < self.NX - 1:
self.navigationController.move_x(self.deltaX)
# move x back
self.navigationController.move_x(-self.deltaX * (self.NX - 1))
# move y
if i < self.NY - 1:
self.navigationController.move_y(self.deltaY)
# move y back
self.navigationController.move_y(-self.deltaY * (self.NY - 1))
# re-enable callback
if self.camera.callback_was_enabled_before_multipoint:
self.camera.stop_streaming()
self.camera.enable_callback()
self.camera.start_streaming()
self.camera.callback_was_enabled_before_multipoint = False
if self.liveController.was_live_before_multipoint:
self.liveController.start_live()
# emit acquisitionFinished signal
self.acquisitionFinished.emit()
# update time_point for the next scheduled single acquisition (if any)
self.time_point = self.time_point + 1
if self.time_point >= self.Nt:
print('Multipoint acquisition finished')
if self.acquisitionTimer.isActive():
self.acquisitionTimer.stop()
self.acquisitionFinished.emit()
self.single_acquisition_in_progress = False
def autofocus(self):
# stop live
if self.liveController.is_live:
self.liveController.was_live_before_autofocus = True
self.liveController.stop_live()
# temporarily disable call back -> image does not go through streamHandler
if self.camera.callback_is_enabled:
self.camera.callback_was_enabled_before_autofocus = True
self.camera.stop_streaming()
self.camera.disable_callback()
self.camera.start_streaming(
) # @@@ to do: absorb stop/start streaming into enable/disable callback - add a flag is_streaming to the camera class
# @@@ to add: increase gain, decrease exposure time
# @@@ can move the execution into a thread
focus_measure_vs_z = [0] * self.N
focus_measure_max = 0
z_af_offset = self.deltaZ * round(self.N / 2)
self.navigationController.move_z(-z_af_offset)
steps_moved = 0
for i in range(self.N):
self.navigationController.move_z(self.deltaZ)
steps_moved = steps_moved + 1
self.liveController.turn_on_illumination()
self.camera.send_trigger()
image = self.camera.read_frame()
self.liveController.turn_off_illumination()
image = utils.crop_image(image, self.crop_width, self.crop_height)
self.image_to_display.emit(image)
QApplication.processEvents()
timestamp_0 = time.time() # @@@ to remove
focus_measure = utils.calculate_focus_measure(image)
timestamp_1 = time.time() # @@@ to remove
print(' calculating focus measure took ' +
str(timestamp_1 - timestamp_0) + ' second')
focus_measure_vs_z[i] = focus_measure
print(i, focus_measure)
focus_measure_max = max(focus_measure, focus_measure_max)
if focus_measure < focus_measure_max * AF.STOP_THRESHOLD:
break
idx_in_focus = focus_measure_vs_z.index(max(focus_measure_vs_z))
self.navigationController.move_z(
(idx_in_focus - steps_moved) * self.deltaZ)
if idx_in_focus == 0:
print('moved to the bottom end of the AF range')
if idx_in_focus == self.N - 1:
print('moved to the top end of the AF range')
if self.camera.callback_was_enabled_before_autofocus:
self.camera.stop_streaming()
self.camera.enable_callback()
self.camera.start_streaming()
self.camera.callback_was_enabled_before_autofocus = False
if self.liveController.was_live_before_autofocus:
self.liveController.start_live()
self.liveController.was_live = False
print('autofocus finished')
self.autofocusFinished.emit()
def _run_multipoint_single(self):
self.FOV_counter = 0
print('multipoint acquisition - time point ' + str(self.time_point))
# do the multipoint acquisition
# for each time point, create a new folder
current_path = os.path.join(self.base_path, self.experiment_ID,
str(self.time_point))
os.mkdir(current_path)
# z-stack
for k in range(self.NZ):
file_ID = str(k)
# iterate through selected modes
for config in self.selected_configurations:
self.signal_current_configuration.emit(config)
self.camera1.send_trigger()
image = self.camera1.read_frame()
image = utils.crop_image(image, self.crop_width,
self.crop_height)
saving_path = os.path.join(
current_path, 'camera1_' + file_ID + str(config.name) +
'.' + Acquisition.IMAGE_FORMAT)
image_to_display = utils.crop_image(
image,
round(self.crop_width *
self.liveController1.display_resolution_scaling),
round(self.crop_height *
self.liveController1.display_resolution_scaling))
self.image_to_display_camera1.emit(image_to_display)
if self.camera1.is_color:
image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
cv2.imwrite(saving_path, image)
self.camera2.send_trigger()
image = self.camera2.read_frame()
image = utils.crop_image(image, self.crop_width,
self.crop_height)
saving_path = os.path.join(
current_path, 'camera2_' + file_ID + str(config.name) +
'.' + Acquisition.IMAGE_FORMAT)
image_to_display = utils.crop_image(
image,
round(self.crop_width *
self.liveController2.display_resolution_scaling),
round(self.crop_height *
self.liveController2.display_resolution_scaling))
self.image_to_display_camera2.emit(image_to_display)
if self.camera2.is_color:
image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
cv2.imwrite(saving_path, image)
QApplication.processEvents()
# QApplication.processEvents()
# move z
if k < self.NZ - 1:
self.navigationController.move_z_usteps(self.deltaZ_usteps)
# move z back
self.navigationController.move_z_usteps(-self.deltaZ_usteps *
(self.NZ - 1))
# update FOV counter
self.FOV_counter = self.FOV_counter + 1
def _run_multipoint_single(self):
self.FOV_counter = 0
print('multipoint acquisition - time point ' + str(self.time_point))
# do the multipoint acquisition
# for each time point, create a new folder
current_path = os.path.join(self.base_path, self.experiment_ID,
str(self.time_point))
os.mkdir(current_path)
# along y
for i in range(self.NY):
# along x
for j in range(self.NX):
# z-stack
for k in range(self.NZ):
# perform AF only if when not taking z stack
# if (self.NZ == 1) and (self.do_autofocus) and (self.FOV_counter%Acquisition.NUMBER_OF_FOVS_PER_AF==0):
# temporary: replace the above line with the line below to AF every FOV
if (self.NZ == 1) and (self.do_autofocus):
# temporary (next 3 lines, to be modified) - use 405 nm for autofocus
configuration_name_AF = 'Fluorescence 405 nm Ex'
config_AF = next(
(config for config in
self.configurationManager.configurations
if config.name == configuration_name_AF))
self.signal_current_configuration.emit(config_AF)
self.autofocusController.autofocus()
if (self.NZ > 1):
# maneuver for achiving uniform step size and repeatability when using open-loop control
self.navigationController.move_z_usteps(80)
time.sleep(0.1)
self.navigationController.move_z_usteps(-80)
time.sleep(0.1)
file_ID = str(i) + '_' + str(j) + '_' + str(k)
# iterate through selected modes
for config in self.selected_configurations:
# self.liveController.set_microscope_mode(config)
self.signal_current_configuration.emit(config)
self.liveController.turn_on_illumination()
self.camera.send_trigger()
image = self.camera.read_frame()
self.liveController.turn_off_illumination()
image = utils.crop_image(image, self.crop_width,
self.crop_height)
saving_path = os.path.join(
current_path, file_ID + str(config.name) + '.' +
Acquisition.IMAGE_FORMAT)
# self.image_to_display.emit(cv2.resize(image,(round(self.crop_width*self.display_resolution_scaling), round(self.crop_height*self.display_resolution_scaling)),cv2.INTER_LINEAR))
image_to_display = utils.crop_image(
image,
round(
self.crop_width *
self.liveController.display_resolution_scaling
),
round(
self.crop_height *
self.liveController.display_resolution_scaling)
)
self.image_to_display.emit(image_to_display)
self.image_to_display_multi.emit(
image_to_display, config.illumination_source)
if self.camera.is_color:
image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
cv2.imwrite(saving_path, image)
QApplication.processEvents()
# QApplication.processEvents()
# move z
if k < self.NZ - 1:
self.navigationController.move_z_usteps(
self.deltaZ_usteps)
# move z back
self.navigationController.move_z_usteps(-self.deltaZ_usteps *
(self.NZ - 1))
# update FOV counter
self.FOV_counter = self.FOV_counter + 1
# move x
if j < self.NX - 1:
self.navigationController.move_x_usteps(self.deltaX_usteps)
# move x back
self.navigationController.move_x_usteps(-self.deltaX_usteps *
(self.NX - 1))
# move y
if i < self.NY - 1:
self.navigationController.move_y_usteps(self.deltaY_usteps)
# move y back
self.navigationController.move_y_usteps(-self.deltaY_usteps *
(self.NY - 1))
def run_single_time_point(self):
self.FOV_counter = 0
column_counter = 0
print('multipoint acquisition - time point ' +
str(self.time_point + 1))
# for each time point, create a new folder
current_path = os.path.join(self.base_path, self.experiment_ID,
str(self.time_point))
os.mkdir(current_path)
# run homing
self.plateReaderNavigationController.home()
self.wait_till_operation_is_completed()
# row scan direction
row_scan_direction = 1 # 1: A -> H, 0: H -> A
# go through columns
for column in self.selected_columns:
# increament counter
column_counter = column_counter + 1
# move to the current column
self.plateReaderNavigationController.moveto_column(column - 1)
self.wait_till_operation_is_completed()
'''
# row homing
if column_counter > 1:
self.plateReaderNavigationController.home_y()
self.wait_till_operation_is_completed()
'''
# go through rows
for row in range(PLATE_READER.NUMBER_OF_ROWS):
if row_scan_direction == 0: # reverse scan:
row = PLATE_READER.NUMBER_OF_ROWS - 1 - row
row_str = chr(ord('A') + row)
file_ID = row_str + str(column)
# move to the selected row
self.plateReaderNavigationController.moveto_row(row)
self.wait_till_operation_is_completed()
time.sleep(SCAN_STABILIZATION_TIME_MS_Y / 1000)
# AF
if (self.NZ == 1) and (self.do_autofocus) and (
self.FOV_counter % Acquisition.NUMBER_OF_FOVS_PER_AF
== 0):
configuration_name_AF = 'BF LED matrix full'
config_AF = next(
(config
for config in self.configurationManager.configurations
if config.name == configuration_name_AF))
self.signal_current_configuration.emit(config_AF)
self.autofocusController.autofocus()
self.autofocusController.wait_till_autofocus_has_completed(
)
# z stack
for k in range(self.NZ):
if (self.NZ > 1):
# update file ID
file_ID = file_ID + '_' + str(k)
# maneuver for achiving uniform step size and repeatability when using open-loop control
self.plateReaderNavigationController.move_z_usteps(80)
self.wait_till_operation_is_completed()
self.plateReaderNavigationController.move_z_usteps(-80)
self.wait_till_operation_is_completed()
time.sleep(SCAN_STABILIZATION_TIME_MS_Z / 1000)
# iterate through selected modes
for config in self.selected_configurations:
self.signal_current_configuration.emit(config)
self.wait_till_operation_is_completed()
self.liveController.turn_on_illumination()
self.wait_till_operation_is_completed()
self.camera.send_trigger()
image = self.camera.read_frame()
self.liveController.turn_off_illumination()
image = utils.crop_image(image, self.crop_width,
self.crop_height)
saving_path = os.path.join(
current_path, file_ID + '_' + str(config.name) +
'.' + Acquisition.IMAGE_FORMAT)
# self.image_to_display.emit(cv2.resize(image,(round(self.crop_width*self.display_resolution_scaling), round(self.crop_height*self.display_resolution_scaling)),cv2.INTER_LINEAR))
# image_to_display = utils.crop_image(image,round(self.crop_width*self.liveController.display_resolution_scaling), round(self.crop_height*self.liveController.display_resolution_scaling))
image_to_display = utils.crop_image(
image, round(self.crop_width),
round(self.crop_height))
self.image_to_display.emit(image_to_display)
self.image_to_display_multi.emit(
image_to_display, config.illumination_source)
if self.camera.is_color:
image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
cv2.imwrite(saving_path, image)
QApplication.processEvents()
if (self.NZ > 1):
# move z
if k < self.NZ - 1:
self.plateReaderNavigationController.move_z_usteps(
self.deltaZ_usteps)
self.wait_till_operation_is_completed()
time.sleep(SCAN_STABILIZATION_TIME_MS_Z / 1000)
if self.NZ > 1:
# move z back
self.plateReaderNavigationController.move_z_usteps(
-self.deltaZ_usteps * (self.NZ - 1))
self.wait_till_operation_is_completed()
if self.abort_acquisition_requested:
return
# update row scan direction
row_scan_direction = 1 - row_scan_direction