def tiff_video(self):
title = self.askdir_file()
if self.filename:
if title == "TIF":
tif_video = reading_videos.read_tif_iterate(self.filename)
self.info_image = video_cropping.Cropping(self)
while self.info_image.raw_data_update_flag:
QtWidgets.QApplication.processEvents()
if self.info_image.flag_RGB2GRAY:
if tif_video.shape[2] == 4:
tif_video = cv2.cvtColor(tif_video, cv2.COLOR_BGR2GRAY)
tif_video = np.expand_dims(tif_video, axis=0)
if self.info_image.frame_e is not None:
if self.info_image.frame_e != -1:
self.original_video = tif_video[
self.info_image.frame_s:self.info_image.frame_e:self.info_image.frame_jump,
self.info_image.width_size_s:self.info_image.width_size_e,
self.info_image.height_size_s:self.info_image.height_size_e]
elif self.info_image.frame_e == -1:
self.original_video = tif_video[self.info_image.frame_s::self.info_image.frame_jump,
self.info_image.width_size_s:self.info_image.width_size_e,
self.info_image.height_size_s:self.info_image.height_size_e]
else:
self.original_video = tif_video
self.original_video = self.original_video.copy(order='C')
if self.info_image.flag_display is True:
self.visualization_ = Visulization_localization()
self.visualization_.new_display(self.original_video, self.original_video, object=None, title='TIF')
self.update_output.emit([self.original_video, title, self.filename, None])
else:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("Type of image is not defined!")
self.msg_box.exec_()
def Update_tab_bgCorrection(self, data):
if data[0] is not None:
if len(data[0]) == 2:
self.bgCorrectedVideo = data[0][0]
else:
self.bgCorrectedVideo = data[0]
self.type_bgCorrection = data[1]
self.history['Type_bg_correction'] = data[1]
self.new_update_bg_video.emit(self.bgCorrectedVideo)
if data[1] == 'DRA':
self.new_update_DRA_video.emit([self.bgCorrectedVideo, 'DRA', None, self.batch_size])
self.visualization_ = Visulization_localization()
self.visualization_.bg_correction_update(in_video=self.bgCorrectedVideo, label=self.type_bgCorrection, object=self.all_tabs["PSFs_Localization"])
else:
self.msg_box2 = QtWidgets.QMessageBox()
self.msg_box2.setWindowTitle("Warning!")
self.msg_box2.setText("Input video does not find!")
self.msg_box2.exec_()
def spectrum(self):
if self.original_video is not None:
self.flag_update_FFT_video = True
worker = FFT2D(video=self.original_video)
worker.signals.result.connect(self.update_FFT_video)
self.threadpool.start(worker)
while self.flag_update_FFT_video:
QtCore.QCoreApplication.processEvents()
self.flag_update_FFT_video = True
visualization_ = Visulization_localization()
visualization_.new_display(self.fft_v,
self.fft_v,
object=None,
title='Spectrum')
else:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("Please load one video!")
self.msg_box.exec_()
def im2video(self):
title = 'image2video'
folder = self.askdir()
self.info_image = import_im2vid.Image2Video(self)
while self.info_image.raw_data_update_flag:
QtWidgets.QApplication.processEvents()
try:
if self.info_image.im_type is not None:
im2vid = image_to_video.Image2Video(path=folder, file_format=self.info_image.im_type,
width_size=self.info_image.width_size,
height_size=self.info_image.height_size,
image_type=np.dtype(self.info_image.set_bit_order + self.info_image.type),
reader_type=self.info_image.video_reader_type)
video = im2vid()
video, status_line_info = self.status_line_remove(video)
self.original_video = video
if self.info_image.flag_display is True:
self.visualization_ = Visulization_localization()
self.visualization_.new_display(self.original_video, self.original_video, object=None, title='im2video')
self.update_output.emit([self.original_video, title, self.folder, status_line_info])
else:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("Type of image is not defined!")
self.msg_box.exec_()
except:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("Selected parameters are not correct!")
self.msg_box.exec_()
def read_video(self):
title = self.askdir_file()
if self.filename:
if title == "Raw":
self.info_image = import_RAW.RawImage(self.filename)
while self.info_image.raw_data_update_flag:
QtWidgets.QApplication.processEvents()
try:
video = reading_videos.read_binary(self.filename, img_width=self.info_image.width_size,
img_height=self.info_image.height_size,
image_type=self.info_image.set_bit_order + self.info_image.type)
if self.info_image.groupBox_cropping.isChecked():
self.original_video = video[
self.info_image.frame_s:self.info_image.frame_e:self.info_image.frame_jump,
self.info_image.width_size_s:self.info_image.width_size_e,
self.info_image.height_size_s:self.info_image.height_size_e]
else:
self.original_video = video
self.original_video, status_line_info = self.status_line_remove(self.original_video)
if self.info_image.flag_display is True:
self.visualization_ = Visulization_localization()
self.visualization_.new_display(self.original_video, self.original_video, object=None, title='Raw video')
self.update_output.emit([self.original_video, title, self.filename, status_line_info])
except:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("Selected parameters are not correct!")
self.msg_box.exec_()
elif title == "PNG":
png_img = reading_videos.read_png(self.filename)
self.original_video = png_img
self.visualization_ = Visulization_localization(self.filename)
self.visualization_.new_display(self.original_video, self.original_video, object=None, title='PNG')
self.update_output.emit([self.original_video, title, self.filename, None])
elif title == "AVI":
avi_video = reading_videos.read_avi(self.filename)
self.info_image = video_cropping.Cropping(self)
while self.info_image.raw_data_update_flag:
QtWidgets.QApplication.processEvents()
if self.info_image.frame_e is not None:
if self.info_image.frame_e != -1:
self.original_video = avi_video[
self.info_image.frame_s:self.info_image.frame_e:self.info_image.frame_jump,
self.info_image.width_size_s:self.info_image.width_size_e,
self.info_image.height_size_s:self.info_image.height_size_e]
elif self.info_image.frame_e == -1:
self.original_video = avi_video[self.info_image.frame_s:-1:self.info_image.frame_jump,
self.info_image.width_size_s:self.info_image.width_size_e,
self.info_image.height_size_s:self.info_image.height_size_e]
else:
self.original_video = avi_video
self.original_video = self.original_video.copy(order='C')
if self.info_image.flag_display is True:
self.visualization_ = Visulization_localization()
self.visualization_.new_display(self.original_video, self.original_video, object=None, title='AVI')
self.update_output.emit([self.original_video, title, self.filename, None])
elif title == "TIF":
tif_video = reading_videos.read_tif(self.filename)
self.info_image = video_cropping.Cropping(self)
while self.info_image.raw_data_update_flag:
QtWidgets.QApplication.processEvents()
if self.info_image.flag_RGB2GRAY:
if tif_video.shape[2] == 4:
tif_video = cv2.cvtColor(tif_video, cv2.COLOR_BGR2GRAY)
tif_video = np.expand_dims(tif_video, axis=0)
if self.info_image.frame_e is not None:
if self.info_image.frame_e != -1:
self.original_video = tif_video[
self.info_image.frame_s:self.info_image.frame_e:self.info_image.frame_jump,
self.info_image.width_size_s:self.info_image.width_size_e,
self.info_image.height_size_s:self.info_image.height_size_e]
elif self.info_image.frame_e == -1:
self.original_video = tif_video[self.info_image.frame_s::self.info_image.frame_jump,
self.info_image.width_size_s:self.info_image.width_size_e,
self.info_image.height_size_s:self.info_image.height_size_e]
else:
self.original_video = tif_video
self.original_video = self.original_video.copy(order='C')
if self.info_image.flag_display is True:
self.visualization_ = Visulization_localization()
self.visualization_.new_display(self.original_video, self.original_video, object=None, title='TIF')
self.update_output.emit([self.original_video, title, self.filename, None])
elif title == "Fits":
fits_video = reading_videos.read_fits(self.filename)
self.info_image = video_cropping.Cropping(self)
while self.info_image.raw_data_update_flag:
QtWidgets.QApplication.processEvents()
if self.info_image.frame_e is not None:
if self.info_image.frame_e != -1:
self.original_video = fits_video[
self.info_image.frame_s:self.info_image.frame_e:self.info_image.frame_jump,
self.info_image.width_size_s:self.info_image.width_size_e,
self.info_image.height_size_s:self.info_image.height_size_e]
elif self.info_image.frame_e == -1:
self.original_video = fits_video[self.info_image.frame_s::self.info_image.frame_jump,
self.info_image.width_size_s:self.info_image.width_size_e,
self.info_image.height_size_s:self.info_image.height_size_e]
else:
self.original_video = fits_video
self.original_video = self.original_video.copy(order='C')
if self.info_image.flag_display is True:
self.visualization_ = Visulization_localization()
self.visualization_.new_display(self.original_video, self.original_video, object=None, title='TIF')
self.update_output.emit([self.original_video, title, self.filename])
else:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("The video type is not defined!")
self.msg_box.exec_()
elif self.filename is False:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("Filename is not valid.!")
self.msg_box.exec_()
class Reading(QtWidgets.QMainWindow):
update_output = QtCore.Signal(object)
def __init__(self):
super(Reading, self).__init__()
self.original_video = None
self.filename = None
self.folder = None
def askdir_file(self):
self.filename = False
dialog = QtWidgets.QFileDialog(self)
dialog.setWindowTitle('Open File')
dialog.setFileMode(QtWidgets.QFileDialog.ExistingFile)
if dialog.exec_() == QtWidgets.QDialog.Accepted:
self.filename = dialog.selectedFiles()[0]
if type(self.filename) is str:
file_extention = os.path.splitext(self.filename)[1]
if file_extention == ".pf" or file_extention == ".raw" or file_extention == ".bin" or file_extention == ".PF" or file_extention == ".RAW" or file_extention == ".BIN":
return "Raw"
elif file_extention == ".jpg" or file_extention == ".JPG" or file_extention == ".png" or file_extention == ".PNG":
return "PNG"
elif file_extention == ".tiff" or file_extention == ".TIFF":
return "TIF"
elif file_extention == ".avi" or file_extention == ".AVI":
return "AVI"
elif file_extention == ".TIF" or file_extention == ".tif":
return "TIF"
elif file_extention == ".fits" or file_extention == ".fits":
return "Fits"
elif file_extention == ".py" or file_extention == ".PY":
return "Python"
def askdir(self):
folder = QtWidgets.QFileDialog.getExistingDirectory(None, 'Select a folder:', '',
QtWidgets.QFileDialog.ShowDirsOnly)
return folder
def read_video(self):
title = self.askdir_file()
if self.filename:
if title == "Raw":
self.info_image = import_RAW.RawImage(self.filename)
while self.info_image.raw_data_update_flag:
QtWidgets.QApplication.processEvents()
try:
video = reading_videos.read_binary(self.filename, img_width=self.info_image.width_size,
img_height=self.info_image.height_size,
image_type=self.info_image.set_bit_order + self.info_image.type)
if self.info_image.groupBox_cropping.isChecked():
self.original_video = video[
self.info_image.frame_s:self.info_image.frame_e:self.info_image.frame_jump,
self.info_image.width_size_s:self.info_image.width_size_e,
self.info_image.height_size_s:self.info_image.height_size_e]
else:
self.original_video = video
self.original_video, status_line_info = self.status_line_remove(self.original_video)
if self.info_image.flag_display is True:
self.visualization_ = Visulization_localization()
self.visualization_.new_display(self.original_video, self.original_video, object=None, title='Raw video')
self.update_output.emit([self.original_video, title, self.filename, status_line_info])
except:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("Selected parameters are not correct!")
self.msg_box.exec_()
elif title == "PNG":
png_img = reading_videos.read_png(self.filename)
self.original_video = png_img
self.visualization_ = Visulization_localization(self.filename)
self.visualization_.new_display(self.original_video, self.original_video, object=None, title='PNG')
self.update_output.emit([self.original_video, title, self.filename, None])
elif title == "AVI":
avi_video = reading_videos.read_avi(self.filename)
self.info_image = video_cropping.Cropping(self)
while self.info_image.raw_data_update_flag:
QtWidgets.QApplication.processEvents()
if self.info_image.frame_e is not None:
if self.info_image.frame_e != -1:
self.original_video = avi_video[
self.info_image.frame_s:self.info_image.frame_e:self.info_image.frame_jump,
self.info_image.width_size_s:self.info_image.width_size_e,
self.info_image.height_size_s:self.info_image.height_size_e]
elif self.info_image.frame_e == -1:
self.original_video = avi_video[self.info_image.frame_s:-1:self.info_image.frame_jump,
self.info_image.width_size_s:self.info_image.width_size_e,
self.info_image.height_size_s:self.info_image.height_size_e]
else:
self.original_video = avi_video
self.original_video = self.original_video.copy(order='C')
if self.info_image.flag_display is True:
self.visualization_ = Visulization_localization()
self.visualization_.new_display(self.original_video, self.original_video, object=None, title='AVI')
self.update_output.emit([self.original_video, title, self.filename, None])
elif title == "TIF":
tif_video = reading_videos.read_tif(self.filename)
self.info_image = video_cropping.Cropping(self)
while self.info_image.raw_data_update_flag:
QtWidgets.QApplication.processEvents()
if self.info_image.flag_RGB2GRAY:
if tif_video.shape[2] == 4:
tif_video = cv2.cvtColor(tif_video, cv2.COLOR_BGR2GRAY)
tif_video = np.expand_dims(tif_video, axis=0)
if self.info_image.frame_e is not None:
if self.info_image.frame_e != -1:
self.original_video = tif_video[
self.info_image.frame_s:self.info_image.frame_e:self.info_image.frame_jump,
self.info_image.width_size_s:self.info_image.width_size_e,
self.info_image.height_size_s:self.info_image.height_size_e]
elif self.info_image.frame_e == -1:
self.original_video = tif_video[self.info_image.frame_s::self.info_image.frame_jump,
self.info_image.width_size_s:self.info_image.width_size_e,
self.info_image.height_size_s:self.info_image.height_size_e]
else:
self.original_video = tif_video
self.original_video = self.original_video.copy(order='C')
if self.info_image.flag_display is True:
self.visualization_ = Visulization_localization()
self.visualization_.new_display(self.original_video, self.original_video, object=None, title='TIF')
self.update_output.emit([self.original_video, title, self.filename, None])
elif title == "Fits":
fits_video = reading_videos.read_fits(self.filename)
self.info_image = video_cropping.Cropping(self)
while self.info_image.raw_data_update_flag:
QtWidgets.QApplication.processEvents()
if self.info_image.frame_e is not None:
if self.info_image.frame_e != -1:
self.original_video = fits_video[
self.info_image.frame_s:self.info_image.frame_e:self.info_image.frame_jump,
self.info_image.width_size_s:self.info_image.width_size_e,
self.info_image.height_size_s:self.info_image.height_size_e]
elif self.info_image.frame_e == -1:
self.original_video = fits_video[self.info_image.frame_s::self.info_image.frame_jump,
self.info_image.width_size_s:self.info_image.width_size_e,
self.info_image.height_size_s:self.info_image.height_size_e]
else:
self.original_video = fits_video
self.original_video = self.original_video.copy(order='C')
if self.info_image.flag_display is True:
self.visualization_ = Visulization_localization()
self.visualization_.new_display(self.original_video, self.original_video, object=None, title='TIF')
self.update_output.emit([self.original_video, title, self.filename])
else:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("The video type is not defined!")
self.msg_box.exec_()
elif self.filename is False:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("Filename is not valid.!")
self.msg_box.exec_()
def load_batch_data(self):
data_setting = {}
self.filename = self.askdir()
self.info_image = import_RAW.RawImage(self.filename)
while self.info_image.raw_data_update_flag:
QtWidgets.QApplication.processEvents()
try:
data_setting['path'] = self.filename
data_setting['title'] = "Raw"
data_setting['img_width'] = self.info_image.width_size
data_setting['img_height'] = self.info_image.height_size
data_setting['image_type'] = self.info_image.set_bit_order + self.info_image.type
data_setting['s_frame'] = self.info_image.frame_s
data_setting['e_frame'] = self.info_image.frame_e
if self.info_image.groupBox_cropping.isChecked():
data_setting['frame_stride'] = self.info_image.frame_jump
data_setting['width_size_s'] = self.info_image.width_size_s
data_setting['width_size_e'] = self.info_image.width_size_e
data_setting['height_size_s'] = self.info_image.height_size_s
data_setting['height_size_e'] = self.info_image.height_size_e
else:
data_setting['frame_stride'] = 1
data_setting['width_size_s'] = 0
data_setting['width_size_e'] = -1
data_setting['height_size_s'] = 0
data_setting['height_size_e'] = -1
self.update_output.emit([data_setting])
except:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("Selected parameters are not correct!")
self.msg_box.exec_()
def im2video(self):
title = 'image2video'
folder = self.askdir()
self.info_image = import_im2vid.Image2Video(self)
while self.info_image.raw_data_update_flag:
QtWidgets.QApplication.processEvents()
try:
if self.info_image.im_type is not None:
im2vid = image_to_video.Image2Video(path=folder, file_format=self.info_image.im_type,
width_size=self.info_image.width_size,
height_size=self.info_image.height_size,
image_type=np.dtype(self.info_image.set_bit_order + self.info_image.type),
reader_type=self.info_image.video_reader_type)
video = im2vid()
video, status_line_info = self.status_line_remove(video)
self.original_video = video
if self.info_image.flag_display is True:
self.visualization_ = Visulization_localization()
self.visualization_.new_display(self.original_video, self.original_video, object=None, title='im2video')
self.update_output.emit([self.original_video, title, self.folder, status_line_info])
else:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("Type of image is not defined!")
self.msg_box.exec_()
except:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("Selected parameters are not correct!")
self.msg_box.exec_()
def tiff_video(self):
title = self.askdir_file()
if self.filename:
if title == "TIF":
tif_video = reading_videos.read_tif_iterate(self.filename)
self.info_image = video_cropping.Cropping(self)
while self.info_image.raw_data_update_flag:
QtWidgets.QApplication.processEvents()
if self.info_image.flag_RGB2GRAY:
if tif_video.shape[2] == 4:
tif_video = cv2.cvtColor(tif_video, cv2.COLOR_BGR2GRAY)
tif_video = np.expand_dims(tif_video, axis=0)
if self.info_image.frame_e is not None:
if self.info_image.frame_e != -1:
self.original_video = tif_video[
self.info_image.frame_s:self.info_image.frame_e:self.info_image.frame_jump,
self.info_image.width_size_s:self.info_image.width_size_e,
self.info_image.height_size_s:self.info_image.height_size_e]
elif self.info_image.frame_e == -1:
self.original_video = tif_video[self.info_image.frame_s::self.info_image.frame_jump,
self.info_image.width_size_s:self.info_image.width_size_e,
self.info_image.height_size_s:self.info_image.height_size_e]
else:
self.original_video = tif_video
self.original_video = self.original_video.copy(order='C')
if self.info_image.flag_display is True:
self.visualization_ = Visulization_localization()
self.visualization_.new_display(self.original_video, self.original_video, object=None, title='TIF')
self.update_output.emit([self.original_video, title, self.filename, None])
else:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("Type of image is not defined!")
self.msg_box.exec_()
def run_py_script(self):
title = self.askdir_file()
if title == "Python":
self.threadpool.start(self.run_py_script_thread(self.filename))
self.set_plain_text(" Done")
else:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("File bin_type is not valid.!")
self.msg_box.exec_()
def status_line_remove(self, video):
statusLine = read_status_line.StatusLine(video)
cut_frames, axis_status_line = statusLine.find_status_line()
if axis_status_line == 'row' or axis_status_line == 'column':
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("status line remove" + "\nold shape:" + str(video.shape) + "\nnew shape:" + str(cut_frames.shape))
self.msg_box.exec_()
return cut_frames, axis_status_line
def closeEvent(self, event):
QtCore.QCoreApplication.instance().quit()
print("closing PlaySetting")
def dra_wrapper(self):
title = ''
if self.original_video is not None and self.original_video.shape[0] - (
2 * self.info_DRA.batch_size) <= 0:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText(
"The batch size bigger than the video length (#frame" +
str(self.original_video.shape[0]) + ")!")
self.msg_box.exec_()
if self.original_video is not None and self.original_video.shape[0] - (
2 * self.info_DRA.batch_size) > 0:
if self.info_DRA.flag_power_normalization:
self.set_new_text.emit("Start PN -->")
self.flag_update_original_video = True
worker = Normalization(self.original_video, flag_pn=True)
worker.signals.result.connect(self.update_original_video)
self.threadpool.start(worker)
while self.flag_update_original_video:
QtCore.QCoreApplication.processEvents()
self.flag_update_original_video = True
title = title + 'PN_'
self.set_plain_text.emit(" Done")
self.p_max = self.original_video.shape[0] - (
2 * self.info_DRA.batch_size) - 1
self.object_update_progressBar.setProgress(0)
self.object_update_progressBar.setRange(self.p_max)
if self.info_DRA.flag_FPN:
self.set_new_text.emit("Start DRA + " +
self.info_DRA.mode_FPN + '-->')
d_arg = {
'video': self.original_video,
'batchSize': self.info_DRA.batch_size,
'flag_GUI': True,
'instance': DifferentialRollingAverage,
'FPN_flag': True,
'select_correction_axis': self.info_DRA.axis,
'object_update_progressBar':
self.object_update_progressBar,
'mode_FPN': self.info_DRA.mode_FPN
}
title = title + self.info_DRA.mode_FPN + '_'
else:
self.set_new_text.emit("Start DRA -->")
d_arg = {
'video': self.original_video,
'batchSize': self.info_DRA.batch_size,
'flag_GUI': True,
'instance': DifferentialRollingAverage,
'FPN_flag': False,
'select_correction_axis': self.info_DRA.axis,
'object_update_progressBar':
self.object_update_progressBar,
'mode_FPN': self.info_DRA.mode_FPN
}
self.flag_thread_dra = True
self.flag_update_dra = True
self.startProgressBar(**d_arg)
while self.flag_thread_dra:
QtCore.QCoreApplication.processEvents()
while self.flag_update_dra:
QtCore.QCoreApplication.processEvents()
self.set_plain_text.emit(" Done")
title = title + 'DRA'
if self.info_DRA.flag_display:
self.visualization_ = Visulization_localization()
self.visualization_.new_display(self.DRA_video,
self.DRA_video,
object=None,
title=title)
self.update_output.emit(
[self.DRA_video, title, None, self.info_DRA.batch_size])
else:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("Please load one video!")
self.msg_box.exec_()
class FUN_DRA(QtWidgets.QMainWindow, QtCore.QObject):
update_output = QtCore.Signal(object)
update_pn_roi = QtCore.Signal(object)
set_new_text = QtCore.Signal(object)
set_plain_text = QtCore.Signal(object)
def __init__(self, video, object_update_progressBar):
super().__init__()
self.threadpool = QThreadPool()
self.original_video = video
self.object_update_progressBar = object_update_progressBar
self.DRA_video = None
self.flag_thread_dra = True
self.flag_update_original_video = True
@Slot()
def thread_DRA_complete(self):
self.object_update_progressBar.setRange(self.p_max)
self.object_update_progressBar.setLabel('')
self.thread_DRA.signals.DRA_complete_signal.emit(False)
self.flag_thread_dra = False
print("THREAD DRA COMPLETE!")
@Slot()
def result_tread_DRA(self, result):
self.DRA_video = result
self.flag_update_dra = False
print("DRA video update!")
@Slot()
def update_original_video(self, video):
self.original_video = video[0]
self.flag_update_original_video = False
@Slot()
def startProgressBar(self, instance, **kwargs):
self.thread_DRA = instance(**kwargs)
self.thread_DRA.signals.updateProgress_DRA.connect(
self.object_update_progressBar.setProgress)
self.thread_DRA.signals.result_final.connect(self.result_tread_DRA)
self.thread_DRA.signals.finished_DRA.connect(self.thread_DRA_complete)
self.threadpool.start(self.thread_DRA)
def dra_wrapper(self):
title = ''
if self.original_video is not None and self.original_video.shape[0] - (
2 * self.info_DRA.batch_size) <= 0:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText(
"The batch size bigger than the video length (#frame" +
str(self.original_video.shape[0]) + ")!")
self.msg_box.exec_()
if self.original_video is not None and self.original_video.shape[0] - (
2 * self.info_DRA.batch_size) > 0:
if self.info_DRA.flag_power_normalization:
self.set_new_text.emit("Start PN -->")
self.flag_update_original_video = True
worker = Normalization(self.original_video, flag_pn=True)
worker.signals.result.connect(self.update_original_video)
self.threadpool.start(worker)
while self.flag_update_original_video:
QtCore.QCoreApplication.processEvents()
self.flag_update_original_video = True
title = title + 'PN_'
self.set_plain_text.emit(" Done")
self.p_max = self.original_video.shape[0] - (
2 * self.info_DRA.batch_size) - 1
self.object_update_progressBar.setProgress(0)
self.object_update_progressBar.setRange(self.p_max)
if self.info_DRA.flag_FPN:
self.set_new_text.emit("Start DRA + " +
self.info_DRA.mode_FPN + '-->')
d_arg = {
'video': self.original_video,
'batchSize': self.info_DRA.batch_size,
'flag_GUI': True,
'instance': DifferentialRollingAverage,
'FPN_flag': True,
'select_correction_axis': self.info_DRA.axis,
'object_update_progressBar':
self.object_update_progressBar,
'mode_FPN': self.info_DRA.mode_FPN
}
title = title + self.info_DRA.mode_FPN + '_'
else:
self.set_new_text.emit("Start DRA -->")
d_arg = {
'video': self.original_video,
'batchSize': self.info_DRA.batch_size,
'flag_GUI': True,
'instance': DifferentialRollingAverage,
'FPN_flag': False,
'select_correction_axis': self.info_DRA.axis,
'object_update_progressBar':
self.object_update_progressBar,
'mode_FPN': self.info_DRA.mode_FPN
}
self.flag_thread_dra = True
self.flag_update_dra = True
self.startProgressBar(**d_arg)
while self.flag_thread_dra:
QtCore.QCoreApplication.processEvents()
while self.flag_update_dra:
QtCore.QCoreApplication.processEvents()
self.set_plain_text.emit(" Done")
title = title + 'DRA'
if self.info_DRA.flag_display:
self.visualization_ = Visulization_localization()
self.visualization_.new_display(self.DRA_video,
self.DRA_video,
object=None,
title=title)
self.update_output.emit(
[self.DRA_video, title, None, self.info_DRA.batch_size])
else:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("Please load one video!")
self.msg_box.exec_()
def apply_DRA(self):
self.info_DRA = DRA()
self.info_DRA.signal_finish.connect(self.run_DRA_wrapper)
def run_DRA_wrapper(self, flag):
if flag:
self.info_DRA.window.close()
self.dra_wrapper()
def run_DRA_from_bgtabs(self, mode_FPN, batch_size,
flag_power_normalization, roi_x_pn, roi_y_pn,
flag_FPN, axis):
title = ''
if self.original_video is not None and self.original_video.shape[0] - (
2 * batch_size) <= 0:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText(
"The batch size bigger than the video length (#frame" +
str(self.original_video.shape[0]) + ")!")
self.msg_box.exec_()
if self.original_video is not None and self.original_video.shape[0] - (
2 * batch_size) > 0:
if flag_power_normalization:
self.set_new_text.emit("Start PN -->")
self.flag_update_original_video = True
worker = Normalization(self.original_video, flag_pn=True)
self.update_pn_roi.connect(worker.update_class_parameter)
worker.signals.result.connect(self.update_original_video)
self.update_pn_roi.emit([roi_x_pn, roi_y_pn])
self.threadpool.start(worker)
while self.flag_update_original_video:
QtCore.QCoreApplication.processEvents()
self.flag_update_original_video = True
title = title + 'PN_'
self.set_plain_text.emit(" Done")
self.p_max = self.original_video.shape[0] - (2 * batch_size) - 1
self.object_update_progressBar.setProgress(0)
self.object_update_progressBar.setRange(self.p_max)
if flag_FPN:
self.set_new_text.emit("Start DRA + " + mode_FPN + '-->')
d_arg = {
'video': self.original_video,
'batchSize': batch_size,
'flag_GUI': True,
'instance': DifferentialRollingAverage,
'FPN_flag_GUI': True,
'gui_select_correction_axis': axis,
'object_update_progressBar':
self.object_update_progressBar,
'mode_FPN': mode_FPN
}
title = title + mode_FPN + '_'
else:
self.set_new_text.emit("Start DRA -->")
d_arg = {
'video': self.original_video,
'batchSize': batch_size,
'flag_GUI': True,
'mode_FPN': mode_FPN,
'instance': DifferentialRollingAverage,
'FPN_flag_GUI': False,
'gui_select_correction_axis': axis,
'object_update_progressBar': self.object_update_progressBar
}
self.flag_thread_dra = True
self.flag_update_dra = True
self.startProgressBar(**d_arg)
while self.flag_thread_dra:
QtCore.QCoreApplication.processEvents()
while self.flag_update_dra:
QtCore.QCoreApplication.processEvents()
self.set_plain_text.emit(" Done")
title = title + 'DRA'
return self.DRA_video
else:
self.msg_box = QtWidgets.QMessageBox()
self.msg_box.setWindowTitle("Warning!")
self.msg_box.setText("Please load one video!")
self.msg_box.exec_()
class ProteinTabs(QtWidgets.QMainWindow):
new_update_df_PSFs = QtCore.Signal(object)
new_update_bg_video = QtCore.Signal(object)
new_update_trajectories = QtCore.Signal(object)
new_update_DRA_video = QtCore.Signal(object)
def __init__(self, video_in, batch_size, object_update_progressBar, parent=None):
super(ProteinTabs, self).__init__(parent)
self.window = QtWidgets.QWidget()
self.all_tabs = {}
self.input_video = video_in
self.batch_size = batch_size
self.bgCorrectedVideo = None
self.df_PSFs = None
self.type_bgCorrection = None
self.trajectories = None
self.current_frame = 0
self.object_update_progressBar = object_update_progressBar
self.history = {'Type_bg_correction': None, 'bg_setting': None,
'PSFs_Localization_setting': None, 'PSFs_Tracking_setting': None}
self.PSFs_Particels_num = {'#PSFs': None, '#Particles': None}
self.initUI()
self.setWindowTitle("Protein")
self.window.setLayout(self.layout)
self.setCentralWidget(self.window)
self.window.show()
def initUI(self):
self.resize(400, 200)
self.setWindowTitle('PSF Tracking')
self.setGeometry(1140, 100, 400, 200)
# Tabs
self.all_tabs = {"Bg_correction": BgCorrection_GUI(input_video=self.input_video, object_update_progressBar=self.object_update_progressBar),
"PSFs_Localization": Localization_GUI(),
"PSFs_Tracking": Tracking_GUI(self.batch_size),
"Histogram": Histogram_GUI()}
self.all_tabs["Bg_correction"].output_Tab_bgCorrection.connect(self.Update_tab_bgCorrection)
self.all_tabs["Bg_correction"].output_batchSize_Tab_bgCorrection.connect(self.Update_batchSize)
self.all_tabs["Bg_correction"].output_setting_Tab_bgCorrection.connect(partial(self.history_update, key='bg_setting'))
self.all_tabs["Bg_correction"].update_tab_index.connect(self.update_tab)
self.all_tabs["PSFs_Localization"].preview_localization.connect(partial(self.Update_tab_localization, flag_preview=True))
self.all_tabs["PSFs_Localization"].update_localization.connect(partial(self.Update_tab_localization, flag_preview=False))
self.all_tabs["PSFs_Localization"].output_setting_Tab_Localization.connect(partial(self.history_update, key='PSFs_Localization_setting'))
self.all_tabs["PSFs_Localization"].output_number_PSFs_tracking.connect(partial(self.number_PSFs, key='#PSFs'))
self.all_tabs["PSFs_Localization"].update_tab_index.connect(self.update_tab)
self.new_update_bg_video.connect(self.all_tabs["PSFs_Localization"].update_in_data)
self.all_tabs["PSFs_Tracking"].update_tracking.connect(self.Update_tab_localization)
self.all_tabs["PSFs_Tracking"].update_trajectories.connect(self.Update_tab_trajectories)
self.all_tabs["PSFs_Tracking"].output_setting_Tab_tracking.connect(partial(self.history_update, key='PSFs_Tracking_setting'))
self.all_tabs["PSFs_Tracking"].output_number_Particels_tracking.connect(partial(self.number_PSFs, key='#Particles'))
self.new_update_df_PSFs.connect(self.all_tabs["PSFs_Tracking"].update_in_data)
self.new_update_trajectories.connect(self.all_tabs["Histogram"].update_in_data)
self.main_tabWidget = QtWidgets.QTabWidget()
self.main_tabWidget.addTab(self.all_tabs["Bg_correction"], "Background correction")
self.main_tabWidget.addTab(self.all_tabs["PSFs_Localization"], "PSFs localization")
self.main_tabWidget.addTab(self.all_tabs["PSFs_Tracking"], "PSFs tracking")
self.main_tabWidget.addTab(self.all_tabs["Histogram"], "Histogram")
self.btn_save = QtWidgets.QPushButton("Save Data_History")
self.btn_save.setAutoDefault(False)
self.btn_save.clicked.connect(self.save_data)
self.btn_save.setFixedWidth(120)
self.btn_save.setFixedHeight(20)
self.btn_load_csv = QtWidgets.QPushButton("Load CSV")
self.btn_load_csv.setAutoDefault(False)
self.btn_load_csv.clicked.connect(self.load_csv_data)
self.btn_load_csv.setFixedWidth(100)
self.btn_load_csv.setFixedHeight(20)
self.btn_load_hdf5 = QtWidgets.QPushButton("Load hdf5")
self.btn_load_hdf5.setAutoDefault(False)
self.btn_load_hdf5.clicked.connect(self.load_hdf5_data)
self.btn_load_hdf5.setFixedWidth(120)
self.btn_load_hdf5.setFixedHeight(20)
self.statusbar = self.statusBar()
self.statusBar().addPermanentWidget(self.btn_save)
self.statusBar().addPermanentWidget(self.btn_load_csv)
self.statusBar().addPermanentWidget(self.btn_load_hdf5)
self.main_tabWidget.setCurrentIndex(0)
self.layout = QtWidgets.QVBoxLayout()
self.layout.addWidget(self.main_tabWidget)
self.layout.setContentsMargins(0, 0, 0, 0)
@Slot()
def update_input(self, video_in):
self.input_video = video_in
def __del__(self):
print('Destructor called, Employee deleted.')
@Slot(int)
def update_tab(self, idx_):
self.main_tabWidget.setCurrentIndex(idx_)
@Slot(int)
def setProgress(self, val):
self.progressBar.setValue(val)
@Slot()
def Update_batchSize(self, batchSize):
self.batch_size = batchSize
self.all_tabs["PSFs_Tracking"].update_batchSize(batchSize=batchSize)
@Slot()
def Update_tab_bgCorrection(self, data):
if data[0] is not None:
if len(data[0]) == 2:
self.bgCorrectedVideo = data[0][0]
else:
self.bgCorrectedVideo = data[0]
self.type_bgCorrection = data[1]
self.history['Type_bg_correction'] = data[1]
self.new_update_bg_video.emit(self.bgCorrectedVideo)
if data[1] == 'DRA':
self.new_update_DRA_video.emit([self.bgCorrectedVideo, 'DRA', None, self.batch_size])
self.visualization_ = Visulization_localization()
self.visualization_.bg_correction_update(in_video=self.bgCorrectedVideo, label=self.type_bgCorrection, object=self.all_tabs["PSFs_Localization"])
else:
self.msg_box2 = QtWidgets.QMessageBox()
self.msg_box2.setWindowTitle("Warning!")
self.msg_box2.setText("Input video does not find!")
self.msg_box2.exec_()
@QtCore.Slot()
def Update_tab_localization(self, df_psfs, flag_preview=False):
self.df_PSFs = df_psfs
if self.bgCorrectedVideo is not None and self.df_PSFs is not None:
if type(self.df_PSFs) is np.ndarray:
self.visualization_.get_sliceNumber(frame_num=self.all_tabs["PSFs_Localization"].frame_num)
self.visualization_.update_localization_onMask(video_in=self.bgCorrectedVideo,
title=self.type_bgCorrection, df_PSFs=self.df_PSFs)
elif type(self.df_PSFs) is pd.core.frame.DataFrame:
self.visualization_.get_sliceNumber(frame_num=self.all_tabs["PSFs_Localization"].frame_num)
self.visualization_.update_localization_onMask(video_in=self.bgCorrectedVideo, title=self.type_bgCorrection,
df_PSFs=self.df_PSFs, flag_preview=flag_preview)
self.new_update_df_PSFs.emit([self.bgCorrectedVideo, self.df_PSFs])
elif self.bgCorrectedVideo is None:
self.msg_box1 = QtWidgets.QMessageBox()
self.msg_box1.setWindowTitle("Warning!")
self.msg_box1.setText("Input Video is None!")
self.msg_box1.exec_()
elif self.df_PSFs is None:
self.msg_box1 = QtWidgets.QMessageBox()
self.msg_box1.setWindowTitle("Warning!")
self.msg_box1.setText("Zero particle detected!")
self.msg_box1.exec_()
@QtCore.Slot()
def Update_tab_trajectories(self, trajectories):
self.trajectories = trajectories
self.new_update_trajectories.emit([trajectories, self.input_video.shape[0], self.batch_size])
@QtCore.Slot()
def history_update(self, history, key):
self.history[key] = history
@QtCore.Slot()
def number_PSFs(self, data_in, key):
self.PSFs_Particels_num[key] = data_in
def save_data(self):
self.file_path = False
self.file_path = QtWidgets.QFileDialog.getExistingDirectory(self, 'Select Folder', os.path.expanduser("~"), QtWidgets.QFileDialog.ShowDirsOnly)
timestr = time.strftime("%Y%m%d-%H%M%S")
name_mkdir = timestr
try:
dr_mk = os.path.join(self.file_path, name_mkdir)
os.mkdir(dr_mk)
print("Directory ", name_mkdir, " Created ")
except FileExistsError:
dr_mk = os.path.join(self.file_path, name_mkdir)
print("Directory ", name_mkdir, " already exists")
self.file_path = dr_mk
if self.file_path:
if self.df_PSFs is not None:
read_write_data.save_df2csv(self.df_PSFs, path=self.file_path, name='df_PSFs')
fout = os.path.join(self.file_path, 'history.txt')
fo = open(fout, "w")
for k, v in self.history.items():
fo.write(str(k) + ' >>> ' + str(v) + '\n\n')
for k, v in self.PSFs_Particels_num.items():
fo.write(str(k) + ' >>> ' + str(v) + '\n\n')
fo.close()
if self.trajectories is not None:
read_write_data.save_mat(data=self.trajectories, path=self.file_path, name='all_trajectories')
read_write_data.save_list_to_hdf5(list_data=self.trajectories, path=self.file_path, name='histData')
def load_hdf5_data(self):
if self.bgCorrectedVideo is not None:
try:
fileName = QtWidgets.QFileDialog().getOpenFileName()
filePath = str(fileName[0])
data_dic = load_dict_from_hdf5(filePath)
self.Update_tab_trajectories(data_dic)
except:
print('HDF5 can not load!')
elif self.bgCorrectedVideo is None:
self.msg_box1 = QtWidgets.QMessageBox()
self.msg_box1.setWindowTitle("Warning!")
self.msg_box1.setText("Update background tab!")
self.msg_box1.exec_()
def load_csv_data(self):
if self.bgCorrectedVideo is not None:
try:
fileName = QtWidgets.QFileDialog().getOpenFileName()
filePath = str(fileName[0])
df_PSFs = pd.read_csv(filePath)
self.Update_tab_localization(df_PSFs)
except:
print('CSV can not load!')
elif self.bgCorrectedVideo is None:
self.msg_box1 = QtWidgets.QMessageBox()
self.msg_box1.setWindowTitle("Warning!")
self.msg_box1.setText("Update background tab!")
self.msg_box1.exec_()
def display_result(self, input_video, headr_name):
visualization_ = Visulization_localization()
visualization_.new_display(input_video,
input_video,
object=None,
title=headr_name)