text: from __future__ import division
  import numpy as np
  import torch
  from PIL import Image
  import collections
  import random
  from PIL import Image, ImageOps, ImageEnhance
  try:
      import accimage
  except ImportError:
      accimage = None
  import types
  
  
  def _is_pil_image(img):
      if accimage is not None:
          return isinstance(img, (Image.Image, accimage.Image))
      else:
          return isinstance(img, Image.Image)
  
  
  def adjust_brightness(img, brightness_factor):
      """Adjust brightness of an Image.
      Args:
          img (PIL.Image): PIL Image to be adjusted.
          brightness_factor (float):  How much to adjust the brightness. Can be
              any non negative number. 0 gives a black image, 1 gives the
              original image while 2 increases the brightness by a factor of 2.
      Returns:
          PIL.Image: Brightness adjusted image.
      """
      if not _is_pil_image(img):
          raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
  
      enhancer = ImageEnhance.Brightness(img)
      img = enhancer.enhance(brightness_factor)
      return img
  
  
  def adjust_contrast(img, contrast_factor):
      """Adjust contrast of an Image.
      Args:
          img (PIL.Image): PIL Image to be adjusted.
          contrast_factor (float): How much to adjust the contrast. Can be any
              non negative number. 0 gives a solid gray image, 1 gives the
              original image while 2 increases the contrast by a factor of 2.
      Returns:
          PIL.Image: Contrast adjusted image.
      """
      if not _is_pil_image(img):
          raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
  
      enhancer = ImageEnhance.Contrast(img)
      img = enhancer.enhance(contrast_factor)
      return img
  
  
  def adjust_saturation(img, saturation_factor):
      """Adjust color saturation of an image.
      Args:
          img (PIL.Image): PIL Image to be adjusted.
          saturation_factor (float):  How much to adjust the saturation. 0 will
              give a black and white image, 1 will give the original image while
              2 will enhance the saturation by a factor of 2.
      Returns:
          PIL.Image: Saturation adjusted image.
      """
      if not _is_pil_image(img):
          raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
  
      enhancer = ImageEnhance.Color(img)
      img = enhancer.enhance(saturation_factor)
      return img
  
  
  def adjust_hue(img, hue_factor):
      """Adjust hue of an image.
      The image hue is adjusted by converting the image to HSV and
      cyclically shifting the intensities in the hue channel (H).
      The image is then converted back to original image mode.
      `hue_factor` is the amount of shift in H channel and must be in the
      interval `[-0.5, 0.5]`.
      See https://en.wikipedia.org/wiki/Hue for more details on Hue.
      Args:
          img (PIL.Image): PIL Image to be adjusted.
          hue_factor (float):  How much to shift the hue channel. Should be in
              [-0.5, 0.5]. 0.5 and -0.5 give complete reversal of hue channel in
              HSV space in positive and negative direction respectively.
              0 means no shift. Therefore, both -0.5 and 0.5 will give an image
              with complementary colors while 0 gives the original image.
      Returns:
          PIL.Image: Hue adjusted image.
      """
      if not(-0.5 <= hue_factor <= 0.5):
          raise ValueError(
              'hue_factor is not in [-0.5, 0.5].'.format(hue_factor))
  
      if not _is_pil_image(img):
          raise TypeError('img should be PIL Image. Got {}'.format(type(img)))
  
      input_mode = img.mode
      if input_mode in {'L', '1', 'I', 'F'}:
          return img
  
      h, s, v = img.convert('HSV').split()
  
      np_h = np.array(h, dtype=np.uint8)
      # uint8 addition take cares of rotation across boundaries
      with np.errstate(over='ignore'):
          np_h += np.uint8(hue_factor * 255)
      h = Image.fromarray(np_h, 'L')
  
      img = Image.merge('HSV', (h, s, v)).convert(input_mode)
      return img
  
  
  class Lambda(object):
      """Apply a user-defined lambda as a transform.
      Args:
          lambd (function): Lambda/function to be used for transform.
      """
  
      def __init__(self, lambd):
          assert isinstance(lambd, types.LambdaType)
          self.lambd = lambd
  
      def __call__(self, img):
          return self.lambd(img)
  
  
  class Compose(object):
      """Composes several transforms together.
      Args:
          transforms (list of ``Transform`` objects): list of transforms to compose.
      Example:
          >>> transforms.Compose([
          >>>     transforms.CenterCrop(10),
          >>>     transforms.ToTensor(),
          >>> ])
      """
  
      def __init__(self, transforms):
          self.transforms = transforms
  
      def __call__(self, img):
          for t in self.transforms:
              img = t(img)
          return img
  
  
  class ColorJitter(object):
      """Randomly change the brightness, contrast and saturation of an image.
      Args:
          brightness (float): How much to jitter brightness. brightness_factor
              is chosen uniformly from [max(0, 1 - brightness), 1 + brightness].
          contrast (float): How much to jitter contrast. contrast_factor
              is chosen uniformly from [max(0, 1 - contrast), 1 + contrast].
          saturation (float): How much to jitter saturation. saturation_factor
              is chosen uniformly from [max(0, 1 - saturation), 1 + saturation].
          hue(float): How much to jitter hue. hue_factor is chosen uniformly from
              [-hue, hue]. Should be >=0 and <= 0.5.
      """
  
      def __init__(self, brightness=0, contrast=0, saturation=0, hue=0):
          self.brightness = brightness
          self.contrast = contrast
          self.saturation = saturation
          self.hue = hue
  
      @staticmethod
      def get_params(brightness, contrast, saturation, hue):
          """Get a randomized transform to be applied on image.
          Arguments are same as that of __init__.
          Returns:
              Transform which randomly adjusts brightness, contrast and
              saturation in a random order.
          """
          transforms = []
          if brightness > 0:
              brightness_factor = np.random.uniform(
                  max(0, 1 - brightness), 1 + brightness)
              transforms.append(
                  Lambda(lambda img: adjust_brightness(img, brightness_factor)))
  
          if contrast > 0:
              contrast_factor = np.random.uniform(
                  max(0, 1 - contrast), 1 + contrast)
              transforms.append(
                  Lambda(lambda img: adjust_contrast(img, contrast_factor)))
  
          if saturation > 0:
              saturation_factor = np.random.uniform(
                  max(0, 1 - saturation), 1 + saturation)
              transforms.append(
                  Lambda(lambda img: adjust_saturation(img, saturation_factor)))
  
          if hue > 0:
              hue_factor = np.random.uniform(-hue, hue)
              transforms.append(Lambda(lambda img: adjust_hue(img, hue_factor)))
  
          np.random.shuffle(transforms)
          transform = Compose(transforms)
  
          return transform
  
      def __call__(self, img):
          """
          Args:
              img (PIL.Image): Input image.
          Returns:
              PIL.Image: Color jittered image.
          """
          transform = self.get_params(self.brightness, self.contrast,
                                      self.saturation, self.hue)
          return transform(img)
  
  
  class Scale(object):
      def __init__(self, size, interpolation=Image.BILINEAR):
          assert isinstance(size, int) or (isinstance(
              size, collections.Iterable) and len(size) == 2)
          self.size = size
          self.interpolation = interpolation
  
      def __call__(self, img):
          if isinstance(self.size, int):
              w, h = img.size
              if (w <= h and w == self.size) or (h <= w and h == self.size):
                  return img
              if w < h:
                  ow = self.size
                  oh = int(self.size * h / w)
                  return img.resize((ow, oh), self.interpolation)
              else:
                  oh = self.size
                  ow = int(self.size * w / h)
                  return img.resize((ow, oh), self.interpolation)
          else:
              return img.resize(self.size, self.interpolation)
  
  
  class ToLabel(object):
  
      def __call__(self, image):
          return torch.from_numpy(np.array(image)).long().unsqueeze(0)
  
  
  class ReLabel(object):
  
      def __init__(self, olabel, nlabel):
          self.olabel = olabel
          self.nlabel = nlabel
  
      def __call__(self, tensor):
          assert isinstance(
              tensor, torch.LongTensor), 'tensor needs to be LongTensor'
          tensor[tensor == self.olabel] = self.nlabel
          return tensor
  
  
  class HorizontalFlip(object):
      """Horizontally flips the given PIL.Image with a probability of 0.5."""
  
      def __call__(self, img):
          return img.transpose(Image.FLIP_LEFT_RIGHT)
  
  
  class VerticalFlip(object):
      """Vertically flips the given PIL.Image with a probability of 0.5."""
  
      def __call__(self, img):
          return img.transpose(Image.FLIP_TOP_BOTTOM)
  