Rasterization backend golden tests.

PiperOrigin-RevId: 363596956

Author: podlipensky

tensorflow_graphics/rendering/tests/interpolate_test.py

@@ -0,0 +1,77 @@
+# Copyright 2020 The TensorFlow Authors
+#
+# 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
+#
+#    https://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 for tensorflow_graphics.rendering.tests.interpolate."""
+
+import tensorflow as tf
+
+from tensorflow_graphics.rendering import interpolate
+from tensorflow_graphics.rendering import rasterization_backend
+from tensorflow_graphics.rendering.tests import rasterization_test_utils
+from tensorflow_graphics.util import test_case
+
+
+class RasterizeTest(test_case.TestCase):
+
+  def setUp(self):
+    super(RasterizeTest, self).setUp()
+
+    self.test_data_directory = (
+        'google3/research/vision/viscam/diffren/mesh/test_data/')
+
+    self.cube_vertex_positions = tf.constant(
+        [[[-1, -1, 1], [-1, -1, -1], [-1, 1, -1], [-1, 1, 1], [1, -1, 1],
+          [1, -1, -1], [1, 1, -1], [1, 1, 1]]],
+        dtype=tf.float32)
+    self.cube_triangles = tf.constant(
+        [[0, 1, 2], [2, 3, 0], [3, 2, 6], [6, 7, 3], [7, 6, 5], [5, 4, 7],
+         [4, 5, 1], [1, 0, 4], [5, 6, 2], [2, 1, 5], [7, 4, 0], [0, 3, 7]],
+        dtype=tf.int32)
+
+    self.image_width = 640
+    self.image_height = 480
+    perspective = rasterization_test_utils.make_perspective_matrix(
+        self.image_width, self.image_height)
+    projection = tf.matmul(
+        perspective,
+        rasterization_test_utils.make_look_at_matrix(
+            camera_origin=(2.0, 3.0, 6.0)))
+    # Add batch dimension.
+    self.projection = tf.expand_dims(projection, axis=0)
+
+  def test_renders_colored_cube(self):
+    """Renders a simple colored cube in two viewpoints."""
+    num_layers = 1
+    rasterized = rasterization_backend.rasterize(
+        self.cube_vertex_positions,
+        self.cube_triangles,
+        self.projection, (self.image_width, self.image_height),
+        num_layers=num_layers,
+        enable_cull_face=False,
+        backend=rasterization_backend.RasterizationBackends.CPU)
+
+    vertex_rgb = (self.cube_vertex_positions * 0.5 + 0.5)
+    vertex_rgba = tf.concat([vertex_rgb, tf.ones([1, 8, 1])], axis=-1)
+    rendered = interpolate.interpolate_vertex_attribute(vertex_rgba,
+                                                        rasterized).value
+
+    baseline_image = rasterization_test_utils.load_baseline_image(
+        'Unlit_Cube_0_0.png', rendered.shape)
+
+    images_near, error_message = rasterization_test_utils.compare_images(
+        self, baseline_image, rendered)
+    self.assertTrue(images_near, msg=error_message)
+
+
+if __name__ == '__main__':
+  tf.test.main()

tensorflow_graphics/rendering/tests/rasterization_backend_test_base.py

@@ -17,12 +17,16 @@
 import tensorflow as tf
 
 from tensorflow_graphics.rendering import rasterization_backend
+from tensorflow_graphics.rendering.tests import rasterization_test_utils
 from tensorflow_graphics.util import test_case
 
 
 class RasterizationBackendTestBase(test_case.TestCase):
   """Base class for CPU/GPU rasterization backend tests."""
 
+  IMAGE_WIDTH = 640
+  IMAGE_HEIGHT = 480
+
   def setUp(self):
     super().setUp()
     self._backend = rasterization_backend.RasterizationBackends.OPENGL
