🧹 Move restrict to ImageAxes and ImageMetadata

We used to host `restrict` in ImageTransformations, which is a big dependency
for ImageAxes and ImageMetadata. Thus specialized `restrict` methods for those
data types are kept in Images. Now that we have `restrict` in ImageBase, we can
move these specialized methods to ImageAxes and ImageMetadata.

This commit requires three new versions:

- ImageBase v0.1.2: this version fixes some of old `restrict` type inferrence issues.
- ImageAxes v0.6.9: JuliaImages/ImageAxes.jl#59
- ImageMetadata v0.9.7: JuliaImages/ImageMetadata.jl#79

AxisArrays is no longer needed because the method is moved to ImageAxes.

ImageTransformations <v0.9 compatibility is dropped so that we can avoid
symbol conflict on `restrict`.

Author: johnnychen94

Project.toml

@@ -3,7 +3,6 @@ uuid = "916415d5-f1e6-5110-898d-aaa5f9f070e0"
 version = "0.24.1"
 
 [deps]
-AxisArrays = "39de3d68-74b9-583c-8d2d-e117c070f3a9"
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
 FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549"
 Graphics = "a2bd30eb-e257-5431-a919-1863eab51364"
@@ -31,22 +30,21 @@ StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
 TiledIteration = "06e1c1a7-607b-532d-9fad-de7d9aa2abac"
 
 [compat]
-AxisArrays = "0.3, 0.4"
 FileIO = "1"
 Graphics = "0.4, 1.0"
-ImageAxes = "0.6"
+ImageAxes = "0.6.9"
 ImageBase = "0.1.5"
 ImageContrastAdjustment = "0.3.3"
 ImageCore = "0.9.3"
 ImageDistances = "0.2.5"
 ImageFiltering = "0.6.3"
 ImageIO = "0.0.1, 0.3, 0.4, 0.5"
 ImageMagick = "0.7.5, 1"
-ImageMetadata = "0.6, 0.7, 0.8, 0.9"
+ImageMetadata = "0.9.7"
 ImageMorphology = "0.2.7"
 ImageQualityIndexes = "0.1.3, 0.2"
 ImageShow = "0.1, 0.2, 0.3"
-ImageTransformations = "0.4, 0.5, 0.6, 0.7, 0.8"
+ImageTransformations = "0.9"
 IndirectArrays = "0.5"
 OffsetArrays = "0.8, 0.9, 0.10, 0.11, 1.0.1"
 Reexport = "0.2, 1.0"

src/Images.jl

@@ -99,9 +99,7 @@ end
 # in deprecations.jl
 import ImageContrastAdjustment: build_histogram, adjust_histogram, adjust_histogram!
 
-using ImageMetadata: ImageMetaAxis
 import ImageMorphology: dilate, erode
-import ImageTransformations: restrict
 using TiledIteration: EdgeIterator
 
 include("compat.jl")
@@ -131,7 +129,6 @@ export
     nimages,
     pixelspacing,
     properties,
-    restrict,
     sdims,
     size_spatial,
     shareproperties,

src/algorithms.jl

@@ -2,7 +2,6 @@ using Base: axes1, tail
 using OffsetArrays
 import Statistics
 using Statistics: mean, var
-import AxisArrays
 using ImageMorphology: dilate!, erode!
 
 function Statistics.var(A::AbstractArray{C}; kwargs...) where C<:AbstractGray
@@ -285,50 +284,6 @@ Like `findlocalmaxima`, but returns the coordinates of the smallest elements.
 findlocalminima(img::AbstractArray, region=coords_spatial(img), edges=true) =
         findlocalextrema(img, region, edges, Base.Order.Reverse)
 
-# restrict for AxisArray and ImageMeta
-restrict(img::AxisArray, ::Tuple{}) = img
-restrict(img::ImageMeta, ::Tuple{}) = img
-
-function restrict(img::ImageMeta, region::Dims)
-    shareproperties(img, restrict(arraydata(img), region))
-end
-
-function restrict(img::AxisArray{T,N}, region::Dims) where {T,N}
-    inregion = falses(ndims(img))
-    inregion[[region...]] .= true
-    inregiont = (inregion...,)::NTuple{N,Bool}
-    rdata = restrict(img.data, region)
-    AxisArray(rdata, map(modax, AxisArrays.axes(img), axes(rdata), inregiont))
-end
-
-# FIXME: this doesn't get inferred, but it should be (see issue #628)
-function restrict(img::Union{AxisArray,ImageMetaAxis}, ::Type{Ax}) where Ax
-    dim = axisdim(img, Ax)
-    A = restrict(img.data, dim)
-    AxisArray(A, replace_axis(modax(img[Ax], axes(A)[dim]), AxisArrays.axes(img)))
-end
-
-replace_axis(newax, axs) = _replace_axis(newax, axnametype(newax), axs...)
-@inline _replace_axis(newax, ::Type{Ax}, ax::Ax, axs...) where {Ax} = (newax, _replace_axis(newax, Ax, axs...)...)
-@inline _replace_axis(newax, ::Type{Ax}, ax, axs...) where {Ax} = (ax, _replace_axis(newax, Ax, axs...)...)
-_replace_axis(newax, ::Type{Ax}) where {Ax} = ()
-
-axnametype(ax::Axis{name}) where {name} = Axis{name}
-
-ofaxes(::Base.OneTo, r) = r
-ofaxes(axs::Any, r) = OffsetArray(r, axs)
-
-function modax(ax, Aax)
-    v = ax.val
-    if iseven(length(v))
-        return ax(ofaxes(Aax, range(first(v)-step(v)/2, stop=last(v)+step(v)/2, length=length(v)÷2 + 1)))
-    else
-        return ax(ofaxes(Aax, range(first(v)/1, stop=last(v)/1, length=length(v)÷2 + 1)))
-    end
-end
-
-modax(ax, Aax, inregion::Bool) = inregion ? modax(ax, Aax) : ax
-
 
 function imlineardiffusion(img::Array{T,2}, dt::AbstractFloat, iterations::Integer) where T
     u = img

