Datasets:

WalkerCH
/

stream3d

# Copyright 2023 Google LLC
#
# 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.
#
# Author: spopov@google.com (Stefan Popov)
"""Functions to compute transformation matrices."""

import torch as t
from torch.nn import functional as F


def scale(v: t.Tensor) -> t.Tensor:
  """Computes homogeneous scale matrices from scale vectors.
  Args:
    v: Scale vectors, `float32[B*, N]`
  Returns:
    Scale matrices, `float32[B*, N+1, N+1]`
  """
  v = t.as_tensor(v, dtype=t.float32)
  batch_dims = v.shape[:-1]
  v = v.reshape([-1, (v.shape[-1])])

  index_batch_flat = t.arange(v.shape[0], dtype=t.int64, device=v.device)
  index_diag = t.arange(v.shape[1], dtype=t.int64, device=v.device)
  index_batch, index_diag = t.meshgrid(index_batch_flat, index_diag,
                                       indexing="ij")
  index_batch = index_batch.reshape([-1])
  index_diag = index_diag.reshape([-1])

  result = v.new_zeros([v.shape[0], v.shape[1] + 1, v.shape[1] + 1])
  result[index_batch, index_diag, index_diag] = v.reshape([-1])
  result[index_batch_flat, v.shape[-1], v.shape[-1]] = 1
  result = result.reshape(batch_dims + result.shape[-2:])
  return result


def translate(v: t.Tensor) -> t.Tensor:
  """Computes a homogeneous translation matrices from translation vectors.
  Args:
    v: Translation vectors, `float32[B*, N]`
  Returns:
    Translation matrices, `float32[B*, N+1, N+1]`
  """
  result = t.as_tensor(v, dtype=t.float32)
  dimensions = result.shape[-1]
  result = result[..., None, :].transpose(-1, -2)
  result = t.constant_pad_nd(result, [dimensions, 0, 0, 1])
  id_matrix = t.diag(result.new_ones([dimensions + 1]))
  id_matrix = id_matrix.expand_as(result)
  result = result + id_matrix
  return result


def rotate(
    angle: t.Tensor,
    axis: t.Tensor,
) -> t.Tensor:
  """Computes a 3D rotation matrices from angle and axis inputs.
  The formula used in this function is explained here:
  https://en.wikipedia.org/wiki/Rotation_matrix#Conversion_from_and_to_axis–angle
  Args:
    angle: The rotation angles, `float32[B*]`
    axis: The rotation axes, `float32[B*, 3]`
  Returns:
    The rotation matrices, `float32[B*, 4, 4]`
  """
  axis = t.as_tensor(axis, dtype=t.float32)
  angle = t.as_tensor(angle, dtype=t.float32)
  axis = F.normalize(axis, dim=-1)
  sin_axis = t.sin(angle)[..., None] * axis
  cos_angle = t.cos(angle)
  cos1_axis = (1.0 - cos_angle)[..., None] * axis
  _, axis_y, axis_z = t.unbind(axis, dim=-1)
  cos1_axis_x, cos1_axis_y, _ = t.unbind(cos1_axis, dim=-1)
  sin_axis_x, sin_axis_y, sin_axis_z = t.unbind(sin_axis, dim=-1)
  tmp = cos1_axis_x * axis_y
  m01 = tmp - sin_axis_z
  m10 = tmp + sin_axis_z
  tmp = cos1_axis_x * axis_z
  m02 = tmp + sin_axis_y
  m20 = tmp - sin_axis_y
  tmp = cos1_axis_y * axis_z
  m12 = tmp - sin_axis_x
  m21 = tmp + sin_axis_x
  zero = t.zeros_like(m01)
  one = t.ones_like(m01)
  diag = cos1_axis * axis + cos_angle[..., None]
  diag_x, diag_y, diag_z = t.unbind(diag, dim=-1)

  matrix = t.stack((diag_x, m01, m02, zero, m10, diag_y, m12, zero, m20, m21,
                    diag_z, zero, zero, zero, zero, one), dim=-1)
  output_shape = axis.shape[:-1] + (4, 4)
  result = matrix.reshape(output_shape)
  return result


