ANSFR: support ANS_FaceRecognizer v1.4 models (AdaFace + ONNX attributes)

- Recognizer: adafacerecognizer.onnx (AdaFace, new default) with automatic
  fallback to ansfacerecognizer.onnx (ArcFace) for pre-v1.4 zips. AdaFace
  consumes BGR: new AdaFace handler in ONNXEngine skips the BGR2RGB swap,
  and the TensorRT paths gate their cvtColor on m_swapRB.
- New C API: SetANSRFRecognizerModel (0=AdaFace, 1=ArcFace),
  GetANSRFRecognizerModel, GetANSRFModelInfo. A live switch reloads the
  recognizer and regenerates all stored embeddings from the enrolled face
  crops; the generating model is persisted in a new SETTINGS table
  (EMBEDDING_MODEL) so upgrading an ArcFace database to the AdaFace
  default migrates automatically on LoadEngine.
- Attributes: prefer agegender.onnx (ViT: gender_logits [male,female] +
  age_pred in years; also handles the single-tensor research export) and
  emotionsrecognition.onnx (YOLOv11-cls, classes from .names) behind new
  IAgeGenderEstimator/IEmotionsClassifier interfaces, falling back to the
  legacy OpenVINO IRs. EP follows hardware: NVIDIA uses TensorRT EP with
  disk-cached engines, AMD DirectML, Intel OpenVINO.
- Emotion JSON mapping: handle the new Fear class and the never-matched
  surprise label (both map to Attentive).
- ANSFR-UnitTest: TestModelSwitchV14 covers default model selection, ONNX
  attribute backends, enrollment, and adaface<->arcface switching.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