test/algorithms.jl

@@ -211,72 +211,6 @@ using Test, Suppressor
         @test img2 ≈ A
     end
 
-    # functionality moved to ImageTransformations
-    # tests are here as well to make sure everything
-    # is exported properly.
-    @testset "Restriction" begin
-        imgcol = colorview(RGB, rand(3,5,6))
-        A = reshape([convert(UInt16, i) for i = 1:60], 4, 5, 3)
-        B = restrict(A, (1,2))
-        Btarget = cat([ 0.96875  4.625   5.96875;
-                           2.875   10.5    12.875;
-                           1.90625  5.875   6.90625],
-                      [ 8.46875  14.625 13.46875;
-                        17.875    30.5   27.875;
-                        9.40625  15.875 14.40625],
-                      [15.96875  24.625 20.96875;
-                       32.875    50.5   42.875;
-                       16.90625  25.875 21.90625], dims=3)
-        @test B ≈ Btarget
-        Argb = reinterpretc(RGB, reinterpret(N0f16, permutedims(A, (3,1,2))))
-        B = restrict(Argb)
-        Bf = permutedims(reinterpretc(eltype(eltype(B)), B), (2,3,1))
-        @test isapprox(Bf, Btarget/reinterpret(one(N0f16)), atol=1e-10)
-        Argba = reinterpretc(RGBA{N0f16}, reinterpret(N0f16, A))
-        B = restrict(Argba)
-        @test isapprox(reinterpretc(eltype(eltype(B)), B), restrict(A, (2,3))/reinterpret(one(N0f16)), atol=1e-10)
-        A = reshape(1:60, 5, 4, 3)
-        B = restrict(A, (1,2,3))
-        @test cat([ 2.6015625  8.71875 6.1171875;
-                       4.09375   12.875   8.78125;
-                       3.5390625 10.59375 7.0546875],
-                     [10.1015625 23.71875 13.6171875;
-                      14.09375   32.875   18.78125;
-                      11.0390625 25.59375 14.5546875], dims=3) ≈ B
-        imgcolax = AxisArray(imgcol, :y, :x)
-        imgr = restrict(imgcolax, (1,2))
-        @test pixelspacing(imgr) == (2,2)
-        @test pixelspacing(imgcolax) == (1,1)  # issue #347
-        @inferred(restrict(imgcolax, Axis{:y}))
-        @inferred(restrict(imgcolax, Axis{:x}))
-        restrict(imgcolax, Axis{:y})  # FIXME #628
-        restrict(imgcolax, Axis{:x})
-        imgmeta = ImageMeta(imgcol, myprop=1)
-        @test isa(restrict(imgmeta, [1, 2]), ImageMeta)
-        # Issue #395
-        img1 = colorview(RGB, fill(0.9, 3, 5, 5))
-        img2 = colorview(RGB, fill(N0f8(0.9), 3, 5, 5))
-        @test isapprox(channelview(restrict(img1)), channelview(restrict(img2)), rtol=0.01)
-        # Issue #655
-        tmp = AxisArray(rand(1080,1120,5,10), (:x, :y, :z, :t), (0.577, 0.5770, 5, 2));
-        @test size(restrict(tmp, 2), 2) == 561
-
-        # restricting OffsetArrays
-        A = ones(4, 5)
-        Ao = OffsetArray(A, 0:3, -2:2)
-        Aor = restrict(Ao)
-        @test axes(Aor) == axes(OffsetArray(restrict(A), 0:2, -1:1))
-
-        # restricting AxisArrays with offset axes
-        AA = AxisArray(Ao, Axis{:y}(0:3), Axis{:x}(-2:2))
-        @test axes(AA) === axes(Ao)
-        AAr = restrict(AA)
-        axs = axisvalues(AAr)
-        @test axes(axs[1])[1] == axes(Aor)[1]
-        @test axes(axs[2])[1] == axes(Aor)[2]
-        AAA = AxisArray(Aor, axs)  # just test that it's constructable (another way of enforcing agreement)
-    end
-
     @testset "Erode/ dilate" begin
         A = zeros(4,4,3)
         A[2,2,1] = 0.8

