code: def degradation_bsrgan_plus(
      img,
      sf=4,
      shuffle_prob=0.5,
      use_sharp=True,
      lq_patchsize=64,
      isp_model=None,
  ):
      """
      This is an extended degradation model by combining
      the degradation models of BSRGAN and Real-ESRGAN
      ----------
      img: HXWXC, [0, 1], its size should be large than (lq_patchsizexsf)x(lq_patchsizexsf)
      sf: scale factor
      use_shuffle: the degradation shuffle
      use_sharp: sharpening the img
      Returns
      -------
      img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1]
      hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1]
      """
  
      h1, w1 = img.shape[:2]
      img = img.copy()[: w1 - w1 % sf, : h1 - h1 % sf, ...]  # mod crop
      h, w = img.shape[:2]
  
      if h < lq_patchsize * sf or w < lq_patchsize * sf:
          raise ValueError(f"img size ({h1}X{w1}) is too small!")
  
      if use_sharp:
          img = add_sharpening(img)
      hq = img.copy()
  
      if random.random() < shuffle_prob:
          shuffle_order = random.sample(range(13), 13)
      else:
          shuffle_order = list(range(13))
          # local shuffle for noise, JPEG is always the last one
          shuffle_order[2:6] = random.sample(
              shuffle_order[2:6], len(range(2, 6))
          )
          shuffle_order[9:13] = random.sample(
              shuffle_order[9:13], len(range(9, 13))
          )
  
      poisson_prob, speckle_prob, isp_prob = 0.1, 0.1, 0.1
  
      for i in shuffle_order:
          if i == 0:
              img = add_blur(img, sf=sf)
          elif i == 1:
              img = add_resize(img, sf=sf)
          elif i == 2:
              img = add_Gaussian_noise(
                  img, noise_level1=2, noise_level2=25
              )
          elif i == 3:
              if random.random() < poisson_prob:
                  img = add_Poisson_noise(img)
          elif i == 4:
              if random.random() < speckle_prob:
                  img = add_speckle_noise(img)
          elif i == 5:
              if random.random() < isp_prob and isp_model is not None:
                  with torch.no_grad():
                      img, hq = isp_model.forward(img.copy(), hq)
          elif i == 6:
              img = add_JPEG_noise(img)
          elif i == 7:
              img = add_blur(img, sf=sf)
          elif i == 8:
              img = add_resize(img, sf=sf)
          elif i == 9:
              img = add_Gaussian_noise(
                  img, noise_level1=2, noise_level2=25
              )
          elif i == 10:
              if random.random() < poisson_prob:
                  img = add_Poisson_noise(img)
          elif i == 11:
              if random.random() < speckle_prob:
                  img = add_speckle_noise(img)
          elif i == 12:
              if random.random() < isp_prob and isp_model is not None:
                  with torch.no_grad():
                      img, hq = isp_model.forward(img.copy(), hq)
          else:
              print("check the shuffle!")
  
      # resize to desired size
      img = cv2.resize(
          img,
          (int(1 / sf * hq.shape[1]), int(1 / sf * hq.shape[0])),
          interpolation=random.choice([1, 2, 3]),
      )
  
      # add final JPEG compression noise
      img = add_JPEG_noise(img)
  
      # random crop
      img, hq = random_crop(img, hq, sf, lq_patchsize)
  
      return img, hq
  
imports: import numpy
  import cv2
  import torch
  from functools import partial
  import random
  from scipy import ndimage
  import scipy
  import scipy.stats
  from scipy.interpolate import interp2d
  from scipy.linalg import orth
  import albumentations
  import ldm.modules.image_degradation.utils_image
label_desc: Use image node_id 25 for calling a global function with example usage: degradation_bsrgan_plus(img, sf, shuffle_prob, use_sharp, lq_patchsize, isp_model) and returns: img,  hq