def transform_points_homogeneous(points: t.Tensor, matrix: t.Tensor,
                                 w: float) -> t.Tensor:
  """Transforms 3D points with a homogeneous matrix.
  Args:
    points: The points to transform, `float32[B*, N, 3]`
    matrix: The transformation matrices, `float32[B*, 4, 4]`
    w: The W value to add to the points to make them homogeneous. Should be 1
      for affine points and 0 for vectors.
  Returns:
    The transformed points in homogeneous space (with a 4th coordinate),
    `float32[B*, N, 4]`
  """
  batch_dims = points.shape[:-2]
  # Fold all batch dimensions into a single one
  points = points.reshape([-1] + list(points.shape[-2:]))
  matrix = matrix.reshape([-1] + list(matrix.shape[-2:]))

  points = t.constant_pad_nd(points, [0, 1], value=w)
  result = t.einsum("bnm,bvm->bvn", matrix, points)
  result = result.reshape(batch_dims + result.shape[-2:])

  return result


def transform_mesh(mesh: t.Tensor, matrix: t.Tensor,
                   vertices_are_points=True) -> t.Tensor:
  """Transforms a single 3D mesh.
  Args:
    mesh: The mesh's triangle vertices, `float32[B*, N, 3, 3]`
    matrix: The transformation matrix, `float32[B*, 4, 4]`
    vertices_are_points: Whether to interpret the vertices as affine points
      or vectors.
  Returns:
    The transformed mesh, `float32[B*, N, 3, 3]`
  """
  original_shape = mesh.shape
  mesh = mesh.reshape([-1, mesh.shape[-3] * 3, 3])
  matrix = matrix.reshape([-1, 4, 4])
  w = 1 if vertices_are_points else 0
  mesh = transform_points_homogeneous(mesh, matrix, w=w)
  if vertices_are_points:
    mesh = mesh[..., :3] / mesh[..., 3:4]
  else:
    mesh = mesh[..., :3]

  return mesh.reshape(original_shape)


def transform_points(points: t.Tensor, matrix: t.Tensor) -> t.Tensor:
  """Transforms points.
  Args:
    points: The points to transform, `float32[B*, N, 3]`
    matrix: Transformation matrices, `float32[B*, 4, 4]`
  Result:
    The transformed points, `float32[B*, N, 3]`
  """
  result = transform_points_homogeneous(points, matrix, w=1)
  result = result[..., :3] / result[..., 3:4]
  return result


def chain(transforms: list[t.Tensor], reverse=True) -> t.Tensor:
  """Chains transformations expressed as matrices.
  Args:
    transforms: The list of transformations to chain
    reverse: The order in which transformations are applied. If true, the last
      transformation is applied first (which matches matrix multiplication
      order). False matches natural order, where the first transformation is
      applied first.
  Returns:
    Matrix combining all transformations.
  """
  assert transforms
  if not reverse:
    transforms = transforms[::-1]
  result = transforms[0]
  for transform in transforms[1:]:
    result = result @ transform
  return result


