class_docstr: Applies pre-processing and data augmentations to the input and returns the transformed output.
  
  Output could be either numpy ndarray or torch tensor.
  When `PreProcessor` class is used for training, the output would be `torch.Tensor`.
  For the inference it returns a numpy array.
  
  Args:
      config (str | A.Compose | None, optional): Transformation configurations.
          When it is ``None``, ``PreProcessor`` only applies resizing. When it is ``str``
          it loads the config via ``albumentations`` deserialisation methos . Defaults to None.
      image_size (int | tuple | None, optional): When there is no config,
      ``image_size`` resizes the image. Defaults to None.
      to_tensor (bool, optional): Boolean to check whether the augmented image is transformed
          into a tensor or not. Defaults to True.
  
  Examples:
      >>> import skimage
      >>> image = skimage.data.astronaut()
  
      >>> pre_processor = PreProcessor(image_size=256, to_tensor=False)
      >>> output = pre_processor(image=image)
      >>> output["image"].shape
      (256, 256, 3)
  
      >>> pre_processor = PreProcessor(image_size=256, to_tensor=True)
      >>> output = pre_processor(image=image)
      >>> output["image"].shape
      torch.Size([3, 256, 256])
  
  
      Transforms could be read from albumentations Compose object.
          >>> import albumentations as A
          >>> from albumentations.pytorch import ToTensorV2
          >>> config = A.Compose([A.Resize(512, 512), ToTensorV2()])
          >>> pre_processor = PreProcessor(config=config, to_tensor=False)
          >>> output = pre_processor(image=image)
          >>> output["image"].shape
          (512, 512, 3)
          >>> type(output["image"])
          numpy.ndarray
  
      Transforms could be deserialized from a yaml file.
          >>> transforms = A.Compose([A.Resize(1024, 1024), ToTensorV2()])
          >>> A.save(transforms, "/tmp/transforms.yaml", data_format="yaml")
          >>> pre_processor = PreProcessor(config="/tmp/transforms.yaml")
          >>> output = pre_processor(image=image)
          >>> output["image"].shape
          torch.Size([3, 1024, 1024])
docstr: Return transformed arguments.
docstr_tok: ["Return","transformed","arguments","."]
code: def __call__(self, *args, **kwargs) -> dict[str, Any]:
      """Return transformed arguments."""
      return self.transforms(*args, **kwargs)
  
file_path: anomalib/src/anomalib/pre_processing/pre_process.py
imports: from __future__ import annotations
  import logging
  import warnings
  from typing import Any
  import albumentations
  from albumentations.pytorch import ToTensorV2
label_desc: Use image node_id 2 for calling the PreProcessor obj's underlying member method code with example usage: obj.__call__() and returns: self