ANSCORE/modules/ANSFR/ANSFaceRecognizer.cpp

#include "ANSFaceRecognizer.h"
#include "engine.h"

//#define DEBUG_TIME
#ifdef DEBUG_TIME
#include <chrono>
#include <iostream>
#define FR_START_TIMER(name) auto timer_##name = std::chrono::high_resolution_clock::now()
#define FR_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 << "  [FR] " << label << ": " << (duration_us / 1000.0) << " ms" << std::endl; \
    } while(0)
#else
#define FR_START_TIMER(name)
#define FR_END_TIMER(name, label)
#endif

namespace ANSCENTER {
	std::string ANSFaceRecognizer::GetOpenVINODevice() {
		ov::Core core;
		std::vector<std::string> available_devices = core.get_available_devices();

		ANS_DBG("FaceRecognizer", "OpenVINO available devices: %zu", available_devices.size());
		for (const auto& d : available_devices) {
			ANS_DBG("FaceRecognizer", "  OpenVINO device: %s", d.c_str());
		}

		std::vector<std::string> priority_devices = { "GPU", "CPU" };
		for (const auto& device : priority_devices) {
			if (std::find(available_devices.begin(), available_devices.end(), device) != available_devices.end()) {
				ANS_DBG("FaceRecognizer", "OpenVINO selected device: %s", device.c_str());
				return device;
			}
		}
		ANS_DBG("FaceRecognizer", "OpenVINO fallback to CPU");
		return "CPU";
	}

	bool ANSFaceRecognizer::Initialize(std::string licenseKey,
		ModelConfig modelConfig,
		const std::string& modelZipFilePath,
		const std::string& modelZipPassword,
		std::string& labelMap)
	{
		ANS_DBG("FaceRecognizer", "Initialize: modelZip=%s", modelZipFilePath.c_str());
		bool result = ANSFRBase::Initialize(licenseKey, modelConfig, modelZipFilePath, modelZipPassword, labelMap);
		if (!result) {
			ANS_DBG("FaceRecognizer", "ANSFRBase::Initialize FAILED");
			return false;
		}
#ifdef CPU_MODE
		engineType = EngineType::CPU;
		ANS_DBG("FaceRecognizer", "CPU_MODE forced: engineType=CPU");
#else
		engineType = ANSLicenseHelper::CheckHardwareInformation();
		ANS_DBG("FaceRecognizer", "HW detection: engineType=%d", static_cast<int>(engineType));
#endif
		try {
			_modelConfig = modelConfig;
			_modelConfig.modelType = ModelType::FACERECOGNIZE;
			_modelConfig.detectionType = DetectionType::FACERECOGNIZER;

			m_knownPersonThresh = _modelConfig.unknownPersonThreshold;
			if (m_knownPersonThresh == 0.0f) m_knownPersonThresh = 0.35f;

			ANS_DBG("FaceRecognizer", "engineType=%d (NVIDIA=%d, OPENVINO=%d, AMD=%d, CPU=%d)",
				static_cast<int>(engineType),
				static_cast<int>(EngineType::NVIDIA_GPU),
				static_cast<int>(EngineType::OPENVINO_GPU),
				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)) {
					_modelFilePath = onnxfile;
					_logger.LogDebug("ANSFaceRecognizer::Initialize. Loading ansfacerecognizer weight",
						_modelFilePath, __FILE__, __LINE__);
				}
				else {
					_logger.LogError("ANSFaceRecognizer::Initialize. Model ansfacerecognizer.onnx does not exist",
						_modelFilePath, __FILE__, __LINE__);
					return false;
				}

				if (!m_trtEngine) {
					// Enable batch support
					m_options.optBatchSize = 8;
					m_options.maxBatchSize = 32;

					m_options.maxInputHeight = GPU_FACE_HEIGHT;
					m_options.minInputHeight = GPU_FACE_HEIGHT;
					m_options.optInputHeight = GPU_FACE_HEIGHT;

					m_options.maxInputWidth = GPU_FACE_WIDTH;
					m_options.minInputWidth = GPU_FACE_WIDTH;
					m_options.optInputWidth = GPU_FACE_WIDTH;

					m_options.calibrationBatchSize = 8;
					m_options.deviceIndex = _modelConfig.gpuDeviceIndex;
					m_options.engineFileDir = _modelFolder;
					m_options.precision = ANSCENTER::Precision::FP16;

					m_poolKey = { _modelFilePath,
						static_cast<int>(m_options.precision),
						m_options.maxBatchSize };
					m_trtEngine = EnginePoolManager<float>::instance().acquire(
						m_poolKey, m_options, _modelFilePath,
						SUB_VALS, DIV_VALS, NORMALIZE, m_maxSlotsPerGpu);
					m_usingSharedPool = (m_trtEngine != nullptr);

					if (!m_trtEngine) {
						_logger.LogError("ANSFaceRecognizer::Initialize. Unable to build/load TensorRT engine.",
							_modelFilePath, __FILE__, __LINE__);
						return false;
					}

					// Create CUDA stream for GPU preprocessing (lazy init)
					if (!m_gpuStream) {
						m_gpuStream = std::make_unique<cv::cuda::Stream>();
					}
				}
			}
			else {
#ifdef USE_ONNX_ENGINE
				std::string faceidModel = CreateFilePath(_modelFolder, "ansfacerecognizer.onnx");
				if (std::filesystem::exists(faceidModel)) {
					_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__);
					return false;
				}
				ANS_DBG("FaceRecognizer", "Creating GlintArcFace with engineType=%d model=%s",
					static_cast<int>(engineType), faceidModel.c_str());
				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");
					return false;
				}
#else
				std::string faceidModel = CreateFilePath(_modelFolder, "ansfacenet.xml");
				if (std::filesystem::exists(faceidModel)) {
					_modelFilePath = faceidModel;
					_logger.LogDebug("ANSFaceRecognizer::Initialize. Loading ANSFaceRecognizer weight",
						_modelFilePath, __FILE__, __LINE__);
				}
				else {
					_logger.LogError("ANSFaceRecognizer::Initialize. Model ansfacenet.xml does not exist",
						_modelFilePath, __FILE__, __LINE__);
					return false;
				}

				std::string deviceName = GetOpenVINODevice();
				ov::Core core;
				CnnConfig reid_config(_modelFilePath, "Face Re-Identification");
				reid_config.m_deviceName = deviceName;
				reid_config.m_max_batch_size = 1; // can be increased if you want batching here too
				reid_config.m_core = core;

				faceRecognizer = std::make_unique<VectorCNN>(reid_config);
				if (!faceRecognizer) {
					_logger.LogFatal("ANSFaceRecognizer::Initialize",
						"Failed to initialize OpenVINO face recognizer", __FILE__, __LINE__);
					return false;
				}