@@ -75,8 +79,9 @@ def test_rasterizer_return_correct_batch_shapes(self, shapes, dtypes,
     """Tests that supported backends return correct shape."""
     placeholders = self._create_placeholders(shapes, dtypes)
     frame_buffer = rasterization_backend.rasterize(
-        placeholders[0], placeholders[1], placeholders[2], (600, 800),
-        enable_cull_face, self._num_layers, self._backend)
+        placeholders[0], placeholders[1], placeholders[2],
+        (self.IMAGE_WIDTH, self.IMAGE_HEIGHT), enable_cull_face,
+        self._num_layers, self._backend)
     batch_size = shapes[0][0]
     self.assertEqual([batch_size],
                      frame_buffer.triangle_id.get_shape().as_list()[:-3])
@@ -94,7 +99,8 @@ def test_rasterizer_rasterize_exception_raised(self, shapes, dtypes, backend):
     placeholders = self._create_placeholders(shapes, dtypes)
     with self.assertRaisesRegexp(KeyError, 'Backend is not supported'):
       rasterization_backend.rasterize(placeholders[0], placeholders[1],
-                                      placeholders[2], (600, 800),
+                                      placeholders[2],
+                                      (self.IMAGE_WIDTH, self.IMAGE_HEIGHT),
                                       self._enable_cull_face, self._num_layers,
                                       backend)
 
@@ -105,8 +111,9 @@ def test_rasterizer_all_vertices_visible(self):
     triangles = tf.convert_to_tensor([[0, 1, 2]], dtype=tf.int32)
     view_projection_matrix = tf.expand_dims(tf.eye(4), axis=0)
     frame_buffer = rasterization_backend.rasterize(
-        vertices, triangles, view_projection_matrix, (100, 100),
-        self._enable_cull_face, self._num_layers, self._backend)
+        vertices, triangles, view_projection_matrix,
+        (self.IMAGE_WIDTH, self.IMAGE_HEIGHT), self._enable_cull_face,
+        self._num_layers, self._backend)
     self.assertAllEqual(frame_buffer.triangle_id.shape[:-1],
                         frame_buffer.vertex_ids.shape[:-1])
     # Assert that triangle is visible.
@@ -115,3 +122,28 @@ def test_rasterizer_all_vertices_visible(self):
     # Assert that all three vertices are visible.
     self.assertAllLess(frame_buffer.triangle_id, 3)
     self.assertAllGreaterEqual(frame_buffer.triangle_id, 0)
+
+  def test_render_simple_triangle(self):
+    """Directly renders a rasterized triangle's barycentric coordinates."""
+    w_vector = tf.constant([1.0, 1.0, 1.0], dtype=tf.float32)
+    clip_init = tf.constant(
+        [[[-0.5, -0.5, 0.8], [0.0, 0.5, 0.3], [0.5, -0.5, 0.3]]],
+        dtype=tf.float32)
+    clip_coordinates = clip_init * tf.reshape(w_vector, [1, 3, 1])
+    triangles = tf.constant([[0, 1, 2]], dtype=tf.int32)
+
+    face_culling_enabled = False
+    framebuffer = rasterization_backend.rasterize(
+        clip_coordinates, triangles, tf.eye(4, batch_shape=[1]),
+        (self.IMAGE_WIDTH, self.IMAGE_HEIGHT), face_culling_enabled,
+        self._num_layers, self._backend)
+    ones_image = tf.ones([1, self.IMAGE_HEIGHT, self.IMAGE_WIDTH, 1])
+    rendered_coordinates = tf.concat(
+        [framebuffer.barycentrics.value, ones_image], axis=-1)
+
+    baseline_image = rasterization_test_utils.load_baseline_image(
+        'Simple_Triangle.png', rendered_coordinates.shape)
+
+    images_near, error_message = rasterization_test_utils.compare_images(
+        self, baseline_image, rendered_coordinates)
+    self.assertTrue(images_near, msg=error_message)

tensorflow_graphics/rendering/tests/rasterization_test_utils.py

