def asmemmaps(basename, video, count = None): """Loads multi-frame video into numpy memmaps. Actual data is written to numpy files with the provide basename and subscripted by source identifier (index), e.g. "basename_0.npy" and "basename_1.npy" in case of dual-frame video source. Parameters ---------- basename: str Base name for the filenames of the videos. video : iterable A multi-frame iterator object. count : int, optional Defines how many multi-frames are in the video. If not provided it is determined by len(). Returns ------- out : tuple of arrays A tuple of memmapped array(s) representing video(s) """ if count is None: try: count = len(video) except TypeError: raise ValueError("You must provide count") def _load(array, frame): array[...] = frame def _empty_arrays(frames): out = tuple( (np.lib.format.open_memmap(basename + "_{}.npy".format(i), "w+", shape = (count,) + frame.shape, dtype = frame.dtype) for i,frame in enumerate(frames))) return out print1("Writing to memmap...") print_progress(0, count) frames = next(video) out = _empty_arrays(frames) [_load(out[i][0],frame) for i,frame in enumerate(frames)] for j,frames in enumerate(video): print_progress(j+1, count) [_load(out[i][j+1],frame) for i,frame in enumerate(frames)] print_progress(count, count) return out
def asarrays(video, count = None): """Loads multi-frame video into numpy arrays. Parameters ---------- video : iterable A multi-frame iterator object. count : int, optional Defines how many frames are in the video. If not provided it will calculate length of the video based on the length of the iterable. If that is not possible ValueError is raised Returns ------- out : tuple of arrays A tuple of array(s) representing video(s) """ t0 = time.time() def _load(array, frame): array[...] = frame print1("Loading array...") if count is None: try: count = len(video) except TypeError: raise ValueError("You must provide count") print_progress(0, count) video = iter(video) frames = next(video) out = tuple((np.empty(shape = (count,) + frame.shape, dtype = frame.dtype) for frame in frames)) [_load(out[i][0],frame) for i,frame in enumerate(frames)] for j,frames in enumerate(video): print_progress(j+1, count) [_load(out[i][j+1],frame) for i,frame in enumerate(frames)] print_progress(count, count) print_frame_rate(count,t0) return out
def test_print(self): conf.set_verbose(0) pt.print1("No print") pt.print2("No print") pt.print_progress(4, 10) pt.print_progress(10, 10) conf.set_verbose(1) pt.print1("Ok") pt.print2("No print") conf.set_verbose(2) pt.print1("OK") pt.print2("OK") pt.print_progress(4, 10) pt.print_progress(10, 10)
def normalize(data, background=None, variance=None, norm=None, mode="corr", scale=False, mask=None, weight=None, ret_weight=False, out=None): """Normalizes correlation (difference) data. Data must be data as returned from ccorr or acorr functions. Except forthe most basic normalization, background and variance data must be provided. Tou can use :func:`stats` to compute background and variance data. Parameters ---------- data : tuple of ndarrays Input data, a length 4 (difference data) or length 5 tuple (correlation data) background : (ndarray, ndarray) or ndarray, optional Background (mean) of the frame(s) in k-space variance : (ndarray, ndarray) or ndarray, optional Variance of the frame(s) in k-space norm : int, optional Normalization type (0:baseline,1:compensation,2:bg subtract, 3: compensation + bg subtract). Input data must support the chosen normalization, otherwise exception is raised. If not given it is chosen based on the input data. mode : str, optional Representation mode: either "corr" (default) for correlation function, or "diff" for image structure function (image difference). scale : bool, optional If specified, performs scaling so that data is scaled beteween 0 and 1. This works in connection with variance, which must be provided. mask : ndarray, optional An array of bools indicating which k-values should we select. If not given, compute at every k-value. weight : ndarray, optional If you wish to specify your own weight for weighted normalization, you must provide it here, otherwise it is computed from the data (default). ret_weight : bool, optional Whether to return weight (when calculating weighted normalization) out : ndarray, optional Output array Returns ------- out : ndarray Normalized data. out, weight : ndarray, ndarray Normalized data and weight if 'ret_weight' was specified """ print1("Normalizing...") #determine what kind of data is there ('diff' or 'corr') method = _method_from_data(data) scale = _inspect_scale(scale) mode = _inspect_mode(mode) if isinstance(norm, str): norm = norm_from_string(norm) #determine default normalization if not specified by user norm = _default_norm_from_data(data, method, norm) # if len(data[1].shape) > 1 and norm & NORM_WEIGHTED: # #if multilevel data, subtracted or baseline is best, so force it here. # norm = norm & NORM_SUBTRACTED # scale factor for normalization if scale == True: _scale_factor = scale_factor(variance, mask) print2(" * background : {}".format(background is not None)) print2(" * variance : {}".format(variance is not None)) print2(" * norm : {}".format(norm)) print2(" * scale : {}".format(scale)) print2(" * mode : {}".format(mode)) print2(" * mask : {}".format(mask is not None)) bg1, bg2 = _inspect_background(background, norm, mask) if (norm & NORM_WEIGHTED == NORM_WEIGHTED): level = disable_prints() norm_comp = (norm & (NORM_SUBTRACTED | NORM_COMPENSATED)) | NORM_STRUCTURED comp_data = normalize(data, background, variance, norm=norm_comp, mode=mode, scale=scale, mask=mask) norm_base = (norm & (NORM_SUBTRACTED | NORM_COMPENSATED)) | NORM_STANDARD base_data = normalize(data, background, variance, norm=norm_base, mode=mode, scale=scale, mask=mask) _multilevel = True if len(data[1].shape) > 1 else False x_avg, y_avg = _data_estimator(comp_data, size=8, n=3, multilevel=_multilevel) _scale_factor = 1. if scale == True else scale_factor(variance, mask) if weight is None: if _multilevel: shape = np.array(comp_data.shape) shape[1:-1] = 1 _x_interp = np.arange(comp_data.shape[-1]) x_interp = np.empty(shape=shape, dtype=int) for x_level in x_interp: x_level[...] = _x_interp _x_interp *= 2 else: x_interp = np.arange(data[1].shape[-1]) if norm & NORM_SUBTRACTED: delta = noise_delta(variance, mask, scale=scale) weight = weight_from_data(y_avg, delta, scale_factor=_scale_factor, mode=mode) else: bg1 = bg1 / (scale_factor(variance, mask))**0.5 if scale == True else bg1 bg2 = bg2 / (scale_factor(variance, mask))**0.5 if scale == True else bg2 delta = noise_delta(variance, mask, scale=scale) weight = weight_prime_from_data(y_avg, bg1, bg2, delta, scale_factor=_scale_factor, mode=mode) weight = _nb.log_interpolate(x_interp, x_avg, weight) enable_prints(level) if ret_weight == True: return weighted_sum(comp_data, base_data, weight), weight else: return weighted_sum(comp_data, base_data, weight) count = data[1] #add dimensions for broadcasting bg1 = bg1[..., None] bg2 = bg2[..., None] if mask is not None: data = take_data(data, mask) #dimensions of correlation data (the first element of the data tuple) ndim = data[0].ndim #need to add dimensions to count for broadcasting #for 2D data, this is equivalent to count = count[...,None,None,:] ndiff = ndim - count.ndim for i in range(ndiff): count = np.expand_dims(count, -2) if norm == NORM_STANDARD: result = _normalize_ccorr_0(data[0], count, bg1, bg2, out=out) if mode == "diff": result = _corr2diff(result, variance, mask) elif norm == NORM_STRUCTURED: if method == "corr": offset = _variance2offset(variance, mask) result = _normalize_ccorr_1(data[0], count, bg1, bg2, data[2], out=out) #m1 = data[3] #m2 = data[4] if data[4] is not None else m1 #result = _normalize_ccorr_3b(data[0], count, data[2], m1, m2, out = out) result += offset if mode == "diff": result = _corr2diff(result, variance, mask) else: d = bg2 - bg1 result = _normalize_cdiff_1(data[0], count, d, out=out) if mode == "corr": result = _diff2corr(result, variance, mask) elif (norm == NORM_SUBTRACTED | NORM_STANDARD) or ( norm == NORM_SUBTRACTED | NORM_STANDARD | NORM_COMPENSATED): m1 = data[3] m2 = data[4] if data[4] is not None else m1 result = _normalize_ccorr_2(data[0], count, bg1, bg2, m1, m2, out=out) if mode == "diff": result = _corr2diff(result, variance, mask) elif norm == NORM_STANDARD | NORM_COMPENSATED: m1 = data[3] m2 = data[4] if data[4] is not None else m1 result = _normalize_ccorr_2b(data[0], count, m1, m2, out=out) if mode == "diff": result = _corr2diff(result, variance, mask) elif (norm == NORM_STRUCTURED | NORM_SUBTRACTED) or ( norm == NORM_SUBTRACTED | NORM_STRUCTURED | NORM_COMPENSATED): if method == "corr": offset = _variance2offset(variance, mask) m1 = data[3] m2 = data[4] if data[4] is not None else m1 #result = _normalize_ccorr_2b(data[0], count, m1,m2, out = out) result = _normalize_ccorr_3(data[0], count, bg1, bg2, data[2], m1, m2, out=out) result += offset if mode == "diff": result = _corr2diff(result, variance, mask) else: d = bg2 - bg1 result = _normalize_cdiff_3(data[0], count, d, data[2], data[3], out=out) if mode == "corr": result = _diff2corr(result, variance, mask) elif norm == NORM_STRUCTURED | NORM_COMPENSATED: offset = _variance2offset(variance, mask) m1 = data[3] m2 = data[4] if data[4] is not None else m1 result = _normalize_ccorr_3b(data[0], count, data[2], m1, m2, out=out) result += offset if mode == "diff": result = _corr2diff(result, variance, mask) else: raise ValueError("Unknown normalization mode {}".format(norm)) if scale == True: result /= _scale_factor[..., None] if ret_weight == True: return result, weight else: return result