example_face_liveness.cpp

Go to the documentation of this file.

 
#include "sfe_toolkit/sfe_core.h"
#include "sfe_toolkit/sfe_face.h"
#include <iomanip>
#include <regex>
#include <sstream>
#include <vector>
 
#include "annotate.hpp"
#include "solvers.h"
#include "utils.hpp"
#include <unordered_map>
 
std::string image_probe = "assets/face/images/obiwan0.png";
 
std::string solver_face_detect = SOLVER_FACE_DETECT;
std::string solver_face_landmarks = SOLVER_FACE_LANDMARKS;
std::string solver_face_liveness = SOLVER_FACE_LIVENESS;
 
const auto SOLVER_PARAMETERS = std::vector<SFESolverParameter>{};
 
size_t face_size_min = 28;
size_t face_size_max = 170;
 
float detection_threshold = 0.1f;
 
void getRecommendedImageSize(const std::string &solver_face_detect,
                             SFEImage &image, const size_t face_size_min,
                             const size_t face_size_max,
                             size_t &recommended_width,
                             size_t &recommended_height) {
 
  // If the face detection solver requires static input (filename contains width
  // and height), we need to prepare the input image accordingly Typically the
  // format is: face_detect_accurate_mask_w1920h1080_op11.onnxrt.solver NOTE:
  // This can be hardcoded into the application, or we can parse the width and
  // height from the solver filename
 
  // Try to use regex capture to extract width and height from solver name
  std::smatch width_height;
  if (std::regex_match(solver_face_detect, width_height,
                       std::regex(".*w([0-9]+)h([0-9]+).*"))) {
    recommended_width = std::stoi(width_height[1]);
    recommended_height = std::stoi(width_height[2]);
  } else {
    // Solvers without width and height in name can accept dynamic input
    // image size. For best results we recommend to scale the input image to
    // a resolution recommended by the sfeFaceDetectInputSize function
 
    // Use sfeFaceDetectInputSize to get recommended input image dimensions
    // for given min_face_size/max_face_size
    SFEDetectionInputSize input_size{};
    SFEError error = sfeFaceDetectInputSize(
        image,
        SFEFaceDetectionAccuracyType::SFE_FACE_DETECT_ACCURACY_TYPE_ACCURATE,
        face_size_min, face_size_max, &input_size);
    utils::checkError(error);
    recommended_width = input_size.width;
    recommended_height = input_size.height;
  };
}
 
inline void printFaceDetectionInfo(SFEDetection &detected_face) {
  std::cout << "SFEDetection{ " << std::endl;
  std::cout << "  confidence: " << detected_face.confidence << std::endl;
  std::cout << "  SFEBoundingBox{ " << std::endl;
  std::cout << "    x: " << detected_face.bounding_box.x << std::endl;
  std::cout << "    y: " << detected_face.bounding_box.y << std::endl;
  std::cout << "    width: " << detected_face.bounding_box.width << std::endl;
  std::cout << "    height: " << detected_face.bounding_box.height << std::endl;
  std::cout << "    }" << std::endl;
  std::cout << "  } " << std::endl;
  std::cout << std::endl;
}
 
inline void prinFaceAreaInfo(SFEFaceArea &face_area) {
  std::cout << "SFEFaceArea{ " << std::endl;
  std::cout << "  size: " << face_area.size << " [px]" << std::endl;
  std::cout << "  area: " << face_area.area << std::endl;
  std::cout << "  area_in_image: " << face_area.area_in_image << std::endl;
  std::cout << "}" << std::endl;
  std::cout << std::endl;
}
 
inline void printFaceHeadPose(SFEFaceHeadPose &head_pose) {
  std::cout << "SFEFaceHeadPose{" << std::endl;
  std::cout << "  pitch: " << head_pose.pitch << std::endl;
  std::cout << "  yaw: " << head_pose.yaw << std::endl;
  std::cout << "  roll: " << head_pose.roll << std::endl;
  std::cout << "} " << std::endl;
  std::cout << std::endl;
}
 
inline void printFaceSize(size_t face_size) {
  std::cout << "Face size: " << face_size << " [px]" << std::endl;
  std::cout << std::endl;
}
 
inline void printMaskConfidence(float mask_confidence) {
  std::cout << "Mask confidence: " << mask_confidence << std::endl;
  std::cout << std::endl;
}
 
inline void
printFaceQualityAttributes(SFEFaceQualityAttributes &quality_attributes) {
  std::cout << "SFEFaceQualityAttributes{" << std::endl;
  std::cout << "  sharpness: " << quality_attributes.sharpness << std::endl;
  std::cout << "  brightness: " << quality_attributes.brightness << std::endl;
  std::cout << "  contrast: " << quality_attributes.contrast << std::endl;
  std::cout << "  unique_intensity_levels: "
            << quality_attributes.unique_intensity_levels << std::endl;
  std::cout << "} " << std::endl;
  std::cout << std::endl;
}
 