#endif
			}
			Init();
			_isInitialized = true;
			return true;
		}
		catch (const std::exception& e) {
			ANS_DBG("FaceRecognizer", "Initialize EXCEPTION: %s", e.what());
			_logger.LogFatal("ANSFaceRecognizer::Initialize", e.what(), __FILE__, __LINE__);
			return false;
		}
	}

	bool ANSFaceRecognizer::LoadModel(const std::string& modelZipFilePath,
		const std::string& modelZipPassword) {
		try {
			bool result = ANSFRBase::LoadModel(modelZipFilePath, modelZipPassword);
			if (!result) return false;

			if (engineType == EngineType::NVIDIA_GPU) {
				std::string onnxfile = CreateFilePath(_modelFolder, "ansfacerecognizer.onnx");
				if (std::filesystem::exists(onnxfile)) {
					_modelFilePath = onnxfile;
					_logger.LogDebug("ANSFaceRecognizer::LoadModel. Loading ansfacerecognizer weight",
						_modelFilePath, __FILE__, __LINE__);
				}
				else {
					_logger.LogError("ANSFaceRecognizer::LoadModel. ansfacerecognizer.onnx not found",
						_modelFilePath, __FILE__, __LINE__);
					return false;
				}
			}
			else {
				std::string faceidModel = CreateFilePath(_modelFolder, "ansfacerecognizer.onnx");
#ifdef USE_ONNX_ENGINE
				if (std::filesystem::exists(faceidModel)) {
					_modelFilePath = faceidModel;
					_logger.LogDebug("ANSFaceRecognizer::LoadModel. Loading ansfacerecognizer weight",
						_modelFilePath, __FILE__, __LINE__);
				}
				else {
					_logger.LogError("ANSFaceRecognizer::LoadModel. ansfacerecognizer.onnx not found",
						_modelFilePath, __FILE__, __LINE__);
					return false;
				}
#else
				if (std::filesystem::exists(faceidModel)) {
					_modelFilePath = faceidModel;
					_logger.LogDebug("ANSFaceRecognizer::LoadModel. Loading ansfacenet weight",
						_modelFilePath, __FILE__, __LINE__);
				}
				else {
					_logger.LogError("ANSFaceRecognizer::LoadModel. ansfacenet.xml not found",
						_modelFilePath, __FILE__, __LINE__);
					return false;
				}
#endif
			}
			return true;
		}
		catch (const std::exception& e) {
			_logger.LogFatal("ANSFaceRecognizer::LoadModel", e.what(), __FILE__, __LINE__);
			return false;
		}
	}

	bool ANSFaceRecognizer::OptimizeModel(bool fp16, std::string& optimizedModelFolder) {
		if (!FileExist(_modelFilePath)) {
			optimizedModelFolder = "";
			return false;
		}
		if (engineType == EngineType::NVIDIA_GPU) {
			optimizedModelFolder = GetParentFolder(_modelFilePath);

			m_options.optBatchSize = 8;
			m_options.maxBatchSize = 32;
			m_options.engineFileDir = optimizedModelFolder;
			m_options.precision = fp16 ? Precision::FP16 : Precision::FP32;

			Engine<float> engine(m_options);

			auto succ = engine.buildWithRetry(_modelFilePath, SUB_VALS, DIV_VALS, NORMALIZE);
			if (!succ) {
				const std::string errMsg =
					"Error: Unable to build the TensorRT engine. Try increasing TensorRT log severity to kVERBOSE.";
				_logger.LogError("ANSFaceRecognizer::OptimizeModel", errMsg, __FILE__, __LINE__);
				return false;
			}
			return true;
		}
		return true;
	}

	std::vector<float> ANSFaceRecognizer::Feature(const cv::Mat& image, const ANSCENTER::Object& bBox) {
		std::vector<float> embeddingResult;
		// Early validation before locking
		if (image.empty()) {
			_logger.LogError("ANSFaceRecognizer::Feature",
				"Input image is empty", __FILE__, __LINE__);
			return embeddingResult;
		}
		if (image.cols < 10 || image.rows < 10) {
			return embeddingResult;
		}

		std::lock_guard<std::recursive_mutex> lock(_mutex);

		try {
			if (engineType == EngineType::NVIDIA_GPU) {
				return RunArcFace(bBox.mask);
			}
			else {
				// CPU path
#ifdef USE_ONNX_ENGINE
				types::FaceContent face_content;
				faceRecognizer->detect(bBox.mask, face_content);
				// Explicitly move and let face_content destructor clean up
				embeddingResult = std::move(face_content.embedding);
				return embeddingResult;
#else
				cv::Mat embedding;
				faceRecognizer->Compute(bBox.mask, &embedding);
				// Check if embedding is valid
				if (embedding.empty() || embedding.total() == 0) {
					return embeddingResult;
				}

				// Reserve space first to avoid reallocations
				embeddingResult.reserve(embedding.total());

				// Optimized conversion
				if (embedding.isContinuous()) {
					const float* dataPtr = embedding.ptr<float>(0);
					embeddingResult.assign(dataPtr, dataPtr + embedding.total());
				}
				else {
					embeddingResult.assign(embedding.begin<float>(), embedding.end<float>());
				}

				// Explicitly release OpenCV Mat
				embedding.release();

				return embeddingResult;
#endif
			}
		}
		catch (const std::exception& e) {
			_logger.LogFatal("ANSFaceRecognizer::Feature", e.what(), __FILE__, __LINE__);
			return std::vector<float>();
		}
	}

	std::vector<FaceResultObject> ANSFaceRecognizer::Match(const cv::Mat& input,const std::vector<ANSCENTER::Object>& bBox,const std::map<std::string, std::string>& userDict) {

		std::vector<FaceResultObject> resultObjects;

		// Early validation before locking
		if (input.empty()) {
			_logger.LogError("ANSFaceRecognizer::Match",
				"Input image is empty", __FILE__, __LINE__);
			return resultObjects;
		}

		if (input.cols < 10 || input.rows < 10) {
			return resultObjects;
		}

		std::lock_guard<std::recursive_mutex> lock(_mutex);

		if (!_isInitialized) {
			_logger.LogError("ANSFaceRecognizer::Match",
				"Model is not initialized", __FILE__, __LINE__);
			return resultObjects;
		}

		try {
			// Get embeddings (Fix #5: call unlocked — we already hold _mutex)
			FR_START_TIMER(forward);
			std::vector<std::vector<float>> detectedEmbeddings = ForwardUnlocked(input, bBox);
			FR_END_TIMER(forward, "ForwardUnlocked (GPU embeddings)");

			// Search for matches (Fix #5: call unlocked — we already hold _mutex)
			FR_START_TIMER(search);
			std::vector<std::string> names;
			std::vector<float> sims;
			std::tie(names, sims) = SearchForFacesUnlocked(detectedEmbeddings);
			FR_END_TIMER(search, "SearchForFacesUnlocked (FAISS)");

			if (names.empty()) {
				_logger.LogError("ANSFaceRecognizer::Match",
					"No face is match", __FILE__, __LINE__);
				return resultObjects;
			}

			// Pre-reserve result space
			const size_t resultCount = std::min(names.size(), bBox.size());
			resultObjects.reserve(resultCount);

			// Build result objects
			for (size_t i = 0; i < resultCount; ++i) {
				FaceResultObject resultObject;

				// Determine if face is known or unknown
				const bool isUnknown = (sims[i] > m_knownPersonThresh);

				if (isUnknown) {
					resultObject.isUnknown = true;
					resultObject.userId = "0";
					resultObject.userName = "Unknown";
					resultObject.confidence = 1.0f;
				}
				else {
					resultObject.isUnknown = false;
					resultObject.userId = names[i];

					// Safe map lookup
					auto it = userDict.find(names[i]);
					resultObject.userName = (it != userDict.end()) ? it->second : names[i];

					resultObject.confidence = std::clamp((2.0f - sims[i]) / 2.0f, 0.0f, 1.0f);
				}

				resultObject.similarity = sims[i];

				// Clamp bounding box to image boundaries
				const float x = MAX(0.0f, bBox[i].box.x);
				const float y = MAX(0.0f, bBox[i].box.y);
				const float w = MIN(bBox[i].box.width, static_cast<float>(input.cols) - x);
				const float h = MIN(bBox[i].box.height, static_cast<float>(input.rows) - y);

				resultObject.box.x = x;
				resultObject.box.y = y;
				resultObject.box.width = w;
				resultObject.box.height = h;

				// Copy additional data
				resultObject.mask = bBox[i].mask;
				resultObject.cameraId = bBox[i].cameraId;
				resultObject.trackId = bBox[i].trackId;
				resultObject.polygon = bBox[i].polygon;
				resultObject.kps = bBox[i].kps;
				resultObject.extraInformation = bBox[i].extraInfo;

				resultObjects.push_back(std::move(resultObject));
			}

			return resultObjects;
		}
		catch (const std::exception& e) {
			_logger.LogFatal("ANSFaceRecognizer::Match", e.what(), __FILE__, __LINE__);
			return resultObjects;
		}
	}
	cv::Mat ANSFaceRecognizer::GetCropFace(const cv::Mat& input, const ANSCENTER::Object& bBox) {
		try {
			// Determine target size based on engine type
			const int targetWidth = (engineType == EngineType::NVIDIA_GPU) ? GPU_FACE_WIDTH : CPU_FACE_WIDTH;
			const int targetHeight = (engineType == EngineType::NVIDIA_GPU) ? GPU_FACE_HEIGHT : CPU_FACE_HEIGHT;

			// Prepare single bounding box vector
			std::vector<ANSCENTER::Object> outputBbox;
			outputBbox.reserve(1);
			outputBbox.push_back(bBox);

			// Get cropped face
			std::vector<CroppedFace> crFaces;
			ANSFRHelper::GetCroppedFaces(input, outputBbox, targetWidth, targetHeight, crFaces);

			if (crFaces.empty()) {
				return cv::Mat();
			}

			return crFaces[0].faceMat;
		}
		catch (const std::exception& e) {
			_logger.LogFatal("ANSFaceRecognizer::GetCropFace", e.what(), __FILE__, __LINE__);
			return cv::Mat();
		}
	}
	bool ANSFaceRecognizer::LoadEngine(const std::string& xmlModelPath,bool engineOptimisation) {
		try {
			// Early validation
			if (!FileExist(xmlModelPath)) {
				_logger.LogError("ANSFaceRecognizer::LoadEngine",
					"Cannot find the raw XML/ONNX model file.", __FILE__, __LINE__);
				return false;
			}
			if (engineType == EngineType::NVIDIA_GPU) {
				// Initialize TensorRT engine via shared pool
				if (!m_trtEngine) {
					m_options.optBatchSize = 8;
					m_options.maxBatchSize = 32;
					m_options.calibrationBatchSize = 8;
					m_options.deviceIndex = _modelConfig.gpuDeviceIndex;
					m_options.engineFileDir = _modelFolder;
					m_options.precision = ANSCENTER::Precision::FP16;

					m_poolKey = { xmlModelPath,
						static_cast<int>(m_options.precision),
						m_options.maxBatchSize };
					m_trtEngine = EnginePoolManager<float>::instance().acquire(
						m_poolKey, m_options, xmlModelPath,
						SUB_VALS, DIV_VALS, NORMALIZE, m_maxSlotsPerGpu);
					m_usingSharedPool = (m_trtEngine != nullptr);

					if (!m_trtEngine) {
						_logger.LogError("ANSFaceRecognizer::LoadEngine. Unable to build/load TensorRT engine.",
							xmlModelPath, __FILE__, __LINE__);
						return false;
					}
				}

				return true;
			}

			return true;
		}
		catch (const std::exception& e) {
			_logger.LogFatal("ANSFaceRecognizer::LoadEngine", e.what(), __FILE__, __LINE__);
			return false;
		}
	}
	
	std::vector<std::vector<float>> ANSFaceRecognizer::ForwardUnlocked(const cv::Mat& input, const std::vector<ANSCENTER::Object>& outputBbox)
	{
		// Fix #5: Caller must hold _mutex — no lock acquisition here
		std::vector<std::vector<float>> detectedEmbeddings;

		if (input.empty() || outputBbox.empty()) {
			return detectedEmbeddings;
		}

		try {
			detectedEmbeddings.reserve(outputBbox.size());
			if (engineType == EngineType::NVIDIA_GPU) {
				// Collect face ROIs — use GPU-resident masks when available (NV12 path),
				// fall back to CPU masks (standard path). This avoids re-uploading faces
				// that are already on GPU from the NV12 affine warp kernel.
				std::vector<cv::Mat> cpuFaceROIs;
				std::vector<cv::cuda::GpuMat> gpuFaceROIs;
				cpuFaceROIs.reserve(outputBbox.size());
				gpuFaceROIs.reserve(outputBbox.size());
				for (const auto& obj : outputBbox) {
					if (!obj.gpuMask.empty()) {
						gpuFaceROIs.push_back(obj.gpuMask);
						cpuFaceROIs.push_back(cv::Mat()); // placeholder to keep indices aligned
					} else if (!obj.mask.empty()) {
						gpuFaceROIs.push_back(cv::cuda::GpuMat()); // placeholder
						cpuFaceROIs.push_back(obj.mask);
					}
				}
				if (!cpuFaceROIs.empty()) {
					detectedEmbeddings = RunArcFaceBatch(cpuFaceROIs, gpuFaceROIs);
				}
			}
			else {
#ifdef USE_ONNX_ENGINE
	#ifdef USE_CPU_BATCH_MODE
				detectedEmbeddings.clear();

				if (!outputBbox.empty()) {
					// Pre-count valid faces to avoid reallocation
					size_t valid_count = 0;
					for (const auto& obj : outputBbox) {
						if (!obj.mask.empty()) valid_count++;
					}
					if (valid_count == 0) return detectedEmbeddings;
					std::vector<cv::Mat> face_rois;
					face_rois.reserve(valid_count);
					// Prepare batch (only valid faces)
					for (const auto& obj : outputBbox) {
						if (obj.mask.empty()) continue;
						if (obj.mask.cols != CPU_FACE_WIDTH || obj.mask.rows != CPU_FACE_HEIGHT) {
							face_rois.emplace_back();
							cv::resize(obj.mask, face_rois.back(), cv::Size(CPU_FACE_WIDTH, CPU_FACE_HEIGHT));
						}
						else {
							face_rois.push_back(obj.mask);
						}
					}
					// Batch inference
					std::vector<types::FaceContent> face_contents;
					faceRecognizer->detectBatch(face_rois, face_contents);

					// Extract embeddings
					detectedEmbeddings.reserve(face_contents.size());
					for (auto& content : face_contents) {
						if (!content.embedding.empty()) {
							detectedEmbeddings.push_back(std::move(content.embedding));
						}
					}
				}
	#else
				// Using single detection in stead of batch (less efficient)
				detectedEmbeddings.clear();
				detectedEmbeddings.reserve(outputBbox.size());

				if (!outputBbox.empty()) {
					// Pre-allocate frame buffer with target size
					cv::Mat frame(CPU_FACE_HEIGHT, CPU_FACE_WIDTH, CV_8UC3);
					types::FaceContent face_content;

					for (const auto& obj : outputBbox) {
						if (obj.mask.empty()) continue;

						// Resize into pre-allocated buffer
						if (obj.mask.cols != CPU_FACE_WIDTH || obj.mask.rows != CPU_FACE_HEIGHT) {
							cv::resize(obj.mask, frame, cv::Size(CPU_FACE_WIDTH, CPU_FACE_HEIGHT));
						}
						else {
							obj.mask.copyTo(frame);  // Copy into buffer
						}

						// Detect
						faceRecognizer->detect(frame, face_content);

						// Move embedding
						if (!face_content.embedding.empty()) {
							detectedEmbeddings.push_back(std::move(face_content.embedding));
							face_content.embedding.clear();
						}
					}
				}
	#endif
#else
				// OpenVINO path - Optimized version
				std::vector<cv::Mat> face_rois;
				face_rois.reserve(outputBbox.size());
				cv::Mat resized_buffer;
				for (const auto& obj : outputBbox) {
					if (obj.mask.empty()) continue;

					if (obj.mask.cols != CPU_FACE_WIDTH || obj.mask.rows != CPU_FACE_HEIGHT) {
						cv::resize(obj.mask, resized_buffer, cv::Size(CPU_FACE_WIDTH, CPU_FACE_HEIGHT));
						face_rois.push_back(resized_buffer.clone());
					}
					else {
						face_rois.push_back(obj.mask);
					}
				}

				if (!face_rois.empty()) {
					std::vector<cv::Mat> embeddings;
					embeddings.reserve(face_rois.size());
					faceRecognizer->Compute(face_rois, &embeddings);

					detectedEmbeddings.reserve(embeddings.size());

					// Process embeddings efficiently
					for (auto& embMat : embeddings) {
						if (embMat.empty()) continue;

						// Direct emplace_back construction
						if (embMat.isContinuous()) {
							const float* dataPtr = embMat.ptr<float>(0);
							detectedEmbeddings.emplace_back(dataPtr, dataPtr + embMat.total());
						}
						else {
							detectedEmbeddings.emplace_back(embMat.begin<float>(), embMat.end<float>());
						}
					}
				}
#endif
			}
			return detectedEmbeddings;
		}
		catch (const std::exception& e) {
			_logger.LogFatal("ANSFaceRecognizer::ForwardUnlocked", e.what(), __FILE__, __LINE__);
			return std::vector<std::vector<float>>();
		}
	}
	ANSFaceRecognizer::~ANSFaceRecognizer() noexcept {
		try {
			Destroy();
		}
		catch (const std::exception& e) {
			// Log but don't throw - exceptions in destructors are dangerous
			_logger.LogError("ANSFaceRecognizer::~ANSFaceRecognizer",
				e.what(), __FILE__, __LINE__);
		}
		catch (...) {
			// Catch all exceptions to prevent std::terminate
			_logger.LogError("ANSFaceRecognizer::~ANSFaceRecognizer",
				"Unknown exception during destruction", __FILE__, __LINE__);
		}
	}
	void ANSFaceRecognizer::L2NormalizeInPlace(std::vector<float>& vec) {
		// Fix #7: In-place normalization — zero allocations
		float norm = 0.0f;

#pragma omp simd reduction(+:norm)
		for (size_t i = 0; i < vec.size(); ++i) {
			norm += vec[i] * vec[i];
		}

		norm = std::sqrt(norm);

		if (norm > 0.0f) {
			const float inv_norm = 1.0f / norm;

#pragma omp simd
			for (size_t i = 0; i < vec.size(); ++i) {
				vec[i] *= inv_norm;
			}
		}
	}
	std::vector<float> ANSFaceRecognizer::RunArcFace(const cv::Mat& inputImage) {
		std::vector<float> embedding;

		// Defense-in-depth: this function uses m_gpuStream / cv::cuda::GpuMat
		// upload path, which is only valid on NVIDIA hardware.  Callers in
		// Feature() and ExtractEmbeddings() already gate on engineType, but
		// the method is public — refuse to run on AMD/Intel/CPU so we never
		// touch m_gpuStream (lazy-initialized, nullptr on non-NVIDIA) or
		// m_gpuRgb.upload() which would activate the CUDA runtime.
		if (engineType != EngineType::NVIDIA_GPU) {
			_logger.LogError("ANSFaceRecognizer::RunArcFace",
				"RunArcFace is NVIDIA-only; called on engineType="
				+ std::to_string(static_cast<int>(engineType)), __FILE__, __LINE__);
			return embedding;
		}

		// Early validation before locking
		if (inputImage.empty()) {
			_logger.LogError("ANSFaceRecognizer::RunArcFace",
				"Input image is empty", __FILE__, __LINE__);
			return embedding;
		}

		if (inputImage.cols < 10 || inputImage.rows < 10) {
			_logger.LogError("ANSFaceRecognizer::RunArcFace",
				"Input image is too small", __FILE__, __LINE__);
			return embedding;
		}

		std::lock_guard<std::recursive_mutex> lock(_mutex);

		if (!_isInitialized) {
			_logger.LogError("ANSFaceRecognizer::RunArcFace",
				"Model is not initialized", __FILE__, __LINE__);
			return embedding;
		}

		if (!m_gpuStream || !m_trtEngine) {
			_logger.LogError("ANSFaceRecognizer::RunArcFace",
				"GPU stream or TRT engine not available (engineType="
				+ std::to_string(static_cast<int>(engineType)) + ")", __FILE__, __LINE__);
			return embedding;
		}

		try {
			// CPU preprocessing: resize + BGR→RGB before GPU upload
			// Reduces PCIe transfer and eliminates GPU cvtColor/resize overhead
			cv::Mat srcImg = inputImage;
			if (srcImg.channels() == 1) {
				cv::cvtColor(srcImg, srcImg, cv::COLOR_GRAY2BGR);
			}
			cv::Mat cpuResized;
			if (srcImg.cols != GPU_FACE_WIDTH || srcImg.rows != GPU_FACE_HEIGHT) {
				cv::resize(srcImg, cpuResized, cv::Size(GPU_FACE_WIDTH, GPU_FACE_HEIGHT), 0, 0, cv::INTER_LINEAR);
			} else {
				cpuResized = srcImg;
			}
			cv::Mat cpuRGB;
			cv::cvtColor(cpuResized, cpuRGB, cv::COLOR_BGR2RGB);
			m_gpuRgb.upload(cpuRGB, *m_gpuStream);
			m_gpuStream->waitForCompletion();

			// Prepare inference inputs
			std::vector<cv::cuda::GpuMat> inputVec;
			inputVec.emplace_back(m_gpuRgb);

			std::vector<std::vector<cv::cuda::GpuMat>> inputs;
			inputs.emplace_back(std::move(inputVec));

			// Run inference
			std::vector<std::vector<std::vector<float>>> featureVectors;
			bool succ = m_trtEngine->runInference(inputs, featureVectors);

			// Synchronize stream
			m_gpuStream->waitForCompletion();

			if (!succ) {
				_logger.LogError("ANSFaceRecognizer::RunArcFace",
					"Failed to run inference.", __FILE__, __LINE__);
				return embedding;
			}

			if (featureVectors.empty() || featureVectors[0].empty()) {
				_logger.LogError("ANSFaceRecognizer::RunArcFace",
					"Feature vectors are empty.", __FILE__, __LINE__);
				return embedding;
			}

			embedding = std::move(featureVectors[0][0]);
			cv::normalize(embedding, embedding); // l2 normalize

			return embedding;
		}
		catch (const std::exception& e) {
			_logger.LogFatal("ANSFaceRecognizer::RunArcFace", e.what(), __FILE__, __LINE__);
			return embedding;
		}
	}	
	std::vector<std::vector<float>> ANSFaceRecognizer::RunArcFaceBatch(
		const std::vector<cv::Mat>& faceROIs,
		const std::vector<cv::cuda::GpuMat>& gpuFaceROIs)
	{
		std::vector<std::vector<float>> embeddings;

		// Defense-in-depth: TensorRT + cv::cuda::GpuMat batch path is NVIDIA-only.
		// Callers in ExtractEmbeddings() already gate on engineType, but this is a
		// public method — refuse to run on AMD/Intel/CPU so we never touch the
		// TRT engine or cv::cuda primitives on non-NVIDIA hardware.
		if (engineType != EngineType::NVIDIA_GPU) {
			_logger.LogError("ANSFaceRecognizer::RunArcFaceBatch",
				"RunArcFaceBatch is NVIDIA-only; called on engineType="
				+ std::to_string(static_cast<int>(engineType)), __FILE__, __LINE__);
			return embeddings;
		}

		try {
			// Early validation checks
			if (!_isInitialized) {
				_logger.LogError("ANSFaceRecognizer::RunArcFaceBatch",
					"Model is not initialized", __FILE__, __LINE__);
				return embeddings;
			}

			if (!m_trtEngine) {
				_logger.LogError("ANSFaceRecognizer::RunArcFaceBatch",
					"TensorRT engine not initialized", __FILE__, __LINE__);
				return embeddings;
			}

			if (!m_gpuStream) {
				_logger.LogError("ANSFaceRecognizer::RunArcFaceBatch",
					"GPU stream not initialized", __FILE__, __LINE__);
				return embeddings;
			}

			if (faceROIs.empty()) {
				return embeddings;
			}

			const auto& inputDims = m_trtEngine->getInputDims();
			if (inputDims.empty() || inputDims[0].nbDims < 3) {
				_logger.LogError("ANSFaceRecognizer::RunArcFaceBatch",
					"Invalid engine input dims", __FILE__, __LINE__);
				return embeddings;
			}

			// Use actual engine batch limit (profile max), not the configured maxBatchSize
			// which may be larger than what the engine was built with.
			const size_t maxBatch = static_cast<size_t>(
				m_trtEngine->getOptions().maxBatchSize > 0
				? m_trtEngine->getOptions().maxBatchSize
				: m_options.maxBatchSize);
			embeddings.reserve(faceROIs.size());

			const cv::Size targetSize(GPU_FACE_WIDTH, GPU_FACE_HEIGHT);

			// Process in chunks of maxBatchSize to avoid exceeding engine limits
			for (size_t chunkStart = 0; chunkStart < faceROIs.size(); chunkStart += maxBatch) {
				const size_t chunkEnd = std::min(chunkStart + maxBatch, faceROIs.size());

				FR_START_TIMER(gpu_preproc);
				std::vector<cv::cuda::GpuMat> batchGpu;
				batchGpu.reserve(chunkEnd - chunkStart);

				for (size_t i = chunkStart; i < chunkEnd; i++) {
					// Use GPU-resident face if available (NV12 affine warp path),
					// otherwise do CPU resize + BGR→RGB before upload
					if (i < gpuFaceROIs.size() && !gpuFaceROIs[i].empty()) {
						cv::cuda::GpuMat d_img = gpuFaceROIs[i];  // already on GPU
						if (d_img.cols != GPU_FACE_WIDTH || d_img.rows != GPU_FACE_HEIGHT) {
							cv::cuda::GpuMat d_resized;
							cv::cuda::resize(d_img, d_resized, targetSize, 0, 0, cv::INTER_LINEAR, *m_gpuStream);
							d_img = d_resized;
						}
						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 {
						const auto& roi = faceROIs[i];
						if (roi.empty()) continue;

						// CPU preprocessing: resize + BGR→RGB before upload
						cv::Mat srcImg = roi;
						if (srcImg.channels() == 1) {
							cv::cvtColor(srcImg, srcImg, cv::COLOR_GRAY2BGR);
						}
						cv::Mat cpuResized;
						if (srcImg.cols != GPU_FACE_WIDTH || srcImg.rows != GPU_FACE_HEIGHT) {
							cv::resize(srcImg, cpuResized, targetSize, 0, 0, cv::INTER_LINEAR);
						} else {
							cpuResized = srcImg;
						}
						cv::Mat cpuRGB;
						cv::cvtColor(cpuResized, cpuRGB, cv::COLOR_BGR2RGB);
						cv::cuda::GpuMat d_rgb;
						d_rgb.upload(cpuRGB, *m_gpuStream);
						batchGpu.emplace_back(std::move(d_rgb));
					}
				}
				FR_END_TIMER(gpu_preproc, "RunArcFaceBatch GPU preprocess (" + std::to_string(batchGpu.size()) + " faces)");

				if (batchGpu.empty()) continue;

				const size_t actualCount = batchGpu.size();

				std::vector<std::vector<cv::cuda::GpuMat>> inputs;
				inputs.emplace_back(std::move(batchGpu));

				FR_START_TIMER(trt_infer);
				std::vector<std::vector<std::vector<float>>> featureVectors;
				bool succ = m_trtEngine->runInference(inputs, featureVectors);
				m_gpuStream->waitForCompletion();
				FR_END_TIMER(trt_infer, "RunArcFaceBatch TRT inference (batch=" + std::to_string(actualCount) + ")");

				if (!succ) {
					_logger.LogError("ANSFaceRecognizer::RunArcFaceBatch",
						"runInference failed for chunk starting at " + std::to_string(chunkStart),
						__FILE__, __LINE__);
					continue;  // Try remaining chunks instead of aborting
				}

				if (featureVectors.empty()) continue;

				for (size_t j = 0; j < featureVectors.size(); j++) {
					if (!featureVectors[j].empty() && !featureVectors[j][0].empty()) {
						auto emb = std::move(featureVectors[j][0]);
						cv::normalize(emb, emb);
						embeddings.emplace_back(std::move(emb));
					}
				}
			}

			return embeddings;
		}
		catch (const cv::Exception& e) {
			_logger.LogFatal("ANSFaceRecognizer::RunArcFaceBatch",
				"OpenCV error: " + std::string(e.what()), __FILE__, __LINE__);
			return embeddings;
		}
		catch (const std::exception& e) {
			_logger.LogFatal("ANSFaceRecognizer::RunArcFaceBatch",
				e.what(), __FILE__, __LINE__);
			return embeddings;
		}
	}
	void ANSFaceRecognizer::Init() {
		std::lock_guard<std::recursive_mutex> lock(_mutex);

		try {
			_faceIdToUserId.clear();
			_nextFaceId = 0;

			// Always create a fresh FAISS index
			if (faiss_index) {
				faiss_index->reset();
				faiss_index.reset();
			}

			if (engineType == EngineType::NVIDIA_GPU) {
				// GPU mode: Initialize GPU resources (shared across index rebuilds)
				if (!m_gpuResources) {
					m_gpuResources = std::make_shared<faiss::gpu::StandardGpuResources>();
				}
				auto gpuIndex = new faiss::gpu::GpuIndexFlatIP(
					m_gpuResources.get(), FACE_EMBEDDING_SIZE);
				faiss_index = std::make_shared<faiss::IndexIDMap>(gpuIndex);
			}
			else {
				// CPU mode: Use CPU IndexFlatIP
				auto cpuIndex = new faiss::IndexFlatIP(FACE_EMBEDDING_SIZE);
				faiss_index = std::make_shared<faiss::IndexIDMap>(cpuIndex);
			}
			faiss_index->own_fields = true;

			_isInitialized = true;

		}
		catch (const std::exception& e) {
			_isInitialized = false;
			_logger.LogFatal("ANSFaceRecognizer::Init",
				std::string(e.what()), __FILE__, __LINE__);
		}
		catch (...) {
			_isInitialized = false;
			_logger.LogFatal("ANSFaceRecognizer::Init",
				"Unknown exception occurred", __FILE__, __LINE__);
		}
	}
	bool ANSFaceRecognizer::Destroy() {
		std::lock_guard<std::recursive_mutex> lock(_mutex);

		try {
			// Mark as uninitialized first to prevent new operations
			_isInitialized = false;

			// Clear GPU/TensorRT resources first (may fail, so do early)
			if (m_usingSharedPool) {
				EnginePoolManager<float>::instance().release(m_poolKey);
				m_trtEngine.reset();
				m_usingSharedPool = false;
			}
			else if (m_trtEngine) {
				m_trtEngine.reset();
			}

			// Clear FAISS index BEFORE GPU resources (index lives on GPU)
			if (faiss_index) {
				faiss_index->reset();  // Clear index data
				faiss_index.reset();    // Delete the object (frees GPU memory)
			}

			// Release FAISS GPU resources after index is destroyed
			if (m_gpuResources) {
				m_gpuResources.reset();
			}

			// Clear face recognizer
			if (faceRecognizer) {
				faceRecognizer.reset();
			}

			// Clear face ID mapping last (safest operation)
			_faceIdToUserId.clear();
			_nextFaceId = 0;

			return true;
		}
		catch (const std::exception& e) {
			_logger.LogFatal("ANSFaceRecognizer::Destroy", e.what(), __FILE__, __LINE__);

			// Even on failure, mark as uninitialized
			_isInitialized = false;

			return false;
		}
	}
	void ANSFaceRecognizer::AddEmbedding(const std::string& className,float embedding[]) {
		std::lock_guard<std::recursive_mutex> lock(_mutex);

		try {
			if (!faiss_index) {
				_logger.LogFatal("ANSFaceRecognizer::AddEmbedding",
					"Search_index is not initialized.", __FILE__, __LINE__);
				return;
			}

			// Fix #1: L2-normalize before storing so L2²/2 = 1-cos(θ)
			std::vector<float> normEmb(embedding, embedding + FACE_EMBEDDING_SIZE);
			L2NormalizeInPlace(normEmb);

			// Use sequential ID for backward-compat path (initial load)
			faiss::idx_t id = _nextFaceId++;
			_faceIdToUserId[id] = className;
			faiss_index->add_with_ids(1, normEmb.data(), &id);

		}
		catch (const std::exception& e) {
			_logger.LogFatal("ANSFaceRecognizer::AddEmbedding", e.what(), __FILE__, __LINE__);
		}
	}
	void ANSFaceRecognizer::AddEmbedding(const std::string& className,const std::vector<float>& embedding) {
		// Early validation before locking (non-shared state)
		if (embedding.size() != FACE_EMBEDDING_SIZE) {
			_logger.LogFatal("ANSFaceRecognizer::AddEmbedding",
				"Embedding size != 512.", __FILE__, __LINE__);
			return;
		}

		std::lock_guard<std::recursive_mutex> lock(_mutex);

		try {
			if (!faiss_index) {
				_logger.LogFatal("ANSFaceRecognizer::AddEmbedding",
					"Search_index is not initialized.", __FILE__, __LINE__);
				return;
			}

			// Fix #1: L2-normalize before storing so L2²/2 = 1-cos(θ)
			std::vector<float> normEmb = embedding;
			L2NormalizeInPlace(normEmb);

			faiss::idx_t id = _nextFaceId++;
			_faceIdToUserId[id] = className;
			faiss_index->add_with_ids(1, normEmb.data(), &id);
		}
		catch (const std::exception& e) {
			_logger.LogFatal("ANSFaceRecognizer::AddEmbedding", e.what(), __FILE__, __LINE__);
		}
	}
	void ANSFaceRecognizer::SwapIndex(
		std::shared_ptr<faiss::IndexIDMap> newIndex,
		std::unordered_map<faiss::idx_t, std::string>&& newFaceIdToUserId)
	{
		std::lock_guard<std::recursive_mutex> lock(_mutex);

		try {
			faiss_index = std::move(newIndex);
			_faceIdToUserId = std::move(newFaceIdToUserId);
			_nextFaceId = static_cast<faiss::idx_t>(_faceIdToUserId.size());

			_logger.LogDebug("ANSFaceRecognizer::SwapIndex",
				"Index swapped successfully. Total embeddings: " +
				std::to_string(faiss_index ? faiss_index->ntotal : 0),
				__FILE__, __LINE__);
		}
		catch (const std::exception& e) {
			_logger.LogFatal("ANSFaceRecognizer::SwapIndex",
				e.what(), __FILE__, __LINE__);
		}
	}
	std::tuple<std::vector<std::string>, std::vector<float>>
		ANSFaceRecognizer::SearchForFacesUnlocked(const std::vector<std::vector<float>>& detectedEmbeddings)
	{
		// Fix #1 + #5: No lock (caller holds _mutex), no reconstruct(),
		// use L2²/2 directly. All stored + query embeddings are L2-normalized,
		// so L2²(a,b)/2 = 1 - cos(a,b) = similarity.
		std::vector<std::string> detectedUsers;
		std::vector<float> simValues;

		try {
			const size_t nq = detectedEmbeddings.size();

			if (nq == 0 || _faceIdToUserId.empty() || !faiss_index || faiss_index->ntotal == 0) {
				detectedUsers.assign(nq, "0");
				simValues.assign(nq, 2.0f);
				return std::make_tuple(detectedUsers, simValues);
			}

			const int k = 10;
			const int d = static_cast<int>(detectedEmbeddings[0].size());

			FR_START_TIMER(search_detail);

			// Build contiguous query matrix (nq × d) — embeddings are already
			// L2-normalized by RunArcFaceBatch (cv::normalize), so just copy
			FR_START_TIMER(build_matrix);
			std::vector<float> queryMatrix(nq * d);
			for (size_t i = 0; i < nq; i++) {
				std::copy(detectedEmbeddings[i].begin(), detectedEmbeddings[i].end(),
					queryMatrix.begin() + i * d);
			}
			FR_END_TIMER(build_matrix, "Build query matrix (nq=" + std::to_string(nq) + ")");

			// Single batched FAISS search — uses BLAS/MKL for matrix multiply
			// when nq > 1, which is dramatically faster than nq individual searches
			FR_START_TIMER(batch_search);
			std::vector<float> allDistances(nq * k);
			std::vector<faiss::idx_t> allIndices(nq * k);
			faiss_index->search(static_cast<faiss::idx_t>(nq), queryMatrix.data(), k,
				allDistances.data(), allIndices.data());
			FR_END_TIMER(batch_search, "FAISS batch search (nq=" + std::to_string(nq) + ")");

			// Process results: find best matching user for each query
			detectedUsers.reserve(nq);
			simValues.reserve(nq);

			for (size_t q = 0; q < nq; q++) {
				float bestSim = 2.0f;
				std::string bestUser = "0";

				const faiss::idx_t* qIndices = allIndices.data() + q * k;
				const float* qDistances = allDistances.data() + q * k;

				for (int i = 0; i < k; ++i) {
					faiss::idx_t id = qIndices[i];
					if (id < 0) continue;

					auto it = _faceIdToUserId.find(id);
					if (it == _faceIdToUserId.end()) continue;

					// IP returns dot(a,b); for unit vectors: 1 - dot = 1 - cos(θ) = same as L2²/2
					float similarity = 1.0f - qDistances[i];

					if (similarity < bestSim) {
						bestSim = similarity;
						bestUser = it->second;
					}
				}

				detectedUsers.push_back(std::move(bestUser));
				simValues.push_back(bestSim);
			}

			FR_END_TIMER(search_detail, "SearchForFacesUnlocked total");
			return std::make_tuple(detectedUsers, simValues);
		}
		catch (const std::exception& e) {
			detectedUsers.assign(1, "0000");
			simValues.assign(1, 2.0f);
			_logger.LogFatal("ANSFaceRecognizer::SearchForFacesUnlocked",
				e.what(), __FILE__, __LINE__);
			return std::make_tuple(detectedUsers, simValues);
		}
	}

	
	//std::tuple<std::vector<std::string>, std::vector<float>>
	//	ANSFaceRecognizer::SearchForFaces(
	//		const std::vector<std::vector<float>>& detectedEmbeddings)
	//{
	//	std::lock_guard<std::recursive_mutex> lock(_mutex);
	//	std::vector<std::string> detectedUsers;
	//	std::vector<float> simValues;

	//	try {
	//		if (!classNames.empty() && faiss_index && faiss_index->ntotal > 0) {
	//			const int k = 10;
	//			for (const auto& embedding : detectedEmbeddings) {
	//				std::vector<faiss::idx_t> indices(k);
	//				std::vector<float> distances(k);

	//				faiss_index->search(1, embedding.data(), k,
	//					distances.data(), indices.data());

	//				float bestSim = 2.0f;
	//				std::string bestUser = "0";

	//				for (int i = 0; i < k; ++i) {
	//					faiss::idx_t id = indices[i];
	//					if (id < 0 || id >= static_cast<faiss::idx_t>(classNames.size())) {
	//						continue;
	//					}

	//					std::vector<float> matchEmbedding(faiss_index->d);
	//					faiss_index->reconstruct(id, matchEmbedding.data());

	//					float cosine = CosineSimilarity(embedding, matchEmbedding, true);
	//					float similarity = 1.0f - cosine; // [0,2], 0 best

	//					if (similarity < bestSim) {
	//						bestSim = similarity;
	//						bestUser = classNames.at(id);
	//					}
	//				}

	//				detectedUsers.push_back(bestUser);
	//				simValues.push_back(bestSim);
	//			}
	//		}
	//		else {
	//			detectedUsers.assign(detectedEmbeddings.size(), "0");
	//			simValues.assign(detectedEmbeddings.size(), 2.0f);
	//		}

	//		return std::make_tuple(detectedUsers, simValues);
	//	}
	//	catch (const std::exception& e) {
	//		detectedUsers.assign(1, "0000");
	//		simValues.assign(1, 2.0f);
	//		_logger.LogFatal("ANSFaceRecognizer::SearchForFaces",
	//			e.what(), __FILE__, __LINE__);
	//		return std::make_tuple(detectedUsers, simValues);
	//	}
	//}
}



