text: # Copyright 2021 Huawei Technologies Co., Ltd
  #
  # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  #
  # http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  # ============================================================================
  
  """
  code in this file is adpated from rpmcruz/autoaugment
  https://github.com/rpmcruz/autoaugment/blob/master/transformations.py
  """
  
  import random
  from PIL import Image, ImageFilter, ImageOps, ImageEnhance, ImageDraw
  import PIL
  import numpy as np
  
  
  def ShearX(img, v):  # [-0.3, 0.3]
      assert -0.3 <= v <= 0.3
      if random.random() > 0.5:
          v = -v
      return img.transform(img.size, PIL.Image.AFFINE, (1, v, 0, 0, 1, 0))
  
  
  def ShearY(img, v):  # [-0.3, 0.3]
      assert -0.3 <= v <= 0.3
      if random.random() > 0.5:
          v = -v
      return img.transform(img.size, PIL.Image.AFFINE, (1, 0, 0, v, 1, 0))
  
  
  def TranslateX(img, v):  # [-150, 150] => percentage: [-0.45, 0.45]
      assert -0.45 <= v <= 0.45
      if random.random() > 0.5:
          v = -v
      v = v * img.size[0]
      return img.transform(img.size, PIL.Image.AFFINE, (1, 0, v, 0, 1, 0))
  
  
  def TranslateXabs(img, v):  # [-150, 150] => percentage: [-0.45, 0.45]
      assert v >= 0
      if random.random() > 0.5:
          v = -v
      return img.transform(img.size, PIL.Image.AFFINE, (1, 0, v, 0, 1, 0))
  
  
  def TranslateY(img, v):  # [-150, 150] => percentage: [-0.45, 0.45]
      assert -0.45 <= v <= 0.45
      if random.random() > 0.5:
          v = -v
      v = v * img.size[1]
      return img.transform(img.size, PIL.Image.AFFINE, (1, 0, 0, 0, 1, v))
  
  
  def TranslateYabs(img, v):  # [-150, 150] => percentage: [-0.45, 0.45]
      assert v >= 0
      if random.random() > 0.5:
          v = -v
      return img.transform(img.size, PIL.Image.AFFINE, (1, 0, 0, 0, 1, v))
  
  
  def Rotate(img, v):  # [-30, 30]
      assert -30 <= v <= 30
      if random.random() > 0.5:
          v = -v
      return img.rotate(v)
  
  
  def AutoContrast(img, _):
      return ImageOps.autocontrast(img)
  
  
  def Invert(img, _):
      return ImageOps.invert(img)
  
  
  def Equalize(img, _):
      return ImageOps.equalize(img)
  
  
  def Flip(img, _):  # not from the paper
      return ImageOps.mirror(img)
  
  
  def Solarize(img, v):  # [0, 256]
      assert 0 <= v <= 256
      return ImageOps.solarize(img, v)
  
  
  def SolarizeAdd(img, addition=0, threshold=128):
      img_np = np.array(img).astype(np.int)
      img_np = img_np + addition
      img_np = np.clip(img_np, 0, 255)
      img_np = img_np.astype(np.uint8)
      img = Image.fromarray(img_np)
      return ImageOps.solarize(img, threshold)
  
  
  def Posterize(img, v):  # [4, 8]
      v = int(v)
      return ImageOps.posterize(img, v)
  
  
  def Contrast(img, v):  # [0.1,1.9]
      assert 0.1 <= v <= 1.9
      return ImageEnhance.Contrast(img).enhance(v)
  
  
  def Color(img, v):  # [0.1,1.9]
      assert 0.1 <= v <= 1.9
      return ImageEnhance.Color(img).enhance(v)
  
  
  def Brightness(img, v):  # [0.1,1.9]
      assert 0.1 <= v <= 1.9
      return ImageEnhance.Brightness(img).enhance(v)
  
  
  def Sharpness(img, v):  # [0.1,1.9]
      assert 0.1 <= v <= 1.9
      return ImageEnhance.Sharpness(img).enhance(v)
  
  
  def Cutout(img, v):  # [0, 60] => percentage: [0, 0.2]
      assert 0.0 <= v <= 0.2
      if v <= 0.:
          return img
  
      v = v * img.size[0]
      return CutoutAbs(img, v)
  
  
  def ToEMBOSS(img, v):
      return img.filter(ImageFilter.EMBOSS)
  
  
  def ToEDGES(img, v):
      return img.filter(ImageFilter.FIND_EDGES)
  
  
  def ToCONTOUR(img, v):
      return img.filter(ImageFilter.CONTOUR)
  
  
  def ToBLUR(img, v):
      return img.filter(ImageFilter.BLUR)
  
  
  def CutoutAbs(img, v):
      """cutoutabs"""
      # [0, 60] => percentage: [0, 0.2]
      if v < 0:
          return img
      w, h = img.size
      x0 = np.random.uniform(w)
      y0 = np.random.uniform(h)
  
      x0 = int(max(0, x0 - v / 2.))
      y0 = int(max(0, y0 - v / 2.))
      x1 = min(w, x0 + v)
      y1 = min(h, y0 + v)
  
      xy = (x0, y0, x1, y1)
      color = (125, 123, 114)
      # color = (0, 0, 0)
      img = img.copy()
      ImageDraw.Draw(img).rectangle(xy, color)
      return img
  
  
  def SamplePairing(imgs):  # [0, 0.4]
      def f(img1, v):
          i = np.random.choice(len(imgs))
          img2 = PIL.Image.fromarray(imgs[i])
          return PIL.Image.blend(img1, img2, v)
  
      return f
  
  
  def Identity(img, v):
      return img
  
  
  def augment_list():
      """augment list"""
      # oeprations and their ranges
      # https://github.com/tensorflow/tpu/blob/8462d083dd89489a79e3200bcc8d4063bf362186/models/official/efficientnet/autoaugment.py#L505
      l = [
          (AutoContrast, 0, 1),
          (Equalize, 0, 1),
          (Invert, 0, 1),
          (Rotate, 0, 30),
          (Posterize, 0, 4),
          (Solarize, 0, 256),
          (SolarizeAdd, 0, 110),
          # (Color, 0.1, 1.9),
          (Contrast, 0.1, 1.9),
          # (Brightness, 0.1, 1.9),
          (Sharpness, 0.1, 1.9),
          (ShearX, 0., 0.3),
          (ShearY, 0., 0.3),
          (CutoutAbs, 0, 40),
          (TranslateXabs, 0., 100),
          (TranslateYabs, 0., 100),
          (ToBLUR, 0, 1),
          (ToCONTOUR, 0, 1),
          (ToEMBOSS, 0, 1),
          (ToEDGES, 0, 1)
      ]
  
      return l
  
  
  class RandAugment:
      """RandAugment"""
      def __init__(self, n, m):
          self.n = n
          self.m = m  # [0, 30]
          self.augment_list = augment_list()
  
      def __call__(self, img):
          ops = []
          for _ in range(self.n):
              ops.append(random.choice(self.augment_list))
          for op, minval, maxval in ops:
              val = (float(self.m) / 30) * float(maxval - minval) + minval
              img = op(img, val)
  
          return img
  