docstr: Predict the landmarks for each face present in the image.
  
  This function predicts a set of 68 2D or 3D images, one for each image present.
  If detect_faces is None the method will also run a face detector.
  
   Arguments:
      image_or_path {string or numpy.array or torch.tensor} -- The input image or path to it.
  
  Keyword Arguments:
      detected_faces {list of numpy.array} -- list of bounding boxes, one for each face found
      in the image (default: {None})
      return_bboxes {boolean} -- If True, return the face bounding boxes in addition to the keypoints.
      return_landmark_score {boolean} -- If True, return the keypoint scores along with the keypoints.
  
  Return:
      result:
          1. if both return_bboxes and return_landmark_score are False, result will be:
              landmark
          2. Otherwise, result will be one of the following, depending on the actual value of return_* arguments.
              (landmark, landmark_score, detected_face)
              (landmark, None,           detected_face)
              (landmark, landmark_score, None         )
docstr_tok: ["Predict","the","landmarks","for","each","face","present","in","the","image",".","This","function","predicts","a","set","of","68","2D","or","3D","images",",","one","for","each","image","present",".","If","detect_faces","is","None","the","method","will","also","run","a","face","detector",".","Arguments",":","image_or_path","{","string","or","numpy.array","or","torch.tensor","}","--","The","input","image","or","path","to","it",".","Keyword","Arguments",":","detected_faces","{","list","of","numpy.array","}","--","list","of","bounding","boxes",",","one","for","each","face","found","in","the","image","(","default",":","{","None","}",")","return_bboxes","{","boolean","}","--","If","True",",","return","the","face","bounding","boxes","in","addition","to","the","keypoints",".","return_landmark_score","{","boolean","}","--","If","True",",","return","the","keypoint","scores","along","with","the","keypoints",".","Return",":","result",":","1.","if","both","return_bboxes","and","return_landmark_score","are","False",",","result","will","be",":","landmark","2",".","Otherwise",",","result","will","be","one","of","the","following",",","depending","on","the","actual","value","of","return_","*","arguments",".","(","landmark",",","landmark_score",",","detected_face",")","(","landmark",",","None",",","detected_face",")","(","landmark",",","landmark_score",",","None",")"]
code: def get_landmarks_from_image(
      self,
      image_or_path,
      detected_faces=None,
      return_bboxes=False,
      return_landmark_score=False,
  ):
      """Predict the landmarks for each face present in the image.
  
      This function predicts a set of 68 2D or 3D images, one for each image present.
      If detect_faces is None the method will also run a face detector.
  
       Arguments:
          image_or_path {string or numpy.array or torch.tensor} -- The input image or path to it.
  
      Keyword Arguments:
          detected_faces {list of numpy.array} -- list of bounding boxes, one for each face found
          in the image (default: {None})
          return_bboxes {boolean} -- If True, return the face bounding boxes in addition to the keypoints.
          return_landmark_score {boolean} -- If True, return the keypoint scores along with the keypoints.
  
      Return:
          result:
              1. if both return_bboxes and return_landmark_score are False, result will be:
                  landmark
              2. Otherwise, result will be one of the following, depending on the actual value of return_* arguments.
                  (landmark, landmark_score, detected_face)
                  (landmark, None,           detected_face)
                  (landmark, landmark_score, None         )
      """
      image = get_image(image_or_path)
  
      if detected_faces is None:
          detected_faces = self.face_detector.detect_from_image(
              image.copy()
          )
  
      if len(detected_faces) == 0:
          warnings.warn("No faces were detected.")
          if return_bboxes or return_landmark_score:
              return None, None, None
          else:
              return None
  
      landmarks = []
      landmarks_scores = []
      for i, d in enumerate(detected_faces):
          center = torch.tensor(
              [d[2] - (d[2] - d[0]) / 2.0, d[3] - (d[3] - d[1]) / 2.0]
          )
          center[1] = center[1] - (d[3] - d[1]) * 0.12
          scale = (
              d[2] - d[0] + d[3] - d[1]
          ) / self.face_detector.reference_scale
  
          inp = crop(image, center, scale)
          inp = torch.from_numpy(inp.transpose((2, 0, 1))).float()
  
          inp = inp.to(self.device, dtype=self.dtype)
          inp.div_(255.0).unsqueeze_(0)
  
          out = self.face_alignment_net(inp).detach()
          if self.flip_input:
              out += flip(
                  self.face_alignment_net(flip(inp)).detach(),
                  is_label=True,
              )
          out = out.to(device="cpu", dtype=torch.float32).numpy()
  
          pts, pts_img, scores = get_preds_fromhm(
              out, center.numpy(), scale
          )
          pts, pts_img = torch.from_numpy(pts), torch.from_numpy(
              pts_img
          )
          pts, pts_img = pts.view(68, 2) * 4, pts_img.view(68, 2)
          scores = scores.squeeze(0)
  
          if self.landmarks_type == LandmarksType.THREE_D:
              heatmaps = np.zeros((68, 256, 256), dtype=np.float32)
              for i in range(68):
                  if pts[i, 0] > 0 and pts[i, 1] > 0:
                      heatmaps[i] = draw_gaussian(
                          heatmaps[i], pts[i], 2
                      )
              heatmaps = torch.from_numpy(heatmaps).unsqueeze_(0)
  
              heatmaps = heatmaps.to(self.device, dtype=self.dtype)
              depth_pred = (
                  self.depth_prediciton_net(
                      torch.cat((inp, heatmaps), 1)
                  )
                  .data.cpu()
                  .view(68, 1)
                  .to(dtype=torch.float32)
              )
              pts_img = torch.cat(
                  (
                      pts_img,
                      depth_pred * (1.0 / (256.0 / (200.0 * scale))),
                  ),
                  1,
              )
  
          landmarks.append(pts_img.numpy())
          landmarks_scores.append(scores)
  
      if not return_bboxes:
          detected_faces = None
      if not return_landmark_score:
          landmarks_scores = None
      if return_bboxes or return_landmark_score:
          return landmarks, landmarks_scores, detected_faces
      else:
          return landmarks
  
file_path: face-alignment/face_alignment/api.py
imports: import torch
  import warnings
  from enum import IntEnum
  from skimage import io
  import numpy
  from packaging import version
  from tqdm import tqdm
  from .utils import *
  from .folder_data import FolderData
label_desc: Use image node_id 3 for calling the FaceAlignment obj's underlying member method code with example usage: obj.get_landmarks_from_image(image_or_path, detected_faces, return_bboxes, return_landmark_score) and returns: landmarks,  landmarks_scores,  detected_faces, landmarks, None,  None,  None, None