def gl_projection_matrix_from_intrinsics(  #
    width: t.Tensor, height: t.Tensor, fx: t.Tensor, fy: t.Tensor, cx: t.Tensor,
    cy: t.Tensor, znear: float = 0.001, zfar: float = 20.) -> t.Tensor:
  """Computes the camera projection matrix for rendering square images.
  Args:
    width: Image's `width`, `float32[B*]`.
    height: Image's `heigh`t,` float32[B*]`.
    fx: Camera's `fx`, `float32[B*]`.
    fy: Camera's `fy`, `float32[B*]`.
    cx: Camera's `cx`, `float32[B*]`.
    cy: Camera's `cy`, `float32[B*]`.
    znear: The near plane location.
    zfar: The far plane location.
  Returns:
    World to OpenGL's normalized device coordinates transformation matrices,
    `float32[B*, 4, 4]`.
  """

  z = t.zeros_like(t.as_tensor(fx))
  o = t.ones_like(z)
  zn = znear * o
  zf = zfar * o
  # yapf: disable
  result = [
      2 * fx / width, z, 2 * (cx / width) - 1, z,
      z, 2 * fy / height, 2 * (cy / height) - 1, z,
      z, z, (zf + zn) / (zf - zn), -2 * zn * zf / (zf - zn),
      z, z, o, z
  ]
  # yapf: enable
  result = t.stack([t.as_tensor(v, dtype=t.float32)
                    for v in result]).reshape((4, 4) + z.shape)

  result = result.permute(tuple(range(len(result.shape)))[2:] + (0, 1))
  return result