// Old method
   //std::tuple<std::vector<std::string>, std::vector<float>> ANSFaceRecognizer::SearchForFaces(std::vector<std::vector<float>> detectedEmbeddings) {
	//    std::lock_guard<std::recursive_mutex> lock(_mutex);
	//    std::vector<std::string> detectedUsers;
	//    std::vector<float> simValues;
	//    try {
	//        // Check if there are class names available
	//        if (!classNames.empty()) {
	//            const int k = 3;  // Number of nearest neighbors to retrieve
	//            // Process each detected embedding
	//            for (const auto& embedding : detectedEmbeddings) {
	//                // Prepare vectors to hold search results
	//                std::vector<faiss::idx_t> indices(k);
	//                std::vector<float> distances(k);

	//                // Perform the search for the k nearest neighbors
	//                faiss_index->search(1, embedding.data(), k, distances.data(), indices.data());

	//                //  Find the index with the minimum distance (i.e., closest neighbor)
	//                auto min_it = std::min_element(distances.begin(), distances.end());
	//                int best_index = std::distance(distances.begin(), min_it);

	//                // Map the index to the corresponding class name and calculate similarity
	//                std::vector<float> matchEmbedding(faiss_index->d);
	//                faiss_index->reconstruct(indices[best_index], matchEmbedding.data());
	//                float similarity = 1 - CosineSimilarity(embedding, matchEmbedding, true);
	//                detectedUsers.push_back(classNames.at(indices[best_index]));
	//                simValues.push_back(std::abs(similarity));
	//            }
	//        }
	//        else {
	//            // If no class names are available, mark all users as "unknown"
	//            detectedUsers.assign(detectedEmbeddings.size(), "0000");
	//            simValues.assign(detectedEmbeddings.size(), 1.0f);
	//        }

	//        return std::make_tuple(detectedUsers, simValues);

	//    }
	//    catch (const std::exception& e) {
	//        // Log the error and return default values for the failed search
	//        detectedUsers.assign(1, "0000");
	//        simValues.assign(1, 1.0f);
	//        this->_logger.LogFatal("ANSFaceRecognizer::SearchForFaces", e.what(), __FILE__, __LINE__);
	//        return std::make_tuple(detectedUsers, simValues);
	//    }
	//} 
	//std::tuple<std::vector<std::string>, std::vector<float>> ANSFaceRecognizer::SearchForFaces(const std::vector<std::vector<float>>& detectedEmbeddings)
	//{
	//    std::lock_guard<std::recursive_mutex> lock(_mutex);
	//    std::vector<std::string> detectedUsers;
	//    std::vector<float> simValues;
	//    try {
	//        if (!classNames.empty() && faiss_index && faiss_index->ntotal > 0) {
	//            const int k = 3;

	//            for (const auto& embedding : detectedEmbeddings) {
	//                std::vector<faiss::idx_t> indices(k);
	//                std::vector<float> distances(k);

	//                faiss_index->search(1, embedding.data(), k, distances.data(), indices.data());

	//                // Find best (smallest distance) match
	//                auto min_it = std::min_element(distances.begin(), distances.end());
	//                int best_index = std::distance(distances.begin(), min_it);
	//                faiss::idx_t best_id = indices[best_index];

	//                if (best_id < 0 || best_id >= static_cast<faiss::idx_t>(classNames.size())) {
	//                    detectedUsers.push_back("0000");
	//                    simValues.push_back(1.0f);
	//                    continue;
	//                }

	//                // Reconstruct matched embedding
	//                std::vector<float> matchEmbedding(faiss_index->d);
	//                faiss_index->reconstruct(best_id, matchEmbedding.data());
				//	float similarity = CosineSimilarity(embedding, matchEmbedding, true);
	//                detectedUsers.push_back(classNames.at(best_id));
	//                simValues.push_back(similarity);
	//            }
	//        }
	//        else {
	//            detectedUsers.assign(detectedEmbeddings.size(), "0000");
	//            simValues.assign(detectedEmbeddings.size(), 1.0f);
	//        }

	//        return std::make_tuple(detectedUsers, simValues);
	//    }
	//    catch (const std::exception& e) {
	//        detectedUsers.assign(1, "0000");
	//        simValues.assign(1, 1.0f);
	//        this->_logger.LogFatal("ANSFaceRecognizer::SearchForFaces", e.what(), __FILE__, __LINE__);
	//        return std::make_tuple(detectedUsers, simValues);
	//    }
	//}

  //space = new hnswlib::InnerProductSpace(FACE_EMBEDDING_SIZE); // it should be in init
	//void ANSFaceRecognizer::Init() 
	//{
	//  try {
	//      classNames.clear();
	//      int maxElements = 100000;   // Maximum number of elements, should be known beforehand
	//      int M = 16;                 // Tightly connected with internal dimensionality of the data
	//      int efConstruction = 200;  // Controls index search speed/build speed tradeoff
	//      this->alg_hnsw = std::make_unique<hnswlib::HierarchicalNSW<float>>(space, maxElements, M, efConstruction);
	//  }
	//  catch (std::exception& e) {
	//      this->_logger.LogFatal("ANSFaceRecognizer::Init", e.what(), __FILE__, __LINE__);
	//  }
	//}

  /*
  * void ANSFaceRecognizer::Init() {
	  try {
		  // Clear class names and reset resources
		  classNames.clear();
		  // Define parameters
		  constexpr int maxElements = 100000;  // Maximum number of elements
		  constexpr int M = 16;                // Internal dimensionality of the data
		  constexpr int efConstruction = 200; // Controls index search/build tradeoff

		  // Release and reinitialize the space
		  if (space) {
			  delete space;
			  space = nullptr;
		  }
		  space = new hnswlib::InnerProductSpace(FACE_EMBEDDING_SIZE);

		  // Reinitialize the HNSW algorithm
		  alg_hnsw = std::make_unique<hnswlib::HierarchicalNSW<float>>(space, maxElements, M, efConstruction);
	  }
	  catch (const std::exception& e) {
		  _logger.LogFatal("ANSFaceRecognizer::Init", e.what(), __FILE__, __LINE__);
	  }
	  catch (...) {
		  _logger.LogFatal("ANSFaceRecognizer::Init", "Unknown exception occurred", __FILE__, __LINE__);
	  }
  }
  bool ANSFaceRecognizer::Destroy() {
	  try {
		  if (space) {
			  delete space;
			  space = nullptr;
		  }
		  return true;
	  }
	  catch (std::exception& e) {
		  this->_logger.LogFatal("ANSFaceRecognizer::Destroy", e.what(), __FILE__, __LINE__);
		  return false;
	  }
  }
  void ANSFaceRecognizer::AddEmbedding(const std::string& className, float embedding[]) {
	  try {
		  classNames.push_back(className);
		  int index = classNames.size() - 1;
		  int outputDim = 512;
		  std::vector<float> vec(embedding, embedding + outputDim);
		  std::vector<float> normalizedVector = NormalizeVector(vec);
		  alg_hnsw->addPoint(normalizedVector.data(), (size_t)index);
	  }
	  catch (std::exception& e) {
		  this->_logger.LogFatal("ANSFaceRecognizer::AddEmbedding", e.what(), __FILE__, __LINE__);
	  }
  }
  void ANSFaceRecognizer::AddEmbedding(const std::string& className, const std::vector<float>& embedding) {
	  try {
		  classNames.push_back(className);
		  int index = classNames.size() - 1;
		  std::vector<float> normalizedVector = NormalizeVector(embedding);
		  alg_hnsw->addPoint(normalizedVector.data(), index);
	  }
	  catch (std::exception& e) {
		  this->_logger.LogFatal("ANSFaceRecognizer::AddEmbedding", e.what(), __FILE__, __LINE__);
	  }
  }
  std::tuple<std::vector<std::string>, std::vector<float>> ANSFaceRecognizer::SearchForFaces(std::vector<std::vector<float>> detectedEmbeddings) {
	  std::vector<std::string> detectedUsers;
	  std::vector<float> distanceValues;
	  try {
		  if (classNames.size() > 0) {
			  detectedUsers.clear();
			  for (int i = 0; i < detectedEmbeddings.size(); i++) {
				  NormalizeVector(detectedEmbeddings[i]);
				  std::priority_queue<std::pair<float, hnswlib::labeltype>> result = alg_hnsw->searchKnn(detectedEmbeddings[i].data(), 1);
				  hnswlib::labeltype label = result.top().second;
				  if (label >= 0) {
					  detectedUsers.push_back(classNames.at(label));
					  distanceValues.push_back(result.top().first);
				  }
			  }
			  return std::make_tuple(detectedUsers, distanceValues);
		  }
		  else {

			  detectedUsers.clear();
			  for (int i = 0; i < detectedEmbeddings.size(); i++) {
				  detectedUsers.push_back("0000");
				  distanceValues.push_back(1);
			  }
			  return std::make_tuple(detectedUsers, distanceValues);
		  }
	  }

	  catch (std::exception& e) {
		  detectedUsers.push_back("0000");
		  distanceValues.push_back(1);
		  this->_logger.LogFatal("ANSArcFace100::SearchForFaces", e.what(), __FILE__, __LINE__);
		  return std::make_tuple(detectedUsers, distanceValues);
	  }
  }
  */

  // Private methods, can be replacable
