updates for Julia v0.7

Author: RalphAS

REQUIRE

@@ -1,4 +1,4 @@
-julia 0.6
+julia 0.7-beta
 ImageCore 0.1.2
 CoordinateTransformations 0.4.0
 Interpolations 0.4

src/ImageTransformations.jl

@@ -9,11 +9,11 @@ using Interpolations, AxisAlgorithms
 using OffsetArrays
 using FixedPointNumbers
 using ColorTypes, Colors, ColorVectorSpace
-using Compat
 using IdentityRanges
 
-import Base: start, next, done, eltype, iteratorsize, size, length
-using Base: tail, Cartesian, Indices
+import Base: start, next, done, eltype, size, length
+using Base: tail, Indices
+using Base.Cartesian
 using ColorTypes: AbstractGray, TransparentGray, TransparentRGB
 
 export
@@ -36,7 +36,7 @@ include("invwarpedview.jl")
 
 @inline _getindex(A, v::StaticVector) = A[convert(Tuple, v)...]
 
-center(img::AbstractArray{T,N}) where {T,N} = SVector{N}(map(_center, indices(img)))
+center(img::AbstractArray{T,N}) where {T,N} = SVector{N}(map(_center, axes(img)))
 _center(ind::AbstractUnitRange) = (first(ind)+last(ind))/2
 
 end # module

src/autorange.jl

@@ -1,9 +1,9 @@
 function autorange(img, tform)
-    R = CartesianRange(indices(img))
+    R = CartesianIndices(axes(img))
     autorange(R, tform)
 end
 
-function autorange(R::CartesianRange, tform)
+function autorange(R::CartesianIndices, tform)
     mn = mx = tform(SVector(first(R).I))
     for I in CornerIterator(R)
         x = tform(SVector(I.I))
@@ -22,13 +22,13 @@ struct CornerIterator{I<:CartesianIndex}
     start::I
     stop::I
 end
-CornerIterator(R::CartesianRange) = CornerIterator(first(R), last(R))
+CornerIterator(R::CartesianIndices) = CornerIterator(first(R), last(R))
 
 eltype(::Type{CornerIterator{I}}) where {I} = I
-iteratorsize(::Type{CornerIterator{I}}) where {I} = Base.HasShape()
+Base.Iterators.IteratorSize(::Type{CornerIterator{I}}) where {I<:CartesianIndex{N}} where {N} = Base.Iterators.HasShape{N}()
 
 # in 0.6 we could write: 1 .+ (iter.stop.I .- iter.start.I .!= 0)
-size(iter::CornerIterator{CartesianIndex{N}}) where {N} = ntuple(d->iter.stop.I[d]-iter.start.I[d]==0 ? 1 : 2, Val{N})::NTuple{N,Int}
+size(iter::CornerIterator{CartesianIndex{N}}) where {N} = ntuple(d->iter.stop.I[d]-iter.start.I[d]==0 ? 1 : 2, Val(N))::NTuple{N,Int}
 length(iter::CornerIterator) = prod(size(iter))
 
 @inline function start(iter::CornerIterator{I}) where I<:CartesianIndex

src/interpolations.jl

@@ -51,11 +51,11 @@ end
 # This is type-piracy, but necessary if we want Interpolations to be
 # independent of OffsetArrays.
 function AxisAlgorithms.A_ldiv_B_md!(dest::OffsetArray, F, src::OffsetArray, dim::Integer, b::AbstractVector)
-    indsdim = indices(parent(src), dim)
-    indsF = indices(F)[2]
+    indsdim = axes(parent(src), dim)
+    indsF = axes(F)[2]
     if indsF == indsdim
         AxisAlgorithms.A_ldiv_B_md!(parent(dest), F, parent(src), dim, b)
         return dest
     end
-    throw(DimensionMismatch("indices $(indices(parent(src))) do not match $(indices(F))"))
+    throw(DimensionMismatch("indices $(axes(parent(src))) do not match $(axes(F))"))
 end

src/invwarpedview.jl

