require ImageBase 0.1.5 and ImageCore 0.9.3

Author: johnnychen94

Project.toml

@@ -34,9 +34,9 @@ TiledIteration = "06e1c1a7-607b-532d-9fad-de7d9aa2abac"
 FileIO = "1"
 Graphics = "0.4, 1.0"
 ImageAxes = "0.6.9"
-ImageBase = "0.1.3"
+ImageBase = "0.1.5"
 ImageContrastAdjustment = "0.3.3"
-ImageCore = "0.9"
+ImageCore = "0.9.3"
 ImageDistances = "0.2.5"
 ImageFiltering = "0.7"
 ImageIO = "0.0.1, 0.3, 0.4, 0.5"

src/algorithms.jl

@@ -68,7 +68,7 @@ macro test_approx_eq_sigma_eps(A, B, sigma, eps)
         kern = KernelFactors.IIRGaussian($(esc(sigma)))
         Af = imfilter($(esc(A)), kern, NA())
         Bf = imfilter($(esc(B)), kern, NA())
-        diffscale = max(_abs(maxabsfinite($(esc(A)))), _abs(maxabsfinite($(esc(B)))))
+        diffscale = max(_abs(maximum_finite(abs, $(esc(A)))), _abs(maximum_finite(abs, $(esc(B)))))
         d = sad(Af, Bf)
         if d > length(Af)*diffscale*($(esc(eps)))
             error("Arrays A and B differ")
