code: def triangulate(
      startpoints, endpoints, weights, name="ray_triangulate"
  ):
      """Triangulates 3d points by miminizing the sum of squared distances to rays.
  
      The rays are defined by their start points and endpoints. At least two rays
      are required to triangulate any given point. Contrary to the standard
      reprojection-error metric, the sum of squared distances to rays can be
      minimized in a closed form.
  
      Note:
        In the following, A1 to An are optional batch dimensions.
  
      Args:
        startpoints: A tensor of ray start points with shape `[A1, ..., An, V, 3]`,
          the number of rays V around which the solution points live should be
          greater or equal to 2, otherwise triangulation is impossible.
        endpoints: A tensor of ray endpoints with shape `[A1, ..., An, V, 3]`, the
          number of rays V around which the solution points live should be greater
          or equal to 2, otherwise triangulation is impossible. The `endpoints`
          tensor should have the same shape as the `startpoints` tensor.
        weights: A tensor of ray weights (certainties) with shape `[A1, ..., An,
          V]`. Weights should have all positive entries. Weight should have at least
          two non-zero entries for each point (at least two rays should have
          certainties > 0).
        name: A name for this op. The default value of None means "ray_triangulate".
  
      Returns:
        A tensor of triangulated points with shape `[A1, ..., An, 3]`.
  
      Raises:
        ValueError: If the shape of the arguments is not supported.
      """
      with tf.name_scope(name):
          startpoints = tf.convert_to_tensor(value=startpoints)
          endpoints = tf.convert_to_tensor(value=endpoints)
          weights = tf.convert_to_tensor(value=weights)
  
          shape.check_static(
              tensor=startpoints,
              tensor_name="startpoints",
              has_rank_greater_than=1,
              has_dim_equals=(-1, 3),
              has_dim_greater_than=(-2, 1),
          )
          shape.check_static(
              tensor=endpoints,
              tensor_name="endpoints",
              has_rank_greater_than=1,
              has_dim_equals=(-1, 3),
              has_dim_greater_than=(-2, 1),
          )
          shape.compare_batch_dimensions(
              tensors=(startpoints, endpoints, weights),
              last_axes=(-2, -2, -1),
              broadcast_compatible=False,
          )
          weights = asserts.assert_all_above(
              weights, 0.0, open_bound=False
          )
          weights = asserts.assert_at_least_k_non_zero_entries(
              weights, k=2
          )
  
          left_hand_side_list = []
          right_hand_side_list = []
          # TODO(b/130892100): Replace the inefficient for loop and add comments here.
          for ray_id in range(weights.shape[-1]):
              weights_single_ray = weights[..., ray_id]
              startpoints_single_ray = startpoints[..., ray_id, :]
              endpoints_singleview = endpoints[..., ray_id, :]
              ray = endpoints_singleview - startpoints_single_ray
              ray = tf.nn.l2_normalize(ray, axis=-1)
              ray_x, ray_y, ray_z = tf.unstack(ray, axis=-1)
              zeros = tf.zeros_like(ray_x)
              cross_product_matrix = tf.stack(
                  (
                      zeros,
                      -ray_z,
                      ray_y,
                      ray_z,
                      zeros,
                      -ray_x,
                      -ray_y,
                      ray_x,
                      zeros,
                  ),
                  axis=-1,
              )
              cross_product_matrix_shape = tf.concat(
                  (tf.shape(input=cross_product_matrix)[:-1], (3, 3)),
                  axis=-1,
              )
              cross_product_matrix = tf.reshape(
                  cross_product_matrix, shape=cross_product_matrix_shape
              )
              weights_single_ray = tf.expand_dims(
                  weights_single_ray, axis=-1
              )
              weights_single_ray = tf.expand_dims(
                  weights_single_ray, axis=-1
              )
              left_hand_side = weights_single_ray * cross_product_matrix
              left_hand_side_list.append(left_hand_side)
              dot_product = tf.matmul(
                  cross_product_matrix,
                  tf.expand_dims(startpoints_single_ray, axis=-1),
              )
              right_hand_side = weights_single_ray * dot_product
              right_hand_side_list.append(right_hand_side)
          left_hand_side_multi_rays = tf.concat(
              left_hand_side_list, axis=-2
          )
          right_hand_side_multi_rays = tf.concat(
              right_hand_side_list, axis=-2
          )
          points = tf.linalg.lstsq(
              left_hand_side_multi_rays, right_hand_side_multi_rays
          )
          points = tf.squeeze(points, axis=-1)
  
          return points
  
file_path: graphics/tensorflow_graphics/geometry/representation/ray.py
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from typing import Tuple, Union
  from six.moves import range
  import tensorflow
  from tensorflow_graphics.math import sampling
  from tensorflow_graphics.math import vector
  from tensorflow_graphics.util import asserts
  from tensorflow_graphics.util import export_api
  from tensorflow_graphics.util import shape
  from tensorflow_graphics.util.type_alias import TensorLike
label_desc: Use image node_id 5 for calling a global function with example usage: triangulate(startpoints, endpoints, weights, name) and returns: points