@@ -46,9 +46,9 @@ function InvWarpedView(inner::InvWarpedView, outer_tinv::Transformation, inds::T
 end
 
 Base.parent(A::InvWarpedView) = parent(A.inner)
-@inline Base.indices(A::InvWarpedView) = indices(A.inner)
+@inline Base.axes(A::InvWarpedView) = axes(A.inner)
 
-Compat.IndexStyle(::Type{T}) where {T<:InvWarpedView} = IndexCartesian()
+IndexStyle(::Type{T}) where {T<:InvWarpedView} = IndexCartesian()
 @inline Base.getindex(A::InvWarpedView{T,N}, I::Vararg{Int,N}) where {T,N} = A.inner[I...]
 
 Base.size(A::InvWarpedView)    = size(A.inner)
@@ -67,9 +67,9 @@ function ShowItLikeYouBuildIt.showarg(io::IO, A::SubArray{T,N,W}) where {T<:Numb
     print(io, "view(")
     showarg(io, parent(A))
     print(io, ", ")
-    for (i, el) in enumerate(A.indexes)
+    for (i, el) in enumerate(A.indices)
         print(io, el)
-        i < length(A.indexes) && print(io, ", ")
+        i < length(A.indices) && print(io, ", ")
     end
     print(io, ')')
 end
@@ -141,7 +141,7 @@ function invwarpedview(
         tinv::Transformation) where {T,N,W<:InvWarpedView,I<:Tuple{Vararg{AbstractUnitRange}}}
     inner = parent(inner_view)
     new_inner = InvWarpedView(inner, tinv, autorange(inner, tinv))
-    inds = autorange(CartesianRange(inner_view.indexes), tinv)
+    inds = autorange(CartesianIndices(inner_view.indices), tinv)
     view(new_inner, map(IdentityRange, inds)...)
 end
 

src/resizing.jl

@@ -10,15 +10,15 @@ See also [`imresize`](@ref).
 """
 restrict(img::AbstractArray, ::Tuple{}) = img
 
-restrict(A::AbstractArray, region::Vector{Int}) = restrict(A, (region...))
+restrict(A::AbstractArray, region::Vector{Int}) = restrict(A, (region...,))
 restrict(A::AbstractArray) = restrict(A, coords_spatial(A))
 function restrict(A::AbstractArray, region::Dims)
     restrict(restrict(A, region[1]), Base.tail(region))
 end
 
 function restrict(A::AbstractArray{T,N}, dim::Integer) where {T,N}
-    indsA = indices(A)
-    newinds = ntuple(i->i==dim?restrict_indices(indsA[dim]):indsA[i], Val{N})
+    indsA = axes(A)
+    newinds = ntuple(i->i==dim ? restrict_indices(indsA[dim]) : indsA[i], Val(N))
     out = similar(Array{restrict_eltype(first(A)),N}, newinds)
     restrict!(out, A, dim)
     out
@@ -35,9 +35,9 @@ restrict_eltype(x::Colorant)        = restrict_eltype_default(convert(ARGB, x))
 
 function restrict!(out::AbstractArray{T,N}, A::AbstractArray, dim) where {T,N}
     if dim > N
-        return copy!(out, A)
+        return copyto!(out, A)
     end
-    indsout, indsA = indices(out), indices(A)
+    indsout, indsA = axes(out), axes(A)
     ndims(out) == ndims(A) || throw(DimensionMismatch("input and output must have the same number of dimensions"))
     for d = 1:length(indsA)
         target = d==dim ? restrict_indices(indsA[d]) : indsA[d]
@@ -155,7 +155,12 @@ end
 end
 
 restrict_size(len::Integer) = isodd(len) ? (len+1)>>1 : (len>>1)+1
-
+# CHECKME: wild guess here
+function restrict_indices(r::Base.Slice)
+    f, l = first(r), last(r)
+    isodd(f) && return (f+1)>>1:restrict_size(l)
+    f>>1 : (isodd(l) ? (l+1)>>1 : l>>1)
+end
 restrict_indices(r::Base.OneTo) = Base.OneTo(restrict_size(length(r)))
 function restrict_indices(r::UnitRange)
     f, l = first(r), last(r)
@@ -173,8 +178,8 @@ function imresize(original::AbstractArray, short_size::Tuple)
     imresize(original, new_size)
 end
 odims(original, i, short_size::Tuple{Integer,Vararg{Integer}}) = size(original, i)
-odims(original, i, short_size::Tuple{}) = indices(original, i)
-odims(original, i, short_size) = oftype(first(short_size), indices(original, i))
+odims(original, i, short_size::Tuple{}) = axes(original, i)
+odims(original, i, short_size) = oftype(first(short_size), axes(original, i))
 
 """
     imresize(img, sz) -> imgr
@@ -193,18 +198,18 @@ See also [`restrict`](@ref).
 """
 function imresize(original::AbstractArray{T,0}, new_inds::Tuple{}) where T
     Tnew = imresize_type(first(original))
-    copy!(similar(original, Tnew), original)
+    copyto!(similar(original, Tnew), original)
 end
 
 function imresize(original::AbstractArray{T,N}, new_size::Dims{N}) where {T,N}
     Tnew = imresize_type(first(original))
-    inds = indices(original)
+    inds = axes(original)
     if map(length, inds) == new_size
         dest = similar(original, Tnew, new_size)
-        if indices(dest) == inds
-            copy!(dest, original)
+        if axes(dest) == inds
+            copyto!(dest, original)
         else
-            copy!(dest, CartesianRange(indices(dest)), original, CartesianRange(inds))
+            copyto!(dest, CartesianIndices(axes(dest)), original, CartesianIndices(inds))
         end
     else
         imresize!(similar(original, Tnew, new_size), original)
@@ -213,8 +218,8 @@ end
 
 function imresize(original::AbstractArray{T,N}, new_inds::Indices{N}) where {T,N}
     Tnew = imresize_type(first(original))
-    if indices(original) == new_inds
-        copy!(similar(original, Tnew), original)
+    if axes(original) == new_inds
+        copyto!(similar(original, Tnew), original)
     else
         imresize!(similar(original, Tnew, new_inds), original)
     end
@@ -247,8 +252,10 @@ function imresize!(resized::AbstractArray{T,N}, original::AbstractInterpolation{
     #     (0.5, 0.5) -> (0.5, 0.5)  (outer corner, top left)
     #     size(resized)+0.5 -> size(original)+0.5  (outer corner, lower right)
     # This ensures that both images cover exactly the same area.
-    Ro, Rr = CartesianRange(indices(original)), CartesianRange(indices(resized))
-    sf = map(/, (last(Ro)-first(Ro)+1).I, (last(Rr)-first(Rr)+1).I) # +1 for outer corners
+    Ro, Rr = CartesianIndices(axes(original)), CartesianIndices(axes(resized))
+    # CHECKME: is this general enough? previously had
+    # sf = map(/, (last(Ro)-first(Ro)+1).I, (last(Rr)-first(Rr)+1).I) # +1 for outer corners
+    sf = map(/, (last(Ro)-first(Ro)).I .+ 1, (last(Rr)-first(Rr)).I .+ 1) # +1 for outer corners
     offset = map((io,ir,s)->io - 0.5 - s*(ir-0.5), first(Ro).I, first(Rr).I, sf)
     if all(x->x >= 1, sf)
         @inbounds for I in Rr
@@ -268,6 +275,6 @@ end
 @inline map3(f, a, b, c) = (f(a[1], b[1], c[1]), map3(f, tail(a), tail(b), tail(c))...)
 @inline map3(f, ::Tuple{}, ::Tuple{}, ::Tuple{}) = ()
 
-@compat function clampR(I::NTuple{N}, R::CartesianRange{N}) where N
+function clampR(I::NTuple{N}, R::CartesianIndices{N}) where N
     map3(clamp, I, first(R).I, last(R).I)
 end

src/warp.jl

@@ -50,7 +50,7 @@ julia> using Images, CoordinateTransformations, TestImages, OffsetArrays
 
 julia> img = testimage("lighthouse");
 
-julia> indices(img)
+julia> axes(img)
 (Base.OneTo(512),Base.OneTo(768))
 
 # Rotate around the center of `img`
@@ -59,7 +59,7 @@ AffineMap([0.707107 0.707107; -0.707107 0.707107], [-196.755,293.99])
 
 julia> imgw = warp(img, tfm);
 
-julia> indices(imgw)
+julia> axes(imgw)
 (-196:709,-68:837)
 
 # Alternatively, specify the origin in the image itself
@@ -70,12 +70,12 @@ LinearMap([0.707107 -0.707107; 0.707107 0.707107])
 
 julia> imgw = warp(img0, rot);
 
-julia> indices(imgw)
+julia> axes(imgw)
 (-293:612,-293:611)
 
 julia> imgr = parent(imgw);
 
-julia> indices(imgr)
+julia> axes(imgr)
 (Base.OneTo(906),Base.OneTo(905))
 ```
 """
@@ -85,7 +85,7 @@ function warp(img::AbstractExtrapolation{T}, tform, inds::Tuple = autorange(img,
 end
 
 function warp!(out, img::AbstractExtrapolation, tform)
-    @inbounds for I in CartesianRange(indices(out))
+    @inbounds for I in CartesianIndices(axes(out))
         out[I] = _getindex(img, tform(SVector(I.I)))
     end
     out

src/warpedview.jl

@@ -38,14 +38,14 @@ function WarpedView(
 end
 
 Base.parent(A::WarpedView) = A.parent
-@inline Base.indices(A::WarpedView) = A.indices
+@inline Base.axes(A::WarpedView) = A.indices
 
-Compat.IndexStyle(::Type{T}) where {T<:WarpedView} = IndexCartesian()
+IndexStyle(::Type{T}) where {T<:WarpedView} = IndexCartesian()
 @inline Base.getindex(A::WarpedView{T,N}, I::Vararg{Int,N}) where {T,N} =
     T(_getindex(A.extrapolation, A.transform(SVector(I))))
 
-Base.size(A::WarpedView{T,N,TA,F}) where {T,N,TA,F}    = OffsetArrays.errmsg(A)
-Base.size(A::WarpedView{T,N,TA,F}, d) where {T,N,TA,F} = OffsetArrays.errmsg(A)
+Base.size(A::WarpedView{T,N,TA,F}) where {T,N,TA,F}    = size(parent(A))
+Base.size(A::WarpedView{T,N,TA,F}, d) where {T,N,TA,F} = size(parent(A),d)
 
 Base.size(A::WarpedView{T,N,TA,F,NTuple{N,Base.OneTo{Int}}}) where {T,N,TA,F}    = map(length, A.indices)
 Base.size(A::WarpedView{T,N,TA,F,NTuple{N,Base.OneTo{Int}}}, d) where {T,N,TA,F} = d <= N ? length(A.indices[d]) : 1

test/autorange.jl

@@ -6,13 +6,13 @@
     # (i.e. without any singleton array dimension of size 1)
     si(num::Number) = 1
     ei(num::Number) = num
-    si(num::Range)  = minimum(num)
-    ei(num::Range)  = maximum(num)
+    si(num::AbstractRange)  = minimum(num)
+    ei(num::AbstractRange)  = maximum(num)
     for t in ((2,), (2,3), (2,3,4), (2,3,4,5),        # OneTo
               (-1:2,), (-1:2,-2:3), (-1:2,-2:3,-3:4)) # Non OneTo
         N = length(t)
         @testset "$N-d array without singleton dimension" begin
-            cr = CartesianRange(t)
+            cr = CartesianIndices(t)
             ci = @inferred(ImageTransformations.CornerIterator(cr))
             @test typeof(ci) <: ImageTransformations.CornerIterator{CartesianIndex{N}}
             @test ci.start === first(cr)
@@ -55,7 +55,7 @@
     @testset "0-element and 1-element edge cases" begin
         for t in ((),(1,),(1,1),(1,1,1))
             N = length(t)
-            cr = CartesianRange(t)
+            cr = CartesianIndices(t)
             ci = @inferred(ImageTransformations.CornerIterator(cr))
             @test ci.start === first(cr)
             @test ci.stop === last(cr)
@@ -69,7 +69,7 @@
     end
 
     @testset "arrays with singleton dimensions" begin
-        cr = CartesianRange((1,3))
+        cr = CartesianIndices((1,3))
         ci = @inferred(ImageTransformations.CornerIterator(cr))
         @test ci.start === first(cr)
         @test ci.stop === last(cr)
@@ -81,7 +81,7 @@
             CartesianIndex{2}((1,1)) CartesianIndex{2}((1,3))
         ]
         # two singleton dimensions
-        cr = CartesianRange((1,3,1,3))
+        cr = CartesianIndices((1,3,1,3))
         ci = @inferred(ImageTransformations.CornerIterator(cr))
         @test ci.start === first(cr)
         @test ci.stop === last(cr)
@@ -127,8 +127,8 @@ end
         end
     end
     #should also work with non-static transforms (Github #48)
-    tfm = LinearMap(eye(2))
-    tfm_s = LinearMap(SMatrix{2,2}(eye(2)))
+    tfm = LinearMap(Matrix(1.0*I,2,2))
+    tfm_s = LinearMap(SMatrix{2,2}(Matrix(1.0*I,2,2)))
     tst_img = zeros(5,5)
     rnge = ImageTransformations.autorange(tst_img, tfm_s)
     @test rnge == ImageTransformations.autorange(tst_img, tfm)