Standard Wavelet Transforms

wpt

Perform a discrete wavelet packet transform of the array x. See also: dwt, wavelet

wpt(x, wt[, L])
wpt(x, wt, tree)

Returns the wavelet packet transform (WPT) for L levels or by given quadratic tree.

Arguments

• x::AbstractVector{T} where T<:Number or x::AbstractArray{T,2} where T<:Number: Input vector/matrix. A vector input undergoes 1D wavelet decomposition whereas a matrix input undergoes 2D wavelet decomposition.
• wt::OrthoFilter: Wavelet filter.
• L::Integer: (Default: maxtransformlevels(x)) Number of levels for wavelet decomposition.
• tree::BitVector: Quadtree to transform to be computed accordingly.

Returns

• ::Array{T,1} or ::Array{T,2}: Transformed signal.

Examples:

using Wavelets, WaveletsExt

# 1D wavelet decomposition
x = randn(8)
wt = wavelet(WT.haar)
xw = wpt(x, wt)

# 2D wavelet decomposition
x = randn(8,8)
wt = wavelet(WT.haar)
xw = wpt(x, wt)

See also: wpt!, maketree

wpt!

Same as wpt but without array allocation.

wpt!(y, x, wt[, L])
wpt!(y, x, wt, tree)

Same as wpt but without array allocation.

Arguments

• y::AbstractVector{T} where T<:Number or y::AbstractArray{T,2} where T<:Number: Allocated output vector/matrix.
• x::AbstractVector{T} where T<:Number or x::AbstractArray{T,2} where T<:Number: Input vector/matrix. A vector input undergoes 1D wavelet packet transform whereas a matrix input undergoes 2D wavelet packet transform.
• wt::OrthoFilter: Wavelet filter.
• L::Integer: (Default: maxtransformlevels(x)) Number of levels for wavelet decomposition.
• tree::BitVector: Quadtree to transform to be computed accordingly.

Returns

• ::Array{T,1} or ::Array{T,2}: Transformed signal.

Examples:

using Wavelets, WaveletsExt

# 1D wavelet decomposition
x = randn(8)
xw = similar(x)
wt = wavelet(WT.haar)
wpt!(xw, x, wt)

# 2D wavelet decomposition
x = randn(8,8)
xw = similar(x)
wt = wavelet(WT.haar)
wpt!(xw, x, wt)

See also: wpt, maketree

iwpt

Perform an inverse discrete wavelet packet transform of the array x. See also: idwt, wavelet

iwpt(xw, wt[, L])
iwpt(xw, wt, tree)

Returns the inverse wavelet packet transform (IWPT) for L levels or by given quadratic tree.

Arguments

• xw::AbstractVector{T} where T<:Number or xw::AbstractArray{T,2} where T<:Number: Input vector/matrix. A vector input undergoes 1D wavelet reconstruction whereas a matrix input undergoes 2D wavelet reconstruction.
• wt::OrthoFilter: Wavelet filter.
• L::Integer: (Default: maxtransformlevels(x)) Number of levels for wavelet decomposition.
• tree::BitVector: Quadtree to transform to be computed accordingly.

Returns

• ::Array{T,1} or ::Array{T,2}: Reconstructed signal.

Examples:

using Wavelets, WaveletsExt

# 1D wavelet decomposition
x = randn(8)
wt = wavelet(WT.haar)
xw = wpt(x, wt)

# 1D wavelet reconstruction
y = iwpt(xw, wt)

# 2D wavelet decomposition
x = randn(8,8)
wt = wavelet(WT.haar)
xw = wpt(x, wt)

# 2D wavelet reconstruction
y = iwpt(xw, wt)

See also: iwpt!, wpt!, maketree

iwpt!

Same as iwpt but without array allocation.

iwpt!(x̂, xw, wt[, L])
iwpt!(x̂, xw, wt, tree)

Same as iwpt but without array allocation.

Arguments

