class_docstr: Get parameters for ```3d affine``` transformation random affine transform.
  
  Args:
      degrees: Range of yaw (x-axis), pitch (y-axis), roll (z-axis) to select from.
          If degrees is a number, then yaw, pitch, roll will be generated from the range of (-degrees, +degrees).
          If degrees is a tuple of (min, max), then yaw, pitch, roll will be generated from the range of (min, max).
          If degrees is a list of floats [a, b, c], then yaw, pitch, roll will be generated from (-a, a), (-b, b)
          and (-c, c).
          If degrees is a list of tuple ((a, b), (m, n), (x, y)), then yaw, pitch, roll will be generated from
          (a, b), (m, n) and (x, y).
          Set to 0 to deactivate rotations.
      translate: tuple of maximum absolute fraction for horizontal, vertical and
          depthical translations (dx,dy,dz). For example translate=(a, b, c), then
          horizontal shift will be randomly sampled in the range -img_width * a < dx < img_width * a
          vertical shift will be randomly sampled in the range -img_height * b < dy < img_height * b.
          depthical shift will be randomly sampled in the range -img_depth * c < dz < img_depth * c.
          Will not translate by default.
      scale: scaling factor interval.
          If (a, b) represents isotropic scaling, the scale is randomly sampled from the range a <= scale <= b.
          If ((a, b), (c, d), (e, f)), the scale is randomly sampled from the range a <= scale_x <= b,
          c <= scale_y <= d, e <= scale_z <= f. Will keep original scale by default.
      shears: Range of degrees to select from.
          If shear is a number, a shear to the 6 facets in the range (-shear, +shear) will be applied.
          If shear is a tuple of 2 values, a shear to the 6 facets in the range (shear[0], shear[1]) will be applied.
          If shear is a tuple of 6 values, a shear to the i-th facet in the range (-shear[i], shear[i])
          will be applied.
          If shear is a tuple of 6 tuples, a shear to the i-th facet in the range (-shear[i, 0], shear[i, 1])
          will be applied.
  
  Returns:
      A dict of parameters to be passed for transformation.
          - translations (torch.Tensor): element-wise translations with a shape of (B, 3).
          - center (torch.Tensor): element-wise center with a shape of (B, 3).
          - scale (torch.Tensor): element-wise scales with a shape of (B, 3).
          - angle (torch.Tensor): element-wise rotation angles with a shape of (B, 3).
          - sxy (torch.Tensor): element-wise x-y-facet shears with a shape of (B,).
          - sxz (torch.Tensor): element-wise x-z-facet shears with a shape of (B,).
          - syx (torch.Tensor): element-wise y-x-facet shears with a shape of (B,).
          - syz (torch.Tensor): element-wise y-z-facet shears with a shape of (B,).
          - szx (torch.Tensor): element-wise z-x-facet shears with a shape of (B,).
          - szy (torch.Tensor): element-wise z-y-facet shears with a shape of (B,).
  
  Note:
      The generated random numbers are not reproducible across different devices and dtypes. By default,
      the parameters will be generated on CPU in float32. This can be changed by calling
      ``self.set_rng_device_and_dtype(device="cuda", dtype=torch.float64)``.
code: def __init__(
      self,
      degrees: Union[
          torch.Tensor,
          float,
          Tuple[float, float],
          Tuple[float, float, float],
          Tuple[
              Tuple[float, float],
              Tuple[float, float],
              Tuple[float, float],
          ],
      ],
      translate: Optional[
          Union[torch.Tensor, Tuple[float, float, float]]
      ] = None,
      scale: Optional[
          Union[
              torch.Tensor,
              Tuple[float, float],
              Tuple[
                  Tuple[float, float],
                  Tuple[float, float],
                  Tuple[float, float],
              ],
          ]
      ] = None,
      shears: Union[
          None,
          torch.Tensor,
          float,
          Tuple[float, float],
          Tuple[float, float, float, float, float, float],
          Tuple[
              Tuple[float, float],
              Tuple[float, float],
              Tuple[float, float],
              Tuple[float, float],
              Tuple[float, float],
              Tuple[float, float],
          ],
      ] = None,
  ) -> None:
      super().__init__()
      self.degrees = degrees
      self.shears = shears
      self.translate = translate
      self.scale = scale
  
file_path: kornia/kornia/augmentation/random_generator/_3d/affine.py
imports: from typing import Dict, Optional, Tuple, Union
  import torch
  from kornia.augmentation.random_generator.base import RandomGeneratorBase, UniformDistribution
  from kornia.augmentation.utils import _adapted_rsampling, _singular_range_check, _tuple_range_reader
  from kornia.utils.helpers import _extract_device_dtype
label_desc: Use image node_id 1 to create a new AffineGenerator3D object from inherited base classes: RandomGeneratorBase with example: obj = AffineGenerator3D(degrees, translate, scale, shears)