def test_swt2_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)
with warnings.catch_warnings():
warnings.simplefilter('ignore', FutureWarning)
(cA1, (cH1, cV1, cD1)) = pywt.swt2(X, current_wavelet, level=1)[0]
# opposite order
(cA2, (cH2, cV2, cD2)) = pywt.swt2(X,
current_wavelet,
level=1,
axes=(1, 0))[0]
assert_allclose(cA1, cA2, atol=atol)
assert_allclose(cH1, cV2, atol=atol)
assert_allclose(cV1, cH2, atol=atol)
assert_allclose(cD1, cD2, atol=atol)
# duplicate axes not allowed
assert_raises(ValueError,
pywt.swt2,
X,
current_wavelet,
1,
axes=(0, 0))
# too few axes
assert_raises(ValueError, pywt.swt2, X, current_wavelet, 1, axes=(0, ))
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 swt2d(img, wavelet='bior2.2', level=2):
if img.ndim == 2:
img = np.expand_dims(img, axis=2)
nc = img.shape[2]
coeffs = [
pywt.swt2(img[:, :, c], wavelet=wavelet, level=level)
for c in range(nc)
]
# print("len(coeffs):", len(coeffs))
approx_list = []
detail_list = []
for c in range(nc):
detail_list.append(coeffs[c][0][0])
for coeff in zip(*coeffs):
# print("len(coeff):", len(coeff))
for c in range(nc):
# print("len(coeff[{}]: {}".format(c, len(coeff[c])))
approx_list.append(coeff[c][0])
for d in zip(*[coeff[i][1] for i in range(nc)]):
for di in range(nc):
detail_list.append(d[di])
# print("len(approx_list):", len(approx_list))
# print("len(detail_list):", len(detail_list))
return approx_list, detail_list
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 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_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_2d_only():
# iswt2 is not currently compatible with data that is not 2D
x_3d = np.ones((4, 4, 4))
with warnings.catch_warnings():
warnings.simplefilter('ignore', FutureWarning)
c = pywt.swt2(x_3d, 'haar', level=1)
assert_raises(ValueError, pywt.iswt2, c, 'haar')
def get_swt_coeffs(self, img, wavelet='db1', downsample="True"):
p = self.get_image(img, gray=True)
# downsampling
if downsample:
p = pywt.dwt2(p, wavelet)[0]
# calculate maximum decomposition level
l_max = pywt.swt_max_level(min(np.shape(p)))
self.max_level = l_max
# Multilevel 2D stationary wavelet transform with wavelet filters.
coefs = pywt.swt2(p,
wavelet,
l_max,
start_level=0,
trim_approx=True,
norm=True)
# converting from float64 to uint8 to save memory
coefs[0] = coefs[0].astype(np.uint8)
for level in range(1, l_max):
coefs[level] = list(coefs[level])
for band in range(3):
picture = np.asarray(coefs[level][band])
picture -= np.min(picture)
picture *= 255 / np.max(picture)
picture = picture.astype(np.uint8)
coefs[level][band] = picture
return coefs
def calculateChannelCoefficients(C, channel, num, lock):
# Pad the image so that there is a border large enough so that edge artifacts don't occur
padding = 2**(Sharpen.LEVEL)
C = cv2.copyMakeBorder(C, padding, padding, padding, padding, cv2.BORDER_REFLECT)
# Pad so that dimensions are multiples of 2**level
h, w = C.shape[:2]
hR = (h % 2**Sharpen.LEVEL)
wR = (w % 2**Sharpen.LEVEL)
C = cv2.copyMakeBorder(C, 0, (2**Sharpen.LEVEL - hR), 0, (2**Sharpen.LEVEL - wR), cv2.BORDER_REFLECT)
C = np.float32(C)
C /= 255
# Compute coefficients
g.coeffs = list(swt2(C, 'haar', level=Sharpen.LEVEL, trim_approx=True))
g.channel = channel
# Make sure that the other processes have completed as well
with lock:
num.value += 1
while(num.value < 3):
sleep(0.01)
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 w2d(img, mode='bior5.5', level=1):
# show wavelet decomp for fits images
imArray = fits.getdata(img)
# DataPrep conversions
imArray[imArray < 0.1] = 0.1
imArray = np.float32(np.sqrt(imArray))
imArray /= imArray.max();
# compute coefficients
lw = pywt.swt2(imArray, mode, level=level)[0]
plt.subplot(221)
plt.imshow(lw[0], cmap='gray')
plt.axis('off')
plt.subplot(222)
plt.imshow(np.abs(lw[1][0]), cmap='gray')
plt.axis('off')
plt.subplot(223)
plt.imshow(np.abs(lw[1][1]), cmap='gray')
plt.axis('off')
plt.subplot(224)
plt.imshow(np.abs(lw[1][2]), cmap='gray')
plt.axis('off')
plt.subplots_adjust(wspace=0, hspace=0)
def setup(self, n, wavelet):
try:
from pywt import iswt2
except ImportError:
raise NotImplementedError("iswt2 not available")
super(Iswt2TimeSuite, self).setup(n, wavelet)
self.data = pywt.swt2(self.data, wavelet, self.level)
def swt_lv2_dict(img, wavelet='bior2.2'):
"""
2019.11.29
It seems that trim_approx option behaves differently from the document.
If trim_approx is False, approximation is shown in every level.
Approximation should be included to recover original image from wavelet transform coefficients
For 1D stationary wavelet transform, the document is writtne correctly
"""
coeffs = pywt.swt2(img,
wavelet=wavelet,
level=2,
start_level=0,
axes=(-2, -1),
trim_approx=True)
LL2, LL, HH = coeffs
LH2, HL2, HH2 = LL
LH1, HL1, HH1 = HH
coeffs_dict = {}
coeffs_dict['LL2'] = LL2
coeffs_dict['LH2'] = LH2
coeffs_dict['HL2'] = HL2
coeffs_dict['HH2'] = HH2
coeffs_dict['LH1'] = LH1
coeffs_dict['HL1'] = HL1
coeffs_dict['HH1'] = HH1
return coeffs_dict
def procChanSWT(img, wavelet, nLevels):
wt = pywt.swt2(img, wavelet=wavelet, level=nLevels)
fv = []
for l in xrange(1, nLevels):
for x in wt[l][1]:
fv.append(np.std(x))
fv.append(np.mean(x))
return fv
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 edges(path):
im = Image.open(path).convert('L')
arr = numpy.fromstring(im.tostring(), numpy.uint8)
arr.shape = (im.size[1], im.size[0])
data = pywt.swt2(arr, 'haar', level=3, start_level=0)
LL, (LH, HL, HH) = data[2]
pylab.imshow(LH, interpolation='nearest', cmap=pylab.cm.gray)
pylab.show()
def performDywt2(input_image):
a = pywt.swt2(input_image, 'haar', level=1, start_level=0)
LL, (LH, HL, HH) = a[0]
LL = LL / 255
return {
'LL': LL,
'LH': LH,
'HL': HL,
'HH': HH
}
def swt2d_c(img, wavelet='bior2.2', level=2):
coeffs = pywt.swt2(img, wavelet, level=level)
approx_list = []
detail_list = []
detail_list.append(coeffs[0][0])
for a, d in coeffs:
approx_list.append(a)
detail_list.extend(d)
return approx_list, detail_list
def swt_lv2(img, wavelet='bior2.2'):
coeffs = pywt.swt2(img,
wavelet=wavelet,
level=2,
start_level=0,
axes=(-2, -1),
trim_approx=True)
LL2, LL, HH = coeffs
LH2, HL2, HH2 = LL
LH1, HL1, HH1 = HH
return (LL2, LH2, HL2, HH2, LH1, HL1, HH1)
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 test_swt2_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)
(cA1, (cH1, cV1, cD1)) = pywt.swt2(X, current_wavelet, level=1)[0]
# opposite order
(cA2, (cH2, cV2, cD2)) = pywt.swt2(X, current_wavelet, level=1,
axes=(1, 0))[0]
assert_allclose(cA1, cA2, atol=atol)
assert_allclose(cH1, cV2, atol=atol)
assert_allclose(cV1, cH2, atol=atol)
assert_allclose(cD1, cD2, atol=atol)
# duplicate axes not allowed
assert_raises(ValueError, pywt.swt2, X, current_wavelet, 1,
axes=(0, 0))
# too few axes
assert_raises(ValueError, pywt.swt2, X, current_wavelet, 1, axes=(0, ))
def swt2d_rgb(img, wavelet='bior2.2', level=2):
coeffs_b = pywt.swt2(img[:, :, 0], wavelet, level=level)
coeffs_g = pywt.swt2(img[:, :, 1], wavelet, level=level)
coeffs_r = pywt.swt2(img[:, :, 2], wavelet, level=level)
approx_list = []
detail_list = []
detail_list.append(coeffs_b[0][0])
detail_list.append(coeffs_g[0][0])
detail_list.append(coeffs_r[0][0])
for (a_b, d_b), (a_g, d_g), (a_r, d_r) in zip(coeffs_b, coeffs_g,
coeffs_r):
approx_list.append(a_b)
approx_list.append(a_g)
approx_list.append(a_r)
# detail_list.extend(d_b)
# detail_list.extend(d_g)
# detail_list.extend(d_r)
for (b, g, r) in zip(d_b, d_g, d_r):
detail_list.append(b)
detail_list.append(g)
detail_list.append(r)
return approx_list, detail_list
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 batch_Swt(batch, level=1):
'''
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], 12 * level])
for i in range(batch.shape[0]):
coeffs_R = pywt.swt2(batch[i, :, :, 0], 'haar', level=level)
coeffs_G = pywt.swt2(batch[i, :, :, 1], 'haar', level=level)
coeffs_B = pywt.swt2(batch[i, :, :, 2], 'haar', level=level)
for k in range(level):
# print((level-k)-1)
(LL_r, (LH_r, HL_r, HH_r)) = coeffs_R[level - k - 1]
(LL_g, (LH_g, HL_g, HH_g)) = coeffs_G[level - k - 1]
(LL_b, (LH_b, HL_b, HH_b)) = coeffs_B[level - k - 1]
coeffs_stack_R = np.stack([LL_r, LH_r, HL_r, HH_r], axis=-1)
coeffs_stack_G = np.stack([LL_g, LH_g, HL_g, HH_g], axis=-1)
coeffs_stack_B = np.stack([LL_b, LH_b, HL_b, HH_b], axis=-1)
# print(coeffs_stack_R.shape)
coeffs = np.concatenate(
[coeffs_stack_R, coeffs_stack_G, coeffs_stack_B], axis=-1)
Swt_batch[i, :, :, 12 * k:12 * (k + 1)] = coeffs
return Swt_batch
def test_swt_dtypes():
wavelet = pywt.Wavelet('haar')
for dt_in, dt_out in zip(dtypes_in, dtypes_out):
errmsg = "wrong dtype returned for {0} input".format(dt_in)
# swt
x = np.ones(8, dtype=dt_in)
(cA2, cD2), (cA1, cD1) = pywt.swt(x, wavelet, level=2)
assert_(cA2.dtype == cD2.dtype == cA1.dtype == cD1.dtype == dt_out,
"swt: " + errmsg)
# swt2
x = np.ones((8, 8), dtype=dt_in)
cA, (cH, cV, cD) = pywt.swt2(x, wavelet, level=1)[0]
assert_(cA.dtype == cH.dtype == cV.dtype == cD.dtype == dt_out,
"swt2: " + errmsg)
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 swt_decomp(Filt, ShapeOrig, ypad, xpad, dcomLvl):
ims = []
# noinspection PyUnusedLocal
for cA, (cH, cV, cD) in pywt.swt2(Filt, 'bior5.5', dcomLvl):
ims.append(cA)
wvFilt = np.stack(ims, axis=2)
del ims
# via Niyi's method
wvFilt[:, :, dcomLvl - 1] = Filt.copy()
del Filt
# remove zero-padding, if needed
if ShapeOrig[0] != ShapeOrig[1] or ShapeOrig[0] != int(2**np.ceil(
np.log2(ShapeOrig[0]))):
wvFilt = remove_padding(wvFilt, ShapeOrig, ypad, xpad)
return wvFilt
def swt2(self):
"""
Test pypwt against pywt for SWT2.
"""
W = self.W
levels = self.levels
wname = self.wname
# Forward SWT2 with pypwt
logging.info("computing Wavelets from pypwt")
t0 = time()
W.forward()
logging.info("Wavelets.forward took %.3f ms" % elapsed_ms(t0))
# Forward SWT2 with pywt
logging.info("computing wavedec2 from pywt")
Wpy = pywt.swt2(self.data, self.wname, level=levels)
logging.info("pywt took %.3f ms" % elapsed_ms(t0))
# Compare results
# FIXME: Error increases when levels increase, since output is scaled.
tol = self.tol * 2**levels
W_coeffs = W.coeffs
if (levels != W.levels):
err_msg = str("compare_coeffs(): pypwt instance has %d levels while pywt instance has %d levels" % (W.levels, levels))
logging.error(err_msg)
raise ValueError(err_msg)
# For now pypwt only returns the last appcoeff
A = Wpy[levels-1][0]
maxerr = _calc_errors(A, W_coeffs[0], "[app]")
self.assertTrue(maxerr < tol, msg="[%s] something wrong with the approximation coefficients (%d levels) (errmax = %e)" % (wname, levels, maxerr))
for i in range(levels): # wavedec2 format. TODO: pywavelets > 0.5 will use another order
tol = self.tol * 2**(i+1)
A, D1, D2, D3 = Wpy[i][0], Wpy[i][1][0], Wpy[i][1][1], Wpy[i][1][2]
logging.info("%s Level %d %s" % ("-"*5, i+1, "-"*5))
maxerr = _calc_errors(D1, W_coeffs[i+1][0], "[det.H]")
self.assertTrue(maxerr < tol, msg="[%s] something wrong with the detail coefficients 1 at level %d (errmax = %e)" % (wname, i+1, maxerr))
maxerr = _calc_errors(D2, W_coeffs[i+1][1], "[det.V]")
self.assertTrue(maxerr < tol, msg="[%s] something wrong with the detail coefficients 2 at level %d (errmax = %e)" % (wname, i+1, maxerr))
maxerr = _calc_errors(D3, W_coeffs[i+1][2], "[det.D]")
self.assertTrue(maxerr < tol, msg="[%s] something wrong with the detail coefficients 3 at level %d (errmax = %e)" % (wname, i+1, maxerr))
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))
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import pylab
import numpy
import Image # PIL
import pywt
im = Image.open("data/aero.png").convert('L')
arr = numpy.fromstring(im.tostring(), numpy.uint8)
arr.shape = (im.size[1], im.size[0])
pylab.imshow(arr, interpolation="nearest", cmap=pylab.cm.gray)
for LL, (LH, HL, HH) in pywt.swt2(arr, 'bior1.3', level=3, start_level=0):
pylab.figure()
for i, a in enumerate([LL, LH, HL, HH]):
pylab.subplot(2, 2, i + 1)
pylab.imshow(a, origin='image', interpolation="nearest",
cmap=pylab.cm.gray)
pylab.show()
def test_iswt2_2d_only():
# iswt2 is not currently compatible with data that is not 2D
x_3d = np.ones((4, 4, 4))
c = pywt.swt2(x_3d, 'haar', level=1)
assert_raises(ValueError, pywt.iswt2, c, 'haar')
def time_swt2(self, n, wavelet):
pywt.swt2(self.data, wavelet, self.level)
