mirror of
https://github.com/deepinsight/insightface.git
synced 2025-12-30 08:02:27 +00:00
278 lines
10 KiB
C
278 lines
10 KiB
C
/**
|
|
* Created by Jingyu Yan
|
|
* @date 2024-10-01
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <inspireface.h>
|
|
|
|
int main(int argc, char* argv[]) {
|
|
HResult ret;
|
|
const char* packPath;
|
|
const char* sourcePath;
|
|
int rotation;
|
|
HFRotation rotation_enum;
|
|
HOption option;
|
|
HFDetectMode detMode;
|
|
HInt32 maxDetectNum;
|
|
HInt32 detectPixelLevel;
|
|
HFSession session;
|
|
HFImageBitmap image;
|
|
HFImageStream imageHandle;
|
|
HFMultipleFaceData multipleFaceData;
|
|
int faceNum;
|
|
HFImageBitmap drawImage;
|
|
HFImageBitmapData data;
|
|
int index;
|
|
HFFaceMaskConfidence maskConfidence;
|
|
HFFaceQualityConfidence qualityConfidence;
|
|
HOption pipelineOption;
|
|
HFFaceDetectPixelList pixelLevels;
|
|
HFFaceEmotionResult faceEmotionResult;
|
|
|
|
/* Check whether the number of parameters is correct */
|
|
if (argc < 3 || argc > 4) {
|
|
HFLogPrint(HF_LOG_ERROR, "Usage: %s <pack_path> <source_path> [rotation]", argv[0]);
|
|
return 1;
|
|
}
|
|
|
|
packPath = argv[1];
|
|
sourcePath = argv[2];
|
|
rotation = 0;
|
|
|
|
/* If rotation is provided, check and set the value */
|
|
if (argc == 4) {
|
|
rotation = atoi(argv[3]);
|
|
if (rotation != 0 && rotation != 90 && rotation != 180 && rotation != 270) {
|
|
HFLogPrint(HF_LOG_ERROR, "Invalid rotation value. Allowed values are 0, 90, 180, 270.");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/* Set rotation based on input parameter */
|
|
switch (rotation) {
|
|
case 90:
|
|
rotation_enum = HF_CAMERA_ROTATION_90;
|
|
break;
|
|
case 180:
|
|
rotation_enum = HF_CAMERA_ROTATION_180;
|
|
break;
|
|
case 270:
|
|
rotation_enum = HF_CAMERA_ROTATION_270;
|
|
break;
|
|
case 0:
|
|
default:
|
|
rotation_enum = HF_CAMERA_ROTATION_0;
|
|
break;
|
|
}
|
|
|
|
HFLogPrint(HF_LOG_INFO, "Pack file Path: %s", packPath);
|
|
HFLogPrint(HF_LOG_INFO, "Source file Path: %s", sourcePath);
|
|
HFLogPrint(HF_LOG_INFO, "Rotation: %d", rotation);
|
|
|
|
HFSetLogLevel(HF_LOG_DEBUG);
|
|
|
|
/* The resource file must be loaded before it can be used */
|
|
ret = HFLaunchInspireFace(packPath);
|
|
if (ret != HSUCCEED) {
|
|
HFLogPrint(HF_LOG_ERROR, "Load Resource error: %d", ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = HFQuerySupportedPixelLevelsForFaceDetection(&pixelLevels);
|
|
if (ret != HSUCCEED) {
|
|
HFLogPrint(HF_LOG_ERROR, "HFQuerySupportedPixelLevelsForFaceDetection error: %d", ret);
|
|
return ret;
|
|
}
|
|
HFLogPrint(HF_LOG_INFO, "Supported pixel levels for face detection: %d", pixelLevels.size);
|
|
for (int i = 0; i < pixelLevels.size; i++) {
|
|
HFLogPrint(HF_LOG_INFO, "Supported pixel level %d: %d", i + 1, pixelLevels.pixel_level[i]);
|
|
}
|
|
|
|
/* Enable the functions in the pipeline: mask detection, live detection, and face quality
|
|
* detection */
|
|
option = HF_ENABLE_QUALITY | HF_ENABLE_MASK_DETECT | HF_ENABLE_LIVENESS | HF_ENABLE_FACE_EMOTION;
|
|
/* Non-video or frame sequence mode uses IMAGE-MODE, which is always face detection without
|
|
* tracking */
|
|
detMode = HF_DETECT_MODE_LIGHT_TRACK;
|
|
/* Maximum number of faces detected */
|
|
maxDetectNum = 20;
|
|
/* Face detection image input level */
|
|
detectPixelLevel = 320;
|
|
/* Handle of the current face SDK algorithm context */
|
|
session = NULL;
|
|
ret = HFCreateInspireFaceSessionOptional(option, detMode, maxDetectNum, detectPixelLevel, -1, &session);
|
|
if (ret != HSUCCEED) {
|
|
HFLogPrint(HF_LOG_ERROR, "Create FaceContext error: %d", ret);
|
|
return ret;
|
|
}
|
|
|
|
HFSessionSetTrackPreviewSize(session, detectPixelLevel);
|
|
HFSessionSetFilterMinimumFacePixelSize(session, 4);
|
|
|
|
/* Load a image */
|
|
ret = HFCreateImageBitmapFromFilePath(sourcePath, 3, &image);
|
|
if (ret != HSUCCEED) {
|
|
HFLogPrint(HF_LOG_ERROR, "The source entered is not a picture or read error.");
|
|
return ret;
|
|
}
|
|
/* Prepare an image parameter structure for configuration */
|
|
ret = HFCreateImageStreamFromImageBitmap(image, rotation_enum, &imageHandle);
|
|
if (ret != HSUCCEED) {
|
|
HFLogPrint(HF_LOG_ERROR, "Create ImageStream error: %d", ret);
|
|
return ret;
|
|
}
|
|
|
|
/* Execute HF_FaceContextRunFaceTrack captures face information in an image */
|
|
ret = HFExecuteFaceTrack(session, imageHandle, &multipleFaceData);
|
|
if (ret != HSUCCEED) {
|
|
HFLogPrint(HF_LOG_ERROR, "Execute HFExecuteFaceTrack error: %d", ret);
|
|
return ret;
|
|
}
|
|
|
|
/* Print the number of faces detected */
|
|
faceNum = multipleFaceData.detectedNum;
|
|
HFLogPrint(HF_LOG_INFO, "Num of face: %d", faceNum);
|
|
|
|
/* Copy a new image to draw */
|
|
ret = HFImageBitmapCopy(image, &drawImage);
|
|
if (ret != HSUCCEED) {
|
|
HFLogPrint(HF_LOG_ERROR, "Copy ImageBitmap error: %d", ret);
|
|
return ret;
|
|
}
|
|
ret = HFImageBitmapGetData(drawImage, &data);
|
|
if (ret != HSUCCEED) {
|
|
HFLogPrint(HF_LOG_ERROR, "Get ImageBitmap data error: %d", ret);
|
|
return ret;
|
|
}
|
|
for (index = 0; index < faceNum; ++index) {
|
|
HInt32 numOfLmk;
|
|
HPoint2f* denseLandmarkPoints;
|
|
HPoint2f fiveKeyPoints[5];
|
|
float area;
|
|
size_t i;
|
|
|
|
HFLogPrint(HF_LOG_INFO, "========================================");
|
|
HFLogPrint(HF_LOG_INFO, "Token size: %d", multipleFaceData.tokens[index].size);
|
|
HFLogPrint(HF_LOG_INFO, "Process face index: %d", index);
|
|
HFLogPrint(HF_LOG_INFO, "DetConfidence: %f", multipleFaceData.detConfidence[index]);
|
|
HFLogPrint(HF_LOG_INFO, "TrackCount: %d", multipleFaceData.trackCounts[index]);
|
|
|
|
HFImageBitmapDrawRect(drawImage, multipleFaceData.rects[index], (HColor){0, 100, 255}, 4);
|
|
|
|
/* Get the number of dense landmark points */
|
|
HFGetNumOfFaceDenseLandmark(&numOfLmk);
|
|
denseLandmarkPoints = (HPoint2f*)malloc(sizeof(HPoint2f) * numOfLmk);
|
|
if (denseLandmarkPoints == NULL) {
|
|
HFLogPrint(HF_LOG_ERROR, "Memory allocation failed!");
|
|
return -1;
|
|
}
|
|
|
|
ret = HFGetFaceDenseLandmarkFromFaceToken(multipleFaceData.tokens[index], denseLandmarkPoints, numOfLmk);
|
|
if (ret != HSUCCEED) {
|
|
free(denseLandmarkPoints);
|
|
HFLogPrint(HF_LOG_ERROR, "HFGetFaceDenseLandmarkFromFaceToken error!!");
|
|
return -1;
|
|
}
|
|
|
|
/* Draw dense landmark points */
|
|
for (i = 0; i < numOfLmk; i++) {
|
|
HFImageBitmapDrawCircleF(drawImage,
|
|
(HPoint2f){denseLandmarkPoints[i].x, denseLandmarkPoints[i].y},
|
|
0,
|
|
(HColor){100, 100, 0},
|
|
2);
|
|
}
|
|
free(denseLandmarkPoints);
|
|
|
|
HFaceRect rt = multipleFaceData.rects[index];
|
|
area = ((float)(rt.height * rt.width)) / (data.width * data.height);
|
|
HFLogPrint(HF_LOG_INFO, "area: %f", area);
|
|
|
|
ret = HFGetFaceFiveKeyPointsFromFaceToken(multipleFaceData.tokens[index], fiveKeyPoints, 5);
|
|
if (ret != HSUCCEED) {
|
|
HFLogPrint(HF_LOG_ERROR, "HFGetFaceFiveKeyPointsFromFaceToken error!!");
|
|
return -1;
|
|
}
|
|
for (i = 0; i < 5; i++) {
|
|
HFImageBitmapDrawCircleF(drawImage, (HPoint2f){fiveKeyPoints[i].x, fiveKeyPoints[i].y}, 0, (HColor){0, 0, 232}, 2);
|
|
}
|
|
}
|
|
HFImageBitmapWriteToFile(drawImage, "draw_detected.jpg");
|
|
HFLogPrint(HF_LOG_WARN, "Write to file success: %s", "draw_detected.jpg");
|
|
|
|
/* Run pipeline function */
|
|
/* Select the pipeline function that you want to execute, provided that it is already enabled
|
|
* when FaceContext is created! */
|
|
pipelineOption = HF_ENABLE_QUALITY | HF_ENABLE_MASK_DETECT | HF_ENABLE_LIVENESS | HF_ENABLE_FACE_EMOTION;
|
|
/* In this loop, all faces are processed */
|
|
ret = HFMultipleFacePipelineProcessOptional(session, imageHandle, &multipleFaceData, pipelineOption);
|
|
if (ret != HSUCCEED) {
|
|
HFLogPrint(HF_LOG_ERROR, "Execute Pipeline error: %d", ret);
|
|
return ret;
|
|
}
|
|
|
|
/* Get mask detection results from the pipeline cache */
|
|
ret = HFGetFaceMaskConfidence(session, &maskConfidence);
|
|
if (ret != HSUCCEED) {
|
|
HFLogPrint(HF_LOG_ERROR, "Get mask detect result error: %d", ret);
|
|
return -1;
|
|
}
|
|
|
|
/* Get face quality results from the pipeline cache */
|
|
ret = HFGetFaceQualityConfidence(session, &qualityConfidence);
|
|
if (ret != HSUCCEED) {
|
|
HFLogPrint(HF_LOG_ERROR, "Get face quality result error: %d", ret);
|
|
return -1;
|
|
}
|
|
|
|
ret = HFGetFaceEmotionResult(session, &faceEmotionResult);
|
|
if (ret != HSUCCEED) {
|
|
HFLogPrint(HF_LOG_ERROR, "Get face emotion result error: %d", ret);
|
|
return -1;
|
|
}
|
|
|
|
for (index = 0; index < faceNum; ++index) {
|
|
HFLogPrint(HF_LOG_INFO, "========================================");
|
|
HFLogPrint(HF_LOG_INFO, "Process face index from pipeline: %d", index);
|
|
HFLogPrint(HF_LOG_INFO, "Mask detect result: %f", maskConfidence.confidence[index]);
|
|
HFLogPrint(HF_LOG_INFO, "Quality predict result: %f", qualityConfidence.confidence[index]);
|
|
HFLogPrint(HF_LOG_INFO, "Emotion result: %d", faceEmotionResult.emotion[index]);
|
|
/* We set the threshold of wearing a mask as 0.85. If it exceeds the threshold, it will be
|
|
* judged as wearing a mask. The threshold can be adjusted according to the scene */
|
|
if (maskConfidence.confidence[index] > 0.85) {
|
|
HFLogPrint(HF_LOG_INFO, "Mask");
|
|
} else {
|
|
HFLogPrint(HF_LOG_INFO, "Non Mask");
|
|
}
|
|
}
|
|
|
|
ret = HFReleaseImageStream(imageHandle);
|
|
if (ret != HSUCCEED) {
|
|
HFLogPrint(HF_LOG_ERROR, "Release image stream error: %d", ret);
|
|
}
|
|
/* The memory must be freed at the end of the program */
|
|
ret = HFReleaseInspireFaceSession(session);
|
|
if (ret != HSUCCEED) {
|
|
HFLogPrint(HF_LOG_ERROR, "Release session error: %d", ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = HFReleaseImageBitmap(image);
|
|
if (ret != HSUCCEED) {
|
|
HFLogPrint(HF_LOG_ERROR, "Release image bitmap error: %d", ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = HFReleaseImageBitmap(drawImage);
|
|
if (ret != HSUCCEED) {
|
|
HFLogPrint(HF_LOG_ERROR, "Release draw image bitmap error: %d", ret);
|
|
return ret;
|
|
}
|
|
|
|
HFLogPrint(HF_LOG_INFO, "");
|
|
HFDeBugShowResourceStatistics();
|
|
|
|
return 0;
|
|
}
|