/*  std::vector<std::vector<float>> ANSFaceRecognizer::Forward(const cv::Mat& input, std::vector<ANSCENTER::Object> outputBbox) {
	  std::lock_guard<std::recursive_mutex> lock(_mutex);
	  std::vector<std::vector<float>> detectedEmbeddings;
	  if (input.empty()) {
		  this->_logger.LogError("ANSFaceRecognizer::Forward", "Input image is empty", __FILE__, __LINE__);
		  return detectedEmbeddings;
	  }
	  try {
		  if (engineType == EngineType::NVIDIA_GPU) {
			  detectedEmbeddings.clear();
			  if (outputBbox.size() > 0) {
				  for (int i = 0; i < outputBbox.size(); i++) {
					  cv::Mat faceROI = outputBbox[i].mask.clone();
					  if (faceROI.empty()) continue;
					  if ((faceROI.cols != GPU_FACE_WIDTH) && (faceROI.rows != GPU_FACE_HEIGHT))
					  {
						  cv::resize(faceROI, faceROI, cv::Size(GPU_FACE_WIDTH, GPU_FACE_HEIGHT));
					  }
					  std::vector<float> embedding = RunArcFace(faceROI);
					  detectedEmbeddings.push_back(embedding);
					  faceROI.release();
				  }
			  }
		  }
		  else {
			  std::vector<cv::Mat> embeddings;
			  std::vector<cv::Mat> face_rois;
			  detectedEmbeddings.clear();
			  if (outputBbox.size() > 0) {
				  for (int i = 0; i < outputBbox.size(); i++) {
					  std::vector<float> embeddingRs;
					  cv::Mat frame = outputBbox[i].mask.clone();
					  if (frame.empty()) continue;
					  if ((frame.cols != CPU_FACE_WIDTH) && (frame.rows != CPU_FACE_HEIGHT))
					  {
						  cv::resize(frame, frame, cv::Size(CPU_FACE_WIDTH, CPU_FACE_HEIGHT));
					  }
#ifdef USE_ONNX_ENGINE
						types::FaceContent face_content;
						faceRecognizer->detect(frame, face_content);
						embeddingRs = face_content.embedding;
#else
						face_rois.clear();
						embeddings.clear();
						face_rois.push_back(frame);
						faceRecognizer->Compute(face_rois, &embeddings);
						embeddingRs.assign(embeddings[0].begin<float>(), embeddings[0].end<float>());
#endif
						detectedEmbeddings.push_back(embeddingRs);
						frame.release();
					}
				}
			}
			return detectedEmbeddings;
		}
		catch (std::exception& e) {
			this->_logger.LogFatal("ANSFaceRecognizer::Forward", e.what(), __FILE__, __LINE__);
			return detectedEmbeddings;
		}
	} */



	// Before refactor (working version)