• x̂::AbstractVector{T} where T<:Number or x̂::AbstractArray{T,2} where T<:Number: Allocated output vector/matrix.
• xw::AbstractVector{T} where T<:Number or xw::AbstractArray{T,2} where T<:Number: Input vector/matrix. A vector input undergoes 1D wavelet packet reconstruction whereas a matrix input undergoes 2D wavelet packet reconstruction.
• wt::OrthoFilter: Wavelet filter.
• L::Integer: (Default: maxtransformlevels(x)) Number of levels for wavelet decomposition.
• tree::BitVector: Quadtree to transform to be computed accordingly.

Returns

• ::Array{T,1} or ::Array{T,2}: Reconstructed signal.

Examples:

using Wavelets, WaveletsExt

# 1D wavelet decomposition
x = randn(8)
xw = similar(x)
wt = wavelet(WT.haar)
wpt!(xw, x, wt)

# 1D wavelet reconstruction
y = similar(x)
iwpt!(y, xw, wt)

# 2D wavelet decomposition
x = randn(8,8)
xw = similar(x)
wt = wavelet(WT.haar)
wpt!(xw, x, wt)

# 2D wavelet reconstruction
y = similar(x)
iwpt!(y, xw, wt)

See also: iwpt, wpt! maketree

wpd(x, wt[, L])

Returns the wavelet packet decomposition (WPD) for L levels for input signal x.

Arguments

• x::AbstractVector{T} where T<:Number or x::AbstractArray{T,2} where T<:Number: Input vector/matrix. A vector input undergoes 1D wavelet decomposition whereas a matrix input undergoes 2D wavelet decomposition.
• wt::OrthoFilter: Wavelet filter.
• L::Integer: (Default: maxtransformlevels(x)) Number of levels for wavelet decomposition.

Returns

• ::Array{T,2} or ::Array{T,3}: Decomposed signal. For an input vector x, output is a 2D matrix where each column corresponds to a level of decomposition. For an input matrix x, output is a 3D array where each slice of dimension 3 corresponds to a level of decomposition.

Examples:

using Wavelets, WaveletsExt

# 1D wavelet decomposition
x = randn(8)
wt = wavelet(WT.haar)
xw = wpd(x, wt)

# 2D wavelet decomposition
x = randn(8,8)
wt = wavelet(WT.haar)
xw = wpd(x, wt)

See also: wpd!, iwpd

wpd!(y, x, wt[, L])

Same as wpd but without array allocation.

Arguments

• y::AbstractArray{T,2} where T<:Number or y::AbstractArray{T,3} where T<:Number: An allocated array to write the outputs of x onto.
• x::AbstractVector{T} where T<:Number or x::AbstractArray{T,2} where T<:Number: Input vector/matrix. A vector input undergoes 1D wavelet decomposition whereas a matrix input undergoes 2D wavelet decomposition.
• wt::OrthoFilter: Wavelet filter.
• L::Integer: (Default: maxtransformlevels(x)) Number of levels for wavelet decomposition.

Returns

• y::AbstractArray{T,2} where T<:Number or y::AbstractArray{T,3} where T<:Number: Decomposed signal. For an input vector, output is a 2D matrix where each column corresponds to a level of decomposition. For an input matrix, output is a 3D array where each slice of dimension 3 corresponds to a level of decomposition.

Examples:

using Wavelets, WaveletsExt

# 1D wavelet decomposition
x = randn(8)
xw = Array{eltype(x)}(undef, (8,3))
wt = wavelet(WT.haar)
wpd!(xw, x, wt)

# 2D wavelet decomposition
x = randn(8,8)
xw = Array{eltype(x)}(undef, (8,8,3))
wt = wavelet(WT.haar)
wpd!(xw, x, wt)

See also: wpd, iwpd

iwpd(xw, wt[, L])
iwpd(xw, wt, tree)

Computes the inverse wavelet packet decomposition (IWPD) for L levels or by given tree.

Arguments

• x̂::AbstractVector{T} where T<:Number or x̂::AbstractArray{T,2} where T<:Number: Allocated output vector/matrix for reconstructed signal.
• xw::AbstractArray{T,2} where T<:Number or xw::AbstractArray{T,3} where T<:Number: Input array. A 2D input undergoes 1D wavelet reconstruction whereas a 3D input undergoes 2D wavelet reconstruction.
• wt::OrthoFilter: Wavelet filter.
• L::Integer: (Default: minimum(size(x)[1:end-1]) |> maxtransformlevels) Number of levels of wavelet decomposition.
• tree::BitVector: Binary tree or Quadtree for inverse transform to be computed accordingly.

