def test_per_axis_wavelets(): # tests seperate wavelet for each axis. rstate = np.random.RandomState(1234) data = rstate.randn(16, 16, 16) level = 3 # wavelet can be a string or wavelet object wavelets = (pywt.Wavelet('haar'), 'sym2', 'db4') coefs = pywt.swtn(data, wavelets, level=level) assert_allclose(pywt.iswtn(coefs, wavelets), data, atol=1e-14) # 1-tuple also okay coefs = pywt.swtn(data, wavelets[:1], level=level) assert_allclose(pywt.iswtn(coefs, wavelets[:1]), data, atol=1e-14) # length of wavelets doesn't match the length of axes assert_raises(ValueError, pywt.swtn, data, wavelets[:2], level) assert_raises(ValueError, pywt.iswtn, coefs, wavelets[:2]) with warnings.catch_warnings(): warnings.simplefilter('ignore', FutureWarning) # swt2/iswt2 also support per-axis wavelets/modes data2 = data[..., 0] coefs2 = pywt.swt2(data2, wavelets[:2], level) assert_allclose(pywt.iswt2(coefs2, wavelets[:2]), data2, atol=1e-14)
def _swt3(matrix, axes): # Stationary Wavelet Transform 3D wavelet = 'coif1' level = 1 start_level = 0 # This function gets a numpy array from the SimpleITK Image "inputImage" matrix = numpy.asarray( matrix ) # The function np.asarray converts "matrix" (which could be also a tuple) into an array. if matrix.ndim != 3: raise ValueError('Expected 3D data array') original_shape = matrix.shape # original_shape becomes a tuple (?,?,?) containing the number of rows, columns, and slices of the image padding = tuple([(0, 1 if dim % 2 != 0 else 0) for dim in original_shape]) # padding is necessary because of pywt.swtn (see function Notes) data = matrix.copy( ) # creates a modifiable copy of "matrix" and we call it "data" data = numpy.pad(data, padding, 'wrap') # padding the tuple "padding" previously computed for i in range(0, start_level ): # if start_level = 0 this for loop never gets executed dec = pywt.swtn(data, wavelet, level=1, start_level=0, axes=axes)[ 0] # computes all decompositions and saves them in "dec" dict data = dec['a' * len(axes)].copy( ) # copies in "data" just the "aaa" decomposition (if len(axes) = 3) ret = [] # initialize empty list for i in range(start_level, start_level + level): dec = pywt.swtn(data, wavelet, level=1, start_level=0, axes=axes)[ 0] # computes the n-dimensional stationary wavelet transform data = dec['a' * len(axes)].copy() dec_im = {} # initialize empty dict for decName, decImage in six.iteritems(dec): decTemp = decImage.copy() decTemp = decTemp[tuple( slice(None, -1 if dim % 2 != 0 else None) for dim in original_shape)] sitkImage = decTemp #print(str(decName).replace('a', 'L').replace('d', 'H') + "\n") dec_im[str(decName).replace('a', 'L').replace('d', 'H')] = sitkImage rst = np.zeros((original_shape[0], original_shape[1], 4)) rst[:, :, 0] = dec_im['LL'][:, :, 0] rst[:, :, 1] = dec_im['LH'][:, :, 0] rst[:, :, 2] = dec_im['HL'][:, :, 0] rst[:, :, 3] = dec_im['HH'][:, :, 0] return rst # returns the approximation and the detail (ret) coefficients of the stationary wavelet decomposition
def _swt3(inputImage, axes, **kwargs): # Stationary Wavelet Transform 3D wavelet = kwargs.get('wavelet', 'coif1') level = kwargs.get('level', 1) start_level = kwargs.get('start_level', 0) matrix = sitk.GetArrayFromImage(inputImage) # This function gets a numpy array from the SimpleITK Image "inputImage" matrix = numpy.asarray(matrix) # The function np.asarray converts "matrix" (which could be also a tuple) into an array. if matrix.ndim != 3: raise ValueError('Expected 3D data array') original_shape = matrix.shape # original_shape becomes a tuple (?,?,?) containing the number of rows, columns, and slices of the image padding = tuple([(0, 1 if dim % 2 != 0 else 0) for dim in original_shape]) # padding is necessary because of pywt.swtn (see function Notes) data = matrix.copy() # creates a modifiable copy of "matrix" and we call it "data" data = numpy.pad(data, padding, 'wrap') # padding the tuple "padding" previously computed if not isinstance(wavelet, pywt.Wavelet): wavelet = pywt.Wavelet(wavelet) for i in range(0, start_level): # if start_level = 0 this for loop never gets executed dec = pywt.swtn(data, wavelet, level=1, start_level=0, axes=axes)[0] # computes all decompositions and saves them in "dec" dict data = dec['a' * len(axes)].copy() # copies in "data" just the "aaa" decomposition (if len(axes) = 3) ret = [] # initialize empty list for i in range(start_level, start_level + level): dec = pywt.swtn(data, wavelet, level=1, start_level=0, axes=axes)[0] # computes the n-dimensional stationary wavelet transform data = dec['a' * len(axes)].copy() dec_im = {} # initialize empty dict for decName, decImage in six.iteritems(dec): # Returning the approximiation is done only for the last loop, # and is handled separately below (by building it from `data`) # There for, skip it here if decName == 'a' * len(axes): continue decTemp = decImage.copy() decTemp = decTemp[tuple(slice(None, -1 if dim % 2 != 0 else None) for dim in original_shape)] sitkImage = sitk.GetImageFromArray(decTemp) sitkImage.CopyInformation(inputImage) dec_im[str(decName).replace('a', 'L').replace('d', 'H')] = sitkImage # modifies 'a' with 'L' (Low-pass filter) and 'd' with 'H' (High-pass filter) ret.append(dec_im) # appending all the filtered sitk images (stored in "dec_im") to the "ret" list data = data[tuple(slice(None, -1 if dim % 2 != 0 else None) for dim in original_shape)] approximation = sitk.GetImageFromArray(data) approximation.CopyInformation(inputImage) return approximation, ret # returns the approximation and the detail (ret) coefficients of the stationary wavelet decomposition
def test_swtn_axes(): atol = 1e-14 current_wavelet = pywt.Wavelet('db2') input_length_power = int( np.ceil(np.log2(max(current_wavelet.dec_len, current_wavelet.rec_len)))) input_length = 2**(input_length_power) X = np.arange(input_length**2).reshape(input_length, input_length) coeffs = pywt.swtn(X, current_wavelet, level=1, axes=None)[0] # opposite order coeffs2 = pywt.swtn(X, current_wavelet, level=1, axes=(1, 0))[0] assert_allclose(coeffs['aa'], coeffs2['aa'], atol=atol) assert_allclose(coeffs['ad'], coeffs2['da'], atol=atol) assert_allclose(coeffs['da'], coeffs2['ad'], atol=atol) assert_allclose(coeffs['dd'], coeffs2['dd'], atol=atol) # 0-level transform empty = pywt.swtn(X, current_wavelet, level=0) assert_equal(empty, []) # duplicate axes not allowed assert_raises(ValueError, pywt.swtn, X, current_wavelet, 1, axes=(0, 0)) # data.ndim = 0 assert_raises(ValueError, pywt.swtn, np.asarray([]), current_wavelet, 1) # start_level too large assert_raises(ValueError, pywt.swtn, X, current_wavelet, level=1, start_level=2) # level < 1 in swt_axis call assert_raises(ValueError, swt_axis, X, current_wavelet, level=0, start_level=0) # odd-sized data not allowed assert_raises(ValueError, swt_axis, X[:-1, :], current_wavelet, level=0, start_level=0, axis=0)
def test_iswtn_mixed_dtypes(): # Mixed precision inputs give double precision output rstate = np.random.RandomState(0) x_real = rstate.randn(8, 8, 8) x_complex = x_real + 1j*x_real wav = 'sym2' for dtype1, dtype2 in [(np.float64, np.float32), (np.float32, np.float64), (np.float16, np.float64), (np.complex128, np.complex64), (np.complex64, np.complex128)]: if dtype1 in [np.complex64, np.complex128]: x = x_complex output_dtype = np.complex128 else: x = x_real output_dtype = np.float64 coeffs = pywt.swtn(x, wav, 2) # different precision for the approximation coefficients a = coeffs[0].pop('a' * x.ndim) a = a.astype(dtype1) coeffs[0] = {k: c.astype(dtype2) for k, c in coeffs[0].items()} coeffs[0]['a' * x.ndim] = a y = pywt.iswtn(coeffs, wav) assert_equal(output_dtype, y.dtype) assert_allclose(y, x, rtol=1e-3, atol=1e-3)
def setup(self, D, n, wavelet, dtype): try: from pywt import iswtn except ImportError: raise NotImplementedError("iswtn not available") super(IswtnTimeSuite, self).setup(D, n, wavelet, dtype) self.data = pywt.swtn(self.data, wavelet, self.level)
def wavelet_features(img, mask): # pywt.swt(img,wavelet,level=1) s = img.shape img2 = np.pad(img, pad_width=[(0, s[0] % 2), (0, s[1] % 2), (0, s[2] % 2)], mode="constant", constant_values=0) mask2 = np.pad(mask, pad_width=[(0, s[0] % 2), (0, s[1] % 2), (0, s[2] % 2)], mode="constant", constant_values=0) wavelet_coefs = pywt.swtn(img2, 'coif1', level=1)[0] features = {} for key in wavelet_coefs: features1 = group1_features(wavelet_coefs[key]) features31 = gray_level_cooccurrence_features(wavelet_coefs[key], mask2) features32 = gray_level_runlength_features(wavelet_coefs[key], mask2) for name in features1: features[key + "_" + name] = features1[name] for name in features31: features[key + "_" + name] = features31[name] for name in features32: features[key + "_" + name] = features32[name] return features
def stationary_wavelet_transform(self, waveform, wavelet, level): # Calculate waveform length waveform_length = len(waveform) # Calculate minimum waveform length for SWT of certain decomposition level waveform_length_updated = self.calculate_decomposition_level( waveform_length, level) # Add necessary padding to waveform waveform_padded, pad_before, pad_after = self.add_padding( waveform, waveform_length_updated) # Compute stationary wavelet transform swt = pywt.swtn(waveform_padded, wavelet=wavelet, level=level, start_level=0) # Loop through decomposition levels and remove padding for lev in range(len(swt)): # Approximation swt[lev]['a'] = swt[lev]['a'][pad_before:len(waveform_padded) - pad_after] # Detail swt[lev]['d'] = swt[lev]['d'][pad_before:len(waveform_padded) - pad_after] return swt
def _analysis(self, data, **kwargs): """ Decompose a real signal using pywt. Parameters ---------- data: nd-array a real array to be decomposed. Returns ------- analysis_data: nd_array the decomposition coefficients. analysis_header: dict the decomposition associated information. """ if self.is_decimated: coeffs = pywt.wavedecn(data, self.trf, mode=self.padding_mode, level=self.nb_scale, axes=self.axes) else: coeffs = pywt.swtn(data, self.trf, level=self.nb_scale, axes=self.axes) analysis_data, analysis_header = self._organize_pysap(coeffs) self.nb_band_per_scale = [ len(scale_info) for scale_info in analysis_header ] return analysis_data, analysis_header
def op(self, data): """ Define the wavelet operator. This method returns the input data convolved with the wavelet filter. Parameters ---------- data: np.ndarray(m', n') or np.ndarray(m', n', p') input 2D or 3D data array. Returns ------- coeffs: np.ndarray the wavelet coefficients. """ if self.undecimated: coeffs_dict = pywt.swtn(data, self.pywt_transform, level=self.nb_scale) coeffs, self.coeffs_shape = self.flatten(coeffs_dict) return coeffs else: coeffs_dict = pywt.wavedecn(data, self.pywt_transform, level=self.nb_scale, mode=self.mode) self.coeffs, self.coeffs_shape = self.flatten(coeffs_dict) return self.coeffs
def main(out_file, bins, signal_events, background_events, max_transient_events, time_steps, cmap): ''' Use a toy model to create a transient appearing in the FoV of another source. A steady background is subtracted and denoised using wavelets. This script then creates an animated gif of the whoe shebang saved under the OUT_FILE argument. ''' bins = [bins, bins] cube_steady = simulate_steady_source( num_slices=time_steps, source_count=signal_events, background_count=background_events, bins=bins, ) def time_dependency(): return transient_gaussian(time_steps=time_steps, max_events=max_transient_events) cube_with_transient = simulate_steady_source_with_transient( time_dependency, source_count=signal_events, background_count=background_events, bins=bins) # remove mean measured noise from current cube cube = cube_with_transient - cube_steady.mean(axis=0) coeffs = pywt.swtn( data=cube, wavelet='bior1.3', level=2, ) # remove noisy coefficents. ct = thresholding_3d(coeffs, k=30) cube_smoothed = pywt.iswtn(coeffs=ct, wavelet='bior1.3') # some Criterion which could be used to trigger this. trans_factor = cube_smoothed.max(axis=1).max(axis=1) p = TransientPlotter( cube_with_transient, cube_smoothed, trans_factor, cmap=cmap, ) print('Plotting animation. (Be patient)') anim = animation.FuncAnimation( p.fig, p.step, frames=time_steps, interval=15, blit=True, ) anim.save(out_file, writer='imagemagick', fps=25)
def _swt3(inputImage, wavelet='coif1', level=1, start_level=0, axes=(2, 1, 0)): matrix = sitk.GetArrayFromImage(inputImage) matrix = numpy.asarray(matrix) if matrix.ndim != 3: raise ValueError('Expected 3D data array') original_shape = matrix.shape padding = tuple([(0, 1 if dim % 2 != 0 else 0) for dim in original_shape]) data = matrix.copy() data = numpy.pad(data, padding, 'wrap') if not isinstance(wavelet, pywt.Wavelet): wavelet = pywt.Wavelet(wavelet) for i in range(0, start_level): dec = pywt.swtn(data, wavelet, level=1, start_level=0, axes=axes)[0] data = dec['a' * len(axes)].copy() ret = [] for i in range(start_level, start_level + level): dec = pywt.swtn(data, wavelet, level=1, start_level=0, axes=axes)[0] data = dec['a' * len(axes)].copy() dec_im = {} for decName, decImage in six.iteritems(dec): decTemp = decImage.copy() decTemp = decTemp[[ slice(None, -1 if dim % 2 != 0 else None) for dim in original_shape ]] sitkImage = sitk.GetImageFromArray(decTemp) sitkImage.CopyInformation(inputImage) dec_im[str(decName).replace('a', 'L').replace('d', 'H')] = sitkImage ret.append(dec_im) data = data[[ slice(None, -1 if dim % 2 != 0 else None) for dim in original_shape ]] approximation = sitk.GetImageFromArray(data) approximation.CopyInformation(inputImage) return approximation, ret
def test_swtn_iswtn_unique_shape_per_axis(): # test case for gh-460 _shape = (1, 48, 32) # unique shape per axis wav = 'sym2' max_level = 3 rstate = np.random.RandomState(0) for shape in permutations(_shape): # transform only along the non-singleton axes axes = [ax for ax, s in enumerate(shape) if s != 1] x = rstate.standard_normal(shape) c = pywt.swtn(x, wav, max_level, axes=axes) r = pywt.iswtn(c, wav, axes=axes) assert_allclose(x, r, rtol=1e-10, atol=1e-10)
def initialize_wl_operators(self): if self.use_decimated: H = lambda x: pywt.wavedecn(x, wavelet=self.wl_type, axes=self.axes, level=self.decomp_lvl) Ht = lambda x: pywt.waverecn(x, wavelet=self.wl_type, axes=self.axes) else: if use_swtn: H = lambda x: pywt.swtn(x, wavelet=self.wl_type, axes=self.axes, level=self.decomp_lvl) Ht = lambda x: pywt.iswtn(x, wavelet=self.wl_type, axes=self.axes) else: H = lambda x: pywt.swt2(np.squeeze(x), wavelet=self.wl_type, axes=self.axes, level=self.decomp_lvl) # Ht = lambda x : pywt.iswt2(x, wavelet=self.wl_type) Ht = lambda x: pywt.iswt2(x, wavelet=self.wl_type)[np.newaxis, ...] return (H, Ht)
def test_iswtn_errors(): x = np.arange(8**3).reshape(8, 8, 8) max_level = 2 axes = (0, 1) w = pywt.Wavelet('db1') coeffs = pywt.swtn(x, w, max_level, axes=axes) # more axes than dimensions transformed assert_raises(ValueError, pywt.iswtn, coeffs, w, axes=(0, 1, 2)) # duplicate axes not allowed assert_raises(ValueError, pywt.iswtn, coeffs, w, axes=(0, 0)) # mismatched coefficient size coeffs[0]['da'] = coeffs[0]['da'][:-1, :] assert_raises(RuntimeError, pywt.iswtn, coeffs, w, axes=axes)
def fuse_stationary_wavelets(first, second, *, levels=None, pca=False, wavelet=None): if levels is None: levels = 6 if wavelet is None: wavelet = 'sym4' pad, unpad = swt_pad_funcs(first.shape, levels) first = pad(first) second = pad(second) first = pywt.swtn(first, wavelet, level=levels, axes=(0, 1), norm=True, trim_approx=True) second = pywt.swtn(second, wavelet, level=levels, axes=(0, 1), norm=True, trim_approx=True) first[0] = (first[0] + second[0]) / 2 for first_cs, second_cs in zip(first[1:], second[1:]): mask = _coeff_strength(second_cs.values(), pca) > _coeff_strength( first_cs.values(), pca) for k, v in first_cs.items(): v[mask, ...] = second_cs[k][mask, ...] del second first = pywt.iswtn(first, wavelet, axes=(0, 1), norm=True) return unpad(first)
def test_swtn_axes(): atol = 1e-14 current_wavelet = pywt.Wavelet('db2') input_length_power = int(np.ceil(np.log2(max( current_wavelet.dec_len, current_wavelet.rec_len)))) input_length = 2**(input_length_power) X = np.arange(input_length**2).reshape(input_length, input_length) coeffs = pywt.swtn(X, current_wavelet, level=1, axes=None)[0] # opposite order coeffs2 = pywt.swtn(X, current_wavelet, level=1, axes=(1, 0))[0] assert_allclose(coeffs['aa'], coeffs2['aa'], atol=atol) assert_allclose(coeffs['ad'], coeffs2['da'], atol=atol) assert_allclose(coeffs['da'], coeffs2['ad'], atol=atol) assert_allclose(coeffs['dd'], coeffs2['dd'], atol=atol) # 0-level transform empty = pywt.swtn(X, current_wavelet, level=0) assert_equal(empty, []) # duplicate axes not allowed assert_raises(ValueError, pywt.swtn, X, current_wavelet, 1, axes=(0, 0)) # data.ndim = 0 assert_raises(ValueError, pywt.swtn, np.asarray([]), current_wavelet, 1) # start_level too large assert_raises(ValueError, pywt.swtn, X, current_wavelet, level=1, start_level=2) # level < 1 in swt_axis call assert_raises(ValueError, swt_axis, X, current_wavelet, level=0, start_level=0) # odd-sized data not allowed assert_raises(ValueError, swt_axis, X[:-1, :], current_wavelet, level=0, start_level=0, axis=0)
def test_swtn_iswtn_integration(wavelets=None): # This function performs a round-trip swtn/iswtn transform for various # possible combinations of: # 1.) 1 out of 2 axes of a 2D array # 2.) 2 out of 3 axes of a 3D array # # To keep test time down, only wavelets of length <= 8 are run. # # This test does not validate swtn or iswtn individually, but only # confirms that iswtn yields an (almost) perfect reconstruction of swtn. max_level = 3 if wavelets is None: wavelets = pywt.wavelist(kind='discrete') if 'dmey' in wavelets: # The 'dmey' wavelet is a special case - disregard it for now wavelets.remove('dmey') for ndim_transform in range(1, 3): ndim = ndim_transform + 1 for axes in combinations(range(ndim), ndim_transform): for current_wavelet_str in wavelets: wav = pywt.Wavelet(current_wavelet_str) if wav.dec_len > 8: continue # avoid excessive test duration input_length_power = int( np.ceil(np.log2(max(wav.dec_len, wav.rec_len)))) N = 2**(input_length_power + max_level - 1) X = np.arange(N**ndim).reshape((N, ) * ndim) for norm in [True, False]: if norm and not wav.orthogonal: # non-orthogonal wavelets to avoid warnings continue for trim_approx in [True, False]: coeffs = pywt.swtn(X, wav, max_level, axes=axes, trim_approx=trim_approx, norm=norm) coeffs_copy = deepcopy(coeffs) Y = pywt.iswtn(coeffs, wav, axes=axes, norm=norm) assert_allclose(Y, X, rtol=1e-5, atol=1e-5) # verify the inverse transform didn't modify any coeffs for c, c2 in zip(coeffs, coeffs_copy): for k, v in c.items(): assert_array_equal(c2[k], v)
def test_swtn_variance_and_energy_preservation(): """Verify that the nD SWT partitions variance among the coefficients.""" # When norm is True and the wavelet is orthogonal, the sum of the # variances of the coefficients should equal the variance of the signal. wav = 'db2' rstate = np.random.RandomState(5) x = rstate.randn(64, 64) coeffs = pywt.swtn(x, wav, level=4, trim_approx=True, norm=True) coeff_list = [coeffs[0].ravel()] for d in coeffs[1:]: for k, v in d.items(): coeff_list.append(v.ravel()) variances = [np.var(v) for v in coeff_list] assert_allclose(np.sum(variances), np.var(x)) # also verify L2-norm energy preservation property assert_allclose(np.linalg.norm(x), np.linalg.norm(np.concatenate(coeff_list))) # non-orthogonal wavelet with norm=True raises a warning assert_warns(UserWarning, pywt.swtn, x, 'bior2.2', level=4, norm=True)
def direct_swt(self, x): """Perform the direct wavelet transform. :param x: Data to transform. :type x: `numpy.array_like` :return: Transformed data. :rtype: list """ if self.pad_on_demand is not None and np.any(self.pad_axes): for ax in np.nonzero(self.pad_axes)[0]: pad_l = np.ceil(self.pad_axes[ax] / 2).astype(np.intp) pad_h = np.floor(self.pad_axes[ax] / 2).astype(np.intp) pad_width = [(0, 0)] * len(x.shape) pad_width[self.axes[ax]] = (pad_l, pad_h) x = np.pad(x, pad_width, mode=self.pad_on_demand) return pywt.swtn(x, wavelet=self.wavelet, axes=self.axes, norm=self.normalized, level=self.level, trim_approx=True)
def test_swtn_iswtn_integration(wavelets=None): # This function performs a round-trip swtn/iswtn transform for various # possible combinations of: # 1.) 1 out of 2 axes of a 2D array # 2.) 2 out of 3 axes of a 3D array # # To keep test time down, only wavelets of length <= 8 are run. # # This test does not validate swtn or iswtn individually, but only # confirms that iswtn yields an (almost) perfect reconstruction of swtn. max_level = 3 if wavelets is None: wavelets = pywt.wavelist(kind='discrete') if 'dmey' in wavelets: # The 'dmey' wavelet is a special case - disregard it for now wavelets.remove('dmey') for ndim_transform in range(1, 3): ndim = ndim_transform + 1 for axes in combinations(range(ndim), ndim_transform): for current_wavelet_str in wavelets: wav = pywt.Wavelet(current_wavelet_str) if wav.dec_len > 8: continue # avoid excessive test duration input_length_power = int(np.ceil(np.log2(max( wav.dec_len, wav.rec_len)))) N = 2**(input_length_power + max_level - 1) X = np.arange(N**ndim).reshape((N, )*ndim) coeffs = pywt.swtn(X, wav, max_level, axes=axes) coeffs_copy = deepcopy(coeffs) Y = pywt.iswtn(coeffs, wav, axes=axes) assert_allclose(Y, X, rtol=1e-5, atol=1e-5) # verify the inverse transform didn't modify any coeffs for c, c2 in zip(coeffs, coeffs_copy): for k, v in c.items(): assert_array_equal(c2[k], v)
def denoise_and_compare_cubes(self, steady_cube, cube_with_transient): cube = cube_with_transient - steady_cube.mean(axis=0) coeffs = pywt.swtn( data=cube, wavelet='bior1.3', level=2, ) # remove noisy coefficents. ct = thresholding_3d(coeffs, k=30) cube_smoothed = pywt.iswtn(coeffs=ct, wavelet='bior1.3') # some Criterion which could be used to trigger this. trans_factor = cube_smoothed.max(axis=1).max(axis=1) # return trans_factor p = TransientPlotter( cube_with_transient, cube_smoothed, trans_factor, cmap='viridis', ) print('Plotting animation. (Be patient)') anim = animation.FuncAnimation( p.fig, p.step, frames=len(cube), interval=15, blit=True, ) anim.save('build/anim_{}.gif'.format(self.window.popleft()[0]), writer='imagemagick', fps=25) return trans_factor
imgPath = 'C:\\Users\\rites\\Desktop\\ProjectSubmit\\Input\\001_F.png' print('Path Imported') I = Image.open(imgPath) print('Image Imported') b = I.convert('YCbCr') print('Image Converted to YCbCr') y, cb, cr = b.split() [one, two, three] = pywt.swtn(y, 'db1', 3) print('SWT applied Successfully') [LL, LH, HL, HH] = three['aa'], three['ad'], three['da'], three['dd'] row, column = LL.shape print('Got LL(approximation) Band') C = [] #Block = np.zeros(8*8).reshape(8,8) #for i in range (1,(row-7)*(column-7)+1): # C.append(Block)
def time_swtn(self, D, n, wavelet, dtype): pywt.swtn(self.data, wavelet, self.level)
def fuse_focal_stack_kmax(images, *, k=None, levels=None, wavelet=None, pca=None, in_memory=None, sharpness_sigma=None): if k is None: k = 3 if levels is None: levels = 3 if wavelet is None: wavelet = 'sym4' if pca is None: pca = True if in_memory is None: in_memory = False if sharpness_sigma is None: sharpness_sigma = 3 k = min(k, len(images)) pad, unpad = swt_pad_funcs(images[0].shape, levels) sharpnesses = temporary_array_list( (sharpness(pad(image), sharpness_sigma, pca=pca) for image in images), in_memory=in_memory) kmax = kmax_sharpnesses(sharpnesses, k) bases = temporary_array_list() ads = [temporary_array_list() for _ in range(levels)] das = [temporary_array_list() for _ in range(levels)] dds = [temporary_array_list() for _ in range(levels)] for image in images: image = pad(image) shape = image.shape coeffs = pywt.swtn(image, wavelet, level=levels, axes=(0, 1), norm=True, trim_approx=True) bases.append(coeffs[0]) for level in range(levels): cl = coeffs[level + 1] ads[level].append(cl['ad']) das[level].append(cl['da']) dds[level].append(cl['dd']) base = np.empty_like(bases[0]) ad = [np.empty_like(ads[level][0]) for level in range(levels)] da = [np.empty_like(das[level][0]) for level in range(levels)] dd = [np.empty_like(dds[level][0]) for level in range(levels)] first = np.full(shape[:2], True) for i, s in enumerate(sharpnesses): mask = np.any(s[:, :, np.newaxis] == kmax, axis=2) mask_and_first = mask & first base[mask_and_first, ...] = bases[i][mask_and_first, ...] for level in range(levels): ad[level][mask_and_first, ...] = ads[level][i][mask_and_first, ...] da[level][mask_and_first, ...] = das[level][i][mask_and_first, ...] dd[level][mask_and_first, ...] = dds[level][i][mask_and_first, ...] del mask_and_first mask_and_not_first = mask & ~first base[mask_and_not_first, ...] += bases[i][mask_and_not_first, ...] for level in range(levels): cmask = ( (reduce_color_dimension(ads[level][i]**2) + reduce_color_dimension(das[level][i]**2) + reduce_color_dimension(dds[level][i]**2)) > (reduce_color_dimension(ad[level]**2) + reduce_color_dimension(da[level]**2) + reduce_color_dimension(dd[level]**2))) & mask_and_not_first ad[level][cmask, ...] = ads[level][i][cmask, ...] da[level][cmask, ...] = das[level][i][cmask, ...] dd[level][cmask, ...] = dds[level][i][cmask, ...] first[mask] = False base /= k coeffs = [base] + [ dict(ad=ad[level], da=da[level], dd=dd[level]) for level in range(levels) ] return unpad(pywt.iswtn(coeffs, wavelet, axes=(0, 1), norm=True))
def main(gamma_file, proton_file, output_file): bins = [80, 80] bin_range = [[62.5, 78.5], [-12.4, 12.4]] df_gammas = loadFile(gamma_file) df_protons = loadFile(proton_file) print('Read {} gammas and {} protons'.format(len(df_gammas), len(df_protons))) factor = (10E5 * len(df_gammas)) / len(df_protons) print(factor) df_background = df_protons[df_protons['prediction:signal:mean'] > 0.87] df_signal = df_gammas[df_gammas['prediction:signal:mean'] > 0.87] print('Read {} signal events and {} background events'.format( len(df_signal), len(df_background))) ratio = len(df_background) / len(df_signal) expected_background = int(ratio * len(df_background) * factor) print('Upsampling background to get {} events'.format(expected_background)) df_background = df_protons.sample(expected_background, replace=True) cube_background = create_cube(df_background.sample(frac=0.5), bins=bins, bin_range=bin_range) cube_gammas = create_cube(df_gammas.sample(frac=0.5), bins=bins, bin_range=bin_range) cube_steady = cube_background + cube_gammas cube_background = create_cube(df_background.sample(frac=0.5), bins=bins, bin_range=bin_range) cube_gammas = create_cube(df_gammas.sample(frac=0.5), bins=bins, bin_range=bin_range) cube_bright_gammas = create_cube(df_gammas, bins=bins, bin_range=bin_range) cube_with_transient = np.vstack( (cube_background + cube_gammas, cube_background + cube_bright_gammas)) # remove mean measured noise from current cube cube = cube_with_transient - cube_steady.mean(axis=0) coeffs = pywt.swtn( data=cube, wavelet='bior1.3', level=2, ) # remove noisy coefficents. ct = thresholding_3d(coeffs, k=30) cube_smoothed = pywt.iswtn(coeffs=ct, wavelet='bior1.3') # some Criterion which could be used to trigger this. trans_factor = cube_smoothed.max(axis=1).max(axis=1) p = TransientPlotter( cube_with_transient, cube_smoothed, trans_factor, cmap='viridis', ) print('Plotting animation. (Be patient)') anim = animation.FuncAnimation( p.fig, p.step, frames=len(cube), interval=15, blit=True, ) anim.save('anim.gif', writer='imagemagick', fps=25)
def compute_depth_map( depth_cues, iterations=500, lambda_tv=2.0, lambda_d2=0.05, lambda_wl=None, use_defocus=1.0, use_correspondence=1.0, use_xcorrelation=0.0, ): """Computes a depth map from the given depth cues. This depth map is based on the procedure from: M. W. Tao, et al., "Depth from combining defocus and correspondence using light-field cameras," in Proceedings of the IEEE International Conference on Computer Vision, 2013, pp. 673–680. :param depth_cues: The depth cues :type depth_cues: dict :param iterations: Number of iterations, defaults to 500 :type iterations: int, optional :param lambda_tv: Lambda value of the TV term, defaults to 2.0 :type lambda_tv: float, optional :param lambda_d2: Lambda value of the smoothing term, defaults to 0.05 :type lambda_d2: float, optional :param lambda_wl: Lambda value of the wavelet term, defaults to None :type lambda_wl: float, optional :param use_defocus: Weight of defocus cues, defaults to 1.0 :type use_defocus: float, optional :param use_correspondence: Weight of corresponence cues, defaults to 1.0 :type use_correspondence: float, optional :param use_xcorrelation: Weight of the cross-correlation cues, defaults to 0.0 :type use_xcorrelation: float, optional :raises ValueError: In case of requested wavelet regularization but not available :returns: The depth map :rtype: `numpy.array_like` """ if not (lambda_wl is None or (has_pywt and use_swtn)): raise ValueError("Wavelet regularization requested but not available") use_defocus = np.fmax(use_defocus, 0.0) use_defocus = np.fmin(use_defocus, 1.0) use_correspondence = np.fmax(use_correspondence, 0.0) use_correspondence = np.fmin(use_correspondence, 1.0) use_xcorrelation = np.fmax(use_xcorrelation, 0.0) use_xcorrelation = np.fmin(use_xcorrelation, 1.0) W_d = depth_cues["confidence_defocus"] a_d = depth_cues["depth_defocus"] W_c = depth_cues["confidence_correspondence"] a_c = depth_cues["depth_correspondence"] W_x = depth_cues["confidence_xcorrelation"] a_x = depth_cues["depth_xcorrelation"] if use_defocus > 0 and (W_d.size == 0 or a_d.size == 0): use_defocus = 0 warnings.warn("Defocusing parameters were not passed, disabling their use") if use_correspondence > 0 and (W_c.size == 0 or a_c.size == 0): use_correspondence = 0 warnings.warn("Correspondence parameters were not passed, disabling their use") if use_xcorrelation > 0 and (W_x.size == 0 or a_x.size == 0): use_xcorrelation = 0 warnings.warn("Cross-correlation parameters were not passed, disabling their use") if use_defocus: img_size = a_d.shape data_type = a_d.dtype elif use_correspondence: img_size = a_c.shape data_type = a_c.dtype elif use_xcorrelation: img_size = a_x.shape data_type = a_x.dtype else: raise ValueError("Cannot proceed if at least one of Defocus, Correspondence, and Cross-correlation cues can be used") if lambda_wl is not None and has_pywt is False: lambda_wl = None print("WARNING - wavelets selected but not available") depth = np.zeros(img_size, dtype=data_type) depth_it = depth q_g = np.zeros(np.concatenate(((2,), img_size)), dtype=data_type) tau = 4 * lambda_tv if lambda_d2 is not None: q_l = np.zeros(img_size, dtype=data_type) tau += 8 * lambda_d2 if use_defocus > 0: q_d = np.zeros(img_size, dtype=data_type) tau += W_d if use_correspondence > 0: q_c = np.zeros(img_size, dtype=data_type) tau += W_c if use_xcorrelation > 0: q_x = np.zeros(img_size, dtype=data_type) tau += W_x if lambda_wl is not None: wl_type = "sym4" wl_lvl = np.fmin(pywt.dwtn_max_level(img_size, wl_type), 2) print("Wavelets selected! Wl type: %s, Wl lvl %d" % (wl_type, wl_lvl)) q_wl = pywt.swtn(depth, wl_type, wl_lvl) tau += lambda_wl * (2 ** wl_lvl) sigma_wl = 1 / (2 ** np.arange(wl_lvl, 0, -1)) tau = 1 / tau for ii in range(iterations): (d0, d1) = _gradient2(depth_it) d_2 = np.stack((d0, d1)) / 2 q_g += d_2 grad_l2_norm = np.fmax(1, np.sqrt(np.sum(q_g ** 2, axis=0))) q_g /= grad_l2_norm update = -lambda_tv * _divergence2(q_g[0, :, :], q_g[1, :, :]) if lambda_d2 is not None: l_dep = _laplacian2(depth_it) q_l += l_dep / 8 q_l /= np.fmax(1, np.abs(q_l)) update += lambda_d2 * _laplacian2(q_l) if use_defocus > 0: q_d += depth_it - a_d q_d /= np.fmax(1, np.abs(q_d)) update += use_defocus * W_d * q_d if use_correspondence > 0: q_c += depth_it - a_c q_c /= np.fmax(1, np.abs(q_c)) update += use_correspondence * W_c * q_c if use_xcorrelation > 0: q_x += depth_it - a_x q_x /= np.fmax(1, np.abs(q_x)) update += use_xcorrelation * W_x * q_x if lambda_wl is not None: d = pywt.swtn(depth_it, wl_type, wl_lvl) for ii_l in range(wl_lvl): for k in q_wl[ii_l].keys(): q_wl[ii_l][k] += d[ii_l][k] * sigma_wl[ii_l] q_wl[ii_l][k] /= np.fmax(1, np.abs(q_wl[ii_l][k])) update += lambda_wl * pywt.iswtn(q_wl, wl_type) depth_new = depth - update * tau depth_it = depth_new + (depth_new - depth) depth = depth_new return depth