An engine's model has always been a path to a password-protected zip: ANSODBase inflates it into a folder, and every engine then picks out train_last.onnx, classes.names and model_config.json. A .ansmodel package replaces all four with one sealed file, and this is the part that turns it back into what the engines already understand. ANSODBase::LoadModel and ::Initialize now recognise a .ansmodel path and take a second route: the package is opened with the process keyring, the model is decrypted into memory, and the classes, task and input geometry come out of the manifest instead of loose files. Nothing is extracted, so the unprotected model never touches the disk — which is the reason the format exists, and it is one function's job to keep. The engines follow it down. BasicOrtHandler gains a constructor that takes the bytes rather than a path; it keeps a view of them, not a copy, because the weights are in RAM either way once a session exists and a copy would only double what every loaded model costs. The owner of the plaintext is ANSODBase, which holds it for as long as the engine object lives — that is what lets the DirectML recovery path rebuild a session after a driver fault — and wipes it on teardown. Wired through ANSONNXYOLO (and so the classification facade), ANSONNXOBB, ANSONNXPOSE, ANSONNXSEG and YOLO12OD. YOLOOD is left alone: it loads darknet weights and OpenCV DNN graphs, neither of which the writer produces. A zip still loads exactly as before, on every engine. Keys come from SetProcessModelKeys, as in ANSMINDCORE, with the same development fallback from the environment. With none set, a package is refused with a sentence saying so and every zip still works, so a build made before the key ceremony runs everything except packages. The engine layer needs CUDA to compile, so the contract it depends on is checked where it can be: ANSModelPackage-UnitTest now opens the fixture ANSMINDCORE wrote through the same glue ANSODBase uses, and covers the refusal a keyless build gives. 32 checks, no failures. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
1378 lines
68 KiB
C++
1378 lines
68 KiB
C++
#ifndef ANSENGINECOMMON_H
|
|
#define ANSENGINECOMMON_H
|
|
#define ANSENGINE_API __declspec(dllexport)
|
|
#pragma once
|
|
#include <opencv2/opencv.hpp>
|
|
#include <opencv2/core/cuda.hpp>
|
|
#include <openvino/openvino.hpp>
|
|
#include "ANSLicense.h"
|
|
#include "Utility.h"
|
|
#include <algorithm>
|
|
#include <fstream>
|
|
#include <exception>
|
|
#include <random>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <vector>
|
|
#include <string>
|
|
#include <map>
|
|
#include <atomic>
|
|
#include <chrono>
|
|
#include "ANSMOT.h"
|
|
#include "onnxruntime_cxx_api.h"
|
|
#include "ANSModelSource.h"
|
|
|
|
#define USEONNXOV
|
|
#define RETAINDETECTEDFRAMES 80
|
|
#define DEBUG_PRINT(x) std::cout << x << std::endl;
|
|
//#define DEBUGENGINE
|
|
//#define USE_TV_MODEL // Use model to detect if person is on TV screen or not
|
|
|
|
const int MAX_HISTORY_FACE = 5;
|
|
const int MAX_MISSING_FACE = 30;
|
|
const int MAX_TRACKS = 200;
|
|
const float PAD_TRACK_RATIO = 0.5f;
|
|
const float PAD_DETECT_RATIO = 1.0f;
|
|
const int MAX_MISSING_SCREEN = 1000;
|
|
|
|
namespace ANSCENTER
|
|
{
|
|
// ────────────────────────────────────────────────────────────────────────
|
|
// DirectML fatal-error detection
|
|
//
|
|
// AMD's DirectML EP can fail in several distinct ways that all leave the
|
|
// Ort::Session permanently broken and require a fresh CPU-fallback session:
|
|
//
|
|
// 887A0005 DXGI_ERROR_DEVICE_REMOVED — adapter killed (RDP attach,
|
|
// TDR, sleep/wake, driver swap). GetDeviceRemovedReason gives
|
|
// the sub-cause but the device is gone either way.
|
|
// 80004005 E_FAIL — generic D3D12 / DML failure. Seen from
|
|
// DmlGraphFusionHelper::ExecuteOperator and
|
|
// DmlCommandRecorder::ExecuteCommandList on AMD when the
|
|
// driver couldn't compile/execute a fused subgraph or when
|
|
// TDR fires mid-command-list. No structured sub-cause
|
|
// available — must treat as device-fatal.
|
|
//
|
|
// Branding strings ("DmlFusedNode", "DmlGraphFusionHelper",
|
|
// "DmlCommandRecorder") catch future failure modes that surface the same
|
|
// way without us having to chase each new HRESULT.
|
|
//
|
|
// Used by every catch site that wraps Ort::Session::Run on AMD DML.
|
|
// Centralised here so a new failure mode is handled once, not 4+ times.
|
|
// ────────────────────────────────────────────────────────────────────────
|
|
inline bool IsDmlFatalError(const std::string& msg) {
|
|
return msg.find("887A0005") != std::string::npos
|
|
|| msg.find("80004005") != std::string::npos
|
|
|| msg.find("DmlFusedNode") != std::string::npos
|
|
|| msg.find("DmlGraphFusionHelper") != std::string::npos
|
|
|| msg.find("DmlCommandRecorder") != std::string::npos
|
|
|| msg.find("DmlExecutionProvider") != std::string::npos;
|
|
}
|
|
|
|
// ────────────────────────────────────────────────────────────────────────
|
|
// IsDmlDeviceRemoved — narrowly checks ONLY 887A0005
|
|
// (DXGI_ERROR_DEVICE_REMOVED). This is the truly unrecoverable case:
|
|
// the D3D12 adapter is gone (driver crashed, RDP attach killed the
|
|
// device, sleep/wake torched the WDDM context). No amount of session
|
|
// recreation will bring it back — only a process restart or CPU
|
|
// fallback can recover.
|
|
//
|
|
// In contrast, 80004005 (E_FAIL) from DmlGraphFusionHelper /
|
|
// DmlCommandRecorder is intermittent on AMD when the driver chokes on
|
|
// a fused subgraph or TDR fires mid-command-list. A fresh DML
|
|
// session typically clears it and resumes GPU inference — that's the
|
|
// stay-on-GPU recovery path used by ANSONNXYOLO's catch blocks.
|
|
// ────────────────────────────────────────────────────────────────────────
|
|
inline bool IsDmlDeviceRemoved(const std::string& msg) {
|
|
return msg.find("887A0005") != std::string::npos
|
|
|| msg.find("DXGI_ERROR_DEVICE_REMOVED") != std::string::npos;
|
|
}
|
|
|
|
template <typename T>
|
|
typename std::enable_if<std::is_arithmetic<T>::value, T>::type
|
|
inline clamp(const T& value, const T& low, const T& high)
|
|
{
|
|
T validLow = low < high ? low : high;
|
|
T validHigh = low < high ? high : low;
|
|
|
|
if (value < validLow) return validLow;
|
|
if (value > validHigh) return validHigh;
|
|
return value;
|
|
}
|
|
struct Point {
|
|
int x, y;
|
|
};
|
|
struct ROIConfig {
|
|
bool Rectangle;
|
|
bool Polygon;
|
|
bool Line;
|
|
int MinItems;
|
|
int MaxItems;
|
|
std::string Name;
|
|
std::string ROIMatch;
|
|
};
|
|
|
|
struct Parameter {
|
|
std::string Name;
|
|
std::string DataType;
|
|
int NoOfDecimals;
|
|
int MaxValue;
|
|
int MinValue;
|
|
std::string StartValue;
|
|
std::vector<std::string> ListItems;
|
|
std::string DefaultValue;
|
|
std::string Value;
|
|
};
|
|
|
|
struct ROIValue {
|
|
std::string ROIMatch;
|
|
std::vector<Point> ROIPoints;
|
|
std::string Option;
|
|
std::string Name;
|
|
int OriginalImageSize;
|
|
};
|
|
struct Params {
|
|
std::vector<ROIConfig> ROI_Config;
|
|
std::vector<std::string> ROI_Options;
|
|
std::vector<Parameter> Parameters;
|
|
std::vector<ROIValue> ROI_Values;
|
|
};
|
|
|
|
|
|
/* Example
|
|
{
|
|
"ROI_Config":[
|
|
{
|
|
"Rectangle":true,
|
|
"Polygon":true,
|
|
"Line":false,
|
|
"MinItems":0,
|
|
"MaxItems":3,
|
|
"Name":"Traffic Light",
|
|
"ROI-Match":"All Corners"
|
|
},
|
|
{
|
|
"Rectangle":true,
|
|
"Polygon":false,
|
|
"Line":false,
|
|
"MinItems":1,
|
|
"MaxItems":1,
|
|
"Name":"Car Zone",
|
|
"ROI-Match":"All Corners"
|
|
},
|
|
{
|
|
"Rectangle":false,
|
|
"Polygon":false,
|
|
"Line":true,
|
|
"MinItems":1,
|
|
"MaxItems":2,
|
|
"Name":"Cross Line",
|
|
"ROI-Match":"All Corners"
|
|
}
|
|
],
|
|
"ROI_Options":[
|
|
"Inside ROI",
|
|
"Inside ROI",
|
|
"Both Directions"
|
|
],
|
|
"Parameters":[
|
|
{
|
|
"Name":"Para1",
|
|
"DataType":"Boolean",
|
|
"NoOfdecimals":0,
|
|
"MaxValue":0,
|
|
"MinValue":0,
|
|
"StartValue":"",
|
|
"ListItems":[],
|
|
"DefaultValue":"",
|
|
"Value":"true"
|
|
},
|
|
{
|
|
"Name":"Para2",
|
|
"DataType":"Integer",
|
|
"NoOfdecimals":0,
|
|
"MaxValue":5,
|
|
"MinValue":1,
|
|
"StartValue":"2",
|
|
"ListItems":[],
|
|
"DefaultValue":"",
|
|
"Value":"3"
|
|
},
|
|
{
|
|
"Name":"Para3",
|
|
"DataType":"List-Single",
|
|
"NoOfdecimals":0,
|
|
"MaxValue":0,
|
|
"MinValue":0,
|
|
"StartValue":"",
|
|
"ListItems":["A","B","C"],
|
|
"DefaultValue":"",
|
|
"Value":"A"
|
|
},
|
|
{
|
|
"Name":"Para4",
|
|
"DataType":"Range",
|
|
"NoOfdecimals":0,
|
|
"MaxValue":100,
|
|
"MinValue":50,
|
|
"StartValue":">,60",
|
|
"ListItems":[">","<"],
|
|
"DefaultValue":"",
|
|
"Value":">,52.000000"
|
|
}
|
|
],
|
|
"ROI_Values":[
|
|
{
|
|
"ROI-Match":"Centre Point",
|
|
"ROIPoints":[
|
|
{"x":269,"y":134},
|
|
{"x":777,"y":134},
|
|
{"x":777,"y":457},
|
|
{"x":269,"y":457}
|
|
],
|
|
"Option":"Inside ROI",
|
|
"Name":"Car Zone 1",
|
|
"OriginalImageSize":1920
|
|
},
|
|
{
|
|
"ROI-Match":"Centre Point",
|
|
"ROIPoints":[{"x":280,"y":613},{"x":1108,"y":280}],
|
|
"Option":"Above",
|
|
"Name":"Cross Line 1",
|
|
"OriginalImageSize":1920
|
|
},
|
|
{
|
|
"ROI-Match":"Centre Point",
|
|
"ROIPoints":[{"x":1511,"y":383},{"x":1283,"y":754}],
|
|
"Option":"Left side",
|
|
"Name":"Cross Line 2",
|
|
"OriginalImageSize":1920
|
|
},
|
|
{
|
|
"ROI-Match":"Centre Point",
|
|
"ROIPoints":[
|
|
{"x":229,"y":161},
|
|
{"x":964,"y":161},
|
|
{"x":964,"y":628},
|
|
{"x":229,"y":628}
|
|
],
|
|
"Option":"Left side",
|
|
"Name":"Traffic Light 1",
|
|
"OriginalImageSize":1920
|
|
},
|
|
{
|
|
"ROI-Match":"Centre Point",
|
|
"ROIPoints":[
|
|
{"x":1115,"y":304},
|
|
{"x":1730,"y":304},
|
|
{"x":1730,"y":695},
|
|
{"x":1115,"y":695}
|
|
],
|
|
"Option":"Left side",
|
|
"Name":"Traffic Light 2",
|
|
"OriginalImageSize":1920
|
|
},
|
|
{
|
|
"ROI-Match":"Centre Point",
|
|
"ROIPoints":[
|
|
{"x":678,"y":683},
|
|
{"x":1217,"y":683},
|
|
{"x":1217,"y":1026},
|
|
{"x":678,"y":1026}
|
|
],
|
|
"Option":"Left side",
|
|
"Name":"Traffic Light 3",
|
|
"OriginalImageSize":1920
|
|
}
|
|
]
|
|
}
|
|
*/
|
|
struct MetaData
|
|
{
|
|
float imageThreshold;
|
|
float pixelThreshold;
|
|
float min;
|
|
float max;
|
|
int inferSize[2]; // h w
|
|
int imageSize[2]; // h w
|
|
std::vector<float> _mean;
|
|
std::vector<float> _std;
|
|
};
|
|
struct Resize
|
|
{
|
|
cv::Mat resizedImage;
|
|
int dw;
|
|
int dh;
|
|
};
|
|
struct Object
|
|
{
|
|
int classId{ 0 };
|
|
int trackId{ 0 };
|
|
std::string className{};
|
|
float confidence{ 0.0 };
|
|
cv::Rect box{};
|
|
std::vector<cv::Point2f> polygon; // polygon that contain x1,y1,x2,y2,x3,y3,x4,y4 (for both segmentation and pose estimation)
|
|
cv::Mat mask{}; // image in box (cropped)
|
|
cv::cuda::GpuMat gpuMask{}; // GPU-resident face crop (set by NV12 affine warp, avoids re-upload)
|
|
std::vector<float> kps{}; // Pose exsimate keypoints, containing x1,y1,x2,y2,... or oriented box x,y,width,height,angle
|
|
std::string extraInfo; // More information such as facial recognition
|
|
std::string cameraId; // Use to check if this object belongs to any camera
|
|
// std::string attributes;
|
|
};
|
|
struct FaceResultObject {
|
|
int trackId{ 0 };
|
|
std::string userId;
|
|
std::string userName;
|
|
float similarity;
|
|
bool isUnknown;
|
|
bool isMasked; // If the face is masked
|
|
cv::Rect box{}; // Face bounding box
|
|
cv::Mat mask;
|
|
std::vector<cv::Point2f> polygon; // polygon that contain x1 ,y1,x2,y2,x3,y3,x4,y4
|
|
std::vector<float> kps{}; // Containing landmarks
|
|
float confidence{ 0.0 };
|
|
std::string extraInformation;
|
|
std::string cameraId;
|
|
// std::string attributes; // Face attributes (in Json format)
|
|
};
|
|
struct BoundingBox {
|
|
int x;
|
|
int y;
|
|
int width;
|
|
int height;
|
|
BoundingBox() : x(0), y(0), width(0), height(0) {}
|
|
BoundingBox(int x_, int y_, int width_, int height_)
|
|
: x(x_), y(y_), width(width_), height(height_) {}
|
|
};
|
|
struct KeyPoint {
|
|
float x; ///< X-coordinate of the keypoint
|
|
float y; ///< Y-coordinate of the keypoint
|
|
float confidence; ///< Confidence score of the keypoint
|
|
KeyPoint(float x_ = 0, float y_ = 0, float conf_ = 0)
|
|
: x(x_), y(y_), confidence(conf_) {
|
|
}
|
|
};
|
|
// A group holds a set of objects and the union (bounding box) of all their boxes.
|
|
struct Group {
|
|
std::vector<Object> objects;
|
|
cv::Rect unionBox;
|
|
};
|
|
typedef std::pair<cv::Scalar, cv::Scalar> Range;
|
|
|
|
class ANSENGINE_API ANNHUBClassifier
|
|
{
|
|
private:
|
|
std::vector<double> nInput; //ANN inputs
|
|
std::vector<double> nOutput; //ANN outputs
|
|
std::vector<std::vector<double>> IW;
|
|
std::vector<std::vector<double>> LW;
|
|
std::vector<double> Ib;
|
|
std::vector<double> Lb;
|
|
// Structural parameters
|
|
int nInputNodes, nHiddenNodes, nOutputNodes;
|
|
int hiddenActivation; // default =2
|
|
int outputActivation; // default =2
|
|
int dataNormalisationModeInput; // default =1;
|
|
int dataNormalisationModeOutput; // default =1;
|
|
|
|
// Preprocessing and postprocessing settings
|
|
std::vector<double> xmaxInput, xminInput; // Maximum and minimum of inputs
|
|
double ymaxInput, yminInput; // Maximum and minimum of inputs
|
|
std::vector<double> xmaxOutput, xminOutput; // Maximum and minimum of outputs
|
|
double ymaxOutput, yminOutput; // Maximum and minimum of outputs
|
|
|
|
// Control creation
|
|
unsigned char isCreated;
|
|
std::string _licenseKey;
|
|
bool _licenseValid{ false };
|
|
bool _isInitialized{ false };
|
|
std::string _modelFilePath;
|
|
|
|
private:
|
|
|
|
void PreProcessing(std::vector<double>& Input); // mode =0--> linear, mode =1 mapminmax, mode =2 standarddev
|
|
void PostProcessing(std::vector<double>& Output); // mode =0--> linear, mode =1 mapminmax, mode =2 standarddev
|
|
void Create(int inputNodes, int HiddenNodes, int outputNodes);
|
|
void FreeNeuralNetwork();
|
|
void CheckLicense();
|
|
int ImportANNFromFile(std::string filename);
|
|
|
|
public:
|
|
ANNHUBClassifier();
|
|
~ANNHUBClassifier();
|
|
bool Init(std::string licenseKey, std::string modelFilePath);
|
|
std::vector<double> Inference(std::vector<double> ip);
|
|
void Destroy();
|
|
int GetOutputNode() { return nOutputNodes; };
|
|
private:
|
|
void ReLu(std::vector<double>& iVal, std::vector<double>& oVal);
|
|
void LogSig(std::vector<double>& iVal, std::vector<double>& oVal);
|
|
void TanSig(std::vector<double>& iVal, std::vector<double>& oVal);
|
|
void PureLin(std::vector<double>& iVal, std::vector<double>& oVal);
|
|
void SoftMax(std::vector<double>& iVal, std::vector<double>& oVal);
|
|
void ActivationFunction(std::vector<double>& iVal, std::vector<double>& oVal, int mode);
|
|
};
|
|
class ANSENGINE_API MoveDetectsHandler
|
|
{
|
|
public:
|
|
// Constructor and Destructor
|
|
MoveDetectsHandler();
|
|
~MoveDetectsHandler();
|
|
|
|
// Main detection methods
|
|
std::vector<Object> MovementDetect(const std::string& camera_id, cv::Mat& next_image);
|
|
std::vector<Object> MovementDetect(const std::string& camera_id, const size_t frame_index, cv::Mat& image);
|
|
|
|
// Camera management
|
|
bool hasCameraData(const std::string& camera_id) const;
|
|
void removeCamera(const std::string& camera_id);
|
|
std::vector<std::string> getCameraIds() const;
|
|
|
|
// Configuration methods
|
|
void setThreshold(const std::string& camera_id, double threshold);
|
|
void setKeyFrameFrequency(const std::string& camera_id, size_t frequency);
|
|
void setNumberOfControlFrames(const std::string& camera_id, size_t count);
|
|
void setThumbnailRatio(const std::string& camera_id, double ratio);
|
|
void setMaskEnabled(const std::string& camera_id, bool enabled);
|
|
void setContoursEnabled(const std::string& camera_id, bool enabled);
|
|
void setBboxEnabled(const std::string& camera_id, bool enabled);
|
|
void setContourThickness(const std::string& camera_id, int thickness);
|
|
void setBboxThickness(const std::string& camera_id, int thickness);
|
|
void setMinObjectArea(const std::string& camera_id, double area);
|
|
void setMinObjectSize(const std::string& camera_id, int size);
|
|
void setMorphologyIterations(const std::string& camera_id, int iterations);
|
|
|
|
// Temporal consistency settings
|
|
void setTemporalConsistency(const std::string& camera_id, bool enabled);
|
|
void setMaskOverlapThreshold(const std::string& camera_id, double threshold);
|
|
void setTemporalHistorySize(const std::string& camera_id, size_t size);
|
|
void setMinConsistentFrames(const std::string& camera_id, size_t frames);
|
|
void setLocationStabilityEnabled(const std::string& camera_id, bool enabled);
|
|
void setMaxLocationJitter(const std::string& camera_id, double pixels);
|
|
|
|
// Getters for configuration
|
|
double getThreshold(const std::string& camera_id) const;
|
|
size_t getKeyFrameFrequency(const std::string& camera_id) const;
|
|
size_t getNumberOfControlFrames(const std::string& camera_id) const;
|
|
double getThumbnailRatio(const std::string& camera_id) const;
|
|
bool isMaskEnabled(const std::string& camera_id) const;
|
|
bool isContoursEnabled(const std::string& camera_id) const;
|
|
bool isBboxEnabled(const std::string& camera_id) const;
|
|
bool isTemporalConsistencyEnabled(const std::string& camera_id) const;
|
|
|
|
// State query methods
|
|
bool isMovementDetected(const std::string& camera_id) const;
|
|
bool wasTransitionDetected(const std::string& camera_id) const;
|
|
double getPSNRScore(const std::string& camera_id) const;
|
|
size_t getFrameIndexWithMovement(const std::string& camera_id) const;
|
|
std::chrono::milliseconds getTimeSinceLastMovement(const std::string& camera_id) const;
|
|
size_t getControlFrameCount(const std::string& camera_id) const;
|
|
size_t getNextFrameIndex(const std::string& camera_id) const;
|
|
double getTemporalConsistencyScore(const std::string& camera_id) const;
|
|
|
|
// Public utility methods
|
|
bool empty(const std::string& camera_id) const;
|
|
void clear(const std::string& camera_id);
|
|
void clearAll();
|
|
cv::Mat getOutput(const std::string& camera_id) const;
|
|
cv::Mat getMask(const std::string& camera_id) const;
|
|
std::vector<std::vector<cv::Point>> getContours(const std::string& camera_id) const;
|
|
|
|
// Statistics
|
|
struct CameraStats {
|
|
size_t total_frames_processed = 0;
|
|
size_t frames_with_movement = 0;
|
|
size_t frames_rejected_by_temporal_check = 0;
|
|
size_t control_frames_count = 0;
|
|
double average_psnr = 0.0;
|
|
double min_psnr = std::numeric_limits<double>::max();
|
|
double max_psnr = 0.0;
|
|
double average_temporal_consistency = 0.0;
|
|
std::chrono::milliseconds total_processing_time{ 0 };
|
|
std::chrono::high_resolution_clock::time_point last_movement_time;
|
|
|
|
// Reset stats
|
|
void reset()
|
|
{
|
|
total_frames_processed = 0;
|
|
frames_with_movement = 0;
|
|
frames_rejected_by_temporal_check = 0;
|
|
control_frames_count = 0;
|
|
average_psnr = 0.0;
|
|
min_psnr = std::numeric_limits<double>::max();
|
|
max_psnr = 0.0;
|
|
average_temporal_consistency = 0.0;
|
|
total_processing_time = std::chrono::milliseconds{ 0 };
|
|
}
|
|
};
|
|
|
|
CameraStats getStats(const std::string& camera_id) const;
|
|
void resetStats(const std::string& camera_id);
|
|
|
|
private:
|
|
struct CameraData
|
|
{
|
|
// Detection state
|
|
bool movement_detected = false;
|
|
bool transition_detected = false;
|
|
size_t next_frame_index = 0;
|
|
size_t next_key_frame = 0;
|
|
double most_recent_psnr_score = 0.0;
|
|
size_t frame_index_with_movement = 0;
|
|
double max_change_percentage = 20.0; // Max % of frame that can change
|
|
double min_change_percentage = 1.0; // Min % of frame that must change
|
|
|
|
std::chrono::high_resolution_clock::time_point movement_last_detected;
|
|
|
|
// Control frames storage
|
|
std::map<size_t, cv::Mat> control_frames;
|
|
|
|
// Output data
|
|
cv::Mat output;
|
|
cv::Mat mask;
|
|
std::vector<std::vector<cv::Point>> contours;
|
|
|
|
// Configuration parameters
|
|
size_t key_frame_frequency = 20;
|
|
size_t number_of_control_frames = 10;
|
|
double psnr_threshold = 45.0;
|
|
double thumbnail_ratio = 0.05;
|
|
cv::Size thumbnail_size = cv::Size(0, 0);
|
|
|
|
// Visual options
|
|
bool mask_enabled = true;
|
|
bool contours_enabled = true;
|
|
bool bbox_enabled = true;
|
|
cv::LineTypes line_type = cv::LINE_4;
|
|
int contours_size = 1;
|
|
int bbox_size = 1;
|
|
|
|
// Filtering parameters
|
|
double min_object_area = 1000.0;
|
|
int min_object_dimension = 5;
|
|
int min_object_total_size = 25;
|
|
|
|
// Morphology parameters
|
|
int morphology_iterations = 10;
|
|
|
|
// Temporal consistency parameters
|
|
bool temporal_consistency_enabled = true;
|
|
double mask_overlap_threshold = 0.05; // 5% overlap with previous required
|
|
size_t temporal_history_size = 5; // Keep last N masks
|
|
size_t min_consistent_frames = 3; // Need N consecutive consistent frames
|
|
bool location_stability_enabled = true;
|
|
double max_location_jitter = 50.0; // Max pixel movement between frames
|
|
|
|
// Temporal consistency state
|
|
std::deque<cv::Mat> mask_history;
|
|
std::deque<cv::Point> centroid_history;
|
|
size_t consistent_frame_count = 0;
|
|
double last_temporal_consistency_score = 0.0;
|
|
|
|
// Statistics
|
|
CameraStats stats;
|
|
|
|
// Clear function to release memory
|
|
void clear()
|
|
{
|
|
for (auto& [index, frame] : control_frames)
|
|
{
|
|
frame.release();
|
|
}
|
|
control_frames.clear();
|
|
output.release();
|
|
mask.release();
|
|
contours.clear();
|
|
|
|
// Clear temporal history
|
|
for (auto& m : mask_history)
|
|
{
|
|
m.release();
|
|
}
|
|
mask_history.clear();
|
|
centroid_history.clear();
|
|
|
|
// Reset state
|
|
movement_detected = false;
|
|
transition_detected = false;
|
|
most_recent_psnr_score = 0.0;
|
|
frame_index_with_movement = 0;
|
|
thumbnail_size = cv::Size(0, 0);
|
|
consistent_frame_count = 0;
|
|
last_temporal_consistency_score = 0.0;
|
|
}
|
|
};
|
|
|
|
// Private member functions
|
|
double psnr(const cv::Mat& src, const cv::Mat& dst);
|
|
cv::Mat simple_colour_balance(const cv::Mat& src);
|
|
cv::Rect BoundingBoxFromContour(const std::vector<cv::Point>& contour);
|
|
|
|
// Multi-camera data storage
|
|
std::unordered_map<std::string, CameraData> cameras;
|
|
mutable std::recursive_mutex cameras_mutex;
|
|
|
|
// Helper functions
|
|
CameraData& getCameraData(const std::string& camera_id);
|
|
const CameraData* getCameraDataConst(const std::string& camera_id) const;
|
|
bool cameraExists(const std::string& camera_id) const;
|
|
|
|
// Processing helpers
|
|
cv::Mat computeMovementMask(const cv::Mat& control_frame, const cv::Mat& current_frame,
|
|
const cv::Size& output_size, int morphology_iterations);
|
|
std::vector<Object> extractObjectsFromMask(const cv::Mat& mask, const cv::Mat& image,
|
|
CameraData& camera, const std::string& camera_id);
|
|
void updateControlFrames(CameraData& camera, size_t frame_index, const cv::Mat& thumbnail);
|
|
void updateStatistics(CameraData& camera, double psnr, bool movement_detected,
|
|
std::chrono::milliseconds processing_time);
|
|
|
|
// Temporal consistency helpers
|
|
bool checkTemporalConsistency(CameraData& camera, const cv::Mat& current_mask);
|
|
double calculateMaskOverlap(const cv::Mat& mask1, const cv::Mat& mask2);
|
|
cv::Point calculateMaskCentroid(const cv::Mat& mask);
|
|
double calculateLocationStability(const std::deque<cv::Point>& centroids);
|
|
void updateTemporalHistory(CameraData& camera, const cv::Mat& mask);
|
|
|
|
std::vector<Object> MovementDetectInternal(const std::string& camera_id,
|
|
const size_t frame_index,
|
|
cv::Mat& image,
|
|
CameraData& camera);
|
|
};
|
|
class ANSENGINE_API ANSUtilityHelper {
|
|
public:
|
|
static std::vector<std::string> Split(const std::string& s, char delimiter);
|
|
static std::vector<cv::Point> StringToPolygon(const std::string& input);
|
|
static cv::Mat CropPolygon(const cv::Mat& image, const std::vector<cv::Point>& polygon);
|
|
static cv::Mat CropFromStringPolygon(const cv::Mat& image, const std::string& strPolygon);
|
|
static std::vector<cv::Rect> GetBoundingBoxesFromString(std::string strBBoxes);
|
|
static std::vector<ANSCENTER::Object> GetDetectionsFromString(const std::string& strDets);
|
|
static std::vector<float> StringToKeypoints(const std::string& str);
|
|
static std::vector<cv::Point2f> PolygonFromString(const std::string& str);
|
|
static ANSCENTER::Params ParseCustomParameters(const std::string& paramsJson);
|
|
static std::string SerializeCustomParamters(const ANSCENTER::Params& params);
|
|
|
|
static bool ParseActiveROIMode(const std::string activeROIMode,int & mode,double & detectionScore, std::vector<int> & trackingObjectIds);
|
|
static cv::Rect GetBoundingBoxFromPolygon(const std::vector<cv::Point>& polygon);
|
|
static std::string VectorDetectionToJsonString(const std::vector<Object>& dets);
|
|
static cv::Mat ReadImagePath(const std::string& imagePath);
|
|
static cv::Mat ReadImageStreamBase64(const std::string& imageStreamBase64);
|
|
static cv::Mat FormatToSquare(const cv::Mat& source);
|
|
static unsigned char* CVMatToBytes(cv::Mat image, unsigned int& bufferLengh);
|
|
static std::vector<std::string> GetConfigFileContent(std::string modelConfigFile, ModelType& modelType, std::vector<int>& inputShape);
|
|
static MetaData GetJson(const std::string& jsonPath);
|
|
static std::vector<unsigned char> DecodeBase64(const std::string& base64);
|
|
static cv::Mat Resize(const cv::Mat& src, int dst_height, int dst_width, const std::string& interpolation);
|
|
static cv::Mat Crop(const cv::Mat& src, int top, int left, int bottom, int right);
|
|
static cv::Mat Divide(const cv::Mat& src, float divide = 255.0);
|
|
static cv::Mat Normalize(cv::Mat& src, const std::vector<float>& mean, const std::vector<float>& std, bool to_rgb = false, bool inplace = true);
|
|
static cv::Mat Transpose(const cv::Mat& src);
|
|
static cv::Mat Pad(const cv::Mat& src, int top, int left, int bottom, int right, int border_type, float val);
|
|
static cv::Mat JpegStringToMat(const std::string& jpegString);
|
|
static cv::Mat MeanAxis0(const cv::Mat& src);
|
|
static cv::Mat ElementwiseMinus(const cv::Mat& A, const cv::Mat& B);
|
|
static cv::Mat VarAxis0(const cv::Mat& src);
|
|
static int MatrixRank(cv::Mat M);
|
|
static cv::Mat SimilarTransform(cv::Mat& dst, cv::Mat& src);
|
|
static std::vector<cv::Mat> AlignFaceWithFivePoints(const cv::Mat& image,
|
|
const std::vector<std::array<int, 4>> boxes,
|
|
std::vector<std::array<float, 2>> landmarks);
|
|
static std::vector<cv::Mat>GetCroppedFaces(const cv::Mat& image, const std::vector<std::array<int, 4>> boxes);
|
|
static cv::Mat GetCroppedFace(const cv::Mat& image, const int x1, const int y1, const int x2, const int y2);
|
|
static cv::Mat GetCroppedFaceScale(const cv::Mat& image, const int x1, const int y1, const int x2, const int y2, int cropedImageSize);
|
|
|
|
// For openVINO face alignment
|
|
static cv::Mat GetTransform(cv::Mat* src, cv::Mat* dst);
|
|
static void AlignFaces(std::vector<cv::Mat>* face_images, std::vector<cv::Mat>* landmarks_vec);
|
|
static void AlignFacesExt(std::vector<cv::Mat>* face_images, std::vector<cv::Mat>* landmarks_vec);
|
|
static std::pair<cv::Mat, cv::Mat> AlignFacesSCRFD(const cv::Mat& input_mat, const std::vector<cv::Point2f>& face_landmark_5);
|
|
|
|
// Model optimsation (for TensorRT)
|
|
static bool ModelOptimizer(std::string modelZipFilePath, std::string modelFileZipPassword, int fp16, std::string& optimisedModelFolder, int inputImageHeight=640, int inputImageWidth=640);
|
|
|
|
// For tiled inference
|
|
static std::vector<Object> ApplyNMS(const std::vector<Object>& detections, float nmsThreshold = 0.4);
|
|
static void AdjustBoudingBox(Object& obj, int offsetX, int offsetY);
|
|
static std::vector<cv::Rect> GetPatches(cv::Mat& image, int tileWidth, int tileHeight, double overlap);
|
|
static std::vector<cv::Mat> ExtractPatches(cv::Mat& image, std::vector<cv::Rect>& patchRegions);
|
|
static cv::Mat ResizePatch(cv::Mat& patch, int modelWidth, int modelHeight);
|
|
static std::map<int, std::vector<int>> Greedy_NMM(const std::vector<Object>& object_predictions, const std::string& match_metric = "IOU", float match_threshold = 0.5);
|
|
static float calculate_intersection_area(const cv::Rect& box1, const cv::Rect& box2);
|
|
static float calculate_bbox_iou(const Object& pred1, const Object& pred2);
|
|
static float calculate_bbox_ios(const Object& pred1, const Object& pred2);
|
|
static bool has_match(const Object& pred1, const Object& pred2, const std::string& match_type = "IOU", float match_threshold = 0.5);
|
|
static float get_merged_score(const Object& pred1, const Object& pred2);
|
|
static cv::Rect calculate_box_union(const cv::Rect& box1, const cv::Rect& box2);
|
|
static cv::Rect get_merged_bbox(const Object& pred1, const Object& pred2);
|
|
static int get_merged_class_id(const Object& pred1, const Object& pred2) {
|
|
return (pred1.confidence > pred2.confidence) ? pred1.classId : pred2.classId;
|
|
}
|
|
static std::string get_merged_category(const Object& pred1, const Object& pred2) {
|
|
return (pred1.confidence > pred2.confidence) ? pred1.className : pred2.className;
|
|
}
|
|
static Object merge_object_pair(const Object& obj1, const Object& obj2);
|
|
static std::vector<Object> select_object_predictions(const std::vector<Object>& object_prediction_list,const std::map<int, std::vector<int>>& keep_to_merge_list,const std::string& match_metric,float match_threshold);
|
|
static cv::Rect BoundingBoxFromContour(std::vector<cv::Point> contour);
|
|
static std::string PolygonToString(const std::vector<cv::Point2f>& polygon);
|
|
static std::string KeypointsToString(const std::vector<float>& kps);
|
|
static std::vector<cv::Point2f> RectToNormalizedPolygon(const cv::Rect& rect, float imageWidth, float imageHeight);
|
|
|
|
// Convert a UTF-8 encoded string to UTF-16LE byte string.
|
|
// Useful for LabVIEW which can display UTF-16LE Unicode text on Windows.
|
|
// Returns a std::string containing the raw UTF-16LE bytes (2 bytes per character).
|
|
static std::string ConvertUTF8ToUTF16LE(const std::string& utf8Str);
|
|
|
|
// Decode JSON Unicode escape sequences (\uXXXX) to UTF-16LE byte string.
|
|
// Input: ASCII string with \uXXXX escapes (e.g., "\\u6c5f\\u6771 599")
|
|
// Output: UTF-16LE byte string for LabVIEW display.
|
|
// ASCII characters pass through as 2-byte UTF-16LE (e.g., 'A' -> 0x41 0x00).
|
|
static std::string DecodeJsonUnicodeToUTF16LE(const std::string& escapedStr);
|
|
static std::vector<cv::Point2f> MaskToNormalizedPolygon(const cv::Mat& binaryMask, const cv::Rect& boundingBox, float imageWidth, float imageHeight, float simplificationEpsilon = 2.0f, int minContourArea = 10, int maxPoints = 50);
|
|
|
|
};
|
|
|
|
class ANSENGINE_API ANSFRBase {
|
|
protected:
|
|
bool _licenseValid{ false };
|
|
bool _isInitialized{ false };
|
|
std::string _licenseKey;
|
|
std::string _modelFolder;
|
|
std::string _modelConfigFile;
|
|
SPDLogger& _logger = SPDLogger::GetInstance("ANSFR", false);
|
|
void CheckLicense();
|
|
|
|
public:
|
|
virtual bool Initialize(std::string licenseKey, ModelConfig modelConfig, const std::string& modelZipFilePath, const std::string& modelZipPassword, std::string& labelMap);
|
|
virtual bool LoadModel(const std::string& modelZipFilePath, const std::string& modelZipPassword);
|
|
virtual bool OptimizeModel(bool fp16, std::string& optimizedModelFolder);
|
|
virtual std::vector<FaceResultObject> Match(const cv::Mat& input, const std::vector<ANSCENTER::Object>& bBox, const std::map<std::string, std::string>& userDict) = 0; //
|
|
virtual std::vector<float> Feature(const cv::Mat& image, const ANSCENTER::Object& bBox) = 0; // Run inference and get embedding information from a cropped image (the first bbox)
|
|
virtual cv::Mat GetCropFace(const cv::Mat& input, const ANSCENTER::Object& bBox) = 0;
|
|
std::string GetModelFolder() { return _modelFolder; };
|
|
virtual bool UpdateParamater(double knownPersonThreshold)=0;
|
|
// For face
|
|
virtual void Init()=0;
|
|
virtual void AddEmbedding(const std::string& className, float embedding[])=0;
|
|
virtual void AddEmbedding(const std::string& className, const std::vector<float>& embedding) =0;
|
|
virtual bool Destroy()=0;
|
|
virtual void SetMaxSlotsPerGpu(int n) {} // override in TRT-based subclasses
|
|
// True once Initialize() fully succeeded (license + model + engine).
|
|
// Callers that compute embeddings (enrollment) must check this first:
|
|
// Feature() returns an empty vector when uninitialized, which is
|
|
// indistinguishable from a bad face crop at the call site.
|
|
bool IsInitialized() const { return _isInitialized; }
|
|
~ANSFRBase();
|
|
|
|
// Utility functions
|
|
std::vector<float> L2Normalize(const std::vector<float>& values);
|
|
float CosineSimilarity(const std::vector<float>& a, const std::vector<float>& b, bool normalized);
|
|
};
|
|
class ANSENGINE_API ANSODBase {
|
|
public:
|
|
// Explicit non-copy/non-move: _modelLoading (std::atomic) deletes the
|
|
// implicit copy ops; spelling them out here gives ClangCL a clean
|
|
// anchor and documents that subclasses are never copied/moved (they
|
|
// are heap-allocated and passed by shared_ptr<...>).
|
|
ANSODBase(const ANSODBase&) = delete;
|
|
ANSODBase& operator=(const ANSODBase&) = delete;
|
|
ANSODBase(ANSODBase&&) = delete;
|
|
ANSODBase& operator=(ANSODBase&&) = delete;
|
|
ANSODBase() = default;
|
|
protected:
|
|
bool _licenseValid{ false };
|
|
bool _isInitialized{ false };
|
|
Params _params;
|
|
std::string _licenseKey;
|
|
std::string _modelFolder;
|
|
std::string _modelConfigFile;
|
|
ModelConfig _modelConfig;
|
|
SPDLogger& _logger = SPDLogger::GetInstance("ANSOD", false);
|
|
// Debug benchmarking flag — when enabled, logs per-stage timing
|
|
// for the full inference pipeline (preprocess, inference, postprocess, tracking, etc.)
|
|
bool _debugFlag{ false };
|
|
std::string _classFilePath;
|
|
std::vector <std::string> _classes;
|
|
bool _loadEngineOnCreation{ true };
|
|
bool _skipEngineCache{ false };
|
|
bool _forceNoPool{ false };
|
|
|
|
void CheckLicense();
|
|
void LoadClassesFromString();
|
|
void LoadClassesFromFile();
|
|
|
|
// ────────────────────────────────────────────────────────────────
|
|
// A model that arrived as an .ansmodel package.
|
|
//
|
|
// A package replaces the whole inflated folder: the model, the
|
|
// classes and the geometry model_config.json used to carry all
|
|
// come out of it, and nothing is written to disk. LoadModelPackage
|
|
// fills these in; the engine then builds its session from
|
|
// _packageModel instead of from _modelFilePath.
|
|
//
|
|
// The bytes stay for as long as the engine object does, because
|
|
// the ONNX handler holds a view of them and rebuilds its session
|
|
// from that view when a GPU driver fault forces a recreate.
|
|
// WipeModelPackage() clears them on teardown.
|
|
// ────────────────────────────────────────────────────────────────
|
|
bool _fromPackage{ false };
|
|
std::vector<unsigned char> _packageModel;
|
|
std::string _packageTask; // detection, classification, …
|
|
std::string _packageFamily; // yolo | yolo10 | rfdetr
|
|
std::string _packageMarker; // what the zip would have carried
|
|
std::string _packageName; // what logs call this model
|
|
int _packageInputWidth{ 0 }; // 0: the package does not say
|
|
int _packageInputHeight{ 0 };
|
|
|
|
// Where this engine's session should read its model from: the
|
|
// package's bytes when one was opened, the file otherwise. Engines
|
|
// keep their own _modelFilePath, so it is passed in.
|
|
ModelSource CurrentModelSource(const std::string& filePath) const {
|
|
if (_fromPackage && !_packageModel.empty())
|
|
return ModelSource::Memory(_packageModel.data(),
|
|
_packageModel.size(), _packageName);
|
|
return ModelSource::File(filePath);
|
|
}
|
|
|
|
// Engines reset the input geometry to their own default after the
|
|
// base class has loaded, which would throw away a package's own
|
|
// (a classification model is 224, not 640). This puts it back.
|
|
void ApplyPackageInputSize() {
|
|
if (_packageInputWidth > 0) _modelConfig.inpWidth = _packageInputWidth;
|
|
if (_packageInputHeight > 0) _modelConfig.inpHeight = _packageInputHeight;
|
|
}
|
|
|
|
static bool IsModelPackagePath(const std::string& path);
|
|
// Opens one, decrypts the model into _packageModel, and fills
|
|
// _classes and _modelConfig's geometry from the manifest. Returns
|
|
// false with the reason logged.
|
|
bool LoadModelPackage(const std::string& path);
|
|
void WipeModelPackage();
|
|
|
|
std::recursive_mutex _mutex;
|
|
// Guard: true while Initialize/LoadModel is in progress on any thread.
|
|
// Inference callers can check this to fail-fast instead of blocking.
|
|
std::atomic<bool> _modelLoading{ false };
|
|
|
|
// Try to lock _mutex with a timeout. Returns a unique_lock that
|
|
// evaluates to true on success. On timeout, logs a warning with
|
|
// the caller name and returns an unlocked unique_lock.
|
|
std::unique_lock<std::recursive_mutex> TryLockWithTimeout(
|
|
const char* caller, unsigned int timeoutMs = 5000)
|
|
{
|
|
const auto deadline = std::chrono::steady_clock::now()
|
|
+ std::chrono::milliseconds(timeoutMs);
|
|
std::unique_lock<std::recursive_mutex> lk(_mutex, std::defer_lock);
|
|
while (!lk.try_lock()) {
|
|
if (std::chrono::steady_clock::now() >= deadline) {
|
|
_logger.LogWarn(caller,
|
|
"Mutex acquisition timed out after "
|
|
+ std::to_string(timeoutMs) + " ms"
|
|
+ (_modelLoading.load() ? " (model loading in progress)" : ""),
|
|
__FILE__, __LINE__);
|
|
return lk; // unlocked
|
|
}
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
|
}
|
|
return lk; // locked
|
|
}
|
|
|
|
// Pre-inference gate: checks _modelLoading, validates state
|
|
// (_modelLoadValid, _licenseValid, _isInitialized), and acquires
|
|
// _mutex with a timeout. Returns true if inference may proceed.
|
|
// On failure (loading in progress, timeout, or invalid state)
|
|
// returns false and the caller should return {}.
|
|
bool PreInferenceCheck(const char* caller) {
|
|
if (_modelLoading.load()) return false;
|
|
auto lk = TryLockWithTimeout(caller);
|
|
if (!lk.owns_lock()) return false;
|
|
if (!_licenseValid || !_isInitialized)
|
|
return false;
|
|
return true; // lock released here — caller proceeds unlocked
|
|
}
|
|
|
|
// RAII helper: sets _modelLoading=true on construction, false on destruction.
|
|
// Use in Initialize/LoadModel/LoadModelFromFolder to guarantee the flag
|
|
// is always cleared, even on exceptions or early returns.
|
|
struct ModelLoadingGuard {
|
|
std::atomic<bool>& flag;
|
|
explicit ModelLoadingGuard(std::atomic<bool>& f) : flag(f) { flag.store(true); }
|
|
~ModelLoadingGuard() { flag.store(false); }
|
|
ModelLoadingGuard(const ModelLoadingGuard&) = delete;
|
|
ModelLoadingGuard& operator=(const ModelLoadingGuard&) = delete;
|
|
};
|
|
|
|
MoveDetectsHandler _handler;
|
|
size_t QUEUE_SIZE = 20;
|
|
|
|
// Multi-object tracker (MOT) — per-camera instances lazy-created in ApplyTracking
|
|
bool _trackerEnabled = false;
|
|
TrackerType _trackerType = TrackerType::BYTETRACK;
|
|
int _trackerMotType = 1; // ANSMOT motType int
|
|
std::string _trackerParams; // JSON params applied to each per-camera tracker
|
|
|
|
// Detection stabilization config
|
|
bool _stabilizationEnabled = false;
|
|
size_t _stabilizationQueueSize = 20; // history depth (frames)
|
|
int _stabilizationMaxConsecutiveMisses = 5; // stop interpolating after N misses
|
|
float _stabilizationConfidenceDecay = 0.85f; // per-miss confidence multiplier
|
|
float _stabilizationMinConfidence = 0.15f; // floor below which ghosts are dropped
|
|
|
|
// #1 Confidence hysteresis: two-threshold system
|
|
float _hysteresisEnterThreshold = 0.0f; // 0 = auto (use detectionScoreThreshold)
|
|
float _hysteresisKeepThreshold = 0.0f; // 0 = auto (enterThreshold * 0.65)
|
|
|
|
// #2 Temporal confidence smoothing (EMA)
|
|
float _emaAlpha = 0.3f; // EMA weight for new observation (0..1)
|
|
|
|
// #5 Track-aware confidence boost for established tracks
|
|
int _trackBoostMinFrames = 10; // frames before boost kicks in
|
|
float _trackBoostAmount = 0.05f; // confidence bonus for established tracks
|
|
|
|
// #7 Class consistency — prevent sudden class switches on established tracks
|
|
int _classConsistencyMinFrames = 5; // consecutive frames of new class required to accept switch
|
|
// Adaptive screens
|
|
struct ImageSection {
|
|
cv::Rect region;
|
|
int priority;
|
|
ImageSection(const cv::Rect& r) : region(r), priority(0) {}
|
|
};
|
|
cv::Size previousImageSize = cv::Size(0, 0);
|
|
|
|
// For active windows
|
|
std::vector<ImageSection> cachedSections;
|
|
int _currentPriority{ 0 }; // None
|
|
cv::Rect _detectedArea;// This is active windows.
|
|
|
|
int _retainDetectedArea{ 0 };
|
|
bool _isObjectDetected{ false };
|
|
struct CameraData
|
|
{
|
|
std::deque<std::vector<Object>> _detectionQueue; // That stores the detection results
|
|
|
|
// Per-camera tracker instance (lazy-created in ApplyTracking)
|
|
ANSCENTER::ANSMOT* _tracker = nullptr;
|
|
|
|
// ── Stabilization state ──────────────────────────────
|
|
struct TrackedObjectHistory {
|
|
int classId = 0;
|
|
std::string className;
|
|
std::string extraInfo; // preserve last-known extraInfo for ghost objects
|
|
cv::Rect lastBox;
|
|
float lastConfidence = 0.f;
|
|
float smoothedConfidence = 0.f; // EMA-smoothed confidence
|
|
int consecutiveMisses = 0; // frames since last raw detection
|
|
int totalDetections = 0; // lifetime detection count
|
|
int frameFirstSeen = 0; // frame counter when first detected
|
|
bool isEstablished = false; // true once totalDetections >= trackBoostMinFrames
|
|
|
|
// #7 Class consistency — resist sudden class switches
|
|
int pendingClassId = -1; // candidate new class (-1 = none)
|
|
std::string pendingClassName;
|
|
int pendingClassStreak = 0; // consecutive frames with pendingClass
|
|
};
|
|
std::unordered_map<int, TrackedObjectHistory> _trackHistories; // trackId -> history
|
|
int _stabilizationFrameCounter = 0;
|
|
|
|
void clear()
|
|
{
|
|
if (_tracker) {
|
|
ReleaseANSMOTHandle(&_tracker);
|
|
_tracker = nullptr;
|
|
}
|
|
for (auto& detectionVector : _detectionQueue)
|
|
{
|
|
detectionVector.clear(); // Clear each vector of Objects
|
|
}
|
|
_detectionQueue.clear(); // Clear the deque itself
|
|
_trackHistories.clear();
|
|
_stabilizationFrameCounter = 0;
|
|
}
|
|
};
|
|
// Multi-camera data storage
|
|
std::unordered_map<std::string, CameraData> _cameras;
|
|
CameraData _defaultCamera; // Default camera data if camera_id is not provided
|
|
|
|
// Tracker: convert detections → TrackerObject, run tracker, assign trackIds via IoU match
|
|
std::vector<Object> ApplyTracking(std::vector<Object>& detections, const std::string& camera_id);
|
|
|
|
// Stabilize detections: fill gaps with tracker-predicted objects, apply confidence decay
|
|
std::vector<Object> StabilizeDetections(std::vector<Object>& detections, const std::string& camera_id);
|
|
|
|
// extraInfo stabilization tag helpers
|
|
static void TagStabilized(std::string& extraInfo);
|
|
static void UntagStabilized(std::string& extraInfo);
|
|
static bool IsTaggedStabilized(const std::string& extraInfo);
|
|
|
|
// Other functions can be used;
|
|
bool isSimilarObject(const Object& obj1, const Object& obj2);
|
|
bool isOverlayObject(const Object& obj1, const Object& obj2);
|
|
// Helper: returns the Euclidean distance between two points.
|
|
float distance(const cv::Point2f& a, const cv::Point2f& b) {
|
|
float dx = a.x - b.x;
|
|
float dy = a.y - b.y;
|
|
return std::sqrt(dx * dx + dy * dy);
|
|
}
|
|
// Compute the union (bounding box) of two rectangles.
|
|
cv::Rect unionRect(const cv::Rect& a, const cv::Rect& b) {
|
|
int x = std::min(a.x, b.x);
|
|
int y = std::min(a.y, b.y);
|
|
int x2 = std::max(a.x + a.width, b.x + b.width);
|
|
int y2 = std::max(a.y + a.height, b.y + b.height);
|
|
return cv::Rect(x, y, x2 - x, y2 - y);
|
|
}
|
|
cv::Rect computeCandidateROI(const cv::Rect& unionBox, int fixedWidth, int fixedHeight, int imageWidth, int imageHeight);
|
|
// Check if two rectangles overlap (i.e. intersection area > 0).
|
|
bool isOverlap(const cv::Rect& a, const cv::Rect& b) {
|
|
return ((a & b).area() > 0);
|
|
}
|
|
std::string GetOpenVINODevice(ov::Core &core);
|
|
|
|
// Function to seperate screen size
|
|
double calculateDistanceToCenter(const cv::Point& center, const cv::Rect& rect);
|
|
std::vector<ImageSection> divideImage(const cv::Mat& image);
|
|
std::vector<ImageSection> createSlideScreens(const cv::Mat& image);
|
|
int getHighestPriorityRegion();
|
|
int getLowestPriorityRegion();
|
|
cv::Rect getRegionByPriority(int priority);
|
|
std::vector<Object> AdjustDetectedBoundingBoxes(const std::vector<Object>& detectionsInROI,
|
|
const cv::Rect& roi, const cv::Size& fullImageSize,
|
|
float aspectRatio = 0.9f, // width at least 2x height
|
|
int padding = 10 // base padding
|
|
);
|
|
void UpdateNoDetectionCondition();
|
|
void UpdateActiveROI(const cv::Mat& frame, ANSCENTER::Object detectedObj);
|
|
bool IsValidObject(const Object& obj, std::vector<int> objectIds);
|
|
public:
|
|
[[nodiscard]] virtual bool Initialize(std::string licenseKey, ModelConfig modelConfig, const std::string& modelZipFilePath, const std::string& modelZipPassword, std::string& labelMap);
|
|
[[nodiscard]] virtual bool LoadModel(const std::string& modelZipFilePath, const std::string& modelZipPassword);
|
|
[[nodiscard]] virtual bool LoadModelFromFolder(std::string licenseKey, ModelConfig modelConfig, std::string modelName, std::string className, const std::string& modelFolder, std::string& labelMap);
|
|
[[nodiscard]] virtual bool OptimizeModel(bool fp16, std::string& optimizedModelFolder);
|
|
[[nodiscard]] virtual std::vector<Object> RunInference(const cv::Mat& input) = 0;
|
|
[[nodiscard]] virtual std::vector<Object> RunInference(const cv::Mat& input, const std::string& camera_id) = 0;
|
|
[[nodiscard]] virtual std::vector<std::vector<Object>> RunInferencesBatch(const std::vector<cv::Mat>& inputs, const std::string& camera_id);
|
|
|
|
[[nodiscard]] std::vector<Object> RunInference(const cv::Mat& input, std::vector<cv::Rect> Bbox, const std::string& camera_id);
|
|
[[nodiscard]] std::vector<Object> RunInference(const cv::Mat& input, std::vector<cv::Point> Polygon, const std::string& camera_id);
|
|
[[nodiscard]] std::vector<Object> RunInferences(const cv::Mat& input, int tiledWidth, int tiledHeight, double overLap, const std::string& camera_id); // split image to slides and run inference
|
|
[[nodiscard]] std::vector<Object> RunInferenceFromJpegString(const char* jpegData, unsigned long jpegSize, const std::string& camera_id) ;
|
|
[[nodiscard]] std::vector<Object> RunTiledInferenceFromJpegString(const char* jpegData, unsigned long jpegSize, int tiledWith, int tiledHeight, double overLap, const std::string& camera_id);
|
|
[[nodiscard]] std::vector<Object> DetectMovement(const cv::Mat& input, const std::string& camera_id);
|
|
[[nodiscard]] std::vector<cv::Rect> GenerateFixedROIs(const std::vector<Object>& movementObjects, int fixedWidth, int fixedHeight, int imageWidth, int imageHeight);
|
|
[[nodiscard]] cv::Rect GenerateMinimumSquareBoundingBox(const std::vector<ANSCENTER::Object>& detectedObjects, int minSize = 640);
|
|
void UpdateAndFilterDetectionObjects(std::vector<Object>& detectionObjects, int threshold);
|
|
[[nodiscard]] bool ContainsIntersectingObject(const std::vector<Object>& movementObjects, const Object& result);
|
|
[[nodiscard]] cv::Rect GetActiveWindow(const cv::Mat& input);
|
|
[[nodiscard]] Params GetParameters() { return _params; } //
|
|
[[nodiscard]] virtual bool ConfigureParameters(Params& param); //
|
|
[[nodiscard]] virtual bool SetParameters(const Params& param); //ANSVIS will set the parameters
|
|
[[nodiscard]] bool UpdateDetectionThreshold(float detectionScore);
|
|
[[nodiscard]] std::vector<Object> RunInferenceWithOption(const cv::Mat& input, const std::string& camera_id, const std::string activeROIMode);// Get detected objects
|
|
// New API to suppor dynamic inference
|
|
[[nodiscard]] std::vector<Object> RunDynamicInference(const cv::Mat& input, cv::Rect Bbox, const std::string& camera_id);
|
|
[[nodiscard]] std::vector<Object> RunStaticInference(const cv::Mat& input, cv::Rect Bbox, const std::string& camera_id);
|
|
void SetLoadEngineOnCreation(bool loadEngineOnCreation) { _loadEngineOnCreation = loadEngineOnCreation; }
|
|
virtual void SetMaxSlotsPerGpu(int n) {} // override in TRT-based subclasses
|
|
void SetSkipEngineCache(bool skip) { _skipEngineCache = skip; } // propagated to Engine<T> before buildLoadNetwork
|
|
void SetForceNoPool(bool force) { _forceNoPool = force; } // propagated to Engine<T> before buildLoadNetwork
|
|
|
|
/// Enable/disable internal debug benchmarking.
|
|
/// When enabled, per-stage timing (preprocess, inference, postprocess, tracking, etc.)
|
|
/// is logged via _logger at info level for every inference call.
|
|
void ActivateDebugger(bool debugFlag) { _debugFlag = debugFlag; }
|
|
|
|
// Multi-object tracker (MOT) control
|
|
bool SetTracker(TrackerType trackerType, bool enabled);
|
|
|
|
// Detection stabilization control
|
|
// Auto-enables tracker if not already enabled. Tracker auto-enables stabilization too.
|
|
bool SetStabilization(bool enabled, int historySize = 20, int maxMisses = 5);
|
|
|
|
// Fine-tune all stabilization parameters at once (JSON input).
|
|
// Keys (all optional — omit to keep current value):
|
|
// "hysteresis_enter" : float — confidence to start tracking (0=auto from model threshold)
|
|
// "hysteresis_keep" : float — confidence to keep tracking (0=auto, 65% of enter)
|
|
// "ema_alpha" : float — EMA weight for new observation (0..1, default 0.3)
|
|
// "track_boost_min_frames" : int — frames before boost kicks in (default 10)
|
|
// "track_boost_amount" : float — confidence bonus for established tracks (default 0.05)
|
|
// "class_consistency_frames": int — consecutive frames of new class to accept switch (default 5)
|
|
// "confidence_decay" : float — per-miss decay multiplier for ghosts (default 0.85)
|
|
// "min_confidence" : float — floor below which ghosts are dropped (default 0.15)
|
|
bool SetStabilizationParameters(const std::string& jsonParams);
|
|
|
|
bool SetTrackerParameters(const std::string& jsonParams);
|
|
|
|
/// Set the text prompt for segmentation (pre-tokenized).
|
|
/// Override in subclasses that support text-prompted segmentation (e.g. ANSSAM3, ANSONNXSAM3).
|
|
virtual bool SetPrompt(const std::vector<int64_t>& inputIds,
|
|
const std::vector<int64_t>& attentionMask) {
|
|
return true;
|
|
}
|
|
|
|
/// Set the text prompt by tokenizing the given text.
|
|
/// Requires merges.txt (CLIP BPE vocabulary) in the model folder.
|
|
/// Override in subclasses that support text-prompted segmentation.
|
|
virtual bool SetPrompt(const std::string& text) { return true; }
|
|
|
|
std::vector<Object> _detectedObjects;
|
|
[[nodiscard]] ModelConfig GetModelConfig();
|
|
// Function to add or retrieve camera data by ID
|
|
CameraData& GetCameraData(const std::string& cameraId) {
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|
try
|
|
{
|
|
if (_cameras.empty())
|
|
{
|
|
std::cerr << "Warning: _cameras is initially empty." << std::endl;
|
|
}
|
|
|
|
// Use try_emplace to insert a default CameraData if cameraId does not exist
|
|
auto [iterator, inserted] = _cameras.try_emplace(cameraId, CameraData{});
|
|
|
|
if (inserted)
|
|
{
|
|
std::cout << "Added new CameraData for cameraId: " << cameraId << std::endl;
|
|
}
|
|
|
|
return iterator->second; // Return the reference to CameraData
|
|
}
|
|
catch (const std::exception& ex)
|
|
{
|
|
std::cerr << "Exception in GetCameraData: " << ex.what() << std::endl;
|
|
return _defaultCamera;
|
|
}
|
|
}
|
|
void EnqueueDetection(const std::vector<Object>& detectedObjects, const std::string& cameraId);
|
|
[[nodiscard]] bool RunInference(const cv::Mat& input, const std::string& camera_id, std::string& detectionResult);
|
|
[[nodiscard]] std::deque<std::vector<Object>> DequeueDetection(const std::string& cameraId);
|
|
[[nodiscard]] virtual bool Destroy()=0;
|
|
~ANSODBase();
|
|
protected:
|
|
std::vector<Object> RunInferenceInScanningMode(const cv::Mat& input, const std::string& camera_id);// Get detected objects
|
|
std::vector<Object> RunInferenceInTrackingMode(const cv::Mat& input, const std::string& camera_id, std::vector<int> trackingObjectIds);// Get detected objects
|
|
};
|
|
class ANSENGINE_API ANSFDBase {
|
|
public:
|
|
// Explicit non-copy/non-move (see ANSODBase for rationale).
|
|
ANSFDBase(const ANSFDBase&) = delete;
|
|
ANSFDBase& operator=(const ANSFDBase&) = delete;
|
|
ANSFDBase(ANSFDBase&&) = delete;
|
|
ANSFDBase& operator=(ANSFDBase&&) = delete;
|
|
ANSFDBase() = default;
|
|
protected:
|
|
bool _licenseValid{ false };
|
|
bool _isInitialized{ false };
|
|
std::string _licenseKey;
|
|
std::string _modelFolder;
|
|
std::string _faceAttrModelFolder;
|
|
|
|
ModelConfig _modelConfig;
|
|
std::string _modelConfigFile;
|
|
std::string _imageProcessingModelFile;
|
|
MoveDetectsHandler _handler;
|
|
const size_t QUEUE_SIZE = 10;
|
|
std::recursive_mutex _mutex;
|
|
std::atomic<bool> _modelLoading{ false };
|
|
|
|
// Pre-inference gate for ANSFDBase subclasses
|
|
bool PreInferenceCheck(const char* caller) {
|
|
if (_modelLoading.load()) return false;
|
|
auto lk = TryLockWithTimeout(caller);
|
|
if (!lk.owns_lock()) return false;
|
|
if (!_licenseValid || !_isInitialized)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
struct ModelLoadingGuard {
|
|
std::atomic<bool>& flag;
|
|
explicit ModelLoadingGuard(std::atomic<bool>& f) : flag(f) { flag.store(true); }
|
|
~ModelLoadingGuard() { flag.store(false); }
|
|
ModelLoadingGuard(const ModelLoadingGuard&) = delete;
|
|
ModelLoadingGuard& operator=(const ModelLoadingGuard&) = delete;
|
|
};
|
|
|
|
std::unique_lock<std::recursive_mutex> TryLockWithTimeout(
|
|
const char* caller, unsigned int timeoutMs = 5000)
|
|
{
|
|
const auto deadline = std::chrono::steady_clock::now()
|
|
+ std::chrono::milliseconds(timeoutMs);
|
|
std::unique_lock<std::recursive_mutex> lk(_mutex, std::defer_lock);
|
|
while (!lk.try_lock()) {
|
|
if (std::chrono::steady_clock::now() >= deadline) {
|
|
_logger.LogWarn(caller,
|
|
"Mutex acquisition timed out after "
|
|
+ std::to_string(timeoutMs) + " ms"
|
|
+ (_modelLoading.load() ? " (model loading in progress)" : ""),
|
|
__FILE__, __LINE__);
|
|
return lk;
|
|
}
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
|
}
|
|
return lk;
|
|
}
|
|
|
|
ANSCENTER::EngineType engineType;
|
|
|
|
bool _facelivenessEngineValid{ false };
|
|
Ort::Env* _ortLivenessEnv = nullptr;
|
|
Ort::SessionOptions* _ortLivenessSessionOptions = nullptr;
|
|
Ort::Session* _livenessSession = nullptr;
|
|
std::string _livenessInputName;
|
|
std::string _livenessOutputName;
|
|
ANSCENTER::ANSMOT* _faceTracker = nullptr;
|
|
#ifdef USE_TV_MODEL
|
|
ANSCENTER::ANSMOT* _tvTracker = nullptr;
|
|
std::unique_ptr<ANSODBase>_tvDetector = nullptr;
|
|
std::vector<Object> TrackTVScreens(const std::vector<Object>& tvObjects);
|
|
bool InsideScreen(const cv::Rect& tvBox, const cv::Rect& faceBox);
|
|
#endif
|
|
bool _useTvDetector{ false };
|
|
std::unordered_map<int, int> _mMissingTrackFrames; // Track ID and number of missing face
|
|
std::unordered_map<int, int> _mMissingTrackScreen; // Track ID and number of missing screen
|
|
std::unordered_map<int, std::deque<int>> _mTrackHistory; //History of liveness attribute
|
|
std::unordered_map<int, std::vector<Object>> _mTrackScreen; //History of Screen's position
|
|
// Adaptive screens
|
|
struct ImageSection {
|
|
cv::Rect region;
|
|
int priority;
|
|
ImageSection(const cv::Rect& r) : region(r), priority(0) {}
|
|
};
|
|
cv::Size previousImageSize = cv::Size(0, 0);
|
|
std::vector<ImageSection> cachedSections;
|
|
int _currentPriority{ 0 }; // None
|
|
cv::Rect _detectedArea;// Area where license plate are detected
|
|
|
|
//AsyncPipeline* _pipeline = nullptr;
|
|
SPDLogger& _logger = SPDLogger::GetInstance("ANSFD", false);
|
|
EngineType _engineType;
|
|
void CheckLicense();
|
|
void Cleanup();
|
|
// Other functions can be used;
|
|
bool isSimilarObject(const Object& obj1, const Object& obj2);
|
|
bool isOverlayObject(const Object& obj1, const Object& obj2);
|
|
struct CameraData
|
|
{
|
|
std::deque<std::vector<Object>> _detectionQueue; // That stores the detection results
|
|
void clear()
|
|
{
|
|
for (auto& detectionVector : _detectionQueue)
|
|
{
|
|
detectionVector.clear(); // Clear each vector of Objects
|
|
}
|
|
_detectionQueue.clear(); // Clear the deque itself
|
|
}
|
|
};
|
|
CameraData _defaultCamera;
|
|
|
|
// Helper: returns the Euclidean distance between two points.
|
|
float distance(const cv::Point2f& a, const cv::Point2f& b) {
|
|
float dx = a.x - b.x;
|
|
float dy = a.y - b.y;
|
|
return std::sqrt(dx * dx + dy * dy);
|
|
}
|
|
// Compute the union (bounding box) of two rectangles.
|
|
cv::Rect unionRect(const cv::Rect& a, const cv::Rect& b) {
|
|
int x = std::min(a.x, b.x);
|
|
int y = std::min(a.y, b.y);
|
|
int x2 = std::max(a.x + a.width, b.x + b.width);
|
|
int y2 = std::max(a.y + a.height, b.y + b.height);
|
|
return cv::Rect(x, y, x2 - x, y2 - y);
|
|
}
|
|
cv::Rect computeCandidateROI(const cv::Rect& unionBox, int fixedWidth, int fixedHeight, int imageWidth, int imageHeight);
|
|
// Check if two rectangles overlap (i.e. intersection area > 0).
|
|
bool isOverlap(const cv::Rect& a, const cv::Rect& b) {
|
|
return ((a & b).area() > 0);
|
|
}
|
|
bool isValidFace(const std::vector<cv::Point2f>& landmarks, const cv::Rect& faceRect, float maxEyeAngle = 25, int offsetX = 0, int offsetY = 0, const cv::Mat& frame = cv::Mat(), float minBlurScore = 15.0f);
|
|
// Multi-camera data storage
|
|
std::unordered_map<std::string, CameraData> _cameras;
|
|
//cv::Mat EnhanceImage(const cv::Mat inputImage, int cropedImageSize);
|
|
cv::Mat GetCroppedFaceScale(const cv::Mat& image, const int x1, const int y1, const int x2, const int y2, int cropedImageSize);
|
|
std::string GetOpenVINODevice(ov::Core& core);
|
|
|
|
cv::Mat Preprocess(cv::Mat& input_mat, std::vector<cv::Point2f>& face_landmark_5, cv::Mat& preprocessed_mat);
|
|
|
|
// Function to seperate screen size
|
|
double calculateDistanceToCenter(const cv::Point& center, const cv::Rect& rect);
|
|
std::vector<ImageSection> divideImage(const cv::Mat& image);
|
|
std::vector<ANSFDBase::ImageSection> createSlideScreens(const cv::Mat& image);
|
|
int getHighestPriorityRegion();
|
|
int getLowestPriorityRegion();
|
|
cv::Rect getRegionByPriority(int priority);
|
|
std::vector<Object> AdjustDetectedBoundingBoxes(const std::vector<Object>& detectionsInROI,
|
|
const cv::Rect& roi, const cv::Size& fullImageSize,
|
|
float aspectRatio = 0.9f, // width at least 2x height
|
|
int padding = 10 // base padding
|
|
);
|
|
|
|
|
|
// Track faces
|
|
std::vector<Object> TrackFaces(const cv::Mat& inputImage, const std::vector<Object>& faceObjects);
|
|
template<typename MapTrackData, typename MapMissingFrames>
|
|
void CleanUpTracks(std::vector<Object>& currentObjects,
|
|
MapTrackData& trackDataMap,
|
|
MapMissingFrames& missingFramesMap,
|
|
int maxMissing,
|
|
int maxTracks);
|
|
public:
|
|
[[nodiscard]] virtual bool Initialize(std::string licenseKey, ModelConfig modelConfig, const std::string& modelZipFilePath, const std::string& modelZipPassword, std::string& labelMap);
|
|
[[nodiscard]] virtual bool LoadModel(const std::string& modelZipFilePath, const std::string& modelZipPassword);
|
|
[[nodiscard]] virtual bool LoadModelFromFolder(std::string licenseKey, ModelConfig modelConfig, std::string modelName, std::string className, const std::string& modelFolder, std::string& labelMap);
|
|
[[nodiscard]] virtual bool OptimizeModel(bool fp16, std::string& optimizedModelFolder);
|
|
[[nodiscard]] virtual std::vector<ANSCENTER::Object> RunInference(const cv::Mat& input, bool useDynamicImage = true, bool validateFace = false, bool facelivenessCheck = true) = 0;
|
|
[[nodiscard]] virtual std::vector<Object> RunInference(const cv::Mat& input, const std::string& camera_id, bool useDynamicImage = true, bool validateFace = false, bool facelivenessCheck = true) = 0;
|
|
[[nodiscard]] virtual bool Destroy() = 0;
|
|
[[nodiscard]] std::vector<Object> DetectMovement(const cv::Mat& input, const std::string& camera_id);
|
|
[[nodiscard]] cv::Rect GenerateMinimumSquareBoundingBox(const std::vector<ANSCENTER::Object>& detectedObjects, int minSize = 640);
|
|
[[nodiscard]] std::vector<cv::Rect> GenerateFixedROIs(const std::vector<Object>& movementObjects, int fixedWidth, int fixedHeight, int imageWidth, int imageHeight);
|
|
[[nodiscard]] bool ContainsIntersectingObject(const std::vector<Object>& movementObjects, const Object& result);
|
|
void UpdateAndFilterDetectionObjects(std::vector<Object>& detectionObjects, int threshold);
|
|
[[nodiscard]] bool UpdateDetectionThreshold(float detectionScore);
|
|
[[nodiscard]] float GetDetectionThreshold();
|
|
[[nodiscard]] ModelConfig GetModelConfig();
|
|
// Function to add or retrieve camera data by ID
|
|
CameraData& GetCameraData(const std::string& cameraId)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|
try
|
|
{
|
|
if (_cameras.empty())
|
|
{
|
|
std::cerr << "Warning: _cameras is initially empty." << std::endl;
|
|
}
|
|
|
|
// Use try_emplace to insert a default CameraData if cameraId does not exist
|
|
auto [iterator, inserted] = _cameras.try_emplace(cameraId, CameraData{});
|
|
|
|
if (inserted)
|
|
{
|
|
std::cout << "Added new CameraData for cameraId: " << cameraId << std::endl;
|
|
}
|
|
|
|
return iterator->second; // Return the reference to CameraData
|
|
}
|
|
catch (const std::exception& ex)
|
|
{
|
|
std::cerr << "Exception in GetCameraData: " << ex.what() << std::endl;
|
|
return _defaultCamera;
|
|
}
|
|
}
|
|
void EnqueueDetection(const std::vector<Object>& detectedObjects, const std::string& cameraId);
|
|
std::deque<std::vector<Object>> DequeueDetection(const std::string& cameraId);
|
|
// Face liveness functions
|
|
bool LoadLivenessModel(std::string antiSpoofModelPath, bool isGPU = true);
|
|
bool InitializeLivenessModel(std::string licenseKey, const std::string& modelZipFilePath, const std::string& modelZipPassword);
|
|
std::pair<int, float> PredictLiveness(const cv::Mat& faceImage);
|
|
std::pair<int, float> LivenessPostProcessing(const float* pOutput);
|
|
|
|
std::vector<Object> ValidateLivenessFaces(const cv::Mat& inputImage, const std::vector<Object>& faceObjects, const std::string& camera_id);
|
|
float ComputeIoU(const cv::Rect& a, const cv::Rect& b);
|
|
virtual void SetMaxSlotsPerGpu(int n) {} // override in TRT-based subclasses
|
|
~ANSFDBase();
|
|
};
|
|
}
|
|
|
|
// Unicode conversion utilities for LabVIEW wrapper classes
|
|
extern "C" ANSENGINE_API int ANSEngine_ConvertUTF8ToUTF16LE(const char* utf8Str, LStrHandle result, int includeBOM = 1);
|
|
extern "C" ANSENGINE_API int ANSEngine_ConvertUTF16LEToUTF8(const unsigned char* utf16leBytes, int byteLen, LStrHandle result);
|
|
|
|
#endif |