Returns

• x̂::Array{T,1} or x̂::Array{T,2}: Reconstructed signal.

Examples:

using Wavelets, WaveletsExt

# 1D wavelet decomposition
x = randn(8)
wt = wavelet(WT.haar)
xw = wpd(x, wt)

# 1D wavelet reconstruction
y = iwpd(xw, wt)

# 2D wavelet decomposition
x = randn(8,8)
wt = wavelet(WT.haar)
xw = wpd(x, wt)

# 2D wavelet reconstruction
y = iwpd(xw, wt)

See also: iwpd!, iwpt

iwpd(x̂, xw, wt[, L])
iwpd(x̂, xw, wt, tree)

Same as iwpd but without array allocation.

Arguments

• x̂::AbstractVector{T} where T<:Number or x̂::AbstractArray{T,2} where T<:Number: Allocated output vector/matrix for reconstructed signal.
• xw::AbstractArray{T,2} where T<:Number or xw::AbstractArray{T,3} where T<:Number: Input array. A 2D input undergoes 1D wavelet reconstruction whereas a 3D input undergoes 2D wavelet reconstruction.
• wt::OrthoFilter: Wavelet filter.
• L::Integer: (Default: maxtransformlevels(x)) Number of levels for wavelet decomposition.
• tree::BitVector: Binary tree or Quadtree to transform to be computed accordingly.

Returns

• x̂::Array{T,1} or x̂::Array{T,2}: Reconstructed signal.

Examples:

using Wavelets, WaveletsExt

# 1D wavelet decomposition
x = randn(8)
wt = wavelet(WT.haar)
xw = wpd(x, wt)
y = similar(x)

# 1D wavelet reconstruction
iwpd!(y, xw, wt)

# 2D wavelet decomposition
x = randn(8,8)
wt = wavelet(WT.haar)
xw = wpd(x, wt)
y = similar(x)

# 2D wavelet reconstruction
iwpd!(y, xw, wt)

See also: iwpd, iwpt

dwtall(x, wt[, L])

Computes the discrete wavelet transform (DWT) on each slice of signal. Signals are sliced on the $n$-th dimension for an $n$-dimensional input x.

Arguments

• x::AbstractArray{T} where T<:Number: Input signals, where each slice corresponds to one signal. For a set of input signals x of dimension $n$, signals are sliced on the $n$-th dimension.
• wt::OrthoFilter: Orthogonal wavelet filter.
• L::Integer: (Default: Wavelets.maxtransformlevels(xᵢ)) Number of levels of wavelet transforms.

Returns

::Array{T}: Slices of transformed signals. Signals are sliced the same way as the input signal x.

Examples

using Wavelets, WaveletsExt

# Generate random signals
x = randn(32, 5)
# Create wavelet
wt = wavelet(WT.db4)

# DWT on all signals in x
xw = dwtall(x, wt)

See also: idwtall, wpdall, wptall

idwtall(xw, wt[, L])

Computes the inverse discrete wavelet transform (iDWT) on each slice of signal. Signals are sliced on the $n$-th dimension for an $n$-dimensional input xw.

Arguments

• xw::AbstractArray{T} where T<:Number: Input decomposed signals, where each slice corresponds to one signal. For a set of input signals xw of dimension $n$, signals are sliced on the $n$-th dimension.
• wt::OrthoFilter: Wavelet used.
• L::Integer: (Default: Wavelets.maxtransformlevels(xwᵢ)) Number of levels of wavelet transforms.

Returns

::Array{T}: Slices of reconstructed signals. Signals are sliced the same way as the input xw.

Examples

using Wavelets, WaveletsExt

# Generate random signals
x = randn(32, 5)
# Create wavelet
wt = wavelet(WT.db4)

# DWT on all signals in x
xw = dwtall(x, wt)

# iDWT on all signals
x̂ = idwtall(xw, wt)

See also: dwtall, iwpdall, iwptall

wptall(x, wt[, L])
wptall(x, wt, tree)