2026-08-26 11:06:10 +10:00
co-authored by Claude Fable 5
parent 881d783fa3
commit ac4369302a
15 changed files with 1111 additions and 51 deletions
+54
View File
@@ -1044,6 +1044,60 @@ namespace ANSCENTER {
}
}
// ====================================================================
// AdaFace
// ====================================================================
Ort::Value AdaFace::transform(const cv::Mat& mat)
{
if (mat.empty())
throw std::runtime_error("AdaFace::transform — input is empty.");
// AdaFace consumes BGR — OpenCV Mats are already BGR, no channel swap.
cv::Mat canvas;
cv::resize(mat, canvas, cv::Size(input_node_dims.at(3), input_node_dims.at(2)));
if (canvas.type() != CV_32FC3)
canvas.convertTo(canvas, CV_32FC3);
utils::transform::normalize_inplace(canvas, mean_val, scale_val);
std::vector<int64_t> shape = input_node_dims;
if (shape[0] == -1) shape[0] = 1;
return utils::transform::create_tensor(
canvas, shape, *memory_info_handler,
input_values_handler, utils::transform::CHW);
}
Ort::Value AdaFace::transformBatch(const std::vector<cv::Mat>& images)
{
if (images.empty())
throw std::runtime_error("AdaFace::transformBatch — batch is empty.");
const int width = input_node_dims.at(3);
const int height = input_node_dims.at(2);
std::vector<cv::Mat> batch;
batch.reserve(images.size());
for (const auto& mat : images) {
if (mat.empty())
throw std::runtime_error("AdaFace::transformBatch — empty image in batch.");
cv::Mat canvas;
cv::resize(mat, canvas, cv::Size(width, height));
if (canvas.type() != CV_32FC3)
canvas.convertTo(canvas, CV_32FC3);
utils::transform::normalize_inplace(canvas, mean_val, scale_val);
batch.push_back(std::move(canvas));
}
std::vector<int64_t> shape = input_node_dims;
shape[0] = static_cast<int64_t>(images.size());
return utils::transform::create_tensor_batch(
batch, shape, *memory_info_handler,
input_values_handler, utils::transform::CHW);
}
// ====================================================================
// GlintCosFace
// ====================================================================
+34
View File
@@ -674,6 +674,40 @@ namespace ANSCENTER {
Ort::Value transformBatch(const std::vector<cv::Mat>& images) override;
};
// ====================================================================
// AdaFace — face recognition
//
// Same session/inference path as GlintArcFace (detect/detectBatch are
// inherited and dispatch through the virtual transform), but AdaFace
// was trained on BGR input — the official repo flips RGB→BGR before
// normalize — so the BGR2RGB conversion is omitted: OpenCV Mats are
// already BGR. Normalization is identical: (x - 127.5) / 127.5.
// ====================================================================
class AdaFace : public GlintArcFace
{
public:
explicit AdaFace(const std::string& _onnx_path,
unsigned int _num_threads = 1)
: GlintArcFace(_onnx_path, _num_threads)
{
}
explicit AdaFace(const std::string& _onnx_path,
EngineType engineType,
unsigned int _num_threads = 1)
: GlintArcFace(_onnx_path, engineType, _num_threads) {
}
~AdaFace() override = default;
private:
static constexpr float mean_val = 127.5f;
static constexpr float scale_val = 1.f / 127.5f;
Ort::Value transform(const cv::Mat& mat) override;
Ort::Value transformBatch(const std::vector<cv::Mat>& images) override;
};
// ====================================================================
// MOVINET — action recognition
// ====================================================================
+280 -13
View File
@@ -4,6 +4,7 @@
#include "ANSOVFaceDetector.h"
#include "SCRFDFaceDetector.h"
#include "ANSFaceRecognizer.h"
#include "ONNXFaceAttributes.h"
#include <faiss/IndexIDMap.h>
#include <faiss/IndexFlat.h>
#include <boost/uuid/uuid.hpp>
@@ -463,6 +464,16 @@ namespace ANSCENTER {
attributeModelsSuccess = false;
}
// Embedding/model consistency: stored embeddings must come from
// the recognizer model that just loaded. A v1.4 upgrade flips the
// default from ArcFace to AdaFace, which silently invalidates a
// pre-existing database — regenerate before the index builds.
if (!SyncEmbeddingsWithActiveModel()) {
LogThreadSafe("ANSFacialRecognition::LoadEngine",
"Warning: embedding/model sync failed — recognition may return "
"Unknown until faces are re-enrolled");
}
// Reload database/embeddings
if (!Reload()) {
LogThreadSafe("ANSFacialRecognition::LoadEngine",
@@ -818,9 +829,12 @@ namespace ANSCENTER {
}
bool ANSFacialRecognition::InitializeRecognizer() {
try {
ANS_DBG("ANSFR", "InitializeRecognizer: starting, modelPath=%s", _recognizerFilePath.c_str());
ANS_DBG("ANSFR", "InitializeRecognizer: starting, modelPath=%s model=%s",
_recognizerFilePath.c_str(), FaceRecognizerModelName(_requestedRecModel));
// Create recognizer instance
_recognizer = std::make_unique<ANSFaceRecognizer>();
auto recognizer = std::make_unique<ANSFaceRecognizer>();
recognizer->SetPreferredModel(_requestedRecModel);
_recognizer = std::move(recognizer);
_recognizer->SetMaxSlotsPerGpu(m_maxSlotsPerGpu);
// Configure model
@@ -861,7 +875,13 @@ namespace ANSCENTER {
return false;
}
ANS_DBG("ANSFR", "InitializeRecognizer: SUCCESS");
// Record what actually loaded — ADAFACE silently falls back to
// ARCFACE when the model pack has no adafacerecognizer.onnx.
if (auto* concrete = dynamic_cast<ANSFaceRecognizer*>(_recognizer.get())) {
_activeRecModel = concrete->GetActiveModel();
}
ANS_DBG("ANSFR", "InitializeRecognizer: SUCCESS, active model=%s",
FaceRecognizerModelName(_activeRecModel));
return true;
}
catch (const std::exception& e) {
@@ -924,8 +944,50 @@ namespace ANSCENTER {
return false;
}
}
namespace {
// EP options for the ONNX attribute models. On NVIDIA the models are
// built into TensorRT engines through the TRT EP and cached on disk
// next to the model pack (first load pays the build, every later load
// is instant). AMD/Intel/CPU resolve to DirectML/OpenVINO/CPU inside
// BasicOrtHandler and ignore every TRT field.
OrtHandlerOptions BuildAttributeOrtOptions(EngineType engineType,
const std::string& modelFolder) {
OrtHandlerOptions opts;
if (engineType == EngineType::NVIDIA_GPU) {
opts.preferTensorRT = true;
opts.trtFP16 = true;
opts.trtEngineCacheDir = CreateFilePath(modelFolder, "TRTCache");
std::error_code ec;
std::filesystem::create_directories(opts.trtEngineCacheDir, ec);
}
return opts;
}
}
bool ANSFacialRecognition::InitializeAgeGenderModel(const std::string& deviceName) {
try {
// Prefer the ONNX model shipped since v1.4; fall back to the
// legacy OpenVINO IR when it is absent (or fails to load).
std::string onnxModelPath = CreateFilePath(_recognizerModelFolder, "agegender.onnx");
if (FileExist(onnxModelPath)) {
try {
auto detector = std::make_unique<OnnxAgeGenderEstimator>(
onnxModelPath, engineType,
BuildAttributeOrtOptions(engineType, _recognizerModelFolder));
std::lock_guard<std::mutex> lock(_ageGenderMutex);
_ageGenderDetector = std::move(detector);
LogThreadSafe("ANSFacialRecognition::InitializeAgeGenderModel",
"Loaded ONNX age-gender model: " + onnxModelPath, LogLevel::Info);
return true;
}
catch (const std::exception& e) {
LogThreadSafe("ANSFacialRecognition::InitializeAgeGenderModel",
"ONNX age-gender model failed (" + std::string(e.what()) +
") — falling back to OpenVINO model");
}
}
std::string ageGenderModelPath = CreateFilePath(_recognizerModelFolder, "agegender.xml");
if (!FileExist(ageGenderModelPath)) {
@@ -949,18 +1011,20 @@ namespace ANSCENTER {
_ageGenderDetector.reset();
// Create new detector
_ageGenderDetector = std::make_unique<AgeGenderDetection>(ageGenderModelPath, true);
auto detector = std::make_unique<AgeGenderDetection>(ageGenderModelPath, true);
// Compile model for target device
ov::CompiledModel compiledModel = core->compile_model(
_ageGenderDetector->read(*core),
detector->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);
detector->request = compiledModel.create_infer_request();
detector->inTensor = detector->request.get_input_tensor();
detector->inTensor.set_shape(detector->inShape);
_ageGenderDetector = std::move(detector);
}
return true;
@@ -979,6 +1043,30 @@ namespace ANSCENTER {
}
bool ANSFacialRecognition::InitializeEmotionModel(const std::string& deviceName) {
try {
// Prefer the YOLOv11 classifier shipped since v1.4 (class list in
// emotionsrecognition.names); fall back to the OpenVINO IR.
std::string onnxModelPath = CreateFilePath(_recognizerModelFolder, "emotionsrecognition.onnx");
if (FileExist(onnxModelPath)) {
try {
std::string namesPath = CreateFilePath(_recognizerModelFolder, "emotionsrecognition.names");
auto classNames = OnnxEmotionsClassifier::LoadClassNames(namesPath);
auto detector = std::make_unique<OnnxEmotionsClassifier>(
onnxModelPath, std::move(classNames), engineType,
BuildAttributeOrtOptions(engineType, _recognizerModelFolder));
std::lock_guard<std::mutex> lock(_emotionsMutex);
_emotionsDetector = std::move(detector);
LogThreadSafe("ANSFacialRecognition::InitializeEmotionModel",
"Loaded ONNX emotion model: " + onnxModelPath, LogLevel::Info);
return true;
}
catch (const std::exception& e) {
LogThreadSafe("ANSFacialRecognition::InitializeEmotionModel",
"ONNX emotion model failed (" + std::string(e.what()) +
") — falling back to OpenVINO model");
}
}
std::string emotionModelPath = CreateFilePath(_recognizerModelFolder, "emotionsrecognition.xml");
if (!FileExist(emotionModelPath)) {
@@ -1002,18 +1090,20 @@ namespace ANSCENTER {
_emotionsDetector.reset();
// Create new detector
_emotionsDetector = std::make_unique<EmotionsDetection>(emotionModelPath, true);
auto detector = std::make_unique<EmotionsDetection>(emotionModelPath, true);
// Compile model for target device
ov::CompiledModel compiledModel = core->compile_model(
_emotionsDetector->read(*core),
detector->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);
detector->request = compiledModel.create_infer_request();
detector->inTensor = detector->request.get_input_tensor();
detector->inTensor.set_shape(detector->inShape);
_emotionsDetector = std::move(detector);
}
return true;
@@ -1085,6 +1175,183 @@ namespace ANSCENTER {
}
}
bool ANSFacialRecognition::SyncEmbeddingsWithActiveModel() {
try {
if (!_db || !_recognizer) return false;
const std::string activeName = FaceRecognizerModelName(_activeRecModel);
std::string storedName;
std::vector<FaceRecord> faces;
{
std::lock_guard<std::mutex> lock(_databaseMutex);
storedName = _db->GetSetting("EMBEDDING_MODEL");
if (_db->GetAllFaces(faces) != 0) return false;
}
if (storedName.empty()) {
// Databases created before v1.4 never recorded the model —
// every embedding in them came from ArcFace.
storedName = faces.empty() ? activeName : "arcface";
}
if (storedName != activeName && !faces.empty()) {
LogThreadSafe("ANSFacialRecognition::SyncEmbeddingsWithActiveModel",
"Stored embeddings were generated by '" + storedName +
"' but the active recognizer is '" + activeName +
"' — regenerating " + std::to_string(faces.size()) +
" embeddings from the enrolled face images", LogLevel::Info);
if (!RegenerateEmbeddings()) return false;
}
{
std::lock_guard<std::mutex> lock(_databaseMutex);
_db->SetSetting("EMBEDDING_MODEL", activeName);
}
return true;
}
catch (const std::exception& e) {
LogThreadSafe("ANSFacialRecognition::SyncEmbeddingsWithActiveModel", e.what());
return false;
}
}
bool ANSFacialRecognition::RegenerateEmbeddings() {
try {
if (!_db || !_recognizer || !_recognizer->IsInitialized()) {
LogThreadSafe("ANSFacialRecognition::RegenerateEmbeddings",
"Recognizer/database not ready");
return false;
}
std::vector<FaceRecord> faces;
{
std::lock_guard<std::mutex> lock(_databaseMutex);
if (_db->GetAllFaces(faces) != 0) return false;
}
if (faces.empty()) return true;
size_t updated = 0, failed = 0;
for (const auto& face : faces) {
// InsertFace stored the aligned face crop — compute the new
// embedding directly on it, no re-detection needed.
cv::Mat crop = cv::imread(face.ImagePath, cv::IMREAD_COLOR);
if (crop.empty()) {
LogThreadSafe("ANSFacialRecognition::RegenerateEmbeddings",
"Cannot read enrolled face image (face ID " +
std::to_string(face.FaceId) + "): " + face.ImagePath);
++failed;
continue;
}
Object faceObject;
faceObject.mask = crop;
std::vector<float> embedding;
{
std::lock_guard<std::mutex> lock(_recognitionMutex);
embedding = _recognizer->Feature(crop, faceObject);
}
if (embedding.size() != static_cast<size_t>(_config._recOutputDim)) {
LogThreadSafe("ANSFacialRecognition::RegenerateEmbeddings",
"Embedding failed for face ID " + std::to_string(face.FaceId));
++failed;
continue;
}
std::lock_guard<std::mutex> lock(_databaseMutex);
if (_db->UpdateFaceEmbedding(face.FaceId, embedding.data()) > 0) ++updated;
else ++failed;
}
LogThreadSafe("ANSFacialRecognition::RegenerateEmbeddings",
"Regenerated " + std::to_string(updated) + "/" +
std::to_string(faces.size()) + " embeddings (" +
std::to_string(failed) + " failed)", LogLevel::Info);
_reloadNeeded.store(true);
return updated > 0 || failed == 0;
}
catch (const std::exception& e) {
LogThreadSafe("ANSFacialRecognition::RegenerateEmbeddings", e.what());
return false;
}
}
bool ANSFacialRecognition::SetRecognizerModelType(int modelType) {
try {
if (modelType < 0 || modelType > 1) {
LogThreadSafe("ANSFacialRecognition::SetRecognizerModelType",
"Invalid model type: " + std::to_string(modelType) +
" (0 = AdaFace, 1 = ArcFace)");
return false;
}
const auto requested = static_cast<FaceRecognizerModel>(modelType);
_requestedRecModel = requested;
// Engine not loaded yet — the preference is applied by LoadEngine.
if (!_recognizer) return true;
if (requested == _activeRecModel) return true;
LogThreadSafe("ANSFacialRecognition::SetRecognizerModelType",
"Switching recognizer model to '" +
std::string(FaceRecognizerModelName(requested)) + "'", LogLevel::Info);
if (!InitializeRecognizer()) {
LogThreadSafe("ANSFacialRecognition::SetRecognizerModelType",
"Failed to load recognizer for model '" +
std::string(FaceRecognizerModelName(requested)) + "'");
return false;
}
_recognizerModelFolder = _recognizer->GetModelFolder();
if (!SyncEmbeddingsWithActiveModel()) {
LogThreadSafe("ANSFacialRecognition::SetRecognizerModelType",
"Warning: embedding regeneration failed after model switch");
}
_reloadNeeded.store(true);
return Reload();
}
catch (const std::exception& e) {
LogThreadSafe("ANSFacialRecognition::SetRecognizerModelType", e.what());
return false;
}
}
int ANSFacialRecognition::GetRecognizerModelType() const {
return static_cast<int>(_recognizer ? _activeRecModel : _requestedRecModel);
}
std::string ANSFacialRecognition::GetActiveModelInfo() {
try {
const char* agegenderBackend = "disabled";
const char* emotionBackend = "disabled";
{
std::lock_guard<std::mutex> lock(_ageGenderMutex);
if (_ageGenderDetector && _ageGenderDetector->enabled())
agegenderBackend = _ageGenderDetector->backendName();
}
{
std::lock_guard<std::mutex> lock(_emotionsMutex);
if (_emotionsDetector && _emotionsDetector->enabled())
emotionBackend = _emotionsDetector->backendName();
}
nlohmann::json info;
info["recognizer_model"] = FaceRecognizerModelName(
_recognizer ? _activeRecModel : _requestedRecModel);
info["recognizer_loaded"] = (_recognizer != nullptr);
info["agegender_backend"] = agegenderBackend;
info["emotion_backend"] = emotionBackend;
return info.dump();
}
catch (const std::exception& e) {
LogThreadSafe("ANSFacialRecognition::GetActiveModelInfo", e.what());
return "{}";
}
}
bool ANSFacialRecognition::UpdateParameters(
float knownPersonThreshold,
bool enableAgeGender,
+39 -2
View File
@@ -97,6 +97,17 @@ namespace ANSCENTER
bool UpdateFaceQueue(int queueSize, int faceThresholdSize, bool enableFaceQueue);
bool GetFaceQueue(int& queueSize, int& faceThresholdSize, bool& enableFaceQueue);
// Recognizer model switching (0 = AdaFace [default], 1 = ArcFace).
// Before LoadEngine: just records the preference. After LoadEngine:
// re-initializes the recognizer, regenerates every stored embedding
// from the enrolled face crops (embeddings from different models are
// not comparable), and rebuilds the FAISS index.
bool SetRecognizerModelType(int modelType);
int GetRecognizerModelType() const;
// JSON summary of what is actually loaded: recognizer model plus the
// backend ("onnx" | "openvino" | "disabled") serving each attribute.
[[nodiscard]] std::string GetActiveModelInfo();
[[nodiscard]] std::vector<FaceResultObject> Recognize(const cv::Mat& frame); // Expect to return on 1 object
[[nodiscard]] std::vector<FaceResultObject> Inference(const cv::Mat& input);
[[nodiscard]] std::vector<FaceResultObject> Detect(const cv::Mat& input);
@@ -141,6 +152,11 @@ namespace ANSCENTER
bool InitializeAgeGenderModel(const std::string& deviceName);
bool InitializeEmotionModel(const std::string& deviceName);
bool InitializeHeadPoseModel(const std::string& deviceName);
// Regenerates stored embeddings when they were produced by a
// different recognizer model than the one currently loaded
// (tracked via the EMBEDDING_MODEL key in the face database).
bool SyncEmbeddingsWithActiveModel();
bool RegenerateEmbeddings();
void ensureUniqueUserIdWithHighestConfidence(std::vector<FaceResultObject>& resultObjects, CameraData* camData = nullptr);
Object GetLargestObject(const std::vector<Object>& objects);
bool AreFacesSimilar(const FaceResultObject& face1, const FaceResultObject& face2);
@@ -214,9 +230,13 @@ namespace ANSCENTER
std::unique_ptr<ANSFRBase>_recognizer = nullptr;
std::unique_ptr<ANSFDBase>_detector = nullptr;
std::unique_ptr<AntispoofingClassifier>_antiSpoofDetector = nullptr;
std::unique_ptr<AgeGenderDetection>_ageGenderDetector = nullptr;
std::unique_ptr<IAgeGenderEstimator>_ageGenderDetector = nullptr;
std::unique_ptr<HeadPoseDetection>_headPoseDetector = nullptr;
std::unique_ptr<EmotionsDetection>_emotionsDetector = nullptr;
std::unique_ptr<IEmotionsClassifier>_emotionsDetector = nullptr;
// Recognizer model preference (settable before/after LoadEngine)
// and what actually loaded (fallback may downgrade ADAFACE->ARCFACE).
FaceRecognizerModel _requestedRecModel{ FaceRecognizerModel::ADAFACE };
FaceRecognizerModel _activeRecModel{ FaceRecognizerModel::ADAFACE };
const size_t QUEUE_SIZE = 10;
const size_t FACE_THRESHOLD_SIZE = 5;
// Cached attribute JSON per tracked face (everything except head pose).
@@ -348,6 +368,23 @@ extern "C" ANSFR_API int GetParamters(ANSCENTER::ANSFacialRecognition** Handl
extern "C" ANSFR_API int UpdateFaceQueue(ANSCENTER::ANSFacialRecognition** Handle, int queueSize, int numKnownFaceInQueue, int enableFaceQueue);
extern "C" ANSFR_API int GetFaceQueue(ANSCENTER::ANSFacialRecognition** Handle, LStrHandle faceQueue);
// Recognizer model switching (ANS_FaceRecognizer v1.4+).
// modelType: 0 = AdaFace (default), 1 = ArcFace.
// Call before LoadANSRFEngine to pick the model for the initial load, or
// after it to switch live — a live switch reloads the recognizer engine and
// regenerates every stored face embedding from the enrolled face images
// (embeddings produced by different models are not comparable), so it can
// take a while on large databases. Returns 1 on success, 0 on failure, -1 on
// invalid arguments.
extern "C" ANSFR_API int SetANSRFRecognizerModel(ANSCENTER::ANSFacialRecognition** Handle, int modelType);
// Returns the ACTIVE model (0 = AdaFace, 1 = ArcFace) or -1 on error. May
// differ from what was requested when the model pack has no
// adafacerecognizer.onnx (pre-v1.4 zips fall back to ArcFace).
extern "C" ANSFR_API int GetANSRFRecognizerModel(ANSCENTER::ANSFacialRecognition** Handle);
// JSON describing the loaded models, e.g.
// {"recognizer_model":"adaface","agegender_backend":"onnx","emotion_backend":"onnx",...}
extern "C" ANSFR_API int GetANSRFModelInfo(ANSCENTER::ANSFacialRecognition** Handle, LStrHandle modelInfo);
extern "C" ANSFR_API int GetUserString(ANSCENTER::ANSFacialRecognition * *Handle, int userId, std::string& userRecord);
+4
View File
@@ -654,10 +654,14 @@ namespace ANSCENTER {
adjustedEmotionName = "Attentive";
else if (emotionName == "Surprised" || emotionName == "surprised")
adjustedEmotionName = "Attentive";
else if (emotionName == "Surprise" || emotionName == "surprise")
adjustedEmotionName = "Attentive";
else if (emotionName == "Disgusted" || emotionName == "disgusted")
adjustedEmotionName = "Attentive";
else if (emotionName == "Fearful" || emotionName == "fearful")
adjustedEmotionName = "Attentive";
else if (emotionName == "Fear" || emotionName == "fear")
adjustedEmotionName = "Attentive";
else if (emotionName == "Anger" || emotionName == "anger")
adjustedEmotionName = "Attentive";
else
+44 -4
View File
@@ -107,6 +107,42 @@ namespace ANSCENTER {
float age;
float maleProb;
};
// Which face-embedding model the recognizer runs. ADAFACE is the default
// since ANS_FaceRecognizer v1.4 (adafacerecognizer.onnx); when that file
// is missing from the model zip the recognizer silently falls back to
// ARCFACE (ansfacerecognizer.onnx) so v1.3-and-older zips keep working.
enum class FaceRecognizerModel : int {
ADAFACE = 0,
ARCFACE = 1,
};
inline const char* FaceRecognizerModelName(FaceRecognizerModel m) {
return (m == FaceRecognizerModel::ARCFACE) ? "arcface" : "adaface";
}
// ----------------------------------------------------------------
// Attribute-model backends. The v1.4 model pack ships ONNX attribute
// models (agegender.onnx / emotionsrecognition.onnx) next to the
// legacy OpenVINO IR pairs (.xml/.bin). These interfaces let the
// pipeline hold either backend behind the same two calls it already
// makes: runInfer() and enabled().
// ----------------------------------------------------------------
class ANSF_API IAgeGenderEstimator {
public:
virtual ~IAgeGenderEstimator() = default;
virtual AgeGenderResults runInfer(const cv::Mat& frame) = 0;
virtual bool enabled() const = 0;
virtual const char* backendName() const = 0; // "openvino" | "onnx"
};
class ANSF_API IEmotionsClassifier {
public:
virtual ~IEmotionsClassifier() = default;
virtual std::map<std::string, float> runInfer(const cv::Mat& frame) = 0;
virtual bool enabled() const = 0;
virtual const char* backendName() const = 0; // "openvino" | "onnx"
};
//// Class for face attribute
class ANSF_API Face {
public:
@@ -200,7 +236,7 @@ namespace ANSCENTER {
//std::vector<HeadPoseResults> getAllResults();
};
class ANSF_API AgeGenderDetection :public BaseDetection {
class ANSF_API AgeGenderDetection : public BaseDetection, public IAgeGenderEstimator {
public:
std::recursive_mutex _mutex;
std::string outputAge;
@@ -211,7 +247,9 @@ namespace ANSCENTER {
bool doRawOutputMessages);
virtual std::shared_ptr<ov::Model> read(const ov::Core& core) override;
AgeGenderResults runInfer(const cv::Mat& frame);
AgeGenderResults runInfer(const cv::Mat& frame) override;
bool enabled() const override { return BaseDetection::enabled(); }
const char* backendName() const override { return "openvino"; }
//void submitRequest();
//void enqueue(const cv::Mat& face);
//AgeGenderResults getResult(int idx);
@@ -219,7 +257,7 @@ namespace ANSCENTER {
};
class ANSF_API EmotionsDetection : public BaseDetection {
class ANSF_API EmotionsDetection : public BaseDetection, public IEmotionsClassifier {
public:
std::recursive_mutex _mutex;
//size_t enquedFaces;
@@ -230,7 +268,9 @@ namespace ANSCENTER {
bool doRawOutputMessages);
virtual std::shared_ptr<ov::Model> read(const ov::Core& core) override;
std::map<std::string, float> runInfer(const cv::Mat& frame);
std::map<std::string, float> runInfer(const cv::Mat& frame) override;
bool enabled() const override { return BaseDetection::enabled(); }
const char* backendName() const override { return "openvino"; }
//void submitRequest();
//void enqueue(const cv::Mat& face);
//std::map<std::string, float> getResult(int idx);
+67 -24
View File
@@ -87,6 +87,31 @@ namespace {
}
namespace ANSCENTER {
std::string ANSFaceRecognizer::ResolveRecognizerModelFile() {
const std::string adaPath = CreateFilePath(_modelFolder, "adafacerecognizer.onnx");
const std::string arcPath = CreateFilePath(_modelFolder, "ansfacerecognizer.onnx");
if (_preferredModel == FaceRecognizerModel::ADAFACE) {
if (std::filesystem::exists(adaPath)) {
_activeModel = FaceRecognizerModel::ADAFACE;
m_swapRB = false; // AdaFace consumes BGR
ANS_DBG("FaceRecognizer", "Recognizer model resolved: ADAFACE (%s)", adaPath.c_str());
return adaPath;
}
_logger.LogWarn("ANSFaceRecognizer::ResolveRecognizerModelFile",
"adafacerecognizer.onnx not found in model pack — falling back to ArcFace",
__FILE__, __LINE__);
}
_activeModel = FaceRecognizerModel::ARCFACE;
m_swapRB = true; // ArcFace consumes RGB
if (std::filesystem::exists(arcPath)) {
ANS_DBG("FaceRecognizer", "Recognizer model resolved: ARCFACE (%s)", arcPath.c_str());
return arcPath;
}
return std::string();
}
std::string ANSFaceRecognizer::GetOpenVINODevice() {
ov::Core core;
std::vector<std::string> available_devices = core.get_available_devices();
@@ -146,16 +171,16 @@ namespace ANSCENTER {
static_cast<int>(EngineType::AMD_GPU),
static_cast<int>(EngineType::CPU));
if (engineType == EngineType::NVIDIA_GPU) {
// 1. Load ONNX model
std::string onnxfile = CreateFilePath(_modelFolder, "ansfacerecognizer.onnx");
if (std::filesystem::exists(onnxfile)) {
// 1. Load ONNX model (adaface by default, arcface fallback)
std::string onnxfile = ResolveRecognizerModelFile();
if (!onnxfile.empty()) {
_modelFilePath = onnxfile;
_logger.LogDebug("ANSFaceRecognizer::Initialize. Loading ansfacerecognizer weight",
_logger.LogDebug("ANSFaceRecognizer::Initialize. Loading face recognizer weight",
_modelFilePath, __FILE__, __LINE__);
}
else {
_logger.LogError("ANSFaceRecognizer::Initialize. Model ansfacerecognizer.onnx does not exist",
_modelFilePath, __FILE__, __LINE__);
_logger.LogError("ANSFaceRecognizer::Initialize. No recognizer model (adafacerecognizer.onnx / ansfacerecognizer.onnx) exists",
_modelFolder, __FILE__, __LINE__);
return false;
}
@@ -213,24 +238,28 @@ namespace ANSCENTER {
}
else {
#ifdef USE_ONNX_ENGINE
std::string faceidModel = CreateFilePath(_modelFolder, "ansfacerecognizer.onnx");
if (std::filesystem::exists(faceidModel)) {
std::string faceidModel = ResolveRecognizerModelFile();
if (!faceidModel.empty()) {
_modelFilePath = faceidModel;
_logger.LogDebug("ANSFaceRecognizer::Initialize. Loading ANSFaceRecognizer weight",
_modelFilePath, __FILE__, __LINE__);
}
else {
_logger.LogError("ANSFaceRecognizer::Initialize. Model ansfacerecognizer.onnx does not exist",
_modelFilePath, __FILE__, __LINE__);
_logger.LogError("ANSFaceRecognizer::Initialize. No recognizer model (adafacerecognizer.onnx / ansfacerecognizer.onnx) exists",
_modelFolder, __FILE__, __LINE__);
return false;
}
ANS_DBG("FaceRecognizer", "Creating GlintArcFace with engineType=%d model=%s",
ANS_DBG("FaceRecognizer", "Creating %s with engineType=%d model=%s",
FaceRecognizerModelName(_activeModel),
static_cast<int>(engineType), faceidModel.c_str());
if (_activeModel == FaceRecognizerModel::ADAFACE)
faceRecognizer = std::make_unique<AdaFace>(faceidModel, engineType);
else
faceRecognizer = std::make_unique<GlintArcFace>(faceidModel, engineType);
if (!faceRecognizer) {
_logger.LogFatal("ANSFaceRecognizer::Initialize",
"Failed to initialize ONNX face recognizer", __FILE__, __LINE__);
ANS_DBG("FaceRecognizer", "FAILED: GlintArcFace returned null");
ANS_DBG("FaceRecognizer", "FAILED: ONNX face recognizer returned null");
return false;
}
#else
@@ -279,29 +308,29 @@ namespace ANSCENTER {
if (!result) return false;
if (engineType == EngineType::NVIDIA_GPU) {
std::string onnxfile = CreateFilePath(_modelFolder, "ansfacerecognizer.onnx");
if (std::filesystem::exists(onnxfile)) {
std::string onnxfile = ResolveRecognizerModelFile();
if (!onnxfile.empty()) {
_modelFilePath = onnxfile;
_logger.LogDebug("ANSFaceRecognizer::LoadModel. Loading ansfacerecognizer weight",
_logger.LogDebug("ANSFaceRecognizer::LoadModel. Loading face recognizer weight",
_modelFilePath, __FILE__, __LINE__);
}
else {
_logger.LogError("ANSFaceRecognizer::LoadModel. ansfacerecognizer.onnx not found",
_modelFilePath, __FILE__, __LINE__);
_logger.LogError("ANSFaceRecognizer::LoadModel. No recognizer model (adafacerecognizer.onnx / ansfacerecognizer.onnx) found",
_modelFolder, __FILE__, __LINE__);
return false;
}
}
else {
std::string faceidModel = CreateFilePath(_modelFolder, "ansfacerecognizer.onnx");
std::string faceidModel = ResolveRecognizerModelFile();
#ifdef USE_ONNX_ENGINE
if (std::filesystem::exists(faceidModel)) {
if (!faceidModel.empty()) {
_modelFilePath = faceidModel;
_logger.LogDebug("ANSFaceRecognizer::LoadModel. Loading ansfacerecognizer weight",
_logger.LogDebug("ANSFaceRecognizer::LoadModel. Loading face recognizer weight",
_modelFilePath, __FILE__, __LINE__);
}
else {
_logger.LogError("ANSFaceRecognizer::LoadModel. ansfacerecognizer.onnx not found",
_modelFilePath, __FILE__, __LINE__);
_logger.LogError("ANSFaceRecognizer::LoadModel. No recognizer model (adafacerecognizer.onnx / ansfacerecognizer.onnx) found",
_modelFolder, __FILE__, __LINE__);
return false;
}
#else
@@ -834,7 +863,7 @@ namespace ANSCENTER {
}
try {
// CPU preprocessing: resize + BGR→RGB before GPU upload
// CPU preprocessing: resize + channel order before GPU upload
// Reduces PCIe transfer and eliminates GPU cvtColor/resize overhead
cv::Mat srcImg = inputImage;
if (srcImg.channels() == 1) {
@@ -846,8 +875,13 @@ namespace ANSCENTER {
} else {
cpuResized = srcImg;
}
// ArcFace needs RGB; AdaFace consumes the Mat's native BGR.
cv::Mat cpuRGB;
if (m_swapRB) {
cv::cvtColor(cpuResized, cpuRGB, cv::COLOR_BGR2RGB);
} else {
cpuRGB = cpuResized;
}
m_gpuRgb.upload(cpuRGB, *m_gpuStream);
m_gpuStream->waitForCompletion();
@@ -963,14 +997,19 @@ namespace ANSCENTER {
cv::cuda::resize(d_img, d_resized, targetSize, 0, 0, cv::INTER_LINEAR, *m_gpuStream);
d_img = d_resized;
}
// ArcFace needs RGB; AdaFace consumes native BGR.
if (m_swapRB) {
cv::cuda::GpuMat d_rgb;
cv::cuda::cvtColor(d_img, d_rgb, cv::COLOR_BGR2RGB, 0, *m_gpuStream);
batchGpu.emplace_back(std::move(d_rgb));
} else {
batchGpu.emplace_back(std::move(d_img));
}
} else {
const auto& roi = faceROIs[i];
if (roi.empty()) continue;
// CPU preprocessing: resize + BGR→RGB before upload
// CPU preprocessing: resize + channel order before upload
cv::Mat srcImg = roi;
if (srcImg.channels() == 1) {
cv::cvtColor(srcImg, srcImg, cv::COLOR_GRAY2BGR);
@@ -982,7 +1021,11 @@ namespace ANSCENTER {
cpuResized = srcImg;
}
cv::Mat cpuRGB;
if (m_swapRB) {
cv::cvtColor(cpuResized, cpuRGB, cv::COLOR_BGR2RGB);
} else {
cpuRGB = cpuResized;
}
cv::cuda::GpuMat d_rgb;
d_rgb.upload(cpuRGB, *m_gpuStream);
batchGpu.emplace_back(std::move(d_rgb));
+18
View File
@@ -53,6 +53,12 @@ namespace ANSCENTER {
int GetEmbeddingSize() const { return FACE_EMBEDDING_SIZE; }
std::shared_ptr<faiss::gpu::StandardGpuResources> GetGpuResources() const { return m_gpuResources; }
// Which embedding model to load (call BEFORE Initialize). Default is
// ADAFACE; Initialize falls back to ARCFACE when the model pack has
// no adafacerecognizer.onnx (pre-v1.4 zips).
void SetPreferredModel(FaceRecognizerModel m) { _preferredModel = m; }
FaceRecognizerModel GetActiveModel() const { return _activeModel; }
bool UpdateParamater(double knownPersonThreshold) {
_modelConfig.unknownPersonThreshold = knownPersonThreshold;
m_knownPersonThresh = _modelConfig.unknownPersonThreshold;
@@ -68,6 +74,11 @@ namespace ANSCENTER {
private:
bool LoadEngine(const std::string& xmlModelPath, bool engineOptimisation = true);
// Resolves the .onnx file for _preferredModel, falling back
// ADAFACE -> ARCFACE when adafacerecognizer.onnx is absent. Sets
// _activeModel and m_swapRB; returns "" when nothing usable exists.
std::string ResolveRecognizerModelFile();
// Batched forward: one embedding per Object.mask (caller must hold _mutex)
std::vector<std::vector<float>> ForwardUnlocked(const cv::Mat& input,const std::vector<ANSCENTER::Object>& outputBbox);
@@ -127,6 +138,13 @@ namespace ANSCENTER {
float m_knownPersonThresh = 0.35f;
EngineType engineType;
FaceRecognizerModel _preferredModel = FaceRecognizerModel::ADAFACE;
FaceRecognizerModel _activeModel = FaceRecognizerModel::ADAFACE;
// ArcFace was trained on RGB (needs the BGR->RGB swap); AdaFace on
// BGR (OpenCV native order, no swap). Gates every cvtColor in the
// TensorRT preprocessing paths.
bool m_swapRB = true;
#ifdef USE_ONNX_ENGINE
std::unique_ptr<GlintArcFace> faceRecognizer = nullptr;
const int CPU_FACE_WIDTH = 112;
+1
View File
@@ -4,6 +4,7 @@ set(ANSFR_SOURCES
ANSFR.cpp
ANSFRCommon.cpp
ANSFaceRecognizer.cpp
ONNXFaceAttributes.cpp
ANSGpuFrameRegistry.cpp
GpuNV12SlotPool.cpp
FaceDatabase.cpp
+79
View File
@@ -265,6 +265,85 @@ namespace ANSCENTER {
}
}
int FaceDatabase::GetAllFaces(std::vector<FaceRecord>& faces) {
std::lock_guard<std::mutex> lock(_mutex);
faces.clear();
sqlite3_stmt* stmt = nullptr;
int rc = sqlite3_prepare_v2(m_db, "SELECT ID, USER, IMG_PATH FROM FACE;", -1, &stmt, NULL);
if (rc != SQLITE_OK) {
_logger.LogError("FaceDatabase::GetAllFaces", sqlite3_errmsg(m_db), __FILE__, __LINE__);
return -1;
}
while ((rc = sqlite3_step(stmt)) == SQLITE_ROW) {
FaceRecord record;
record.FaceId = sqlite3_column_int(stmt, 0);
record.UserId = sqlite3_column_int(stmt, 1);
const unsigned char* path = sqlite3_column_text(stmt, 2);
record.ImagePath = path ? reinterpret_cast<const char*>(path) : "";
faces.push_back(std::move(record));
}
sqlite3_finalize(stmt);
return 0;
}
int FaceDatabase::UpdateFaceEmbedding(int faceId, const float embedding[]) {
std::lock_guard<std::mutex> lock(_mutex);
sqlite3_stmt* stmt = nullptr;
int rc = sqlite3_prepare_v2(m_db, "UPDATE FACE SET EMBEDDING=? WHERE ID=?;", -1, &stmt, NULL);
if (rc != SQLITE_OK) {
_logger.LogError("FaceDatabase::UpdateFaceEmbedding", sqlite3_errmsg(m_db), __FILE__, __LINE__);
return -1;
}
int resultCode = 1;
if (sqlite3_bind_blob(stmt, 1, embedding, sizeof(float) * m_embedding_dim, SQLITE_STATIC) != SQLITE_OK)
resultCode = -2;
if (sqlite3_bind_int(stmt, 2, faceId) != SQLITE_OK)
resultCode = -2;
rc = sqlite3_step(stmt);
if (rc != SQLITE_ROW && rc != SQLITE_DONE) {
_logger.LogError("FaceDatabase::UpdateFaceEmbedding", sqlite3_errmsg(m_db), __FILE__, __LINE__);
resultCode = -3;
}
sqlite3_finalize(stmt);
return resultCode;
}
bool FaceDatabase::SetSetting(const std::string& key, const std::string& value) {
std::lock_guard<std::mutex> lock(_mutex);
// Older databases predate the SETTINGS table — create on demand.
sqlite3_exec(m_db,
"CREATE TABLE IF NOT EXISTS SETTINGS (KEY TEXT PRIMARY KEY, VALUE TEXT);",
nullptr, nullptr, nullptr);
sqlite3_stmt* stmt = nullptr;
int rc = sqlite3_prepare_v2(m_db,
"INSERT INTO SETTINGS (KEY, VALUE) VALUES (?, ?) "
"ON CONFLICT(KEY) DO UPDATE SET VALUE=excluded.VALUE;",
-1, &stmt, NULL);
if (rc != SQLITE_OK) {
_logger.LogError("FaceDatabase::SetSetting", sqlite3_errmsg(m_db), __FILE__, __LINE__);
return false;
}
sqlite3_bind_text(stmt, 1, key.c_str(), int(key.length()), SQLITE_STATIC);
sqlite3_bind_text(stmt, 2, value.c_str(), int(value.length()), SQLITE_STATIC);
rc = sqlite3_step(stmt);
sqlite3_finalize(stmt);
return (rc == SQLITE_ROW || rc == SQLITE_DONE);
}
std::string FaceDatabase::GetSetting(const std::string& key) {
std::lock_guard<std::mutex> lock(_mutex);
sqlite3_stmt* stmt = nullptr;
int rc = sqlite3_prepare_v2(m_db, "SELECT VALUE FROM SETTINGS WHERE KEY=?;", -1, &stmt, NULL);
if (rc != SQLITE_OK) {
// Missing table (legacy database) — treat as "no value".
return std::string();
}
std::string value;
sqlite3_bind_text(stmt, 1, key.c_str(), int(key.length()), SQLITE_STATIC);
if (sqlite3_step(stmt) == SQLITE_ROW) {
const unsigned char* v = sqlite3_column_text(stmt, 0);
if (v) value = reinterpret_cast<const char*>(v);
}
sqlite3_finalize(stmt);
return value;
}
int FaceDatabase::DeleteFace(int id) {
try {
// Fix #4: Single lock scope — GetFaceById + DELETE in one atomic section
+9
View File
@@ -35,6 +35,15 @@ namespace ANSCENTER {
int GetUsersWithFaceIds(std::vector<int>& ids, std::vector<std::string>& codes,
std::vector<std::string>& userNames, std::vector<std::vector<int>>& faceIdsByUser);
int GetFaceById(int faceId, int& userId, std::string& imagePath);
// All enrolled faces (ID, USER, IMG_PATH) — used to regenerate
// embeddings after a recognizer model switch.
int GetAllFaces(std::vector<FaceRecord>& faces);
// Replaces the stored embedding of one face (same dim as Initialize).
int UpdateFaceEmbedding(int faceId, const float embedding[]);
// Simple key/value store (SETTINGS table, created on demand) — used
// to persist which recognizer model generated the stored embeddings.
bool SetSetting(const std::string& key, const std::string& value);
std::string GetSetting(const std::string& key);
std::map<std::string, std::string> GetUserDict();
int GetEmbeddings(ANSFRBase& recognizer);
int GetEmbeddings(std::unique_ptr<ANSFRBase>& recognizer);
+256
View File
@@ -0,0 +1,256 @@
#include "ONNXFaceAttributes.h"
#include <algorithm>
#include <cmath>
#include <fstream>
#include <filesystem>
namespace {
// The exported classifier may or may not end with a softmax node
// (Ultralytics kept flipping this across versions). Treat the output
// as probabilities only when it already looks like a distribution.
void SoftmaxIfNeeded(std::vector<float>& v) {
if (v.empty()) return;
float sum = 0.0f;
bool inRange = true;
for (float x : v) {
if (x < 0.0f || x > 1.0f) { inRange = false; break; }
sum += x;
}
if (inRange && std::fabs(sum - 1.0f) < 0.05f) return;
float maxVal = *std::max_element(v.begin(), v.end());
float denom = 0.0f;
for (float& x : v) {
x = std::exp(x - maxVal);
denom += x;
}
if (denom > 0.0f) {
for (float& x : v) x /= denom;
}
}
void ResolveInputSize(const std::vector<int64_t>& dims, int& width, int& height) {
// NCHW; dynamic dims come back as -1 — the shipped models are 224x224.
width = 224;
height = 224;
if (dims.size() >= 4) {
if (dims[2] > 0) height = static_cast<int>(dims[2]);
if (dims[3] > 0) width = static_cast<int>(dims[3]);
}
}
}
namespace ANSCENTER {
// ================================================================
// OnnxAgeGenderEstimator
// ================================================================
OnnxAgeGenderEstimator::OnnxAgeGenderEstimator(const std::string& onnxPath,
EngineType engineType,
const OrtHandlerOptions& options,
unsigned int numThreads)
: BasicOrtHandler(onnxPath, engineType, options, numThreads)
{
_ready = true;
}
Ort::Value OnnxAgeGenderEstimator::transform(const cv::Mat& mat)
{
if (mat.empty())
throw std::runtime_error("OnnxAgeGenderEstimator::transform — input is empty.");
int width = 0, height = 0;
ResolveInputSize(input_node_dims, width, height);
cv::Mat canvas = mat;
if (canvas.channels() == 1)
cv::cvtColor(canvas, canvas, cv::COLOR_GRAY2BGR);
cv::Mat resized;
cv::resize(canvas, resized, cv::Size(width, height), 0, 0, cv::INTER_LINEAR);
cv::cvtColor(resized, resized, cv::COLOR_BGR2RGB);
resized.convertTo(resized, CV_32FC3, 1.0 / 255.0);
// ImageNet normalization (ViTFeatureExtractor defaults)
static const float mean_vals[3] = { 0.485f, 0.456f, 0.406f };
static const float scale_vals[3] = { 1.f / 0.229f, 1.f / 0.224f, 1.f / 0.225f };
utils::transform::normalize_inplace(resized, mean_vals, scale_vals);
std::vector<int64_t> shape = input_node_dims;
if (shape.size() < 4) shape = { 1, 3, height, width };
if (shape[0] <= 0) shape[0] = 1;
if (shape[2] <= 0) shape[2] = height;
if (shape[3] <= 0) shape[3] = width;
return utils::transform::create_tensor(
resized, shape, *memory_info_handler,
input_values_handler, utils::transform::CHW);
}
Ort::Value OnnxAgeGenderEstimator::transformBatch(const std::vector<cv::Mat>&)
{
throw std::runtime_error("OnnxAgeGenderEstimator::transformBatch — not supported.");
}
AgeGenderResults OnnxAgeGenderEstimator::runInfer(const cv::Mat& frame)
{
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
if (!_ready || frame.empty()) return { -1, -1 };
Ort::Value input_tensor = transform(frame);
DmlInferenceGuard dmlGuard(m_engineType, "OnnxAgeGenderEstimator::runInfer");
auto output_tensors = ort_session->Run(
Ort::RunOptions{ nullptr },
input_node_names.data(), &input_tensor, 1,
output_node_names.data(), num_outputs);
// Two known export layouts, distinguished by tensor sizes:
// (a) v1.4 pack: age_pred [1] (years) + gender_logits [1,2]
// with class order [male, female]
// (b) research export: a single [1,2] tensor of
// [age_years, gender_logit] where sigmoid >= 0.5 -> Female
const float* agePtr = nullptr;
const float* genderLogits = nullptr;
for (auto& tensor : output_tensors) {
const size_t count =
tensor.GetTensorTypeAndShapeInfo().GetElementCount();
if (count == 1 && !agePtr)
agePtr = tensor.GetTensorMutableData<float>();
else if (count >= 2 && !genderLogits)
genderLogits = tensor.GetTensorMutableData<float>();
}
if (agePtr && genderLogits) { // layout (a)
const float age = std::clamp(agePtr[0], 0.0f, 100.0f);
const float m = genderLogits[0], f = genderLogits[1];
const float mx = std::max(m, f);
const float em = std::exp(m - mx), ef = std::exp(f - mx);
return { age, em / (em + ef) };
}
if (genderLogits) { // layout (b)
const float age = std::clamp(genderLogits[0], 0.0f, 100.0f);
const float femaleProb = 1.0f / (1.0f + std::exp(-genderLogits[1]));
return { age, 1.0f - femaleProb };
}
return { -1, -1 };
}
catch (const std::exception& error) {
std::cerr << "OnnxAgeGenderEstimator error: " << error.what() << std::endl;
return { -1, -1 };
}
}
// ================================================================
// OnnxEmotionsClassifier
// ================================================================
std::vector<std::string> OnnxEmotionsClassifier::LoadClassNames(const std::string& namesFilePath)
{
std::vector<std::string> names;
try {
std::ifstream file(namesFilePath);
std::string line;
while (std::getline(file, line)) {
while (!line.empty() && (line.back() == '\r' || line.back() == '\n'
|| line.back() == ' ' || line.back() == '\t'))
line.pop_back();
if (!line.empty()) names.push_back(line);
}
}
catch (const std::exception&) {
names.clear();
}
if (names.empty()) {
names = { "neutral", "happy", "sad", "surprise", "anger" };
}
return names;
}
OnnxEmotionsClassifier::OnnxEmotionsClassifier(const std::string& onnxPath,
std::vector<std::string> classNames,
EngineType engineType,
const OrtHandlerOptions& options,
unsigned int numThreads)
: BasicOrtHandler(onnxPath, engineType, options, numThreads)
, _classNames(std::move(classNames))
{
if (_classNames.empty())
_classNames = { "neutral", "happy", "sad", "surprise", "anger" };
_ready = true;
}
Ort::Value OnnxEmotionsClassifier::transform(const cv::Mat& mat)
{
if (mat.empty())
throw std::runtime_error("OnnxEmotionsClassifier::transform — input is empty.");
int width = 0, height = 0;
ResolveInputSize(input_node_dims, width, height);
cv::Mat canvas = mat;
if (canvas.channels() == 1)
cv::cvtColor(canvas, canvas, cv::COLOR_GRAY2BGR);
cv::Mat resized;
cv::resize(canvas, resized, cv::Size(width, height), 0, 0, cv::INTER_LINEAR);
cv::cvtColor(resized, resized, cv::COLOR_BGR2RGB);
// Ultralytics classifier preprocessing: RGB, scaled to [0, 1]
resized.convertTo(resized, CV_32FC3, 1.0 / 255.0);
std::vector<int64_t> shape = input_node_dims;
if (shape.size() < 4) shape = { 1, 3, height, width };
if (shape[0] <= 0) shape[0] = 1;
if (shape[2] <= 0) shape[2] = height;
if (shape[3] <= 0) shape[3] = width;
return utils::transform::create_tensor(
resized, shape, *memory_info_handler,
input_values_handler, utils::transform::CHW);
}
Ort::Value OnnxEmotionsClassifier::transformBatch(const std::vector<cv::Mat>&)
{
throw std::runtime_error("OnnxEmotionsClassifier::transformBatch — not supported.");
}
std::map<std::string, float> OnnxEmotionsClassifier::runInfer(const cv::Mat& frame)
{
std::lock_guard<std::recursive_mutex> lock(_mutex);
try {
if (!_ready || frame.empty()) return { };
Ort::Value input_tensor = transform(frame);
DmlInferenceGuard dmlGuard(m_engineType, "OnnxEmotionsClassifier::runInfer");
auto output_tensors = ort_session->Run(
Ort::RunOptions{ nullptr },
input_node_names.data(), &input_tensor, 1,
output_node_names.data(), num_outputs);
auto info = output_tensors.at(0).GetTensorTypeAndShapeInfo();
const size_t count = info.GetElementCount();
if (count == 0) return { };
const float* vals = output_tensors.at(0).GetTensorMutableData<float>();
std::vector<float> scores(vals, vals + count);
SoftmaxIfNeeded(scores);
std::map<std::string, float> emotions;
for (size_t i = 0; i < scores.size(); ++i) {
const std::string name = (i < _classNames.size())
? _classNames[i]
: ("class_" + std::to_string(i));
emotions[name] = scores[i];
}
return emotions;
}
catch (const std::exception& error) {
std::cerr << "OnnxEmotionsClassifier error: " << error.what() << std::endl;
return { };
}
}
}
+69
View File
@@ -0,0 +1,69 @@
#ifndef ONNXFACEATTRIBUTES_H
#define ONNXFACEATTRIBUTES_H
#pragma once
// ONNX Runtime backends for the face attribute models shipped with
// ANS_FaceRecognizer v1.4:
// - agegender.onnx ViT-Base age/gender head (224x224, ImageNet norm,
// 2 logits: [age 0..100, gender sigmoid -> Female >= 0.5])
// - emotionsrecognition.onnx YOLOv11 classifier (class list in
// emotionsrecognition.names)
//
// Execution provider follows the detected hardware through BasicOrtHandler:
// NVIDIA -> TensorRT EP (disk-cached engines) with CUDA EP fallback,
// AMD -> DirectML, Intel -> OpenVINO, otherwise CPU.
#include "ANSFRCommon.h"
#include "ONNXEngine.h"
#include <mutex>
namespace ANSCENTER {
class OnnxAgeGenderEstimator : public BasicOrtHandler, public IAgeGenderEstimator {
public:
OnnxAgeGenderEstimator(const std::string& onnxPath,
EngineType engineType,
const OrtHandlerOptions& options,
unsigned int numThreads = 2);
~OnnxAgeGenderEstimator() override = default;
AgeGenderResults runInfer(const cv::Mat& frame) override;
bool enabled() const override { return _ready; }
const char* backendName() const override { return "onnx"; }
private:
Ort::Value transform(const cv::Mat& mat) override;
Ort::Value transformBatch(const std::vector<cv::Mat>& images) override;
std::recursive_mutex _mutex;
bool _ready{ false };
};
class OnnxEmotionsClassifier : public BasicOrtHandler, public IEmotionsClassifier {
public:
OnnxEmotionsClassifier(const std::string& onnxPath,
std::vector<std::string> classNames,
EngineType engineType,
const OrtHandlerOptions& options,
unsigned int numThreads = 2);
~OnnxEmotionsClassifier() override = default;
std::map<std::string, float> runInfer(const cv::Mat& frame) override;
bool enabled() const override { return _ready; }
const char* backendName() const override { return "onnx"; }
// Reads one class name per line; returns the legacy 5-emotion list
// when the file is missing/empty so the classifier still produces
// labelled output.
static std::vector<std::string> LoadClassNames(const std::string& namesFilePath);
private:
Ort::Value transform(const cv::Mat& mat) override;
Ort::Value transformBatch(const std::vector<cv::Mat>& images) override;
std::recursive_mutex _mutex;
std::vector<std::string> _classNames;
bool _ready{ false };
};
}
#endif
+36
View File
@@ -1294,6 +1294,42 @@ extern "C" ANSFR_API int GetFaceQueue(ANSCENTER::ANSFacialRecognition** Handl
}
}
extern "C" ANSFR_API int SetANSRFRecognizerModel(ANSCENTER::ANSFacialRecognition** Handle, int modelType) {
ANS_DBG("ANSFR","SetANSRFRecognizerModel: HandlePtr=%p, *Handle=%p, modelType=%d (0=AdaFace,1=ArcFace)",
(void*)Handle, (void*)(Handle ? *Handle : nullptr), modelType);
try {
if (!Handle || !*Handle) return -1;
if (modelType < 0 || modelType > 1) return -1;
FRHandleGuard guard(AcquireFRHandle(*Handle));
if (!guard) return -1;
return (*Handle)->SetRecognizerModelType(modelType) ? 1 : 0;
}
catch (const std::exception& e) {
ANS_DBG("ANSFR","SetANSRFRecognizerModel EXCEPTION: %s", e.what());
return -1;
}
}
extern "C" ANSFR_API int GetANSRFRecognizerModel(ANSCENTER::ANSFacialRecognition** Handle) {
try {
if (!Handle || !*Handle) return -1;
return (*Handle)->GetRecognizerModelType();
}
catch (const std::exception&) {
return -1;
}
}
extern "C" ANSFR_API int GetANSRFModelInfo(ANSCENTER::ANSFacialRecognition** Handle, LStrHandle modelInfo) {
try {
if (!Handle || !*Handle || !modelInfo) return -1;
return CopyToLStrHandle(modelInfo, (*Handle)->GetActiveModelInfo());
}
catch (const std::exception&) {
return -1;
}
}
extern "C" ANSFR_API int RunInferenceComplete_LV(
ANSCENTER::ANSFacialRecognition** Handle,
cv::Mat** cvImage,
+114 -1
View File
@@ -19,6 +19,7 @@
#include <chrono>
#include <thread>
#include <iomanip>
#include <filesystem>
#include "ANSFR.h"
#include "fastdeploy/vision.h"
#include "ANSFilePlayer.h"
@@ -1713,6 +1714,117 @@ int SCRFDVideoRepro()
return 0;
}
// ===========================================================================
// ANS_FaceRecognizer v1.4 test:
// - AdaFace loads by default from the v1.4 model pack
// - ONNX age-gender + emotion models load (TensorRT EP on NVIDIA)
// - SetANSRFRecognizerModel switches adaface <-> arcface live, and stored
// embeddings are regenerated so recognition keeps working after a switch
// ===========================================================================
static bool V14Check(bool condition, const std::string& label, int& failures)
{
std::cout << (condition ? "[PASS] " : "[FAIL] ") << label << std::endl;
if (!condition) ++failures;
return condition;
}
int TestModelSwitchV14()
{
const std::string modelZip = "C:\\Programs\\Models\\ANS_FaceRecognizer_v1.4.zip";
const std::string detectorZip = "C:\\ProgramData\\ANSCENTER\\ANSVIS Server\\ANSFDET\\ANS_GenericFD(GPU)_v1.0.zip";
const std::string dbFolder = "C:\\Programs\\DemoAssets\\ANSFRDB\\v14_test";
const std::string dbFile = dbFolder + "\\ANSFR_v14_test.db";
const std::string enrollImage = "C:\\Programs\\DemoAssets\\TestImages\\FacialRecognition\\Obama+Oprah1.jpg";
const std::string userName = "V14TestUser";
int failures = 0;
std::cout << "\n===== TestModelSwitchV14 =====" << std::endl;
// Fresh database each run so the test is repeatable
std::error_code ec;
std::filesystem::remove_all(dbFolder, ec);
cv::Mat frame = cv::imread(enrollImage, cv::IMREAD_COLOR);
if (!V14Check(!frame.empty(), "test image readable: " + enrollImage, failures))
return failures;
ANSCENTER::ANSFacialRecognition* h = nullptr;
int cr = CreateANSRFHandle(&h, "", "", dbFile.c_str(), modelZip.c_str(), detectorZip.c_str(),
0, 0.35f, 1, 1, 1, 30, 0.5f, 0, 0);
if (!V14Check(cr > 0 && h != nullptr, "CreateANSRFHandle", failures))
return failures;
int le = LoadANSRFEngine(&h);
if (!V14Check(le == 1, "LoadANSRFEngine (v1.4 model pack)", failures)) {
ReleaseANSRFHandle(&h);
return failures;
}
// --- default model + attribute backends -------------------------------
std::string info = h->GetActiveModelInfo();
std::cout << "Model info: " << info << std::endl;
V14Check(GetANSRFRecognizerModel(&h) == 0, "default recognizer model is AdaFace (0)", failures);
V14Check(info.find("\"recognizer_model\":\"adaface\"") != std::string::npos,
"model info reports adaface", failures);
V14Check(info.find("\"agegender_backend\":\"onnx\"") != std::string::npos,
"age-gender uses agegender.onnx backend", failures);
V14Check(info.find("\"emotion_backend\":\"onnx\"") != std::string::npos,
"emotions use emotionsrecognition.onnx backend", failures);
// --- enroll one user ---------------------------------------------------
int userId = InsertUser(&h, "0001", userName.c_str());
V14Check(userId > 0, "InsertUser", failures);
unsigned int bufLen = 0;
unsigned char* buf = ANSCENTER::ANSFRHelper::CVMatToBytes(frame, bufLen);
int faceInserted = InsertFaceBinary(&h, userId, buf, frame.cols, frame.rows);
delete buf;
V14Check(faceInserted > 0, "InsertFaceBinary (enrollment)", failures);
Reload(&h);
auto recognizesUser = [&](const char* label) {
// Full pipeline (detect + match). The Recognize API needs a config
// file with _recInputShape, which this test intentionally omits.
unsigned int len = 0;
unsigned char* bytes = ANSCENTER::ANSFRHelper::CVMatToBytes(frame, len);
std::string res = RunANSRFInferenceBinary(&h, bytes, frame.cols, frame.rows);
delete bytes;
std::cout << " recognition result: " << res << std::endl;
V14Check(res.find(userName) != std::string::npos, label, failures);
};
recognizesUser("recognized with AdaFace embeddings");
// --- live switch to ArcFace (regenerates stored embeddings) ------------
V14Check(SetANSRFRecognizerModel(&h, 1) == 1, "switch to ArcFace", failures);
V14Check(GetANSRFRecognizerModel(&h) == 1, "active model is ArcFace (1)", failures);
std::cout << "Model info: " << h->GetActiveModelInfo() << std::endl;
recognizesUser("recognized after switch to ArcFace");
// --- and back to AdaFace ------------------------------------------------
V14Check(SetANSRFRecognizerModel(&h, 0) == 1, "switch back to AdaFace", failures);
V14Check(GetANSRFRecognizerModel(&h) == 0, "active model is AdaFace (0)", failures);
recognizesUser("recognized after switch back to AdaFace");
// --- attributes through the full pipeline (ONNX age/gender + emotions) --
{
unsigned int len = 0;
unsigned char* bytes = ANSCENTER::ANSFRHelper::CVMatToBytes(frame, len);
std::string res = RunANSRFInferenceBinary(&h, bytes, frame.cols, frame.rows);
delete bytes;
std::cout << " inference (attributes): " << res << std::endl;
V14Check(res.find("Age") != std::string::npos || res.find("results") != std::string::npos,
"inference with ONNX attribute models returns results", failures);
}
ReleaseANSRFHandle(&h);
std::cout << "===== TestModelSwitchV14: "
<< (failures == 0 ? "ALL PASSED" : (std::to_string(failures) + " FAILURE(S)"))
<< " =====" << std::endl;
return failures;
}
int main(int argc, char** argv)
{
// ── GPU visibility bisect (Blackwell Myelin l2cm debugging) ─────────────
@@ -1735,7 +1847,8 @@ int main(int argc, char** argv)
//FaceDetectorTest();
//TestFaceRecognition();
//TestCompleteFR1();
ANSVISTest();
TestModelSwitchV14();
//ANSVISTest();
//ANSVISImageTest();
//ANSVISTest();
//ANSVISTestFilePlayer();