/*std::vector<float> ANSFaceRecognizer::Feature(const cv::Mat& image,
		ANSCENTER::Object bBox) {
		std::lock_guard<std::recursive_mutex> lock(_mutex);
		std::vector<float> embeddingResult;

		if (image.empty()) {
			_logger.LogError("ANSFaceRecognizer::Feature",
				"Input image is empty", __FILE__, __LINE__);
			return embeddingResult;
		}

		try {
			if (engineType == EngineType::NVIDIA_GPU) {
				embeddingResult = RunArcFace(bBox.mask);
				return embeddingResult;
			}
			else {
				if (image.cols < 10 || image.rows < 10) return embeddingResult;

				cv::Mat frame = bBox.mask.clone();
#ifdef USE_ONNX_ENGINE
				types::FaceContent face_content;
				faceRecognizer->detect(frame, face_content);
				embeddingResult = face_content.embedding;
#else
				cv::Mat embedding;
				faceRecognizer->Compute(frame, &embedding);
				embeddingResult.assign(embedding.begin<float>(), embedding.end<float>());
#endif
				return embeddingResult;
			}
		}
		catch (const std::exception& e) {
			_logger.LogFatal("ANSFaceRecognizer::Feature", e.what(), __FILE__, __LINE__);
			embeddingResult.clear();
			return embeddingResult;
		}
	}*/

	/*std::vector<FaceResultObject> ANSFaceRecognizer::Match(
		const cv::Mat& input,
		std::vector<ANSCENTER::Object> bBox,
		std::map<std::string, std::string> userDict) {
		std::lock_guard<std::recursive_mutex> lock(_mutex);
		std::vector<FaceResultObject> resultObjects;

		if (input.empty()) {
			_logger.LogError("ANSFaceRecognizer::Match",
				"Input image is empty", __FILE__, __LINE__);
			return resultObjects;
		}
		if (!_isInitialized) {
			_logger.LogError("ANSFaceRecognizer::Match",
				"Model is not initialized", __FILE__, __LINE__);
			return resultObjects;
		}

		try {
			if (input.cols < 10 || input.rows < 10) return resultObjects;

			std::vector<std::vector<float>> detectedEmbeddings = Forward(input, bBox);
			std::vector<std::string> names;
			std::vector<float> sims;
			std::tie(names, sims) = SearchForFaces(detectedEmbeddings);

			if (names.empty()) {
				_logger.LogError("ANSFaceRecognizer::Match",
					"No face is match", __FILE__, __LINE__);
				return resultObjects;
			}

			for (size_t i = 0; i < names.size() && i < bBox.size(); ++i) {
				FaceResultObject resultObject;
				bool isUnknown = (sims[i] > m_knownPersonThresh);

				if (isUnknown) {
					resultObject.isUnknown = true;
					resultObject.userId = "0";
					resultObject.userName = "Unknown";
					resultObject.confidence = 1.0f;
				}
				else {
					resultObject.isUnknown = false;
					resultObject.userId = names[i];
					resultObject.userName = userDict[names[i]];
					resultObject.confidence =
						std::clamp((2.0f - sims[i]) / 2.0f, 0.0f, 1.0f);
				}

				resultObject.similarity = sims[i];

				float x = bBox[i].box.x;
				float y = bBox[i].box.y;
				float w = bBox[i].box.width;
				float h = bBox[i].box.height;

				x = std::max(0.0f, x);
				y = std::max(0.0f, y);
				w = std::min(w, input.cols - x);
				h = std::min(h, input.rows - y);

				resultObject.box.x = x;
				resultObject.box.y = y;
				resultObject.box.width = w;
				resultObject.box.height = h;
				resultObject.mask = bBox[i].mask;
				resultObject.cameraId = bBox[i].cameraId;
				resultObject.trackId = bBox[i].trackId;
				resultObject.polygon = bBox[i].polygon;
				resultObject.kps = bBox[i].kps;
				resultObject.extraInformation = bBox[i].extraInfo;

				resultObjects.push_back(resultObject);
			}

			return resultObjects;
		}
		catch (const std::exception& e) {
			_logger.LogFatal("ANSFaceRecognizer::Match", e.what(), __FILE__, __LINE__);
			return resultObjects;
		}
	}*/

	//cv::Mat ANSFaceRecognizer::GetCropFace(const cv::Mat& input,
		//	ANSCENTER::Object bBox) {
		//	try {
		//		std::vector<ANSCENTER::Object> outputBbox;
		//		outputBbox.push_back(bBox);
		//		std::vector<CroppedFace> crFaces;
		//		crFaces.clear();

		//		if (engineType == EngineType::NVIDIA_GPU) {
		//			ANSFRHelper::GetCroppedFaces(input, outputBbox, GPU_FACE_WIDTH, GPU_FACE_HEIGHT, crFaces);
		//		}
		//		else {
		//			ANSFRHelper::GetCroppedFaces(input, outputBbox, CPU_FACE_WIDTH, CPU_FACE_HEIGHT, crFaces);
		//		}
		//		if (crFaces.empty()) return cv::Mat();
		//		return crFaces[0].faceMat;
		//	}
		//	catch (const std::exception& e) {
		//		_logger.LogFatal("ANSFaceRecognizer::GetCropFace", e.what(), __FILE__, __LINE__);
		//		return cv::Mat();
		//	}
		//}

