Add some precompiles (#201)

On the current release, the first call looks like this:
```julia
julia> @time imfilter(img, KernelFactors.gaussian((3,3)));
  2.135609 seconds (3.46 M allocations: 211.109 MiB, 12.01% gc time, 94.98% compilation time)

julia> @time mapwindow(extrema, img, (3,3))
  0.756083 seconds (1.17 M allocations: 68.258 MiB, 6.57% gc time, 99.89% compilation time)
```

On this branch, it looks like this:
```julia
julia> @time imfilter(img, KernelFactors.gaussian((3,3)));
  0.620004 seconds (362.78 k allocations: 40.455 MiB, 1.47% gc time, 96.09% compilation time)

julia> @time mapwindow(extrema, img, (3,3))
  0.385470 seconds (334.52 k allocations: 19.585 MiB, 9.43% gc time, 99.82% compilation time)
```

Quite a nice reduction in latency.

Author: timholy

precompile/script.jl

@@ -0,0 +1,54 @@
+# This is to be used with `@snoopi_deep` from SnoopCompile
+
+using SnoopCompile
+using ImageCore
+using Statistics
+
+images2d = [rand(Float32, 100, 100),
+            rand(Float64, 100, 100),
+            rand(Gray{N0f8}, 100, 100),
+            rand(Gray{N0f16}, 100, 100),
+            rand(RGB{N0f8}, 100, 100),
+]
+
+images3d = [rand(Gray{N0f16}, 100, 100, 10),
+]
+
+tinf = @snoopi_deep begin
+    using ImageFiltering
+
+    Kernel.gaussian((3,3))
+    Kernel.gaussian((3.0,3.0))
+    Kernel.DoG(3)
+    Kernel.DoG(3.0)
+    Kernel.Laplacian()
+    Kernel.LoG(3)
+    Kernel.LoG(3.0)
+    Kernel.sobel()
+
+    KernelFactors.gaussian((3,3))
+    KernelFactors.gaussian((3.0,3.0))
+    KernelFactors.IIRGaussian((3,3))
+    KernelFactors.IIRGaussian(3.0)
+    KernelFactors.sobel()
+
+    for img in images2d
+        for kern in (Kernel.gaussian((3,3)),
+                     KernelFactors.gaussian((3,3)),
+                     KernelFactors.IIRGaussian((3.0, 3.0)))
+            imfilter(img, kern)
+        end
+        if eltype(img) <: Union{Number,Gray}
+            mapwindow(extrema, img, (3,3))
+            mapwindow(median!, img, (3,3))
+        end
+    end
+
+    for img in images3d
+        for kern in (Kernel.gaussian((3,3,3)),
+                     KernelFactors.gaussian((3,3,3)),
+                     KernelFactors.IIRGaussian((3.0, 3.0, 3.0)))
+            imfilter(img, kern)
+        end
+    end
+end

src/ImageFiltering.jl

@@ -102,4 +102,8 @@ function __init__()
     end
 end
 
+if Base.VERSION >= v"1.4.2"
+    include("precompile.jl")
+end
+
 end # module

src/border.jl

@@ -660,7 +660,7 @@ The command `padarray(A,Fill(0,(1,1,1)))` yields
 padarray(img::AbstractArray, border::AbstractBorder)  = padarray(eltype(img), img, border)
 function padarray(::Type{T}, img::AbstractArray, border) where {T}
     ba = BorderArray(img, border)
-    out = similar(ba, T)
+    out = similar(ba, T, axes(ba))
     copy!(out, ba)
 end
 
@@ -897,23 +897,24 @@ end
 
 Generate an index-vector to be used for padding. `inds` specifies the image axes along a particular axis; `lo` and `hi` are the amount to pad on the lower and upper, respectively, sides of this axis. `border` specifying the style of padding.
 """
-function padindex(border::Pad, lo::Integer, inds::AbstractUnitRange, hi::Integer)
+function padindex(border::Pad, lo::Int, inds::UnitRange{Int}, hi::Int)
     if border.style == :replicate
-        indsnew = vcat(fill(first(inds), lo), UnitRange(inds), fill(last(inds), hi))
+        indsnew = Int[fill(first(inds), lo); inds; fill(last(inds), hi)]
         OffsetArray(indsnew, first(inds)-lo:last(inds)+hi)
     elseif border.style == :circular
         return modrange(extend(lo, inds, hi), inds)
     elseif border.style == :symmetric
-        I = OffsetArray([inds; reverse(inds)], (0:2*length(inds)-1) .+ first(inds))
+        I = OffsetArray(Int[inds; reverse(inds)], (0:2*length(inds)-1) .+ first(inds))
         r = modrange(extend(lo, inds, hi), axes(I, 1))
         return I[r]
     elseif border.style == :reflect
-        I = OffsetArray([inds; last(inds)-1:-1:first(inds)+1], (0:2*length(inds)-3) .+ first(inds))
+        I = OffsetArray(Int[inds; last(inds)-1:-1:first(inds)+1], (0:2*length(inds)-3) .+ first(inds))
         return I[modrange(extend(lo, inds, hi), axes(I, 1))]
     else
         error("border style $(border.style) unrecognized")
     end
 end
+padindex(border::Pad, lo::Integer, inds::AbstractUnitRange, hi::Integer) = padindex(border, Int(lo)::Int, UnitRange{Int}(inds)::UnitRange{Int}, Int(hi)::Int)
 function padindex(border::Pad, inner::AbstractUnitRange, outer::AbstractUnitRange)
     lo = max(0, first(inner)-first(outer))
     hi = max(0, last(outer)-last(inner))

src/kernel.jl

@@ -484,4 +484,14 @@ end
 
 reflectind(r::AbstractUnitRange) = -last(r):-first(r)
 
+if Base.VERSION >= v"1.4.2" && ccall(:jl_generating_output, Cint, ()) == 1
+    precompile(Laplacian, ())
+    precompile(sobel, ())
+    for T in (Int, Float64, Float32)
+        precompile(gaussian, (Tuple{T,T},))
+        precompile(DoG, (T,))
+        precompile(LoG, (T,))
+    end
+end
+
 end

src/kernelfactors.jl

@@ -408,12 +408,13 @@ Construct a 1d gaussian kernel `g` with standard deviation `σ`, optionally
 providing the kernel length `l`. The default is to extend by two `σ`
 in each direction from the center. `l` must be odd.
 """
-function gaussian(σ::Real, l = 4*ceil(Int,σ)+1)
+function gaussian(σ::Real, l::Int = 4*ceil(Int,σ)+1)
     isodd(l) || throw(ArgumentError("length must be odd"))
     w = l>>1
     g = σ == 0 ? [exp(0/(2*oftype(σ, 1)^2))] : [exp(-x^2/(2*σ^2)) for x=-w:w]
     centered(g/sum(g))
 end
+gaussian(σ::Real, l::Integer) = gaussian(σ, Int(l)::Int)
 
 """
     gaussian((σ1, σ2, ...), [l]) -> (g1, g2, ...)
@@ -424,8 +425,8 @@ provide the kernel length `l`, which must be a tuple of the same
 length.
 """
 gaussian(σs::NTuple{N,Real}, ls::NTuple{N,Integer}) where {N} =
-    kernelfactors( map((σ,l)->gaussian(σ,l), σs, ls) )
-gaussian(σs::NTuple{N,Real}) where {N} = kernelfactors(map(σ->gaussian(σ), σs))
+    kernelfactors( map(gaussian, σs, ls) )
+gaussian(σs::NTuple{N,Real}) where {N} = kernelfactors(map(gaussian, σs))
 
 gaussian(σs::AbstractVector, ls::AbstractVector) = gaussian((σs...,), (ls...,))
 gaussian(σs::AbstractVector) = gaussian((σs...,))
@@ -573,4 +574,14 @@ end
 
 kdim(keep::Bool, k) = keep ? centered(k) : OffsetArray([oneunit(eltype(k))], 0:0)
 
+if Base.VERSION >= v"1.4.2" && ccall(:jl_generating_output, Cint, ()) == 1
+    precompile(sobel, ())
+    for T in (Int, Float64, Float32)
+        precompile(gaussian, (Tuple{T,T},))
+        precompile(gaussian, (T,))
+        precompile(gaussian, (T, Int))
+        precompile(IIRGaussian, (Tuple{T,T},))
+    end
+end
+
 end

src/mapwindow.jl

@@ -61,8 +61,8 @@ and then `mapwindow(f, img, (m,n))` should filter at the 75th quantile.
 
 See also: [`imfilter`](@ref).
 """
-function mapwindow(f, img, window; border="replicate",
-                   indices=default_imginds(img, window, border), callmode=:copy!)
+function mapwindow(f::F, img, window; border="replicate",
+                   indices=default_imginds(img, window, border), callmode=:copy!) where F
     if callmode != :copy!
         error("Only callmode=:copy! is currently supported")
     end
@@ -88,7 +88,7 @@ function default_imginds(img, window, border::Inner)
     map(self_offset, indind)
 end
 
-function _mapwindow(f, img, window, border, imginds)
+function _mapwindow(f::F, img, window, border, imginds) where F
     out = allocate_output(f, img, window, border, imginds)
     mapwindow_kernel!(f, out, img, window, border, imginds)
 end
@@ -223,20 +223,20 @@ function _indices_of_interiour_indices(fullimginds, imginds, kerinds)
     map(_indices_of_interiour_range, fullimginds, imginds, kerinds)
 end
 
-function allocate_output(f, img, window, border, imginds)
+function allocate_output(f::F, img, window, border, imginds) where F
     T = compute_output_eltype(f, img, window, border, imginds)
     outinds = compute_output_indices(imginds)
     similar(img, T, outinds)
 end
 
-function allocate_buffer(f, img, window)
+function allocate_buffer(f::F, img, window) where F
     T = eltype(img)
     buf = Array{T}(undef,map(length, window))
     bufrs = default_shape(f)(buf)
     buf, bufrs
 end
 
-function compute_output_eltype(f, img, window, border, imginds)
+function compute_output_eltype(f::F, img, window, border, imginds) where F
     buf, bufrs = allocate_buffer(f, img, window)
     make_buffer_values_realistic!(buf, img, window, border, imginds)
     typeof(f(bufrs))
@@ -383,8 +383,8 @@ function _extrema_filter!(A::AbstractArray, w1, w...)
     if w1 > 1
         a = first(A)
         if w1 <= 20
-            cache = ntuple(i->a, w1>>1)
-            _extrema_filter1!(A, w1, cache)
+            cache = ntuple(i->a, w1>>1)      # this line is not inferrable, and contributes to latency via...
+            _extrema_filter1!(A, w1, cache)  # ...extensive specialization of _extrema_filter1! (on typeof(A) and value of w1)
         else
             n = w1>>1
             cache = CircularDeque{typeof(a)}(n)
@@ -395,7 +395,7 @@ function _extrema_filter!(A::AbstractArray, w1, w...)
         end
     end
     if ndims(A) > 1
-        _extrema_filter!(permutedims(A, [2:ndims(A);1]), w...)
+        _extrema_filter!(permutedims(A, [2:ndims(A);1:1]), w...)
     else
         return A
     end

src/precompile.jl

@@ -0,0 +1,37 @@
+if ccall(:jl_generating_output, Cint, ()) == 1
+    let
+        images2d = [rand(Float32, 100, 100),
+                    rand(Float64, 100, 100),
+                    rand(Gray{N0f8}, 100, 100),
+                    rand(Gray{N0f16}, 100, 100),
+                    rand(RGB{N0f8}, 100, 100),
+        ]
+        images3d = [rand(Gray{N0f16}, 100, 100, 10),
+        ]
+
+        for img in images2d
+            for kern in (Kernel.gaussian((3,3)),
+                        KernelFactors.gaussian((3,3)),
+                        KernelFactors.IIRGaussian((3.0, 3.0)))
+                for r in (CPU1(FIR()), CPUThreads(FIRTiled((5,5))), CPU1(FFT()))
+                    @assert precompile(imfilter, (typeof(r), typeof(img), typeof(kern)))
+                end
+                @assert precompile(imfilter, (typeof(img), typeof(kern)))
+            end
+            if eltype(img) <: Union{Number,Gray}
+                @assert precompile(mapwindow, (typeof(extrema), typeof(img), typeof((3,3))))
+                @assert precompile(mapwindow, (typeof(median!), typeof(img), typeof((3,3))))
+            end
+        end
+        for img in images3d
+            for kern in (Kernel.gaussian((3,3,3)),
+                         KernelFactors.gaussian((3,3,3)),
+                         KernelFactors.IIRGaussian((3.0, 3.0, 3.0)))
+                for r in (CPU1(FIR()), CPUThreads(FIRTiled((5,5))), CPU1(FFT()))
+                    @assert precompile(imfilter, (typeof(r), typeof(img), typeof(kern)))
+                end
+                @assert precompile(imfilter, (typeof(img), typeof(kern)))
+            end
+        end
+    end
+end