@@ -0,0 +1,124 @@
+# Copyright 2020 The TensorFlow Authors
+#
+# 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
+#
+#    https://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.
+"""Util functions for rasterization tests."""
+
+import os
+
+import numpy as np
+import tensorflow as tf
+
+from tensorflow_graphics.geometry.transformation import look_at
+from tensorflow_graphics.rendering.camera import perspective
+from tensorflow_graphics.util import shape
+
+
+def make_perspective_matrix(image_width=None, image_height=None):
+  """Generates perspective matrix for a given image size.
+
+  Args:
+    image_width: int representing image width.
+    image_height: int representing image height.
+
+  Returns:
+    Perspective matrix, tensor of shape [4, 4].
+
+  Note: Golden tests require image size to be fixed and equal to the size of
+  golden image examples.
+  """
+
+  field_of_view = (40 * np.math.pi / 180,)
+  near_plane = (0.01,)
+  far_plane = (10.0,)
+  return perspective.right_handed(field_of_view,
+                                  (float(image_width) / float(image_height),),
+                                  near_plane, far_plane)
+
+
+def make_look_at_matrix(
+    camera_origin=(0.0, 0.0, 0.0), look_at_point=(0.0, 0.0, 0.0)):
+  camera_up = (0.0, 1.0, 0.0)
+  return look_at.right_handed(camera_origin, look_at_point, camera_up)
+
+
+def compare_images(test_case,
+                   baseline_image,
+                   image,
+                   max_outlier_fraction=0.005,
+                   pixel_error_threshold=0.04):
+  """Compares two image arrays.
+
+  The comparison is soft: the images are considered identical if fewer than
+  max_outlier_fraction of the pixels differ by more than pixel_error_threshold
+  of the full color value.
+
+  Differences in JPEG encoding can produce pixels with pretty large variation,
+  so by default we use 0.04 (4%) for pixel_error_threshold and 0.005 (0.5%) for
+  max_outlier_fraction.
+
+  Args:
+    test_case: test_case.TestCase instance this util function is used in.
+    baseline_image: tensor of shape [batch, height, width, channels] containing
+      the baseline image.
+    image: tensor of shape [batch, height, width, channels] containing the
+      result image.
+    max_outlier_fraction: fraction of pixels that may vary by more than the
+      error threshold. 0.005 means 0.5% of pixels. Number of outliers are
+      computed and compared per image.
+    pixel_error_threshold: pixel values are considered to differ if their
+      difference exceeds this amount. Range is 0.0 - 1.0.
+
+  Returns:
+    Tuple of a boolean and string error message. Boolean indicates
+    whether images are close to each other or not. Error message contains
+    details of two images mismatch.
+  """
+  tf.assert_equal(baseline_image.shape, image.shape)
+  if baseline_image.dtype != image.dtype:
+    return False, ("Image types %s and %s do not match" %
+                   (baseline_image.dtype, image.dtype))
+  shape.check_static(
+      tensor=baseline_image, tensor_name="baseline_image", has_rank=4)
+  # Flatten height, width and channels dimensions since we're interested in
+  # error per image.
+  image_height, image_width = image.shape[1:3]
+  baseline_image = tf.reshape(baseline_image, [baseline_image.shape[0]] + [-1])
+  image = tf.reshape(image, [image.shape[0]] + [-1])
+  abs_diff = tf.abs(baseline_image - image)
+  outliers = tf.math.greater(abs_diff, pixel_error_threshold)
+  num_outliers = tf.math.reduce_sum(tf.cast(outliers, tf.int32))
+  perc_outliers = num_outliers / (image_height * image_width)
+  error_msg = "{:.2%} pixels are not equal to baseline image pixels.".format(
+      test_case.evaluate(perc_outliers) * 100.0)
+  return test_case.evaluate(perc_outliers < max_outlier_fraction), error_msg
+
+
+def load_baseline_image(filename, image_shape=None):
+  """Loads baseline image and makes sure it is of the right shape.
+
+  Args:
+    filename: file name of the image to load.
+    image_shape: expected shape of the image.
+
+  Returns:
+    tf.Tensor with baseline image
+  """
+  image_path = tf.compat.v1.resource_loader.get_path_to_datafile(
+      os.path.join("test_data", filename))
+  file = tf.io.read_file(image_path)
+  baseline_image = tf.cast(tf.image.decode_image(file), tf.float32) / 255.0
+  baseline_image = tf.expand_dims(baseline_image, axis=0)
+  if image_shape is not None:
+    # Graph-mode requires image shape to be known in advance.
+    baseline_image = tf.reshape(baseline_image, image_shape)
+  return baseline_image