Blend Image Op (#1275)

* autoaugment, no changes

* autoaugment with tfa and tf2

* removed contrib_training, hparams for now

* Delete hparam.py

* init augment_ops, added blend

* typo in BUILD

* added random test, round, unint8 ValueError

* fixed build

* image test

* add previous tests

* removed image test

Author: NoobMaster

Diff for: tensorflow_addons/image/BUILD

@@ -17,6 +17,7 @@ py_library(
         "interpolate_spline.py",
         "connected_components.py",
         "resampler_ops.py",
+        "compose_ops.py",
     ]),
     data = [
         ":sparse_image_warp_test_data",
@@ -164,3 +165,15 @@ py_test(
         ":image",
     ],
 )
+
+py_test(
+    name = "compose_ops_test",
+    size = "medium",
+    srcs = [
+        "compose_ops_test.py",
+    ],
+    main = "compose_ops_test.py",
+    deps = [
+        ":image",
+    ],
+)

Diff for: tensorflow_addons/image/__init__.py

@@ -28,3 +28,4 @@
 from tensorflow_addons.image.transform_ops import rotate
 from tensorflow_addons.image.transform_ops import transform
 from tensorflow_addons.image.translate_ops import translate
+from tensorflow_addons.image.compose_ops import blend

Diff for: tensorflow_addons/image/compose_ops.py

@@ -0,0 +1,69 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Compose Ops"""
+
+import tensorflow as tf
+
+from tensorflow_addons.utils.types import TensorLike
+
+
+def blend(image1: TensorLike, image2: TensorLike, factor: float) -> TensorLike:
+    """Blend image1 and image2 using 'factor'.
+
+  Factor can be above 0.0.  A value of 0.0 means only image1 is used.
+  A value of 1.0 means only image2 is used.  A value between 0.0 and
+  1.0 means we linearly interpolate the pixel values between the two
+  images.  A value greater than 1.0 "extrapolates" the difference
+  between the two pixel values, and we clip the results to values
+  between 0 and 255.
+
+  Args:
+    image1: An image Tensor of type uint8.
+    image2: An image Tensor of type uint8.
+    factor: A floating point value above 0.0.
+
+  Returns:
+    A blended image Tensor of type uint8.
+
+  """
+    with tf.name_scope("blend"):
+        if image1.dtype != tf.uint8 or image2.dtype != tf.uint8:
+            raise ValueError("Images must have dtype tf.uint8")
+
+        if factor == 0.0:
+            return tf.convert_to_tensor(image1)
+        if factor == 1.0:
+            return tf.convert_to_tensor(image2)
+
+        image1 = tf.cast(image1, dtype=tf.dtypes.float32)
+        image2 = tf.cast(image2, dtype=tf.dtypes.float32)
+
+        difference = image2 - image1
+        scaled = factor * difference
+
+        # Do addition in float.
+        temp = image1 + scaled
+
+        # Interpolate
+        if factor > 0.0 and factor < 1.0:
+            # Interpolation means we always stay within 0 and 255.
+            temp = tf.round(temp)
+            return tf.cast(temp, tf.dtypes.uint8)
+
+        # Extrapolate:
+        #
+        # We need to clip and then cast.
+        temp = tf.round(tf.clip_by_value(temp, 0.0, 255.0))
+        return tf.cast(temp, tf.dtypes.uint8)

Diff for: tensorflow_addons/image/compose_ops_test.py

@@ -0,0 +1,79 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests of augmentation ops"""
+
+import sys
+import pytest
+import tensorflow as tf
+import numpy as np
+
+from tensorflow_addons.image import compose_ops
+from tensorflow_addons.utils import test_utils
+
+_DTYPES = {
+    tf.dtypes.uint8,
+}
+
+
+def blend_np(image1, image2, factor):
+    image1 = image1.astype("float32")
+    image2 = image2.astype("float32")
+    difference = image2 - image1
+    scaled = factor * difference
+    temp = image1 + scaled
+    if factor >= 0.0 and factor <= 1.0:
+        temp = np.round(temp)
+        return temp.astype("uint8")
+    temp = np.round(np.clip(temp, 0.0, 255.0))
+    return temp.astype("uint8")
+
+
+@test_utils.run_all_in_graph_and_eager_modes
+class ComposeOpTest(tf.test.TestCase):
+    def test_blend(self):
+        for dtype in _DTYPES:
+            image1 = tf.constant(
+                [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=dtype
+            )
+            image2 = tf.constant(
+                [
+                    [255, 255, 255, 255],
+                    [255, 255, 255, 255],
+                    [255, 255, 255, 255],
+                    [255, 255, 255, 255],
+                ],
+                dtype=dtype,
+            )
+            blended = compose_ops.blend(image1, image2, 0.5)
+            self.assertAllEqual(
+                self.evaluate(blended),
+                [
+                    [128, 128, 128, 128],
+                    [128, 128, 128, 128],
+                    [128, 128, 128, 128],
+                    [128, 128, 128, 128],
+                ],
+            )
+
+            image1 = np.random.randint(0, 255, (4, 4, 3), np.uint8)
+            image2 = np.random.randint(0, 255, (4, 4, 3), np.uint8)
+            blended = compose_ops.blend(
+                tf.convert_to_tensor(image1), tf.convert_to_tensor(image2), 0.35
+            )
+            self.assertAllEqual(self.evaluate(blended), blend_np(image1, image2, 0.35))
+
+
+if __name__ == "__main__":
+    sys.exit(pytest.main([__file__]))