Window Functions

window_radial_linear([T=Float64], size::NTuple; 
            offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

A multidimensional radial window with a linear transition from zero at the borders (border_out) to one (border_in). Note that border_in and border_out need to be scalar values for radial type windows. The elypticity can be adjusted via the scale parameter. With the default offset and scale the borders are specified relative to the edge.

julia> window_radial_linear((4,5),border_in=0.0)
4×5 IndexFunArray{Float64, 2, IndexFunArrays.var"#59#60"{Float64, Tuple{Float64, Float64}, Tuple{Float64, Float64}, Float64, Float64}}:
 0.0  0.0       0.0  0.0       0.0
 0.0  0.292893  0.5  0.292893  0.0
 0.0  0.5       1.0  0.5       0.0
 0.0  0.292893  0.5  0.292893  0.0

window_radial_linear(arr::AbstractArray; offset=CtrFt, scaling=ScaUnit,
                     border_in=0.8, border_out=1.0, dims=ntuple(+, N))

This is a wrapper for window_radial_linear(eltype(arr), size(arr), scaling=scaling, offset=offset, border_in=border_in, border_out=border_out).

window_hanning([T=Float64], size::NTuple; 
                   offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

A multidimensional (separable) window with a von Hann transition between the borders (border_out) to one (border_in). See ?window_linear for more details on the arguments.

window_hanning(arr::AbstractArray;
                   offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

This is a wrapper for window_hanning(eltype(arr), size(arr), scaling=scaling, offset=offset, border_in=border_in, border_out=border_out).

window_radial_hamming([T=Float64], size::NTuple; 
                      offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

A multidimensional radial window with a Hamming transition between the borders (border_out) to one (border_in). Note that border_in and border_out need to be scalar values for radial type windows. The elypticity can be adjusted via the scale parameter. See ?window_radial_linear for more details on the arguments.

window_radial_hamming(arr::AbstractArray;
                      offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

This is a wrapper for window_radial_hamming(eltype(arr), size(arr), scaling=scaling, offset=offset, border_in=border_in, border_out=border_out).

window_hamming([T=Float64], size::NTuple; 
               offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

A multidimensional (separable) window with a Hamming transition between the borders (border_out) to one (border_in). See ?window_linear for more details on the arguments.

window_hamming(arr::AbstractArray;
               offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

This is a wrapper for window_hamming(eltype(arr), size(arr), scaling=scaling, offset=offset, border_in=border_in, border_out=border_out).

window_radial_hanning([T=Float64], size::NTuple; 
                   offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

A multidimensional radial window with a von Hann transition between the borders (border_out) to one (border_in). Note that border_in and border_out need to be scalar values for radial type windows. The elypticity can be adjusted via the scale parameter. See ?window_radial_linear for more details on the arguments.

window_radial_hanning(arr::AbstractArray;
                      offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

This is a wrapper for window_radial_hanning(eltype(arr), size(arr), scaling=scaling, offset=offset, border_in=border_in, border_out=border_out).

window_edge([T=Float64], size::NTuple; 
            offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

A multidimensional (separable) window with a sudden transition half way between the borders (border_out) to one (border_in). See ?window_linear for more details on the arguments.

window_edge(arr::AbstractArray; offset=CtrFt, scaling=ScaUnit,
                                  border_in=0.8, border_out=1.0)

This is a wrapper for window_edge(eltype(arr), size(arr), scaling=scaling, offset=offset, border_in=border_in, border_out=border_out).

window_radial_blackman_harris([T=Float64], size::NTuple; 
                      offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

A multidimensional radial window with a Hamming transition according to Blackman/Harris between the borders (border_out) to one (border_in). Note that border_in and border_out need to be scalar values for radial type windows. The elypticity can be adjusted via the scale parameter. See ?window_radial_linear for more details on the arguments.

window_radial_blackman_harris(arr::AbstractArray;
                              offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

This is a wrapper for window_radial_blackman_harris(eltype(arr), size(arr), scaling=scaling, offset=offset, border_in=border_in, border_out=border_out).

window_blackman_harris([T=Float64], size::NTuple; 
                      offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

A multidimensional (separable) window with a transition according to Blackman/Harris between the borders (border_out) to one (border_in). See ?window_linear for more details on the arguments.

window_blackman_harris(arr::AbstractArray;
                      offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

This is a wrapper for window_blackman_harris(eltype(arr), size(arr), scaling=scaling, offset=offset, border_in=border_in, border_out=border_out).

window_radial_edge([T=Float64], size::NTuple; 
            offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

A multidimensional radial window (disk) with a sudden transition half way between the borders (border_out) to one (border_in). Note that border_in and border_out need to be scalar values for radial type windows. The elypticity can be adjusted via the scale parameter. See ?window_radial_linear for more details on the arguments.

window_radial_edge(arr::AbstractArray; 
                   offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

This is a wrapper for window_radial_edge(eltype(arr), size(arr), scaling=scaling, offset=offset, border_in=border_in, border_out=border_out).

window_linear([T=Float64], size::NTuple; 
            offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

A multidimensional (separable) window with a linear transition from zero at the borders (border_out) to one (border_in).

julia> window_linear((8,9),border_in=0.0)
8×9 IndexFunArray{Float64, 2, IndexFunArrays.var"#34#35"{Float64, Tuple{Float64, Float64}, Tuple{Float64, Float64}, Float64, Float64}}:
 0.0  0.0     0.0    0.0     0.0   0.0     0.0    0.0     0.0
 0.0  0.0625  0.125  0.1875  0.25  0.1875  0.125  0.0625  0.0
 0.0  0.125   0.25   0.375   0.5   0.375   0.25   0.125   0.0
 0.0  0.1875  0.375  0.5625  0.75  0.5625  0.375  0.1875  0.0
 0.0  0.25    0.5    0.75    1.0   0.75    0.5    0.25    0.0
 0.0  0.1875  0.375  0.5625  0.75  0.5625  0.375  0.1875  0.0
 0.0  0.125   0.25   0.375   0.5   0.375   0.25   0.125   0.0
 0.0  0.0625  0.125  0.1875  0.25  0.1875  0.125  0.0625  0.0

window_linear(arr::AbstractArray; offset=CtrFt, scaling=ScaUnit,
                                  border_in=0.8, border_out=1.0)

This is a wrapper for window_linear(eltype(arr), size(arr), scaling=scaling, offset=offset, border_in=border_in, border_out=border_out).

window_radial_gaussian([T=Float64], size::NTuple; 
                      offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

A multidimensional radial window with a Gaussian transition between the borders (border_out) to one (border_in). By default the standard deviation sigma of the Gaussian is adjusted such that the 2 sigma level is reached at border_out. However, this window is not clipped at the outer border, thus allowing the sigma to be adjusted by placing border_out closer to border_in. Note that border_in and border_out are scalar values for radial type windows. The elypticity can be adjusted via the scale parameter. See ?window_radial_linear for more details on the arguments.

windowradialgaussian(arr::AbstractArray; offset=CtrFT, scale=ScaFTEdge, borderin=0.8, borderout=1.0, dims=ntuple(+, N)) This is a wrapper for window_radial_gaussian(eltype(arr), size(arr), scaling=scaling, offset=offset, border_in=border_in, border_out=border_out).

window_gaussian([T=Float64], size::NTuple; 
                      offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

A multidimensional (separable) window with a transition according to a decaying Gaussian between the borders (border_out) to one (border_in). By default the standard deviation sigma of the Gaussian is adjusted such that the 2 sigma level is reached at border_out. However, this window is not clipped at the outer border, thus allowing the sigma to be adjusted by placing border_out closer to border_in. See ?window_linear for more details on the arguments.

julia> w1 = window_gaussian((9,9), border_in=(0.3,0.3), border_out=(0.6,1))
9×9 IndexFunArray{Float64, 2, IndexFunArrays.var"#286#288"{Float64, Tuple{Float64, Float64}, Tuple{Float64, Float64}, Tuple{Float64, Float64}, Tuple{Float64, Int64}}}:
 0.000109245  0.000259904  0.000413188  0.000449917  0.000449917  0.000449917  0.000413188  0.000259904  0.000109245
 0.012239     0.0291178    0.0462907    0.0504055    0.0504055    0.0504055    0.0462907    0.0291178    0.012239
 0.152725     0.363345     0.577637     0.628984     0.628984     0.628984     0.577637     0.363345     0.152725
 0.242811     0.57767      0.918365     1.0          1.0          1.0          0.918365     0.57767      0.242811
 0.242811     0.57767      0.918365     1.0          1.0          1.0          0.918365     0.57767      0.242811
 0.242811     0.57767      0.918365     1.0          1.0          1.0          0.918365     0.57767      0.242811
 0.152725     0.363345     0.577637     0.628984     0.628984     0.628984     0.577637     0.363345     0.152725
 0.012239     0.0291178    0.0462907    0.0504055    0.0504055    0.0504055    0.0462907    0.0291178    0.012239
 0.000109245  0.000259904  0.000413188  0.000449917  0.000449917  0.000449917  0.000413188  0.000259904  0.000109245

window_gaussian(arr::AbstractArray;
                      offset=CtrFT, scale=ScaFTEdge, border_in=0.8, border_out=1.0, dims=ntuple(+, N))

This is a wrapper for window_gaussian(eltype(arr), size(arr), scaling=scaling, offset=offset, border_in=border_in, border_out=border_out).