code: def run_alignment(image):
      img = Image.fromarray(image).convert("RGB")
      face = futils.dlib.detect(img)
      if not face:
          raise Exception("Could not find a face in the given image.")
      face_on_image = face[0]
      lm = futils.dlib.landmarks(img, face_on_image)
      lm = np.array(lm)[:, ::-1]
      lm_eye_left = lm[36:42]
      lm_eye_right = lm[42:48]
      lm_mouth_outer = lm[48:60]
  
      output_size = 1024
      transform_size = 4096
      enable_padding = True
  
      # Calculate auxiliary vectors.
      eye_left = np.mean(lm_eye_left, axis=0)
      eye_right = np.mean(lm_eye_right, axis=0)
      eye_avg = (eye_left + eye_right) * 0.5
      eye_to_eye = eye_right - eye_left
      mouth_left = lm_mouth_outer[0]
      mouth_right = lm_mouth_outer[6]
      mouth_avg = (mouth_left + mouth_right) * 0.5
      eye_to_mouth = mouth_avg - eye_avg
  
      # Choose oriented crop rectangle.
      x = eye_to_eye - np.flipud(eye_to_mouth) * [-1, 1]
      x /= np.hypot(*x)
      x *= max(
          np.hypot(*eye_to_eye) * 2.0, np.hypot(*eye_to_mouth) * 1.8
      )
      y = np.flipud(x) * [-1, 1]
      c = eye_avg + eye_to_mouth * 0.1
      quad = np.stack([c - x - y, c - x + y, c + x + y, c + x - y])
      qsize = np.hypot(*x) * 2
  
      # Shrink.
      shrink = int(np.floor(qsize / output_size * 0.5))
      if shrink > 1:
          rsize = (
              int(np.rint(float(img.size[0]) / shrink)),
              int(np.rint(float(img.size[1]) / shrink)),
          )
          img = img.resize(rsize, Image.ANTIALIAS)
          quad /= shrink
          qsize /= shrink
  
      # Crop.
      border = max(int(np.rint(qsize * 0.1)), 3)
      crop = (
          int(np.floor(min(quad[:, 0]))),
          int(np.floor(min(quad[:, 1]))),
          int(np.ceil(max(quad[:, 0]))),
          int(np.ceil(max(quad[:, 1]))),
      )
      crop = (
          max(crop[0] - border, 0),
          max(crop[1] - border, 0),
          min(crop[2] + border, img.size[0]),
          min(crop[3] + border, img.size[1]),
      )
      if (
          crop[2] - crop[0] < img.size[0]
          or crop[3] - crop[1] < img.size[1]
      ):
          img = img.crop(crop)
          quad -= crop[0:2]
  
      # Pad.
      pad = (
          int(np.floor(min(quad[:, 0]))),
          int(np.floor(min(quad[:, 1]))),
          int(np.ceil(max(quad[:, 0]))),
          int(np.ceil(max(quad[:, 1]))),
      )
      pad = (
          max(-pad[0] + border, 0),
          max(-pad[1] + border, 0),
          max(pad[2] - img.size[0] + border, 0),
          max(pad[3] - img.size[1] + border, 0),
      )
      if enable_padding and max(pad) > border - 4:
          pad = np.maximum(pad, int(np.rint(qsize * 0.3)))
          img = np.pad(
              np.float32(img),
              ((pad[1], pad[3]), (pad[0], pad[2]), (0, 0)),
              "reflect",
          )
          h, w, _ = img.shape
          y, x, _ = np.ogrid[:h, :w, :1]
          mask = np.maximum(
              1.0
              - np.minimum(
                  np.float32(x) / pad[0], np.float32(w - 1 - x) / pad[2]
              ),
              1.0
              - np.minimum(
                  np.float32(y) / pad[1], np.float32(h - 1 - y) / pad[3]
              ),
          )
          blur = qsize * 0.02
          img += (
              scipy.ndimage.gaussian_filter(img, [blur, blur, 0]) - img
          ) * np.clip(mask * 3.0 + 1.0, 0.0, 1.0)
          img += (np.median(img, axis=(0, 1)) - img) * np.clip(
              mask, 0.0, 1.0
          )
          img = Image.fromarray(
              np.uint8(np.clip(np.rint(img), 0, 255)), "RGB"
          )
          quad += pad[:2]
  
      # Transform.
      img = img.transform(
          (transform_size, transform_size),
          Image.QUAD,
          (quad + 0.5).flatten(),
          Image.BILINEAR,
      )
  
      return img
  
file_path: PaddleHub/modules/image/Image_gan/gan/pixel2style2pixel/model.py
imports: import os
  import cv2
  import scipy
  import random
  import numpy
  import paddle
  import paddle.vision.transforms
  import ppgan.faceutils
  from ppgan.models.generators import Pixel2Style2Pixel
  from ppgan.utils.download import get_path_from_url
  from PIL import Image
label_desc: Use image node_id 1 for calling a global function with example usage: run_alignment(image) and returns: img