3553 lines
142 KiB
C++
3553 lines
142 KiB
C++
#include "ANSFR.h"
|
||
#include <opencv2/imgcodecs.hpp>
|
||
#include "ANSOVFaceDetector.h"
|
||
#include "SCRFDFaceDetector.h"
|
||
#include "ANSFaceRecognizer.h"
|
||
#include <faiss/IndexIDMap.h>
|
||
#include <faiss/IndexFlat.h>
|
||
#include <boost/uuid/uuid.hpp>
|
||
#include <boost/uuid/uuid_generators.hpp>
|
||
#include <boost/uuid/uuid_io.hpp>
|
||
#include <json.hpp>
|
||
|
||
// Add this at the top of your header or before the function
|
||
//#define DEBUG_TIME
|
||
|
||
#ifdef DEBUG_TIME
|
||
#define TIME_POINT auto
|
||
#define START_TIMER(name) auto timer_##name = std::chrono::high_resolution_clock::now()
|
||
#define END_TIMER(name, label) \
|
||
do { \
|
||
auto timer_##name##_end = std::chrono::high_resolution_clock::now(); \
|
||
auto duration_us = std::chrono::duration_cast<std::chrono::microseconds>(timer_##name##_end - timer_##name).count(); \
|
||
std::cout << label << ": " << (duration_us / 1000.0) << " ms" << std::endl; \
|
||
} while(0)
|
||
#define END_TIMER_STORE(name, var) \
|
||
do { \
|
||
auto timer_##name##_end = std::chrono::high_resolution_clock::now(); \
|
||
var = std::chrono::duration_cast<std::chrono::microseconds>(timer_##name##_end - timer_##name).count(); \
|
||
} while(0)
|
||
#else
|
||
#define START_TIMER(name)
|
||
#define END_TIMER(name, label)
|
||
#define END_TIMER_STORE(name, var)
|
||
#endif
|
||
|
||
static bool ansfrLicenceValid = false;
|
||
// Global once_flag to protect license checking
|
||
static std::once_flag ansfrLicenseOnceFlag;
|
||
namespace ANSCENTER {
|
||
std::vector<FaceResultObject> FaceChecker::UniqueFaces(const std::vector<FaceResultObject>& faces) {
|
||
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
||
try{
|
||
std::unordered_map<std::string, FaceResultObject> uniqueFacesMap;
|
||
for (const auto& face : faces) {
|
||
std::string key = face.userId + "_" + face.userName + "_" + face.cameraId;
|
||
|
||
// If the face with the same userId, userName, and cameraId is not in the map, add it
|
||
if (uniqueFacesMap.find(key) == uniqueFacesMap.end()) {
|
||
uniqueFacesMap[key] = face;
|
||
}
|
||
else {
|
||
// If it already exists, compare confidence scores
|
||
if (face.confidence > uniqueFacesMap[key].confidence) {
|
||
// Update the map to store the face with the highest confidence
|
||
uniqueFacesMap[key] = face;
|
||
}
|
||
}
|
||
}
|
||
|
||
std::vector<FaceResultObject> resultFaces;
|
||
for (const auto& face : faces) {
|
||
std::string key = face.userId + "_" + face.userName + "_" + face.cameraId;
|
||
|
||
if (uniqueFacesMap[key].confidence == face.confidence) {
|
||
// Keep the highest confidence face
|
||
resultFaces.push_back(face);
|
||
}
|
||
else {
|
||
// Update the other duplicate face to be "Unknown"
|
||
FaceResultObject unknownFace = face;
|
||
unknownFace.userId = "0000";
|
||
unknownFace.userName = "Unknown";
|
||
resultFaces.push_back(unknownFace);
|
||
}
|
||
}
|
||
|
||
return resultFaces;
|
||
}
|
||
catch (std::exception& e) {
|
||
return std::vector<FaceResultObject>();
|
||
}
|
||
|
||
}
|
||
std::vector<FaceResultObject> FaceChecker::ValidateDetectedFaces(const std::vector<FaceResultObject>& faces) {
|
||
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
||
try {
|
||
std::vector<FaceResultObject> detectedFaces;
|
||
std::unordered_set<std::string> detectedFaceIds; // Store detected userIds for this frame
|
||
|
||
for (const auto& faceResult : faces) {
|
||
const std::string& cameraId = faceResult.cameraId;
|
||
|
||
// Create a FaceDetection object
|
||
FaceDetection detection;
|
||
detection.faceObject = faceResult;
|
||
detection.faceConfLevel = 1;
|
||
|
||
// Get or create frame buffer for this camera
|
||
auto& frameBuffer = frameBufferMap[cameraId];
|
||
bool found = false;
|
||
|
||
// If the face is already in the buffer, increase the confidence level and update the face in buffer
|
||
for (auto& frame : frameBuffer) {
|
||
for (auto& detectionInBuffer : frame) {
|
||
if ((detectionInBuffer.faceObject.userId == detection.faceObject.userId) &&
|
||
(detectionInBuffer.faceObject.userName == detection.faceObject.userName) &&
|
||
(detectionInBuffer.faceObject.cameraId == detection.faceObject.cameraId) &&
|
||
(detection.faceObject.confidence > minScore))
|
||
{
|
||
// Found: Increase confidence & update face info
|
||
detectionInBuffer.faceConfLevel += 1;
|
||
if (detectionInBuffer.faceConfLevel >= MAX_FACE_CHECKER_FRAMES) detectionInBuffer.faceConfLevel = MAX_FACE_CHECKER_FRAMES;
|
||
detectionInBuffer.faceObject = detection.faceObject;
|
||
detection.faceConfLevel = detectionInBuffer.faceConfLevel; // Sync confidence level
|
||
found = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Store detected faceId to avoid multiple decrements later
|
||
detectedFaceIds.insert(detection.faceObject.userId);
|
||
|
||
// If face not found in the buffer, add it (except for unknown faces)
|
||
if (!found && detection.faceObject.userId != "0000") {
|
||
frameBuffer.push_back({ detection });
|
||
}
|
||
|
||
// Add face to the detected list
|
||
if (detection.faceConfLevel >= FACE_CONFIDENT_LEVEL) {
|
||
detectedFaces.push_back(detection.faceObject);
|
||
}
|
||
else {
|
||
FaceResultObject unknownFace = detection.faceObject;
|
||
unknownFace.userId = "0000";
|
||
unknownFace.userName = "Unknown";
|
||
detectedFaces.push_back(unknownFace);
|
||
}
|
||
}
|
||
|
||
// **Reduce confidence level for all faces in buffer ONCE if they were not detected**
|
||
auto& frameBuffer = frameBufferMap[faces.empty() ? "" : faces[0].cameraId]; // Ensure buffer exists
|
||
for (auto& frame : frameBuffer) {
|
||
for (auto& detectionInBuffer : frame) {
|
||
if (detectedFaceIds.find(detectionInBuffer.faceObject.userId) == detectedFaceIds.end()) {
|
||
if (detectionInBuffer.faceConfLevel > 0) {
|
||
detectionInBuffer.faceConfLevel--; // Safe decrement
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Remove faces in buffer if their confidence level is less than 0
|
||
for (auto& frame : frameBuffer) {
|
||
frame.erase(std::remove_if(frame.begin(), frame.end(),
|
||
[](const FaceDetection& detection) {
|
||
return detection.faceConfLevel < 0;
|
||
}),
|
||
frame.end());
|
||
}
|
||
|
||
// Remove empty frames from buffer
|
||
frameBuffer.erase(std::remove_if(frameBuffer.begin(), frameBuffer.end(),
|
||
[](const std::vector<FaceDetection>& frame) {
|
||
return frame.empty();
|
||
}),
|
||
frameBuffer.end());
|
||
|
||
// If buffer reaches max size, remove the oldest frame
|
||
if (frameBuffer.size() >= maxFrames) {
|
||
frameBuffer.erase(frameBuffer.begin());
|
||
}
|
||
|
||
return UniqueFaces(detectedFaces);
|
||
}
|
||
catch (std::exception& e) {
|
||
return std::vector<FaceResultObject>();
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// Start Facial Recognition class
|
||
/// </summary>
|
||
static void VerifyGlobalANSFRLicense(const std::string& licenseKey) {
|
||
try {
|
||
ansfrLicenceValid = ANSCENTER::ANSLicenseHelper::LicenseVerification(licenseKey, 1004, "ANSFR");//Default productId=1004
|
||
if (!ansfrLicenceValid) { // we also support ANSTS license
|
||
ansfrLicenceValid = ANSCENTER::ANSLicenseHelper::LicenseVerification(licenseKey, 1003, "ANSVIS");//Default productId=1003 (ANSVIS)
|
||
}
|
||
}
|
||
catch (std::exception& e) {
|
||
ansfrLicenceValid = false;
|
||
}
|
||
}
|
||
void ANSFacialRecognition::CheckLicense() {
|
||
try {
|
||
// Check once globally
|
||
std::call_once(ansfrLicenseOnceFlag, [this]() {
|
||
VerifyGlobalANSFRLicense(_licenseKey);
|
||
});
|
||
|
||
// Update this instance's local license flag
|
||
_licenseValid = ansfrLicenceValid;
|
||
}
|
||
catch (const std::exception& e) {
|
||
this->_logger.LogFatal("ANSODBase::CheckLicense. Error:", e.what(), __FILE__, __LINE__);
|
||
}
|
||
}
|
||
ANSFacialRecognition::ANSFacialRecognition()
|
||
: core(std::make_shared<ov::Core>())
|
||
{
|
||
_licenseValid = false;
|
||
|
||
}
|
||
int ANSFacialRecognition::Initialize(
|
||
const std::string& licenseKey,
|
||
const std::string& configFile,
|
||
const std::string& databaseFilePath,
|
||
const std::string& recognizerFilePath,
|
||
const std::string& detectorFilePath,
|
||
int precisionType,
|
||
float knownPersonThreshold,
|
||
bool enableAgeGender,
|
||
bool enableFaceEmotions,
|
||
bool enableHeadPose,
|
||
int minFaceSize,
|
||
float faceDetectorScoreThreshold,
|
||
bool faceLiveness,
|
||
bool antiSpoofing)
|
||
{
|
||
try {
|
||
// Store initialization parameters
|
||
_licenseKey = licenseKey;
|
||
_detectorFilePath = detectorFilePath;
|
||
_recognizerFilePath = recognizerFilePath;
|
||
_databaseFilePath = databaseFilePath;
|
||
_precisionType = 2; // Force FP32
|
||
|
||
// Validate and set thresholds
|
||
if (faceDetectorScoreThreshold <= 0.0f || faceDetectorScoreThreshold >= 1.0f) {
|
||
_faceDetectorScoreThreshold = 0.5f;
|
||
LogThreadSafe("ANSFacialRecognition::Initialize",
|
||
"Invalid detector threshold, using default: 0.5");
|
||
}
|
||
else {
|
||
_faceDetectorScoreThreshold = faceDetectorScoreThreshold;
|
||
}
|
||
|
||
if (knownPersonThreshold <= 0.0f || knownPersonThreshold >= 1.0f) {
|
||
_config._knownPersonThreshold = 0.35f;
|
||
LogThreadSafe("ANSFacialRecognition::Initialize",
|
||
"Invalid known person threshold, using default: 0.35");
|
||
}
|
||
else {
|
||
_config._knownPersonThreshold = knownPersonThreshold;
|
||
}
|
||
|
||
// Set minimum face size
|
||
_minFaceSize = (minFaceSize > 0) ? minFaceSize : 50;
|
||
|
||
// Configure feature flags
|
||
{
|
||
std::lock_guard<std::mutex> lock(_configMutex);
|
||
|
||
_enableAgeGender = enableAgeGender;
|
||
_enableFaceEmotions = enableFaceEmotions;
|
||
_enableHeadPose = enableHeadPose;
|
||
_enableAntiSpoof = antiSpoofing;
|
||
_enableFaceliveness = faceLiveness;
|
||
_enableFaceQueue = false;
|
||
_queueSize = QUEUE_SIZE;
|
||
_faceThresholdSize = FACE_THRESHOLD_SIZE;
|
||
_removeFakeFaces = false;
|
||
}
|
||
|
||
// Validate license
|
||
CheckLicense();
|
||
if (!_licenseValid) {
|
||
LogThreadSafe("ANSFacialRecognition::Initialize",
|
||
"Invalid license key");
|
||
return 0;
|
||
}
|
||
|
||
// Detect hardware
|
||
#ifdef CPU_MODE
|
||
engineType = EngineType::CPU;
|
||
#else
|
||
engineType = ANSLicenseHelper::CheckHardwareInformation();
|
||
#endif
|
||
|
||
// Initialize configuration
|
||
_config._databasePath = _databaseFilePath;
|
||
_config._recOutputDim = 512;
|
||
_config._detThresholdNMS = 0.5f;
|
||
_config._detThresholdBbox = 0.80f;
|
||
_config._videoFrameHeight = 480;
|
||
_config._videoFrameWidth = 640;
|
||
|
||
// Load config file if exists
|
||
if (FileExist(configFile)) {
|
||
if (!ANSFRHelper::LoadConfigFile(configFile, _config)) {
|
||
LogThreadSafe("ANSFacialRecognition::Initialize",
|
||
"Unable to load configuration file: " + configFile);
|
||
}
|
||
else {
|
||
// Restore database path if provided
|
||
if (!_databaseFilePath.empty()) {
|
||
_config._databasePath = _databaseFilePath;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Set model paths
|
||
if (FileExist(_detectorFilePath)) {
|
||
_config._detEngineFile = _detectorFilePath;
|
||
}
|
||
|
||
if (FileExist(_recognizerFilePath)) {
|
||
_config._recEngineFile = _recognizerFilePath;
|
||
}
|
||
|
||
// Validate database path
|
||
if (_config._databasePath.empty()) {
|
||
LogThreadSafe("ANSFacialRecognition::Initialize",
|
||
"Invalid database path: empty");
|
||
return -1;
|
||
}
|
||
|
||
// Create database folders
|
||
std::string faceDatabaseFolder = GetParentFolder(_config._databasePath);
|
||
if (!FolderExist(faceDatabaseFolder)) {
|
||
std::filesystem::create_directories(faceDatabaseFolder);
|
||
}
|
||
|
||
_config._gen_imgSource = CreateFilePath(faceDatabaseFolder, "data");
|
||
if (!FolderExist(_config._gen_imgSource)) {
|
||
std::filesystem::create_directories(_config._gen_imgSource);
|
||
}
|
||
|
||
// Initialize database
|
||
{
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
|
||
if (!_db->Initialize(_config._databasePath, _config._recOutputDim, _config._gen_imgSource)) {
|
||
LogThreadSafe("ANSFacialRecognition::Initialize",
|
||
"Failed to initialize database: " + _config._databasePath);
|
||
return -2;
|
||
}
|
||
|
||
_userDict = _db->GetUserDict();
|
||
}
|
||
|
||
// Validate recognizer model
|
||
if (!FileExist(_config._recEngineFile)) {
|
||
LogThreadSafe("ANSFacialRecognition::Initialize",
|
||
"Recognizer model not found: " + _config._recEngineFile);
|
||
return -3;
|
||
}
|
||
|
||
// Mark as initialized
|
||
_isInitialized=true;
|
||
|
||
return 1;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::Initialize",
|
||
"Initialization failed: " + std::string(e.what()));
|
||
|
||
_isInitialized=false;
|
||
return -4;
|
||
}
|
||
}
|
||
|
||
bool ANSFacialRecognition::LoadEngine() {
|
||
try {
|
||
// Unload existing engine (handles its own locking)
|
||
UnloadEngine();
|
||
|
||
// Initialize core components (lock during initialization)
|
||
{
|
||
std::lock_guard<std::mutex> lock(_configMutex);
|
||
|
||
if (!InitializeDetector()) {
|
||
LogThreadSafe("ANSFacialRecognition::LoadEngine",
|
||
"Failed to initialize detector");
|
||
return false;
|
||
}
|
||
|
||
if (!InitializeRecognizer()) {
|
||
LogThreadSafe("ANSFacialRecognition::LoadEngine",
|
||
"Failed to initialize recognizer");
|
||
return false;
|
||
}
|
||
|
||
_recognizerModelFolder = _recognizer->GetModelFolder();
|
||
}
|
||
|
||
// Verify model folder exists
|
||
if (!FolderExist(_recognizerModelFolder)) {
|
||
LogThreadSafe("ANSFacialRecognition::LoadEngine",
|
||
"Model folder not found: " + _recognizerModelFolder);
|
||
return false;
|
||
}
|
||
|
||
// Configure device
|
||
std::string deviceName = GetOpenVINODevice();
|
||
|
||
if (deviceName == "NPU") {
|
||
// Configure NPU with GPU fallback
|
||
try {
|
||
core->set_property("NPU",
|
||
ov::hint::performance_mode(ov::hint::PerformanceMode::LATENCY));
|
||
core->set_property("GPU",
|
||
ov::hint::performance_mode(ov::hint::PerformanceMode::LATENCY));
|
||
core->set_property("GPU",
|
||
ov::streams::num(ov::streams::AUTO));
|
||
|
||
deviceName = "AUTO:NPU,GPU";
|
||
|
||
LogThreadSafe("ANSFacialRecognition::LoadEngine",
|
||
"Configured NPU with GPU fallback");
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::LoadEngine",
|
||
"Failed to configure NPU/GPU: " + std::string(e.what()));
|
||
// Fall back to default device
|
||
}
|
||
}
|
||
|
||
// Initialize attribute detection models
|
||
bool attributeModelsSuccess = true;
|
||
|
||
if (!InitializeAntispoofingModel(deviceName)) {
|
||
LogThreadSafe("ANSFacialRecognition::LoadEngine",
|
||
"Warning: Failed to initialize anti-spoofing model");
|
||
attributeModelsSuccess = false;
|
||
}
|
||
|
||
if (!InitializeAgeGenderModel(deviceName)) {
|
||
LogThreadSafe("ANSFacialRecognition::LoadEngine",
|
||
"Warning: Failed to initialize age-gender model");
|
||
attributeModelsSuccess = false;
|
||
}
|
||
|
||
if (!InitializeEmotionModel(deviceName)) {
|
||
LogThreadSafe("ANSFacialRecognition::LoadEngine",
|
||
"Warning: Failed to initialize emotion model");
|
||
attributeModelsSuccess = false;
|
||
}
|
||
|
||
if (!InitializeHeadPoseModel(deviceName)) {
|
||
LogThreadSafe("ANSFacialRecognition::LoadEngine",
|
||
"Warning: Failed to initialize head pose model");
|
||
attributeModelsSuccess = false;
|
||
}
|
||
|
||
// Reload database/embeddings
|
||
if (!Reload()) {
|
||
LogThreadSafe("ANSFacialRecognition::LoadEngine",
|
||
"Failed to reload database/embeddings");
|
||
return false;
|
||
}
|
||
|
||
// Mark as initialized
|
||
{
|
||
std::lock_guard<std::mutex> lock(_configMutex);
|
||
_isInitialized = true;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::LoadEngine", e.what());
|
||
|
||
// Mark as not initialized on failure
|
||
{
|
||
std::lock_guard<std::mutex> lock(_configMutex);
|
||
_isInitialized = false;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
}
|
||
void ANSFacialRecognition::UnloadEngine() {
|
||
try {
|
||
// Clean up detector
|
||
{
|
||
std::lock_guard<std::mutex> lock(_detectionMutex);
|
||
if (_detector) _detector.reset();
|
||
}
|
||
|
||
// Clean up recognizer
|
||
{
|
||
std::lock_guard<std::mutex> lock(_recognitionMutex);
|
||
if (_recognizer) _recognizer.reset();
|
||
}
|
||
|
||
// Clean up anti-spoofing detector
|
||
{
|
||
std::lock_guard<std::mutex> lock(_antispoofMutex);
|
||
if (_antiSpoofDetector) _antiSpoofDetector.reset();
|
||
}
|
||
|
||
// Clean up age-gender detector
|
||
{
|
||
std::lock_guard<std::mutex> lock(_ageGenderMutex);
|
||
if (_ageGenderDetector) _ageGenderDetector.reset();
|
||
}
|
||
|
||
// Clean up emotions detector
|
||
{
|
||
std::lock_guard<std::mutex> lock(_emotionsMutex);
|
||
if (_emotionsDetector) _emotionsDetector.reset();
|
||
}
|
||
|
||
// Clean up head pose detector
|
||
{
|
||
std::lock_guard<std::mutex> lock(_headPoseMutex);
|
||
if (_headPoseDetector) _headPoseDetector.reset();
|
||
}
|
||
|
||
// Clear user dictionary
|
||
{
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
_userDict.clear();
|
||
}
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::UnloadEngine",
|
||
"Error during unload: " + std::string(e.what()));
|
||
}
|
||
}
|
||
bool ANSFacialRecognition::Reload() {
|
||
try {
|
||
// Skip rebuild if index is already up-to-date (no mutations since last Reload).
|
||
// exchange(false) atomically reads + clears: if it was already false, nothing to do.
|
||
if (!_reloadNeeded.exchange(false)) {
|
||
LogThreadSafe("ANSFacialRecognition::Reload",
|
||
"Index already up-to-date, skipping rebuild", LogLevel::Debug);
|
||
return true;
|
||
}
|
||
|
||
// Validate initialization first (without locks)
|
||
if (!_recognizer) {
|
||
LogThreadSafe("ANSFacialRecognition::Reload",
|
||
"Recognizer not initialized");
|
||
_reloadNeeded.store(true); // Restore flag — reload still needed
|
||
return false;
|
||
}
|
||
|
||
if (!_db) {
|
||
LogThreadSafe("ANSFacialRecognition::Reload",
|
||
"Database not initialized");
|
||
_reloadNeeded.store(true); // Restore flag — reload still needed
|
||
return false;
|
||
}
|
||
|
||
// ============================================================
|
||
// PHASE 1: Build new index in temporary structures (NO INDEX LOCK)
|
||
// Inference continues unblocked using the old index.
|
||
// ============================================================
|
||
|
||
auto* concreteRecognizer = dynamic_cast<ANSFaceRecognizer*>(_recognizer.get());
|
||
if (!concreteRecognizer) {
|
||
LogThreadSafe("ANSFacialRecognition::Reload",
|
||
"Recognizer is not ANSFaceRecognizer type");
|
||
_reloadNeeded.store(true); // Restore flag — reload still needed
|
||
return false;
|
||
}
|
||
int embeddingSize = concreteRecognizer->GetEmbeddingSize();
|
||
|
||
std::unordered_map<faiss::idx_t, std::string> newFaceIdToUserId;
|
||
std::map<std::string, std::string> newUserDict;
|
||
|
||
// Read all data from database into temporaries
|
||
std::vector<float> allEmbeddings;
|
||
std::vector<faiss::idx_t> allIds;
|
||
|
||
{
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
|
||
std::vector<FaceEmbeddingRecord> records;
|
||
int rc = _db->GetAllEmbeddingRecords(records);
|
||
if (rc != 0) {
|
||
LogThreadSafe("ANSFacialRecognition::Reload",
|
||
"Failed to load embedding records from database");
|
||
_reloadNeeded.store(true); // Restore flag — reload still needed
|
||
return false;
|
||
}
|
||
|
||
// Pre-allocate for bulk GPU transfer
|
||
allEmbeddings.reserve(records.size() * embeddingSize);
|
||
allIds.reserve(records.size());
|
||
|
||
for (const auto& record : records) {
|
||
faiss::idx_t faceId = static_cast<faiss::idx_t>(record.faceId);
|
||
newFaceIdToUserId[faceId] = record.userId;
|
||
allIds.push_back(faceId);
|
||
|
||
// L2-normalize before storing (IP metric on unit vectors = cosine sim)
|
||
std::vector<float> normEmb = record.embedding;
|
||
ANSFaceRecognizer::L2NormalizeInPlace(normEmb);
|
||
allEmbeddings.insert(allEmbeddings.end(), normEmb.begin(), normEmb.end());
|
||
}
|
||
|
||
newUserDict = _db->GetUserDict();
|
||
}
|
||
|
||
// Always build FAISS index on CPU. This avoids thread-safety issues with
|
||
// FAISS GPU StandardGpuResources (not thread-safe) — Reload() can run
|
||
// concurrently with inference without sharing GPU memory pools.
|
||
// CPU FAISS search is fast enough for face databases (<5ms for 10K faces)
|
||
// and is a negligible fraction of total inference time.
|
||
auto cpuIndex = new faiss::IndexFlatIP(embeddingSize);
|
||
auto newFaissIndex = std::make_shared<faiss::IndexIDMap>(cpuIndex);
|
||
newFaissIndex->own_fields = true;
|
||
|
||
if (!allIds.empty()) {
|
||
newFaissIndex->add_with_ids(
|
||
static_cast<faiss::idx_t>(allIds.size()),
|
||
allEmbeddings.data(), allIds.data());
|
||
}
|
||
|
||
LogThreadSafe("ANSFacialRecognition::Reload",
|
||
"Built new index with " + std::to_string(newFaissIndex->ntotal) +
|
||
" embeddings, " + std::to_string(newUserDict.size()) + " users", LogLevel::Info);
|
||
|
||
// ============================================================
|
||
// PHASE 2: Atomic swap (brief exclusive lock ~microseconds)
|
||
// Inference is blocked only during this swap.
|
||
// ============================================================
|
||
{
|
||
std::unique_lock<std::shared_mutex> lock(_indexSwapMutex);
|
||
concreteRecognizer->SwapIndex(
|
||
std::move(newFaissIndex),
|
||
std::move(newFaceIdToUserId));
|
||
_userDict = std::move(newUserDict);
|
||
}
|
||
|
||
LogThreadSafe("ANSFacialRecognition::Reload",
|
||
"Index swap completed successfully", LogLevel::Info);
|
||
|
||
return true;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::Reload",
|
||
"Failed to reload: " + std::string(e.what()));
|
||
_reloadNeeded.store(true); // Restore flag — reload still needed
|
||
return false;
|
||
}
|
||
}
|
||
bool ANSFacialRecognition::UpdateUserDictionary() {
|
||
try {
|
||
// Validate database initialization first (without lock)
|
||
if (!_db) {
|
||
LogThreadSafe("ANSFacialRecognition::UpdateUserDictionary",
|
||
"Database not initialized");
|
||
return false;
|
||
}
|
||
|
||
// Load user dictionary with database lock
|
||
std::map<std::string, std::string> newUserDict;
|
||
|
||
{
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
newUserDict = _db->GetUserDict();
|
||
}
|
||
|
||
// Validate the loaded dictionary
|
||
if (newUserDict.empty()) {
|
||
LogThreadSafe("ANSFacialRecognition::UpdateUserDictionary",
|
||
"Warning: User dictionary is empty");
|
||
}
|
||
|
||
// Swap userDict under exclusive lock (same lock as Reload)
|
||
{
|
||
std::unique_lock<std::shared_mutex> lock(_indexSwapMutex);
|
||
_userDict = std::move(newUserDict);
|
||
}
|
||
return true;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::UpdateUserDictionary",
|
||
"Failed to update user dictionary: " + std::string(e.what()));
|
||
return false;
|
||
}
|
||
}
|
||
ANSFacialRecognition::~ANSFacialRecognition() noexcept {
|
||
try {
|
||
// Destroy engine and resources
|
||
Destroy();
|
||
|
||
// Clean up camera data
|
||
{
|
||
std::lock_guard<std::mutex> lock(_cameraMutex);
|
||
for (auto& [cameraId, cameraData] : _cameras) {
|
||
cameraData.clear();
|
||
}
|
||
_cameras.clear();
|
||
}
|
||
}
|
||
catch (const std::exception& e) {
|
||
// Log but don't throw from destructor
|
||
LogThreadSafe("ANSFacialRecognition::Destructor",
|
||
"Error during destruction: " + std::string(e.what()));
|
||
}
|
||
catch (...) {
|
||
// Catch all other exceptions - never throw from destructor
|
||
}
|
||
}
|
||
void ANSFacialRecognition::Destroy() {
|
||
try {
|
||
// Unload engine (handles its own locking)
|
||
UnloadEngine();
|
||
|
||
// Clean up database connection
|
||
{
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
if (_db) _db.reset();
|
||
}
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::Destroy",
|
||
"Error during cleanup: " + std::string(e.what()));
|
||
}
|
||
}
|
||
ModelConfig ANSFacialRecognition::CreateDetectorModelConfig() {
|
||
// NO LOCK NEEDED - Reading configuration values only
|
||
try {
|
||
ModelConfig config;
|
||
config.modelType = ANSCENTER::ModelType::FACEDETECT;
|
||
config.detectionType = ANSCENTER::DetectionType::FACEDETECTOR;
|
||
config.precisionType = static_cast<ANSCENTER::PrecisionType>(_precisionType);
|
||
config.autoGPUDetection = true;
|
||
config.modelMNSThreshold = _config._detThresholdNMS;
|
||
config.detectionScoreThreshold = _config._detThresholdBbox;
|
||
config.modelConfThreshold = 0.48f;
|
||
|
||
return config;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::CreateDetectorModelConfig",
|
||
"Failed to create config: " + std::string(e.what()));
|
||
return ModelConfig();
|
||
}
|
||
}
|
||
|
||
bool ANSFacialRecognition::InitializeDetector() {
|
||
try {
|
||
// Create model configuration
|
||
ModelConfig detectorConfig = CreateDetectorModelConfig();
|
||
detectorConfig.detectionScoreThreshold = _faceDetectorScoreThreshold;
|
||
|
||
// Create appropriate detector based on engine type
|
||
if (engineType == EngineType::NVIDIA_GPU) {
|
||
_detector = std::make_unique<ANSSCRFDFD>();
|
||
}
|
||
else {
|
||
_detector = std::make_unique<ANSOVFD>();
|
||
}
|
||
_detector->SetMaxSlotsPerGpu(m_maxSlotsPerGpu);
|
||
|
||
// LOCK DURING INITIALIZATION
|
||
bool initSuccess;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_detectionMutex);
|
||
|
||
std::string labelMap;
|
||
initSuccess = _detector->Initialize(
|
||
_licenseKey,
|
||
detectorConfig,
|
||
_detectorFilePath,
|
||
"",
|
||
labelMap
|
||
);
|
||
|
||
if (initSuccess) {
|
||
// Update detection threshold after initialization
|
||
initSuccess = _detector->UpdateDetectionThreshold(_faceDetectorScoreThreshold);
|
||
}
|
||
}
|
||
|
||
if (!initSuccess) {
|
||
LogThreadSafe("ANSFacialRecognition::InitializeDetector",
|
||
"Failed to initialize detector - check file path: " + _detectorFilePath);
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::InitializeDetector",
|
||
"Failed to initialize: " + std::string(e.what()));
|
||
return false;
|
||
}
|
||
}
|
||
bool ANSFacialRecognition::InitializeRecognizer() {
|
||
try {
|
||
// Create recognizer instance
|
||
_recognizer = std::make_unique<ANSFaceRecognizer>();
|
||
_recognizer->SetMaxSlotsPerGpu(m_maxSlotsPerGpu);
|
||
|
||
// Configure model
|
||
ModelConfig recognizerConfig;
|
||
recognizerConfig.modelType = ANSCENTER::ModelType::FACERECOGNIZE;
|
||
recognizerConfig.detectionType = ANSCENTER::DetectionType::FACERECOGNIZER;
|
||
recognizerConfig.precisionType = ANSCENTER::PrecisionType::FP32;
|
||
recognizerConfig.autoGPUDetection = true;
|
||
recognizerConfig.modelMNSThreshold = _config._detThresholdNMS;
|
||
recognizerConfig.detectionScoreThreshold = _config._detThresholdBbox;
|
||
recognizerConfig.modelConfThreshold = 0.48f;
|
||
recognizerConfig.unknownPersonThreshold = _config._knownPersonThreshold;
|
||
|
||
// LOCK DURING INITIALIZATION
|
||
std::string labelMap;
|
||
bool initSuccess;
|
||
|
||
{
|
||
std::lock_guard<std::mutex> lock(_recognitionMutex);
|
||
|
||
initSuccess = _recognizer->Initialize(
|
||
_licenseKey,
|
||
recognizerConfig,
|
||
_recognizerFilePath,
|
||
"",
|
||
labelMap
|
||
);
|
||
}
|
||
|
||
if (!initSuccess) {
|
||
LogThreadSafe("ANSFacialRecognition::InitializeRecognizer",
|
||
"Failed to initialize recognizer - check file path: " + _recognizerFilePath);
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::InitializeRecognizer",
|
||
"Failed to initialize: " + std::string(e.what()));
|
||
return false;
|
||
}
|
||
}
|
||
bool ANSFacialRecognition::InitializeAntispoofingModel(const std::string& deviceName) {
|
||
try {
|
||
std::string antispoofModelPath = CreateFilePath(_recognizerModelFolder, "antispoof.xml");
|
||
|
||
if (!FileExist(antispoofModelPath)) {
|
||
LogThreadSafe("ANSFacialRecognition::InitializeAntispoofingModel",
|
||
"Anti-spoofing model not found: " + antispoofModelPath);
|
||
|
||
// Disable anti-spoofing if model not available
|
||
{
|
||
std::lock_guard<std::mutex> lock(_configMutex);
|
||
_enableAntiSpoof = false;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// LOCK ONLY DURING MODEL INITIALIZATION
|
||
{
|
||
std::lock_guard<std::mutex> lock(_antispoofMutex);
|
||
|
||
// Reset existing detector
|
||
_antiSpoofDetector.reset();
|
||
|
||
// Create new detector
|
||
_antiSpoofDetector = std::make_unique<AntispoofingClassifier>(antispoofModelPath, true);
|
||
|
||
// Compile model for target device
|
||
ov::CompiledModel compiledModel = core->compile_model(
|
||
_antiSpoofDetector->read(*core),
|
||
deviceName
|
||
);
|
||
|
||
// Create inference request
|
||
_antiSpoofDetector->request = compiledModel.create_infer_request();
|
||
_antiSpoofDetector->inTensor = _antiSpoofDetector->request.get_input_tensor();
|
||
_antiSpoofDetector->inTensor.set_shape(_antiSpoofDetector->inShape);
|
||
}
|
||
return true;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::InitializeAntispoofingModel",
|
||
"Failed to initialize: " + std::string(e.what()));
|
||
|
||
// Disable anti-spoofing on failure
|
||
{
|
||
std::lock_guard<std::mutex> lock(_configMutex);
|
||
_enableAntiSpoof = false;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
}
|
||
bool ANSFacialRecognition::InitializeAgeGenderModel(const std::string& deviceName) {
|
||
try {
|
||
std::string ageGenderModelPath = CreateFilePath(_recognizerModelFolder, "agegender.xml");
|
||
|
||
if (!FileExist(ageGenderModelPath)) {
|
||
LogThreadSafe("ANSFacialRecognition::InitializeAgeGenderModel",
|
||
"Age-gender model not found: " + ageGenderModelPath);
|
||
|
||
// Disable age-gender detection if model not available
|
||
{
|
||
std::lock_guard<std::mutex> lock(_configMutex);
|
||
_enableAgeGender = false;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// LOCK ONLY DURING MODEL INITIALIZATION
|
||
{
|
||
std::lock_guard<std::mutex> lock(_ageGenderMutex);
|
||
|
||
// Reset existing detector
|
||
_ageGenderDetector.reset();
|
||
|
||
// Create new detector
|
||
_ageGenderDetector = std::make_unique<AgeGenderDetection>(ageGenderModelPath, true);
|
||
|
||
// Compile model for target device
|
||
ov::CompiledModel compiledModel = core->compile_model(
|
||
_ageGenderDetector->read(*core),
|
||
deviceName
|
||
);
|
||
|
||
// Create inference request
|
||
_ageGenderDetector->request = compiledModel.create_infer_request();
|
||
_ageGenderDetector->inTensor = _ageGenderDetector->request.get_input_tensor();
|
||
_ageGenderDetector->inTensor.set_shape(_ageGenderDetector->inShape);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::InitializeAgeGenderModel",
|
||
"Failed to initialize: " + std::string(e.what()));
|
||
// Disable age-gender detection on failure
|
||
{
|
||
std::lock_guard<std::mutex> lock(_configMutex);
|
||
_enableAgeGender = false;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
}
|
||
bool ANSFacialRecognition::InitializeEmotionModel(const std::string& deviceName) {
|
||
try {
|
||
std::string emotionModelPath = CreateFilePath(_recognizerModelFolder, "emotionsrecognition.xml");
|
||
|
||
if (!FileExist(emotionModelPath)) {
|
||
LogThreadSafe("ANSFacialRecognition::InitializeEmotionModel",
|
||
"Emotion model not found: " + emotionModelPath);
|
||
|
||
// Disable emotion detection if model not available
|
||
{
|
||
std::lock_guard<std::mutex> lock(_configMutex);
|
||
_enableFaceEmotions = false;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// LOCK ONLY DURING MODEL INITIALIZATION
|
||
{
|
||
std::lock_guard<std::mutex> lock(_emotionsMutex);
|
||
|
||
// Reset existing detector
|
||
_emotionsDetector.reset();
|
||
|
||
// Create new detector
|
||
_emotionsDetector = std::make_unique<EmotionsDetection>(emotionModelPath, true);
|
||
|
||
// Compile model for target device
|
||
ov::CompiledModel compiledModel = core->compile_model(
|
||
_emotionsDetector->read(*core),
|
||
deviceName
|
||
);
|
||
|
||
// Create inference request
|
||
_emotionsDetector->request = compiledModel.create_infer_request();
|
||
_emotionsDetector->inTensor = _emotionsDetector->request.get_input_tensor();
|
||
_emotionsDetector->inTensor.set_shape(_emotionsDetector->inShape);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::InitializeEmotionModel",
|
||
"Failed to initialize: " + std::string(e.what()));
|
||
|
||
// Disable emotion detection on failure
|
||
{
|
||
std::lock_guard<std::mutex> lock(_configMutex);
|
||
_enableFaceEmotions = false;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
}
|
||
bool ANSFacialRecognition::InitializeHeadPoseModel(const std::string& deviceName) {
|
||
try {
|
||
std::string headPoseModelPath = CreateFilePath(_recognizerModelFolder, "headpose.xml");
|
||
|
||
if (!FileExist(headPoseModelPath)) {
|
||
LogThreadSafe("ANSFacialRecognition::InitializeHeadPoseModel",
|
||
"Head pose model not found: " + headPoseModelPath);
|
||
|
||
// Disable head pose detection if model not available
|
||
{
|
||
std::lock_guard<std::mutex> lock(_configMutex);
|
||
_enableHeadPose = false;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// LOCK ONLY DURING MODEL INITIALIZATION
|
||
{
|
||
std::lock_guard<std::mutex> lock(_headPoseMutex);
|
||
|
||
// Reset existing detector
|
||
_headPoseDetector.reset();
|
||
|
||
// Create new detector
|
||
_headPoseDetector = std::make_unique<HeadPoseDetection>(headPoseModelPath, true);
|
||
|
||
// Compile model for target device
|
||
ov::CompiledModel compiledModel = core->compile_model(
|
||
_headPoseDetector->read(*core),
|
||
deviceName
|
||
);
|
||
|
||
// Create inference request
|
||
_headPoseDetector->request = compiledModel.create_infer_request();
|
||
_headPoseDetector->inTensor = _headPoseDetector->request.get_input_tensor();
|
||
_headPoseDetector->inTensor.set_shape(_headPoseDetector->inShape);
|
||
}
|
||
return true;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::InitializeHeadPoseModel",
|
||
"Failed to initialize: " + std::string(e.what()));
|
||
|
||
// Disable head pose on failure
|
||
{
|
||
std::lock_guard<std::mutex> lock(_configMutex);
|
||
_enableHeadPose = false;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
}
|
||
|
||
bool ANSFacialRecognition::UpdateParameters(
|
||
float knownPersonThreshold,
|
||
bool enableAgeGender,
|
||
bool enableFaceEmotions,
|
||
bool enableHeadPose,
|
||
int minFaceSize,
|
||
float faceDetectorScoreThreshold,
|
||
bool faceLiveness,
|
||
bool antiSpoof,
|
||
bool removeFakeFace)
|
||
{
|
||
// Validate inputs
|
||
if (knownPersonThreshold < 0.0f || knownPersonThreshold > 1.0f) {
|
||
LogThreadSafe("ANSFacialRecognition::UpdateParameters",
|
||
"Invalid known person threshold: " + std::to_string(knownPersonThreshold) +
|
||
" (valid range: 0.0-1.0)");
|
||
return false;
|
||
}
|
||
|
||
if (faceDetectorScoreThreshold < 0.0f || faceDetectorScoreThreshold > 1.0f) {
|
||
LogThreadSafe("ANSFacialRecognition::UpdateParameters",
|
||
"Invalid detector threshold: " + std::to_string(faceDetectorScoreThreshold) +
|
||
" (valid range: 0.0-1.0)");
|
||
return false;
|
||
}
|
||
|
||
try {
|
||
// Update configuration (with config lock)
|
||
{
|
||
std::lock_guard<std::mutex> lock(_configMutex);
|
||
|
||
_enableAgeGender = enableAgeGender;
|
||
_enableFaceEmotions = enableFaceEmotions;
|
||
_enableHeadPose = enableHeadPose;
|
||
_enableAntiSpoof = antiSpoof;
|
||
_enableFaceliveness = faceLiveness;
|
||
_removeFakeFaces = removeFakeFace;
|
||
// Enforce minimum face size
|
||
_minFaceSize = (minFaceSize > 0) ? minFaceSize : 30;
|
||
}
|
||
// Update recognizer (with recognition lock)
|
||
bool recognizerUpdateResult = false;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_recognitionMutex);
|
||
|
||
if (_recognizer) {
|
||
recognizerUpdateResult = _recognizer->UpdateParamater(knownPersonThreshold);
|
||
|
||
if (recognizerUpdateResult) {
|
||
_config._knownPersonThreshold = knownPersonThreshold;
|
||
}
|
||
else {
|
||
LogThreadSafe("ANSFacialRecognition::UpdateParameters",
|
||
"Failed to update face recognizer with threshold " +
|
||
std::to_string(knownPersonThreshold));
|
||
}
|
||
}
|
||
else {
|
||
LogThreadSafe("ANSFacialRecognition::UpdateParameters",
|
||
"Recognizer not initialized");
|
||
}
|
||
}
|
||
|
||
// Update detector (with detection lock)
|
||
bool detectorUpdateResult = true;
|
||
if (faceDetectorScoreThreshold > 0.0f) {
|
||
std::lock_guard<std::mutex> lock(_detectionMutex);
|
||
|
||
if (_detector) {
|
||
detectorUpdateResult = _detector->UpdateDetectionThreshold(faceDetectorScoreThreshold);
|
||
|
||
if (detectorUpdateResult) {
|
||
_faceDetectorScoreThreshold = faceDetectorScoreThreshold;
|
||
}
|
||
else {
|
||
LogThreadSafe("ANSFacialRecognition::UpdateParameters",
|
||
"Failed to update face detector with threshold " +
|
||
std::to_string(faceDetectorScoreThreshold));
|
||
}
|
||
}
|
||
else {
|
||
LogThreadSafe("ANSFacialRecognition::UpdateParameters",
|
||
"Detector not initialized");
|
||
detectorUpdateResult = false;
|
||
}
|
||
}
|
||
|
||
return recognizerUpdateResult && detectorUpdateResult;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::UpdateParameters", e.what());
|
||
return false;
|
||
}
|
||
}
|
||
bool ANSFacialRecognition::GetFaceParameters(
|
||
float& knownPersonThreshold,
|
||
bool& enableAgeGender,
|
||
bool& enableFaceEmotions,
|
||
bool& enableHeadPose,
|
||
int& minFaceSize,
|
||
float& faceDetectorScoreThreshold,
|
||
bool& faceLiveness,
|
||
bool& antiSpoof,
|
||
bool& removeFakeFaces)
|
||
{
|
||
try {
|
||
// LOCK DURING CONFIGURATION READ
|
||
std::lock_guard<std::mutex> lock(_configMutex);
|
||
|
||
knownPersonThreshold = this->_config._knownPersonThreshold;
|
||
enableAgeGender = this->_enableAgeGender;
|
||
enableFaceEmotions = this->_enableFaceEmotions;
|
||
enableHeadPose = this->_enableHeadPose;
|
||
minFaceSize = this->_minFaceSize;
|
||
faceLiveness = this->_enableFaceliveness;
|
||
antiSpoof = this->_enableAntiSpoof;
|
||
removeFakeFaces = this->_removeFakeFaces;
|
||
|
||
// Detector threshold may need detection mutex if detector state can change
|
||
if (_detector) {
|
||
faceDetectorScoreThreshold = _detector->GetDetectionThreshold();
|
||
}
|
||
else {
|
||
faceDetectorScoreThreshold = this->_faceDetectorScoreThreshold;
|
||
LogThreadSafe("ANSFacialRecognition::GetFaceParameters",
|
||
"Detector not initialized");
|
||
}
|
||
|
||
return true;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::GetFaceParameters", e.what());
|
||
return false;
|
||
}
|
||
}
|
||
|
||
|
||
bool ANSFacialRecognition::UpdateFaceQueue(int queueSize,int faceThresholdSize,bool enableFaceQueue)
|
||
{
|
||
try {
|
||
// LOCK DURING CONFIGURATION UPDATE
|
||
std::lock_guard<std::mutex> lock(_configMutex);
|
||
|
||
_queueSize = queueSize;
|
||
_faceThresholdSize = faceThresholdSize;
|
||
_enableFaceQueue = enableFaceQueue;
|
||
return true;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::UpdateFaceQueue", e.what());
|
||
return false;
|
||
}
|
||
}
|
||
bool ANSFacialRecognition::GetFaceQueue(int& queueSize,int& faceThresholdSize,bool& enableFaceQueue)
|
||
{
|
||
try {
|
||
std::lock_guard<std::mutex> lock(_configMutex);
|
||
queueSize = _queueSize;
|
||
faceThresholdSize = _faceThresholdSize;
|
||
enableFaceQueue = _enableFaceQueue;
|
||
return true;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::GetFaceQueue", e.what());
|
||
return false;
|
||
}
|
||
}
|
||
int ANSFacialRecognition::InsertUser(const std::string& userCode,const std::string& userName)
|
||
{
|
||
try {
|
||
int userId;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
userId = _db->InsertUser(userCode, userName);
|
||
}
|
||
|
||
if (userId <= 0) {
|
||
LogThreadSafe("ANSFacialRecognition::InsertUser",
|
||
"Failed to insert user: " + userCode);
|
||
}
|
||
|
||
return userId;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::InsertUser",
|
||
"User code " + userCode + ": " + e.what());
|
||
return 0;
|
||
}
|
||
}
|
||
int ANSFacialRecognition::DeleteUser(int userId) {
|
||
try {
|
||
// First delete all faces for this user
|
||
int result = DeleteFacesByUser(userId);
|
||
// Then delete the user record (lock during database access)
|
||
{
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
result = _db->DeleteUser(userId);
|
||
}
|
||
|
||
if (result <= 0) {
|
||
LogThreadSafe("ANSFacialRecognition::DeleteUser",
|
||
"Failed to delete user ID " + std::to_string(userId) + " from database");
|
||
}
|
||
else {
|
||
// User record deleted — mark dirty so Reload() refreshes _userDict.
|
||
// (DeleteFacesByUser above already reloaded for face removal;
|
||
// this second Reload rebuilds _userDict without the deleted user.)
|
||
_reloadNeeded.store(true);
|
||
Reload();
|
||
}
|
||
|
||
return result;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::DeleteUser",
|
||
"User ID " + std::to_string(userId) + ": " + e.what());
|
||
return 0;
|
||
}
|
||
}
|
||
int ANSFacialRecognition::DeleteUsers(const std::vector<int>& userIds) {
|
||
int deletedCount = 0;
|
||
for (int userId : userIds) {
|
||
try {
|
||
// First delete all faces for this user
|
||
DeleteFacesByUser(userId);
|
||
// Then delete the user record (lock during database access)
|
||
int result;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
result = _db->DeleteUser(userId);
|
||
}
|
||
if (result <= 0) {
|
||
LogThreadSafe("ANSFacialRecognition::DeleteUsers",
|
||
"Failed to delete user ID " + std::to_string(userId) + " from database");
|
||
}
|
||
else {
|
||
deletedCount++;
|
||
}
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::DeleteUsers",
|
||
"User ID " + std::to_string(userId) + ": " + e.what());
|
||
}
|
||
}
|
||
if (deletedCount > 0) {
|
||
_reloadNeeded.store(true);
|
||
Reload();
|
||
}
|
||
return deletedCount;
|
||
}
|
||
int ANSFacialRecognition::InsertFace(int userId, const cv::Mat& image) {
|
||
// Early validation checks (read-only, thread-safe)
|
||
if (!ValidateInput(image)) {
|
||
return 0;
|
||
}
|
||
|
||
try {
|
||
// Prepare input frame (CPU operation, independent)
|
||
cv::Mat frame = PrepareInputFrame(image);
|
||
if (frame.empty()) {
|
||
LogThreadSafe("ANSFacialRecognition::InsertFace",
|
||
"Failed to prepare input frame for user ID " + std::to_string(userId));
|
||
return 0;
|
||
}
|
||
|
||
// LOCK ONLY DURING DETECTION (shared detector)
|
||
std::vector<Object> detectedFaces;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_detectionMutex);
|
||
detectedFaces = _detector->RunInference(frame, "", false, true, false);
|
||
}
|
||
|
||
if (detectedFaces.empty()) {
|
||
LogThreadSafe("ANSFacialRecognition::InsertFace",
|
||
"No faces detected for user ID " + std::to_string(userId));
|
||
return 0;
|
||
}
|
||
|
||
// Get largest face (CPU operation)
|
||
Object faceObject = GetLargestObject(detectedFaces);
|
||
|
||
// LOCK ONLY DURING RECOGNITION (shared recognizer)
|
||
std::vector<float> embedding;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_recognitionMutex);
|
||
embedding = _recognizer->Feature(frame, faceObject);
|
||
}
|
||
|
||
// Validate embedding
|
||
if (embedding.empty() || embedding.size() != _config._recOutputDim) {
|
||
LogThreadSafe("ANSFacialRecognition::InsertFace",
|
||
"Invalid embedding generated for user ID " + std::to_string(userId) +
|
||
" (size: " + std::to_string(embedding.size()) + ")");
|
||
return 0;
|
||
}
|
||
|
||
// Prepare storage folder (filesystem operation, no lock)
|
||
std::string userImageFolderName = "User" + std::to_string(userId);
|
||
std::string imageFolder = CreateFilePath(_config._gen_imgSource, userImageFolderName);
|
||
|
||
if (!FolderExist(imageFolder)) {
|
||
try {
|
||
std::filesystem::create_directory(imageFolder);
|
||
}
|
||
catch (const std::filesystem::filesystem_error& e) {
|
||
LogThreadSafe("ANSFacialRecognition::InsertFace",
|
||
"Failed to create directory for user ID " + std::to_string(userId) +
|
||
": " + e.what());
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
// Generate unique filename
|
||
boost::uuids::uuid uuid = boost::uuids::random_generator()();
|
||
std::string imageFileName = Underscore2Dash(boost::uuids::to_string(uuid)) + ".jpg";
|
||
std::string imagePath = CreateFilePath(imageFolder, imageFileName);
|
||
|
||
// Save face image
|
||
if (!cv::imwrite(imagePath, faceObject.mask)) {
|
||
LogThreadSafe("ANSFacialRecognition::InsertFace",
|
||
"Failed to save face image for user ID " + std::to_string(userId));
|
||
return 0;
|
||
}
|
||
|
||
// Verify file was created
|
||
if (!FileExist(imagePath)) {
|
||
LogThreadSafe("ANSFacialRecognition::InsertFace",
|
||
"Image file verification failed for user ID " + std::to_string(userId) +
|
||
" at path: " + imagePath);
|
||
return 0;
|
||
}
|
||
|
||
// Insert into database (lock during database access)
|
||
int faceId;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
faceId = _db->InsertFace(userId, imagePath, embedding.data());
|
||
}
|
||
|
||
if (faceId <= 0) {
|
||
LogThreadSafe("ANSFacialRecognition::InsertFace",
|
||
"Failed to insert face into database for user ID " + std::to_string(userId));
|
||
}
|
||
else {
|
||
// Fix #3: Auto-reload FAISS index so new face is searchable immediately
|
||
_reloadNeeded.store(true);
|
||
Reload();
|
||
}
|
||
|
||
return faceId;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::InsertFace",
|
||
"User ID " + std::to_string(userId) + ": " + e.what());
|
||
return 0;
|
||
}
|
||
}
|
||
std::vector<int> ANSFacialRecognition::InsertMultipleFaces(int userId, const cv::Mat& image) {
|
||
std::vector<int> faceIds;
|
||
// Early validation checks (read-only, thread-safe)
|
||
if (!ValidateInput(image)) {
|
||
return faceIds;
|
||
}
|
||
|
||
try {
|
||
// Prepare input frame (CPU operation, independent)
|
||
cv::Mat frame = PrepareInputFrame(image);
|
||
if (frame.empty()) {
|
||
LogThreadSafe("ANSFacialRecognition::InsertMultipleFaces",
|
||
"Failed to prepare input frame for user ID " + std::to_string(userId));
|
||
return faceIds;
|
||
}
|
||
|
||
// LOCK ONLY DURING DETECTION (shared detector)
|
||
std::vector<Object> detectedFaces;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_detectionMutex);
|
||
detectedFaces = _detector->RunInference(frame, "", false, true, false);
|
||
}
|
||
|
||
if (detectedFaces.empty()) {
|
||
LogThreadSafe("ANSFacialRecognition::InsertMultipleFaces",
|
||
"No faces detected for user ID " + std::to_string(userId));
|
||
return faceIds;
|
||
}
|
||
|
||
// Get largest face
|
||
Object faceObject = GetLargestObject(detectedFaces);
|
||
|
||
// LOCK ONLY DURING RECOGNITION (shared recognizer)
|
||
std::vector<float> embedding;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_recognitionMutex);
|
||
embedding = _recognizer->Feature(frame, faceObject);
|
||
}
|
||
|
||
if (embedding.empty() || embedding.size() != _config._recOutputDim) {
|
||
LogThreadSafe("ANSFacialRecognition::InsertMultipleFaces",
|
||
"Invalid embedding generated for user ID " + std::to_string(userId));
|
||
return faceIds;
|
||
}
|
||
|
||
// Prepare storage folder (filesystem operation, no lock)
|
||
std::string userImageFolderName = "User" + std::to_string(userId);
|
||
std::string imageFolder = CreateFilePath(_config._gen_imgSource, userImageFolderName);
|
||
|
||
if (!FolderExist(imageFolder)) {
|
||
std::filesystem::create_directory(imageFolder);
|
||
}
|
||
|
||
// Generate unique filename
|
||
boost::uuids::uuid uuid = boost::uuids::random_generator()();
|
||
std::string imageFileName = Underscore2Dash(boost::uuids::to_string(uuid)) + ".jpg";
|
||
std::string imagePath = CreateFilePath(imageFolder, imageFileName);
|
||
|
||
// Save face image
|
||
if (!cv::imwrite(imagePath, faceObject.mask)) {
|
||
LogThreadSafe("ANSFacialRecognition::InsertMultipleFaces",
|
||
"Failed to save face image for user ID " + std::to_string(userId));
|
||
return faceIds;
|
||
}
|
||
|
||
if (!FileExist(imagePath)) {
|
||
LogThreadSafe("ANSFacialRecognition::InsertMultipleFaces",
|
||
"Image file verification failed for user ID " + std::to_string(userId));
|
||
return faceIds;
|
||
}
|
||
|
||
// Insert into database (lock during database access)
|
||
int faceId;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
faceId = _db->InsertFace(userId, imagePath, embedding.data());
|
||
}
|
||
|
||
if (faceId > 0) {
|
||
faceIds.push_back(faceId);
|
||
}
|
||
else {
|
||
LogThreadSafe("ANSFacialRecognition::InsertMultipleFaces",
|
||
"Failed to insert face into database for user ID " + std::to_string(userId));
|
||
}
|
||
|
||
// Auto-reload FAISS index so newly inserted faces are searchable
|
||
if (!faceIds.empty()) {
|
||
_reloadNeeded.store(true);
|
||
Reload();
|
||
}
|
||
|
||
return faceIds;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::InsertMultipleFaces",
|
||
"User ID " + std::to_string(userId) + ": " + e.what());
|
||
return faceIds;
|
||
}
|
||
}
|
||
int ANSFacialRecognition::DeleteFace(int faceId) {
|
||
try {
|
||
int result;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
result = _db->DeleteFace(faceId);
|
||
}
|
||
|
||
if (result <= 0) {
|
||
LogThreadSafe("ANSFacialRecognition::DeleteFace",
|
||
"Failed to delete face ID " + std::to_string(faceId));
|
||
}
|
||
else {
|
||
// Fix #3: Auto-reload FAISS index so deleted face is no longer searchable
|
||
_reloadNeeded.store(true);
|
||
Reload();
|
||
}
|
||
|
||
return result;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::DeleteFace",
|
||
"Face ID " + std::to_string(faceId) + ": " + e.what());
|
||
return 0;
|
||
}
|
||
}
|
||
int ANSFacialRecognition::UpdateUser(int userId, const std::string& userCode, const std::string& userName)
|
||
{
|
||
try {
|
||
// Validate input
|
||
if (userId <= 0) {
|
||
LogThreadSafe("ANSFacialRecognition::UpdateUser",
|
||
"Invalid user ID: " + std::to_string(userId));
|
||
return 0;
|
||
}
|
||
|
||
if (userCode.empty() && userName.empty()) {
|
||
LogThreadSafe("ANSFacialRecognition::UpdateUser",
|
||
"Both userCode and userName are empty for user ID " + std::to_string(userId));
|
||
return 0;
|
||
}
|
||
|
||
// Validate database initialization
|
||
if (!_db) {
|
||
LogThreadSafe("ANSFacialRecognition::UpdateUser",
|
||
"Database not initialized");
|
||
return 0;
|
||
}
|
||
|
||
// Update user in database
|
||
int result;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
result = _db->UpdateUser(userId, userCode, userName);
|
||
}
|
||
|
||
if (result <= 0) {
|
||
LogThreadSafe("ANSFacialRecognition::UpdateUser",
|
||
"Failed to update user ID " + std::to_string(userId) + " in database");
|
||
return 0;
|
||
}
|
||
|
||
// Update user dictionary to reflect changes
|
||
if (!UpdateUserDictionary()) {
|
||
LogThreadSafe("ANSFacialRecognition::UpdateUser",
|
||
"Warning: User ID " + std::to_string(userId) +
|
||
" updated in database but failed to refresh user dictionary");
|
||
// Consider: Should this be a critical error?
|
||
// return 0; // Uncomment if dictionary sync is critical
|
||
}
|
||
|
||
LogThreadSafe("ANSFacialRecognition::UpdateUser",
|
||
"Successfully updated user ID " + std::to_string(userId), LogLevel::Info);
|
||
|
||
return result;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::UpdateUser",
|
||
"Error updating user ID " + std::to_string(userId) + ": " + e.what());
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
int ANSFacialRecognition::GetUser(int userId, UserRecord& userRecord) {
|
||
try {
|
||
// Validate input
|
||
if (userId <= 0) {
|
||
LogThreadSafe("ANSFacialRecognition::GetUser",
|
||
"Invalid user ID: " + std::to_string(userId));
|
||
return 0;
|
||
}
|
||
|
||
// Validate database initialization
|
||
if (!_db) {
|
||
LogThreadSafe("ANSFacialRecognition::GetUser",
|
||
"Database not initialized");
|
||
return 0;
|
||
}
|
||
|
||
// Initialize user ID
|
||
userRecord.UserId = userId;
|
||
|
||
// LOCK ONLY DURING DATABASE ACCESS
|
||
{
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
|
||
// Get user basic information
|
||
int result = _db->GetUser(userId, userRecord.UserCode, userRecord.UserName);
|
||
if (result <= 0) {
|
||
LogThreadSafe("ANSFacialRecognition::GetUser",
|
||
"User ID " + std::to_string(userId) + " not found in database");
|
||
return 0;
|
||
}
|
||
|
||
// Get user's face IDs
|
||
result = _db->GetFaceIdsByUser(userId, userRecord.FaceIds);
|
||
if (result <= 0) {
|
||
LogThreadSafe("ANSFacialRecognition::GetUser",
|
||
"No faces found for user ID " + std::to_string(userId));
|
||
// Consider: Should this be an error or just a warning?
|
||
// A user might exist but have no registered faces yet
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
// Optional: Log successful retrieval
|
||
LogThreadSafe("ANSFacialRecognition::GetUser",
|
||
"Successfully retrieved user ID " + std::to_string(userId) +
|
||
" with " + std::to_string(userRecord.FaceIds.size()) + " face(s)");
|
||
|
||
return 1;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::GetUser",
|
||
"Error retrieving user ID " + std::to_string(userId) + ": " + e.what());
|
||
return 0;
|
||
}
|
||
}
|
||
int ANSFacialRecognition::GetUser(int userId, const std::string& userCode,const std::string& userName, UserRecord& userRecord) {
|
||
try {
|
||
// Initialize user ID
|
||
userRecord.UserId = userId;
|
||
userRecord.UserCode = userCode;
|
||
userRecord.UserName = userName;
|
||
|
||
// LOCK ONLY DURING DATABASE ACCESS
|
||
{
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
// Get user's face IDs
|
||
int result = _db->GetFaceIdsByUser(userId, userRecord.FaceIds);
|
||
if (result <= 0) {
|
||
LogThreadSafe("ANSFacialRecognition::GetUser",
|
||
"No faces found for user ID " + std::to_string(userId));
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::GetUser",
|
||
"User ID " + std::to_string(userId) + ": " + e.what());
|
||
return 0;
|
||
}
|
||
}
|
||
int ANSFacialRecognition::GetUsers(std::vector<UserRecord>& userRecords,std::vector<int>& userIds)
|
||
{
|
||
// Clear output parameters
|
||
userRecords.clear();
|
||
userIds.clear();
|
||
|
||
try {
|
||
std::vector<std::string> userCodes;
|
||
std::vector<std::string> userNames;
|
||
std::vector<std::vector<int>> faceIdsByUser;
|
||
|
||
// Fix #12: Single batch query with JOIN replaces N+1 individual queries
|
||
{
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
int result = _db->GetUsersWithFaceIds(userIds, userCodes, userNames, faceIdsByUser);
|
||
if (result <= 0) {
|
||
LogThreadSafe("ANSFacialRecognition::GetUsers",
|
||
"Failed to query users from database");
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
if (userIds.empty()) {
|
||
return 0;
|
||
}
|
||
|
||
// Build UserRecord objects directly from batch results
|
||
userRecords.reserve(userIds.size());
|
||
for (size_t i = 0; i < userIds.size(); ++i)
|
||
{
|
||
UserRecord userRecord;
|
||
userRecord.UserId = userIds[i];
|
||
userRecord.UserCode = std::move(userCodes[i]);
|
||
userRecord.UserName = std::move(userNames[i]);
|
||
userRecord.FaceIds = std::move(faceIdsByUser[i]);
|
||
userRecords.push_back(std::move(userRecord));
|
||
}
|
||
|
||
return static_cast<int>(userRecords.size());
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::GetUsers", e.what());
|
||
userRecords.clear();
|
||
userIds.clear();
|
||
return 0;
|
||
}
|
||
}
|
||
int ANSFacialRecognition::GetFace(int faceId, FaceRecord& faceRecord) {
|
||
try {
|
||
// Initialize the record with the face ID
|
||
faceRecord.FaceId = faceId;
|
||
|
||
// LOCK ONLY DURING DATABASE ACCESS
|
||
int result;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
result = _db->GetFaceById(faceId, faceRecord.UserId, faceRecord.ImagePath);
|
||
}
|
||
|
||
if (result <= 0) {
|
||
LogThreadSafe("ANSFacialRecognition::GetFace",
|
||
"Face ID " + std::to_string(faceId) + " not found in database");
|
||
}
|
||
|
||
return result;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::GetFace",
|
||
"Face ID " + std::to_string(faceId) + ": " + e.what());
|
||
return 0;
|
||
}
|
||
}
|
||
int ANSFacialRecognition::GetFaces(int userId, std::vector<FaceRecord>& faceRecords) {
|
||
// Clear output parameter
|
||
faceRecords.clear();
|
||
|
||
try {
|
||
// Get face IDs from database (lock during database access)
|
||
std::vector<int> faceIds;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
int result = _db->GetFaceIdsByUser(userId, faceIds);
|
||
|
||
if (result <= 0) {
|
||
LogThreadSafe("ANSFacialRecognition::GetFaces",
|
||
"Failed to query face IDs for user " + std::to_string(userId));
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
if (faceIds.empty()) {
|
||
return 0;
|
||
}
|
||
|
||
// Reserve space for efficiency
|
||
faceRecords.reserve(faceIds.size());
|
||
|
||
// Retrieve each face record
|
||
for (int faceId : faceIds) {
|
||
FaceRecord faceRecord;
|
||
int result = GetFace(faceId, faceRecord);
|
||
|
||
if (result <= 0) {
|
||
LogThreadSafe("ANSFacialRecognition::GetFaces",
|
||
"Failed to retrieve face ID " + std::to_string(faceId) +
|
||
" for user " + std::to_string(userId));
|
||
faceRecords.clear(); // Clear partial results on error
|
||
return 0;
|
||
}
|
||
|
||
faceRecords.push_back(std::move(faceRecord));
|
||
}
|
||
|
||
return static_cast<int>(faceRecords.size());
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::GetFaces",
|
||
std::string("User ") + std::to_string(userId) + ": " + e.what());
|
||
faceRecords.clear();
|
||
return 0;
|
||
}
|
||
}
|
||
int ANSFacialRecognition::DeleteFacesByUser(int userId) {
|
||
try {
|
||
std::vector<int> faceIds;
|
||
|
||
// Get face IDs for this user (lock during database access)
|
||
{
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
int result = _db->GetFaceIdsByUser(userId, faceIds);
|
||
|
||
if (result <= 0) {
|
||
LogThreadSafe("ANSFacialRecognition::DeleteFacesByUser",
|
||
"Failed to query faces for user ID " + std::to_string(userId));
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
// No faces is a valid state (user just created or faces already removed)
|
||
if (faceIds.empty()) {
|
||
LogThreadSafe("ANSFacialRecognition::DeleteFacesByUser",
|
||
"No faces found for user ID " + std::to_string(userId) + " — skipping",
|
||
LogLevel::Debug);
|
||
return 1;
|
||
}
|
||
|
||
// Delete each face from database (lock per deletion)
|
||
for (int faceId : faceIds) {
|
||
std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
int result = _db->DeleteFace(faceId);
|
||
|
||
if (result <= 0) {
|
||
LogThreadSafe("ANSFacialRecognition::DeleteFacesByUser",
|
||
"Failed to delete face ID " + std::to_string(faceId) +
|
||
" for user ID " + std::to_string(userId));
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
// Delete user's image folder (filesystem operation, no lock needed)
|
||
std::string userImageFolderName = "User" + std::to_string(userId);
|
||
std::string imageFolder = CreateFilePath(_config._gen_imgSource, userImageFolderName);
|
||
|
||
if (FolderExist(imageFolder)) {
|
||
DeleteFolder(imageFolder);
|
||
}
|
||
|
||
// Fix #3: Auto-reload FAISS index after batch face deletion
|
||
_reloadNeeded.store(true);
|
||
Reload();
|
||
|
||
return 1;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::DeleteFacesByUser",
|
||
"User ID " + std::to_string(userId) + ": " + e.what());
|
||
return 0;
|
||
}
|
||
}
|
||
int ANSFacialRecognition::GetUser(int userId, std::string& userRecord) {
|
||
// NO LOCK NEEDED - Delegates to another method that handles locking
|
||
|
||
try {
|
||
UserRecord record;
|
||
|
||
// Get user record (this method handles its own locking)
|
||
int result = GetUser(userId, record);
|
||
|
||
if (result <= 0) {
|
||
userRecord.clear();
|
||
return 0;
|
||
}
|
||
|
||
// Serialize to JSON (CPU operation, thread-safe)
|
||
userRecord = ANSFRHelper::UserRecordToJsonString(record);
|
||
|
||
return 1;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::GetUser",
|
||
"User ID " + std::to_string(userId) + ": " + e.what());
|
||
userRecord.clear();
|
||
return 0;
|
||
}
|
||
}
|
||
int ANSFacialRecognition::GetUsers(std::string& userRecords, std::vector<int>& userIds) {
|
||
// NO LOCK NEEDED - Delegates to another method that handles locking
|
||
|
||
// Clear output parameters
|
||
userRecords.clear();
|
||
userIds.clear();
|
||
|
||
try {
|
||
std::vector<UserRecord> records;
|
||
|
||
// Get user records (this method handles its own locking)
|
||
int result = GetUsers(records, userIds);
|
||
|
||
if (result <= 0 || records.empty()) {
|
||
return 0;
|
||
}
|
||
|
||
// Serialize to JSON (CPU operation, thread-safe)
|
||
userRecords = ANSFRHelper::UserRecordsToJsonString(records);
|
||
|
||
return 1;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::GetUsers", e.what());
|
||
userRecords.clear();
|
||
userIds.clear();
|
||
return 0;
|
||
}
|
||
}
|
||
int ANSFacialRecognition::GetFace(int faceId, std::string& faceRecord) {
|
||
// NO LOCK NEEDED - Delegates to another method that handles locking
|
||
|
||
try {
|
||
FaceRecord record;
|
||
|
||
// Get face record (this method handles its own locking)
|
||
int result = GetFace(faceId, record);
|
||
|
||
if (result <= 0) {
|
||
faceRecord.clear();
|
||
return 0;
|
||
}
|
||
|
||
// Serialize to JSON (CPU operation, thread-safe)
|
||
faceRecord = ANSFRHelper::FaceRecordToJsonString(record);
|
||
|
||
return 1;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::GetFace",
|
||
"Face ID " + std::to_string(faceId) + ": " + e.what());
|
||
faceRecord.clear();
|
||
return 0;
|
||
}
|
||
}
|
||
int ANSFacialRecognition::GetFaces(int userId, std::string& faceRecords)
|
||
{
|
||
// NO LOCK NEEDED - Delegates to another method that handles locking if needed
|
||
|
||
try {
|
||
std::vector<FaceRecord> records;
|
||
|
||
// Get face records (this method should handle its own locking if needed)
|
||
int result = GetFaces(userId, records);
|
||
|
||
if (result <= 0 || records.empty()) {
|
||
faceRecords.clear();
|
||
return 0;
|
||
}
|
||
|
||
// Serialize to JSON (CPU operation, thread-safe)
|
||
faceRecords = ANSFRHelper::FaceRecordsToJsonString(records);
|
||
|
||
return 1;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::GetFaces", e.what());
|
||
faceRecords.clear();
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
|
||
int ANSFacialRecognition::CheckFace(const cv::Mat& image) {
|
||
// Early validation checks (read-only, thread-safe)
|
||
if (!ValidateInput(image)) {
|
||
return 0;
|
||
}
|
||
|
||
try {
|
||
// Prepare input frame (CPU operation, independent)
|
||
cv::Mat frame = PrepareInputFrame(image);
|
||
if (frame.empty()) {
|
||
LogThreadSafe("ANSFacialRecognition::CheckFace",
|
||
"Failed to prepare input frame");
|
||
return 0;
|
||
}
|
||
|
||
// LOCK ONLY DURING DETECTION (shared detector)
|
||
std::vector<Object> detectedFaces;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_detectionMutex);
|
||
detectedFaces = _detector->RunInference(frame, "", false, true, false);
|
||
}
|
||
|
||
if (detectedFaces.empty()) {
|
||
return 0;
|
||
}
|
||
|
||
// Filter faces (CPU operation, independent)
|
||
auto validFaces = CheckFaces(detectedFaces,true);
|
||
|
||
return validFaces.empty() ? 0 : 1;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::CheckFace", e.what());
|
||
return 0;
|
||
}
|
||
}
|
||
std::vector<FaceResultObject> ANSFacialRecognition::Recognize(const cv::Mat& input) {
|
||
return Recognize(input, "FRCAM");
|
||
}
|
||
std::vector<FaceResultObject> ANSFacialRecognition::Recognize(const cv::Mat& input, const std::string& camera_id) {
|
||
|
||
std::vector<FaceResultObject> resultObjects;
|
||
// Early validation checks (read-only, thread-safe)
|
||
if (!ValidateInitialization() || !ValidateInput(input) || !ValidateComponents()) {
|
||
return resultObjects;
|
||
}
|
||
|
||
try {
|
||
// Prepare input frame (CPU operation, independent per camera)
|
||
cv::Mat frame = PrepareInputFrame(input);
|
||
if (frame.empty()) {
|
||
LogError("ANSFacialRecognition::Recognize",
|
||
"Failed to prepare input frame", camera_id);
|
||
return resultObjects;
|
||
}
|
||
|
||
// Sanity check config dimensions
|
||
if (_config._recInputShape.size() < 3) {
|
||
LogError("ANSFacialRecognition::Recognize",
|
||
"Invalid _recInputShape size", camera_id);
|
||
return resultObjects;
|
||
}
|
||
|
||
int target_height = _config._recInputShape[1];
|
||
int target_width = _config._recInputShape[2];
|
||
|
||
// Resize if needed
|
||
if (frame.cols != target_width || frame.rows != target_height) {
|
||
cv::resize(frame, frame, cv::Size(target_width, target_height));
|
||
}
|
||
|
||
// Prepare dummy detection (1 full-frame face box)
|
||
std::vector<Object> outputBbox;
|
||
Object bbox;
|
||
bbox.box = cv::Rect(0, 0, std::min(target_width, frame.cols), std::min(target_height, frame.rows));
|
||
bbox.confidence = 1.0f;
|
||
bbox.mask = frame;
|
||
bbox.cameraId = camera_id;
|
||
outputBbox.push_back(bbox);
|
||
|
||
// LOCK ONLY DURING RECOGNITION (shared recognizer with GPU buffers)
|
||
std::vector<FaceResultObject> recognizedFaces;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_recognitionMutex);
|
||
recognizedFaces = RecognizeFaces(frame, outputBbox);
|
||
}
|
||
|
||
resultObjects = UpdateFaceAttributes(recognizedFaces, camera_id);
|
||
return resultObjects;
|
||
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogError("ANSFacialRecognition::Recognize", e.what(), camera_id);
|
||
}
|
||
catch (...) {
|
||
LogError("ANSFacialRecognition::Recognize", "Unknown exception", camera_id);
|
||
}
|
||
|
||
|
||
return std::vector<FaceResultObject>();
|
||
}
|
||
|
||
std::vector<FaceResultObject> ANSFacialRecognition::Inference(const cv::Mat& input) {
|
||
return Inference(input, "FRCAM");
|
||
}
|
||
|
||
std::vector<FaceResultObject> ANSFacialRecognition::Inference(const cv::Mat& input, const std::string& camera_id)
|
||
{
|
||
START_TIMER(total);
|
||
|
||
std::vector<FaceResultObject> resultObjects;
|
||
|
||
// Early validation checks (read-only, thread-safe)
|
||
START_TIMER(validate_init);
|
||
bool init_valid = ValidateInitialization();
|
||
END_TIMER(validate_init, "ValidateInitialization Time");
|
||
|
||
if (!init_valid) {
|
||
END_TIMER(total, "Total Inference Time (early exit - init)");
|
||
return resultObjects;
|
||
}
|
||
|
||
START_TIMER(validate_input);
|
||
bool input_valid = ValidateInput(input);
|
||
END_TIMER(validate_input, "ValidateInput Time");
|
||
|
||
if (!input_valid) {
|
||
END_TIMER(total, "Total Inference Time (early exit - input)");
|
||
return resultObjects;
|
||
}
|
||
|
||
START_TIMER(validate_components);
|
||
bool components_valid = ValidateComponents();
|
||
END_TIMER(validate_components, "ValidateComponents Time");
|
||
|
||
if (!components_valid) {
|
||
END_TIMER(total, "Total Inference Time (early exit - components)");
|
||
return resultObjects;
|
||
}
|
||
|
||
try {
|
||
// Prepare input frame (CPU operation, independent per camera)
|
||
START_TIMER(prepare_frame);
|
||
cv::Mat frame = PrepareInputFrame(input);
|
||
END_TIMER(prepare_frame, "PrepareInputFrame Time");
|
||
|
||
if (frame.empty()) {
|
||
LogError("ANSFacialRecognition::Inference",
|
||
"Failed to prepare input frame", camera_id);
|
||
END_TIMER(total, "Total Inference Time (early exit - empty frame)");
|
||
return resultObjects;
|
||
}
|
||
|
||
// LOCK ONLY DURING DETECTION (shared detector)
|
||
std::vector<Object> detectedFaces;
|
||
{
|
||
START_TIMER(detection);
|
||
std::lock_guard<std::mutex> lock(_detectionMutex);
|
||
|
||
START_TIMER(detection_actual);
|
||
detectedFaces = DetectFaces(frame, camera_id);
|
||
END_TIMER(detection_actual, "Face Detection (actual) Time");
|
||
|
||
END_TIMER(detection, "Face Detection (with lock) Time");
|
||
}
|
||
|
||
if (detectedFaces.empty()) {
|
||
END_TIMER(total, "Total Inference Time (no faces detected)");
|
||
return resultObjects;
|
||
}
|
||
|
||
// Filter faces (CPU operation, independent per camera)
|
||
START_TIMER(filter);
|
||
std::vector<Object> validFaces = CheckFaces(detectedFaces, true);
|
||
END_TIMER(filter, "Filter Faces Time");
|
||
|
||
if (validFaces.empty()) {
|
||
END_TIMER(total, "Total Inference Time (no valid faces)");
|
||
return resultObjects;
|
||
}
|
||
|
||
// LOCK ONLY DURING RECOGNITION (shared recognizer with GPU buffers)
|
||
std::vector<FaceResultObject> recognizedFaces;
|
||
{
|
||
START_TIMER(recognition);
|
||
std::lock_guard<std::mutex> lock(_recognitionMutex);
|
||
|
||
START_TIMER(recognition_actual);
|
||
recognizedFaces = RecognizeFaces(frame, validFaces);
|
||
END_TIMER(recognition_actual, "Face Recognition (actual) Time");
|
||
|
||
END_TIMER(recognition, "Face Recognition (with lock) Time");
|
||
}
|
||
|
||
// Post-process faces (CPU operation, independent per camera)
|
||
if (!recognizedFaces.empty()) {
|
||
START_TIMER(postprocess);
|
||
resultObjects=UpdateFaceAttributes(recognizedFaces, camera_id);
|
||
END_TIMER(postprocess, "Update Face Attributes Time");
|
||
|
||
// Deduplicate: if two faces matched the same userId, keep only the highest confidence
|
||
// Pass camera data for trackId-based identity persistence to prevent flickering
|
||
CameraData* camDataPtr = (!camera_id.empty()) ? &GetCameraData(camera_id) : nullptr;
|
||
ensureUniqueUserIdWithHighestConfidence(resultObjects, camDataPtr);
|
||
}
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogError("ANSFacialRecognition::Inference", e.what(), camera_id);
|
||
END_TIMER(total, "Total Inference Time (exception)");
|
||
return resultObjects;
|
||
}
|
||
catch (...) {
|
||
LogError("ANSFacialRecognition::Inference", "Unknown exception", camera_id);
|
||
END_TIMER(total, "Total Inference Time (unknown exception)");
|
||
return resultObjects;
|
||
}
|
||
|
||
END_TIMER(total, "Total Inference Time");
|
||
// Fix #9: std::cout removed from production DLL
|
||
|
||
return resultObjects;
|
||
}
|
||
|
||
std::vector<FaceResultObject> ANSFacialRecognition::Detect(const cv::Mat& input) {
|
||
return Detect(input, "FRCAM");
|
||
}
|
||
std::vector<FaceResultObject> ANSFacialRecognition::Detect(const cv::Mat& input,const std::string& camera_id)
|
||
{
|
||
std::vector<FaceResultObject> resultObjects;
|
||
|
||
// Early validation checks (read-only, thread-safe)
|
||
if (!ValidateInitialization() || !ValidateInput(input) || !ValidateComponents()) {
|
||
return resultObjects;
|
||
}
|
||
|
||
try {
|
||
// Prepare input frame (CPU operation, independent per camera)
|
||
cv::Mat frame = PrepareInputFrame(input);
|
||
if (frame.empty()) {
|
||
LogError("ANSFacialRecognition::Detect",
|
||
"Failed to prepare input frame", camera_id);
|
||
return resultObjects;
|
||
}
|
||
|
||
// LOCK ONLY DURING DETECTION (shared detector)
|
||
std::vector<Object> detectedFaces;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_detectionMutex);
|
||
detectedFaces = DetectFaces(frame, camera_id);
|
||
}
|
||
|
||
if (detectedFaces.empty()) {
|
||
return resultObjects;
|
||
}
|
||
|
||
// Filter faces (CPU operation, independent per camera)
|
||
auto validFaces = CheckFaces(detectedFaces, true);
|
||
if (validFaces.empty()) {
|
||
return resultObjects;
|
||
}
|
||
|
||
// Build face result objects with attributes (CPU/GPU mixed operations)
|
||
resultObjects = BuildFaceResultObjects(validFaces, input, camera_id);
|
||
return resultObjects;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogError("ANSFacialRecognition::Detect", e.what(), camera_id);
|
||
}
|
||
catch (...) {
|
||
LogError("ANSFacialRecognition::Detect", "Unknown exception", camera_id);
|
||
}
|
||
|
||
return resultObjects;
|
||
}
|
||
|
||
std::vector<Object> ANSFacialRecognition::FaceDetect(const cv::Mat& input) {
|
||
return FaceDetect(input, "FRCAM");
|
||
}
|
||
std::vector<Object> ANSFacialRecognition::FaceDetect(const cv::Mat& input,const std::string& camera_id)
|
||
{
|
||
std::vector<Object> resultObjects;
|
||
|
||
// Early validation checks (read-only, thread-safe)
|
||
if (!ValidateInitialization() || !ValidateInput(input)) {
|
||
return resultObjects;
|
||
}
|
||
|
||
try {
|
||
// Prepare input frame (CPU operation, independent per camera)
|
||
cv::Mat frame = PrepareInputFrame(input);
|
||
if (frame.empty()) {
|
||
LogError("ANSFacialRecognition::FaceDetect",
|
||
"Failed to prepare input frame", camera_id);
|
||
return resultObjects;
|
||
}
|
||
|
||
// LOCK ONLY DURING DETECTION (shared detector)
|
||
std::vector<Object> detectedFaces;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_detectionMutex);
|
||
detectedFaces = DetectFaces(frame, camera_id);
|
||
}
|
||
|
||
if (detectedFaces.empty()) {
|
||
return resultObjects;
|
||
}
|
||
|
||
// Filter faces (CPU operation, independent per camera)
|
||
auto validFaces = CheckFaces(detectedFaces);
|
||
|
||
return validFaces;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogError("ANSFacialRecognition::FaceDetect", e.what(), camera_id);
|
||
}
|
||
catch (...) {
|
||
LogError("ANSFacialRecognition::FaceDetect", "Unknown exception", camera_id);
|
||
}
|
||
|
||
return resultObjects;
|
||
}
|
||
|
||
|
||
std::vector<FaceResultObject> ANSFacialRecognition::PostProcess(const std::vector<FaceResultObject>& detectedObjects,const std::string& cameraId)
|
||
{
|
||
//ScopedTimer("Post Process");
|
||
if (!_enableFaceQueue) {
|
||
return detectedObjects;
|
||
}
|
||
|
||
// Lock ONLY for queue operations
|
||
std::lock_guard<std::mutex> lock(_faceQueueMutex);
|
||
|
||
// Enqueue current detection
|
||
EnqueueDetection(detectedObjects, cameraId);
|
||
|
||
// Dequeue and process
|
||
std::deque<std::vector<FaceResultObject>> faceQueue = DequeueDetection(cameraId);
|
||
std::vector<FaceResultObject> faceObjects = FindFrequentFaces(faceQueue,detectedObjects,this->_faceThresholdSize);
|
||
return faceObjects;
|
||
}
|
||
std::string ANSFacialRecognition::PolygonToString(const std::vector<cv::Point2f>& polygon) {
|
||
if (polygon.empty()) {
|
||
return "";
|
||
}
|
||
|
||
try {
|
||
std::string result;
|
||
result.reserve(polygon.size() * 20);
|
||
|
||
char buffer[64];
|
||
for (size_t i = 0; i < polygon.size(); ++i) {
|
||
if (i > 0) {
|
||
snprintf(buffer, sizeof(buffer), ";%.3f;%.3f", polygon[i].x, polygon[i].y);
|
||
}
|
||
else {
|
||
snprintf(buffer, sizeof(buffer), "%.3f;%.3f", polygon[i].x, polygon[i].y);
|
||
}
|
||
result += buffer;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
catch (const std::exception& e) {
|
||
this->_logger.LogFatal("ANSFacialRecognition::PolygonToString()", e.what(), __FILE__, __LINE__);
|
||
return "";
|
||
}
|
||
}
|
||
std::string ANSFacialRecognition::KeypointsToString(const std::vector<float>& kps) {
|
||
if (kps.empty()) {
|
||
return "";
|
||
}
|
||
try {
|
||
// Pre-allocate: each float ~10 chars (e.g., "123.456;")
|
||
std::string result;
|
||
result.reserve(kps.size() * 10);
|
||
|
||
char buffer[32];
|
||
for (size_t i = 0; i < kps.size(); ++i) {
|
||
if (i > 0) result += ';';
|
||
snprintf(buffer, sizeof(buffer), "%.3f", kps[i]);
|
||
result += buffer;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
catch (const std::exception& e) {
|
||
this->_logger.LogFatal("ANSFacialRecognition::KeypointsToString()", e.what(), __FILE__, __LINE__);
|
||
return "";
|
||
}
|
||
}
|
||
|
||
// Using nlohmann/json (much faster)
|
||
static std::string DoubleEscapeUnicode(const std::string& utf8Str) {
|
||
bool hasNonAscii = false;
|
||
for (unsigned char c : utf8Str) {
|
||
if (c >= 0x80) { hasNonAscii = true; break; }
|
||
}
|
||
if (!hasNonAscii) return utf8Str;
|
||
std::string result;
|
||
result.reserve(utf8Str.size() * 2);
|
||
size_t i = 0;
|
||
while (i < utf8Str.size()) {
|
||
unsigned char c = static_cast<unsigned char>(utf8Str[i]);
|
||
if (c < 0x80) { result += utf8Str[i++]; continue; }
|
||
uint32_t cp = 0;
|
||
if ((c & 0xE0) == 0xC0 && i + 1 < utf8Str.size()) {
|
||
cp = ((c & 0x1F) << 6) | (static_cast<unsigned char>(utf8Str[i + 1]) & 0x3F); i += 2;
|
||
} else if ((c & 0xF0) == 0xE0 && i + 2 < utf8Str.size()) {
|
||
cp = ((c & 0x0F) << 12) | ((static_cast<unsigned char>(utf8Str[i + 1]) & 0x3F) << 6) | (static_cast<unsigned char>(utf8Str[i + 2]) & 0x3F); i += 3;
|
||
} else if ((c & 0xF8) == 0xF0 && i + 3 < utf8Str.size()) {
|
||
cp = ((c & 0x07) << 18) | ((static_cast<unsigned char>(utf8Str[i + 1]) & 0x3F) << 12) | ((static_cast<unsigned char>(utf8Str[i + 2]) & 0x3F) << 6) | (static_cast<unsigned char>(utf8Str[i + 3]) & 0x3F); i += 4;
|
||
} else { i++; continue; }
|
||
if (cp <= 0xFFFF) { char buf[8]; snprintf(buf, sizeof(buf), "\\u%04x", cp); result += buf; }
|
||
else { cp -= 0x10000; char buf[16]; snprintf(buf, sizeof(buf), "\\u%04x\\u%04x", 0xD800 + (uint16_t)(cp >> 10), 0xDC00 + (uint16_t)(cp & 0x3FF)); result += buf; }
|
||
}
|
||
return result;
|
||
}
|
||
|
||
std::string ANSFacialRecognition::FaceObjectsToJsonString(const std::vector<FaceResultObject>& faces) {
|
||
START_TIMER(json_total);
|
||
|
||
try {
|
||
nlohmann::json root;
|
||
auto& results = root["results"] = nlohmann::json::array();
|
||
|
||
START_TIMER(json_build);
|
||
for (const auto& face : faces) {
|
||
results.push_back({
|
||
{"user_id", face.userId},
|
||
{"user_name", DoubleEscapeUnicode(face.userName)},
|
||
{"similarity", std::to_string(face.similarity)},
|
||
{"is_unknown", std::to_string(face.isUnknown)},
|
||
{"prob", std::to_string(face.confidence)},
|
||
{"x", std::to_string(face.box.x)},
|
||
{"y", std::to_string(face.box.y)},
|
||
{"width", std::to_string(face.box.width)},
|
||
{"height", std::to_string(face.box.height)},
|
||
{"extra_info", face.extraInformation},
|
||
{"camera_id", face.cameraId},
|
||
{"track_id", std::to_string(face.trackId)},
|
||
{"polygon", PolygonToString(face.polygon)},
|
||
{"kps", KeypointsToString(face.kps)}
|
||
});
|
||
}
|
||
END_TIMER(json_build, "JSON Build Time");
|
||
|
||
START_TIMER(json_serialize);
|
||
std::string result = root.dump();
|
||
END_TIMER(json_serialize, "JSON Serialize Time");
|
||
|
||
END_TIMER(json_total, "JSON Conversion Total Time");
|
||
return result;
|
||
}
|
||
catch (const std::exception& e) {
|
||
END_TIMER(json_total, "JSON Conversion Time (error)");
|
||
LogThreadSafe("ANSFacialRecognition::FaceObjectsToJsonString", e.what());
|
||
return R"({"results":[],"error":"Serialization failed"})";
|
||
}
|
||
}
|
||
std::string ANSFacialRecognition::FaceToJsonString(const std::vector<Object>& dets) {
|
||
nlohmann::json root;
|
||
nlohmann::json detectedObjects = nlohmann::json::array();
|
||
|
||
for (const auto& det : dets) {
|
||
nlohmann::json detectedNode;
|
||
detectedNode["class_id"] = std::to_string(det.classId);
|
||
detectedNode["track_id"] = std::to_string(det.trackId);
|
||
detectedNode["class_name"] = DoubleEscapeUnicode(det.className);
|
||
detectedNode["prob"] = std::to_string(det.confidence);
|
||
detectedNode["x"] = std::to_string(det.box.x);
|
||
detectedNode["y"] = std::to_string(det.box.y);
|
||
detectedNode["width"] = std::to_string(det.box.width);
|
||
detectedNode["height"] = std::to_string(det.box.height);
|
||
detectedNode["mask"] = ""; // TODO: convert masks to comma separated string
|
||
detectedNode["extra_info"] = det.extraInfo;
|
||
detectedNode["camera_id"] = det.cameraId;
|
||
detectedNode["polygon"] = PolygonToString(det.polygon);
|
||
detectedNode["kps"] = KeypointsToString(det.kps);
|
||
|
||
detectedObjects.push_back(detectedNode);
|
||
}
|
||
|
||
root["results"] = detectedObjects;
|
||
|
||
return root.dump();
|
||
}
|
||
|
||
// Validation helper methods
|
||
bool ANSFacialRecognition::ValidateInitialization() {
|
||
//ScopedTimer("Validate Initialization");
|
||
if (!_isInitialized) {
|
||
_logger.LogError("ANSFacialRecognition::Inference()",
|
||
"Models are not initialized.", __FILE__, __LINE__);
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool ANSFacialRecognition::ValidateInput(const cv::Mat& input) {
|
||
//ScopedTimer("ValidateInput");
|
||
constexpr int MIN_DIMENSION = 10;
|
||
|
||
if (input.empty() || input.cols < MIN_DIMENSION || input.rows < MIN_DIMENSION) {
|
||
_logger.LogFatal("ANSFacialRecognition::Inference()",
|
||
"Input image is invalid or too small", __FILE__, __LINE__);
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool ANSFacialRecognition::ValidateComponents() {
|
||
//ScopedTimer("ValidateComponents");
|
||
if (!_detector) {
|
||
_logger.LogFatal("ANSFacialRecognition::Inference()",
|
||
"_detector is null", __FILE__, __LINE__);
|
||
return false;
|
||
}
|
||
|
||
if (!_recognizer) {
|
||
_logger.LogFatal("ANSFacialRecognition::Inference()",
|
||
"_recognizer is null", __FILE__, __LINE__);
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
// Frame preparation
|
||
cv::Mat ANSFacialRecognition::PrepareInputFrame(const cv::Mat& input) {
|
||
// If input is already BGR and you don't modify it downstream
|
||
if (input.channels() == 3) {
|
||
return input; // Just return reference (no copy!)
|
||
}
|
||
|
||
// Only convert if grayscale
|
||
cv::Mat frame;
|
||
cv::cvtColor(input, frame, cv::COLOR_GRAY2BGR);
|
||
return frame;
|
||
}
|
||
void ANSFacialRecognition::ensureUniqueUserIdWithHighestConfidence(std::vector<FaceResultObject>& resultObjects, CameraData* camData)
|
||
{
|
||
if (resultObjects.empty()) {
|
||
return;
|
||
}
|
||
|
||
auto isUnknownId = [](const std::string& id) {
|
||
return id == "0000" || id == "0" || id.empty();
|
||
};
|
||
|
||
if (camData) {
|
||
auto& identities = camData->trackIdentities;
|
||
|
||
// Step 1: Build map of userId → candidate face indices (before modifying anything)
|
||
std::unordered_map<std::string, std::vector<size_t>> userIdCandidates;
|
||
for (size_t i = 0; i < resultObjects.size(); ++i) {
|
||
if (isUnknownId(resultObjects[i].userId)) continue;
|
||
userIdCandidates[resultObjects[i].userId].push_back(i);
|
||
}
|
||
|
||
// Step 2: Resolve duplicate userIds using accumulated scores
|
||
for (auto& [uid, indices] : userIdCandidates) {
|
||
if (indices.size() <= 1) continue;
|
||
|
||
// Find the candidate with the highest accumulated score for this userId
|
||
size_t winner = indices[0];
|
||
float bestScore = 0.0f;
|
||
|
||
for (size_t idx : indices) {
|
||
int tid = resultObjects[idx].trackId;
|
||
float score = resultObjects[idx].confidence; // fallback for new trackIds
|
||
auto it = identities.find(tid);
|
||
if (it != identities.end() && it->second.userId == uid) {
|
||
// Use accumulated score + this frame's confidence
|
||
score = it->second.accumulatedScore + resultObjects[idx].confidence;
|
||
}
|
||
if (score > bestScore) {
|
||
bestScore = score;
|
||
winner = idx;
|
||
}
|
||
}
|
||
|
||
// Mark all non-winners as unknown
|
||
for (size_t idx : indices) {
|
||
if (idx != winner) {
|
||
MarkAsUnknown(resultObjects[idx]);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Step 3: Update accumulated scores after dedup.
|
||
// - Winners: add this frame's confidence to their score
|
||
// - Losers (marked Unknown by dedup): decay their score (×0.8)
|
||
// so they gradually lose claim but don't reset instantly
|
||
// (avoids the alternating-win problem where neither can accumulate)
|
||
// - Losers that decay below a threshold are erased entirely
|
||
constexpr float DECAY_FACTOR = 0.8f;
|
||
constexpr float MIN_SCORE = 0.1f;
|
||
|
||
for (auto& r : resultObjects) {
|
||
int tid = r.trackId;
|
||
|
||
if (isUnknownId(r.userId)) {
|
||
// Lost dedup or genuinely unknown — decay existing score
|
||
auto it = identities.find(tid);
|
||
if (it != identities.end()) {
|
||
it->second.accumulatedScore *= DECAY_FACTOR;
|
||
if (it->second.accumulatedScore < MIN_SCORE) {
|
||
identities.erase(it);
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
|
||
auto it = identities.find(tid);
|
||
if (it != identities.end()) {
|
||
if (it->second.userId == r.userId) {
|
||
// Same identity as before and won dedup — accumulate
|
||
it->second.accumulatedScore += r.confidence;
|
||
} else {
|
||
// Different identity — start fresh
|
||
it->second.userId = r.userId;
|
||
it->second.accumulatedScore = r.confidence;
|
||
}
|
||
} else {
|
||
// New trackId — initialize
|
||
identities[tid] = { r.userId, r.confidence };
|
||
}
|
||
}
|
||
|
||
// Step 3: Clean up trackIds no longer in the scene
|
||
std::unordered_set<int> activeTrackIds;
|
||
for (const auto& r : resultObjects) {
|
||
activeTrackIds.insert(r.trackId);
|
||
}
|
||
for (auto it = identities.begin(); it != identities.end(); ) {
|
||
if (activeTrackIds.find(it->first) == activeTrackIds.end()) {
|
||
it = identities.erase(it);
|
||
} else {
|
||
++it;
|
||
}
|
||
}
|
||
} else {
|
||
// No camera data: fall back to simple confidence-based dedup
|
||
std::unordered_map<std::string, size_t> highestConfidenceIndices;
|
||
highestConfidenceIndices.reserve(resultObjects.size());
|
||
|
||
for (size_t i = 0; i < resultObjects.size(); ++i) {
|
||
const std::string& userId = resultObjects[i].userId;
|
||
if (isUnknownId(userId)) continue;
|
||
|
||
auto it = highestConfidenceIndices.find(userId);
|
||
if (it == highestConfidenceIndices.end()) {
|
||
highestConfidenceIndices[userId] = i;
|
||
} else {
|
||
size_t existingIndex = it->second;
|
||
if (resultObjects[i].confidence > resultObjects[existingIndex].confidence) {
|
||
MarkAsUnknown(resultObjects[existingIndex]);
|
||
highestConfidenceIndices[userId] = i;
|
||
} else {
|
||
MarkAsUnknown(resultObjects[i]);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
std::vector<Object> ANSFacialRecognition::CheckFaces(const std::vector<Object>& faceObjects,bool checkFaceSize)
|
||
{
|
||
// NO LOCK NEEDED - Pure filtering operation on local data
|
||
std::vector<Object> validFaceObjects;
|
||
validFaceObjects.reserve(faceObjects.size());
|
||
|
||
try {
|
||
for (const auto& face : faceObjects) {
|
||
// Skip faces smaller than minimum size if checking is enabled
|
||
if (checkFaceSize &&
|
||
(face.box.width <= _minFaceSize || face.box.height <= _minFaceSize)) {
|
||
continue;
|
||
}
|
||
validFaceObjects.push_back(face);
|
||
}
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::CheckFaces", e.what());
|
||
}
|
||
|
||
return validFaceObjects;
|
||
}
|
||
// Pipeline stage methods with timing
|
||
std::vector<Object> ANSFacialRecognition::DetectFaces(const cv::Mat& frame, const std::string& camera_id)
|
||
{
|
||
//ScopedTimer timer("Face Detection");
|
||
return _detector->RunInference(frame, camera_id, true, _enableHeadPose, _enableFaceliveness);
|
||
}
|
||
|
||
|
||
|
||
std::vector<FaceResultObject> ANSFacialRecognition::RecognizeFaces(const cv::Mat& frame, const std::vector<Object>& validFaces)
|
||
{
|
||
// Hold shared lock during the entire Match operation to prevent
|
||
// Reload() from swapping the index while we're using it.
|
||
// Fix #6: Pass _userDict by const& — shared_lock guarantees it won't
|
||
// be modified during Match (only unique_lock in Reload can write).
|
||
std::shared_lock<std::shared_mutex> lock(_indexSwapMutex);
|
||
return _recognizer->Match(frame, validFaces, _userDict);
|
||
}
|
||
std::string ANSFacialRecognition::GetOpenVINODevice() {
|
||
ov::Core core;
|
||
std::vector<std::string> available_devices = core.get_available_devices();
|
||
// Prioritize devices: NPU > GPU > CPU
|
||
std::vector<std::string> priority_devices = { "NPU","GPU","CPU" };
|
||
for (const auto& device : priority_devices) {
|
||
if (std::find(available_devices.begin(), available_devices.end(), device) != available_devices.end()) {
|
||
return device; // Return the first available device based on priority
|
||
}
|
||
}
|
||
return "CPU";
|
||
}
|
||
|
||
std::vector<FaceResultObject> ANSFacialRecognition::UpdateFaceAttributes(
|
||
const std::vector<FaceResultObject>& resultObjects,
|
||
const std::string& camera_id)
|
||
{
|
||
std::vector<FaceResultObject> updatedResults;
|
||
try {
|
||
const size_t faceCount = resultObjects.size();
|
||
if (faceCount == 0) return updatedResults;
|
||
|
||
// Determine if this is a full-attribute frame or head-pose-only frame
|
||
bool runSlowAttributes = true;
|
||
CameraData* camDataPtr = nullptr;
|
||
if (!camera_id.empty() && _attributeInterval > 1) {
|
||
camDataPtr = &GetCameraData(camera_id);
|
||
|
||
// ── Adaptive interval (#5): adjust based on scene stability ──
|
||
// Count current trackIds
|
||
int currentTrackIdCount = static_cast<int>(faceCount);
|
||
if (currentTrackIdCount == camDataPtr->previousTrackIdCount) {
|
||
camDataPtr->stableFrameCount++;
|
||
} else {
|
||
camDataPtr->stableFrameCount = 0;
|
||
}
|
||
camDataPtr->previousTrackIdCount = currentTrackIdCount;
|
||
|
||
// Adapt interval: stable scene → increase (max 10), changes → decrease (min 2)
|
||
if (camDataPtr->stableFrameCount > 30) {
|
||
camDataPtr->currentAttributeInterval = std::min(10, _attributeInterval * 2);
|
||
} else if (camDataPtr->stableFrameCount > 10) {
|
||
camDataPtr->currentAttributeInterval = _attributeInterval;
|
||
} else {
|
||
camDataPtr->currentAttributeInterval = std::max(2, _attributeInterval / 2);
|
||
}
|
||
|
||
camDataPtr->attributeFrameCounter++;
|
||
if (camDataPtr->attributeFrameCounter >= camDataPtr->currentAttributeInterval) {
|
||
camDataPtr->attributeFrameCounter = 0;
|
||
runSlowAttributes = true;
|
||
} else {
|
||
runSlowAttributes = false;
|
||
}
|
||
}
|
||
|
||
// Pre-allocate per-face working data
|
||
std::vector<FaceResultObject> results(resultObjects.begin(), resultObjects.end());
|
||
std::vector<cv::Mat> masks(faceCount);
|
||
std::vector<bool> maskValid(faceCount, false);
|
||
std::vector<bool> skipAttributes(faceCount, false);
|
||
std::vector<bool> runAgeGender(faceCount, false);
|
||
std::vector<bool> runEmotions(faceCount, false);
|
||
std::vector<bool> runHeadPose(faceCount, false);
|
||
std::vector<bool> useCachedAttrs(faceCount, false);
|
||
std::vector<AgeGenderResults> ageGenderResults(faceCount, AgeGenderResults{});
|
||
std::vector<std::map<std::string, float>> emotionsResults(faceCount);
|
||
std::vector<HeadPoseResults> headPoseResults(faceCount, HeadPoseResults{});
|
||
|
||
std::vector<Face> faces;
|
||
faces.reserve(faceCount);
|
||
|
||
START_TIMER(attr_phase1);
|
||
// ---- Phase 1: Setup + antispoof (sequential) ----
|
||
for (size_t i = 0; i < faceCount; i++) {
|
||
cv::Rect faceBox = resultObjects[i].box;
|
||
faces.emplace_back(i, faceBox);
|
||
Face& face = faces[i];
|
||
|
||
face.ageGenderEnable(this->_enableAgeGender && _ageGenderDetector && _ageGenderDetector->enabled());
|
||
face.emotionsEnable(this->_enableFaceEmotions && _emotionsDetector && _emotionsDetector->enabled());
|
||
face.headPoseEnable(this->_enableHeadPose && _headPoseDetector && _headPoseDetector->enabled());
|
||
face.antispoofingEnable(this->_enableAntiSpoof && _antiSpoofDetector && _antiSpoofDetector->enabled());
|
||
face.faceLivenessEnable(this->_enableFaceliveness);
|
||
|
||
// Clone mask once per face
|
||
masks[i] = (!results[i].mask.empty()) ? resultObjects[i].mask.clone() : cv::Mat();
|
||
maskValid[i] = !masks[i].empty() && masks[i].cols >= 5 && masks[i].rows >= 5;
|
||
|
||
// Check if we can use cached attributes for this face
|
||
bool hasCachedAttrs = false;
|
||
if (!runSlowAttributes && camDataPtr) {
|
||
auto it = camDataPtr->cachedAttributes.find(resultObjects[i].trackId);
|
||
if (it != camDataPtr->cachedAttributes.end()) {
|
||
hasCachedAttrs = true;
|
||
}
|
||
}
|
||
|
||
// Determine if slow attributes should run for this face
|
||
bool runSlowForThisFace = runSlowAttributes || !hasCachedAttrs;
|
||
|
||
bool fakeFaceDetected = false;
|
||
if (face.isFaceLivenessEnabled() && !results[i].extraInformation.empty()) {
|
||
const std::string& livenessResult = results[i].extraInformation;
|
||
if (livenessResult == "real") {
|
||
face.updateFaceLiveness(1);
|
||
}
|
||
else if (livenessResult == "fake") {
|
||
face.updateFaceLiveness(0);
|
||
fakeFaceDetected = true;
|
||
}
|
||
}
|
||
|
||
// Antispoof: only on full-attribute frames or new faces
|
||
if (runSlowForThisFace && !fakeFaceDetected && face.isAntispoofingEnabled() && maskValid[i]) {
|
||
float confidence;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_antispoofMutex);
|
||
confidence = _antiSpoofDetector->runInfer(masks[i]);
|
||
}
|
||
face.updateRealFaceConfidence(confidence);
|
||
if (!face.isReal()) fakeFaceDetected = true;
|
||
}
|
||
|
||
if (_removeFakeFaces && fakeFaceDetected) {
|
||
skipAttributes[i] = true;
|
||
MarkAsUnknown(results[i]);
|
||
}
|
||
|
||
// Skip attribute inference for faces below minimum size threshold
|
||
if (!skipAttributes[i] &&
|
||
(resultObjects[i].box.width < _minFaceSize ||
|
||
resultObjects[i].box.height < _minFaceSize)) {
|
||
skipAttributes[i] = true;
|
||
MarkAsUnknown(results[i]);
|
||
}
|
||
|
||
// Slow attributes: only on attribute frames or new faces
|
||
runAgeGender[i] = !skipAttributes[i] && runSlowForThisFace && face.isAgeGenderEnabled() && maskValid[i];
|
||
runEmotions[i] = !skipAttributes[i] && runSlowForThisFace && face.isEmotionsEnabled() && maskValid[i];
|
||
// Head pose: ALWAYS runs (every frame)
|
||
runHeadPose[i] = !skipAttributes[i] && face.isHeadPoseEnabled() && maskValid[i];
|
||
// Track whether to use cache for output
|
||
useCachedAttrs[i] = !skipAttributes[i] && !runSlowForThisFace && hasCachedAttrs;
|
||
}
|
||
|
||
END_TIMER(attr_phase1, " [Attr] Phase1 (setup+antispoof)");
|
||
|
||
// ---- Phase 2: Run attribute models sequentially ----
|
||
// On cached frames: only head pose runs. AgeGender + Emotions are skipped.
|
||
START_TIMER(attr_agegender);
|
||
{
|
||
std::lock_guard<std::mutex> lock(_ageGenderMutex);
|
||
for (size_t i = 0; i < faceCount; i++) {
|
||
if (!runAgeGender[i]) continue;
|
||
ageGenderResults[i] = _ageGenderDetector->runInfer(masks[i]);
|
||
}
|
||
}
|
||
END_TIMER(attr_agegender, " [Attr] AgeGender (all faces)");
|
||
|
||
START_TIMER(attr_emotions);
|
||
{
|
||
std::lock_guard<std::mutex> lock(_emotionsMutex);
|
||
for (size_t i = 0; i < faceCount; i++) {
|
||
if (!runEmotions[i]) continue;
|
||
emotionsResults[i] = _emotionsDetector->runInfer(masks[i]);
|
||
}
|
||
}
|
||
END_TIMER(attr_emotions, " [Attr] Emotions (all faces)");
|
||
|
||
// Head pose: ALWAYS runs (every frame, real-time accuracy)
|
||
START_TIMER(attr_headpose);
|
||
{
|
||
std::lock_guard<std::mutex> lock(_headPoseMutex);
|
||
for (size_t i = 0; i < faceCount; i++) {
|
||
if (!runHeadPose[i]) continue;
|
||
headPoseResults[i] = _headPoseDetector->runInfer(masks[i]);
|
||
}
|
||
}
|
||
END_TIMER(attr_headpose, " [Attr] HeadPose (all faces)");
|
||
|
||
// ---- Phase 3: Collect results and build output ----
|
||
for (size_t i = 0; i < faceCount; i++) {
|
||
if (skipAttributes[i]) continue;
|
||
|
||
Face& face = faces[i];
|
||
FaceResultObject& resultObject = results[i];
|
||
|
||
if (useCachedAttrs[i] && camDataPtr) {
|
||
// Cached frame: use cached JSON but splice in fresh head pose
|
||
auto& cached = camDataPtr->cachedAttributes[resultObjects[i].trackId];
|
||
|
||
if (runHeadPose[i]) {
|
||
// Check extreme head pose → mark unknown
|
||
if (std::abs(headPoseResults[i].angle_y) > 60 ||
|
||
std::abs(headPoseResults[i].angle_r) > 60 ||
|
||
std::abs(headPoseResults[i].angle_p) > 60) {
|
||
MarkAsUnknown(resultObject);
|
||
}
|
||
|
||
// Replace Pose(r,p,y) in cached JSON with fresh values
|
||
std::string json = cached.attributeJson;
|
||
std::string newPose = "(" + std::to_string(static_cast<int>(headPoseResults[i].angle_r)) +
|
||
", " + std::to_string(static_cast<int>(headPoseResults[i].angle_p)) +
|
||
", " + std::to_string(static_cast<int>(headPoseResults[i].angle_y)) + ")";
|
||
// Find and replace the pose value in the JSON
|
||
size_t poseKeyPos = json.find("\"Pose(r,p,y)\"");
|
||
if (poseKeyPos != std::string::npos) {
|
||
size_t valueStart = json.find("\"(", poseKeyPos + 13);
|
||
size_t valueEnd = json.find(")\"", valueStart + 1);
|
||
if (valueStart != std::string::npos && valueEnd != std::string::npos) {
|
||
json.replace(valueStart + 1, valueEnd - valueStart, newPose);
|
||
}
|
||
}
|
||
resultObject.extraInformation = json;
|
||
} else {
|
||
resultObject.extraInformation = cached.attributeJson;
|
||
}
|
||
|
||
if (cached.isUnknown) MarkAsUnknown(resultObject);
|
||
} else {
|
||
// Full attribute frame: build from scratch
|
||
if (runAgeGender[i]) {
|
||
face.updateGender(ageGenderResults[i].maleProb);
|
||
face.updateAge(ageGenderResults[i].age);
|
||
}
|
||
if (runEmotions[i]) {
|
||
face.updateEmotions(emotionsResults[i]);
|
||
}
|
||
if (runHeadPose[i]) {
|
||
face.updateHeadPose(headPoseResults[i]);
|
||
if (std::abs(headPoseResults[i].angle_y) > 60 ||
|
||
std::abs(headPoseResults[i].angle_r) > 60 ||
|
||
std::abs(headPoseResults[i].angle_p) > 60) {
|
||
MarkAsUnknown(resultObject);
|
||
}
|
||
}
|
||
|
||
std::string faceAtt = ANSFRHelper::FaceAttributeToJsonString(face);
|
||
resultObject.extraInformation = faceAtt;
|
||
|
||
// Cache for future frames
|
||
if (camDataPtr) {
|
||
CachedFaceAttributes& cache = camDataPtr->cachedAttributes[resultObjects[i].trackId];
|
||
cache.attributeJson = faceAtt;
|
||
cache.isUnknown = resultObject.isUnknown;
|
||
}
|
||
}
|
||
|
||
updatedResults.push_back(resultObject);
|
||
}
|
||
|
||
// Clean up stale cache entries (trackIds not seen this frame)
|
||
if (camDataPtr && runSlowAttributes) {
|
||
std::unordered_set<int> activeTrackIds;
|
||
for (const auto& r : resultObjects)
|
||
activeTrackIds.insert(r.trackId);
|
||
for (auto it = camDataPtr->cachedAttributes.begin(); it != camDataPtr->cachedAttributes.end(); ) {
|
||
if (activeTrackIds.find(it->first) == activeTrackIds.end())
|
||
it = camDataPtr->cachedAttributes.erase(it);
|
||
else
|
||
++it;
|
||
}
|
||
}
|
||
|
||
return updatedResults;
|
||
}
|
||
catch (const std::bad_alloc& e) {
|
||
LogThreadSafe("ANSFacialRecognition::updateFaceAttributes",
|
||
std::string("Memory allocation failed: ") + e.what());
|
||
return updatedResults;
|
||
}
|
||
catch (const std::exception& e) {
|
||
LogThreadSafe("ANSFacialRecognition::updateFaceAttributes", e.what());
|
||
return updatedResults;
|
||
}
|
||
}
|
||
std::vector<FaceResultObject> ANSFacialRecognition::BuildFaceResultObjects(const std::vector<Object>& validFaces,const cv::Mat& originalInput,const std::string& camera_id)
|
||
{
|
||
std::vector<FaceResultObject> resultObjects;
|
||
resultObjects.reserve(validFaces.size());
|
||
|
||
for (size_t i = 0; i < validFaces.size(); ++i) {
|
||
const Object& faceObj = validFaces[i];
|
||
|
||
// Create face attribute object
|
||
cv::Rect rect = faceObj.box;
|
||
Face face(i, rect);
|
||
|
||
// Enable attributes based on configuration
|
||
face.ageGenderEnable(_enableAgeGender && _ageGenderDetector && _ageGenderDetector->enabled());
|
||
face.emotionsEnable(_enableFaceEmotions && _emotionsDetector && _emotionsDetector->enabled());
|
||
face.headPoseEnable(_enableHeadPose && _headPoseDetector && _headPoseDetector->enabled());
|
||
face.antispoofingEnable(_enableAntiSpoof && _antiSpoofDetector && _antiSpoofDetector->enabled());
|
||
|
||
// Process face attributes if mask is valid
|
||
if (!faceObj.mask.empty() && faceObj.mask.cols > 4 && faceObj.mask.rows > 4) {
|
||
ProcessFaceAttributes(face, faceObj.mask);
|
||
}
|
||
// Build result object
|
||
FaceResultObject result;
|
||
result.isUnknown = true;
|
||
result.userId = "0";
|
||
result.userName = "Unknown";
|
||
result.similarity = 0.0f;
|
||
result.confidence = 1.0f;
|
||
result.cameraId = camera_id;
|
||
result.trackId = faceObj.trackId;
|
||
|
||
// Clamp bounding box to image boundaries
|
||
result.box.x = std::max(0.0f, static_cast<float>(faceObj.box.x));
|
||
result.box.y = std::max(0.0f, static_cast<float>(faceObj.box.y));
|
||
result.box.width = std::min(
|
||
static_cast<float>(originalInput.cols) - result.box.x,
|
||
static_cast<float>(faceObj.box.width)
|
||
);
|
||
result.box.height = std::min(
|
||
static_cast<float>(originalInput.rows) - result.box.y,
|
||
static_cast<float>(faceObj.box.height)
|
||
);
|
||
|
||
// Copy face data
|
||
result.mask = faceObj.mask;
|
||
result.polygon = faceObj.polygon;
|
||
result.kps = faceObj.kps;
|
||
|
||
// Serialize face attributes to JSON
|
||
result.extraInformation = ANSFRHelper::FaceAttributeToJsonString(face);
|
||
|
||
resultObjects.push_back(result);
|
||
}
|
||
|
||
return resultObjects;
|
||
}
|
||
void ANSFacialRecognition::ProcessFaceAttributes(Face& face,const cv::Mat& mask)
|
||
{
|
||
// Age & Gender
|
||
if (face.isAgeGenderEnabled()) {
|
||
AgeGenderResults ageGenderResult;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_ageGenderMutex);
|
||
ageGenderResult = _ageGenderDetector->runInfer(mask);
|
||
}
|
||
face.updateGender(ageGenderResult.maleProb);
|
||
face.updateAge(ageGenderResult.age);
|
||
}
|
||
|
||
// Emotions
|
||
if (face.isEmotionsEnabled()) {
|
||
std::map<std::string, float> emotions;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_emotionsMutex);
|
||
emotions = _emotionsDetector->runInfer(mask);
|
||
}
|
||
face.updateEmotions(emotions);
|
||
}
|
||
|
||
// Head Pose
|
||
if (face.isHeadPoseEnabled()) {
|
||
HeadPoseResults headPoseResult;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_headPoseMutex);
|
||
headPoseResult = _headPoseDetector->runInfer(mask);
|
||
}
|
||
face.updateHeadPose(headPoseResult);
|
||
}
|
||
|
||
// Anti-Spoofing
|
||
if (face.isAntispoofingEnabled()) {
|
||
float confidence;
|
||
{
|
||
std::lock_guard<std::mutex> lock(_antispoofMutex);
|
||
confidence = _antiSpoofDetector->runInfer(mask);
|
||
}
|
||
face.updateRealFaceConfidence(confidence);
|
||
}
|
||
}
|
||
|
||
void ANSFacialRecognition::MarkAsUnknown(FaceResultObject& face) {
|
||
face.userId = "0000";
|
||
face.isUnknown = true;
|
||
face.userName = "Unknown";
|
||
face.confidence = 1.0;
|
||
}
|
||
void ANSFacialRecognition::EnqueueDetection(const std::vector<FaceResultObject>& detectedObjects, const std::string& cameraId) {
|
||
try {
|
||
CameraData& camera = GetCameraData(cameraId);// Retrieve camera data
|
||
if (camera._detectionQueue.size() == this->_queueSize) {
|
||
camera._detectionQueue.pop_front(); // Remove the oldest element if the queue is full
|
||
}
|
||
camera._detectionQueue.push_back(detectedObjects); // Add the new detection, even if empty
|
||
}
|
||
catch (const std::exception& e) {
|
||
this->_logger.LogFatal("ANSFacialRecognition::EnqueueDetection()", e.what(), __FILE__, __LINE__);
|
||
}
|
||
}
|
||
std::deque<std::vector<FaceResultObject>>ANSFacialRecognition::DequeueDetection(const std::string& cameraId) {
|
||
try {
|
||
CameraData& camera = GetCameraData(cameraId);// Retrieve camera data
|
||
return camera._detectionQueue;
|
||
}
|
||
catch (const std::exception& e) {
|
||
this->_logger.LogFatal("ANSFacialRecognition::DequeueDetection()", e.what(), __FILE__, __LINE__);
|
||
return std::deque<std::vector<FaceResultObject>>();
|
||
}
|
||
}
|
||
|
||
Object ANSFacialRecognition::GetLargestObject(const std::vector<Object>& objects) {
|
||
try {
|
||
if (!objects.empty()) {
|
||
// Find the object with the largest size
|
||
auto largestObjectIt = std::max_element(objects.begin(), objects.end(),
|
||
[](const Object& a, const Object& b) {
|
||
return (a.box.width * a.box.height) <
|
||
(b.box.width * b.box.height);
|
||
});
|
||
|
||
return *largestObjectIt; // Return the largest object
|
||
}
|
||
return Object();
|
||
}
|
||
catch (const std::exception& e) {
|
||
this->_logger.LogFatal("ANSFacialRecognition::GetLargestObject()", e.what(), __FILE__, __LINE__);
|
||
return Object();
|
||
}
|
||
}
|
||
|
||
bool ANSFacialRecognition::AreFacesSimilar(const FaceResultObject& face1, const FaceResultObject& face2) {
|
||
// Check if both faces belong to the same camera and user
|
||
return face1.cameraId == face2.cameraId &&
|
||
face1.userId == face2.userId &&
|
||
face1.userName == face2.userName;
|
||
}
|
||
|
||
// Helper function to generate a hash for a face based on AreFacesSimilar
|
||
size_t ANSFacialRecognition::GenerateFaceHash(const FaceResultObject & face, const std::vector<FaceResultObject>&detectedObjects) {
|
||
for (size_t i = 0; i < detectedObjects.size(); ++i) {
|
||
if (AreFacesSimilar(face, detectedObjects[i])) {
|
||
return i; // Use index of `detectedObjects` as the hash key
|
||
}
|
||
}
|
||
return static_cast<size_t>(-1); // Invalid index if not similar
|
||
}
|
||
std::vector<FaceResultObject> ANSFacialRecognition::FindFrequentFaces(const std::deque<std::vector<FaceResultObject>>&faceQueue,
|
||
const std::vector<FaceResultObject>&detectedObjects,
|
||
int occurrenceThreshold)
|
||
{
|
||
try {
|
||
// Map to count occurrences of each detected face using detectedObjects as keys
|
||
std::unordered_map<size_t, int> faceCount;
|
||
// Iterate over the face queue to count occurrences
|
||
for (const auto& faceArray : faceQueue) {
|
||
for (const auto& face : faceArray) {
|
||
if (face.userName != "Unknown") { // Skip checking "Unknown" faces
|
||
size_t hash = GenerateFaceHash(face, detectedObjects);
|
||
if (hash != static_cast<size_t>(-1)) { // Valid hash
|
||
faceCount[hash]++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// Collect frequent faces from detectedObjects
|
||
std::vector<FaceResultObject> frequentFaces;
|
||
for (size_t i = 0; i < detectedObjects.size(); ++i) {
|
||
const auto& detectedFace = detectedObjects[i];
|
||
if (detectedFace.userName == "Unknown") {
|
||
// Add "Unknown" faces directly without checking
|
||
frequentFaces.push_back(detectedFace);
|
||
}
|
||
else if (faceCount[i] >= occurrenceThreshold) {
|
||
// Add frequent known faces
|
||
frequentFaces.push_back(detectedFace);
|
||
}
|
||
}
|
||
|
||
return frequentFaces;
|
||
}
|
||
catch (const std::exception& e) {
|
||
this->_logger.LogFatal("ANSFacialRecognition::FindFrequentFaces()", e.what(), __FILE__, __LINE__);
|
||
return std::vector<FaceResultObject>();
|
||
}
|
||
}
|
||
|
||
// Helper methods with proper thread safety
|
||
void ANSFacialRecognition::LogError(const std::string& function, const std::string& message, const std::string& camera_id)
|
||
{
|
||
std::ostringstream oss;
|
||
oss << "Camera " << camera_id << ": " << message;
|
||
|
||
std::lock_guard<std::mutex> lock(_loggerMutex);
|
||
_logger.LogError(function, oss.str(), __FILE__, __LINE__);
|
||
}
|
||
|
||
// Helper methods
|
||
void ANSFacialRecognition::LogThreadSafe(const std::string& function, const std::string& message,
|
||
LogLevel level) {
|
||
std::lock_guard<std::mutex> lock(_loggerMutex);
|
||
switch (level) {
|
||
case LogLevel::Debug: _logger.LogDebug(function, message, __FILE__, __LINE__); break;
|
||
case LogLevel::Info: _logger.LogDebug(function, message, __FILE__, __LINE__); break;
|
||
case LogLevel::Warn: _logger.LogWarn(function, message, __FILE__, __LINE__); break;
|
||
case LogLevel::Fatal: _logger.LogFatal(function, message, __FILE__, __LINE__); break;
|
||
case LogLevel::Error:
|
||
default: _logger.LogError(function, message, __FILE__, __LINE__); break;
|
||
}
|
||
}
|
||
};
|
||
|
||
|
||
// Working version
|
||
//std::vector<FaceResultObject> ANSFacialRecognition::Inference(
|
||
// const cv::Mat& input,
|
||
// const std::string& camera_id)
|
||
//{
|
||
// std::lock_guard<std::recursive_mutex> lock(_mutex);
|
||
// std::vector<FaceResultObject> resultObjects;
|
||
//
|
||
// // Early validation checks
|
||
// if (!ValidateInitialization() || !ValidateInput(input) || !ValidateComponents()) {
|
||
// return resultObjects;
|
||
// }
|
||
//
|
||
// try {
|
||
// // Start total timing
|
||
// auto t_total_start = std::chrono::high_resolution_clock::now();
|
||
//
|
||
// // Prepare input frame
|
||
// auto t_prepare_start = std::chrono::high_resolution_clock::now();
|
||
// cv::Mat frame = PrepareInputFrame(input);
|
||
// auto t_prepare_end = std::chrono::high_resolution_clock::now();
|
||
// float prepare_ms = std::chrono::duration<float, std::milli>(t_prepare_end - t_prepare_start).count();
|
||
//
|
||
// if (frame.empty()) {
|
||
// _logger.LogFatal("ANSFacialRecognition::Inference()",
|
||
// "Failed to prepare input frame", __FILE__, __LINE__);
|
||
// return resultObjects;
|
||
// }
|
||
//
|
||
// // Detect faces
|
||
// auto t_detect_start = std::chrono::high_resolution_clock::now();
|
||
// auto detectedFaces = DetectFaces(frame, camera_id);
|
||
// auto t_detect_end = std::chrono::high_resolution_clock::now();
|
||
// float detect_ms = std::chrono::duration<float, std::milli>(t_detect_end - t_detect_start).count();
|
||
//
|
||
// if (detectedFaces.empty()) {
|
||
// _logger.LogDebug("ANSFacialRecognition::Inference()",
|
||
// "No faces detected", __FILE__, __LINE__);
|
||
// return resultObjects;
|
||
// }
|
||
//
|
||
// // Filter faces
|
||
// auto t_filter_start = std::chrono::high_resolution_clock::now();
|
||
// auto validFaces = FilterFaces(detectedFaces);
|
||
// auto t_filter_end = std::chrono::high_resolution_clock::now();
|
||
// float filter_ms = std::chrono::duration<float, std::milli>(t_filter_end - t_filter_start).count();
|
||
//
|
||
// if (validFaces.empty()) {
|
||
// _logger.LogDebug("ANSFacialRecognition::Inference()",
|
||
// "No valid faces after filtering", __FILE__, __LINE__);
|
||
// return resultObjects;
|
||
// }
|
||
//
|
||
// // Recognize faces (BATCH INFERENCE HAPPENS HERE)
|
||
// auto t_recognize_start = std::chrono::high_resolution_clock::now();
|
||
// resultObjects = RecognizeFaces(frame, validFaces);
|
||
// auto t_recognize_end = std::chrono::high_resolution_clock::now();
|
||
// float recognize_ms = std::chrono::duration<float, std::milli>(t_recognize_end - t_recognize_start).count();
|
||
//
|
||
// // Post-process faces
|
||
// auto t_postproc_start = std::chrono::high_resolution_clock::now();
|
||
// PostProcessFaces(resultObjects);
|
||
// auto t_postproc_end = std::chrono::high_resolution_clock::now();
|
||
// float postproc_ms = std::chrono::duration<float, std::milli>(t_postproc_end - t_postproc_start).count();
|
||
//
|
||
// // Apply head pose filtering if enabled
|
||
// float headpose_ms = 0.0f;
|
||
// if (_enableHeadPose) {
|
||
// auto t_headpose_start = std::chrono::high_resolution_clock::now();
|
||
// resultObjects = PostProcessDetection(resultObjects, camera_id);
|
||
// auto t_headpose_end = std::chrono::high_resolution_clock::now();
|
||
// headpose_ms = std::chrono::duration<float, std::milli>(t_headpose_end - t_headpose_start).count();
|
||
// }
|
||
//
|
||
// // Calculate total time
|
||
// auto t_total_end = std::chrono::high_resolution_clock::now();
|
||
// float total_ms = std::chrono::duration<float, std::milli>(t_total_end - t_total_start).count();
|
||
//
|
||
// // Calculate measured sum
|
||
// float measured_sum = prepare_ms + detect_ms + filter_ms + recognize_ms + postproc_ms + headpose_ms;
|
||
// float unaccounted_ms = total_ms - measured_sum;
|
||
//
|
||
// // Detailed logging
|
||
// _logger.LogDebug("ANSFacialRecognition::Inference()",
|
||
// "=== Timing Breakdown (Faces: " + std::to_string(validFaces.size()) + ") ===\n"
|
||
// " Prepare Frame: " + std::to_string(prepare_ms) + " ms\n"
|
||
// " Face Detection: " + std::to_string(detect_ms) + " ms\n"
|
||
// " Face Filter: " + std::to_string(filter_ms) + " ms\n"
|
||
// " Face Recognition: " + std::to_string(recognize_ms) + " ms (" +
|
||
// std::to_string(recognize_ms / validFaces.size()) + " ms/face)\n"
|
||
// " Post-Process: " + std::to_string(postproc_ms) + " ms\n"
|
||
// " Head Pose: " + std::to_string(headpose_ms) + " ms\n"
|
||
// " --------------------------------\n"
|
||
// " Measured Sum: " + std::to_string(measured_sum) + " ms\n"
|
||
// " Actual Total: " + std::to_string(total_ms) + " ms\n"
|
||
// " Unaccounted: " + std::to_string(unaccounted_ms) + " ms\n"
|
||
// " ================================",
|
||
// __FILE__, __LINE__);
|
||
//
|
||
// return resultObjects;
|
||
// }
|
||
// catch (const std::exception& e) {
|
||
// _logger.LogFatal("ANSFacialRecognition::Inference()",
|
||
// e.what(), __FILE__, __LINE__);
|
||
// }
|
||
// catch (...) {
|
||
// _logger.LogFatal("ANSFacialRecognition::Inference()",
|
||
// "Unknown exception occurred", __FILE__, __LINE__);
|
||
// }
|
||
// return resultObjects;
|
||
//}
|
||
|
||
// Old code
|
||
// std::vector<FaceResultObject> ANSFacialRecognition::Detect(const cv::Mat& input, const std::string& camera_id) {
|
||
// std::lock_guard<std::recursive_mutex> lock(_mutex);
|
||
// if (!_isInitialized) {
|
||
// std::vector<Object> _outputBbox;
|
||
// _outputBbox.clear();
|
||
// std::vector<FaceResultObject> resultObjects;
|
||
// this->_logger.LogError("ANSFacialRecognition::Detect()", "Models are not initialized.", __FILE__, __LINE__);
|
||
// return resultObjects;
|
||
// }
|
||
// try {
|
||
// std::vector<Object> _rawOutputBbox;
|
||
// std::vector<Object> _outputBbox;
|
||
|
||
// std::vector<FaceResultObject> resultObjects;
|
||
// resultObjects.clear();
|
||
// if (input.empty()) {
|
||
// this->_logger.LogFatal("ANSFacialRecognition::Detect()", "image frame is empty", __FILE__, __LINE__);
|
||
// return resultObjects;
|
||
// }
|
||
// if ((input.cols < 10) || (input.rows < 10)) return resultObjects;
|
||
// // Convert grayscale images to 3-channel BGR if needed
|
||
// cv::Mat frame;
|
||
// if (input.channels() == 1) {
|
||
// cv::cvtColor(input, frame, cv::COLOR_GRAY2BGR);
|
||
// }
|
||
// else {
|
||
// frame = input.clone();
|
||
// }
|
||
|
||
|
||
// _rawOutputBbox = _detector->RunInference(frame,camera_id);
|
||
// if (_rawOutputBbox.empty()) {
|
||
// return resultObjects;
|
||
// }
|
||
// // For every detected face
|
||
// for (size_t i = 0; i < _rawOutputBbox.size(); i++) {
|
||
// cv::Rect rect = _rawOutputBbox[i].box;
|
||
// Face face(i, rect);
|
||
// face.ageGenderEnable(this->_enableAgeGender && _ageGenderDetector->enabled());
|
||
// face.emotionsEnable(this->_enableFaceEmotions && _emotionsDetector->enabled());
|
||
// face.headPoseEnable(this->_enableHeadPose && _headPoseDetector->enabled());
|
||
// face.antispoofingEnable(this->_enableAntiProof && _antisproofDetector->enabled());
|
||
|
||
// if (face.isAgeGenderEnabled()) {
|
||
// if (!_rawOutputBbox[i].mask.empty()) {
|
||
// cv::Mat mask = _rawOutputBbox[i].mask.clone();
|
||
// if (mask.empty()) continue;
|
||
// if ((mask.cols < 5) && (mask.rows < 5)) continue;
|
||
// AgeGenderResults ageGenderResult = _ageGenderDetector->runInfer(mask);
|
||
// face.updateGender(ageGenderResult.maleProb);
|
||
// face.updateAge(ageGenderResult.age);
|
||
// mask.release();
|
||
// }
|
||
// }
|
||
// if (face.isEmotionsEnabled()) {
|
||
// if (!_rawOutputBbox[i].mask.empty()) {
|
||
// cv::Mat mask = _rawOutputBbox[i].mask.clone();
|
||
// if (mask.empty()) continue;
|
||
// if ((mask.cols < 5) && (mask.rows < 5)) continue;
|
||
// std::map<std::string, float> emotions = _emotionsDetector->runInfer(mask);
|
||
// face.updateEmotions(emotions);
|
||
// mask.release();
|
||
// }
|
||
// }
|
||
// if (face.isHeadPoseEnabled()) {
|
||
// if (!_rawOutputBbox[i].mask.empty()) {
|
||
// cv::Mat mask = _rawOutputBbox[i].mask.clone();
|
||
// if (mask.empty()) continue;
|
||
// if ((mask.cols < 5) && (mask.rows < 5)) continue;
|
||
// HeadPoseResults headPoseResult = _headPoseDetector->runInfer(mask);
|
||
// face.updateHeadPose(headPoseResult);
|
||
// mask.release();
|
||
// }
|
||
// }
|
||
// if (face.isAntispoofingEnabled()) {
|
||
// if (!_rawOutputBbox[i].mask.empty()) {
|
||
// cv::Mat mask = _rawOutputBbox[i].mask.clone();
|
||
// if (mask.empty()) continue;
|
||
// if ((mask.cols < 5) && (mask.rows < 5)) continue;
|
||
// float confidence = _antisproofDetector->runInfer(mask);
|
||
// face.updateRealFaceConfidence(confidence);
|
||
// mask.release();
|
||
// }
|
||
// }
|
||
// // convert face into string to add-into extra information
|
||
// bool isUnknown;
|
||
// isUnknown = false;
|
||
// FaceResultObject resultObject;
|
||
// resultObject.isUnknown = isUnknown;
|
||
// resultObject.userId = "0000";
|
||
// resultObject.userName = "Unknown";
|
||
// resultObject.similarity = 0;
|
||
// resultObject.confidence = 1.0;
|
||
// float x = _rawOutputBbox[i].box.x;
|
||
// float y = _rawOutputBbox[i].box.y;
|
||
// float w = _rawOutputBbox[i].box.width;;
|
||
// float h = _rawOutputBbox[i].box.height;
|
||
// resultObject.box.x = x;
|
||
// resultObject.box.y = y;
|
||
// resultObject.box.width = w;
|
||
// resultObject.box.height = h;
|
||
|
||
// resultObject.box.x = MAX(0.0f, resultObject.box.x);
|
||
// resultObject.box.y = MAX(0.0f, resultObject.box.y);
|
||
// resultObject.box.width = MIN((float)input.cols - resultObject.box.x, resultObject.box.width);
|
||
// resultObject.box.height = MIN((float)input.rows - resultObject.box.y, resultObject.box.height);
|
||
|
||
// resultObject.mask = _rawOutputBbox[i].mask;
|
||
// resultObject.polygon = _rawOutputBbox[i].polygon;
|
||
// resultObject.kps = _rawOutputBbox[i].kps;
|
||
// std::string faceAtt = ANSFRHelper::FaceAttributeToJsonString(face);
|
||
// resultObject.extraInformation = faceAtt;//coversion from face to string
|
||
// resultObject.cameraId = camera_id;
|
||
// resultObject.trackId = _rawOutputBbox[i].trackId;
|
||
// resultObjects.push_back(resultObject);
|
||
// }
|
||
|
||
// frame.release();
|
||
// _outputBbox.clear();
|
||
// return PostProcessDetection(resultObjects, camera_id);
|
||
// }
|
||
// catch (std::exception& e) {
|
||
// this->_logger.LogFatal("ANSFacialRecognition::Detect()", e.what(), __FILE__, __LINE__);
|
||
// std::vector<FaceResultObject> resultObjects;
|
||
// resultObjects.clear();
|
||
// return resultObjects;
|
||
// }
|
||
// }
|
||
|
||
// std::vector<FaceResultObject> ANSFacialRecognition::Inference(const cv::Mat& input, const std::string& camera_id) {
|
||
// std::lock_guard<std::recursive_mutex> lock(_mutex);
|
||
// if (!_isInitialized) {
|
||
// std::vector<Object> _outputBbox;
|
||
// _outputBbox.clear();
|
||
// std::vector<FaceResultObject> resultObjects;
|
||
// this->_logger.LogError("ANSFacialRecognition::Inference()", "Models are not initialized.", __FILE__, __LINE__);
|
||
// return resultObjects;
|
||
// }
|
||
// try {
|
||
// std::vector<FaceResultObject> resultObjects;
|
||
// std::vector<Object> _outputBbox;
|
||
// if (input.empty()) {
|
||
// this->_logger.LogFatal("ANSFacialRecognition::Inference()", "image frame is empty", __FILE__, __LINE__);
|
||
// return resultObjects;
|
||
// }
|
||
// if ((input.cols < 10) || (input.rows < 10)) return resultObjects;
|
||
// // Convert grayscale images to 3-channel BGR if needed
|
||
// cv::Mat frame;
|
||
// if (input.channels() == 1) {
|
||
// cv::cvtColor(input, frame, cv::COLOR_GRAY2BGR);
|
||
// }
|
||
// else {
|
||
// frame = input.clone();
|
||
// }
|
||
|
||
|
||
// _outputBbox = _detector->RunInference(frame,camera_id);
|
||
// if (_outputBbox.empty()) {
|
||
// return resultObjects;
|
||
// }
|
||
// // Filter out the faces that are too small
|
||
// std::vector<Object> validFaces=checkFaces(_outputBbox, true);
|
||
// resultObjects = _recognizer->Match(frame, validFaces, _userDict);
|
||
// updateFaceAttributes(resultObjects);
|
||
// ensureUniqueUserIdWithHighestConfidence(resultObjects);
|
||
// frame.release();
|
||
// return PostProcessDetection(resultObjects, camera_id);
|
||
// }
|
||
// catch (std::exception& e) {
|
||
// this->_logger.LogFatal("ANSFacialRecognition::Inference()", e.what(), __FILE__, __LINE__);
|
||
// return std::vector<FaceResultObject>();
|
||
// }
|
||
// }
|
||
|
||
//int ANSFacialRecognition::GetUser(int userId, UserRecord& userRecord) {
|
||
// try {
|
||
// // Initialize user ID
|
||
// userRecord.UserId = userId;
|
||
|
||
// // LOCK ONLY DURING DATABASE ACCESS
|
||
// {
|
||
// std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
|
||
// // Get user basic information
|
||
// int result = _db->GetUser(userId, userRecord.UserCode, userRecord.UserName);
|
||
// if (result <= 0) {
|
||
// LogThreadSafe("ANSFacialRecognition::GetUser",
|
||
// "User ID " + std::to_string(userId) + " not found in database");
|
||
// return 0;
|
||
// }
|
||
|
||
// // Get user's face IDs
|
||
// result = _db->GetFaceIdsByUser(userId, userRecord.FaceIds);
|
||
// if (result <= 0) {
|
||
// LogThreadSafe("ANSFacialRecognition::GetUser",
|
||
// "No faces found for user ID " + std::to_string(userId));
|
||
// return 0;
|
||
// }
|
||
// }
|
||
|
||
// return 1;
|
||
// }
|
||
// catch (const std::exception& e) {
|
||
// LogThreadSafe("ANSFacialRecognition::GetUser",
|
||
// "User ID " + std::to_string(userId) + ": " + e.what());
|
||
// return 0;
|
||
// }
|
||
//}
|
||
//int ANSFacialRecognition::GetUser(int userId, std::string userCode, std::string userName, UserRecord& userRecord) {
|
||
// try {
|
||
// // Initialize user ID
|
||
// userRecord.UserId = userId;
|
||
// userRecord.UserCode = userCode;
|
||
// userRecord.UserName = userName;
|
||
|
||
// // LOCK ONLY DURING DATABASE ACCESS
|
||
// {
|
||
// std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
// // Get user's face IDs
|
||
// int result = _db->GetFaceIdsByUser(userId, userRecord.FaceIds);
|
||
// if (result <= 0) {
|
||
// LogThreadSafe("ANSFacialRecognition::GetUser",
|
||
// "No faces found for user ID " + std::to_string(userId));
|
||
// return 0;
|
||
// }
|
||
// }
|
||
|
||
// return 1;
|
||
// }
|
||
// catch (const std::exception& e) {
|
||
// LogThreadSafe("ANSFacialRecognition::GetUser",
|
||
// "User ID " + std::to_string(userId) + ": " + e.what());
|
||
// return 0;
|
||
// }
|
||
//}
|
||
|
||
//bool ANSFacialRecognition::UpdateUserDictionary() {
|
||
// try {
|
||
// // Load embeddings and user dictionary (with database lock)
|
||
// {
|
||
// std::lock_guard<std::mutex> lock(_databaseMutex);
|
||
|
||
// if (!_db) {
|
||
// LogThreadSafe("ANSFacialRecognition::UpdateUserDictionary",
|
||
// "Database not initialized");
|
||
// return false;
|
||
// }
|
||
|
||
// _userDict = _db->GetUserDict();
|
||
// }
|
||
// return true;
|
||
// }
|
||
// catch (const std::exception& e) {
|
||
// LogThreadSafe("ANSFacialRecognition::UpdateUserDictionary",
|
||
// "Failed to update user dictiornary: " + std::string(e.what()));
|
||
// return false;
|
||
// }
|
||
//}
|