Handle colorscheme to colormap conversion (#49)

* Handle colorscheme to colormap conversion

* More fixes

Author: juliohm

ext/ColorfyCategoricalArraysExt.jl

@@ -9,14 +9,16 @@ using CategoricalArrays: levels, levelcode
 
 import Colorfy
 
-function Colorfy.repr(values::AbstractVector{<:CategoricalValue}, colorscheme, colorrange)
+function Colorfy.repr(values::AbstractVector{<:CategoricalValue}, colormap, colorrange)
   # not all levels may be present in the input values,
   # so we need to get the number of levels from the type
-  n = length(levels(values))
-  c = get(colorscheme, 1:n, colorrange)
-  c[map(levelcode, values)]
+  n = Colorfy.nlevels(values)
+  c = get(colormap, 1:n, colorrange)
+  c[Colorfy.nominal(values)]
 end
 
 Colorfy.nominal(values::AbstractVector{<:CategoricalValue}) = map(levelcode, values)
 
+Colorfy.nlevels(values::AbstractVector{<:CategoricalValue}) = length(levels(values))
+
 end

ext/ColorfyCoDaExt.jl

@@ -10,23 +10,19 @@ using Colors: coloralpha
 
 import Colorfy
 
-function Colorfy.repr(values::AbstractVector{<:Composition}, colorscheme, colorrange)
-  # compute probabilities
-  ps = map(values) do v
-    cs = components(v)
-    cs ./ sum(cs)
-  end
+function Colorfy.repr(values::AbstractVector{<:Composition}, colormap, colorrange)
+  # derive base color from mode
+  n = Colorfy.nlevels(values)
+  c = get(colormap, 1:n, colorrange)
+  cs = c[Colorfy.nominal(values)]
 
   # compute Shannon entropy
-  hs = map(ps) do p
+  hs = map(values) do v
+    c = components(v)
+    p = c ./ sum(c)
     -sum(pᵢ * log(pᵢ) for pᵢ in p if pᵢ > 0)
   end
 
-  # derive base color from mode
-  n = length(first(ps))
-  c = get(colorscheme, 1:n, colorrange)
-  cs = c[map(argmax, ps)]
-
   # derive transparency from entropy
   a, b = 0.0, log(n)
   αs = @. 1.0 - (hs - a) / (b - a)
@@ -37,4 +33,6 @@ end
 
 Colorfy.nominal(values::AbstractVector{<:Composition}) = map(argmax ∘ components, values)
 
+Colorfy.nlevels(values::AbstractVector{<:Composition}) = length(components(first(values)))
+
 end

ext/ColorfyDistributionsExt.jl

@@ -9,13 +9,12 @@ using Colors
 
 import Colorfy
 
-function Colorfy.repr(values::AbstractVector{<:Normal}, colorscheme, colorrange)
-  # extract location and entropy
-  ms = map(location, values)
-  hs = map(entropy, values)
-
+function Colorfy.repr(values::AbstractVector{<:Normal}, colormap, colorrange)
   # derive base colors from location
-  cs = Colorfy.repr(ms, colorscheme, colorrange)
+  cs = Colorfy.repr(Colorfy.nominal(values), colormap, colorrange)
+
+  # compute Shannon entropy
+  hs = map(entropy, values)
 
   # derive transparency from entropy
   a, b = extrema(hs)
@@ -29,17 +28,16 @@ function Colorfy.repr(values::AbstractVector{<:Normal}, colorscheme, colorrange)
   map(coloralpha, cs, αs)
 end
 
-Colorfy.repr(values::AbstractVector{<:Dirac}, colorscheme, colorrange) =
-  Colorfy.repr(mode.(values), colorscheme, colorrange)
-
-function Colorfy.repr(values::AbstractVector{<:Bernoulli}, colorscheme, colorrange)
-  # extract mode and entropy
-  ms = map(mode, values)
-  hs = map(entropy, values)
+Colorfy.repr(values::AbstractVector{<:Dirac}, colormap, colorrange) =
+  Colorfy.repr(map(mode, values), colormap, colorrange) # TODO
 
+function Colorfy.repr(values::AbstractVector{<:Bernoulli}, colormap, colorrange)
   # derive base colors from mode
-  c = get(colorscheme, 0:1, colorrange)
-  cs = c[ms .+ 1]
+  c = get(colormap, 0:1, colorrange)
+  cs = c[Colorfy.nominal(values) .+ 1]
+
+  # compute Shannon entropy
+  hs = map(entropy, values)
 
   # derive transparency from entropy
   a, b = 0.0, log(2)
@@ -49,15 +47,14 @@ function Colorfy.repr(values::AbstractVector{<:Bernoulli}, colorscheme, colorran
   map(coloralpha, cs, αs)
 end
 
-function Colorfy.repr(values::AbstractVector{<:Categorical}, colorscheme, colorrange)
-  # extract mode and entropy
-  ms = map(mode, values)
-  hs = map(entropy, values)
-
+function Colorfy.repr(values::AbstractVector{<:Categorical}, colormap, colorrange)
   # derive base colors from mode
-  n = ncategories(first(values))
-  c = get(colorscheme, 1:n, colorrange)
-  cs = c[ms]
+  n = Colorfy.nlevels(values)
+  c = get(colormap, 1:n, colorrange)
+  cs = c[Colorfy.nominal(values)]
+
+  # compute Shannon entropy
+  hs = map(entropy, values)
 
   # derive transparency from entropy
   a, b = 0.0, log(n)
@@ -75,4 +72,10 @@ Colorfy.nominal(values::AbstractVector{<:ContinuousUnivariateDistribution}) = Co
 
 Colorfy.nominal(values::AbstractVector{<:DiscreteUnivariateDistribution}) = Colorfy.nominal(map(mode, values))
 
+Colorfy.nlevels(values::AbstractVector{<:Dirac}) = 1
+
+Colorfy.nlevels(values::AbstractVector{<:Bernoulli}) = 2
+
+Colorfy.nlevels(values::AbstractVector{<:Categorical}) = ncategories(first(values))
+
 end

ext/ColorfyUnitfulExt.jl

@@ -9,8 +9,8 @@ using Unitful: ustrip
 
 import Colorfy
 
-Colorfy.repr(values::AbstractVector{<:Quantity}, colorscheme, colorrange) =
-  Colorfy.repr(map(ustrip, values), colorscheme, colorrange)
+Colorfy.repr(values::AbstractVector{<:Quantity}, colormap, colorrange) =
+  Colorfy.repr(Colorfy.nominal(values), colormap, colorrange)
 
 Colorfy.nominal(values::AbstractVector{<:Quantity}) = Colorfy.nominal(map(ustrip, values))
 

src/Colorfy.jl

@@ -24,7 +24,7 @@ Convert `values` to Colors.jl colors based on given options.
 """
 function colorfy(values; alpha=1.0, colorscheme=:viridis, colorrange=:extrema)
   # handle input arguments
-  vs, αs, s, r = handleargs(values, alpha, colorscheme, colorrange)
+  vs, αs, cm, cr = handleargs(values, alpha, colorscheme, colorrange)
 
   # find invalid and valid indices
   iinds = findall(isinvalid, vs)
@@ -34,7 +34,7 @@ function colorfy(values; alpha=1.0, colorscheme=:viridis, colorrange=:extrema)
   isempty(vinds) && return fill(colorant"transparent", length(values))
 
   # construct colors for valid values
-  rcolors = repr(nonmissingvec(vs[vinds]), s, r)
+  rcolors = repr(nonmissingvec(vs[vinds]), cm, cr)
   ralphas = map(Colors.alpha, rcolors)
   vcolors = coloralpha.(rcolors, αs[vinds] .* ralphas)
 
@@ -49,9 +49,9 @@ end
 function handleargs(values, alphas, colorscheme, colorrange)
   vs = asvalues(values)
   αs = asalphas(alphas, vs)
-  s = ascolorscheme(colorscheme)
-  r = ascolorrange(colorrange)
-  vs, αs, s, r
+  cm = ascolormap(colorscheme, vs)
+  cr = ascolorrange(colorrange)
+  vs, αs, cm, cr
 end
 
 asvalues(values) = values
@@ -68,6 +68,12 @@ function asalphas(alphas::AbstractVector, values)
   alphas
 end
 
+function ascolormap(colorscheme, values)
+  nl = nlevels(values)
+  cs = ascolorscheme(colorscheme)
+  isfinite(nl) ? discretescheme(cs, nl) : cs
+end
+
 ascolorscheme(colorscheme::Symbol) = colorschemes[colorscheme]
 ascolorscheme(colorscheme::AbstractString) = ascolorscheme(Symbol(colorscheme))
 ascolorscheme(colorscheme::AbstractVector) = ColorScheme([parse(Colorant, color) for color in colorscheme])
@@ -79,42 +85,16 @@ function ascolorrange(colorrange::NTuple{2,Number})
   Tuple(nominal(collect(crange)))
 end
 
-"""
-    nominal(values)
-
-Nominal representation of `values` for color mapping.
-This function is used to convert non-numeric values to
-numeric values that can be used in ticks and color bars.
-"""
-function nominal(values)
-  # find invalid and valid indices
-  iinds = findall(isinvalid, values)
-  vinds = setdiff(1:length(values), iinds)
-
-  # if all values are invalid, return missing values
-  isempty(vinds) && return fill(missing, length(values))
-
-  # construct nominal values for valid values
-  vvalues = nominal(nonmissingvec(values[vinds]))
-
-  # construct nominal values for all values
-  if isempty(iinds) # all values are valid, return nominal values directly
-    vvalues
-  else # set missing value for invalid values
-    genvec(vinds, vvalues, iinds, missing)
-  end
-end
-
 # ----------------
 # IMPLEMENTATIONS
 # ----------------
 
 """
-    repr(values::AbstractVector{T}, colorscheme, colorrange)
+    repr(values, colormap, colorrange)
 
-Colorful representation of `values` of type `T` based on `colorscheme` and `colorrange`.
+Colorful representation of `values` based on `colormap` and `colorrange`.
 """
-function repr(values::AbstractVector{T}, colorscheme, colorrange) where {T}
+function repr(values::AbstractVector{T}, colormap, colorrange) where {T}
   throw(ArgumentError("""
     values of type `$T` do not have a colorful representation.
 
@@ -123,30 +103,57 @@ function repr(values::AbstractVector{T}, colorscheme, colorrange) where {T}
     """))
 end
 
-repr(values::AbstractVector{<:Colorant}, colorscheme, colorrange) = values
+repr(values::AbstractVector{<:Colorant}, colormap, colorrange) = values
 
-function repr(values::AbstractVector{<:Number}, colorscheme, colorrange)
+function repr(values::AbstractVector{<:Number}, colormap, colorrange)
   isna(v) = isnan(v) || isinf(v)
   if any(isna, values)
     iinds = findall(isna, values)
     vinds = setdiff(1:length(values), iinds)
     vvals = nonmissingvec(values[vinds])
-    vcolor = get(colorscheme, vvals, colorrange)
+    vcolor = get(colormap, vvals, colorrange)
     icolor = colorant"transparent"
     genvec(vinds, vcolor, iinds, icolor)
   else
-    get(colorscheme, values, colorrange)
+    get(colormap, values, colorrange)
   end
 end
 
-repr(values::AbstractVector{<:Symbol}, colorscheme, colorrange) = repr(map(string, values), colorscheme, colorrange)
+repr(values::AbstractVector{<:Symbol}, colormap, colorrange) = repr(map(string, values), colormap, colorrange)
+
+repr(values::AbstractVector{<:AbstractString}, colormap, colorrange) = map(v -> parse(Colorant, v), values)
 
-repr(values::AbstractVector{<:AbstractString}, colorscheme, colorrange) = map(v -> parse(Colorant, v), values)
+repr(values::AbstractVector{<:Date}, colormap, colorrange) = repr(map(DateTime, values), colormap, colorrange)
 
-repr(values::AbstractVector{<:Date}, colorscheme, colorrange) = repr(map(DateTime, values), colorscheme, colorrange)
+repr(values::AbstractVector{<:DateTime}, colormap, colorrange) =
+  repr(map(datetime2unix, values), colormap, colorrange)
 
-repr(values::AbstractVector{<:DateTime}, colorscheme, colorrange) =
-  repr(map(datetime2unix, values), colorscheme, colorrange)
+"""
+    nominal(values)
+
+Nominal representation of `values` for color mapping.
+
+This function is used to convert non-numeric values to
+numeric values that can be used in ticks and color bars.
+"""
+function nominal(values)
+  # find invalid and valid indices
+  iinds = findall(isinvalid, values)
+  vinds = setdiff(1:length(values), iinds)
+
+  # if all values are invalid, return missing values
+  isempty(vinds) && return fill(missing, length(values))
+
+  # construct nominal values for valid values
+  vvalues = nominal(nonmissingvec(values[vinds]))
+
+  # construct nominal values for all values
+  if isempty(iinds) # all values are valid, return nominal values directly
+    vvalues
+  else # set missing value for invalid values
+    genvec(vinds, vvalues, iinds, missing)
+  end
+end
 
 function nominal(values::AbstractVector{<:Number})
   isna(v) = isnan(v) || isinf(v)
@@ -164,14 +171,28 @@ nominal(values::AbstractVector{<:Date}) = nominal(map(DateTime, values))
 
 nominal(values::AbstractVector{<:DateTime}) = map(datetime2unix, values)
 
+"""
+    nlevels(values)
+
+Number of levels in `values` for color mapping.
+
+This function is used to determine the number of
+colors needed for categorical data. By default,
+it returns `Inf` to indicate that the number of
+levels is infinite (i.e., continuous data).
+"""
+nlevels(values) = Inf
+
 # -----------------
 # HELPER FUNCTIONS
 # -----------------
 
-isinvalid(value) = ismissing(value) || (value isa Number && !isfinite(value))
-
 fixcolors(colors) = convert.(floattype(eltype(colors)), colors)
 
+discretescheme(colorscheme, n) = colorscheme # TODO
+
+isinvalid(value) = ismissing(value) || (value isa Number && !isfinite(value))
+
 nonmissingvec(values::AbstractVector{T}) where {T} = convert(AbstractVector{nonmissingtype(T)}, values)
 
 function genvec(vecinds, vec, valinds, val)