Computes the wavelet packet transform (WPT) on each slice of signal. Signals are sliced on the $n$-th dimension for an $n$-dimensional input x.

Arguments

• x::AbstractArray{T} where T<:Number: Input signals, where each slice corresponds to one signal. For a set of input signals x of dimension $n$, signals are sliced on the $n$-th dimension.
• wt::OrthoFilter: Wavelet used.
• L::Integer: (Default: Wavelets.maxtransformlevels(xᵢ)) Number of levels of wavelet decomposition.
• tree::BitVector: (Default: Wavelets.maketree(xᵢ, :full)) Tree to follow for wavelet decomposition. Default value is only applicable for 1D signals.

Returns

::Array{T}: Slices of transformed signals. Signals are sliced the same way as the input signal x.

Examples

using Wavelets, WaveletsExt

# Generate random signals
x = randn(32, 5)
# Create wavelet
wt = wavelet(WT.db4)

# WPT on all signals in x
xw = wptall(x, wt)

See also: wpdall, dwtall, wpt

iwptall(xw, wt[, L])
iwptall(xw, wt, tree)

Computes the inverse wavelet packet transform (iWPT) on each slice of signal. Signals are sliced on the $n$-th dimension for an $n$-dimensional input xw.

Arguments

• x::AbstractArray{T} where T<:Number: Input signals, where each slice corresponds to one signal. For a set of input signals x of dimension $n$, signals are sliced on the $n$-th dimension.
• wt::OrthoFilter: Wavelet used.
• L::Integer: (Default: Wavelets.maxtransformlevels(xᵢ)) Number of levels of wavelet decomposition.
• tree::BitVector: (Default: Wavelets.maketree(xᵢ, :full)) Tree to follow for wavelet decomposition. Default value is only applicable for 1D signals.

Returns

::Array{T}: Slices of transformed signals. Signals are sliced the same way as the input signal x.

Examples

using Wavelets, WaveletsExt

# Generate random signals
x = randn(32, 5)
# Create wavelet
wt = wavelet(WT.db4)

# WPT on all signals in x
xw = wptall(x, wt)

# iWPT on all signals on x
x̂ = iwptall(xw, wt)

See also: wpdall, dwtall, wpt

wpdall(x, wt[, L])

Computes the wavelet packet decomposition (WPD) on each slice of signal. Signals are sliced on the $n$-th dimension for an $n$-dimensional input x.

Arguments

• x::AbstractArray{T} where T<:Number: Input signals, where each slice corresponds to one signal. For a set of input signals x of dimension $n$, signals are sliced on the $n$-th dimension.
• wt::OrthoFilter: Wavelet used.
• L::Integer: (Default: minimum(size(x)[1:end-1]) |> maxtransformlevels) Number of levels of wavelet decomposition.

Returns

::Array{T}: Array of decomposed signals. Signals are sliced by the final dimension.

Examples

using Wavelets, WaveletsExt

# Generate random signals
x = randn(32, 5)
# Create wavelet
wt = wavelet(WT.db4)

# WPT on all signals in x
xw = wpdall(x, wt)

See also: wptall, dwtall, wpd, wpd!

iwpdall(xw, wt[, L; standard])
iwpdall(xw, wt, tree[; standard])

Computes the inverse wavelet packet decomposition (IWPD) on each slice of signal. Signals are sliced on the $n$-th dimension for an $n$-dimensional input xw.

Arguments

• xw::AbstractArray{T} where T<:Number: Input signals, where each slice corresponds to one signal decomposition. For a set of input signals x of dimension $n$, xw is sliced on the $n$-th dimension.
• wt::OrthoFilter: Wavelet used.
• L::Integer: (Default: Wavelets.maxtransformlevels(xᵢ)) Number of levels of wavelet decomposition.

Keyword Arguments

• standard::Bool: (Default: true) Whether to compute the standard or non-standard wavelet transform. Only applicable for 2D signals.

Returns

::Array{T}: Array of decomposed signals. Signals are sliced by the final dimension.

Examples

using Wavelets, WaveletsExt

# Generate random signals
x = randn(32, 5)
# Create wavelet
wt = wavelet(WT.db4)

# WPD on all signals in x
xw = wpdall(x, wt)