/*void ANSFaceRecognizer::AddEmbedding(const std::string& className,
		float embedding[]) {
		std::lock_guard<std::recursive_mutex> lock(_mutex);
		try {
			if (!faiss_index) {
				_logger.LogFatal("ANSFaceRecognizer::AddEmbedding",
					"Search_index is not initialized.", __FILE__, __LINE__);
				return;
			}
			std::vector<float> vec(embedding, embedding + FACE_EMBEDDING_SIZE);
			if (vec.size() != FACE_EMBEDDING_SIZE) {
				_logger.LogFatal("ANSFaceRecognizer::AddEmbedding",
					"Embedding size != 512.", __FILE__, __LINE__);
				return;
			}
			classNames.push_back(className);
			faiss_index->add(1, vec.data());
		}
		catch (const std::exception& e) {
			_logger.LogFatal("ANSFaceRecognizer::AddEmbedding", e.what(), __FILE__, __LINE__);
		}
	}*/

	/*void ANSFaceRecognizer::AddEmbedding(const std::string& className,
		const std::vector<float>& embedding) {
		std::lock_guard<std::recursive_mutex> lock(_mutex);
		try {
			if (!faiss_index) {
				_logger.LogFatal("ANSFaceRecognizer::AddEmbedding",
					"Search_index is not initialized.", __FILE__, __LINE__);
				return;
			}
			if (embedding.size() != FACE_EMBEDDING_SIZE) {
				_logger.LogFatal("ANSFaceRecognizer::AddEmbedding",
					"Embedding size != 512.", __FILE__, __LINE__);
				return;
			}
			classNames.push_back(className);
			faiss_index->add(1, embedding.data());
		}
		catch (const std::exception& e) {
			_logger.LogFatal("ANSFaceRecognizer::AddEmbedding", e.what(), __FILE__, __LINE__);
		}
	}*/

	//void ANSFaceRecognizer::Init() {
	//	std::lock_guard<std::recursive_mutex> lock(_mutex);
	//	try {
	//		classNames.clear();

	//		if (faiss_index) {
	//			faiss_index->reset();
	//		}
	//		else {
	//			faiss_index = std::make_shared<faiss::IndexFlatL2>(FACE_EMBEDDING_SIZE);
	//		}
	//	}
	//	catch (const std::exception& e) {
	//		_logger.LogFatal("ANSFaceRecognizer::Init", e.what(), __FILE__, __LINE__);
	//	}
	//	catch (...) {
	//		_logger.LogFatal("ANSFaceRecognizer::Init", "Unknown exception occurred", __FILE__, __LINE__);
	//	}
	//}

