Type alias Kernel{N}

Author: emmt

src/linear.jl

@@ -219,15 +219,10 @@ for (f, order) in ((:correlate, :FORWARD_FILTER),
                    (:convolve,  :REVERSE_FILTER))
     f! = Symbol(f,"!")
     @eval begin
-        function $f(A::AbstractArray{<:Any,N},
-                    B::Union{Window{N},AbstractArray{<:Any,N}}) where {N}
-            return sumprod(A, kernel(Dims{N}, B); order = $order)
-        end
-        function $f!(dst::AbstractArray{<:Any,N},
-                     A::AbstractArray{<:Any,N},
-                     B::Union{Window{N},AbstractArray{<:Any,N}}) where {N}
-            return sumprod!(dst, A, kernel(Dims{N}, B); order = $order)
-        end
+        $f(A::AbstractArray{<:Any,N}, B::Kernel{N}) where {N} =
+            sumprod(A, kernel(Dims{N}, B); order = $order)
+        $f!(dst::AbstractArray{<:Any,N}, A::AbstractArray{<:Any,N}, B::Kernel{N}) where {N} =
+            sumprod!(dst, A, kernel(Dims{N}, B); order = $order)
     end
 end
 

src/morphology.jl

@@ -359,7 +359,7 @@ for f in (:closing, :opening)
     @eval begin
         # Provide destination and workspace.
         function $f(A::AbstractArray{<:Any,N},
-                    B::Union{Window{N},AbstractArray{<:Any,N}} = 3; kwds...) where {N}
+                    B::Kernel{N} = 3; kwds...) where {N}
             return $f!(similar(A), similar(A), A, B; kwds...)
         end
 
@@ -411,7 +411,7 @@ See also [`top_hat`](@ref) for more details.
 function top_hat!(dst::AbstractArray{<:Any,N},
                   wrk::AbstractArray{<:Any,N},
                   A::AbstractArray{<:Any,N},
-                  B::Union{Window{N},AbstractArray{<:Any,N}}; kwds...) where {N}
+                  B::Kernel{N}; kwds...) where {N}
     opening!(dst, wrk, A, B; kwds...)
     @inbounds for i in eachindex(dst, A)
         dst[i] = A[i] - dst[i]
@@ -453,10 +453,8 @@ different arrays. The destination `dst` is returned.
 See also [`bottom_hat`](@ref) for more details.
 
 """
-function bottom_hat!(dst::AbstractArray{<:Any,N},
-                     wrk::AbstractArray{<:Any,N},
-                     A::AbstractArray{<:Any,N},
-                     B::Union{Window{N},AbstractArray{<:Any,N}}; kwds...) where {N}
+function bottom_hat!(dst::AbstractArray{<:Any,N}, wrk::AbstractArray{<:Any,N},
+                     A::AbstractArray{<:Any,N}, B::Kernel{N} = 3; kwds...) where {N}
     closing!(dst, wrk, A, B; kwds...)
     @inbounds for i in eachindex(dst, A)
         dst[i] -= A[i]
@@ -471,13 +469,9 @@ for (f, pf!) in ((:top_hat,    :(closing!)),
     @eval begin
         # Provide destination and workspace. Out-of-place top/bottom hat filters require 2
         # allocations without a pre-filtering, 3 allocations with a pre-filtering.
-        function $f(A::AbstractArray{<:Any,N},
-                    B::Union{Window{N},AbstractArray{<:Any,N}} = 3; kwds...) where {N}
-            return $f!(similar(A), similar(A), A, B; kwds...)
-        end
-        function $f(A::AbstractArray{<:Any,N},
-                    B::Union{Window{N},AbstractArray{<:Any,N}},
-                    C::Union{Window{N},AbstractArray{<:Any,N}};
+        $f(A::AbstractArray{<:Any,N}, B::Kernel{N} = 3; kwds...) where {N} =
+            $f!(similar(A), similar(A), A, B; kwds...)
+        function $f(A::AbstractArray{<:Any,N}, B::Kernel{N}, C::Kernel{N};
                     order::Union{FilterOrdering,NTuple{2,FilterOrdering}} = FORWARD_FILTER,
                     kwds...) where {N}
             B_order = order isa FilterOrdering ? order : order[1]

src/types.jl

@@ -29,14 +29,29 @@ struct Indices{S<:IndexStyle} <: Function end
 """
     LocalFilters.Window{N}
 
-is the union of types of arguments suitable to define a simple `N`-dimensional
-hyper-rectangular sliding window and that can be converted into a kernel by the
-[`LocalFilters.kernel`](@ref) method.
+is the union of types for an argument `B` to be suitable to define a simple
+`N`-dimensional hyper-rectangular sliding window and that can be converted into a
+`Box{N}`, that is a `N`-dimensional uniformly true kernel array by [`kernel(Dims{N},
+B)`](@ref LocalFilters.kernel).
+
+
+ a kernel
+by the [`LocalFilters.kernel`](@ref) method.
 
 """
 const Window{N} = Union{Axis,NTuple{N,Axis},NTuple{2,CartesianIndex{N}},
                         CartesianIndices{N}}
 
+"""
+    LocalFilters.Kernel{N}
+
+is the union of types for an argument `B` to be suitable to define a `N`-dimensional
+kernel or filter that can be converted into a `N`-dimensional kernel array by
+[`kernel(Dims{N}, B)`](@ref LocalFilters.kernel).
+
+"""
+const Kernel{N} = Union{Window{N},AbstractArray{<:Any,N}}
+
 """
     const LocalFilters.Box{N} = FastUniformArray{Bool,N,true}