code: def get_barycentric_coordinates(
      triangle_vertices: type_alias.TensorLike,
      pixels: type_alias.TensorLike,
      name: str = "rasterizer_get_barycentric_coordinates",
  ) -> type_alias.TensorLike:
      """Computes the barycentric coordinates of pixels for 2D triangles.
  
      Barycentric coordinates of a point `p` are represented as coefficients
      $(w_1, w_2, w_3)$ corresponding to the masses placed at the vertices of a
      reference triangle if `p` is the center of mass. Barycentric coordinates are
      normalized so that $w_1 + w_2 + w_3 = 1$. These coordinates play an essential
      role in computing the pixel attributes (e.g. depth, color, normals, and
      texture coordinates) of a point lying on the surface of a triangle. The point
      `p` is inside the triangle if all of its barycentric coordinates are positive.
  
      Note:
        In the following, A1 to An are optional batch dimensions.
  
      Args:
        triangle_vertices: A tensor of shape `[A1, ..., An, 3, 2]`, where the last
          two dimensions represents the `x` and `y` coordinates for each vertex of a
          2D triangle.
        pixels: A tensor of shape `[A1, ..., An, N, 2]`, where `N` represents the
          number of pixels, and the last dimension represents the `x` and `y`
          coordinates of each pixel.
        name: A name for this op that defaults to
          "rasterizer_get_barycentric_coordinates".
  
      Returns:
        barycentric_coordinates: A float tensor of shape `[A1, ..., An, N, 3]`,
          representing the barycentric coordinates.
        valid: A boolean tensor of shape `[A1, ..., An, N], which is `True` where
          pixels are inside the triangle, and `False` otherwise.
      """
      with tf.name_scope(name):
          triangle_vertices = tf.convert_to_tensor(
              value=triangle_vertices
          )
          pixels = tf.convert_to_tensor(value=pixels)
  
          shape.check_static(
              tensor=triangle_vertices,
              tensor_name="triangle_vertices",
              has_dim_equals=((-1, 2), (-2, 3)),
          )
          shape.check_static(
              tensor=pixels,
              tensor_name="pixels",
              has_dim_equals=(-1, 2),
          )
          shape.compare_batch_dimensions(
              tensors=(triangle_vertices, pixels),
              last_axes=(-3, -3),
              broadcast_compatible=True,
          )
  
          vertex_1, vertex_2, vertex_3 = tf.unstack(
              tf.expand_dims(triangle_vertices, axis=-3), axis=-2
          )
          vertex_x1, vertex_y1 = tf.unstack(vertex_1, axis=-1)
          vertex_x2, vertex_y2 = tf.unstack(vertex_2, axis=-1)
          vertex_x3, vertex_y3 = tf.unstack(vertex_3, axis=-1)
          pixels_x, pixels_y = tf.unstack(pixels, axis=-1)
  
          x1_minus_x3 = vertex_x1 - vertex_x3
          x3_minus_x2 = vertex_x3 - vertex_x2
          y3_minus_y1 = vertex_y3 - vertex_y1
          y2_minus_y3 = vertex_y2 - vertex_y3
          x_minus_x3 = pixels_x - vertex_x3
          y_minus_y3 = pixels_y - vertex_y3
  
          determinant = (
              y2_minus_y3 * x1_minus_x3 - x3_minus_x2 * y3_minus_y1
          )
          coordinate_1 = (
              y2_minus_y3 * x_minus_x3 + x3_minus_x2 * y_minus_y3
          )
          coordinate_1 = safe_ops.safe_signed_div(
              coordinate_1, determinant
          )
          coordinate_2 = (
              y3_minus_y1 * x_minus_x3 + x1_minus_x3 * y_minus_y3
          )
          coordinate_2 = safe_ops.safe_signed_div(
              coordinate_2, determinant
          )
          coordinate_3 = 1.0 - (coordinate_1 + coordinate_2)
  
          barycentric_coordinates = tf.stack(
              (coordinate_1, coordinate_2, coordinate_3), axis=-1
          )
          valid = tf.logical_and(
              tf.logical_and(coordinate_1 >= 0.0, coordinate_2 >= 0.0),
              coordinate_3 >= 0.0,
          )
          return barycentric_coordinates, valid
  
file_path: graphics/tensorflow_graphics/math/interpolation/weighted.py
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import tensorflow
  from tensorflow_graphics.math import vector
  from tensorflow_graphics.util import asserts
  from tensorflow_graphics.util import export_api
  from tensorflow_graphics.util import safe_ops
  from tensorflow_graphics.util import shape
  from tensorflow_graphics.util import type_alias
label_desc: Use image node_id 2 for calling a global function with example usage: get_barycentric_coordinates(triangle_vertices, pixels, name) and returns: barycentric_coordinates,  valid