//std::vector<float> ANSFaceRecognizer::RunArcFace(const cv::Mat& inputImage) {
	//	std::lock_guard<std::recursive_mutex> lock(_mutex);
	//	std::vector<float> embedding;

	//	if (inputImage.empty()) {
	//		_logger.LogError("ANSFaceRecognizer::RunArcFace",
	//			"Input image is empty", __FILE__, __LINE__);
	//		return embedding;
	//	}
	//	if (!_isInitialized) {
	//		_logger.LogError("ANSFaceRecognizer::RunArcFace",
	//			"Model is not initialized", __FILE__, __LINE__);
	//		return embedding;
	//	}
	//	if (inputImage.cols < 10 || inputImage.rows < 10) {
	//		_logger.LogError("ANSFaceRecognizer::RunArcFace",
	//			"Input image is too small", __FILE__, __LINE__);
	//		return embedding;
	//	}

	//	try {
	//		cv::Mat frame;
	//		if (inputImage.channels() == 1) {
	//			cv::cvtColor(inputImage, frame, cv::COLOR_GRAY2BGR);
	//		}
	//		else {
	//			frame = inputImage;
	//		}

	//		if (frame.cols != GPU_FACE_WIDTH || frame.rows != GPU_FACE_HEIGHT) {
	//			cv::resize(frame, frame, cv::Size(GPU_FACE_WIDTH, GPU_FACE_HEIGHT));
	//		}

	//		cv::cvtColor(frame, frame, cv::COLOR_BGR2RGB);

	//		cv::cuda::Stream stream;
	//		cv::cuda::GpuMat img;
	//		img.upload(frame, stream);
	//		stream.waitForCompletion();

	//		std::vector<cv::cuda::GpuMat> inputVec{ std::move(img) };
	//		std::vector<std::vector<cv::cuda::GpuMat>> inputs{ std::move(inputVec) };

	//		std::vector<std::vector<std::vector<float>>> featureVectors;
	//		bool succ = m_trtEngine->runInference(inputs, featureVectors);

	//		if (!succ) {
	//			_logger.LogError("ANSFaceRecognizer::RunArcFace",
	//				"Failed to run inference.", __FILE__, __LINE__);
	//			return embedding;
	//		}
	//		if (featureVectors.empty() || featureVectors[0].empty()) {
	//			_logger.LogError("ANSFaceRecognizer::RunArcFace",
	//				"Feature vectors are empty.", __FILE__, __LINE__);
	//			return embedding;
	//		}

	//		embedding = std::move(featureVectors[0][0]);
	//		cv::normalize(embedding, embedding); // l2 normalize
	//		return embedding;
	//	}
	//	catch (const std::exception& e) {
	//		_logger.LogFatal("ANSFaceRecognizer::RunArcFace", e.what(), __FILE__, __LINE__);
	//		return embedding;
	//	}
	//}
	//    std::vector<std::vector<float>> ANSFaceRecognizer::RunArcFaceBatch(const std::vector<cv::Mat>& faceROIs) 
	//    {
	//        std::vector<std::vector<float>> embeddings;
	//    try {
	//        if (!_isInitialized) {
	//            _logger.LogError("ANSFaceRecognizer::RunArcFaceBatch",
	//                "Model is not initialized", __FILE__, __LINE__);
	//            return embeddings;
	//        }
	//        if (!m_trtEngine) {
	//            _logger.LogError("ANSFaceRecognizer::RunArcFaceBatch",
	//                "TensorRT engine not initialized", __FILE__, __LINE__);
	//            return embeddings;
	//        }
	//        if (faceROIs.empty()) {
	//            return embeddings;
	//        }
	//        if (faceROIs.size() > static_cast<size_t>(m_options.maxBatchSize)) {
	//            _logger.LogError("ANSFaceRecognizer::RunArcFaceBatch",
	//                "Batch size " + std::to_string(faceROIs.size()) +
	//                " exceeds maxBatchSize " + std::to_string(m_options.maxBatchSize),
	//                __FILE__, __LINE__);
	//            return embeddings;
	//        }
	//
	//        const auto& inputDims = m_trtEngine->getInputDims();
	//        if (inputDims.empty() || inputDims[0].nbDims < 3) {
	//            _logger.LogError("ANSFaceRecognizer::RunArcFaceBatch",
	//                "Invalid engine input dims", __FILE__, __LINE__);
	//            return embeddings;
	//        }
	//
	//        // Prepare GPU batch
	//        cv::cuda::Stream stream;
	//        std::vector<cv::cuda::GpuMat> batchGpu;
	//        batchGpu.reserve(faceROIs.size());
	//
	//        for (size_t i = 0; i < faceROIs.size(); ++i) {
	//            const cv::Mat& roi = faceROIs[i];
	//            if (roi.empty()) {
	//                continue;
	//            }
	//            cv::Mat frame;
	//            if (roi.channels() == 1) {
	//                cv::cvtColor(roi, frame, cv::COLOR_GRAY2BGR);
	//            }
	//            else {
	//                frame = roi;
	//            }
	//
	//            if (frame.cols != GPU_FACE_WIDTH || frame.rows != GPU_FACE_HEIGHT) {
	//                cv::resize(frame, frame, cv::Size(GPU_FACE_WIDTH, GPU_FACE_HEIGHT));
	//            }
	//
	//            cv::cvtColor(frame, frame, cv::COLOR_BGR2RGB);
	//
	//            cv::cuda::GpuMat d_img;
	//            d_img.upload(frame, stream);
	//            batchGpu.emplace_back(std::move(d_img));
	//        }
	//
	//        if (batchGpu.empty()) {
	//            return embeddings;
	//        }
	//
	//        // Prepare inputs for inference
	//        std::vector<std::vector<cv::cuda::GpuMat>> inputs;
	//        inputs.emplace_back(std::move(batchGpu));
	//
	//        // Run inference
	//        std::vector<std::vector<std::vector<float>>> featureVectors;
	//        bool succ = m_trtEngine->runInference(inputs, featureVectors);
	//        stream.waitForCompletion();
	//
	//        if (!succ) {
	//            _logger.LogError("ANSFaceRecognizer::RunArcFaceBatch",
	//                "runInference failed", __FILE__, __LINE__);
	//            return embeddings;
	//        }
	//
	//        if (featureVectors.empty()) {
	//            _logger.LogError("ANSFaceRecognizer::RunArcFaceBatch",
	//                "Empty featureVectors returned from inference", __FILE__, __LINE__);
	//            return embeddings;
	//        }
	//
	//
	//        size_t batchSize = featureVectors.size();
	//        embeddings.reserve(batchSize);
	//
	//        for (size_t i = 0; i < batchSize; ++i) {
	//            if (featureVectors[i].empty()) {
	//                continue;
	//            }
	//            // Get the first (and typically only) output for this face
	//            // featureVectors[i][0] is the embedding vector for face i
	//            const auto& embedding = featureVectors[i][0];
	//
	//            if (embedding.empty()) {
	//                continue;
	//            }
	//
	//            embeddings.push_back(embedding);
	//        }
	//
	//        // Verify we got the expected number of embeddings
	//        //if (embeddings.size() != inputs[0].size()) {
	//        //    _logger.LogWarn("ANSFaceRecognizer::RunArcFaceBatch",
	//        //        "Expected " + std::to_string(inputs[0].size()) +
	//        //        " embeddings but got " + std::to_string(embeddings.size()),
	//        //        __FILE__, __LINE__);
	//        //}
	//        return embeddings;
	//    }
	//    catch (const std::exception& e) {
	//        _logger.LogFatal("ANSFaceRecognizer::RunArcFaceBatch",
	//            e.what(), __FILE__, __LINE__);
	//        return embeddings;
	//    }
	//}

