Add support for hadamard(⊙) for TransparentGray/TransparentRGB (#162)

Author: kimikage

src/ColorVectorSpace.jl

@@ -187,10 +187,12 @@ copy(c::MathTypes) = c
 (/)(c::MathTypes, f::Integer) = (one(eltype(c))/f)*c
 abs(c::MathTypes) = mapc(abs, c)
 norm(c::MathTypes, p::Real=2) = (cc = channels(c); norm(cc, p)/(p == 0 ? length(cc) : length(cc)^(1/p)))
+(⊙)(a::C, b::C) where {C<:MathTypes} = mapc(*, a, b)
 
 ## Mixed types
 (+)(a::MathTypes, b::MathTypes) = (+)(promote(a, b)...)
 (-)(a::MathTypes, b::MathTypes) = (-)(promote(a, b)...)
+(⊙)(a::MathTypes, b::MathTypes) = (⊙)(promote(a, b)...)
 
 
 # Scalar RGB
@@ -220,8 +222,6 @@ end
 # New multiplication operators
 (⋅)(x::AbstractRGB, y::AbstractRGB)  = (T = acctype(eltype(x), eltype(y)); T(red(x))*T(red(y)) + T(green(x))*T(green(y)) + T(blue(x))*T(blue(y)))/3
 (⋅)(x::Union{AbstractRGB,AbstractGray}, y::Union{AbstractRGB,AbstractGray})  = ⋅(promote(x, y)...)
-(⊙)(x::C, y::C) where C<:AbstractRGB = base_color_type(C)(red(x)*red(y), green(x)*green(y), blue(x)*blue(y))
-(⊙)(x::Union{AbstractRGB,AbstractGray}, y::Union{AbstractRGB,AbstractGray})  = ⊙(promote(x, y)...)
 # ⊗ defined below
 
 
@@ -278,9 +278,7 @@ middle(x::C, y::C) where {C<:AbstractGray} = arith_colorant_type(C)(middle(gray(
 (-)(a::Number, b::AbstractGray) = base_color_type(b)(a-gray(b))
 
 (⋅)(x::AbstractGray, y::AbstractGray) = gray(x)*gray(y)
-(⊙)(x::C, y::C) where C<:AbstractGray = base_color_type(C)(gray(x)*gray(y))
-(⊙)(x::AbstractGray, y::AbstractGray) = ⊙(promote(x, y)...)
-(⊗)(x::AbstractGray, y::AbstractGray) = ⊙(x, y)
+(⊗)(x::AbstractGray, y::AbstractGray) = x ⊙ y
 
 max(a::T, b::T) where {T<:AbstractGray} = T(max(gray(a),gray(b)))
 max(a::AbstractGray, b::AbstractGray) = max(promote(a,b)...)
@@ -304,7 +302,7 @@ if !hasmethod(isless, Tuple{AbstractGray,Real})  # planned for ColorTypes 0.11
     isless(r::Real, c::AbstractGray) = isless(r, gray(c))
 end
 
-dotc(x::T, y::T) where {T<:AbstractGray} = acc(gray(x))*acc(gray(y))
+dotc(x::C, y::C) where {C<:AbstractGray} = acc(gray(x))*acc(gray(y))
 dotc(x::AbstractGray, y::AbstractGray) = dotc(promote(x, y)...)
 
 typemin(::Type{C}) where {C<:AbstractGray} = C(typemin(eltype(C)))

test/runtests.jl

@@ -315,6 +315,15 @@ ColorTypes.comp2(c::RGBA32) = alpha(c)
         @test @inferred(GrayA32(0.8,0.2)/2)   === GrayA(0.5f0*N0f8(0.8),0.5f0*N0f8(0.2))
         @test @inferred(GrayA32(0.8,0.2)/2.0) === GrayA(0.4,0.1)
         @test @inferred(GrayA32(1, 0.4) - GrayA32(0.2, 0.2)) === GrayA32(0.8, 0.2)
+
+        # Multiplication
+        cf = AGray{Float32}(0.8, 0.2)
+        @test_throws MethodError cf * cf
+        @test_throws MethodError cf ⋅ cf
+        @test_throws MethodError cf ⊗ cf
+        cf64 = mapc(Float64, cf)
+        @test @inferred(cf ⊙ cf)   === AGray{Float32}(0.8f0^2, 0.2f0^2)
+        @test @inferred(cf ⊙ cf64) === AGray{Float64}(0.8f0*(0.8f0*1.0), 0.2f0*(0.2f0*1.0))
     end
 
     @testset "Arithemtic with RGB" begin
@@ -508,6 +517,15 @@ ColorTypes.comp2(c::RGBA32) = alpha(c)
         @test @inferred(RGBA32(1,0,0,0.8)/2)   === RGBA(0.5f0,0,0,0.5f0*N0f8(0.8))
         @test @inferred(RGBA32(1,0,0,0.8)/2.0) === RGBA(0.5,0,0,0.4)
         @test @inferred(RGBA32(1, 0, 0, 0.2) + RGBA32(0, 0, 1, 0.2)) === RGBA32(1, 0, 1, 0.4)
+
+        # Multiplication
+        @test_throws MethodError cf * cf
+        @test_throws MethodError cf ⋅ cf
+        @test_throws MethodError cf ⊗ cf
+        cf64 = mapc(Float64, cf)
+        @test @inferred(cf ⊙ cf)   === RGBA{Float32}(0.1f0^2, 0.2f0^2, 0.3f0^2, 0.4f0^2)
+        @test @inferred(cf ⊙ cf64) === RGBA{Float64}(0.1f0*(0.1f0*1.0), 0.2f0*(0.2f0*1.0),
+                                                     0.3f0*(0.3f0*1.0), 0.4f0*(0.4f0*1.0))
     end
 
     @testset "Mixed-type arithmetic" begin
@@ -524,11 +542,28 @@ ColorTypes.comp2(c::RGBA32) = alpha(c)
         @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)
 
-        g, rgb = Gray(0.2), RGB(0.1, 0.2, 0.3)
-        @test g ⋅ rgb == rgb ⋅ g ≈ 0.2*(0.1 + 0.2 + 0.3)/3
-        @test g ⊙ rgb == rgb ⊙ g ≈ RGB(0.2*0.1, 0.2^2, 0.2*0.3)
-        @test g ⊗ rgb == RGB(g) ⊗ rgb
-        @test rgb ⊗ g == rgb ⊗ RGB(g)
+        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)
+        @test g ⋅ rgb === rgb ⋅ g === 0.2f0*(0.1 + 0.2 + 0.3)/3
+        @test_throws MethodError g ⋅ ag
+        @test_throws MethodError g ⋅ argb
+        @test_throws MethodError ag ⋅ rgb
+        @test_throws MethodError ag ⋅ argb
+        @test_throws MethodError rgb ⋅ argb
+        @test g ⊙ rgb === rgb ⊙ g === RGB{Float64}(0.2f0*0.1, 0.2f0*0.2, 0.2f0*0.3)
+        @test g ⊙ ag === ag ⊙ g === AGray{Float64}(0.2f0*0.2, 1.0f0*0.8)
+        @test g ⊙ argb === argb ⊙ g === ARGB{Float32}(0.2f0*0.1f0, 0.2f0*0.2f0, 0.2f0*0.3f0, 1.0f0*0.4f0)
+        @test ag ⊙ rgb === rgb ⊙ ag === ARGB{Float64}(0.2*0.1, 0.2*0.2, 0.2*0.3, 0.8*1.0)
+        @test ag ⊙ argb === argb ⊙ ag === ARGB{Float64}(0.2*0.1f0, 0.2*0.2f0, 0.2*0.3f0, 0.8*0.4f0)
+        @test rgb ⊙ argb === argb ⊙ rgb === ARGB{Float64}(0.1*0.1f0, 0.2*0.2f0, 0.3*0.3f0, 1.0*0.4f0)
+        @test g ⊗ rgb === RGB(g) ⊗ rgb
+        @test rgb ⊗ g === rgb ⊗ RGB(g)
+        @test Matrix(g ⊗ rgb) == Matrix(rgb ⊗ g)'
+        @test_throws MethodError g ⊗ ag
+        @test_throws MethodError g ⊗ argb
+        @test_throws MethodError ag ⊗ rgb
+        @test_throws MethodError ag ⊗ argb
+        @test_throws MethodError rgb ⊗ argb
     end
 
     @testset "Custom RGB arithmetic" begin # see also the `RGBA32` cases above