Merge pull request #17 from tlnagy/tn/eager-interpretation

Various improvements to eager realization

Author: tlnagy

src/TIFF.jl

@@ -19,6 +19,7 @@ include("files.jl")
 include("compression.jl")
 include("tags.jl")
 include("ifds.jl")
+include("layout.jl")
 include(joinpath("types", "common.jl"))
 include(joinpath("types", "dense.jl"))
 include("load.jl")

src/compression.jl

@@ -9,10 +9,10 @@ Base.read!(tf::TiffFile, arr::AbstractArray, comp::CompressionType) = read!(tf,
 
 Base.read!(tf::TiffFile, arr::AbstractArray, ::Val{COMPRESSION_NONE}) = read!(tf, arr)
 
-function Base.read!(tf::TiffFile, arr::AbstractArray, ::Val{COMPRESSION_PACKBITS})
+function Base.read!(tf::TiffFile, arr::AbstractArray{T, N}, ::Val{COMPRESSION_PACKBITS}) where {T, N}
     pos = 1
     nbit = Array{Int8}(undef, 1)
-    nxt = Array{UInt8}(undef, 1)
+    nxt = Array{T}(undef, 1)
     while pos < length(arr)
         read!(tf, nbit)
         n = nbit[1]
@@ -38,7 +38,7 @@ julia> TIFF.get_inflator(first(methods(read!, [TIFF.TiffFile, AbstractArray, Val
 COMPRESSION_NONE::CompressionType = 1 
 ```
 """
-get_inflator(::Type{Tuple{F, T, A, Val{C}}}) where {F, T, A, C} = C
+get_inflator(::Type{Tuple{typeof(read!), TiffFile, AbstractArray{T, N} where {T, N}, Val{C}}}) where C = C
 
 # autogenerate nice error messages for all non-implemented inflation methods
 implemented = map(x->get_inflator(x.sig), methods(read!, [TiffFile, AbstractArray, Val], ))

src/enum.jl

@@ -503,4 +503,10 @@ end
 	COMPRESSION_SGILOG24 = 34677	# SGI Log 24-bit packed
 	COMPRESSION_JP2000 = 34712   	# Leadtools JPEG2000
 	COMPRESSION_LZMA = 34925		# LZMA2
+end
+
+@enum ExtraSamples begin
+	EXTRASAMPLE_UNSPECIFIED = 0		# unspecified data
+	EXTRASAMPLE_ASSOCALPHA = 1 		# associated alpha data
+	EXTRASAMPLE_UNASSALPHA = 2 		# unassociated alpha data
 end

src/files.jl

@@ -88,11 +88,10 @@ function Base.read!(io::IOStream, arr::SubArray{T,N,P,I,L}) where {T, N, P <: Bi
     error("Strided bilevel TIFFs are not yet supported. Please open an issue against TIFF.jl.")
 end
 
-function Base.read!(io::IOStream, arr::SubArray{T,N,P,I,L}) where {T, N, P <: BitArray, I <: Tuple{Base.Slice, Int64}, L}
-    rng = arr.offset1 .+ arr.indices[1]
-    n = length(rng)
-    Bc = view(parent(arr).chunks, (Base.get_chunks_id(rng.start)[1]):(Base.get_chunks_id(rng.stop)[1]))
-    nc = length(read!(io, Bc))
+function Base.read!(file::TiffFile, arr::BitArray)
+    Bc = arr.chunks 
+    n = length(arr)
+    nc = length(read!(file.io, Bc))
     if length(Bc) > 0 && Bc[end] & Base._msk_end(n) ≠ Bc[end]
         Bc[end] &= Base._msk_end(n) # ensure that the BitArray is not broken
     end

src/ifds.jl

@@ -9,6 +9,7 @@ Base.keys(ifd::IFD) = keys(ifd.tags)
 Base.iterate(ifd::IFD) = iterate(ifd.tags)
 Base.iterate(ifd::IFD, n::Integer) = iterate(ifd.tags, n)
 Base.getindex(ifd::IFD, key::TiffTag) = getindex(ifd, UInt16(key))
+Base.getindex(ifd::IFD{O}, key::UInt16) where {O} = getindex(ifd.tags, key)
 Base.in(key::TiffTag, v::IFD) = in(UInt16(key), v)
 Base.in(key::UInt16, v::IFD) = in(key, keys(v))
 Base.delete!(ifd::IFD, key::TiffTag) = delete!(ifd, UInt16(key))
@@ -22,7 +23,6 @@ function Base.setindex!(ifd::IFD{O}, value, key::UInt16) where {O <: Unsigned}
     setindex!(ifd, Tag{O}(key, value), UInt16(key))
 end
 
-Base.getindex(ifd::IFD{O}, key::UInt16) where {O} = getindex(ifd.tags, key)
 
 function load!(tf::TiffFile, ifd::IFD)
     for idx in keys(ifd)

src/layout.jl

@@ -0,0 +1,74 @@
+nrows(ifd::IFD) = Int(first(ifd[IMAGELENGTH].data))
+ncols(ifd::IFD) = Int(first(ifd[IMAGEWIDTH].data))
+nsamples(ifd::IFD) = Int(first(ifd[SAMPLESPERPIXEL].data))
+
+"""
+    interpretation(ifd)
+
+For a given IFD, determine the proper colorimetric interpretation of the data.
+It returns subtypes of `Colorant` depending on the values of the tiff tags and
+whether there are extrasamples it doesn't know how to deal with.
+"""
+function interpretation(ifd::IFD)
+    interp = PhotometricInterpretations(first(ifd[PHOTOMETRIC].data))
+    extras = EXTRASAMPLE_UNSPECIFIED
+    if EXTRASAMPLES in ifd
+        try 
+            extras = ExtraSamples(first(ifd[EXTRASAMPLES].data))
+        catch
+            extras = EXTRASAMPLE_ASSOCALPHA
+        end
+    end
+    interpretation(interp, extras, nsamples(ifd))
+end
+
+# dummy color type for palette colored images to dispatch on
+struct Palette{T} <: Colorant{T, 1} 
+    i::T
+end
+Base.reinterpret(::Type{Palette{T}}, arr::A) where {T, N, S, A <: AbstractArray{S, N}} = arr
+
+interpretation(p::PhotometricInterpretations) = interpretation(Val(p))
+interpretation(::Val{PHOTOMETRIC_RGB}) = RGB
+interpretation(::Val{PHOTOMETRIC_MINISBLACK}) = Gray
+interpretation(::Val{PHOTOMETRIC_PALETTE}) = Palette
+interpretation(::Val{PHOTOMETRIC_YCBCR}) = YCbCr
+interpretation(::Val{PHOTOMETRIC_CIELAB}) = Lab
+
+function interpretation(p::PhotometricInterpretations, extrasamples::ExtraSamples, samplesperpixel::Int)
+    interp = interpretation(p)
+    len = length(interp)
+    if len + 1 == samplesperpixel
+        return interpretation(p, extrasamples, Val(samplesperpixel))
+    elseif len == samplesperpixel
+        return interp, false
+    elseif len < samplesperpixel
+        return interp, true
+    else
+        error("TIFF file says it contains $interp values, but only has $samplesperpixel samples per pixel instead of the minimum required $(length(interp))")
+    end
+end
+_pad(::Type{RGB}) = RGBX
+_pad(::Type{T}) where {T} = T
+
+interpretation(p::PhotometricInterpretations, extrasamples::ExtraSamples, nsamples::Val) = interpretation(p, Val(extrasamples), nsamples)
+interpretation(p::PhotometricInterpretations, ::Val{EXTRASAMPLE_UNSPECIFIED}, ::Val) = interpretation(p), true
+interpretation(p::PhotometricInterpretations, ::Val{EXTRASAMPLE_UNSPECIFIED}, ::Val{4}) = _pad(interpretation(p)), false
+interpretation(p::PhotometricInterpretations, ::Val{EXTRASAMPLE_ASSOCALPHA}, ::Val) = coloralpha(interpretation(p)), false
+interpretation(p::PhotometricInterpretations, ::Val{EXTRASAMPLE_UNASSALPHA}, nsamples::Val) = interpretation(p, Val(EXTRASAMPLE_ASSOCALPHA), nsamples)
+
+_mappedtype(::Type{T}) where {T} = T
+_mappedtype(::Type{T}) where {T <: Unsigned} = Normed{T, sizeof(T) * 8}
+_mappedtype(::Type{T}) where {T <: Signed}   = Fixed{T, sizeof(T) * 8 - 1}
+
+function rawtype(ifd::IFD)
+    samplesperpixel = nsamples(ifd)
+    bitsperpixel = ifd[BITSPERSAMPLE].data
+    sampleformats = fill(UInt16(0x01), samplesperpixel)
+    if SAMPLEFORMAT in ifd
+        sampleformats = ifd[SAMPLEFORMAT].data
+    end
+    rawtype_mapping[SampleFormats(first(sampleformats)), first(bitsperpixel)]
+end
+
+

src/load.jl

@@ -1,4 +1,4 @@
-function load(filepath::String; verbose=false)
+function load(filepath::String; verbose=true)
     open(filepath) do io
         load(io; verbose=verbose)
     end
@@ -29,79 +29,61 @@ function load(io::IOStream; verbose=true)
 
         nplanes += 1
     end
-    if layout.rawtype == Bool
-        slice = view(BitArray(undef, layout.nbytes*8), :, 1)
-    else
-        slice = Array{layout.readtype}(undef, layout.nbytes÷sizeof(layout.readtype))
-    end
-    
-    ifds_iter = Iterators.Stateful(ifds)
 
-    # load first slice
-    ifd = popfirst!(ifds_iter)
-    trans = load(slice, tf, layout, ifd)
-
-    # construct the final realized array from the lazy wrappers
-    data = Array{eltype(trans)}(undef, size(trans)..., nplanes)
-    plane_dim = length(size(data))
-    # set the first plane to the data in trans
-    selectdim(data, plane_dim, 1) .= trans
-
-    freq = verbose ? 1 : Inf
-    @showprogress freq for (idx, ifd) in enumerate(ifds_iter)
-        trans = load(slice, tf, layout, ifd)
-        selectdim(data, plane_dim, idx+1) .= trans
-    end
-
-    if layout.interpretation == PHOTOMETRIC_PALETTE
+    loaded = load(tf, layout, ifds, Val(nplanes); verbose=verbose)
+    
+    if eltype(loaded) <: Palette
+        ifd = ifds[1]
+        raw = rawtype(ifd)
+        loadedr = reinterpret(raw, loaded)
         maxdepth = 2^(first(ifd[BITSPERSAMPLE].data))-1
         colors = ifd[COLORMAP].data
         color_map = vec(reinterpret(RGB{N0f16}, reshape(colors, :, 3)'))
-        data = IndirectArray(data, OffsetArray(color_map, 0:maxdepth))
+        data = IndirectArray(loadedr, OffsetArray(color_map, 0:maxdepth))
+    elseif eltype(loaded) <: Bool
+        data = Gray.(loaded)
+    else
+        data = loaded
     end
 
     close(tf.io)
-    todrop = tuple(findall(size(data) .== 1)...)
-    DenseTaggedImage(dropdims(data, dims=todrop), ifds)
+    return DenseTaggedImage(data, ifds)
 end
 
-"""
-    load(prealloc, tf, layout, ifd)
-
-Read the raw data from `tf` into `prealloc` and then lazily transform the latter
-based on the information in `layout` and `ifd`. The returned array can later be
-realized to unwrap the lazy transforms.
-"""
-function load(prealloc::AbstractVector, tf::TiffFile, layout::IFDLayout, ifd::IFD)
-    read!(prealloc, tf, ifd)
-
-    data = reinterpret(layout.rawtype, prealloc)
+function load(tf::TiffFile, layout::IFDLayout, ifds, ::Val{1}; verbose = true)
+    ifd = ifds[1]
 
-    trans = reshape(data, :, layout.nrows) 
+    colortype, extras = interpretation(ifd)
+    
     if layout.rawtype == Bool
-        trans = view(trans, 1:layout.ncols, 1:layout.nrows)
+        cache = BitArray(undef, ncols(ifd), nrows(ifd))
+    else
+        cache = Array{colortype{layout.mappedtype}}(undef, ncols(ifd), nrows(ifd))
     end
+    
+    read!(cache, tf, ifd)
+
+    return Array(cache')
+end
+
+function load(tf::TiffFile, layout::IFDLayout, ifds, ::Val{N}; verbose = true) where {N}
+    ifd = ifds[1]
 
-    if layout.nsamples > 1
-        trans = PermutedDimsArray(reshape(trans, layout.nsamples, layout.ncols, layout.nrows), [1, 3, 2])
+    colortype, extras = interpretation(ifd)
+
+    if layout.rawtype == Bool
+        cache = BitArray(undef, ncols(ifd), nrows(ifd))
     else
-        trans = PermutedDimsArray(trans, [2, 1])
+        cache = Array{colortype{layout.mappedtype}}(undef, ncols(ifd), nrows(ifd))
     end
 
-    colortype = nothing
-    if layout.interpretation != PHOTOMETRIC_PALETTE
-        if layout.interpretation == PHOTOMETRIC_MINISBLACK
-            colortype = Gray{layout.mappedtype}
-            if layout.nsamples > 1
-                trans = view(trans, 1, :, :)
-            end
-        elseif layout.interpretation == PHOTOMETRIC_RGB
-            colortype = RGB{layout.mappedtype}
-            trans = view(trans, 1:3, :, :)
-        else
-            error("Given TIFF requests $(layout.interpretation) interpretation, but that's not yet supported")
-        end
-        trans = reinterpret(colortype, trans)
+    data = similar(cache, nrows(ifd), ncols(ifd), N)
+
+    freq = verbose ? 1 : Inf
+    @showprogress freq for (idx, ifd) in enumerate(ifds)
+        read!(cache, tf, ifd)
+        data[:, :, idx] .= cache'
     end
-    trans
+    
+    return data
 end

src/utils.jl

@@ -136,3 +136,7 @@ const rawtype_mapping = Dict(
     (SAMPLEFORMAT_IEEEFP, 32) => Float32,
     (SAMPLEFORMAT_IEEEFP, 64) => Float64,
 )
+
+Base.bswap(d::FixedPoint{T, N}) where {T, N} = FixedPointNumber.rawone(FixedPoint{T, N}(bswap(d)))
+Base.bswap(c::Colorant{T, N}) where {T, N} = mapc(bswap, c)
+Base.bswap(c::Colorant{<: FixedPoint{UInt8, N1}, N2}) where {N1, N2} = c

test/layouts.jl

@@ -0,0 +1,35 @@
+@testset "Interpretations" begin
+    ifd = TIFF.IFD(UInt32)
+    ifd[TIFF.PHOTOMETRIC] = TIFF.PHOTOMETRIC_MINISBLACK
+    ifd[TIFF.SAMPLESPERPIXEL] = 1
+
+    @test TIFF.interpretation(ifd) == (Gray, false)
+
+    ifd[TIFF.SAMPLESPERPIXEL] = 2
+
+    @test TIFF.interpretation(ifd) == (Gray, true)
+
+    ifd[TIFF.EXTRASAMPLES] = TIFF.EXTRASAMPLE_ASSOCALPHA
+
+    @test TIFF.interpretation(ifd) == (GrayA, false)
+
+    ifd[TIFF.EXTRASAMPLES] = TIFF.EXTRASAMPLE_UNSPECIFIED
+
+    @test TIFF.interpretation(ifd) == (Gray, true)
+
+    ifd[TIFF.SAMPLESPERPIXEL] = 3
+
+    @test TIFF.interpretation(ifd) == (Gray, true)
+
+    ifd[TIFF.PHOTOMETRIC] = TIFF.PHOTOMETRIC_RGB
+
+    @test TIFF.interpretation(ifd) == (RGB, false)
+
+    ifd[TIFF.SAMPLESPERPIXEL] = 4
+
+    @test TIFF.interpretation(ifd) == (RGBX, false)
+
+    ifd[TIFF.EXTRASAMPLES] = TIFF.EXTRASAMPLE_ASSOCALPHA 
+
+    @test TIFF.interpretation(ifd) == (RGBA, false)
+end

test/runtests.jl

@@ -15,10 +15,10 @@ get_example(name) = download("https://github.com/tlnagy/exampletiffs/blob/master
     filepath = get_example("house.tif")
     img = TIFF.load(filepath)
     @test size(img) == (512, 512)
-    @test eltype(img) == Gray{N0f8}
-    @test img[50,50] == Gray{N0f8}(0.804) # value from ImageMagick.jl
+    @test eltype(img) == GrayA{N0f8}
+    @test img[50,50] == GrayA{N0f8}(0.804, 1.0) # value from ImageMagick.jl
     img[50:300, 50:150] .= 0.0
-    @test img[50, 50] == Gray{N0f8}(0.0)
+    @test img[50, 50] == GrayA{N0f8}(0.0, 1.0)
 end
 
 @testset "MRI stack" begin
@@ -92,4 +92,8 @@ end
 
 @testset "Writing" begin
     include("writer.jl")
+end
+
+@testset "Interpreting IFD layouts" begin
+    include("layouts.jl")
 end