class_docstr: Augmentation defines (often random) policies/strategies to generate :class:`Transform`
  from data. It is often used for pre-processing of input data.
  
  A "policy" that generates a :class:`Transform` may, in the most general case,
  need arbitrary information from input data in order to determine what transforms
  to apply. Therefore, each :class:`Augmentation` instance defines the arguments
  needed by its :meth:`get_transform` method. When called with the positional arguments,
  the :meth:`get_transform` method executes the policy.
  
  Note that :class:`Augmentation` defines the policies to create a :class:`Transform`,
  but not how to execute the actual transform operations to those data.
  Its :meth:`__call__` method will use :meth:`AugInput.transform` to execute the transform.
  
  The returned `Transform` object is meant to describe deterministic transformation, which means
  it can be re-applied on associated data, e.g. the geometry of an image and its segmentation
  masks need to be transformed together.
  (If such re-application is not needed, then determinism is not a crucial requirement.)
docstr: Augment the given `aug_input` **in-place**, and return the transform that's used.
  
  This method will be called to apply the augmentation. In most augmentation, it
  is enough to use the default implementation, which calls :meth:`get_transform`
  using the inputs. But a subclass can overwrite it to have more complicated logic.
  
  Args:
      aug_input (AugInput): an object that has attributes needed by this augmentation
          (defined by ``self.get_transform``). Its ``transform`` method will be called
          to in-place transform it.
  
  Returns:
      Transform: the transform that is applied on the input.
docstr_tok: ["Augment","the","given","`","aug_input","`","*","*","in-place","*","*",",","and","return","the","transform","that","'s","used",".","This","method","will","be","called","to","apply","the","augmentation",".","In","most","augmentation",",","it","is","enough","to","use","the","default","implementation",",","which","calls",":","meth",":","`","get_transform","`","using","the","inputs",".","But","a","subclass","can","overwrite","it","to","have","more","complicated","logic",".","Args",":","aug_input","(","AugInput",")",":","an","object","that","has","attributes","needed","by","this","augmentation","(","defined","by","``","self.get_transform","``",")",".","Its","``","transform","``","method","will","be","called","to","in-place","transform","it",".","Returns",":","Transform",":","the","transform","that","is","applied","on","the","input","."]
code: def __call__(self, aug_input) -> Transform:
      """
      Augment the given `aug_input` **in-place**, and return the transform that's used.
  
      This method will be called to apply the augmentation. In most augmentation, it
      is enough to use the default implementation, which calls :meth:`get_transform`
      using the inputs. But a subclass can overwrite it to have more complicated logic.
  
      Args:
          aug_input (AugInput): an object that has attributes needed by this augmentation
              (defined by ``self.get_transform``). Its ``transform`` method will be called
              to in-place transform it.
  
      Returns:
          Transform: the transform that is applied on the input.
      """
      args = _get_aug_input_args(self, aug_input)
      tfm = self.get_transform(*args)
      assert isinstance(tfm, (Transform, TransformList)), (
          f"{type(self)}.get_transform must return an instance of Transform! "
          f"Got {type(tfm)} instead."
      )
      aug_input.transform(tfm)
      return tfm
  
imports: import inspect
  import numpy
  import pprint
  from typing import Any, List, Optional, Tuple, Union
  from fvcore.transforms.transform import Transform, TransformList
label_desc: Use image node_id 3 for calling the Augmentation obj's underlying member method code with example usage: obj.__call__(aug_input) and returns: tfm