test/deprecated.jl

@@ -8,4 +8,9 @@
         @test all(complement(img) .== 1 .- img)
     end
 
+    @testset "Restrict with vector dimensions" begin
+        imgcol = colorview(RGB, rand(3,5,6))
+        imgmeta = ImageMeta(imgcol, myprop=1)
+        @test isa(restrict(imgmeta, [1, 2]), ImageMeta)
+    end
 end

test/legacy.jl

@@ -52,4 +52,68 @@
         dc = maxfinite(img)-RGB{Float32}(maximum(A, dims=(2,3))...)
         @test _abs(dc) < 1e-6
     end
+
+    # Once moved to ImageTransformations, and then moved to ImageBase
+    @testset "Restriction" begin
+        imgcol = colorview(RGB, rand(3,5,6))
+        A = reshape([convert(UInt16, i) for i = 1:60], 4, 5, 3)
+        B = restrict(A, (1,2))
+        Btarget = cat([ 0.96875  4.625   5.96875;
+                           2.875   10.5    12.875;
+                           1.90625  5.875   6.90625],
+                      [ 8.46875  14.625 13.46875;
+                        17.875    30.5   27.875;
+                        9.40625  15.875 14.40625],
+                      [15.96875  24.625 20.96875;
+                       32.875    50.5   42.875;
+                       16.90625  25.875 21.90625], dims=3)
+        @test B ≈ Btarget
+        Argb = reinterpretc(RGB, reinterpret(N0f16, permutedims(A, (3,1,2))))
+        B = restrict(Argb)
+        Bf = permutedims(reinterpretc(eltype(eltype(B)), B), (2,3,1))
+        @test isapprox(Bf, Btarget/reinterpret(one(N0f16)), atol=1e-10)
+        Argba = reinterpretc(RGBA{N0f16}, reinterpret(N0f16, A))
+        B = restrict(Argba)
+        @test isapprox(reinterpretc(eltype(eltype(B)), B), restrict(A, (2,3))/reinterpret(one(N0f16)), atol=1e-10)
+        A = reshape(1:60, 5, 4, 3)
+        B = restrict(A, (1,2,3))
+        @test cat([ 2.6015625  8.71875 6.1171875;
+                       4.09375   12.875   8.78125;
+                       3.5390625 10.59375 7.0546875],
+                     [10.1015625 23.71875 13.6171875;
+                      14.09375   32.875   18.78125;
+                      11.0390625 25.59375 14.5546875], dims=3) ≈ B
+        imgcolax = AxisArray(imgcol, :y, :x)
+        imgr = restrict(imgcolax, (1,2))
+        @test pixelspacing(imgr) == (2,2)
+        @test pixelspacing(imgcolax) == (1,1)  # issue #347
+        @inferred(restrict(imgcolax, Axis{:y}))
+        @inferred(restrict(imgcolax, Axis{:x}))
+        restrict(imgcolax, Axis{:y})  # FIXME #628
+        restrict(imgcolax, Axis{:x})
+        imgmeta = ImageMeta(imgcol, myprop=1)
+        @test isa(restrict(imgmeta, (1, 2)), ImageMeta)
+        # Issue #395
+        img1 = colorview(RGB, fill(0.9, 3, 5, 5))
+        img2 = colorview(RGB, fill(N0f8(0.9), 3, 5, 5))
+        @test isapprox(channelview(restrict(img1)), channelview(restrict(img2)), rtol=0.01)
+        # Issue #655
+        tmp = AxisArray(rand(1080,1120,5,10), (:x, :y, :z, :t), (0.577, 0.5770, 5, 2));
+        @test size(restrict(tmp, 2), 2) == 561
+
+        # restricting OffsetArrays
+        A = ones(4, 5)
+        Ao = OffsetArray(A, 0:3, -2:2)
+        Aor = restrict(Ao)
+        @test axes(Aor) == axes(OffsetArray(restrict(A), 0:2, -1:1))
+
+        # restricting AxisArrays with offset axes
+        AA = AxisArray(Ao, Axis{:y}(0:3), Axis{:x}(-2:2))
+        @test axes(AA) === axes(Ao)
+        AAr = restrict(AA)
+        axs = axisvalues(AAr)
+        @test axes(axs[1])[1] == axes(Aor)[1]
+        @test axes(axs[2])[1] == axes(Aor)[2]
+        AAA = AxisArray(Aor, axs)  # just test that it's constructable (another way of enforcing agreement)
+    end
 end

test/runtests.jl

@@ -2,6 +2,7 @@ using Images
 using OffsetArrays
 using Statistics
 using Test
+using ImageBase
 using Suppressor
 
 @testset "Images" begin