//	std::vector<std::vector<float>> ANSFaceRecognizer::Forward(const cv::Mat& input, std::vector<ANSCENTER::Object> outputBbox)
//	{
//		std::lock_guard<std::recursive_mutex> lock(_mutex);
//		std::vector<std::vector<float>> detectedEmbeddings;
//
//		if (input.empty()) {
//			_logger.LogError("ANSFaceRecognizer::Forward",
//				"Input image is empty", __FILE__, __LINE__);
//			return detectedEmbeddings;
//		}
//
//		try {
//			if (outputBbox.empty()) {
//				return detectedEmbeddings;
//			}
//
//			if (engineType == EngineType::NVIDIA_GPU) {
//				std::vector<cv::Mat> faceROIs;
//				faceROIs.reserve(outputBbox.size());
//
//				for (const auto& obj : outputBbox) {
//					const cv::Mat& faceROI = obj.mask;  // aligned mask
//					if (faceROI.empty()) continue;
//					faceROIs.push_back(faceROI);
//				}
//
//				if (!faceROIs.empty()) {
//					detectedEmbeddings = RunArcFaceBatch(faceROIs);
//				}
//			}
//			else {
//				detectedEmbeddings.clear();
//#ifdef USE_ONNX_ENGINE
//				for (const auto& obj : outputBbox) {
//					cv::Mat frame = obj.mask.clone();
//					if (frame.empty()) continue;
//
//					if (frame.cols != CPU_FACE_WIDTH || frame.rows != CPU_FACE_HEIGHT) {
//						cv::resize(frame, frame, cv::Size(CPU_FACE_WIDTH, CPU_FACE_HEIGHT));
//					}
//
//					types::FaceContent face_content;
//					faceRecognizer->detect(frame, face_content);
//					if (!face_content.embedding.empty()) {
//						detectedEmbeddings.push_back(face_content.embedding);
//					}
//				}
//#else
//				std::vector<cv::Mat> face_rois;
//				face_rois.reserve(outputBbox.size());
//
//				for (const auto& obj : outputBbox) {
//					cv::Mat frame = obj.mask;
//					if (frame.empty()) continue;
//
//					if (frame.cols != CPU_FACE_WIDTH || frame.rows != CPU_FACE_HEIGHT) {
//						cv::resize(frame, frame, cv::Size(CPU_FACE_WIDTH, CPU_FACE_HEIGHT));
//					}
//					face_rois.push_back(frame);
//				}
//
//				if (!face_rois.empty()) {
//					std::vector<cv::Mat> embeddings;
//					faceRecognizer->Compute(face_rois, &embeddings);
//
//					detectedEmbeddings.reserve(embeddings.size());
//					for (const auto& embMat : embeddings) {
//						if (embMat.empty()) continue;
//						std::vector<float> emb(embMat.begin<float>(), embMat.end<float>());
//						detectedEmbeddings.push_back(std::move(emb));
//					}
//				}
//#endif
//			}
//			return detectedEmbeddings;
//		}
//		catch (const std::exception& e) {
//			_logger.LogFatal("ANSFaceRecognizer::Forward", e.what(), __FILE__, __LINE__);
//			return detectedEmbeddings;
//		}
//	}

	//std::vector<float> ANSFaceRecognizer::NormalizeVector(const std::vector<float>& vec) {
	//    std::lock_guard<std::recursive_mutex> lock(_mutex);
	//    float norm = 0.0f;
	//    for (float v : vec) norm += v * v;
	//    norm = std::sqrt(norm);

	//    std::vector<float> normalizedVec(vec.size());
	//    if (norm > 0) {
	//        for (size_t i = 0; i < vec.size(); ++i) {
	//            normalizedVec[i] = vec[i] / norm;
	//        }
	//    }
	//    else {
	//        normalizedVec = vec;
	//    }
	//    return normalizedVec;
	//}

/*bool ANSFaceRecognizer::LoadEngine(const std::string xmlModelPath,
		bool engineOptimisation) {
		try {
			if (!FileExist(xmlModelPath)) {
				_logger.LogError("ANSFaceRecognizer::LoadEngine",
					"Cannot find the raw XML/ONNX model file.", __FILE__, __LINE__);
				return false;
			}
			if (engineType == EngineType::NVIDIA_GPU) {
				if (!m_trtEngine) {
					m_options.optBatchSize = 8;
					m_options.maxBatchSize = 32;
					m_options.calibrationBatchSize = 8;
					m_options.deviceIndex = _modelConfig.gpuDeviceIndex;
					m_options.engineFileDir = _modelFolder;
					m_options.precision = ANSCENTER::Precision::FP16;
					m_trtEngine = std::make_unique<Engine<float>>(m_options);
				}
				if (FileExist(xmlModelPath)) {
					bool succ = m_trtEngine->buildLoadNetwork(xmlModelPath, SUB_VALS, DIV_VALS, NORMALIZE);
					if (!succ) {
						_logger.LogError("ANSFaceRecognizer::LoadEngine. Unable to build/load TensorRT engine.",
							xmlModelPath, __FILE__, __LINE__);
						return false;
					}
				}
				else {
					_logger.LogError("ANSFaceRecognizer::LoadEngine. Model file does not exist",
						xmlModelPath, __FILE__, __LINE__);
					return false;
				}
				return true;
			}
			return true;
		}
		catch (const std::exception& e) {
			_logger.LogFatal("ANSFaceRecognizer::LoadEngine", e.what(), __FILE__, __LINE__);
			return false;
		}
	}*/
	//bool ANSFaceRecognizer::Destroy() {
	//	try {
	//		classNames.clear();
	//		if (faiss_index) {
	//			faiss_index->reset();
	//			faiss_index.reset();
	//		}
	//		faceRecognizer.reset();
	//		m_trtEngine.reset();
	//		return true;
	//	}
	//	catch (const std::exception& e) {
	//		_logger.LogFatal("ANSFaceRecognizer::Destroy", e.what(), __FILE__, __LINE__);
	//		return false;
	//	}
	//}



//	std::vector<std::vector<float>> ANSFaceRecognizer::Forward(const cv::Mat& input, std::vector<ANSCENTER::Object> outputBbox)
//	{
//		std::vector<std::vector<float>> detectedEmbeddings;
//
//		// Early validation before locking
//		if (input.empty()) {
//			_logger.LogError("ANSFaceRecognizer::Forward",
//				"Input image is empty", __FILE__, __LINE__);
//			return detectedEmbeddings;
//		}
//
//		if (outputBbox.empty()) {
//			return detectedEmbeddings;
//		}
//
//		std::lock_guard<std::recursive_mutex> lock(_mutex);
//
//		try {
//			// Pre-reserve output space
//			detectedEmbeddings.reserve(outputBbox.size());
//
//			if (engineType == EngineType::NVIDIA_GPU) {
//				// GPU path
//				std::vector<cv::Mat> faceROIs;
//				faceROIs.reserve(outputBbox.size());
//
//				for (const auto& obj : outputBbox) {
//					if (!obj.mask.empty()) {
//						faceROIs.push_back(obj.mask);
//					}
//				}
//
//				if (!faceROIs.empty()) {
//					detectedEmbeddings = RunArcFaceBatch(faceROIs);
//				}
//			}
//			else {
//				// CPU path
//#ifdef USE_ONNX_ENGINE
//				for (const auto& obj : outputBbox) {
//					if (obj.mask.empty()) continue;
//
//					cv::Mat frame;
//					if (obj.mask.cols != CPU_FACE_WIDTH || obj.mask.rows != CPU_FACE_HEIGHT) {
//						cv::resize(obj.mask, frame, cv::Size(CPU_FACE_WIDTH, CPU_FACE_HEIGHT));
//					}
//					else {
//						frame = obj.mask.clone();
//					}
//
//					types::FaceContent face_content;
//					faceRecognizer->detect(frame, face_content);
//
//					if (!face_content.embedding.empty()) {
//						detectedEmbeddings.push_back(std::move(face_content.embedding));
//					}
//				}
//#else
//				std::vector<cv::Mat> face_rois;
//				face_rois.reserve(outputBbox.size());
//
//				for (const auto& obj : outputBbox) {
//					if (obj.mask.empty()) continue;
//
//					cv::Mat frame;
//					if (obj.mask.cols != CPU_FACE_WIDTH || obj.mask.rows != CPU_FACE_HEIGHT) {
//						cv::resize(obj.mask, frame, cv::Size(CPU_FACE_WIDTH, CPU_FACE_HEIGHT));
//					}
//					else {
//						frame = obj.mask;
//					}
//
//					face_rois.push_back(frame);
//				}
//
//				if (!face_rois.empty()) {
//					std::vector<cv::Mat> embeddings;
//					embeddings.reserve(face_rois.size());
//
//					faceRecognizer->Compute(face_rois, &embeddings);
//
//					detectedEmbeddings.reserve(embeddings.size());
//					for (auto& embMat : embeddings) {
//						if (embMat.empty()) continue;
//
//						// Optimized conversion
//						if (embMat.isContinuous()) {
//							float* dataPtr = embMat.ptr<float>(0);
//							detectedEmbeddings.emplace_back(dataPtr, dataPtr + embMat.total());
//						}
//						else {
//							std::vector<float> emb(embMat.begin<float>(), embMat.end<float>());
//							detectedEmbeddings.push_back(std::move(emb));
//						}
//					}
//				}
//#endif
//			}
//
//			return detectedEmbeddings;
//		}
//		catch (const std::exception& e) {
//			_logger.LogFatal("ANSFaceRecognizer::Forward", e.what(), __FILE__, __LINE__);
//			return detectedEmbeddings;
//		}
//	}