# IWPD on all signals
x̂ = iwpdall(xw, wt)

See also: wptall, dwtall, wpd, wpd!

dwt_step(v, h, g)

Perform one level of the discrete wavelet transform (DWT) on the vector v, which is the d-th level scaling coefficients (Note the 0th level scaling coefficients is the raw signal). The vectors h and g are the detail and scaling filters.

Arguments

• v::AbstractVector{T} where T<:Number: Vector of coefficients from a node at level d.
• h::Vector{S} where S<:Number: High pass filter.
• g::Vector{S} where S<:Number: Low pass filter.

Returns

• w₁::Vector{T}: Output from the low pass filter.
• w₂::Vector{T}: Output from the high pass filter.

Examples

using Wavelets, WaveletsExt

# Setup
v = randn(8)
wt = wavelet(WT.haar)
g, h = WT.makereverseqmfpair(wt, true)

# One step of DWT
DWT.dwt_step(v, h, g)

See also: dwt_step!, idwt_step

dwt_step(v, h, g)

Compute 1 step of 2D discrete wavelet transform (DWT).

Arguments

• v::AbstractArray{T,2} where T<:Number: Array of coefficients of size $(n,m)$.
• h::Array{S,1} where S<:Number: High pass filter.
• g::Array{S,1} where S<:Number: Low pass filter.

Returns

• w₁::Array{T,2}: Top left output. Result of low pass filter on columns + low pass filter on rows.
• w₂::Array{T,2}: Top left output. Result of low pass filter on columns + high pass filter on rows.
• w₃::Array{T,2}: Top left output. Result of high pass filter on columns + low pass filter on rows.
• w₄::Array{T,2}: Top left output. Result of high pass filter on columns + high pass filter on rows.

Examples

using Wavelets, WaveletsExt

# Setup
v = randn(8,8)
wt = wavelet(WT.haar)
g, h = WT.makereverseqmfpair(wt, true)

# One step of DWT
DWT.dwt_step(v, h, g)

See also: dwt_step, dwt_step!, idwt_step

dwt_step!(w₂, w₂, v, h, g)

Same as dwt_step but without array allocation.

Arguments

• w₁::AbstractVector{T} where T<:Number: Vector allocation for output from low pass filter.
• w₂::AbstractVector{T} where T<:Number: Vector allocation for output from high pass filter.
• v::AbstractVector{T} where T<:Number: Vector of coefficients from a node at level d.
• h::Vector{S} where S<:Number: High pass filter.
• g::Vector{S} where S<:Number: Low pass filter.

Returns

• w₁::Vector{T}: Output from the low pass filter.
• w₂::Vector{T}: Output from the high pass filter.

Examples

using Wavelets, WaveletsExt

# Setup
v = randn(8)
wt = wavelet(WT.haar)
g, h = WT.makereverseqmfpair(wt, true)
w₁ = zeros(8)
w₂ = zeros(8)

# One step of DWT
DWT.dwt_step!(w₁, w₂, v, 0, h, g)

See also: dwt_step, idwt_step

dwt_step!(v, w₁, w₂, w₃, w₄, h, g, temp)

Same as 2D version of dwt_step but without array allocation.

Arguments

• w₁::AbstractArray{T,2} where T<:Number: Array allocation for top left output.
• w₂::AbstractArray{T,2} where T<:Number: Array allocation for top right output.
• w₃::AbstractArray{T,2} where T<:Number: Array allocation for bottom left output.
• w₄::AbstractArray{T,2} where T<:Number: Array allocation for bottom right output.
• v::AbstractArray{T,2} where T<:Number: Array of coefficients to be transformed.
• h::Array{S,1} where S<:Number: High pass filter.
• g::Array{S,1} where S<:Number: Low pass filter.
• temp::AbstractArray{T,2} where T<:Number: Array allocation for intermediate computations.

Returns

• w₁::Array{T,2}: Top left output. Result of low pass filter on columns + low pass filter on rows.
• w₂::Array{T,2}: Top left output. Result of low pass filter on columns + high pass filter on rows.
• w₃::Array{T,2}: Top left output. Result of high pass filter on columns + low pass filter on rows.
• w₄::Array{T,2}: Top left output. Result of high pass filter on columns + high pass filter on rows.

