Introduce shouldapply function

src/operation.jl

@@ -17,6 +17,20 @@
 @inline supports_stepview(A)   = supports_stepview(typeof(A))
 @inline supports_lazy(A)       = supports_lazy(typeof(A))
 
+"""
+    shouldapply(op, what)
+    shouldapply(typeof(op), typeof(what))
+
+Determines if operation `op` should be applied to `what`, which can be either
+an image or a semantic wrapper.
+"""
+shouldapply(op, what) = shouldapply(typeof(op), typeof(what))
+shouldapply(::Type{<:ImageOperation}, ::Type{<:AbstractArray})   = true
+shouldapply(::Type{<:ImageOperation}, ::Type{<:SemanticWrapper}) = true
+shouldapply(::Type{<:ColorOperation}, ::Type{Mask})              = true
+# By default any operation is applicable to any image and any semantic wrapper.
+# Add new methods to this function to define exceptions.
+
 # --------------------------------------------------------------------
 
 """

test/tst_operations.jl

@@ -7,6 +7,45 @@
 @test Augmentor.AffineOperation <: Augmentor.ImageOperation
 @test Augmentor.ColorOperation <: Augmentor.ImageOperation
 
+@testset "shouldapply" begin
+    @testset "type arguments" begin
+        ops = [Rotate90(), ColorJitter()]
+        whats = [testpattern(), Augmentor.Mask(testpattern())]
+        for op in ops, what in whats
+            @test Augmentor.shouldapply(op, what) == Augmentor.shouldapply(typeof(op), typeof(what))
+        end
+    end
+
+    @testset "affine operations" begin
+        ops = [FlipX, FlipY, NoOp, Rotate, Rotate180, Rotate270, Rotate90,
+               Scale, ShearX, ShearY]
+        applicable = [AbstractMatrix, Augmentor.Mask]
+        notapplicable = []
+        for op in ops
+            for what in applicable
+                @test Augmentor.shouldapply(op, what)
+            end
+            for what in notapplicable
+                @test !Augmentor.shouldapply(op, what)
+            end
+        end
+    end
+
+    @testset "color operations" begin
+        ops = [ColorJitter]
+        applicable = [AbstractMatrix]
+        notapplicable = [Augmentor.Mask]
+        for op in ops
+            for what in applicable
+                @test Augmentor.shouldapply(op, what)
+            end
+            for what in notapplicable
+                @test !Augmentor.shouldapply(op, what)
+            end
+        end
+    end
+end
+
 @testset "prepare" begin
     @test @inferred(Augmentor.preparelazy(rect)) === rect
     wv = @inferred Augmentor.prepareaffine(rect)