Add more support for color type promotions (#158)

This uses the promotion rules defined in ColorTypes.jl v0.10 or later.

Author: kimikage

src/ColorVectorSpace.jl

@@ -94,14 +94,7 @@ acctype(::Type{T1}, ::Type{T2}) where {T1,T2} = acctype(promote_type(T1, T2))
 
 acc(x::Number) = convert(acctype(typeof(x)), x)
 
-# Scalar binary RGB operations require the same RGB type for each element,
-# otherwise we don't know which to return
-color_rettype(::Type{A}, ::Type{B}) where {A<:AbstractRGB,B<:AbstractRGB} = _color_rettype(base_colorant_type(A), base_colorant_type(B))
-color_rettype(::Type{A}, ::Type{B}) where {A<:AbstractGray,B<:AbstractGray} = _color_rettype(base_colorant_type(A), base_colorant_type(B))
-color_rettype(::Type{A}, ::Type{B}) where {A<:TransparentRGB,B<:TransparentRGB} = _color_rettype(base_colorant_type(A), base_colorant_type(B))
-color_rettype(::Type{A}, ::Type{B}) where {A<:TransparentGray,B<:TransparentGray} = _color_rettype(base_colorant_type(A), base_colorant_type(B))
-_color_rettype(::Type{C}, ::Type{C}) where {C<:Colorant} = C
-
+color_rettype(::Type{C1}, ::Type{C2}) where {C1, C2} = base_colorant_type(promote_type(C1, C2))
 color_rettype(c1::Colorant, c2::Colorant) = color_rettype(typeof(c1), typeof(c2))
 
 arith_colorant_type(::C) where {C<:Colorant} = arith_colorant_type(C)
@@ -433,11 +426,7 @@ end
 function __init__()
     if isdefined(Base, :Experimental) && isdefined(Base.Experimental, :register_error_hint)
         Base.Experimental.register_error_hint(MethodError) do io, exc, argtypes, kwargs
-            if exc.f === _color_rettype && length(argtypes) >= 2
-                # Color is not necessary, this is just to show it's possible.
-                A, B = argtypes
-                A !== B && print(io, "\nIn binary operation with $A and $B, the return type is ambiguous")
-            elseif exc.f === dot && length(argtypes) == 2
+            if exc.f === dot && length(argtypes) == 2
                 if any(C -> C <: Union{TransparentGray, TransparentRGB}, argtypes)
                     print(io, "\n`dot` (or `⋅`) for transparent colors is not supported ")
                     print(io, "because the normalization is designed for opaque grays and RGBs.")

test/runtests.jl

@@ -364,8 +364,6 @@ ColorTypes.comp2(c::RGBA32) = alpha(c)
         @test_throws MethodError sum(abs2, RGB(0.1,0.2,0.3))
         @test norm(RGB(0.1,0.2,0.3)) ≈ sqrt(0.14)/sqrt(3)
 
-        @test_throws MethodError RGBX(0, 0, 1) + XRGB(1, 0, 0)
-
         acu = RGB{N0f8}[cu]
         acf = RGB{Float32}[cf]
         @test typeof(acu+acf) == Vector{RGB{Float32}}
@@ -529,7 +527,14 @@ ColorTypes.comp2(c::RGBA32) = alpha(c)
     end
 
     @testset "Mixed-type arithmetic" begin
+        # issue 155
+        @test @inferred(Gray(0.2f0) + Gray24(0.2)) === Gray{Float32}(0.2 + 0.2N0f8)
+        @test @inferred(RGBX(0, 0, 1) + XRGB(1, 0, 0)) === XRGB{N0f8}(1, 0, 1)
+        @test @inferred(BGR(0, 0, 1) + RGB24(1, 0, 0)) === RGB{N0f8}(1, 0, 1)
+        @test_throws Exception HSV(100, 0.2, 0.4) + Gray(0.2)
+
         @test AGray32(0.2, 0.4) + Gray24(0.2) === AGray32(0.4, 0.4N0f8+1N0f8)
+        @test AGray32(0.2, 0.4) + Gray(0.2f0) === AGray{Float32}(0.2+0.2N0f8, 0.4N0f8+1)
         @test RGB(1, 0, 0)      + Gray(0.2f0) === RGB{Float32}(1.2, 0.2, 0.2)
         @test RGB(1, 0, 0)      - Gray(0.2f0) === RGB{Float32}(0.8, -0.2, -0.2)
         @test RGB24(1, 0, 0)    + Gray(0.2f0) === RGB{Float32}(1.2, 0.2, 0.2)
@@ -541,6 +546,7 @@ ColorTypes.comp2(c::RGBA32) = alpha(c)
         @test RGB24(0.4, 0.6, 0.5) - AGray32(0.4, 0.2) === ARGB32(0, 0.2, 0.1, 0.8)
         @test ARGB32(0.4, 0, 0.2, 0.5) + Gray24(0.4)   === ARGB32(0.8, 0.4, 0.6, 0.5N0f8+1N0f8)
         @test ARGB32(0.4, 0, 0.2, 0.5) + AGray32(0.4, 0.2) === ARGB32(0.8, 0.4, 0.6, 0.5N0f8+0.2N0f8)
+        @test ARGB32(0.4, 0, 0.2, 0.5) + RGB(0.4f0, 0, 0) === ARGB{Float32}(0.4N0f8+0.4, 0, 0.2N0f8, 0.5N0f8+1)
 
         g, rgb = Gray{Float32}(0.2), RGB{Float64}(0.1, 0.2, 0.3)
         ag, argb = AGray{Float64}(0.2, 0.8), ARGB{Float32}(0.1, 0.2, 0.3, 0.4)