Examples

using Wavelets, WaveletsExt

# Setup
v = randn(8,8)
temp = similar(v)
w₁ = Array{Float64,2}(undef, (4,4))
w₂ = Array{Float64,2}(undef, (4,4))
w₃ = Array{Float64,2}(undef, (4,4))
w₄ = Array{Float64,2}(undef, (4,4))
wt = wavelet(WT.haar)
g, h = WT.makereverseqmfpair(wt, true)

# One step of DWT
DWT.dwt_step!(w₁, w₂, w₃, w₄, v, h, g, temp)

idwt_step(w₁, w₂, h, g)

Perform one level of the inverse discrete wavelet transform (IDWT) on the vectors w₁ and w₂, which are the scaling and detail coefficients. The vectors h and g are the detail and scaling filters.

Arguments

• w₁::AbstractVector{T} where T<:Number: Vector allocation for output from low pass filter.
• w₂::AbstractVector{T} where T<:Number: Vector allocation for output from high pass filter.
• h::Vector{S} where S<:Number: High pass filter.
• g::Vector{S} where S<:Number: Low pass filter.

Returns

• v::Vector{T}: Reconstructed coefficients.

Examples

using Wavelets, WaveletsExt

# Setup
v = randn(8)
wt = wavelet(WT.haar)
g, h = WT.makereverseqmfpair(wt, true)

# One step of SDWT
w₁, w₂ = DWT.dwt_step(v, h, g)

# One step of ISDWT
v̂ = DWT.idwt_step(w₁, w₂, h, g)

See also: idwt_step!

idwt_step(w₁, w₂, w₃, w₄, h, g)

Computes one step of inverse discrete wavelet transform on 2D-signals.

Arguments

• w₁::AbstractArray{T,2} where T<:Number: Top left child coefficients.
• w₂::AbstractArray{T,2} where T<:Number: Top right child coefficients.
• w₃::AbstractArray{T,2} where T<:Number: Bottom left child coefficients.
• w₄::AbstractArray{T,2} where T<:Number: Bottom right child coefficients.
• h::Array{S,1} where S<:Number: High pass filter.
• g::Array{S,1} where S<:Number: Low pass filter.

Returns

• ::Array{T,2}: Reconstructed coefficients.

idwt_step!(v, w₁, w₂, h, g)

Same as idwt_step but without array allocation.

Arguments

• v::AbstractVector{T} where T<:Number: Vector allocation for reconstructed coefficients.
• w₁::AbstractVector{T} where T<:Number: Vector allocation for output from low pass filter.
• w₂::AbstractVector{T} where T<:Number: Vector allocation for output from high pass filter.
• h::Vector{S} where S<:Number: High pass filter.
• g::Vector{S} where S<:Number: Low pass filter.

Returns

• v::Vector{T}: Reconstructed coefficients.

Examples

using Wavelets, WaveletsExt

# Setup
v = randn(8)
v̂ = similar(v)
wt = wavelet(WT.haar)
g, h = WT.makereverseqmfpair(wt, true)

# One step of SDWT
w₁, w₂ = DWT.dwt_step(v, h, g)

# One step of ISDWT
DWT.idwt_step!(v̂, w₁, w₂, h, g)

See also: idwt_step

idwt_step!(v, w₁, w₂, w₃, w₄, h, g, temp)

Same as 2D version of idwt_step but without array allocation.

Arguments

• v::AbstractArray{T,2} where T<:Number: Array allocation for inverse transformed output.
• w₁::AbstractArray{T,2} where T<:Number: Array allocation for top left coefficients.
• w₂::AbstractArray{T,2} where T<:Number: Array allocation for top right coefficients.
• w₃::AbstractArray{T,2} where T<:Number: Array allocation for bottom left coefficients.
• w₄::AbstractArray{T,2} where T<:Number: Array allocation for bottom right coefficients.
• h::Array{S,1} where S<:Number: High pass filter.
• g::Array{S,1} where S<:Number: Low pass filter.
• temp::AbstractArray{T,2} where T<:Number: Array allocation for intermediate computations.

Returns

• v::Array{T,2}: Reconstructed coefficients.