code: def get_projective_transform(
      center: Tensor, angles: Tensor, scales: Tensor
  ) -> Tensor:
      r"""Calculate the projection matrix for a 3D rotation.
  
      .. warning::
          This API signature it is experimental and might suffer some changes in the future.
  
      The function computes the projection matrix given the center and angles per axis.
  
      Args:
          center: center of the rotation (x,y,z) in the source with shape :math:`(B, 3)`.
          angles: axis angle vector containing the rotation angles in degrees in the form
              of (rx, ry, rz) with shape :math:`(B, 3)`. Internally it calls Rodrigues to compute
              the rotation matrix from axis-angle.
          scales: scale factor for x-y-z-directions with shape :math:`(B, 3)`.
  
      Returns:
          the projection matrix of 3D rotation with shape :math:`(B, 3, 4)`.
  
      .. note::
          This function is often used in conjunction with :func:`warp_affine3d`.
      """
      if not (len(center.shape) == 2 and center.shape[-1] == 3):
          raise AssertionError(center.shape)
      if not (len(angles.shape) == 2 and angles.shape[-1] == 3):
          raise AssertionError(angles.shape)
      if center.device != angles.device:
          raise AssertionError(center.device, angles.device)
      if center.dtype != angles.dtype:
          raise AssertionError(center.dtype, angles.dtype)
  
      # create rotation matrix
      axis_angle_rad: Tensor = deg2rad(angles)
      rmat: Tensor = axis_angle_to_rotation_matrix(
          axis_angle_rad
      )  # Bx3x3
      scaling_matrix: Tensor = eye_like(3, rmat)
      scaling_matrix = scaling_matrix * scales.unsqueeze(dim=1)
      rmat = rmat @ scaling_matrix.to(rmat)
  
      # define matrix to move forth and back to origin
      from_origin_mat = eye_like(4, rmat, shared_memory=False)  # Bx4x4
      from_origin_mat[..., :3, -1] += center
  
      to_origin_mat = from_origin_mat.clone()
      to_origin_mat = _torch_inverse_cast(from_origin_mat)
  
      # append translation with zeros
      proj_mat = projection_from_Rt(
          rmat, torch.zeros_like(center)[..., None]
      )  # Bx3x4
  
      # chain 4x4 transforms
      proj_mat = convert_affinematrix_to_homography3d(proj_mat)  # Bx4x4
      proj_mat = from_origin_mat @ proj_mat @ to_origin_mat
  
      return proj_mat[..., :3, :]
  
imports: from __future__ import annotations
  from typing import Optional
  import torch
  import torch.nn.functional
  from kornia.core import Tensor, concatenate, ones, ones_like, stack, tan, tensor, zeros
  from kornia.core.check import KORNIA_CHECK, KORNIA_CHECK_SHAPE
  from kornia.geometry.conversions import angle_to_rotation_matrix, axis_angle_to_rotation_matrix, convert_affinematrix_to_homography, convert_affinematrix_to_homography3d, deg2rad, normalize_homography, normalize_homography3d, normalize_pixel_coordinates
  from kornia.geometry.linalg import transform_points
  from kornia.utils import create_meshgrid, create_meshgrid3d, eye_like
  from kornia.utils.helpers import _torch_inverse_cast, _torch_solve_cast
label_desc: Use image node_id 18 for calling a global function with example usage: get_projective_transform(center, angles, scales) and returns: proj_mat