@@ -104,7 +104,7 @@ function test_approx_eq_sigma_eps(A::AbstractArray, B::AbstractArray,
     kern = KernelFactors.IIRGaussian(sigma)
     Af = imfilter(A, kern, NA())
     Bf = imfilter(B, kern, NA())
-    diffscale = max(_abs(maxabsfinite(A)), _abs(maxabsfinite(B)))
+    diffscale = max(_abs(maximum_finite(abs, A)), _abs(maximum_finite(abs, B)))
     d = sad(Af, Bf)
     diffpct = d / (length(Af) * diffscale)
     if diffpct > eps
@@ -131,42 +131,6 @@ end
 imgaussiannoise(img::AbstractArray{T}, variance::Number) where {T} = imgaussiannoise(img, variance, 0)
 imgaussiannoise(img::AbstractArray{T}) where {T} = imgaussiannoise(img, 0.01, 0)
 
-# image gradients
-
-function div(p::AbstractArray{T,3}) where T
-    # Definition from the Chambolle citation below, between Eqs. 5 and 6
-    # This is the adjoint of -forwarddiff
-    inds = axes(p)[1:2]
-    out = similar(p, inds)
-    Router = CartesianIndices(inds)
-    rstp = _oneunit(first(Router))
-    Rinner = _clippedinds(Router,rstp)
-    # Since most of the points are in the interior, compute them more quickly by avoiding branches
-    for I in Rinner
-        out[I] = p[I,1] - p[I[1]-1, I[2], 1] +
-                 p[I,2] - p[I[1], I[2]-1, 2]
-    end
-    # Handle the edge points
-    for I in EdgeIterator(Router, Rinner)
-        out[I] = 0
-        if I[1] == first(inds[1])
-            out[I] += p[I, 1]
-        elseif I[1] == last(inds[1])
-            out[I] -= p[I[1]-1, I[2], 1]
-        else
-            out[I] += p[I,1] - p[I[1]-1, I[2], 1]
-        end
-        if I[2] == first(inds[2])
-            out[I] += p[I, 2]
-        elseif I[2] == last(inds[2])
-            out[I] -= p[I[1], I[2]-1, 2]
-        else
-            out[I] += p[I,2] - p[I[1], I[2]-1, 2]
-        end
-    end
-    out
-end
-
 """
 ```
 imgr = imROF(img, λ, iterations)
@@ -188,12 +152,12 @@ function imROF(img::AbstractMatrix{T}, λ::Number, iterations::Integer) where T<
     s1, s2 = size(img)
     p = zeros(T, s1, s2, 2)
     # This iterates Eq. (9) of the Chambolle citation
-    local u
+    u = similar(img)
     τ = 1/4   # see 2nd remark after proof of Theorem 3.1.
     for i = 1:iterations
-        div_p = div(p)
-        u = img - λ*div_p # multiply term inside ∇ by -λ. Thm. 3.1 relates this to u via Eq. 7.
-        grad_u = cat(fdiff(u, dims=1, boundary=:zero), fdiff(u, dims=2, boundary=:zero), dims=3)
+        div_p = ImageBase.FiniteDiff.fdiv(view(p, :, :, 1), view(p, :, :, 2))
+        u .= img - λ*div_p # multiply term inside ∇ by -λ. Thm. 3.1 relates this to u via Eq. 7.
+        grad_u = cat(ImageBase.fdiff(u, dims=1, boundary=:zero), ImageBase.fdiff(u, dims=2, boundary=:zero), dims=3)
         grad_u_mag = sqrt.(sum(abs2, grad_u, dims=3))
         p .= (p .- (τ/λ).*grad_u)./(1 .+ (τ/λ).*grad_u_mag)
     end

src/deprecations.jl

@@ -1077,10 +1077,10 @@ function ColorVectorSpace.complement(x::AbstractArray)
 end
 
 # ImageBase.fdiff is more performent and generic
-@deprecate forwarddiffx(X) fdiff(X, dims=2, boundary=:zero)
-@deprecate forwarddiffy(X) fdiff(X, dims=1, boundary=:zero)
-@deprecate backdiffx(X) fdiff(X, dims=2, rev=true, boundary=:zero)
-@deprecate backdiffy(X) fdiff(X, dims=1, rev=true, boundary=:zero)
+@deprecate forwarddiffx(X) ImageBase.FiniteDiff.fdiff(X, dims=2, boundary=:zero)
+@deprecate forwarddiffy(X) ImageBase.FiniteDiff.fdiff(X, dims=1, boundary=:zero)
+@deprecate backdiffx(X) ImageBase.FiniteDiff.fdiff(X, dims=2, rev=true, boundary=:zero)
+@deprecate backdiffy(X) ImageBase.FiniteDiff.fdiff(X, dims=1, rev=true, boundary=:zero)
 
 # This is now replaced by ImageTransformations and Interpolations
 function bilinear_interpolation(img::AbstractArray{T,N}, xs::Vararg{<:Number, N}) where {T,N}
@@ -1144,3 +1144,5 @@ end
 @deprecate boxdiff(Ai::IntegralArray{T,2}, y::UnitRange, x::UnitRange) where T               Ai[first(y)..last(y), first(x)..last(x)]
 @deprecate boxdiff(Ai::IntegralArray{T,2}, tl::CartesianIndex, br::CartesianIndex) where T   Ai[tl[1]..br[1], tl[2]..br[2]]
 @deprecate boxdiff(Ai::IntegralArray{T,2}, tl_y::Integer, tl_x::Integer, br_y::Integer, br_x::Integer) where T  Ai[tl_y..br_y, tl_x..br_x]
+
+@deprecate div(A::AbstractArray{<:Any,3}) ImageBase.FiniteDiff.fdiv(view(A, :, :, 1), view(A, :, :, 2)) false

test/algorithms.jl

@@ -250,12 +250,6 @@ using Test, Suppressor
     end
 
     @testset "imROF" begin
-        # Test that -div is the adjoint of forwarddiff
-        p = rand(3,3,2)
-        u = rand(3,3)
-        gu = cat(fdiff(u, dims=1, boundary=:zero), fdiff(u, dims=2, boundary=:zero), dims=3)
-        @test sum(-Images.div(p) .* u) ≈ sum(p .* gu)
-
         img = [0.1 0.2 0.1 0.8 0.9 0.7;
                0.2 0.1 0.1 0.8 0.1 0.8;
                0.1 0.2 0.1 0.7 0.9 0.8]

test/legacy.jl

@@ -286,4 +286,16 @@ using Images, Images.OffsetArrays, Statistics, Test
         @test @inferred(component_centroids(lbltarget)) == Tuple[(1.5,2.5),(4/3,4/3),(5/3,11/3)]
     end
 
+    # moved to ImageBase.FiniteDiff.fdiv
+    @testset "div" begin
+        # Test that -div is the adjoint of forwarddiff
+        p = rand(3,3,2)
+        u = rand(3,3)
+        gu = cat(
+            ImageBase.FiniteDiff.fdiff(u, dims=1, boundary=:periodic),
+            ImageBase.FiniteDiff.fdiff(u, dims=2, boundary=:periodic),
+            dims=3)
+        @test sum(-Images.div(p) .* u) ≈ sum(p .* gu)
+    end
+
 end