def __setitem__(self, path, data):
"""
Set node represented by the given path with a new value.
path - string composed of node names.
data - array or BaseNode subclass.
"""
if isinstance(path, basestring):
if (
self.maxlevel is not None
and len(self.path) + len(path) > self.maxlevel * self.PART_LEN
):
raise IndexError("Path length out of range.")
if path:
subnode = self.get_subnode(path[0:self.PART_LEN], False)
if subnode is None:
self._create_subnode(path[0:self.PART_LEN], None)
subnode = self.get_subnode(path[0:self.PART_LEN], False)
subnode[path[self.PART_LEN:]] = data
else:
if isinstance(data, BaseNode):
self.data = numerix.as_float_array(data.data)
else:
self.data = numerix.as_float_array(data)
else:
raise TypeError("Invalid path parameter type - expected string but"
" got %s." % type(path))
def __setitem__(self, path, data):
"""
Set node represented by the given path with a new value.
path - string composed of node names.
data - array or BaseNode subclass.
"""
if isinstance(path, basestring):
if (self.maxlevel is not None and len(self.path) + len(path) >
self.maxlevel * self.PART_LEN):
raise IndexError("Path length out of range.")
if path:
subnode = self.get_subnode(path[0:self.PART_LEN], False)
if subnode is None:
self._create_subnode(path[0:self.PART_LEN], None)
subnode = self.get_subnode(path[0:self.PART_LEN], False)
subnode[path[self.PART_LEN:]] = data
else:
if isinstance(data, BaseNode):
self.data = numerix.as_float_array(data.data)
else:
self.data = numerix.as_float_array(data)
else:
raise TypeError("Invalid path parameter type - expected string but"
" got %s." % type(path))
def dwtn(data, wavelet, mode='sym'):
"""
Single-level n-dimensional Discrete Wavelet Transform.
data - n-dimensional array
wavelet - wavelet to use (Wavelet object or name string)
mode - signal extension mode, see MODES
Results are arranged in a dictionary, where key specifies
the transform type on each dimension and value is a n-dimensional
coefficients array.
For example, for a 2D case the result will look something like this:
{
'aa': <coeffs> # A(LL) - approx. on 1st dim, approx. on 2nd dim
'ad': <coeffs> # H(LH) - approx. on 1st dim, det. on 2nd dim
'da': <coeffs> # V(HL) - det. on 1st dim, approx. on 2nd dim
'dd': <coeffs> # D(HH) - det. on 1st dim, det. on 2nd dim
}
"""
data = as_float_array(data)
dim = len(data.shape)
coeffs = [('', data)]
for axis in range(dim):
new_coeffs = []
for subband, x in coeffs:
new_coeffs.extend([(subband + 'a',
apply_along_axis(_downcoef, axis, x, wavelet,
mode, 'a')),
(subband + 'd',
apply_along_axis(_downcoef, axis, x, wavelet,
mode, 'd'))])
coeffs = new_coeffs
return dict(coeffs)
def dwtn(data, wavelet, mode='sym'):
"""
Single-level n-dimensional Discrete Wavelet Transform.
data - n-dimensional array
wavelet - wavelet to use (Wavelet object or name string)
mode - signal extension mode, see MODES
Results are arranged in a dictionary, where key specifies
the transform type on each dimension and value is a n-dimensional
coefficients array.
For example, for a 2D case the result will look something like this:
{
'aa': <coeffs> # A(LL) - approx. on 1st dim, approx. on 2nd dim
'ad': <coeffs> # H(LH) - approx. on 1st dim, det. on 2nd dim
'da': <coeffs> # V(HL) - det. on 1st dim, approx. on 2nd dim
'dd': <coeffs> # D(HH) - det. on 1st dim, det. on 2nd dim
}
"""
data = as_float_array(data)
dim = len(data.shape)
coeffs = [('', data)]
for axis in range(dim):
new_coeffs = []
for subband, x in coeffs:
new_coeffs.extend([
(subband + 'a', apply_along_axis(_downcoef, axis,
x, wavelet, mode, 'a')),
(subband + 'd', apply_along_axis(_downcoef, axis,
x, wavelet, mode, 'd'))
])
coeffs = new_coeffs
return dict(coeffs)
def __init__(self, data, wavelet, mode='sp1', maxlevel=None):
super(WaveletPacket2D, self).__init__(None, data, "")
if not isinstance(wavelet, Wavelet):
wavelet = Wavelet(wavelet)
self.wavelet = wavelet
self.mode = mode
if data is not None:
data = numerix.as_float_array(data)
assert len(data.shape) == 2
self.data_size = data.shape
if maxlevel is None:
maxlevel = dwt_max_level(min(self.data_size), self.wavelet)
else:
self.data_size = None
self._maxlevel = maxlevel
def __init__(self, data, wavelet, mode='sp1', maxlevel=None):
super(WaveletPacket2D, self).__init__(None, data, "")
if not isinstance(wavelet, Wavelet):
wavelet = Wavelet(wavelet)
self.wavelet = wavelet
self.mode = mode
if data is not None:
data = numerix.as_float_array(data)
assert len(data.shape) == 2
self.data_size = data.shape
if maxlevel is None:
maxlevel = dwt_max_level(min(self.data_size), self.wavelet)
else:
self.data_size = None
self._maxlevel = maxlevel
def wavedec2(data, wavelet, mode='sym', level=None):
"""
Multilevel 2D Discrete Wavelet Transform.
data - 2D input data
wavelet - wavelet to use (Wavelet object or name string)
mode - signal extension mode, see MODES
level - decomposition level. If level is None then it will be
calculated using `dwt_max_level` function .
Returns coefficients list - [cAn, (cHn, cVn, cDn), ... (cH1, cV1, cD1)]
"""
data = as_float_array(data)
if len(data.shape) != 2:
raise ValueError("Expected 2D input data.")
if not isinstance(wavelet, Wavelet):
wavelet = Wavelet(wavelet)
if level is None:
size = min(data.shape)
level = dwt_max_level(size, wavelet.dec_len)
elif level < 0:
raise ValueError("Level value of %d is too low . Minimum level is 0." %
level)
coeffs_list = []
a = data
for i in xrange(level):
a, ds = dwt2(a, wavelet, mode)
coeffs_list.append(ds)
coeffs_list.append(a)
coeffs_list.reverse()
return coeffs_list
def wavedec2(data, wavelet, mode='sym', level=None):
"""
Multilevel 2D Discrete Wavelet Transform.
data - 2D input data
wavelet - wavelet to use (Wavelet object or name string)
mode - signal extension mode, see MODES
level - decomposition level. If level is None then it will be
calculated using `dwt_max_level` function .
Returns coefficients list - [cAn, (cHn, cVn, cDn), ... (cH1, cV1, cD1)]
"""
data = as_float_array(data)
if len(data.shape) != 2:
raise ValueError("Expected 2D input data.")
if not isinstance(wavelet, Wavelet):
wavelet = Wavelet(wavelet)
if level is None:
size = min(data.shape)
level = dwt_max_level(size, wavelet.dec_len)
elif level < 0:
raise ValueError(
"Level value of %d is too low . Minimum level is 0." % level)
coeffs_list = []
a = data
for i in xrange(level):
a, ds = dwt2(a, wavelet, mode)
coeffs_list.append(ds)
coeffs_list.append(a)
coeffs_list.reverse()
return coeffs_list
def swt2(data, wavelet, level, start_level=0):
"""
2D Stationary Wavelet Transform.
data - 2D array with input data
wavelet - wavelet to use (Wavelet object or name string)
level - how many decomposition steps to perform
start_level - the level at which the decomposition will start
Returns list of approximation and details coefficients:
[
(cA_n,
(cH_n, cV_n, cD_n)
),
(cA_n+1,
(cH_n+1, cV_n+1, cD_n+1)
),
...,
(cA_n+level,
(cH_n+level, cV_n+level, cD_n+level)
)
]
where cA is approximation, cH is horizontal details, cV is
vertical details, cD is diagonal details and n is start_level.
"""
data = as_float_array(data)
if len(data.shape) != 2:
raise ValueError("Expected 2D data array")
if not isinstance(wavelet, Wavelet):
wavelet = Wavelet(wavelet)
ret = []
for i in range(start_level, start_level + level):
# filter rows
H, L = [], []
append_L = L.append
append_H = H.append
for row in data:
cA, cD = swt(row, wavelet, level=1, start_level=i)[0]
append_L(cA)
append_H(cD)
del data
# filter columns
H = transpose(H)
L = transpose(L)
LL, LH = [], []
append_LL = LL.append
append_LH = LH.append
for row in L:
cA, cD = swt(array(row, default_dtype),
wavelet,
level=1,
start_level=i)[0]
append_LL(cA)
append_LH(cD)
del L
HL, HH = [], []
append_HL = HL.append
append_HH = HH.append
for row in H:
cA, cD = swt(array(row, default_dtype),
wavelet,
level=1,
start_level=i)[0]
append_HL(cA)
append_HH(cD)
del H
# build result structure
# (approx., (horizontal, vertical, diagonal))
approx = transpose(LL)
ret.append((approx, (transpose(LH), transpose(HL), transpose(HH))))
data = approx # for next iteration
return ret
def dwt2(data, wavelet, mode='sym'):
"""
2D Discrete Wavelet Transform.
data - 2D array with input data
wavelet - wavelet to use (Wavelet object or name string)
mode - signal extension mode, see MODES
Returns approximaion and three details 2D coefficients arrays.
The result form four 2D coefficients arrays organized in tuples:
(approximation,
(horizontal details,
vertical details,
diagonal details)
)
which sometimes is also interpreted as layed out in one 2D array
of coefficients, where:
-----------------
| | |
| A(LL) | H(LH) |
| | |
(A, (H, V, D)) <---> -----------------
| | |
| V(HL) | D(HH) |
| | |
-----------------
"""
data = as_float_array(data)
if len(data.shape) != 2:
raise ValueError("Expected 2D data array")
if not isinstance(wavelet, Wavelet):
wavelet = Wavelet(wavelet)
mode = MODES.from_object(mode)
# filter rows
H, L = [], []
append_L = L.append
append_H = H.append
for row in data:
cA, cD = dwt(row, wavelet, mode)
append_L(cA)
append_H(cD)
del data
# filter columns
H = transpose(H)
L = transpose(L)
LL, LH = [], []
append_LL = LL.append
append_LH = LH.append
for row in L:
cA, cD = dwt(array(row, default_dtype), wavelet, mode)
append_LL(cA)
append_LH(cD)
del L
HL, HH = [], []
append_HL = HL.append
append_HH = HH.append
for row in H:
cA, cD = dwt(array(row, default_dtype), wavelet, mode)
append_HL(cA)
append_HH(cD)
del H
# build result structure
# (approx., (horizontal, vertical, diagonal))
ret = (transpose(LL), (transpose(LH), transpose(HL), transpose(HH)))
return ret
def swt2(data, wavelet, level, start_level=0):
"""
2D Stationary Wavelet Transform.
data - 2D array with input data
wavelet - wavelet to use (Wavelet object or name string)
level - how many decomposition steps to perform
start_level - the level at which the decomposition will start
Returns list of approximation and details coefficients:
[
(cA_n,
(cH_n, cV_n, cD_n)
),
(cA_n+1,
(cH_n+1, cV_n+1, cD_n+1)
),
...,
(cA_n+level,
(cH_n+level, cV_n+level, cD_n+level)
)
]
where cA is approximation, cH is horizontal details, cV is
vertical details, cD is diagonal details and n is start_level.
"""
data = as_float_array(data)
if len(data.shape) != 2:
raise ValueError("Expected 2D data array")
if not isinstance(wavelet, Wavelet):
wavelet = Wavelet(wavelet)
ret = []
for i in range(start_level, start_level + level):
# filter rows
H, L = [], []
for row in data:
cA, cD = swt(row, wavelet, level=1, start_level=i)[0]
L.append(cA)
H.append(cD)
del data
# filter columns
H = transpose(H)
L = transpose(L)
LL, LH = [], []
for row in L:
cA, cD = swt(
array(row, default_dtype), wavelet, level=1, start_level=i
)[0]
LL.append(cA)
LH.append(cD)
del L
HL, HH = [], []
for row in H:
cA, cD = swt(
array(row, default_dtype), wavelet, level=1, start_level=i
)[0]
HL.append(cA)
HH.append(cD)
del H
# build result structure
# (approx., (horizontal, vertical, diagonal))
approx = transpose(LL)
ret.append((approx, (transpose(LH), transpose(HL), transpose(HH))))
# for next iteration
data = approx # noqa
return ret
def dwt2(data, wavelet, mode='sym'):
"""
2D Discrete Wavelet Transform.
data - 2D array with input data
wavelet - wavelet to use (Wavelet object or name string)
mode - signal extension mode, see MODES
Returns approximation and three details 2D coefficients arrays.
The result form four 2D coefficients arrays organized in tuples:
(approximation,
(horizontal details,
vertical details,
diagonal details)
)
which sometimes is also interpreted as laid out in one 2D array
of coefficients, where:
-----------------
| | |
| A(LL) | H(LH) |
| | |
(A, (H, V, D)) <---> -----------------
| | |
| V(HL) | D(HH) |
| | |
-----------------
"""
data = as_float_array(data)
if len(data.shape) != 2:
raise ValueError("Expected 2D data array")
if not isinstance(wavelet, Wavelet):
wavelet = Wavelet(wavelet)
mode = MODES.from_object(mode)
# filter rows
H, L = [], []
for row in data:
cA, cD = dwt(row, wavelet, mode)
L.append(cA)
H.append(cD)
del data
# filter columns
H = transpose(H)
L = transpose(L)
LL, LH = [], []
for row in L:
cA, cD = dwt(array(row, default_dtype), wavelet, mode)
LL.append(cA)
LH.append(cD)
del L
HL, HH = [], []
for row in H:
cA, cD = dwt(array(row, default_dtype), wavelet, mode)
HL.append(cA)
HH.append(cD)
del H
# build result structure
# (approx., (horizontal, vertical, diagonal))
ret = (transpose(LL), (transpose(LH), transpose(HL), transpose(HH)))
return ret
