def _perspective_correct_barycentrics(vertices_per_pixel, model_to_eye_matrix,
perspective_matrix, image_size_float):
"""Creates the pixels grid and computes barycentrics."""
# Construct the pixel grid with half-integer pixel centers.
width = image_size_float[1]
height = image_size_float[0]
px = tf.linspace(0.5, width - 0.5, num=int(width))
py = tf.linspace(0.5, height - 0.5, num=int(height))
xv, yv = tf.meshgrid(px, py)
pixel_position = tf.stack((xv, yv), axis=-1)
return glm.perspective_correct_barycentrics(vertices_per_pixel,
pixel_position,
model_to_eye_matrix,
perspective_matrix,
(width, height))
def test_perspective_correct_barycentrics_preset(self):
"""Tests that perspective_correct_barycentrics generates expected results."""
camera_origin = np.array((0.0, 0.0, 0.0))
camera_up = np.array((0.0, 1.0, 0.0))
look_at_point = np.array((0.0, 0.0, 1.0))
fov = np.array((90.0 * np.math.pi / 180.0,))
bottom_left = np.array((0.0, 0.0))
image_size = np.array((501.0, 501.0))
near_plane = np.array((0.01,))
far_plane = np.array((10.0,))
batch_size = np.random.randint(1, 5)
triangle_x_y = np.random.uniform(-10.0, 10.0, (batch_size, 3, 2))
triangle_z = np.random.uniform(2.0, 10.0, (batch_size, 3, 1))
triangles = np.concatenate((triangle_x_y, triangle_z), axis=-1)
# Builds barycentric weights.
barycentric_weights = np.random.uniform(size=(batch_size, 3))
barycentric_weights = barycentric_weights / np.sum(
barycentric_weights, axis=-1, keepdims=True)
# Barycentric interpolation of vertex positions.
convex_combination = np.einsum("ba, bac -> bc", barycentric_weights,
triangles)
# Build matrices.
model_to_eye_matrix = look_at.right_handed(camera_origin, look_at_point,
camera_up)
perspective_matrix = perspective.right_handed(
fov, (image_size[0:1] / image_size[1:2]), near_plane, far_plane)
# Computes where those points project in screen coordinates.
pixel_position, _ = glm.model_to_screen(convex_combination,
model_to_eye_matrix,
perspective_matrix, image_size,
bottom_left)
prediction = glm.perspective_correct_barycentrics(triangles,
pixel_position[..., 0:2],
model_to_eye_matrix,
perspective_matrix,
image_size, bottom_left)
self.assertAllClose(prediction, barycentric_weights)
def _perspective_correct_barycentrics(vertices_per_pixel, model_to_eye_matrix,
perspective_matrix, image_size_float):
"""Creates the pixels grid and computes barycentrics."""
# Construct the pixel grid with half-integer pixel centers.
width = image_size_float[1]
height = image_size_float[0]
px = tf.linspace(0.5, width - 0.5, num=int(width))
py = tf.linspace(0.5, height - 0.5, num=int(height))
xv, yv = tf.meshgrid(px, py)
pixel_position = tf.stack((xv, yv), axis=-1)
# Since `model_to_eye_matrix` is defined per batch, while vertices in
# `vertices_per_pixel` are defined per batch per pixel, we have to make them
# broadcast-compatible. In other words we want to tile matrices per vertex
# per pixel.
image_shape = vertices_per_pixel.shape[1:-1]
model_to_eye_matrix = _tile_to_image_size(model_to_eye_matrix, image_shape)
perspective_matrix = _tile_to_image_size(perspective_matrix, image_shape)
return glm.perspective_correct_barycentrics(vertices_per_pixel,
pixel_position,
model_to_eye_matrix,
perspective_matrix,
(width, height))