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 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