text: resize_possible = True
  
  try:
      # TRY USING OpenCV AS RESIZER
      # raise ImportError #debugging
      import cv2
      import numpy as np
  
      def resizer(pic, newsize):
          lx, ly = int(newsize[0]), int(newsize[1])
          if lx > pic.shape[1] or ly > pic.shape[0]:
              # For upsizing use linear for good quality & decent speed
              interpolation = cv2.INTER_LINEAR
          else:
              # For dowsizing use area to prevent aliasing
              interpolation = cv2.INTER_AREA
          return cv2.resize(+pic.astype("uint8"), (lx, ly), interpolation=interpolation)
  
      resizer.origin = "cv2"
  
  except ImportError:
  
      try:
          # TRY USING PIL/PILLOW AS RESIZER
          from PIL import Image
          import numpy as np
  
          def resizer(pic, newsize):
              newsize = list(map(int, newsize))[::-1]
              shape = pic.shape
              if len(shape) == 3:
                  newshape = (newsize[0], newsize[1], shape[2])
              else:
                  newshape = (newsize[0], newsize[1])
  
              pilim = Image.fromarray(pic)
              resized_pil = pilim.resize(newsize[::-1], Image.ANTIALIAS)
              # arr = np.fromstring(resized_pil.tostring(), dtype='uint8')
              # arr.reshape(newshape)
              return np.array(resized_pil)
  
          resizer.origin = "PIL"
  
      except ImportError:
          # TRY USING SCIPY AS RESIZER
          try:
              from scipy.misc import imresize
  
              def resizer(pic, newsize):
                  return imresize(pic, map(int, newsize[::-1]))
  
              resizer.origin = "Scipy"
  
          except ImportError:
              resize_possible = False
  
  
  def resize(clip, newsize=None, height=None, width=None, apply_to_mask=True):
      """ 
      Returns a video clip that is a resized version of the clip.
      
      Parameters
      ------------
      
      newsize:
        Can be either 
          - ``(width,height)`` in pixels or a float representing
          - A scaling factor, like 0.5
          - A function of time returning one of these.
              
      width:
        width of the new clip in pixel. The height is then computed so
        that the width/height ratio is conserved. 
              
      height:
        height of the new clip in pixel. The width is then computed so
        that the width/height ratio is conserved.
      
      Examples
      ----------
               
      >>> myClip.resize( (460,720) ) # New resolution: (460,720)
      >>> myClip.resize(0.6) # width and heigth multiplied by 0.6
      >>> myClip.resize(width=800) # height computed automatically.
      >>> myClip.resize(lambda t : 1+0.02*t) # slow swelling of the clip
      
      """
  
      w, h = clip.size
  
      if newsize is not None:
  
          def trans_newsize(ns):
  
              if isinstance(ns, (int, float)):
                  return [ns * w, ns * h]
              else:
                  return ns
  
          if hasattr(newsize, "__call__"):
              # The resizing is a function of time
  
              def newsize2(t):
                  return trans_newsize(newsize(t))
  
              if clip.ismask:
  
                  def fun(gf, t):
                      return (
                          1.0 * resizer((255 * gf(t)).astype("uint8"), newsize2(t)) / 255
                      )
  
              else:
  
                  def fun(gf, t):
                      return resizer(gf(t).astype("uint8"), newsize2(t))
  
              newclip = clip.fl(
                  fun, keep_duration=True, apply_to=(["mask"] if apply_to_mask else [])
              )
              if apply_to_mask and clip.mask is not None:
                  newclip.mask = resize(clip.mask, newsize, apply_to_mask=False)
  
              return newclip
  
          else:
              newsize = trans_newsize(newsize)
  
      elif height is not None:
  
          if hasattr(height, "__call__"):
  
              def fun(t):
                  return 1.0 * int(height(t)) / h
  
              return resize(clip, fun)
  
          else:
              newsize = [w * height / h, height]
  
      elif width is not None:
  
          if hasattr(width, "__call__"):
  
              def fun(t):
                  return 1.0 * width(t) / w
  
              return resize(clip, fun)
  
          else:
              newsize = [width, h * width / w]
  
      # From here, the resizing is constant (not a function of time), size=newsize
  
      if clip.ismask:
  
          def fl(pic):
              return 1.0 * resizer((255 * pic).astype("uint8"), newsize) / 255.0
  
      else:
  
          def fl(pic):
              return resizer(pic.astype("uint8"), newsize)
  
      newclip = clip.fl_image(fl)
  
      if apply_to_mask and clip.mask is not None:
          newclip.mask = resize(clip.mask, newsize, apply_to_mask=False)
  
      return newclip
  
  
  if not resize_possible:
  
      doc = resize.__doc__
  
      def resize(clip, newsize=None, height=None, width=None):
          raise ImportError("fx resize needs OpenCV or Scipy or PIL")
  
      resize.__doc__ = doc
  