def _regional_balance_chcy_ims(chcy_ims, calib): """ Balance and subtract background on each channel according to calibration data. Returns: balanced_chcy_ims: The regionally balanced chcy_ims """ n_channels, n_cycles = chcy_ims.shape[0:2] balanced_chcy_ims = np.zeros_like(chcy_ims) dim = chcy_ims.shape[-2:] for ch in range(n_channels): regional_bg_mean = np.array( calib[f"regional_bg_mean.instrument_channel[{ch}]"]) regional_balance = np.array( calib[f"regional_illumination_balance.instrument_channel[{ch}]"]) cy_ims = chcy_ims[ch] balance_im = imops.interp(regional_balance, dim) bg_im = imops.interp(regional_bg_mean, dim) if np.any(np.isnan(cy_ims)): raise ValueError( f"regional_balance_chcy_ims chcy_ims contains nan") if np.any(np.isnan(bg_im)): raise ValueError(f"regional_balance_chcy_ims bg_im contains nan") balanced_chcy_ims[ch] = (cy_ims - bg_im) * balance_im return balanced_chcy_ims
def it_interpolates_to_1_by_1_to_4_by_4(): # Bypasses interp out_size = 4 src = np.array([[3.0]]) res = imops.interp(src, (out_size, out_size)) assert res.shape == (4, 4) assert np.all(res == 3.0)
def it_interpolates_to_2_by_2_to_4_by_4(): # Requires a linear interp out_size = 4 src = np.array([[0, 2], [2, 3],]) res = imops.interp(src, (out_size, out_size)) assert res.shape == (4, 4) _check(res)
def it_interpolates_to_4_by_4_to_12_by_12(): # Uses cubic interp out_size = 12 src = np.array([[0, 1, 1, 2], [1, 1, 1, 2], [1, 1, 1, 2], [2, 2, 2, 3],]) res = imops.interp(src, (out_size, out_size)) assert res.shape == (12, 12) _check(res)
def _calibrate_bg_and_psf_im(im, divs=5, keep_dist=8, peak_mea=11, locs=None): """ Run background & PSF calibration for one image. These are typically combined from many fields and for each channel to get a complete calibration. This returns the accepted locs so that a z-stack can be estimated by using the most in-focus frame for the locations Arguments: im: One image divs: Spatial divisions keep_dist: Pixel distancer under which is considered a collision peak_mea: n pixel width and height to hold the peak image locs: If None it will use the peak finder; otherwise these locs are being passed in and are expected to coorespond to the peak locs found in a previous step. Returns: locs (location of accepted peaks) regional_bg_mean regional_bg_std regional_psf_zstack """ check.array_t(im, ndim=2) stats = _regional_bg_fg_stats(im, divs=divs) reg_bg_mean = stats[:, :, 0] reg_bg_std = stats[:, :, 1] check.array_t(reg_bg_mean, shape=(divs, divs)) check.array_t(reg_bg_std, shape=(divs, divs)) bg_im = imops.interp(reg_bg_mean, im.shape[-2:]) im = im - bg_im if locs is None: locs = _peak_find(im) n_locs = locs.shape[0] accepted = np.zeros((n_locs, )) # In each region gather a PSF estimate and a list of # locations that were accepted. These locs can be # re-used when analyzing other z slices reg_psfs = np.zeros((divs, divs, peak_mea, peak_mea)) for win_im, y, x, coord in imops.region_enumerate(im, divs): mea = win_im.shape[0] assert win_im.shape[1] == mea local_locs = locs - coord local_locs_mask = np.all((local_locs > 0) & (local_locs < mea), axis=1) local_locs = local_locs[local_locs_mask] n_local_locs = local_locs.shape[0] psfs, reasons = _psf_estimate(win_im, local_locs, peak_mea, keep_dist=keep_dist, return_reasons=True) reg_psfs[y, x] = psfs # for reason in ( # PSFEstimateMaskFields.accepted, # # PSFEstimateMaskFields.skipped_near_edges, # # PSFEstimateMaskFields.skipped_too_crowded, # # PSFEstimateMaskFields.skipped_has_nan, # # PSFEstimateMaskFields.skipped_empty, # # PSFEstimateMaskFields.skipped_too_dark, # # PSFEstimateMaskFields.skipped_too_oval, # ): # n_local_rejected = (reasons[:, reason] > 0).sum() # print(f"y,x={y},{x} {str(reason)}:, {n_local_rejected}") # Go backwards from local to global space. local_accepted_iz = np.argwhere( reasons[:, PSFEstimateMaskFields.accepted] == 1).flatten() local_loc_i_to_global_loc_i = np.arange(n_locs)[local_locs_mask] assert local_loc_i_to_global_loc_i.shape == (n_local_locs, ) global_accepted_iz = local_loc_i_to_global_loc_i[local_accepted_iz] accepted[global_accepted_iz] = 1 return locs[accepted > 0], reg_bg_mean, reg_bg_std, reg_psfs