void printHelp() {
  std::cout << "Help: Usage of the program." << std::endl;
  std::cout << "Options:" << std::endl;
  std::cout << "-h: Display help." << std::endl;
  std::cout << "-p: Probe image file." << std::endl;
  std::cout << "-d: Path to detector solver." << std::endl;
  std::cout << "-l: Path to landmarks solver." << std::endl;
  std::cout << "-i: Path to liveness solver." << std::endl;
  std::cout << "-t: Face detection threshold. <0,1>" << std::endl;
  std::cout << "-m: Minimal face size in pixels to detect." << std::endl;
  std::cout << "-x: Max face size in pixels to detect." << std::endl;
}
 
int main(int argc, char *argv[]) {
 
  { // STAGE: 0 Parse command line arguments
    // Map to store argument values
    std::unordered_map<std::string, std::string> args;
 
    // Parse command line arguments
    for (int i = 1; i < argc; ++i) {
      std::string arg = argv[i];
      if (arg[0] == '-') {
        if (arg == "-h") {
          printHelp();
          return 0;
        }
        // Check if there's a next argument and it isn't another option
        if (i + 1 < argc && argv[i + 1][0] != '-') {
          args[arg] = argv[++i];
        } else {
          std::cerr << "Option " << arg << " requires a value." << std::endl;
          return 1;
        }
      } else {
        std::cerr << "Unknown option: " << arg << std::endl;
        return 1;
      }
    }
 
    // Assign values to variables based on parsed arguments
    if (args.count("-p"))
      image_probe = args["-p"];
    if (args.count("-d"))
      solver_face_detect = args["-d"];
    if (args.count("-l"))
      solver_face_landmarks = args["-l"];
    if (args.count("-i"))
      solver_face_liveness = args["-i"];
    if (args.count("-t"))
      detection_threshold = std::stof(args["-t"]);
    if (args.count("-m"))
      face_size_min = std::stoi(args["-m"]);
    if (args.count("-x"))
      face_size_max = std::stoi(args["-x"]);
 
    utils::printFormatted("PARAMETERS");
    // Print resource names
    std::cout << "Probe image: " << image_probe << std::endl;
 
    // Print solver names
    std::cout << "Face detection solver: " << solver_face_detect << std::endl;
    std::cout << "Face landmarks solver: " << solver_face_landmarks
              << std::endl;
    std::cout << "Face liveness solver: " << solver_face_liveness << std::endl;
 
    // Print other options
    std::cout << "Min face size [px]: " << face_size_min << std::endl;
    std::cout << "Max face size [px]: " << face_size_max << std::endl;
    std::cout << "Detection threshold: " << detection_threshold << std::endl;
  }
 
  utils::printToolkitInfo();
 
  SFEError error{};
 
  SFESolver detector_solver{};
  DEFER(sfeSolverFree(detector_solver));
  SFESolver landmarks_solver{};
  DEFER(sfeSolverFree(landmarks_solver));
  SFESolver liveness_solver{};
  DEFER(sfeSolverFree(liveness_solver));
  { // STAGE 1: loading solvers
    utils::printFormatted("LOADING solvers");
    // Initialize face detection solver
    error = sfeSolverCreate(
        solver_face_detect.c_str(), SOLVER_PARAMETERS.data(),
        SOLVER_PARAMETERS.size(), &detector_solver);
    utils::checkError(error);
 
    // Initialize landmarks detection solver
    error = sfeSolverCreate(
        solver_face_landmarks.c_str(), SOLVER_PARAMETERS.data(),
        SOLVER_PARAMETERS.size(), &landmarks_solver);
    utils::checkError(error);
 
    // Initialize face liveness solver
    error = sfeSolverCreate(
        solver_face_liveness.c_str(), SOLVER_PARAMETERS.data(),
        SOLVER_PARAMETERS.size(), &liveness_solver);
    utils::checkError(error);
  }
 
  SFEImage image{};
  DEFER(sfeImageFree(image));
  SFEImage resized_image{};
  DEFER(sfeImageFree(resized_image));
  { // STAGE 2: Load image
 
    utils::printFormatted("FACE DETECTION");
    // Load image data from file
    auto image_data = utils::readFile(image_probe);
 
    // Decode image from data
    error = sfeImageDecode(image_data.data(), image_data.size(), &image);
    utils::checkError(error);
 
    size_t recommended_width{};
    size_t recommended_height{};
 
    // Calculate optimal input image size for face detection. Image will be
    // resized to recommended size for optimal performance.
    getRecommendedImageSize(solver_face_detect, image, face_size_min,
                            face_size_max, recommended_width,
                            recommended_height);
 
    // Resize image to recommended size
    // NOTE: This function will resize the image without preserving the aspect
    // ratio of the image.
    error = sfeImageResize(image, recommended_width, recommended_height,
                           &resized_image);
    utils::checkError(error);
  }
  SFEDetection detected_face = {};
  { // STAGE 3: Detect face in the image
    size_t detection_count = 1;
    // Detect face in the image
    error = sfeDetect(detector_solver, resized_image, detection_threshold,
                          &detected_face, &detection_count);
    utils::checkError(error);
 
    if (detection_count == 0) {
      std::cout << "No face detected in the probe image." << std::endl;
      return 0;
    } else {
      std::cout << "Found " << detection_count
                << " face(s) in the probe image. Using the face with highest "
                   "confidence."
                << std::endl;
    }
  }
 
  std::vector<SFEFaceLandmarks> landmarks(SFE_FACE_LANDMARK_COUNT);
  { // STAGE 4: Get face landmarks
 
    // Use landmarks detection solver to get relevant landmarks for
    // the detected face
    error = sfeFaceLandmarks(landmarks_solver, image, &detected_face,
                             landmarks.data());
    utils::checkError(error);
  }
 
  SFEFaceLiveness liveness = {};
  { // STAGE 5: Liveness check
    utils::printFormatted("LIVENESS CHECK");
    error = sfeFaceLivenessPassive(liveness_solver, image, landmarks.data(),
                                   &liveness);
    utils::checkError(error);
  }
 
  { // STAGE 6: Print the liveness score
    std::cout << "Liveness score is " << liveness.score;
    // Recommended threshold for liveness detection, see EER threshold for distant fast mode in the documentation
    static const float LIVENESS_THRESHOLD = 0.81f;
    if (liveness.score < LIVENESS_THRESHOLD) {
      std::cout << " which is below " << LIVENESS_THRESHOLD
                << " threshold. Face is spoof." << std::endl;
    } else {
      std::cout << " which is above " << LIVENESS_THRESHOLD
                << " threshold. Face is genuine." << std::endl;
    }
  }
 
  // Optional face attributes to check for further analysis. See the
  // documentation for more information.
  float face_size = 0;
  float mask_confidence;
  SFEFaceArea face_area = {};
  SFEFaceHeadPose head_pose{};
  SFEFaceQualityAttributes quality_attributes{};
  { // STAGE 6: (optional) Face attributes
    utils::printFormatted("FACE ATTRIBUTES");
 
    error = sfeFaceSize(image, landmarks.data(), &face_size);
    utils::checkError(error);
 
    error = sfeFaceMaskConfidence(landmarks.data(), &mask_confidence);
    utils::checkError(error);
 
    error = sfeFaceArea(image, landmarks.data(), &face_area);
    utils::checkError(error);
 
    error = sfeFaceHeadPose(image, landmarks.data(), &head_pose);
    utils::checkError(error);
 
    error =
        sfeFaceQualityAttributes(image, landmarks.data(), &quality_attributes);
    utils::checkError(error);
  }
 
  { // STAGE 8: Print the face attributes
    printFaceDetectionInfo(detected_face);
    printFaceSize(face_size);
    printMaskConfidence(mask_confidence);
    prinFaceAreaInfo(face_area);
    printFaceHeadPose(head_pose);
    printFaceQualityAttributes(quality_attributes);
  }
 
  { // STAGE 9: Annotate the image
    // Render bounding box
    std::stringstream label;
    label << "Face" << std::fixed << std::setprecision(2)
          << " d:" << detected_face.confidence << " m:" << mask_confidence
          << " l:" << liveness.score;
 
    annotate::labelBox(image, label.str(), detected_face.bounding_box, annotate::WHITE,
                       annotate::GREEN);
 
    // Render landmarks
    for (auto &landmark : landmarks) {
      auto x = landmark.x * image.width;
      auto y = landmark.y * image.height;
      annotate::circle(image, x, y, 3, annotate::YELLOW);
    }
 
    // Save annotated image
    size_t size = image.width * image.height * 3;
    auto png_file = std::vector<unsigned char>(size);
    error = sfeImageEncode(image, SFE_IMAGE_FORMAT_PNG, png_file.data(), &size);
    utils::checkError(error);
    png_file.resize(size);
    utils::saveFile("face_liveness.png", png_file);
 
    std::cout << std::endl;
    std::cout << "Annotated image saved to face_liveness.png" << std::endl;
  }
 
  utils::printFormatted("FINISHED");
}