def batch_ISwt(batch): ''' Args: batch: Tensor of batch [16,h,w,12] Returns: Idwt_batch: Tensor of Inverse wavelet transform [16,h*2,w*2,3] ''' swt_batch = np.zeros([batch.shape[0], batch.shape[1], batch.shape[2], 3]) for i in range(batch.shape[0]): Iswt_R = pywt.iswt2( (batch[i, :, :, 0], (batch[i, :, :, 1], batch[i, :, :, 2], batch[i, :, :, 3])), wavelet='haar') Iswt_G = pywt.iswt2( (batch[i, :, :, 4], (batch[i, :, :, 5], batch[i, :, :, 6], batch[i, :, :, 7])), wavelet='haar') Iswt_B = pywt.iswt2( (batch[i, :, :, 8], (batch[i, :, :, 9], batch[i, :, :, 10], batch[i, :, :, 11])), wavelet='haar') coeffs = cv2.merge([Iswt_R, Iswt_G, Iswt_B]) swt_batch[i, :, :, :] = coeffs # print(coeffs.shape) return swt_batch
def iswt2d_rgb(approxs, details, wavelet='bior2.2'): approxs_b = [] approxs_g = [] approxs_r = [] details_b = [] details_g = [] details_r = [] coeffs_b = [] coeffs_g = [] coeffs_r = [] for i in range(0, len(approxs), 3): approxs_b.append(approxs[i]) approxs_g.append(approxs[i + 1]) approxs_r.append(approxs[i + 2]) for i in range(0, len(details), 3): details_b.append(details[i]) details_g.append(details[i + 1]) details_r.append(details[i + 2]) for i in range(0, len(approxs_b)): if i == 0: coeff_b = (details_b[0], details_b[1:4]) coeff_g = (details_g[0], details_g[1:4]) coeff_r = (details_r[0], details_r[1:4]) else: coeff_b = (approxs_b[i], details_b[1 + 3 * i:1 + 3 * (i + 1)]) coeff_g = (approxs_g[i], details_g[1 + 3 * i:1 + 3 * (i + 1)]) coeff_r = (approxs_r[i], details_r[1 + 3 * i:1 + 3 * (i + 1)]) coeffs_b.append(coeff_b) coeffs_g.append(coeff_g) coeffs_r.append(coeff_r) ch_b = pywt.iswt2(coeffs_b, wavelet=wavelet) ch_g = pywt.iswt2(coeffs_g, wavelet=wavelet) ch_r = pywt.iswt2(coeffs_r, wavelet=wavelet) # ch_b[ch_b > 255] = 255 # ch_b[ch_b < 0] = 0 # ch_g[ch_g > 255] = 255 # ch_g[ch_g < 0] = 0 # ch_r[ch_r > 255] = 255 # ch_r[ch_r < 0] = 0 # ch_b = ch_b.astype(np.uint8) # ch_g = ch_g.astype(np.uint8) # ch_r = ch_r.astype(np.uint8) img = np.dstack((ch_b, ch_g, ch_r)) return img
def batch_ISwt(batch): ''' Args: batch: Input batch RGB image [batch_size, img_h, img_w, 3] Returns: dwt_batch: Batch DWT result [batch_size, img_h, img_w, 12] ''' # print(len(batch.shape)) # assert (len(batch.shape) == 4 ),"Input batch Shape error" # assert (batch.shape[3] == 3 ),"Color channel error" Swt_batch = np.zeros([batch.shape[0], batch.shape[1], batch.shape[2], 3]) for i in range(batch.shape[0]): Iswt_level_1_R = (batch[i, :, :, 0], (batch[i, :, :, 1], batch[i, :, :, 2], batch[i, :, :, 3])) Iswt_level_2_R = (batch[i, :, :, 12], (batch[i, :, :, 13], batch[i, :, :, 14], batch[i, :, :, 15])) Iswt_level_1_G = (batch[i, :, :, 4], (batch[i, :, :, 5], batch[i, :, :, 6], batch[i, :, :, 7])) Iswt_level_2_G = (batch[i, :, :, 16], (batch[i, :, :, 17], batch[i, :, :, 18], batch[i, :, :, 19])) Iswt_level_1_B = (batch[i, :, :, 8], (batch[i, :, :, 9], batch[i, :, :, 10], batch[i, :, :, 11])) Iswt_level_2_B = (batch[i, :, :, 20], (batch[i, :, :, 21], batch[i, :, :, 22], batch[i, :, :, 23])) Iswt_R = pywt.iswt2([Iswt_level_2_R, Iswt_level_1_R], wavelet='haar') Iswt_G = pywt.iswt2([Iswt_level_2_G, Iswt_level_1_G], wavelet='haar') Iswt_B = pywt.iswt2([Iswt_level_2_B, Iswt_level_1_B], wavelet='haar') coeffs = cv2.merge([Iswt_R, Iswt_G, Iswt_B]) Swt_batch[i, :, :, :] = coeffs return Swt_batch
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 test_iswt2_mixed_dtypes(): # Mixed precision inputs give double precision output rstate = np.random.RandomState(0) x_real = rstate.randn(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.swt2(x, wav, 2) # different precision for the approximation coefficients coeffs[0] = [coeffs[0][0].astype(dtype1), tuple([c.astype(dtype2) for c in coeffs[0][1]])] y = pywt.iswt2(coeffs, wav) assert_equal(output_dtype, y.dtype) assert_allclose(y, x, rtol=1e-3, atol=1e-3)
def test_swt2_iswt2_integration(): # This function performs a round-trip swt2/iswt2 transform test on # all available types of wavelets in PyWavelets - except the # 'dmey' wavelet. The latter has been excluded because it does not # produce very precise results. This is likely due to the fact # that the 'dmey' wavelet is a discrete approximation of a # continuous wavelet. All wavelets are tested up to 3 levels. The # test validates neither swt2 or iswt2 as such, but it does ensure # that they are each other's inverse. max_level = 3 wavelets = pywt.wavelist() if 'dmey' in wavelets: # The 'dmey' wavelet seems to be a bit special - disregard it for now wavelets.remove('dmey') for current_wavelet_str in wavelets: current_wavelet = pywt.Wavelet(current_wavelet_str) input_length_power = int(np.ceil(np.log2(max( current_wavelet.dec_len, current_wavelet.rec_len)))) input_length = 2**(input_length_power + max_level - 1) X = np.arange(input_length**2).reshape(input_length, input_length) coeffs = pywt.swt2(X, current_wavelet, max_level) Y = pywt.iswt2(coeffs, current_wavelet) assert_allclose(Y, X, rtol=1e-5, atol=1e-5)
def _transform(self, image, channel=['r']): new_image = self._pad(image) wave = pywt.Wavelet(self._wavelet) cA_1, (cH_1, cV_1, cD_1) = pywt.swt2(new_image, wave, level=1, start_level=1)[0] if self._mode == 'rebuild': cA = np.zeros_like(cA_1) coeffs = ((cA, (cH_1, cV_1, cD_1)), ) reb_image = pywt.iswt2(coeffs, wave) channels = (channel, 'high_pass') return channels, (image, self._unpad(reb_image)) elif self._mode == 'features': channels = (channel, 'cH', 'cV', 'cD') return channels, (image, self._unpad(cH_1), self._unpad(cV_1), self._unpad(cD_1)) elif self._mode == 'features-all': channels = (channel, 'cA', 'cH', 'cV', 'cD') return channels, (image, self._unpad(cA_1), self._unpad(cH_1), self._unpad(cV_1), self._unpad(cD_1)) elif self._mode == 'features-only': channels = ('cA', 'cH', 'cV', 'cD') return channels, (self._unpad(cA_1), self._unpad(cH_1), self._unpad(cV_1), self._unpad(cD_1))
def wavelet_blend(left, right, shift_x, dx, f_x, wavelet, level): coeffs_left = pywt.swt2(left, wavelet, level) coeffs_right = pywt.swt2(right, wavelet, level) coeffs = [] for l, (cleft, cright) in enumerate(zip(coeffs_left, coeffs_right)): approx_left, details_left = cleft approx_right, details_right = cright # blend approximation x intersections inter_approx_left = approx_left[:, dx:] inter_approx_right = approx_right[:, :shift_x] inter_approx = f_x * inter_approx_left + (1 - f_x) * inter_approx_right approx = approx_right approx[:, :shift_x] = inter_approx # blend detail x intersections details = [] for dl, dr in zip(details_left, details_right): inter_dl = dl[:, dx:] inter_dr = dr[:, :shift_x] inter_detail = f_x * inter_dl + (1 - f_x) * inter_dr detail = dr detail[:, :shift_x] = inter_detail details.append(detail) coeffs.append((approx, tuple(details))) return pywt.iswt2(coeffs, wavelet)
def test_swt2_iswt2_integration(wavelets=None): # This function performs a round-trip swt2/iswt2 transform test on # all available types of wavelets in PyWavelets - except the # 'dmey' wavelet. The latter has been excluded because it does not # produce very precise results. This is likely due to the fact # that the 'dmey' wavelet is a discrete approximation of a # continuous wavelet. All wavelets are tested up to 3 levels. The # test validates neither swt2 or iswt2 as such, but it does ensure # that they are each other's inverse. 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 current_wavelet_str in wavelets: current_wavelet = pywt.Wavelet(current_wavelet_str) input_length_power = int(np.ceil(np.log2(max( current_wavelet.dec_len, current_wavelet.rec_len)))) input_length = 2**(input_length_power + max_level - 1) X = np.arange(input_length**2).reshape(input_length, input_length) coeffs = pywt.swt2(X, current_wavelet, max_level) Y = pywt.iswt2(coeffs, current_wavelet) assert_allclose(Y, X, rtol=1e-5, atol=1e-5)
def apply_wavelet(self,img): ################ADDED undecimated isotropic wavelet transform#################### import pywt #Interested in the Stationary Wavelet Transformation or a Trous or starlet (swt2) #get a median filter for wavelet transformation from scipy.signal import medfilt #Use skimage to create the background gaussian filter from scipy.ndimage.filters import gaussian_filter #check to see if image is a list if not make it one for convience unlist = False if not isinstance(img,list): img = [img] unlist = True #processed image list nimg = [] for j,i in enumerate(img): #Add wavelet transformation wav_img = i.data #degrade image for faster comp wav_img_low = self.shrink(wav_img,1024,1024)/16. d_size = 15 #get median filter n_back = medfilt(wav_img_low,kernel_size=d_size) #expand the median filter back to normal size n_back = np.repeat(n_back,4,axis=1) n_back = np.repeat(n_back,4,axis=0) n_back = gaussian_filter(n_back,2) #subtract median filter img_sub = wav_img-n_back #Use Biorthogonal Wavelet wavelet = 'bior2.6' #use 6 levels n_lev = 6 o_wav = pywt.swt2(img_sub, wavelet, level=n_lev ) #only use the first 4 (Will need to switch order sometime) f_img = pywt.iswt2(o_wav[0:4],wavelet) #Add wavelet back into image f_img = f_img+wav_img #store the new image and return nimg.append(sunpy.map.Map(f_img,i.meta)) #if it was only one file remove list attribute if unlist: nimg = nimg[0] return nimg
def test_swt2_iswt2_non_square(wavelets=None): for nrows in [8, 16, 48]: X = np.arange(nrows*32).reshape(nrows, 32) current_wavelet = 'db1' with warnings.catch_warnings(): warnings.simplefilter('ignore', FutureWarning) coeffs = pywt.swt2(X, current_wavelet, level=2) Y = pywt.iswt2(coeffs, current_wavelet) assert_allclose(Y, X, rtol=tol_single, atol=tol_single)
def get_swt(shape, wname, levels): """ returns stationary wavelet transforms for a given image shape """ # get slices for pywt array <--> coeff conversion coeffs = pywt.swt2(np.zeros(shape), wname, levels, trim_approx=True) _, swt_slices = coeffs_to_array(coeffs) # stationary/undecimated wavelet transform iswt = lambda x: pywt.iswt2(array_to_coeffs(x, swt_slices, 'wavedec2'), wname) swt = lambda x: coeffs_to_array( pywt.swt2(x, wname, levels, trim_approx=True))[0] return swt, iswt
def iswt2d(approxs, details, wavelet='bior2.2'): coeffs = [] for i in range(len(approxs)): if i == 0: coeff = (details[0], details[1:4]) else: coeff = (approxs[i], details[1 + 3 * i:1 + 3 * (i + 1)]) coeffs.append(coeff) img = pywt.iswt2(coeffs, wavelet=wavelet) return img
def _swt_norm(x, wavelet, level, p=2): """Computes the p-norm of the SWT detail coefficients of the input and its gradient.""" div = 2**math.ceil(math.log2(max(x.shape[1:]))) pw = pad_width(x.shape, (1, div, div)) x_pad = np.pad(x, pw, 'symmetric') inv = [] for ch in x_pad: coeffs = pywt.swt2(ch, wavelet, level) for a, _ in coeffs: a[...] = 0 inv.append(pywt.iswt2(coeffs, wavelet)[pw[1][0]:pw[1][0] + x.shape[1], pw[2][0]:pw[2][0] + x.shape[2]]) return p_norm(np.stack(inv), p)
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 _swt_norm(x, wavelet, level, p=2): """Computes the p-norm of the SWT detail coefficients of the input and its gradient.""" div = 2**math.ceil(math.log2(max(x.shape[1:]))) pw = pad_width(x.shape, (1, div, div)) x_pad = np.pad(x, pw, 'symmetric') inv = [] for ch in x_pad: coeffs = pywt.swt2(ch, wavelet, level) for a, _ in coeffs: a[:] = 0 inv.append( pywt.iswt2(coeffs, wavelet)[pw[1][0]:pw[1][0] + x.shape[1], pw[2][0]:pw[2][0] + x.shape[2]]) return p_norm(np.stack(inv), p)
def sharpenChannelLayers(params): c = g.coeffs # Go through each wavelet layer and apply sharpening cCopy = [] for i in range(1, len(c)): level = (len(c) - i - 1) # Copy the layer if a change is made to the coefficients if (params['level'][level] and (params['radius'][level] > 0 or params['sharpen'][level] > 0 or params['denoise'][level] > 0)): cCopy.append(copy.deepcopy(c[i])) else: cCopy.append(None) # Process Layers if (params['level'][level]): # Apply Unsharp Mask if (params['radius'][level] > 0): unsharp(c[i][0], params['radius'][level], 2) unsharp(c[i][1], params['radius'][level], 2) unsharp(c[i][2], params['radius'][level], 2) # Multiply the layer to increase intensity if (params['sharpen'][level] > 0): factor = (100 - 10 * level) cv2.add(c[i][0], c[i][0] * params['sharpen'][level] * factor, c[i][0]) cv2.add(c[i][1], c[i][1] * params['sharpen'][level] * factor, c[i][1]) cv2.add(c[i][2], c[i][2] * params['sharpen'][level] * factor, c[i][2]) # Denoise if (params['denoise'][level] > 0): unsharp(c[i][0], params['denoise'][level], -1) unsharp(c[i][1], params['denoise'][level], -1) unsharp(c[i][2], params['denoise'][level], -1) # Reconstruction padding = 2**(Sharpen.LEVEL) img = iswt2(c, 'haar') # Reset coefficients for i in range(1, len(c)): if (cCopy[i - 1] is not None): c[i] = cCopy[i - 1] # Prepare image for saving img = img[padding:, padding:] return (g.channel, img)
def main(): noise_sigma = 2 wavelet = 'bior1.3' images = list(io.load_fits_images_in_folder('./resources')) with PdfPages('multipage.pdf') as pdf: for i, (calibrated_image, npe_truth) in tqdm(enumerate(images)): fig = plt.figure() plt.text(1, 1, 'Event Number: {}'.format(i)) plt.xlim(0, 2) plt.ylim(0, 2) plt.axis('off') pdf.savefig(fig) plt.close() # transform the image level = pywt.swt_max_level(len(calibrated_image)) # print('maximum level of decomposition: {}'.format(level)) coeff_list = pywt.swt2(calibrated_image, wavelet, level) fig = plot.coefficients(coeff_list) pdf.savefig(figure=fig) plt.close() levels = [0.889, 0.7, 0.586] coeff_list = denoise.thresholding(coeff_list, sigma_d=noise_sigma, kind='hard', sigma_levels=levels) # coeff_list = denoise.wiener(coeff_list) reconstructed_image = pywt.iswt2(coeff_list, wavelet) fig = plot.results(calibrated_image, reconstructed_image, npe_truth) pdf.savefig(figure=fig) plt.close() fig = plot.pixel_histogram( reconstructed_image, calibrated_image, npe_truth, labels=['reconstructed', 'calibrated', 'npe mc truth'], bins=60) pdf.savefig(figure=fig) plt.close()
def test_swt_roundtrip_dtypes(): # verify perfect reconstruction for all dtypes rstate = np.random.RandomState(5) wavelet = pywt.Wavelet('haar') for dt_in, dt_out in zip(dtypes_in, dtypes_out): # swt, iswt x = rstate.standard_normal((8, )).astype(dt_in) c = pywt.swt(x, wavelet, level=2) xr = pywt.iswt(c, wavelet) assert_allclose(x, xr, rtol=1e-6, atol=1e-7) # swt2, iswt2 x = rstate.standard_normal((8, 8)).astype(dt_in) c = pywt.swt2(x, wavelet, level=2) xr = pywt.iswt2(c, wavelet) assert_allclose(x, xr, rtol=1e-6, atol=1e-7)
def shrink(img, lev=4, shrink_type='bayes', thresh_type='hard', k=1): # convert to float data = np.asarray(img) data = np.float32(data) # swt c = pywt.swt2(data, 'bior4.4', level=lev, trim_approx=True) # algorithm choosing if shrink_type == 'visu': d = visushrink(c, lev, thresh_type, k) elif shrink_type == 'sure': d = sureshrink(c, lev, thresh_type) elif shrink_type == 'bayes': d = bayesshrink(c, lev, thresh_type, k) else: d = c img_denoised = pywt.iswt2(d, 'bior4.4') img_denoised = np.clip(img_denoised, 0, 255) return img_denoised
def fienup(anc_vec, con_upp, con_low): # initial guess rec_vec = anc_vec for inn_itr in range(INN_ITR): # copy cpy_vec = cp.deepcopy(rec_vec) # thresholding rec_vec = pw.swt2(rec_vec, QMF, DLV, norm=True) for d in range(DLV): # LL rec_vec[d] = list(rec_vec[d]) rec_vec[d][0] = pw.threshold(rec_vec[d][0], REG_PRM) # LH, HL, and HH rec_vec[d][1] = list(rec_vec[d][1]) rec_vec[d][1][0] = pw.threshold(rec_vec[d][1][0], REG_PRM) rec_vec[d][1][1] = pw.threshold(rec_vec[d][1][1], REG_PRM) rec_vec[d][1][2] = pw.threshold(rec_vec[d][1][2], REG_PRM) rec_vec = pw.iswt2(rec_vec, QMF, DLV) # proximal mapping for inner product rec_vec = rec_vec + PEN_PRM * anc_vec # projection rec_vec = bdct2(rec_vec) rec_vec = np.minimum(rec_vec, con_upp) rec_vec = np.maximum(rec_vec, con_low) rec_vec = bidct2(rec_vec) # acceleration rec_vec = rec_vec + (inn_itr - 1) * (rec_vec - cpy_vec) / (inn_itr + 2) return rec_vec
def iswt2(self): """ Test pypwt for DWT2 reconstruction (iswt2). """ W = self.W # inverse DWT with pypwt W.forward() logging.info("computing Wavelets.inverse from pypwt") t0 = time() W.inverse() logging.info("Wavelets.inverse took %.3f ms" % elapsed_ms(t0)) if self.do_pywt: # inverse DWT with pywt Wpy = pywt.swt2(self.data, self.wname, level=self.levels) logging.info("computing iswt2 from pywt") _ = pywt.iswt2(Wpy, self.wname) logging.info("pywt took %.3f ms" % elapsed_ms(t0)) # Check reconstruction W_image = W.image maxerr = _calc_errors(self.data, W_image, "[rec]") self.assertTrue(maxerr < self.tol, msg="[%s] something wrong with the reconstruction (errmax = %e)" % (self.wname, maxerr))
V2L1 = np.float32(HL) D2L1 = np.float32(HH) #Fusion start AfL1 = 0.5 * (A1L1 + A2L1) D = (np.abs(H1L1) - np.abs(H2L1)) >= 0 HfL1 = np.multiply(D, H1L1) + np.multiply(np.logical_not(D), H2L1) D = (np.abs(V1L1) - np.abs(V2L1)) >= 0 VfL1 = np.multiply(D, V1L1) + np.multiply(np.logical_not(D), V2L1) D = (np.abs(D1L1) - np.abs(D2L1)) >= 0 DfL1 = np.multiply(D, D1L1) + np.multiply(np.logical_not(D), D2L1) #For inverse swt2 (iswt2) coeffs3 = AfL1, (HfL1, VfL1, DfL1) imf = np.uint8(pywt.iswt2(coeffs3, 'db2')) #Display images plt.figure(dpi=200) plt.subplot(121) plt.imshow(img1, cmap='gray') plt.subplot(122) plt.imshow(img2, cmap='gray') plt.savefig('inputs.png', dpi=200) plt.show() plt.figure(dpi=200) plt.imshow(imf, cmap='gray') plt.savefig('output.png') plt.show()
def sw(img_path, wavelet='haar', level=1): img1 = Image.open(img_path[0]).convert('RGB') img2 = Image.open(img_path[1]).convert('RGB') x = np.array(img1) y = np.array(img2) img_1 = cv2.cvtColor(x, cv2.COLOR_RGB2BGR) img_2 = cv2.cvtColor(y, cv2.COLOR_RGB2BGR) img_2 = cv2.resize(y, (img_1.shape[0], img_1.shape[1])) Red_Input_Image1 = img_1[:, :, 0] Green_Input_Image1 = img_1[:, :, 1] Blue_Input_Image1 = img_1[:, :, 2] LAr1, LDr1 = pywt.swt2(Red_Input_Image1, wavelet=wavelet, level=level, norm=True)[0] LAg1, LDg1 = pywt.swt2(Green_Input_Image1, wavelet=wavelet, level=level, norm=True)[0] LAb1, LDb1 = pywt.swt2(Blue_Input_Image1, wavelet=wavelet, level=level, norm=True)[0] Red_Input_Image2 = img_2[:, :, 0] Green_Input_Image2 = img_2[:, :, 1] Blue_Input_Image2 = img_2[:, :, 2] LAr2, LDr2 = pywt.swt2(Red_Input_Image2, wavelet=wavelet, level=level, norm=True)[0] LAg2, LDg2 = pywt.swt2(Green_Input_Image2, wavelet=wavelet, level=level, norm=True)[0] LAb2, LDb2 = pywt.swt2(Blue_Input_Image2, wavelet=wavelet, level=level, norm=True)[0] LAr = np.add(LAr1, LAr2) LAg = np.add(LAg1, LAg2) LAb = np.add(LAb1, LAb2) LDr = np.add(LDr1, LDr2) / 2 LDg = np.add(LDg1, LDg2) / 2 LDb = np.add(LDb1, LDb2) / 2 R = pywt.iswt2((LAr, LDr), wavelet=wavelet) G = pywt.iswt2((LAg, LDg), wavelet=wavelet) B = pywt.iswt2((LAb, LDb), wavelet=wavelet) imgx = np.zeros([R.shape[0], R.shape[1], 3], dtype=np.uint8) imgx[:, :, 0] = R imgx[:, :, 1] = G imgx[:, :, 2] = B return imgx
def make_images(f): global wav, img_scale, wx, wy, h0, w0, sdir #try to make the image. If it fails just move on try: #width of ind. image img_w = w0 / len(wav) if wx > wy: img_wx = wx / len(wav) img_wy = wy else: img_wy = wy / len(wav) img_wx = wx wavelet = False #read all images into sunpy maps img = sunpy.map.Map(*f) #output file outfi = sdir + '/working/panel_{0}'.format( img[0].date.strftime('%Y%m%d_%H%M%S')) + '.png' #skip if file exists exit if os.path.isfile(outfi): return #dictionary of images img_dict = {} scale = {} scale_list = [] #create new image new_img = Image.new('RGB', (w0, h0)) #image size of subwindow sub_img_size = (img_w, h0) #put parameters in a series of dictionaries for j, i in enumerate(img): #create image position based on index if j == 0: px, py = 0, 0 elif j == 2: px, py = 0, 1024 elif j == 1: px, py = 1024, 0 elif j == 3: px, py = 1024, 1024 #color mapping icmap = img_scale[wav[j]][0] ivmin = img_scale[wav[j]][1] ivmax = img_scale[wav[j]][2] #keep list of scale scale = [i.scale[0].value, i.scale[1].value] #set up for wavelet analysis wav_img = i.data f_img = wav_img #do wavelet analysis if wavelet: d_size = 15 * 4 + 1 #get median filter n_back = medfilt(wav_img, kernel_size=d_size) #subtract median filter img_sub = wav_img - n_back #Use Biorthogonal Wavelet wavelet = 'bior2.6' #use 6 levels n_lev = 6 o_wav = pywt.swt2(img_sub, wavelet, level=n_lev) #only use the first 4 f_img = pywt.iswt2(o_wav[0:4], wavelet) #Add wavelet back into image f_img = f_img + wav_img #remove zero values f_img[f_img < 0.] = 0. #do normalization b_img = (np.arcsinh(f_img) - ivmin) / (ivmax - ivmin) #format image with color scale img_n = np.array(b_img) #if greater than 1 set to 0.99 img_n[img_n > 0.99] = 0.99 #print(wav[j],img_n.max(),f_img.max(),np.percentile(f_img,[5.,99])) #img_n[img_n < -.2] = 0.99 img_n[img_n < 0.] = 0. img_n = icmap(img_n) img_n = np.uint8(img_n * 255) if img_n.max() > 255: print(img_n.max()) print(img[0].date.strftime('%Y%m%d_%H%M%S')) img_n = Image.fromarray(img_n) img_dict[wav[j]] = img_n #resize image to img0 scale img_n = img_n.resize((1024, 1024)) #default image size old_size = img_n.size horizontal_padding = (1024 - old_size[0]) / 2 vertical_padding = (1024 - old_size[1]) / 2 temp_img = img_n.crop((-horizontal_padding, -vertical_padding, old_size[0] + horizontal_padding, old_size[1] + vertical_padding)) #Add image to array of images new_img.paste(temp_img, (px, py)) #set scale for plotting #observed time obs_time = img[0].date #write on text w_text = '{0:%Y/%m/%d %H:%M:%S} '.format(obs_time) #add wavelengths for i in wav: w_text += str(int(i)) + u'\u212B/' #remove final / w_text = w_text[:-1] #Add text of datetime to image draw = ImageDraw.Draw(new_img) draw.text((10, 10), w_text, (255, 255, 255), font=font) #save image new_img.save(outfi) except: pass
def format_img(i): global goes, goesdat, sday, eday global aceadat, ace ## try: filep = dayarray[i] #output file # outfi = sdir+'/working/seq{0:4d}.png'.format(i).replace(' ','0') outfi = filep.replace('raw', 'working').replace('fits', 'png') test = os.path.isfile(outfi) #check image quality check, img = qual_check(filep) #test to see if bmpfile exists if ((test == False) & (check)): print('Modifying file ' + filep) img = sunpy.map.Map(filep) fig, ax = plt.subplots(figsize=(sc * float(w0) / float(dpi), sc * float(h0) / float(dpi))) fig.set_dpi(dpi) fig.subplots_adjust(left=0, bottom=0, right=1, top=1) ax.set_axis_off() #ax.imshow(img.data,interpolation='none',cmap=cm.sdoaia193,vmin=0,vmax=255,origin='lower') # J. Prchlik 2016/10/06 #Modified for fits files # ax.imshow(np.arcsinh(img.data),interpolation='none',cmap=cm.sdoaia193,vmin=np.arcsinh(70.),vmax=np.arcsinh(7500.),origin='lower') #Block add J. Prchlik (2016/10/06) to give physical coordinate values #return extent of image maxx, minx, maxy, miny = img_extent(img) #Add wavelet transformation J. Prchlik 2018/01/17 wav_img = img.data d_size = 15 #get median filter n_back = medfilt(wav_img, kernel_size=d_size) #subtract median filter img_sub = wav_img - n_back #Use Biorthogonal Wavelet wavelet = 'bior2.6' #use 6 levels n_lev = 6 o_wav = pywt.swt2(img_sub, wavelet, level=n_lev) #only use the first 4 #f_img = pywt.iswt2(o_wav[0:4],wavelet) #use last four because PyWavelet switched the ordering f_img = pywt.iswt2(o_wav[-4:], wavelet) #Add wavelet back into image f_img = f_img + wav_img #remove zero values f_img[f_img < 0.] = 0. #plot the image in matplotlib # ax.imshow(img.data,interpolation='none',cmap=cm.sdoaia193,vmin=0,vmax=255,origin='lower',extent=[minx,maxx,miny,maxy]) #ax.imshow(np.arcsinh(f_img),interpolation='none',cmap=cm.sdoaia193,origin='lower',vmin=np.arcsinh(5.),vmax=np.arcsinh(7500.),extent=[minx,maxx,miny,maxy]) #switch to 0.25 power #increase v_min to 33. ax.imshow((f_img)**0.25, interpolation='none', cmap=cm.sdoaia193, origin='lower', vmin=(15.)**0.25, vmax=(3500.)**0.25, extent=[minx, maxx, miny, maxy]) # ax.set_axis_bgcolor('black') ax.text(-2000, -1100, 'AIA 193 - ' + img.date.strftime('%Y/%m/%d - %H:%M:%S') + 'Z', color='white', fontsize=36, zorder=50, fontweight='bold') if goes: #format string for date on xaxis myFmt = mdates.DateFormatter('%m/%d') #only use goes data upto observed time use, = np.where((goesdat['time_dt'] < img.date + dt(minutes=150)) & (goesdat['Long'] > 0.0)) clos, = np.where((goesdat['time_dt'] < img.date) & (goesdat['Long'] > 0.0)) ingoes = inset_axes( ax, width="27%", height="20%", loc=7, borderpad=-27) #hack so it is outside normal boarders ingoes.set_position(Bbox([[0.525, 0.51], [1.5, 1.48]])) ingoes.set_facecolor('black') #set inset plotting information to be white ingoes.tick_params(axis='both', colors='white') ingoes.spines['top'].set_color('white') ingoes.spines['bottom'].set_color('white') ingoes.spines['right'].set_color('white') ingoes.spines['left'].set_color('white') #make grid ingoes.grid(color='gray', ls='dashdot') ingoes.xaxis.set_major_formatter(myFmt) ingoes.set_ylim([1.E-9, 1.E-2]) ingoes.set_xlim([sday, eday]) ingoes.set_ylabel( 'X-ray Flux (1-8$\mathrm{\AA}$) [Watts m$^{-2}$]', color='white') ingoes.set_xlabel('Universal Time', color='white') try: ingoes.plot(goesdat['time_dt'][use], goesdat['Long'][use], color='white') ingoes.scatter(goesdat['time_dt'][clos][-1], goesdat['Long'][clos][-1], color='red', s=10, zorder=1000) except: print('No GOES data') ingoes.set_yscale('log') #plot ace information if ((ace) & (goes)): use, = np.where((aceadat['time_dt'] < img.date + dt(minutes=150)) & (aceadat['S_1'] == 0.0) & (aceadat['S_2'] == 0) & (aceadat['Speed'] > -1000.)) clos, = np.where((aceadat['time_dt'] < img.date) & (aceadat['S_1'] == 0) & (aceadat['S_2'] == 0) & (aceadat['Speed'] > -1000)) acetop = inset_axes(ingoes, width='100%', height='100%', loc=9, borderpad=-27) acebot = inset_axes(ingoes, width='100%', height='100%', loc=8, borderpad=-27) #set inset plotting information to be white acetop.tick_params(axis='both', colors='white') acetop.spines['top'].set_color('white') acetop.spines['bottom'].set_color('white') acetop.spines['right'].set_color('white') acetop.spines['left'].set_color('white') #set inset plotting information to be white acebot.tick_params(axis='both', colors='white') acebot.spines['top'].set_color('white') acebot.spines['bottom'].set_color('white') acebot.spines['right'].set_color('white') acebot.spines['left'].set_color('white') #make grid acebot.grid(color='gray', ls='dashdot') acetop.grid(color='gray', ls='dashdot') acetop.set_facecolor('black') acebot.set_facecolor('black') acetop.set_ylim([0., 50.]) acebot.set_ylim([200., 1000.]) acetop.set_xlim([sday, eday]) acebot.set_xlim([sday, eday]) acetop.set_xlabel('Universal Time', color='white') acebot.set_xlabel('Universal Time', color='white') acetop.set_ylabel('B$_\mathrm{T}$ [nT]', color='white') acebot.set_ylabel('Wind Speed [km/s]', color='white') #skip missing ace solar wind data try: acetop.plot(aceadat['time_dt'][use], aceadat['Bt'][use], color='white') acebot.plot(aceadat['time_dt'][use], aceadat['Speed'][use], color='white') acetop.scatter(aceadat['time_dt'][clos][-1], aceadat['Bt'][clos][-1], color='red', s=10, zorder=1000) acebot.scatter(aceadat['time_dt'][clos][-1], aceadat['Speed'][clos][-1], color='red', s=10, zorder=1000) except: print('Missing ACE data') acebot.xaxis.set_major_formatter(myFmt) acetop.xaxis.set_major_formatter(myFmt) ## ax.set_axis_bgcolor('black') # ax.text(-1000,175,'AIA 193 - '+img.date.strftime('%Y/%m/%d - %H:%M:%S')+'Z',color='white',fontsize=36,zorder=50,fontweight='bold') fig.savefig(outfi, edgecolor='black', facecolor='black', dpi=dpi) plt.clf() plt.close() ## except: ## print 'Unable to create {0}'.format(outfi) return
def add_aia_image(stime, ax, tries=4): file_fmt = '{0:%Y/%m/%d/H%H00/AIA%Y%m%d_%H%M_}' tries = 4 wave = [193] gsf.download(stime, stime + datetime.timedelta(minutes=tries), datetime.timedelta(minutes=1), '', nproc=1, syn_arch='http://jsoc.stanford.edu/data/aia/synoptic/', f_dir=file_fmt, d_wav=wave) #Decide which AIA file to overplot nofile = True run = 0 while nofile: testfile = file_fmt.format(stime + datetime.timedelta( minutes=run)) + '{0:04d}.fits'.format(wave[0]) #exit once you find the file if os.path.isfile(testfile): filep = testfile nofile = False run += 1 #exit after tries if run == tries + 1: nofile = False img = sunpy.map.Map(filep) #Block add J. Prchlik (2016/10/06) to give physical coordinate values #return extent of image maxx, minx, maxy, miny = img_extent(img) #Add wavelet transformation J. Prchlik 2018/01/17 wav_img = img.data d_size = 15 #get median filter n_back = medfilt(wav_img, kernel_size=d_size) #subtract median filter img_sub = wav_img - n_back #Use Biorthogonal Wavelet wavelet = 'bior2.6' #use 6 levels n_lev = 6 o_wav = pywt.swt2(img_sub, wavelet, level=n_lev) #only use the first 4 f_img = pywt.iswt2(o_wav[0:4], wavelet) #Add wavelet back into image f_img = f_img + wav_img #remove zero values f_img[f_img < 0.] = 0. #set alpha values only works with png file 2018/05/02 J. Prchlik #alphas = np.ones(f_img.shape) #alphas[:,:] = np.linspace(1,0,f_img.shape[0]) colors = Normalize((15.)**0.25, (3500.)**0.25, clip=True) #img_193 = cmap((f_img)**0.25) img_193 = cm.sdoaia193(colors((f_img)**0.25)) #get radius values and convert to arcsec mesh_x2, mesh_y2 = np.meshgrid(np.arange(img.data.shape[0]), np.arange(img.data.shape[1])) mesh_x2 = mesh_x2.T * (maxx - minx) / f_img.shape[0] + minx mesh_y2 = mesh_y2.T * (maxy - miny) / f_img.shape[1] + miny #mask out less than a solar radius rsun = sunpy.sun.solar_semidiameter_angular_size( t=img.meta['date-obs'][:-1].replace('T', ' ')).value r2 = np.sqrt(mesh_x2**2 + mesh_y2**2) / rsun rmin = .98 rfad = 1.02 rep2 = (r2 < rmin) rep3 = ((r2 > rmin) & (r2 < rfad)) #set alpha values img_193[..., 3][rep2] = 0 img_193[..., 3][rep3] = (r2[rep3] - rmin) / (rfad - rmin) #plot the image in matplotlib ax.imshow(img_193, interpolation='none', cmap=cm.sdoaia193, origin='lower', vmin=(15.)**0.25, vmax=(3500.)**0.25, extent=[minx, maxx, miny, maxy], zorder=0) return ax
def adjoint(self, point: array) -> array: return pywt.iswt2(self.cube2coeffs(point), self.wlt, norm=self.norm)
def time_iswt2(self, n, wavelet): pywt.iswt2(self.data, wavelet)
def udDTCWTLvl1Inv(coeffsAll, lvl1Filters): AA_LL = coeffsAll[1][0] AB_LL = coeffsAll[1][1] BA_LL = coeffsAll[1][2] BB_LL = coeffsAll[1][3] (coeffs0, coeffs1, coeffs2, coeffs3, coeffs4, coeffs5) = coeffsAll[0] fac = np.sqrt(0.5) AA_HH = fac * (np.real(coeffs4) + np.real(coeffs1)) AA_LH = fac * (np.real(coeffs0) + np.real(coeffs5)) AA_HL = fac * (np.real(coeffs2) + np.real(coeffs3)) BB_HH = fac * (np.real(coeffs4) - np.real(coeffs1)) BB_LH = fac * (np.real(coeffs0) - np.real(coeffs5)) BB_HL = fac * (np.real(coeffs2) - np.real(coeffs3)) AB_HH = fac * (np.imag(coeffs1) + np.imag(coeffs4)) AB_LH = fac * (np.imag(coeffs5) + np.imag(coeffs0)) AB_HL = fac * (np.imag(coeffs3) + np.imag(coeffs2)) BA_HH = fac * (np.imag(coeffs1) - np.imag(coeffs4)) BA_LH = fac * (np.imag(coeffs5) - np.imag(coeffs0)) BA_HL = fac * (np.imag(coeffs3) - np.imag(coeffs2)) # pad the lvl 0 filters lvl1Len = np.max((lvl1Filters[0].shape[0], lvl1Filters[1].shape[0], lvl1Filters[2].shape[0], lvl1Filters[3].shape[0])) fac = 1.0 h0o = np.roll( np.pad(fac * lvl1Filters[0][::1, 0], [3, 3], mode='constant')[::1], 1).tolist() g0o = np.roll( np.pad(fac * lvl1Filters[1][::1, 0], [0, 0], mode='constant')[::1], 0).tolist() h1o = np.roll( np.pad(fac * lvl1Filters[2][::1, 0], [0, 0], mode='constant')[::1], 1).tolist() g1o = np.roll( np.pad(fac * lvl1Filters[3][::1, 0], [3, 3], mode='constant')[::1], 0).tolist() hsd = 1 lvl1WvtA = pywt.Wavelet('lvl1', filter_bank=[ np.roll(h0o, 0), np.roll(h1o, 0), np.roll(g0o, 0), np.roll(g1o, 0) ]) #g0o,g1o]) lvl1WvtB = pywt.Wavelet('lvl1', filter_bank=[ np.roll(h0o, 1), np.roll(h1o, 1), np.roll(g0o, 1), np.roll(g1o, 1) ]) # Undecimated "a trous" transform tree AA swtCoeffs = (AA_LL, (AA_LH, AA_HL, AA_HH)) AA_LL = pywt.iswt2((swtCoeffs, ), wavelet=(lvl1WvtA, lvl1WvtA)) # Undecimated "a trous" transform tree AB swtCoeffs = (AB_LL, (AB_LH, AB_HL, AB_HH)) AB_LL = pywt.iswt2((swtCoeffs, ), wavelet=(lvl1WvtA, lvl1WvtB)) # Undecimated "a trous" transform tree BA swtCoeffs = (BA_LL, (BA_LH, BA_HL, BA_HH)) BA_LL = pywt.iswt2((swtCoeffs, ), wavelet=(lvl1WvtB, lvl1WvtA)) # Undecimated "a trous" transform tree BB swtCoeffs = (BB_LL, (BB_LH, BB_HL, BB_HH)) BB_LL = pywt.iswt2((swtCoeffs, ), wavelet=(lvl1WvtB, lvl1WvtB)) return (AA_LL, AB_LL, BA_LL, BB_LL)
def udDTCWTLvl2Inv(coeffsAll, lvl2Filters): AA_LL = coeffsAll[1][0] AB_LL = coeffsAll[1][1] BA_LL = coeffsAll[1][2] BB_LL = coeffsAll[1][3] nLevels = len(coeffsAll[0]) # Index zero is the lvl1 part of the transform # So iterate down to index 1 and no further. for iLev in range(nLevels - 1, 0, -1): (coeffs0, coeffs1, coeffs2, coeffs3, coeffs4, coeffs5) = coeffsAll[0][iLev] fac = np.sqrt(0.5) AA_HH = fac * (np.real(coeffs4) + np.real(coeffs1)) AA_LH = fac * (np.real(coeffs0) + np.real(coeffs5)) AA_HL = fac * (np.real(coeffs2) + np.real(coeffs3)) BB_HH = fac * (np.real(coeffs4) - np.real(coeffs1)) BB_LH = fac * (np.real(coeffs0) - np.real(coeffs5)) BB_HL = fac * (np.real(coeffs2) - np.real(coeffs3)) AB_HH = fac * (np.imag(coeffs1) + np.imag(coeffs4)) AB_LH = fac * (np.imag(coeffs5) + np.imag(coeffs0)) AB_HL = fac * (np.imag(coeffs3) + np.imag(coeffs2)) BA_HH = fac * (np.imag(coeffs1) - np.imag(coeffs4)) BA_LH = fac * (np.imag(coeffs5) - np.imag(coeffs0)) BA_HL = fac * (np.imag(coeffs3) - np.imag(coeffs2)) # phi (0) h0a = lvl2Filters[0][:, 0] h0b = lvl2Filters[1][:, 0] g0a = lvl2Filters[2][:, 0] g0b = lvl2Filters[3][:, 0] # psi (1) h1a = lvl2Filters[4][:, 0] h1b = lvl2Filters[5][:, 0] g1a = lvl2Filters[6][:, 0] g1b = lvl2Filters[7][:, 0] # On the first and future iterations, insert extra '0' between filter coefficients # This is to account for lack of decimation, a la "a trous". # The pywavelets swt2 already does this but this accounts for previous iterations. for iiLev in range( 0, iLev): #upscale once for lvl 1, twice for lvl 2, e.t.c. h0a = upscaleFilter(h0a) h0b = upscaleFilter(h0b) h1a = upscaleFilter(h1a) h1b = upscaleFilter(h1b) g0a = upscaleFilter(g0a) g0b = upscaleFilter(g0b) g1a = upscaleFilter(g1a) g1b = upscaleFilter(g1b) # What is the half-sample delay offset? hsd = 2**iLev if iLev % 2 == 0: lvl2WvtA = pywt.Wavelet('lvl2a', filter_bank=[ np.roll(h0a, 0), np.roll(h1a, 0), np.roll(g0a, hsd), np.roll(g1a, hsd) ]) lvl2WvtB = pywt.Wavelet('lvl2b', filter_bank=[ np.roll(h0b, hsd), np.roll(h1b, hsd), np.roll(g0b, 0), np.roll(g1b, 0) ]) else: lvl2WvtB = pywt.Wavelet('lvl2b', filter_bank=[ np.roll(h0a, 0), np.roll(h1a, 0), np.roll(g0a, hsd), np.roll(g1a, hsd) ]) lvl2WvtA = pywt.Wavelet('lvl2a', filter_bank=[ np.roll(h0b, hsd), np.roll(h1b, hsd), np.roll(g0b, 0), np.roll(g1b, 0) ]) # Undecimated "a trous" transform tree AA swtCoeffs = (AA_LL, (AA_LH, AA_HL, AA_HH)) AA_LL = np.roll(np.roll(pywt.iswt2((swtCoeffs, ), wavelet=(lvl2WvtA, lvl2WvtA)), -1, axis=0), -1, axis=1) # Undecimated "a trous" transform tree AB swtCoeffs = (AB_LL, (AB_LH, AB_HL, AB_HH)) AB_LL = np.roll(np.roll(pywt.iswt2((swtCoeffs, ), wavelet=(lvl2WvtA, lvl2WvtB)), -1, axis=0), -1, axis=1) # Undecimated "a trous" transform tree BA swtCoeffs = (BA_LL, (BA_LH, BA_HL, BA_HH)) BA_LL = np.roll(np.roll(pywt.iswt2((swtCoeffs, ), wavelet=(lvl2WvtB, lvl2WvtA)), -1, axis=0), -1, axis=1) # Undecimated "a trous" transform tree BB swtCoeffs = (BB_LL, (BB_LH, BB_HL, BB_HH)) BB_LL = np.roll(np.roll(pywt.iswt2((swtCoeffs, ), wavelet=(lvl2WvtB, lvl2WvtB)), -1, axis=0), -1, axis=1) return (AA_LL, AB_LL, BA_LL, BB_LL)