abstract type BoundaryExtension end

Abstract type associated to boundary extension.

struct ConstantBE <: BoundaryExtension end

A type used to tag constant constant extension

abstract type LinearFilter{T<:Number} end

Abstract type defining a linear filter.

struct LinearFilter_Default{T<:Number,N}

Default linear filter.

You can create a filter as follows

julia> linear_filter=LinearFilter([1,-2,1],1)
Filter(r=-1:1,c=[1.0, -2.0, 1.0])


julia> offset(linear_filter)
1


julia> range(linear_filter)
-1:1

struct MirrorBE <: BoundaryExtension end

A type used to tag mirror extension

struct PeriodicBE <: BoundaryExtension end

A type used to tag periodic extension

function SG_Filter(T::DataType=Float64;halfWidth::Int=5,degree::Int=2)

Creates a SG_Filter structure used to store Savitzky-Golay filters.

• filter length is 2*halfWidth+1
• polynomial degree is degree, which defines maxDerivativeOrder

You can apply these filters using the

• apply_SG_filter
• apply_SG_filter2D

functions.

Example:

julia> sg = SG_Filter(halfWidth=5,degree=3);


julia> maxDerivativeOrder(sg)
3

julia> length(sg)
11

julia> filter(sg,derivativeOrder=2)
Filter(r=-5:5,c=[0.03497, 0.01399, -0.002331, -0.01399, -0.02098, -0.02331, -0.02098, -0.01399, -0.002331, 0.01399, 0.03497])

abstract type UDWT_Filter{T<:Number} <: UDWT_Filter_Biorthogonal{T} end

A specialization of UDWT_Filter_Biorthogonal for orthogonal filters.

For orthogonal filters we have: ϕ=tildeϕ, ψ=tildeψ

abstract type UDWT_Filter_Biorthogonal{T<:Number} end

Abstract type defining the ϕ, ψ, tildeϕ and tildeψ filters associated to an undecimated biorthogonal wavelet transform

Subtypes of this structure are:

• UDWT_Filter

Associated methods are:

• ϕ_filter
• ψ_filter
• tildeϕ_filter
• tildeψ_filter

struct ZeroPaddingBE <: BoundaryExtension end

A type used to tag zero padding extension

function filter(sg::SG_Filter{T,N};derivativeOrder::Int=0)

Returns the filter to be used to compute the smoothed derivatives of order derivativeOrder.

See: SG_Filter

length(c::LinearFilter)::Int

Returns filter length

function length(sg::SG_Filter{T,N})

Returns filter length, this is an odd number.

See: SG_Filter

range(c::LinearFilter)::UnitRange

Returns filter range Ω

Filter support of a filter α is defined by Ω = [ - offset(α), length(α) - offset(α) - 1 ]

function apply_SG_filter(signal::Array{T,1},
                         sg::SG_Filter{T};
                         derivativeOrder::Int=0,
                         left_BE::Type{<:BoundaryExtension}=ConstantBE,
                         right_BE::Type{<:BoundaryExtension}=ConstantBE)

Applies an 1D Savitzky-Golay and returns the smoothed signal.

function apply_SG_filter2D(signal::Array{T,2},
                           sg_I::SG_Filter{T},
                           sg_J::SG_Filter{T};
                           derivativeOrder_I::Int=0,
                           derivativeOrder_J::Int=0,
                           min_I_BE::Type{<:BoundaryExtension}=ConstantBE,
                           max_I_BE::Type{<:BoundaryExtension}=ConstantBE,
                           min_J_BE::Type{<:BoundaryExtension}=ConstantBE,
                           max_J_BE::Type{<:BoundaryExtension}=ConstantBE)

Applies an 2D Savitzky-Golay and returns the smoothed signal.

boundaryExtension(β::AbstractArray{T,1},
                  k::Int,
                  ::Type{BOUNDARY_EXT_TYPE})

Computes extended boundary value β[k] given boundary extension type BOUNDARY_EXT_TYPE

Available BOUNDARY_EXT_TYPE are:

• ZeroPaddingBE: zero padding
• ConstantBE: constant boundary extension padding
• PeriodicBE: periodic boundary extension padding
• MirrorBE: mirror symmetry boundary extension padding

The routine is robust in the sens that there is no restriction on k value.

julia> dom = [-5:10;];

julia> hcat(dom,map(x->boundaryExtension([1; 2; 3],x,ZeroPaddingBE),dom))'
2×16 adjoint(::Matrix{Int64}) with eltype Int64:
 -5  -4  -3  -2  -1  0  1  2  3  4  5  6  7  8  9  10
  0   0   0   0   0  0  1  2  3  0  0  0  0  0  0   0

julia> hcat(dom,map(x->boundaryExtension([1; 2; 3],x,ConstantBE),dom))'
2×16 adjoint(::Matrix{Int64}) with eltype Int64:
 -5  -4  -3  -2  -1  0  1  2  3  4  5  6  7  8  9  10
  1   1   1   1   1  1  1  2  3  3  3  3  3  3  3   3

julia> hcat(dom,map(x->boundaryExtension([1; 2; 3],x,PeriodicBE),dom))'
2×16 adjoint(::Matrix{Int64}) with eltype Int64:
 -5  -4  -3  -2  -1  0  1  2  3  4  5  6  7  8  9  10
  1   2   3   1   2  3  1  2  3  1  2  3  1  2  3   1

julia> hcat(dom,map(x->boundaryExtension([1; 2; 3],x,MirrorBE),dom))'
2×16 adjoint(::Matrix{Int64}) with eltype Int64:
 -5  -4  -3  -2  -1  0  1  2  3  4  5  6  7  8  9  10
  3   2   1   2   3  2  1  2  3  2  1  2  3  2  1   2

directConv!

Computes a convolution.

\[\gamma[k]=\sum\limits_{i\in\Omega^\alpha}\alpha[i]\beta[k+\lambda i]\]

The following example shows how to apply inplace the [0 0 1] filter on γ[5:10]

julia> β=[1:15;];

julia> γ=ones(Int,15);

julia> α=LinearFilter([0,0,1],0);

julia> directConv!(α,1,β,γ,5:10)

julia> hcat([1:length(γ);],γ)
15×2 Matrix{Int64}:
  1   1
  2   1
  3   1
  4   1
  5   7
  6   8
  7   9
  8  10
  9  11
 10  12
 11   1
 12   1
 13   1
 14   1
 15   1

fcoef(c::LinearFilter)

Returns filter coefficients

function maxDerivativeOrder(sg::SG_Filter{T,N})

Maximum order of the smoothed derivatives we can compute using sg filters.

See: SG_Filter

offset(c::LinearFilter)::Int

Returns filter offset

Caveat: the first position is 0 (and not 1)

function polynomialOrder(sg::SG_Filter{T,N})

Returns the degree of the polynomial used to construct the Savitzky-Golay filters. This is mainly a 'convenience' function, as it is equivalent to maxDerivativeOrder

See: SG_Filter

scale(λ::Int,Ω::UnitRange{Int})

Range scaling.

Caveat:

We do not use Julia * operator as it returns a step range:

julia> r=6:8
6:8

julia> -2*r
-12:-2:-16

What we need is:

julia> r=6:8
6:8

julia> scale(-2,r)
-16:-12

ϕ_filter(c::UDWT_Filter_Biorthogonal)

Returns the ϕ filter