def displayImage(self, imp, show = True): imp.setDisplayMode(IJ.COMPOSITE) enhancer = ContrastEnhancer() enhancer.setUseStackHistogram(True) splitter = ChannelSplitter() for c in range(1, imp.getNChannels() + 1): imp.c = c enhancer.stretchHistogram(imp, 0.35) if show: imp.show()
def getPreview(image): enhancer = ContrastEnhancer() projector = ZProjector() splitter = ChannelSplitter() imp1 = ImagePlus("CH1", ) width, height, channels, slices, frames = image.getDimensions() chimps = [] for ch in range(1, channels + 1): projector = ZProjector(ImagePlus("C%i" % ch, splitter.getChannel(image, ch))) projector.setMethod(ZProjector.MAX_METHOD) projector.doProjection() proj = projector.getProjection() enhancer.equalize(proj) chimps.append(proj) return RGBStackMerge.mergeChannels(chimps, False)
def cubify_ROI(self, e): self.manualROI_name = self.name + "_manualROI-" + self.textfield3.text # warn the user if that ROI exists already in the processed data self.processed_files = listdir(self.output_path) self.out_core_names = get_core_names(self.processed_files, self.file_core_name) if self.manualROI_name in self.out_core_names: print("################## ##################") print("CAREFUL!!!! This ROI already exists in your processed data:") print("################## ##################") print(self.manualROI_name) # set square roi size in the low resolution level gui_adjust = 128 # for historic reasons hr_L = int(self.textfield1.text) * gui_adjust # convert back to low resolution self.L = hr_L / self.binFactor # get info tit = self.lr_dapi.getTitle() self.roi = self.lr_dapi.getRoi() # get corners corners = get_corners(self.roi, self.L) self.corners_cleaned = clean_corners(corners, self.roi, self.L) # get the overlay self.ov = overlay_corners(self.corners_cleaned, self.L) self.ov = overlay_roi(self.roi, self.ov) # write roi name self.ov = write_roi_numbers(self.ov, self.corners_cleaned, self.L) # overlay self.lr_dapi.setOverlay(self.ov) self.lr_dapi.updateAndDraw() # open the Xth highest resolution one to see if it is in focus if int(self.textfield5.text) != 0: pir_for_focus = int(self.textfield5.text) bf_corr = self.binFactor / (self.binStep ** (pir_for_focus - 1)) min_x = int(min([x[0] for x in self.corners_cleaned]) * bf_corr) min_y = int(min([x[1] for x in self.corners_cleaned]) * bf_corr) max_x = int((max([x[0] for x in self.corners_cleaned]) + self.L) * bf_corr) max_y = int((max([x[1] for x in self.corners_cleaned]) + self.L) * bf_corr) series_num = self.high_res_index + pir_for_focus - 1 self.med_res_image = open_czi_series( self.input_path, series_num, rect=[min_x, min_y, max_x - min_x, max_y - min_y]) # read the image # play with that one, and do the real processing in the background self.med_res_image.show() self.med_res_image.setDisplayMode(IJ.COMPOSITE) color_order = ['Grays', 'Green', 'Red', 'Cyan'] for c in range(self.med_res_image.getNChannels()): self.med_res_image.setC(c + 1) IJ.run(color_order[c]) ContrastEnhancer().stretchHistogram(self.med_res_image, 0.35) self.med_res_image.updateAndDraw() # rename self.med_res_image.setTitle(self.manualROI_name)
def save_registration_image(self): reg_text_info = self.textfield4.text.split(',') reg_pir_num = int(reg_text_info[0]) reg_channel = int(reg_text_info[1]) self.reg_final_res = float(reg_text_info[2]) self.forreg_output_path = path.join(self.output_path, "000_Slices_for_ARA_registration") if path.isdir(self.forreg_output_path): print("Output path for low resolution slices was already created") else: mkdir(self.forreg_output_path) print("Output path for low resolution slices created") # check that this slice has not been saved before reg_slice_name = path.join(self.forreg_output_path, self.name) if path.isfile(reg_slice_name + '.tif'): print("Registration slice already exists") else: # save otherwise print("Saving for registration channel {} at {} um/px".format(reg_channel, self.reg_final_res)) # get the Xth resolution image and Xth channel for saving it for registration series_num = self.high_res_index + reg_pir_num self.raw_reg_image = open_czi_series(self.input_path, series_num) # read the image self.regist_image = extractChannel(self.raw_reg_image, reg_channel, 1) ContrastEnhancer().stretchHistogram(self.regist_image, 0.35) # self.regist_image.show() self.regist_image.getProcessor().resetRoi() # reset min and max automatically # convert to 8-bit (which also applies the contrast) # ImageConverter(self.regist_image).convertToGray8() # convert to Xum/px so that it can be aligned to ARA reg_im_bin_factor = self.binStep ** reg_pir_num regres_resolution = reg_im_bin_factor * self.res_xy_size rescale_factor = regres_resolution / self.reg_final_res new_width = int(rescale_factor * self.regist_image.getWidth()) # self.lr_dapi_reg.getProcessor().scale(rescale_factor, rescale_factor) ip = self.regist_image.getProcessor().resize(new_width) self.regist_image.setProcessor(ip) # Add the information to the metadata self.regist_image.getCalibration().pixelWidth = self.reg_final_res self.regist_image.getCalibration().pixelHeight = self.reg_final_res self.regist_image.getCalibration().pixelDepth = 1 self.regist_image.getCalibration().setXUnit("micrometer") self.regist_image.getCalibration().setYUnit("micrometer") self.regist_image.getCalibration().setZUnit("micrometer") # self.lr_dapi_reg.getProcessor().resetRoi() IJ.saveAsTiff(self.regist_image, reg_slice_name) self.regist_image.close() self.regist_image.flush() print("Slice for registration saved")
def open_lowres_image(self, e): sender = e.getSource() IJ.run("Close All") if not e.getValueIsAdjusting(): self.name = sender.getSelectedValue() print(self.name) # parse the slice number self.sl_num = int(self.name.split('-')[-1]) print("Opening slice " + str(self.sl_num)) if not path.exists(self.input_path): print("I don't find the file, which is weird as I just found it before") else: # get the number of piramids for that image, the index of highres and the binning self.num_of_piramids = self.num_of_piramids_list[self.sl_num] self.high_res_index = self.max_res_indexes[self.sl_num] self.binFactor = self.binFactor_list[self.sl_num] self.binStep = self.binStep_list[self.sl_num] # get the lowest resolution binned, depending on the number # of resolutions. The order is higher to lower. series_num = self.high_res_index + self.num_of_piramids - 1 self.low_res_image = open_czi_series(self.input_path, series_num) # read the image # save the resolution (every image has the high-resolution information) self.res_xy_size = self.low_res_image.getCalibration().pixelWidth self.res_units = self.low_res_image.getCalibration().getXUnit() # play with that one, and do the real processing in the background # select the DAPI channel and adjust the intensity self.lr_dapi = extractChannel(self.low_res_image, 1, 1) ContrastEnhancer().stretchHistogram(self.lr_dapi, 0.35) self.lr_dapi.setTitle(self.name) self.lr_dapi.show() # reposition image self.lr_dapi.getWindow().setLocation(420, 10) self.lr_dapi.updateAndDraw() # clean self.low_res_image.close() self.low_res_image.flush()
num_of_piramids = num_of_piramids_list[sl_num] binFactor = binFactor_list[sl_num] high_res_index = max_res_indexes[sl_num] binStep = binStep_list[sl_num] # open the image # get the Xth resolution binned, depending on the number # of resolutions. The order is higher to lower. series_num = high_res_index + piramid_to_open raw_image = open_czi_series(input_path, series_num) # save the resolution (every image has the high-resolution information) res_xy_size = raw_image.getCalibration().pixelWidth res_units = raw_image.getCalibration().getXUnit() # select the requested channel and adjust the intensity regist_image = extractChannel(raw_image, channel_to_save, 1) # TODO: test if contrast enhancement and background sustraction are needed for registration ContrastEnhancer().stretchHistogram(regist_image, 0.35) # IMPLEMENT BACKGROUND SUSTRACTION HERE regist_image.setTitle(sl_name) #ch_image.show() # clean raw_image.close() raw_image.flush() # convert to Xum/px so that it can be aligned to ARA reg_im_bin_factor = binStep**piramid_to_open regres_resolution = reg_im_bin_factor * res_xy_size rescale_factor = regres_resolution / final_resolution new_width = int(rescale_factor * regist_image.getWidth()) # self.lr_dapi_reg.getProcessor().scale(rescale_factor, rescale_factor) ip = regist_image.getProcessor().resize(new_width) regist_image.setProcessor(ip) # Add the information to the metadata
import glob arguments = docopt(__doc__, version='NER 0.1') input_dir = arguments['INPUT'] output_dir = arguments['OUTPUT'] filter_window = float(arguments['--filter-window']) if arguments['--filter-window'] else 5.0 gamma = float(arguments['--gamma']) if arguments['--gamma'] else 0.50 channel = int(arguments['--channel']) if arguments['--channel'] else 1 objective = int(arguments['--objective']) if arguments['--objective'] else 20 microscope = arguments['--microscope'] if arguments['--microscope'] else "SD" pixel_size = float(arguments['--pixel-size']) if arguments['--pixel-size'] else None rolling_ball_size = int(arguments['--rolling-ball-size']) if arguments['--pixel-size'] else 30 channel_splitter = ChannelSplitter() contrast_enhancer = ContrastEnhancer() contrast_enhancer.setNormalize(True) if pixel_size is None: if objective == 20 and microscope == "SD": pixel_size = 0.5089 else: pixel_size = 1.0 files = glob.glob(input_dir + "*.tif") files.sort() frame_i = 1 for file in files: print("Processing frame \033[1m" + str(frame_i) + "\033[0m") frame = IJ.openImage(file) # ImagePlus