#include "sfe_toolkit/sfe_core.h"
#include "sfe_toolkit/sfe_face.h"
#include "annotate.hpp"
#include "solvers.h"
#include "utils.hpp"
#include <iomanip>
#include <iostream>
#include <sstream>
#include <unordered_map>
#include <vector>

Functions
void	printHelp ()

int	main (int argc, char *argv[])

Variables
std::string	image_probe = "assets/face/images/obiwan0.png"

std::string	solver_face_detect = SOLVER_FACE_DETECT
	Solvers to use in example, the defaults are filled in by CMake.

std::string	solver_face_landmarks = SOLVER_FACE_LANDMARKS

std::string	solver_face_demographic = SOLVER_FACE_DEMOGRAPHIC_ATTRIBUTES

const auto	SOLVER_PARAMETERS = std::vector<SFESolverParameter>{}

size_t	face_size_min = 28
	Required size of the face to be detected.

size_t	face_size_max = 170

float	detection_threshold = 0.1f

Function Documentation

◆ main()

int main	(	int	argc,
		char *	argv[]
	)

[Image Load]

[Face Detect]

[Face Landmarks]

[Face Demographic Attributes]

Definition at line 46 of file example_face_demographic_attributes.cpp.

                                 {
 
  { // STAGE 0: Parse command line arguments
    std::unordered_map<std::string, std::string> args;
 
    for (int i = 1; i < argc; ++i) {
      std::string arg = argv[i];
      if (arg[0] == '-') {
        if (arg == "-h") {
          printHelp();
          return 0;
        }
        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;
      }
    }
 
    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("-g"))
      solver_face_demographic = args["-g"];
    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");
    std::cout << "Probe image: " << image_probe << std::endl;
    std::cout << "Face detection solver: " << solver_face_detect << std::endl;
    std::cout << "Face landmarks solver: " << solver_face_landmarks << std::endl;
    std::cout << "Face demographic attributes solver: " << solver_face_demographic
              << std::endl;
    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 demographic_solver{};
  DEFER(sfeSolverFree(demographic_solver));
 
  { // STAGE 1: loading solvers
    utils::printFormatted("LOADING solvers");
 
    error = sfeSolverCreate(
        solver_face_detect.c_str(), SOLVER_PARAMETERS.data(),
        SOLVER_PARAMETERS.size(), &detector_solver);
    utils::checkError(error);
 
    error = sfeSolverCreate(
        solver_face_landmarks.c_str(), SOLVER_PARAMETERS.data(),
        SOLVER_PARAMETERS.size(), &landmarks_solver);
    utils::checkError(error);
 
    error = sfeSolverCreate(
        solver_face_demographic.c_str(), SOLVER_PARAMETERS.data(),
        SOLVER_PARAMETERS.size(), &demographic_solver);
    utils::checkError(error);
  }
 
  SFEImage image{};
  DEFER(sfeImageFree(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);
  }
 
  SFEDetection detected_face = {};
  { // STAGE 3: Detect face in the image
    size_t detection_count = 1;
    error = sfeDetect(detector_solver, 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
    error = sfeFaceLandmarks(landmarks_solver, image, &detected_face,
                             landmarks.data());
    utils::checkError(error);
  }
 
  SFEFaceDemographicAttributes attributes{};
  { // STAGE 5: Demographic attributes
    utils::printFormatted("FACE DEMOGRAPHIC ATTRIBUTES");
    error = sfeFaceDemographicAttributes(demographic_solver, image,
                                         landmarks.data(), &attributes);
    utils::checkError(error);
  }
 
  { // STAGE 6: Print demographic attributes
    std::cout << "Demographic attributes:" << std::endl;
    std::cout << "  Age: " << std::fixed << std::setprecision(1) << attributes.age
              << " years" << std::endl;
    std::cout << "  Gender score: " << std::setprecision(2) << attributes.gender
              << " (" << (attributes.gender > 0.0f ? "female" : "male") << ")"
              << std::endl;
  }
 
  utils::printFormatted("FINISHED");
}

◆ printHelp()

void printHelp ( )

Definition at line 33 of file example_face_demographic_attributes.cpp.

                 {
  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 << "-g: Path to demographic attributes 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;
}