code: def compute_correspond_epilines(
      points: Tensor, F_mat: Tensor
  ) -> Tensor:
      r"""Compute the corresponding epipolar line for a given set of points.
  
      Args:
          points: tensor containing the set of points to project in the shape of :math:`(*, N, 2)` or :math:`(*, N, 3)`.
          F_mat: the fundamental to use for projection the points in the shape of :math:`(*, 3, 3)`.
  
      Returns:
          a tensor with shape :math:`(*, N, 3)` containing a vector of the epipolar
          lines corresponding to the points to the other image. Each line is described as
          :math:`ax + by + c = 0` and encoding the vectors as :math:`(a, b, c)`.
      """
      KORNIA_CHECK_SHAPE(points, ["*", "N", "DIM"])
      if points.shape[-1] == 2:
          points_h: Tensor = convert_points_to_homogeneous(points)
      elif points.shape[-1] == 3:
          points_h = points
      else:
          raise AssertionError(points.shape)
      KORNIA_CHECK_SHAPE(F_mat, ["*", "3", "3"])
      # project points and retrieve lines components
      points_h = torch.transpose(points_h, dim0=-2, dim1=-1)
      a, b, c = torch.chunk(F_mat @ points_h, dim=-2, chunks=3)
  
      # compute normal and compose equation line
      nu: Tensor = a * a + b * b
      nu = where(nu > 0.0, 1.0 / torch.sqrt(nu), torch.ones_like(nu))
  
      line = torch.cat([a * nu, b * nu, c * nu], dim=-2)  # *x3xN
      return torch.transpose(line, dim0=-2, dim1=-1)
  
file_path: kornia/kornia/geometry/epipolar/fundamental.py
imports: from typing import Literal, Optional, Tuple
  import torch
  from kornia.core import Tensor, concatenate, ones_like, stack, where, zeros
  from kornia.core.check import KORNIA_CHECK_SHAPE
  from kornia.geometry.conversions import convert_points_from_homogeneous, convert_points_to_homogeneous
  from kornia.geometry.linalg import transform_points
  from kornia.geometry.solvers import solve_cubic
  from kornia.utils.helpers import _torch_svd_cast
label_desc: Use image node_id 6 for calling a global function with example usage: compute_correspond_epilines(points, F_mat) and returns: torch