def test_data_reconstruction_delete_nodes_2d(): x = np.array([[1, 2, 3, 4, 5, 6, 7, 8]] * 8, dtype=np.float64) wp = pywt.WaveletPacket2D(data=x, wavelet='db1', mode='sym') new_wp = pywt.WaveletPacket2D(data=None, wavelet='db1', mode='sym') new_wp['vh'] = wp['vh'].data new_wp['vv'] = wp['vh'].data new_wp['vd'] = np.zeros((2, 2), dtype=np.float64) new_wp['a'] = [[3.0, 7.0, 11.0, 15.0]] * 4 new_wp['d'] = np.zeros((4, 4), dtype=np.float64) new_wp['h'] = wp['h'] # all zeros assert_allclose(new_wp.reconstruct(update=False), np.array([[1.5, 1.5, 3.5, 3.5, 5.5, 5.5, 7.5, 7.5]] * 8), rtol=1e-12) new_wp['va'] = wp['va'].data assert_allclose(new_wp.reconstruct(update=False), x, rtol=1e-12) del(new_wp['va']) new_wp['va'] = wp['va'].data assert_(new_wp.data is None) assert_allclose(new_wp.reconstruct(update=True), x, rtol=1e-12) assert_allclose(new_wp.data, x, rtol=1e-12)
def filt(array, channel='a'): import pywt if array.ndim == 3: abc = [] for k in range(3): wp = pywt.WaveletPacket2D(data=array[:, :, k], wavelet='db1', mode='symmetric') abc.append(wp[channel].data) return np.stack(abc, axis=2) else: wp = pywt.WaveletPacket2D(data=array, wavelet='db1', mode='symmetric') return wp[channel].data
def wavelete_packet2D(img_name): img = np.array(Image.open(img_name).convert('L')) rows, cols = img.shape plt.figure(img_name) plt.imshow(img, cmap='gray') # plt.axis('off') plt.show() # show the original image # use 2D wavelete db1 mode='symmetric' wp = pywt.WaveletPacket2D(data=img, wavelet='db2', mode='symmetric') # show a - LL, low-low coefficients plt.imshow((wp['a'].data), cmap='gray') plt.show() # show h - LH, low-high coefficients plt.imshow((wp['h'].data), cmap='gray') plt.show() # show v - HL, high-low coefficients plt.imshow((wp['v'].data), cmap='gray') plt.show() # show d - HH, high-high coefficients plt.imshow((wp['d'].data), cmap='gray') plt.show()
def test_collecting_nodes_2d(): x = np.array([[1, 2, 3, 4, 5, 6, 7, 8]] * 8, dtype=np.float64) wp = pywt.WaveletPacket2D(data=x, wavelet='db1', mode='sym') assert_(len(wp.get_level(0)) == 1) assert_(wp.get_level(0)[0].path == '') # First level assert_(len(wp.get_level(1)) == 4) assert_([node.path for node in wp.get_level(1)] == ['a', 'h', 'v', 'd']) # Second level assert_(len(wp.get_level(2)) == 16) paths = [node.path for node in wp.get_level(2)] expected_paths = ['aa', 'ah', 'av', 'ad', 'ha', 'hh', 'hv', 'hd', 'va', 'vh', 'vv', 'vd', 'da', 'dh', 'dv', 'dd'] assert_(paths == expected_paths) # Third level. assert_(len(wp.get_level(3)) == 64) paths = [node.path for node in wp.get_level(3)] expected_paths = ['aaa', 'aah', 'aav', 'aad', 'aha', 'ahh', 'ahv', 'ahd', 'ava', 'avh', 'avv', 'avd', 'ada', 'adh', 'adv', 'add', 'haa', 'hah', 'hav', 'had', 'hha', 'hhh', 'hhv', 'hhd', 'hva', 'hvh', 'hvv', 'hvd', 'hda', 'hdh', 'hdv', 'hdd', 'vaa', 'vah', 'vav', 'vad', 'vha', 'vhh', 'vhv', 'vhd', 'vva', 'vvh', 'vvv', 'vvd', 'vda', 'vdh', 'vdv', 'vdd', 'daa', 'dah', 'dav', 'dad', 'dha', 'dhh', 'dhv', 'dhd', 'dva', 'dvh', 'dvv', 'dvd', 'dda', 'ddh', 'ddv', 'ddd'] assert_(paths == expected_paths)
def getWaveletComplexShiftData(img, wf='rbio3.1', mo='periodization', log=False, Type=0): '''input: img: image data should in range [0,1] with shape [2x,2y] wf: wavelet family, default is rbio3.1 mo: mode of wavelet family, default is periodization log: whether return the complex data for logging Type: 0 performs waveletPacket2D first, then performs fft, output with shape [x, y, 2]; 1 only performs fft, output with shape [2x, 2y, 2]. 3 perform the logarithm of absolute fft, output with shape [2x, 2y] return: return wavelet complex shift data with m x n x 2 shape, where the wavelet data is the sum of 'v' 'h' 'd' components. ''' #wc=np.fft.fft2(img) without wavelet decomposing if Type==3: wc=np.fft.fft2(img)# without wavelet decomposing wcs=np.fft.fftshift(wc) wcs=np.log(np.abs(wcs)) twcs=wcs.real twcs=np.reshape(twcs, [twcs.shape[0], twcs.shape[1], 1]) if Type==0: wave=pywt.WaveletPacket2D(data=img, wavelet=wf, mode=mo) wst=np.add(np.add(wave['h'].data, wave['v'].data), wave['d'].data) wc=np.fft.fft2(wst) wcs=np.fft.fftshift(wc) twcs=np.stack((wcs.real, wcs.imag), axis=2) elif Type==1: wc=np.fft.fft2(img)# without wavelet decomposing wcs=np.fft.fftshift(wc) twcs=np.stack((wcs.real, wcs.imag), axis=2) if log: return (twcs, np.hstack((wcs.real, wcs.imag))) return (twcs, None)
def attack_rotate_v2(angle, orgimgspatial, Xdelta): noisyspatial = rotate(orgimgspatial, angle) wp = pywt.WaveletPacket2D(data=noisyspatial, wavelet='db4') noisyimg = wp['aaa'].data # Attacked NOT WMked Image noisyimgwm = noisyimg + np.reshape(Xdelta, noisyimg.shape, order='F') # Attacked WMked Image return noisyimgwm, noisyimg
def procChanPacket(img, wavelet, nLevels): wt = pywt.WaveletPacket2D(img, wavelet=wavelet, maxlevel=nLevels) fv = [] wts = wt.decompose() for item in wts: item.walk(lambda node: processPacketNode(node=node, fv=fv)) return fv
def _compare_trees2( wavelet_str: str, max_lev: int, pywt_boundary: str = "zero", ptwt_boundary: str = "zero", height: int = 256, width: int = 256, batch_size: int = 1, transform_mode: bool = False, multiple_transforms: bool = False, ): face = misc.face()[:height, :width] face = np.mean(face, axis=-1).astype(np.float64) wavelet = pywt.Wavelet(wavelet_str) batch_list = [] for _ in range(batch_size): wp_tree = pywt.WaveletPacket2D( data=face, wavelet=wavelet, mode=pywt_boundary, maxlevel=max_lev, ) # Get the full decomposition wp_keys = list(product(["a", "h", "v", "d"], repeat=wp_tree.maxlevel)) np_packets = [] for node in wp_keys: np_packet = wp_tree["".join(node)].data np_packets.append(np_packet) np_packets = np.stack(np_packets, 0) batch_list.append(np_packets) batch_np_packets = np.stack(batch_list, 0) # get the PyTorch decomposition pt_data = torch.stack([torch.from_numpy(face)] * batch_size, 0) if transform_mode: ptwt_wp_tree = WaveletPacket2D(None, wavelet=wavelet, mode=ptwt_boundary).transform( pt_data, max_level=max_lev) else: ptwt_wp_tree = WaveletPacket2D(pt_data, wavelet=wavelet, mode=ptwt_boundary, max_level=max_lev) # if multiple_transform flag is set, recalculcate the packets if multiple_transforms: ptwt_wp_tree.transform(pt_data, max_level=max_lev) packets = [] for node in wp_keys: packet = ptwt_wp_tree["".join(node)] packets.append(packet) packets_pt = torch.stack(packets, 1).numpy() assert wp_tree.maxlevel == ptwt_wp_tree.max_level assert np.allclose(packets_pt, batch_np_packets)
def sp_project(image, weights, wavelet='bior4.4', mode='periodization', max_lev=1, rho=0.02): """ Projects weights onto top rho% of the support of image (in the wavelet basis). :param image: Should be in the range [-1, 1] and of shape [num_features] where num_features is a perfect square. :param weights: Should be of shape [num_features]. :param rho: Sparsity level, in the range [0, 1]. :param wavelet: Wavelet to use in the transform. See https://pywavelets.readthedocs.io/ for more details. :param mode: Signal extension mode. See https://pywavelets.readthedocs.io/ for more details. :param max_lev: Maximum allowed level of decomposition. """ num_features = image.shape[0] num_features_per_dim = np.int(np.sqrt(num_features)) image = 0.5 * image.reshape([num_features_per_dim, num_features_per_dim ]) + 0.5 wp = pywt.WaveletPacket2D(image, wavelet, mode, max_lev) paths = [node.path for node in wp.get_level(max_lev)] m = wp[paths[0]].data.shape[0] l = (4**max_lev) * m * m k = np.floor(rho * l).astype('int') n = l - k coeffs = np.zeros(l) for j in range(4**max_lev): coeffs[j * m * m:(j + 1) * m * m] = wp[paths[j]].data.flatten() indices = np.argpartition(np.abs(coeffs), n)[:n] wp_w = pywt.WaveletPacket2D( weights.reshape(num_features_per_dim, num_features_per_dim), wavelet, mode, max_lev) paths_w = [node.path for node in wp_w.get_level(max_lev)] coeffs_w = np.zeros(l) for j in range(4**max_lev): coeffs_w[j * m * m:(j + 1) * m * m] = wp_w[paths_w[j]].data.flatten() coeffs_w_proj = coeffs_w.copy() coeffs_w_proj[indices] = 0 for i2 in range(4**max_lev): wp_w[paths_w[i2]].data = coeffs_w_proj[i2 * m * m:(i2 + 1) * m * m].reshape([m, m]) weights_proj = wp_w.reconstruct(update=False).astype('float32').flatten() return weights_proj
def test_2d_roundtrip(): # test case corresponding to PyWavelets issue 447 original = pywt.data.camera() wp = pywt.WaveletPacket2D(data=original, wavelet='db3', mode='smooth', maxlevel=3) r = wp.reconstruct() assert_allclose(original, r, atol=1e-12, rtol=1e-12)
def emg_dwpt2d(signal, wavelet_name='db1'): wavelet_level = 3 wp = pywt.WaveletPacket2D(signal, wavelet_name, mode='sym') coeffs = [] level_coeff = wp.get_level(wavelet_level) for i in range(len(level_coeff)): coeffs.append(level_coeff[i].data.flatten()) coeffs = np.hstack(coeffs) # coeffs = coeffs.flatten() return coeffs
def aa(): # img = eng.read_img(LEAN_IMG) # img_array = np.array([list(ii) for ii in img]) # pkl.dump(img_array, open(PKL_IMG_ARRAY, 'wb')) img_array = pkl.load(open(PKL_IMG_ARRAY, 'rb')) wp = pywt.WaveletPacket2D(data=img_array, wavelet='bior4.4', maxlevel=9) # py_dwt = pywt.wavedec2(img_array, 'bior4.4') return wp
def test_lazy_evaluation_2D(): # Note: internal implementation detail not to be relied on. Testing for # now for backwards compatibility, but this test may be broken in needed. x = np.array([[1, 2, 3, 4, 5, 6, 7, 8]] * 8) wp = pywt.WaveletPacket2D(data=x, wavelet='db1', mode='sym') assert_(wp.a is None) assert_allclose(wp['a'].data, np.array([[3., 7., 11., 15.]] * 4), rtol=1e-12) assert_allclose(wp.a.data, np.array([[3., 7., 11., 15.]] * 4), rtol=1e-12) assert_allclose(wp.d.data, np.zeros((4, 4)), rtol=1e-12, atol=1e-12)
def get_WaveletDataC3(img, wf='rbio3.1', mo='periodization'): '''input: img: image data should in range [0,1] with shape [2x,2y] wf: wavelet family, default is rbio3.1 mo: mode of wavelet family, default is periodization return: return wavelet data with m x n x 3 shape, where the wavelet data is the stacks of 'v' 'h' 'd' components. ''' wave=pywt.WaveletPacket2D(data=img, wavelet=wf, mode=mo) wst=np.stack([wave['h'].data,wave['v'].data,wave['d'].data], axis=-1) return wst
def init_dwt(resume=None, shape=None, wave=None, colors=None): size = None wp_fake = pywt.WaveletPacket2D(data=np.zeros(shape[2:]), wavelet='db1', mode='symmetric') xfm = DWTForward(J=wp_fake.maxlevel, wave=wave, mode='symmetric').cuda() # xfm = DTCWTForward(J=lvl, biort='near_sym_b', qshift='qshift_b').cuda() # 4x more params, biort ['antonini','legall','near_sym_a','near_sym_b'] ifm = DWTInverse(wave=wave, mode='symmetric').cuda() # symmetric zero periodization # ifm = DTCWTInverse(biort='near_sym_b', qshift='qshift_b').cuda() # 4x more params, biort ['antonini','legall','near_sym_a','near_sym_b'] if resume is None: # random init Yl_in, Yh_in = xfm(torch.zeros(shape).cuda()) Ys = [torch.randn(*Y.shape).cuda() for Y in [Yl_in, *Yh_in]] elif isinstance(resume, str): if os.path.isfile(resume): if os.path.splitext(resume)[1].lower()[1:] in [ 'jpg', 'png', 'tif', 'bmp' ]: img_in = imread(resume) Ys = img2dwt(img_in, wave=wave, colors=colors) print(' loaded image', resume, img_in.shape, 'level', len(Ys) - 1) size = img_in.shape[:2] wp_fake = pywt.WaveletPacket2D(data=np.zeros(size), wavelet='db1', mode='symmetric') xfm = DWTForward(J=wp_fake.maxlevel, wave=wave, mode='symmetric').cuda() else: Ys = torch.load(resume) Ys = [y.detach().cuda() for y in Ys] else: print(' Snapshot not found:', resume) exit() else: Ys = [y.cuda() for y in resume] # print('level', len(Ys)-1, 'low freq', Ys[0].cpu().numpy().shape) return Ys, xfm, ifm, size
def enhance_puncta(img, level=7): """ Removing low frequency wavelet signals to enhance puncta. Dependent on image size, try level 6~8. """ if level == 0: return img wp = pywt.WaveletPacket2D(data=img, wavelet='haar', mode='sym') back = resize( np.array(wp['d' * level].data), img.shape, order=3, mode='reflect') / (2**level) cimg = img - back cimg[cimg < 0] = 0 return cimg
def test_accessing_node_atributes_2d(): x = np.array([[1, 2, 3, 4, 5, 6, 7, 8]] * 8, dtype=np.float64) wp = pywt.WaveletPacket2D(data=x, wavelet='db1', mode='sym') assert_allclose(wp['av'].data, np.zeros((2, 2)) - 4, rtol=1e-12) assert_(wp['av'].path == 'av') assert_(wp['av'].node_name == 'v') assert_(wp['av'].parent.path == 'a') assert_allclose(wp['av'].parent.data, np.array([[3., 7., 11., 15.]] * 4), rtol=1e-12) assert_(wp['av'].level == 2) assert_(wp['av'].maxlevel == 3) assert_(wp['av'].mode == 'sym')
def img2dwt(img_in, wave='coif2', sharp=0.3, colors=1.): image_t = un_rgb(img_in, colors=colors) with torch.no_grad(): wp_fake = pywt.WaveletPacket2D(data=np.zeros(image_t.shape[2:]), wavelet='db1', mode='zero') lvl = wp_fake.maxlevel # print(image_t.shape, lvl) xfm = DWTForward(J=lvl, wave=wave, mode='symmetric').cuda() Yl_in, Yh_in = xfm(image_t.cuda()) Ys = [Yl_in, *Yh_in] scale = dwt_scale(Ys, sharp) for i in range(len(Ys) - 1): Ys[i + 1] /= scale[i] return Ys
def getWaveletData(img, wf='rbio3.1', mo='periodization'): '''input: img: image data should in range [0,1] with shape [2x,2y] wf: wavelet family, default is rbio3.1 mo: mode of wavelet family, default is periodization log: whether return the complex data for logging return: return wavelet data with m x n shape, where the wavelet data is the sum of 'v' 'h' 'd' components. ''' #wc=np.fft.fft2(img) without wavelet decomposing wave=pywt.WaveletPacket2D(data=img, wavelet=wf, mode=mo) wst=np.add(np.add(wave['h'].data, wave['v'].data), wave['d'].data) wst=np.reshape(wst, [wst.shape[0], wst.shape[1], 1]) return wst
def localfeature(seg): ll2 = [] lh1 = [] hl1 = [] hh1 = [] dwvt = [] ht = [] vt = [] for i in range(16): wp = pywt.WaveletPacket2D(data=seg[i], wavelet='haar', mode='sym') lh1.append(wp['v'].data) hl1.append(wp['h'].data) hh1.append(wp['d'].data) level1 = np.hstack((np.vstack((wp['aa'].data, wp['vv'].data)), np.vstack((wp['hh'].data, wp['dd'].data)))) level2 = np.hstack((np.vstack((wp['aaa'].data, wp['vvv'].data)), np.vstack((wp['hhh'].data, wp['ddd'].data)))) level3 = np.hstack((np.vstack((wp['aaaa'].data, wp['vvvv'].data)), np.vstack((wp['hhhh'].data, wp['dddd'].data)))) level4 = np.hstack((np.vstack((wp['aaaaa'].data, wp['vvvvv'].data)), np.vstack((wp['hhhhh'].data, wp['ddddd'].data)))) level3[:8, :8] = level4 level2[:16, :16] = level3 level1[:32, :32] = level2 ll2.append(level1) vt.append(np.vstack((ll2[i], lh1[i]))) ht.append(np.vstack((hl1[i], hh1[i]))) dwvt.append(np.hstack((vt[i], ht[i]))) s1 = [] s2 = [] s3 = [] s4 = [] subvector = [] vector = [] for i in range(16): s1.append(np.linalg.svd(ll2[i], compute_uv=False)) s2.append(np.linalg.svd(hl1[i], compute_uv=False)) s3.append(np.linalg.svd(lh1[i], compute_uv=False)) s4.append(np.linalg.svd(hh1[i], compute_uv=False)) subvector.append( np.vstack((np.vstack((s1[i], s2[i])), np.vstack((s3[i], s4[i]))))) vector.append(subvector[i]) vector1 = np.concatenate(vector, axis=0) vector1 = np.array(vector1, dtype=int) return vector1
def test_wavelet_packet_dtypes(): shape = (16, 16) for dtype in [np.float32, np.float64, np.complex64, np.complex128]: x = np.random.randn(*shape).astype(dtype) if np.iscomplexobj(x): x = x + 1j * np.random.randn(*shape).astype(x.real.dtype) wp = pywt.WaveletPacket2D(data=x, wavelet='db1', mode='symmetric') # no unnecessary copy made assert_(wp.data is x) # assiging to a node should not change supported dtypes wp['d'] = wp['d'].data assert_equal(wp['d'].data.dtype, x.dtype) # full decomposition wp.get_level(wp.maxlevel) # reconstruction from coefficients should preserve dtype r = wp.reconstruct(False) assert_equal(r.dtype, x.dtype) assert_allclose(r, x, atol=1e-5, rtol=1e-5)
def test_freq_order(level, wavelet_str, pywt_boundary): """Test the packets in frequency order.""" face = misc.face() wavelet = pywt.Wavelet(wavelet_str) wp_tree = pywt.WaveletPacket2D( data=np.mean(face, axis=-1).astype(np.float64), wavelet=wavelet, mode=pywt_boundary, ) # Get the full decomposition freq_tree = wp_tree.get_level(level, "freq") freq_order = get_freq_order(level) for order_list, tree_list in zip(freq_tree, freq_order): for order_el, tree_el in zip(order_list, tree_list): print( level, order_el.path, "".join(tree_el), order_el.path == "".join(tree_el), ) assert order_el.path == "".join(tree_el)
def sp_frontend(images, rho=0.02, wavelet='bior4.4', mode='periodization', max_lev=1): """ Sparsifies input in the wavelet basis (using the PyWavelets package) and returns reconstruction. :param images: Should be in the range [-1, 1] and of shape [num_samples, num_features] where num_features is a perfect square. :param rho: Sparsity level, in the range [0, 1]. :param wavelet: Wavelet to use in the transform. See https://pywavelets.readthedocs.io/ for more details. :param mode: Signal extension mode. See https://pywavelets.readthedocs.io/ for more details. :param max_lev: Maximum allowed level of decomposition. """ num_samples = images.shape[0] num_features = images.shape[1] num_features_per_dim = np.int(np.sqrt(num_features)) images_sp = images.copy() for i in range(num_samples): image = 0.5 * images[i, :].reshape(num_features_per_dim, num_features_per_dim) + 0.5 wp = pywt.WaveletPacket2D(image, wavelet, mode, max_lev) paths = [node.path for node in wp.get_level(max_lev)] m = wp[paths[0]].data.shape[0] l = (4**max_lev) * m * m k = np.floor(rho * l).astype('int') n = l - k coeffs = np.zeros(l) for j in range(4**max_lev): coeffs[j * m * m:(j + 1) * m * m] = wp[paths[j]].data.flatten() indices = np.argpartition(np.abs(coeffs), n)[:n] coeffs[indices] = 0 for j in range(4**max_lev): wp[paths[j]].data = coeffs[j * m * m:(j + 1) * m * m].reshape( [m, m]) image_r = wp.reconstruct(update=False).astype('float32') image_r = 2.0 * np.clip(image_r, 0.0, 1.0) - 1.0 images_sp[i, :] = image_r.flatten() return images_sp
def test_traversing_tree_2d(): x = np.array([[1, 2, 3, 4, 5, 6, 7, 8]] * 8, dtype=np.float64) wp = pywt.WaveletPacket2D(data=x, wavelet='db1', mode='sym') assert_(np.all(wp.data == x)) assert_(wp.path == '') assert_(wp.level == 0) assert_(wp.maxlevel == 3) assert_allclose(wp['a'].data, np.array([[3., 7., 11., 15.]] * 4), rtol=1e-12) assert_allclose(wp['h'].data, np.zeros((4, 4)), rtol=1e-12, atol=1e-14) assert_allclose(wp['v'].data, -np.ones((4, 4)), rtol=1e-12, atol=1e-14) assert_allclose(wp['d'].data, np.zeros((4, 4)), rtol=1e-12, atol=1e-14) assert_allclose(wp['aa'].data, np.array([[10., 26.]] * 2), rtol=1e-12) assert_(wp['a']['a'].data is wp['aa'].data) assert_allclose(wp['aaa'].data, np.array([[36.]]), rtol=1e-12) assert_raises(IndexError, lambda: wp['aaaa']) assert_raises(ValueError, lambda: wp['f'])
import cv2 import pywt import numpy as np import matplotlib.pyplot as plt from PIL import Image import os dir = os.path.dirname(__file__) foldername = os.path.join(dir, 'Images') os.chdir(foldername) image = cv2.imread('BPF.jpg') gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) cv2.imwrite('gray_image.png', gray_image) x = np.asarray(Image.open("gray_image.png").convert("L")) wp = pywt.WaveletPacket2D(data=x, wavelet='db1', mode='sym') plt.title("Original Image") plt.imshow(wp.data, plt.cm.gray) # plot original image plt.show() limith = 25 limitv = 20 limitd = 20 zh = wp['h'].data zh[zh < limith] = 0.0 plt.title("Horizontal") plt.imshow(zh, plt.cm.gray) # plot horizontal decomposition of image plt.show() zv = wp['v'].data
def tentDetection_wt_mm(strInputFile, maxTentArea, strOutputFile, strShape='box', iThresh_coeff=0): import pywt import pymorph as pymm objImg = osgeo.gdal.Open(strInputFile, GA_ReadOnly) nRasterCount = objImg.RasterCount poDataset = objImg.ReadAsArray().astype(np.float) geotransform = objImg.GetGeoTransform() pixelWidth = np.fabs(geotransform[1]) pixelHeight = np.fabs(geotransform[5]) resolution = pixelWidth * pixelHeight # NoDataValue = objImg.GetRasterBand(1).GetNoDataValue() # gray scale image if (nRasterCount == 1): objnImg = pymm.to_int32(poDataset) # RGB image elif (nRasterCount == 3): objnImg = pymm.to_gray(poDataset) else: print 'it only supports gray-scale or RGB image' sys.exit(1) # determine the structure element iNum = int(np.sqrt(maxTentArea) / resolution) + 1 if (strShape == 'box'): objStructureElement = pymm.sebox(iNum) elif (strShape == 'cross'): objStructureElement = pymm.secross(iNum) else: objStructureElement = pymm.sedisk(iNum) # decomposition until 1 level wp = pywt.WaveletPacket2D(data=objnImg, wavelet='db4', mode='sym', maxlevel=1) # iMaxLevel = wp.maxlevel() # top-hat wp['h'].data = pymm.openrecth(pymm.to_int32(wp['h'].data), objStructureElement, objStructureElement) wp['v'].data = pymm.openrecth(pymm.to_int32(wp['v'].data), objStructureElement, objStructureElement) wp['d'].data = pymm.openrecth(pymm.to_int32(wp['d'].data), objStructureElement, objStructureElement) wp['a'].data = 0.5 * wp['a'].data # reconstruction wp.reconstruct(update=True) # top-hat for reconstructed image objtophat = pymm.openrecth(pymm.to_int32(wp.data), objStructureElement, objStructureElement) # y = mean + k*std (minValue, maxValue, meanValue, stdValue) = objImg.GetRasterBand(1).GetStatistics(0, 1) if (nRasterCount == 3): (minValue2, maxValue2, meanValue2, stdValue2) = objImg.GetRasterBand(2).GetStatistics(0, 1) (minValue3, maxValue3, meanValue3, stdValue3) = objImg.GetRasterBand(3).GetStatistics(0, 1) meanValue = 0.2989 * meanValue + 0.5870 * meanValue2 + 0.1140 * meanValue3 maxValue = 0.2989 * maxValue + 0.5870 * maxValue2 + 0.1140 * maxValue3 # meanValue = 438 # maxValue = 2047 threshad = meanValue + iThresh_coeff * stdValue objTent = pymm.threshad(objtophat, stdValue, maxValue) data_list = [] data_list.append(objTent) WriteOutputImage(strOutputFile, 1, data_list, 0, 0, 0, strInputFile)
def GetFeatures(input_img): #input_img_name = "../images/10045.jpg" features = {} I_rgb_in = input_img #cv2.imread(input_img_name)[:,:,::-1] scaler = np.min([800.0 / I_rgb_in.shape[0], 800.0 / I_rgb_in.shape[1]]) I_rgb = cv2.resize(I_rgb_in, (np.int( scaler * I_rgb_in.shape[1]), np.int(scaler * I_rgb_in.shape[0])), interpolation=cv.CV_INTER_AREA) print I_rgb_in.shape, "->", I_rgb.shape #assert isinstance(I_rgb, np.ndarray), "Filename %s is not valid" % input_img_name I_rgb = remove_border(I_rgb) I_hsv = cv2.cvtColor(I_rgb, cv.CV_RGB2HSV) I_h = I_hsv[:, :, 0] I_h_rad = I_h.flatten() * np.pi / 180.0 I_s = I_hsv[:, :, 1] features['isGray'] = np.all(I_s == 0) I_v = I_hsv[:, :, 2] I_g = cv2.cvtColor(I_rgb, cv.CV_RGB2GRAY) nrows = I_rgb.shape[0] ncols = I_rgb.shape[1] rows1thrd = np.int(np.floor(nrows * 1.0 / 3.0)) rows2thrd = np.int(np.floor(nrows * 2.0 / 3.0)) cols1thrd = np.int(np.floor(ncols * 1.0 / 3.0)) cols2thrd = np.int(np.floor(ncols * 2.0 / 3.0)) rows1thrd_o = np.int(rows1thrd - np.floor(nrows / 20.0)) rows2thrd_o = np.int(rows2thrd + np.floor(nrows / 20.0)) cols1thrd_o = np.int(cols1thrd - np.floor(ncols / 20.0)) cols2thrd_o = np.int(cols2thrd + np.floor(ncols / 20.0)) rows1thrd_i = np.int(rows1thrd + np.floor(nrows / 20.0)) rows2thrd_i = np.int(rows2thrd - np.floor(nrows / 20.0)) cols1thrd_i = np.int(cols1thrd + np.floor(ncols / 20.0)) cols2thrd_i = np.int(cols2thrd - np.floor(ncols / 20.0)) I_zRoT = np.zeros_like(I_g) I_zRoT[rows1thrd_o:rows2thrd_o, cols1thrd_o:cols2thrd_o] = 1 I_zRoT[rows1thrd_i:rows2thrd_i, cols1thrd_i:cols2thrd_i] = 0 sm = pySaliencyMap.pySaliencyMap(ncols, nrows) saliencymap = sm.SMGetSM(I_rgb) features['Salience_mu'] = np.mean(saliencymap) # 0-1 features['Salience_med'] = np.median(saliencymap) # 0-1 features['Salience_var'] = np.var(saliencymap) # 0-1 features['SubjLighting_Hue'] = np.log( circstat.mean(I_h[saliencymap >= 0.2] * np.pi / 180.0) / circstat.mean(I_h * np.pi / 180.0)) features['SubjLighting_Saturation'] = np.log( np.mean(I_s[saliencymap >= 0.2]) / np.mean(I_s)) features['SubjLighting_Value'] = np.log( np.mean(I_v[saliencymap >= 0.2]) / np.mean(I_v)) features['Blurriness'] = BlurDetection.blur_detector(I_rgb)[1] features['ComplementaryColorIndex'] = np.abs( np.exp(2 * I_h_rad * 1j).sum() / len(I_h_rad)) # dutta f4 features['Hue_mu'] = circstat.mean(I_h_rad) * 180.0 / np.pi features['Hue_var'] = circstat.var(I_h_rad) * 180.0 / np.pi # dutta f3 features['Saturation_mu'] = np.mean(I_s) / 255.0 features['Saturation_var'] = np.var(I_s / 255.0) # dutta f1 features['Value_mu'] = np.mean(I_v) / 255.0 features['Value_var'] = np.var(I_v / 255.0) # dutta f2 features['Colorfulness'] = emd.getColorfulness(I_rgb, 8) # dutta f5 - circularized features['Rule_of_Thirds_Hue'] = circstat.mean( I_h[rows1thrd:rows2thrd, cols1thrd:cols2thrd] * np.pi / 180.0) * 180.0 / np.pi # dutta f6 features['Rule_of_Thirds_Saturation'] = np.mean( I_s[rows1thrd:rows2thrd, cols1thrd:cols2thrd] / 255.0) # dutta f7 features['Rule_of_Thirds_Value'] = np.mean( I_v[rows1thrd:rows2thrd, cols1thrd:cols2thrd] / 255.0) features['Rule_of_Thirds_Salience'] = np.sum( saliencymap[I_zRoT == 1]) / np.sum(I_zRoT) (maskr, maskc) = np.where(I_zRoT) (maxsr, maxsc) = np.where(saliencymap == np.max(saliencymap)) features['Rule_of_Thirds_Distance'] = np.min([ np.sqrt(((maxsc[0] - maskc[i]) / np.float(ncols))**2 + ((maxsr[0] - maskr[i]) / np.float(nrows))**2) for i in range(len(maskr)) ]) / np.sqrt(2) # dutta f8/f9 - Familiarity Metric - Requires Knn clustering of a large dataset. # # dutta f10-12 wpH = pywt.WaveletPacket2D(data=I_h, wavelet='db1', mode='zpd', maxlevel=3) for ii in xrange(3): whh = wpH['d' * ii].data whl = wpH['v' * ii].data wlh = wpH['h' * ii].data Sk = np.linalg.norm(whh, 2) + np.linalg.norm(whl, 2) + np.linalg.norm( wlh, 2) features["Wavelet_hue_%d" % ii] = (whh.sum() + whl.sum() + wlh.sum()) / Sk # dutta f13-15 wpS = pywt.WaveletPacket2D(data=I_s, wavelet='db1', mode='zpd', maxlevel=3) for ii in xrange(3): whh = wpS['d' * ii].data whl = wpS['v' * ii].data wlh = wpS['h' * ii].data Sk = np.linalg.norm(whh, 2) + np.linalg.norm(whl, 2) + np.linalg.norm( wlh, 2) features["Wavelet_saturation_%d" % ii] = (whh.sum() + whl.sum() + wlh.sum()) / Sk # dutta f16-18 wpV = pywt.WaveletPacket2D(data=I_v, wavelet='db1', mode='zpd', maxlevel=3) for ii in xrange(3): whh = wpV['d' * ii].data whl = wpV['v' * ii].data wlh = wpV['h' * ii].data Sk = np.linalg.norm(whh, 2) + np.linalg.norm(whl, 2) + np.linalg.norm( wlh, 2) features["Wavelet_value_%d" % ii] = (whh.sum() + whl.sum() + wlh.sum()) / Sk # dutta f19-21 features['Wavelet_hue'] = features['Wavelet_hue_0'] + features[ 'Wavelet_hue_1'] + features['Wavelet_hue_2'] features[ 'Wavelet_saturation'] = features['Wavelet_saturation_0'] + features[ 'Wavelet_saturation_1'] + features['Wavelet_saturation_2'] features['Wavelet_value'] = features['Wavelet_value_0'] + features[ 'Wavelet_value_1'] + features['Wavelet_value_2'] # dutta f22 - size features['Img_size'] = nrows + ncols # dutta f23 - ratio features['Img_ratio'] = float(ncols) / nrows # dutta f24-52 - Requires Segementation! # # dutta f53-55 Low DOF #wp = pywt.WaveletPacket2D(data=I_h, wavelet='db1', mode='zpd', maxlevel=3) (nsmallrows, nsmallcols) = wpH['ddd'].data.shape A = wpH['ddd'].data[nsmallrows*1/4:nsmallrows*3/4,nsmallcols*1/4:nsmallcols*3/4].sum() + \ wpH['vvv'].data[nsmallrows*1/4:nsmallrows*3/4,nsmallcols*1/4:nsmallcols*3/4].sum() + \ wpH['hhh'].data[nsmallrows*1/4:nsmallrows*3/4,nsmallcols*1/4:nsmallcols*3/4].sum() B = wpH['ddd'].data.sum() + wpH['vvv'].data.sum() + wpH['hhh'].data.sum() features["DoF_hue"] = A / B #wp = pywt.WaveletPacket2D(data=I_s, wavelet='db1', mode='zpd', maxlevel=3) (nsmallrows, nsmallcols) = wpS['ddd'].data.shape A = wpS['ddd'].data[nsmallrows*1/4:nsmallrows*3/4,nsmallcols*1/4:nsmallcols*3/4].sum() + \ wpS['vvv'].data[nsmallrows*1/4:nsmallrows*3/4,nsmallcols*1/4:nsmallcols*3/4].sum() + \ wpS['hhh'].data[nsmallrows*1/4:nsmallrows*3/4,nsmallcols*1/4:nsmallcols*3/4].sum() B = wpS['ddd'].data.sum() + wpS['vvv'].data.sum() + wpS['hhh'].data.sum() features["DoF_saturation"] = A / B #wp = pywt.WaveletPacket2D(data=I_v, wavelet='db1', mode='zpd', maxlevel=3) (nsmallrows, nsmallcols) = wpV['ddd'].data.shape A = wpV['ddd'].data[nsmallrows*1/4:nsmallrows*3/4,nsmallcols*1/4:nsmallcols*3/4].sum() + \ wpV['vvv'].data[nsmallrows*1/4:nsmallrows*3/4,nsmallcols*1/4:nsmallcols*3/4].sum() + \ wpV['hhh'].data[nsmallrows*1/4:nsmallrows*3/4,nsmallcols*1/4:nsmallcols*3/4].sum() B = wpV['ddd'].data.sum() + wpV['vvv'].data.sum() + wpV['hhh'].data.sum() features["DoF_value"] = A / B features["LapVar_Hue"] = cv2.Laplacian(I_h / 255.0, cv2.CV_64F).var() features["LapVar_Saturation"] = cv2.Laplacian(I_s / 255.0, cv2.CV_64F).var() features["LapVar_Value"] = cv2.Laplacian(I_v / 255.0, cv2.CV_64F).var() tmp = I_h lines = cv2.HoughLinesP(cv2.Canny(tmp, 100, 200, apertureSize=3), 1, np.pi / 180, 100, minLineLength=5, maxLineGap=20) if not lines is None: features['ProbAngles_Hue'] = circstat.mean([ np.arctan2(np.abs(y2 - y1), np.abs(x2 - x1)) for x1, y1, x2, y2 in lines[0] ]) else: features['ProbAngles_Hue'] = 0 tmp = I_s lines = cv2.HoughLinesP(cv2.Canny(tmp, 100, 200, apertureSize=3), 1, np.pi / 180, 100, minLineLength=5, maxLineGap=20) if not lines is None: features['ProbAngles_Saturation'] = circstat.mean([ np.arctan2(np.abs(y2 - y1), np.abs(x2 - x1)) for x1, y1, x2, y2 in lines[0] ]) else: features['ProbAngles_Saturation'] = 0 tmp = I_v lines = cv2.HoughLinesP(cv2.Canny(tmp, 100, 200, apertureSize=3), 1, np.pi / 180, 100, minLineLength=5, maxLineGap=20) if not lines is None: features['ProbAngles_Value'] = circstat.mean([ np.arctan2(np.abs(y2 - y1), np.abs(x2 - x1)) for x1, y1, x2, y2 in lines[0] ]) else: features['ProbAngles_Value'] = 0 tmp = I_h a = tmp.astype("float") b1 = tmp[::-1, :].astype("float") b2 = tmp[:, ::-1].astype("float") features['Sym_Horizontal_Hue'] = (a * b1).sum() / (np.sqrt( (a**2).sum()) * np.sqrt((b1**2).sum())) features['Sym_Vertical_Hue'] = (a * b2).sum() / (np.sqrt( (a**2).sum()) * np.sqrt((b2**2).sum())) tmp = I_s a = tmp.astype("float") b1 = tmp[::-1, :].astype("float") b2 = tmp[:, ::-1].astype("float") features['Sym_Horizontal_Saturation'] = (a * b1).sum() / (np.sqrt( (a**2).sum()) * np.sqrt((b1**2).sum())) features['Sym_Vertical_Saturation'] = (a * b2).sum() / (np.sqrt( (a**2).sum()) * np.sqrt((b2**2).sum())) tmp = I_v a = tmp.astype("float") b1 = tmp[::-1, :].astype("float") b2 = tmp[:, ::-1].astype("float") features['Sym_Horizontal_Value'] = (a * b1).sum() / (np.sqrt( (a**2).sum()) * np.sqrt((b1**2).sum())) features['Sym_Vertical_Value'] = (a * b2).sum() / (np.sqrt( (a**2).sum()) * np.sqrt((b2**2).sum())) return features
# # add a 'best fit' line # y = mlab.normpdf(bins, np.mean(Cresult_SB_list), np.std(Cresult_SB_list)) # l = plt.plot(bins, y, 'r--', linewidth=1) plt.xlabel('Correlation Coefficient in H domain', fontsize=14) plt.ylabel('Normalized Frequency', fontsize=14) plt.legend() # plt.title(r'$\mathrm{Histogram\ of\ IQ:}\ \mu=100,\ \sigma=15$') # plt.axis([40, 160, 0, 0.03]) plt.grid(True) plt.show() ############################################################################################# lena = misc.imread("./images/im_512_3.tif") wp = pywt.WaveletPacket2D(data=lena, wavelet='db4') orgimg = wp['aa'].data #wp['aa'].data # (lena[:100, :100]).astype(float) # wp['aaa'].data rectnumber, rectsize = 5, 15 hugemat, WMvec, m_begin_vec, m_finish_vec, n_begin_vec, n_finish_vec, Wlist = watermarking.encoding(orgimg, rectnumber, rectsize, k) # Displaying rectangles orgimg_squared=orgimg.copy() for rectindex in range(rectnumber): orgimg_squared[int(m_begin_vec[rectindex]),int(n_begin_vec[rectindex]):int(n_finish_vec[rectindex])]=0; orgimg_squared[int(m_finish_vec[rectindex]),int(n_begin_vec[rectindex]):int(n_finish_vec[rectindex])]=0; orgimg_squared[int(m_begin_vec[rectindex]):int(m_finish_vec[rectindex]),int(n_begin_vec[rectindex])]=0; orgimg_squared[int(m_begin_vec[rectindex]):int(m_finish_vec[rectindex]),int(n_finish_vec[rectindex])]=0; fig = plt.imshow(orgimg_squared, cmap='gray') fig.axes.get_xaxis().set_visible(False) fig.axes.get_yaxis().set_visible(False)
import pywt import numpy as np import matplotlib.pyplot as plt from scipy import misc root = os.path.dirname( os.path.dirname(os.path.dirname(os.path.realpath(__file__)))) if __name__ == '__main__': img_filename = os.path.join(root, 'test', 'test_data', 'sphere_mapped', '30_to_60_solid_angle_to_sphere.raw') img = np.fromfile(img_filename, dtype=np.float).reshape([360, 180]).T # Decompose image wp = pywt.WaveletPacket2D(data=img, wavelet='haar', mode='symmetric') print(wp.data) print(repr(wp.path)) print(wp.level) print(wp.maxlevel) # PLot results plt.figure() plt.subplot(221) plt.imshow(wp['a'].data, cmap='gray') plt.subplot(222) plt.imshow(wp['h'].data, cmap='gray') plt.subplot(223) plt.imshow(wp['v'].data, cmap='gray') plt.subplot(224) plt.imshow(wp['d'].data, cmap='gray')
def _waveletPacket(img, outdir, level, kernel, subband, plot, distinct): wp = pywt.WaveletPacket2D(img, kernel, 'symmetric', level) # set wavelet sub band decomposition if subband == 'll': increment = 'a' elif subband == 'lh': increment = 'h' elif subband == 'hl': increment = 'v' elif subband == 'hh': increment = 'd' elif subband == 'all': pass else: print( 'wavelet index error subband must be \'ll\' \'lh\' \'hl\' \'hh\' or \'all\'' ) if subband == 'all': # create energies, entropies list energies = list() entropies = list() # loop over level index = ['a', 'h', 'v', 'd'] for n in range(1, level + 1): # get sub band index temp = list(index) for i in temp: # pop index del index[0] # plot if plot == True: pass # calculate power spectrum # powerSpectrum = np.array(np.abs(wp[i].data)**2, copy=True) # outdirTemp = outdir+'level_'+str(n)+'_subband_'+i # _plotCoeffs(wp[i].data, outdirTemp+'_coeffs.png') # _plotSpectrum(powerSpectrum, outdirTemp+'_powerspectrum.png') # _plotHistogram(powerSpectrum, outdirTemp+'_hist.png') # binning data binData = _binningData(wp[i].data, 1000) histData = _calcHist(binData, 1000) probaData = _calcProbaHist(histData) # calculate energy and entropy energy = np.sum(np.abs(wp[i].data)) entropy = _calcEntropy(probaData) # generate next level index if n < level + 1: index.append(i + 'a') index.append(i + 'h') index.append(i + 'v') index.append(i + 'd') if n != distinct: continue # append energy and entropy to list energies.append(energy) entropies.append(entropy) # calculate total energy total_energy = np.sum(energies) # check sanity if total_energy != 0: energies = energies / np.sum(energies) # append list of energy and entropy to feature features = np.concatenate((energies, entropies), axis=0) return features else: pass features = list() index = '' for n in range(1, level + 1): # pass entropy = dict() outdirTemp = outdir + 'level_' + str(n) + '_subband_' + index index += increment return features