move MultiChannelColors and ImageMetadata support to extensions (#317)

Also check if Gtk4 is initialized in __init__ and before precompiling

Author: jwahlstrand

Project.toml

@@ -12,8 +12,6 @@ Gtk4 = "9db2cae5-386f-4011-9d63-a5602296539b"
 GtkObservables = "8710efd8-4ad6-11eb-33ea-2d5ceb25a41c"
 ImageBase = "c817782e-172a-44cc-b673-b171935fbb9e"
 ImageCore = "a09fc81d-aa75-5fe9-8630-4744c3626534"
-ImageMetadata = "bc367c6b-8a6b-528e-b4bd-a4b897500b49"
-MultiChannelColors = "d4071afc-4203-49ee-90bc-13ebeb18d604"
 PrecompileTools = "aea7be01-6a6a-4083-8856-8a6e6704d82a"
 RoundingIntegers = "d5f540fe-1c90-5db3-b776-2e2f362d9394"
 StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
@@ -24,7 +22,7 @@ Cairo = "0.6, 0.7, 0.8, 1"
 Compat = "3, 4"
 Graphics = "0.2, 0.3, 0.4, 1"
 GtkObservables = "2.1"
-Gtk4 = "0.6.2, 0.7"
+Gtk4 = "0.7.6"
 ImageBase = "0.1"
 ImageCore = "0.9, 0.10"
 ImageMetadata = "0.9"
@@ -37,9 +35,13 @@ TestImages = "1.9"
 
 [weakdeps]
 FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549"
+ImageMetadata = "bc367c6b-8a6b-528e-b4bd-a4b897500b49"
+MultiChannelColors = "d4071afc-4203-49ee-90bc-13ebeb18d604"
 
 [extensions]
 ImageViewFileIOExt = "FileIO"
+ImageViewMultiChannelColorsExt = "MultiChannelColors"
+ImageViewImageMetadataExt = "ImageMetadata"
 
 [extras]
 ImageCore = "a09fc81d-aa75-5fe9-8630-4744c3626534"
@@ -51,4 +53,4 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 TestImages = "5e47fb64-e119-507b-a336-dd2b206d9990"
 
 [targets]
-test = ["ImageCore", "ImageIO", "IntervalSets", "OffsetArrays", "Observables", "Test", "TestImages"]
+test = ["ImageCore", "ImageIO", "IntervalSets", "MultiChannelColors", "OffsetArrays", "Observables", "Test", "TestImages"]

ext/ImageViewImageMetadataExt.jl

@@ -0,0 +1,8 @@
+module ImageViewImageMetadataExt
+
+using ImageMetadata
+import ImageView: _mappedarray
+
+_mappedarray(f, img::ImageMeta) = shareproperties(img, _mappedarray(f, data(img)))
+
+end

ext/ImageViewMultiChannelColorsExt.jl

@@ -0,0 +1,68 @@
+module ImageViewMultiChannelColorsExt
+
+using MultiChannelColors, GtkObservables
+using ImageCore, ImageCore.MappedArrays
+import ImageView: default_clim, _deflt_clim, channel_clims, mapped_channel_clims, histsignals,
+                 scalechannels, safeminmax, outtype, change_channel, contrast_gui, CLim, GrayLike,
+                 _default_clim, channel_clim, nanz
+
+default_clim(img::AbstractArray{C}) where {C<:AbstractMultiChannelColor} = _default_clim(img, eltype(C))
+
+function _deflt_clim(img::AbstractMatrix{C}) where {C<:AbstractMultiChannelColor}
+    minval = zero(C)
+    maxval = oneunit(C)
+    Observable(CLim(minval, maxval))
+end
+
+channel_clims(clim::CLim{C}) where {C<:AbstractMultiChannelColor} = map(f->channel_clim(f, clim), ntuple(i -> (c -> Tuple(c)[i]), length(C)))
+
+function mapped_channel_clims(clim::Observable{CLim{C}}) where {C<:AbstractMultiChannelColor}
+    inits = channel_clims(clim[])
+    return [map!(x -> channel_clim(c -> Tuple(c)[i], x), Observable(inits[1]), clim) for i = 1:length(C)]
+end
+
+function histsignals(enabled::Observable{Bool}, img::Observable, clim::Observable{CLim{C}}) where {C<:AbstractMultiChannelColor}
+    chanarrays = [map(x->mappedarray(c -> Tuple(c)[i], x), img) for i = 1:length(C)]
+    cls = mapped_channel_clims(clim) #note currently this gets called twice, also in contrast gui creation (a bit inefficient/awkward)
+    histsigs = [histsignals(enabled, chanarrays[i], cls[i])[1] for i = 1:length(C)]
+    return histsigs
+end
+
+function scalechannels(::Type{Tout}, cmin::AbstractMultiChannelColor{T}, cmax::AbstractMultiChannelColor{T}) where {T,Tout}
+    return x->Tout(ntuple(i -> nanz(scaleminmax(T, Tuple(cmin)[i], Tuple(cmax)[i])(Tuple(x)[i])), length(cmin)))
+end
+
+function safeminmax(cmin::C, cmax::C) where {C<:AbstractMultiChannelColor}
+    minmaxpairs = ntuple(i -> safeminmax(Tuple(cmin)[i], Tuple(cmax)[i]), length(C))
+    return C(first.(minmaxpairs)), C(last.(minmaxpairs))
+end
+
+outtype(::Type{C}) where C<:AbstractMultiChannelColor = C
+
+function change_channel(col::CLim{C}, chanlim::CLim{G}, i::Int) where {C<:AbstractMultiChannelColor, G<:GrayLike}
+    cmin, cmax = col.min, col.max
+    cmin = Base.setindex(cmin, chanlim.min, i)
+    cmax = Base.setindex(cmax, chanlim.max, i)
+    return CLim(cmin, cmax)
+end
+
+function contrast_gui(enabled::Observable{Bool}, hists::Vector, clim::Observable{CLim{C}}) where {C<:AbstractMultiChannelColor}
+    N = length(C)
+    @assert length(hists) == N #one signal per color channel
+    chanlims = channel_clims(clim[])
+    csigs = Observable.(chanlims)
+    #make sure that changes to individual channels update the color clim signal and vice versa
+    for i = 1:N
+        Observables.ObservablePair(clim, csigs[i]; f=x->channel_clim(c->Tuple(c)[i], x), g=x->change_channel(clim, x, i))
+    end
+    names = ["Contrast $i" for i = 1:N]
+    cguis = []
+    for i=1:length(hists)
+        push!(cguis, contrast_gui(enabled, hists[i], csigs[i]; wname = names[i]))
+    end
+    return cguis
+end
+
+
+end
+

src/ImageView.jl

@@ -8,13 +8,11 @@ end
 
 using ImageCore, ImageBase, StatsBase
 using ImageCore.MappedArrays
-using MultiChannelColors
 using RoundingIntegers
 using Gtk4, GtkObservables, Graphics, Cairo
 using Gtk4: Align_START, Align_END, Align_FILL
 using GtkObservables.Observables
 using AxisArrays: AxisArrays, Axis, AxisArray, axisnames, axisvalues, axisdim
-using ImageMetadata
 using Compat # for @constprop :none
 
 export AnnotationText, AnnotationPoint, AnnotationPoints,
@@ -559,7 +557,6 @@ end
 default_clim(img) = nothing
 default_clim(img::AbstractArray{C}) where {C<:GrayLike} = _default_clim(img, eltype(C))
 default_clim(img::AbstractArray{C}) where {C<:AbstractRGB} = _default_clim(img, eltype(C))
-default_clim(img::AbstractArray{C}) where {C<:AbstractMultiChannelColor} = _default_clim(img, eltype(C))
 _default_clim(img, ::Type{Bool}) = nothing
 _default_clim(img, ::Type{T}) where {T} = _deflt_clim(img)
 function _deflt_clim(img::AbstractMatrix)
@@ -573,12 +570,6 @@ function _deflt_clim(img::AbstractMatrix{T}) where {T<:AbstractRGB}
     Observable(CLim(minval, maxval))
 end
 
-function _deflt_clim(img::AbstractMatrix{C}) where {C<:AbstractMultiChannelColor}
-    minval = zero(C)
-    maxval = oneunit(C)
-    Observable(CLim(minval, maxval))
-end
-
 saferound(x::Integer) = convert(RInteger, x)
 saferound(x) = x
 
@@ -615,7 +606,6 @@ end
 
 channel_clim(f, clim::CLim{C}) where {C<:Colorant} = CLim(f(clim.min), f(clim.max))
 channel_clims(clim::CLim{T}) where {T<:AbstractRGB} = map(f->channel_clim(f, clim), (red, green, blue))
-channel_clims(clim::CLim{C}) where {C<:AbstractMultiChannelColor} = map(f->channel_clim(f, clim), ntuple(i -> (c -> Tuple(c)[i]), length(C)))
 
 function mapped_channel_clims(clim::Observable{CLim{T}}) where {T<:AbstractRGB}
     inits = channel_clims(clim[])
@@ -637,18 +627,6 @@ function histsignals(enabled::Observable{Bool}, img::Observable, clim::Observabl
     return histsigs
 end
 
-function mapped_channel_clims(clim::Observable{CLim{C}}) where {C<:AbstractMultiChannelColor}
-    inits = channel_clims(clim[])
-    return [map!(x -> channel_clim(c -> Tuple(c)[i], x), Observable(inits[1]), clim) for i = 1:length(C)]
-end
-
-function histsignals(enabled::Observable{Bool}, img::Observable, clim::Observable{CLim{C}}) where {C<:AbstractMultiChannelColor}
-    chanarrays = [map(x->mappedarray(c -> Tuple(c)[i], x), img) for i = 1:length(C)]
-    cls = mapped_channel_clims(clim) #note currently this gets called twice, also in contrast gui creation (a bit inefficient/awkward)
-    histsigs = [histsignals(enabled, chanarrays[i], cls[i])[1] for i = 1:length(C)]
-    return histsigs
-end
-
 function scalechannels(::Type{Tout}, cmin::AbstractRGB{T}, cmax::AbstractRGB{T}) where {T,Tout}
     r = scaleminmax(T, red(cmin), red(cmax))
     g = scaleminmax(T, green(cmin), green(cmax))
@@ -671,15 +649,6 @@ function safeminmax(cmin::T, cmax::T) where {T<:AbstractRGB}
     return T(rmin, gmin, bmin), T(rmax, gmax, bmax)
 end
 
-function scalechannels(::Type{Tout}, cmin::AbstractMultiChannelColor{T}, cmax::AbstractMultiChannelColor{T}) where {T,Tout}
-    return x->Tout(ntuple(i -> nanz(scaleminmax(T, Tuple(cmin)[i], Tuple(cmax)[i])(Tuple(x)[i])), length(cmin)))
-end
-
-function safeminmax(cmin::C, cmax::C) where {C<:AbstractMultiChannelColor}
-    minmaxpairs = ntuple(i -> safeminmax(Tuple(cmin)[i], Tuple(cmax)[i]), length(C))
-    return C(first.(minmaxpairs)), C(last.(minmaxpairs))
-end
-
 function prep_contrast(@nospecialize(img::Observable), clim::Observable{CLim{T}}) where {T}
     # Set up the signals to calculate the histogram of intensity
     enabled = Observable(false) # skip hist calculation if the contrast gui isn't open
@@ -695,7 +664,6 @@ end
 
 outtype(::Type{T}) where T<:GrayLike         = Gray{N0f8}
 outtype(::Type{C}) where C<:Color            = RGB{N0f8}
-outtype(::Type{C}) where C<:AbstractMultiChannelColor = C
 outtype(::Type{C}) where C<:TransparentColor = RGBA{N0f8}
 
 function prep_contrast(canvas, @nospecialize(img::Observable), clim::Observable{CLim{T}}) where T
@@ -833,7 +801,6 @@ isgray(img) = false
 
 _mappedarray(f, img) = mappedarray(f, img)
 _mappedarray(f, img::AxisArray) = AxisArray(mappedarray(f, img.data), AxisArrays.axes(img))
-_mappedarray(f, img::ImageMeta) = shareproperties(img, _mappedarray(f, data(img)))
 
 wrap_signal(x) = Observable(x)
 wrap_signal(x::Observable) = x
@@ -849,6 +816,10 @@ include("contrast_gui.jl")
 include("annotations.jl")
 
 function __init__()
+    if !Gtk4.initialized[]
+        error("Gtk4 not initialized")
+        return
+    end
     # by default, GtkFrame and GtkAspectFrame use rounded corners
     # the way to override this is via custom CSS
     css="""
@@ -863,6 +834,10 @@ using PrecompileTools
     for T in (N0f8, N0f16, Float32)
         for C in (Gray, RGB)
             img = rand(C{T}, 2, 2)
+            if !Gtk4.initialized[]
+                @warn("ImageView precompile skipped: Gtk4 could not be initialized (are you on a headless system?)")
+                return
+            end
             imshow(img)
             clim = ImageView.default_clim(img)
             imgsig = Observable(img)

src/contrast_gui.jl

@@ -17,12 +17,6 @@ change_red(col::Observable, chan::CLim) = change_red(col[], chan)
 change_green(col::Observable, chan::CLim) = change_green(col[], chan)
 change_blue(col::Observable, chan::CLim) = change_blue(col[], chan)
 
-function change_channel(col::CLim{C}, chanlim::CLim{G}, i::Int) where {C<:AbstractMultiChannelColor, G<:GrayLike}
-    cmin, cmax = col.min, col.max
-    cmin = Base.setindex(cmin, chanlim.min, i)
-    cmax = Base.setindex(cmax, chanlim.max, i)
-    return CLim(cmin, cmax)
-end
 change_channel(col::Observable, chanlim::CLim, i::Int) = change_channel(col[], chanlim, i)
 
 function contrast_gui(enabled::Observable{Bool}, hists::Vector, clim::Observable{CLim{T}}) where {T<:AbstractRGB}
@@ -44,23 +38,6 @@ function contrast_gui(enabled::Observable{Bool}, hists::Vector, clim::Observable
     return cguis
 end
 
-function contrast_gui(enabled::Observable{Bool}, hists::Vector, clim::Observable{CLim{C}}) where {C<:AbstractMultiChannelColor}
-    N = length(C)
-    @assert length(hists) == N #one signal per color channel
-    chanlims = channel_clims(clim[])
-    csigs = Observable.(chanlims)
-    #make sure that changes to individual channels update the color clim signal and vice versa
-    for i = 1:N
-        Observables.ObservablePair(clim, csigs[i]; f=x->channel_clim(c->Tuple(c)[i], x), g=x->change_channel(clim, x, i))
-    end
-    names = ["Contrast $i" for i = 1:N]
-    cguis = []
-    for i=1:length(hists)
-        push!(cguis, contrast_gui(enabled, hists[i], csigs[i]; wname = names[i]))
-    end
-    return cguis
-end
-
 contrast_gui(enabled, hist::Vector, clim) = contrast_gui(enabled, hist[1], clim)
 
 function contrast_gui(enabled::Observable{Bool}, hist::Observable, clim::Observable; wname="Contrast")

test/contrast.jl

@@ -1,4 +1,4 @@
-using ImageView, ImageCore, ImageView.Observables, ImageView.MultiChannelColors
+using ImageView, ImageCore, ImageView.Observables, MultiChannelColors
 using Gtk4: Gtk4
 using Test