code: def model_to_eye(
      point_model_space: type_alias.TensorLike,
      camera_position: type_alias.TensorLike,
      look_at_point: type_alias.TensorLike,
      up_vector: type_alias.TensorLike,
      name: str = "model_to_eye",
  ) -> tf.Tensor:
      """Transforms points from model to eye coordinates.
  
      Note:
        In the following, A1 to An are optional batch dimensions which must be
        broadcast compatible.
  
      Args:
        point_model_space: A tensor of shape `[A1, ..., An, 3]`, where the last
          dimension represents the 3D points in model space.
        camera_position: A tensor of shape `[A1, ..., An, 3]`, where the last
          dimension represents the 3D position of the camera.
        look_at_point: A tensor of shape `[A1, ..., An, 3]`, with the last dimension
          storing the position where the camera is looking at.
        up_vector: A tensor of shape `[A1, ..., An, 3]`, where the last dimension
          defines the up vector of the camera.
        name: A name for this op. Defaults to "model_to_eye".
  
      Raises:
        ValueError: if the all the inputs are not of the same shape, or if any input
        of of an unsupported shape.
  
      Returns:
        A tensor of shape `[A1, ..., An, 3]`, containing `point_model_space` in eye
        coordinates.
      """
      with tf.name_scope(name):
          point_model_space = tf.convert_to_tensor(
              value=point_model_space
          )
          camera_position = tf.convert_to_tensor(value=camera_position)
          look_at_point = tf.convert_to_tensor(value=look_at_point)
          up_vector = tf.convert_to_tensor(value=up_vector)
  
          shape.check_static(
              tensor=point_model_space,
              tensor_name="point_model_space",
              has_dim_equals=(-1, 3),
          )
          shape.compare_batch_dimensions(
              tensors=(point_model_space, camera_position),
              last_axes=-2,
              tensor_names=("point_model_space", "camera_position"),
              broadcast_compatible=True,
          )
  
          model_to_eye_matrix = look_at.right_handed(
              camera_position, look_at_point, up_vector
          )
          batch_shape = tf.shape(input=point_model_space)[:-1]
          one = tf.ones(
              shape=tf.concat((batch_shape, (1,)), axis=-1),
              dtype=point_model_space.dtype,
          )
          point_model_space = tf.concat(
              (point_model_space, one), axis=-1
          )
          point_model_space = tf.expand_dims(point_model_space, axis=-1)
          res = tf.squeeze(
              tf.matmul(model_to_eye_matrix, point_model_space), axis=-1
          )
          return res[..., :-1]
  
file_path: graphics/tensorflow_graphics/rendering/opengl/math.py
imports: from typing import Tuple
  import tensorflow
  from tensorflow_graphics.geometry.transformation import look_at
  from tensorflow_graphics.math.interpolation import weighted
  from tensorflow_graphics.rendering.camera import perspective
  from tensorflow_graphics.util import asserts
  from tensorflow_graphics.util import export_api
  from tensorflow_graphics.util import shape
  from tensorflow_graphics.util import type_alias
label_desc: Use image node_id 1 for calling a global function with example usage: model_to_eye(point_model_space, camera_position, look_at_point, up_vector, name) and returns: res