def quaternion_to_rotation_matrix(q: t.Tensor) -> t.Tensor:
  """Computes a rotation matrix from a quaternion.
  Args:
    q: Rotation quaternions, float32[B*, 4]
  Returns:
    Rotation matrices, float32[B, 4, 4]
  """
  q = t.as_tensor(q, dtype=t.float32)
  w, x, y, z = t.unbind(q, dim=-1)
  zz = t.zeros_like(z)
  oo = t.ones_like(z)
  s = 2.0 / (q * q).sum(dim=-1)
  # yapf: disable
  return t.stack([
      1 - s * (y ** 2 + z ** 2), s * (x * y - z * w), s * (x * z + y * w), zz,
      s * (x * y + z * w), 1 - s * (x ** 2 + z ** 2), s * (y * z - x * w), zz,
      s * (x * z - y * w), s * (y * z + x * w), 1 - s * (x ** 2 + y ** 2), zz,
      zz, zz, zz, oo
  ], dim=-1).reshape(q.shape[:-1] + (4, 4))
  # yapf: enable

	# Copyright 2023 Google LLC
	#
	# 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.
	#
	# Author: spopov@google.com (Stefan Popov)
	"""Functions to compute transformation matrices."""

	import torch as t
	from torch.nn import functional as F


	def scale(v: t.Tensor) -> t.Tensor:
	"""Computes homogeneous scale matrices from scale vectors.

	Args:
	v: Scale vectors, `float32[B*, N]`

	Returns:
	Scale matrices, `float32[B*, N+1, N+1]`
	"""
	v = t.as_tensor(v, dtype=t.float32)
	batch_dims = v.shape[:-1]
	v = v.reshape([-1, (v.shape[-1])])

	index_batch_flat = t.arange(v.shape[0], dtype=t.int64, device=v.device)
	index_diag = t.arange(v.shape[1], dtype=t.int64, device=v.device)
	index_batch, index_diag = t.meshgrid(index_batch_flat, index_diag,
	indexing="ij")
	index_batch = index_batch.reshape([-1])
	index_diag = index_diag.reshape([-1])

	result = v.new_zeros([v.shape[0], v.shape[1] + 1, v.shape[1] + 1])
	result[index_batch, index_diag, index_diag] = v.reshape([-1])
	result[index_batch_flat, v.shape[-1], v.shape[-1]] = 1
	result = result.reshape(batch_dims + result.shape[-2:])
	return result


	def translate(v: t.Tensor) -> t.Tensor:
	"""Computes a homogeneous translation matrices from translation vectors.

	Args:
	v: Translation vectors, `float32[B*, N]`

	Returns:
	Translation matrices, `float32[B*, N+1, N+1]`
	"""
	result = t.as_tensor(v, dtype=t.float32)
	dimensions = result.shape[-1]
	result = result[..., None, :].transpose(-1, -2)
	result = t.constant_pad_nd(result, [dimensions, 0, 0, 1])
	id_matrix = t.diag(result.new_ones([dimensions + 1]))
	id_matrix = id_matrix.expand_as(result)
	result = result + id_matrix
	return result


	def rotate(
	angle: t.Tensor,
	axis: t.Tensor,
	) -> t.Tensor:
	"""Computes a 3D rotation matrices from angle and axis inputs.

	The formula used in this function is explained here:
	https://en.wikipedia.org/wiki/Rotation_matrix#Conversion_from_and_to_axis–angle

	Args:
	angle: The rotation angles, `float32[B*]`
	axis: The rotation axes, `float32[B*, 3]`

	Returns:
	The rotation matrices, `float32[B*, 4, 4]`
	"""
	axis = t.as_tensor(axis, dtype=t.float32)
	angle = t.as_tensor(angle, dtype=t.float32)
	axis = F.normalize(axis, dim=-1)
	sin_axis = t.sin(angle)[..., None] * axis
	cos_angle = t.cos(angle)
	cos1_axis = (1.0 - cos_angle)[..., None] * axis
	_, axis_y, axis_z = t.unbind(axis, dim=-1)
	cos1_axis_x, cos1_axis_y, _ = t.unbind(cos1_axis, dim=-1)
	sin_axis_x, sin_axis_y, sin_axis_z = t.unbind(sin_axis, dim=-1)
	tmp = cos1_axis_x * axis_y
	m01 = tmp - sin_axis_z
	m10 = tmp + sin_axis_z
	tmp = cos1_axis_x * axis_z
	m02 = tmp + sin_axis_y
	m20 = tmp - sin_axis_y
	tmp = cos1_axis_y * axis_z
	m12 = tmp - sin_axis_x
	m21 = tmp + sin_axis_x
	zero = t.zeros_like(m01)
	one = t.ones_like(m01)
	diag = cos1_axis * axis + cos_angle[..., None]
	diag_x, diag_y, diag_z = t.unbind(diag, dim=-1)

	matrix = t.stack((diag_x, m01, m02, zero, m10, diag_y, m12, zero, m20, m21,
	diag_z, zero, zero, zero, zero, one), dim=-1)
	output_shape = axis.shape[:-1] + (4, 4)
	result = matrix.reshape(output_shape)
	return result


	def transform_points_homogeneous(points: t.Tensor, matrix: t.Tensor,
	w: float) -> t.Tensor:
	"""Transforms 3D points with a homogeneous matrix.

	Args:
	points: The points to transform, `float32[B*, N, 3]`
	matrix: The transformation matrices, `float32[B*, 4, 4]`
	w: The W value to add to the points to make them homogeneous. Should be 1
	for affine points and 0 for vectors.

	Returns:
	The transformed points in homogeneous space (with a 4th coordinate),
	`float32[B*, N, 4]`
	"""
	batch_dims = points.shape[:-2]
	# Fold all batch dimensions into a single one
	points = points.reshape([-1] + list(points.shape[-2:]))
	matrix = matrix.reshape([-1] + list(matrix.shape[-2:]))

	points = t.constant_pad_nd(points, [0, 1], value=w)
	result = t.einsum("bnm,bvm->bvn", matrix, points)
	result = result.reshape(batch_dims + result.shape[-2:])

	return result


	def transform_mesh(mesh: t.Tensor, matrix: t.Tensor,
	vertices_are_points=True) -> t.Tensor:
	"""Transforms a single 3D mesh.

	Args:
	mesh: The mesh's triangle vertices, `float32[B*, N, 3, 3]`
	matrix: The transformation matrix, `float32[B*, 4, 4]`
	vertices_are_points: Whether to interpret the vertices as affine points
	or vectors.

	Returns:
	The transformed mesh, `float32[B*, N, 3, 3]`
	"""
	original_shape = mesh.shape
	mesh = mesh.reshape([-1, mesh.shape[-3] * 3, 3])
	matrix = matrix.reshape([-1, 4, 4])
	w = 1 if vertices_are_points else 0
	mesh = transform_points_homogeneous(mesh, matrix, w=w)
	if vertices_are_points:
	mesh = mesh[..., :3] / mesh[..., 3:4]
	else:
	mesh = mesh[..., :3]

	return mesh.reshape(original_shape)


	def transform_points(points: t.Tensor, matrix: t.Tensor) -> t.Tensor:
	"""Transforms points.
	Args:
	points: The points to transform, `float32[B*, N, 3]`
	matrix: Transformation matrices, `float32[B*, 4, 4]`
	Result:
	The transformed points, `float32[B*, N, 3]`
	"""
	result = transform_points_homogeneous(points, matrix, w=1)
	result = result[..., :3] / result[..., 3:4]
	return result


	def chain(transforms: list[t.Tensor], reverse=True) -> t.Tensor:
	"""Chains transformations expressed as matrices.

	Args:
	transforms: The list of transformations to chain
	reverse: The order in which transformations are applied. If true, the last
	transformation is applied first (which matches matrix multiplication
	order). False matches natural order, where the first transformation is
	applied first.

	Returns:
	Matrix combining all transformations.

	"""
	assert transforms
	if not reverse:
	transforms = transforms[::-1]
	result = transforms[0]
	for transform in transforms[1:]:
	result = result @ transform
	return result


	def gl_projection_matrix_from_intrinsics( #
	width: t.Tensor, height: t.Tensor, fx: t.Tensor, fy: t.Tensor, cx: t.Tensor,
	cy: t.Tensor, znear: float = 0.001, zfar: float = 20.) -> t.Tensor:
	"""Computes the camera projection matrix for rendering square images.

	Args:
	width: Image's `width`, `float32[B*]`.
	height: Image's `heigh`t,` float32[B*]`.
	fx: Camera's `fx`, `float32[B*]`.
	fy: Camera's `fy`, `float32[B*]`.
	cx: Camera's `cx`, `float32[B*]`.
	cy: Camera's `cy`, `float32[B*]`.
	znear: The near plane location.
	zfar: The far plane location.

	Returns:
	World to OpenGL's normalized device coordinates transformation matrices,
	`float32[B*, 4, 4]`.
	"""

	z = t.zeros_like(t.as_tensor(fx))
	o = t.ones_like(z)
	zn = znear * o
	zf = zfar * o
	# yapf: disable
	result = [
	2 * fx / width, z, 2 * (cx / width) - 1, z,
	z, 2 * fy / height, 2 * (cy / height) - 1, z,
	z, z, (zf + zn) / (zf - zn), -2 * zn * zf / (zf - zn),
	z, z, o, z
	]
	# yapf: enable
	result = t.stack([t.as_tensor(v, dtype=t.float32)
	for v in result]).reshape((4, 4) + z.shape)

	result = result.permute(tuple(range(len(result.shape)))[2:] + (0, 1))
	return result


	def quaternion_to_rotation_matrix(q: t.Tensor) -> t.Tensor:
	"""Computes a rotation matrix from a quaternion.

	Args:
	q: Rotation quaternions, float32[B*, 4]

	Returns:
	Rotation matrices, float32[B, 4, 4]

	"""
	q = t.as_tensor(q, dtype=t.float32)
	w, x, y, z = t.unbind(q, dim=-1)
	zz = t.zeros_like(z)
	oo = t.ones_like(z)
	s = 2.0 / (q * q).sum(dim=-1)
	# yapf: disable
	return t.stack([
	1 - s * (y 2 + z 2), s * (x * y - z * w), s * (x * z + y * w), zz,
	s * (x * y + z * w), 1 - s * (x 2 + z 2), s * (y * z - x * w), zz,
	s * (x * z - y * w), s * (y * z + x * w), 1 - s * (x 2 + y 2), zz,
	zz, zz, zz, oo
	], dim=-1).reshape(q.shape[:-1] + (4, 4))
	# yapf: enable