2745 lines
120 KiB
C++
2745 lines
120 KiB
C++
#include "ANSODTest.h"
|
|
|
|
int GPUYolov10EngineUnitTest(std::string modelFilePath, std::string videoFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.5;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 14;//TENSORRT V10
|
|
int detectorType = 1;
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType, 1,1);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
std::cout << "begin read video" << std::endl;
|
|
cv::VideoCapture capture(videoFilePath);
|
|
|
|
if (!capture.isOpened()) {
|
|
printf("could not read this video file...\n");
|
|
return -1;
|
|
}
|
|
|
|
std::cout << "end read video" << std::endl;
|
|
|
|
while (true)
|
|
{
|
|
cv::Mat frame;
|
|
if (!capture.read(frame)) // if not success, break loop
|
|
{
|
|
std::cout << "\n Cannot read the video file. please check your video.\n";
|
|
break;
|
|
}
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", frame);
|
|
if (cv::waitKey(30) == 27) // Wait for 'esc' key press to exit
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
capture.release();
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int OpenVINOYolov10EngineUnitTest(std::string modelFilePath, std::string videoFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float detectionScoreThreshold = 0.48;
|
|
float modelConfThreshold = 0.48;
|
|
float modelNMSThreshold = 0.48;
|
|
int modelType = 15;//OPENVINO
|
|
int detectorType = 1; // Detection
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), detectionScoreThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
std::cout << "begin read video" << std::endl;
|
|
cv::VideoCapture capture(videoFilePath);
|
|
|
|
if (!capture.isOpened()) {
|
|
printf("could not read this video file...\n");
|
|
return -1;
|
|
}
|
|
|
|
std::cout << "end read video" << std::endl;
|
|
while (true)
|
|
{
|
|
cv::Mat frame;
|
|
if (!capture.read(frame)) // if not success, break loop
|
|
{
|
|
std::cout << "\n Cannot read the video file. please check your video.\n";
|
|
break;
|
|
}
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto prob = GetData<float>(result, "prob");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d:%.2f", classes[class_id], class_id, prob), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", frame);
|
|
if (cv::waitKey(30) == 27) // Wait for 'esc' key press to exit
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
capture.release();
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int OpenVINOYolov10EngineUnitTestLoop(std::string modelFilePath, std::string videoFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float detectionScoreThreshold = 0.48;
|
|
float modelConfThreshold = 0.48;
|
|
float modelNMSThreshold = 0.48;
|
|
int modelType = 15; // OPENVINO
|
|
int detectorType = 1; // Detection
|
|
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), detectionScoreThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good()) {
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size() << std::endl;
|
|
|
|
while (true) {
|
|
std::cout << "begin read video" << std::endl;
|
|
cv::VideoCapture capture(videoFilePath);
|
|
|
|
if (!capture.isOpened()) {
|
|
printf("could not read this video file...\n");
|
|
return -1;
|
|
}
|
|
|
|
std::cout << "end read video" << std::endl;
|
|
|
|
while (true) {
|
|
cv::Mat frame;
|
|
if (!capture.read(frame)) {
|
|
std::cout << "\n Cannot read the video file. Restarting...\n";
|
|
capture.set(cv::CAP_PROP_POS_FRAMES, 0); // Reset to the beginning of the video
|
|
continue;
|
|
}
|
|
|
|
unsigned int bufferLength = 0;
|
|
cv::Mat croppedFrame = frame(cv::Rect(0, 0, 1920, 1080));
|
|
auto start1 = std::chrono::system_clock::now();
|
|
|
|
std::vector<uchar> imageData;
|
|
bool success = cv::imencode(".jpg", croppedFrame, imageData);
|
|
if (!success) {
|
|
std::cout << "Failed to encode the image" << std::endl;
|
|
break;
|
|
}
|
|
std::string jpegImage(imageData.begin(), imageData.end());
|
|
auto end1 = std::chrono::system_clock::now();
|
|
auto elapsed1 = std::chrono::duration_cast<std::chrono::milliseconds>(end1 - start1);
|
|
//printf("Conversion Time = %lld ms\n", static_cast<long long int>(elapsed1.count()));
|
|
|
|
int height = croppedFrame.rows;
|
|
int width = croppedFrame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceFromCV(&infHandle, croppedFrame);//RunInferenceFromJpegString(&infHandle, jpegImage.c_str(), imageData.size());// , 100, 100, 0.2);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results")) {
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto prob = GetData<float>(result, "prob");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(croppedFrame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(croppedFrame, cv::format("%s:%d:%.2f", classes[class_id], class_id, prob), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", croppedFrame);
|
|
if (cv::waitKey(30) == 27) { // Wait for 'esc' key press to exit
|
|
capture.release();
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
int OpenVINOEngineUnitTest(std::string modelFilePath, std::string videoFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.2;
|
|
float modelConfThreshold = 0.2;
|
|
float modelNMSThreshold = 0.2;
|
|
int modelType = 5;//OPENVINO
|
|
int detectorType = 1; // Detection
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
std::cout << "begin read video" << std::endl;
|
|
cv::VideoCapture capture(videoFilePath);
|
|
|
|
if (!capture.isOpened()) {
|
|
printf("could not read this video file...\n");
|
|
return -1;
|
|
}
|
|
|
|
std::cout << "end read video" << std::endl;
|
|
while (true)
|
|
{
|
|
cv::Mat frame;
|
|
if (!capture.read(frame)) // if not success, break loop
|
|
{
|
|
std::cout << "\n Cannot read the video file. please check your video.\n";
|
|
break;
|
|
}
|
|
unsigned int bufferLength = 0;
|
|
cv::Mat croppedframe = frame(cv::Rect(0, 0, frame.cols, frame.rows));
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(croppedframe, bufferLength);
|
|
int height = croppedframe.rows;
|
|
int width = croppedframe.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto prob = GetData<float>(result, "prob");
|
|
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(croppedframe, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(croppedframe, cv::format("%s:%d:%.2f", classes[class_id], class_id, prob), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", croppedframe);
|
|
if (cv::waitKey(30) == 27) // Wait for 'esc' key press to exit
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
capture.release();
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int Yolov8EngineUnitTest(std::string modelFilePath, std::string videoFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.5;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 3;//TENSORRT
|
|
int detectorType = 1;
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType,1, 1);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
std::cout << "begin read video" << std::endl;
|
|
cv::VideoCapture capture(videoFilePath);
|
|
|
|
if (!capture.isOpened()) {
|
|
printf("could not read this video file...\n");
|
|
return -1;
|
|
}
|
|
|
|
std::cout << "end read video" << std::endl;
|
|
|
|
while (true)
|
|
{
|
|
cv::Mat frame;
|
|
if (!capture.read(frame)) // if not success, break loop
|
|
{
|
|
std::cout << "\n Cannot read the video file. please check your video.\n";
|
|
break;
|
|
}
|
|
unsigned int bufferLength = 0;
|
|
cv::Mat croppedFrame = frame.clone();// frame(cv::Rect(1440, 0, 320, 320)).clone();// frame.clone();//frame(cv::Rect(1250, 0, 640, 640)).clone();//frame.clone();// frame.clone();//
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(croppedFrame, bufferLength);
|
|
int height = croppedFrame.rows;
|
|
int width = croppedFrame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(croppedFrame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(croppedFrame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", croppedFrame);
|
|
if (cv::waitKey(30) == 27) // Wait for 'esc' key press to exit
|
|
{
|
|
break;
|
|
}
|
|
croppedFrame.release();
|
|
}
|
|
capture.release();
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int Yolov5EngineUnitTest(std::string modelFilePath, std::string videoFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.2;
|
|
float modelConfThreshold = 0.2;
|
|
float modelNMSThreshold = 0.2;
|
|
int modelType = 2;//Yolov5
|
|
int detectorType = 1;
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType,1, 1);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
std::cout << "begin read video" << std::endl;
|
|
cv::VideoCapture capture(videoFilePath);
|
|
|
|
if (!capture.isOpened()) {
|
|
printf("could not read this video file...\n");
|
|
return -1;
|
|
}
|
|
|
|
std::cout << "end read video" << std::endl;
|
|
|
|
while (true)
|
|
{
|
|
cv::Mat frame;
|
|
if (!capture.read(frame)) // if not success, break loop
|
|
{
|
|
std::cout << "\n Cannot read the video file. please check your video.\n";
|
|
break;
|
|
}
|
|
unsigned int bufferLength = 0;
|
|
cv::Mat croppedFrame = frame.clone();// frame(cv::Rect(1440, 0, 320, 320)).clone();// frame.clone();//frame(cv::Rect(1250, 0, 640, 640)).clone();//frame.clone();// frame.clone();//
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(croppedFrame, bufferLength);
|
|
int height = croppedFrame.rows;
|
|
int width = croppedFrame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(croppedFrame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(croppedFrame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", croppedFrame);
|
|
if (cv::waitKey(30) == 27) // Wait for 'esc' key press to exit
|
|
{
|
|
break;
|
|
}
|
|
croppedFrame.release();
|
|
}
|
|
capture.release();
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int Yolov12EngineUnitTest(std::string modelFilePath, std::string videoFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.25;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 17;//Yolov12 (4 RT)
|
|
int detectorType = 1;
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType,1, 1);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
std::cout << "begin read video" << std::endl;
|
|
cv::VideoCapture capture(videoFilePath);
|
|
|
|
if (!capture.isOpened()) {
|
|
printf("could not read this video file...\n");
|
|
return -1;
|
|
}
|
|
|
|
std::cout << "end read video" << std::endl;
|
|
|
|
while (true)
|
|
{
|
|
cv::Mat frame;
|
|
if (!capture.read(frame)) // if not success, break loop
|
|
{
|
|
std::cout << "\n Cannot read the video file. please check your video.\n";
|
|
break;
|
|
}
|
|
unsigned int bufferLength = 0;
|
|
cv::Mat croppedFrame = frame.clone();// frame(cv::Rect(1440, 0, 320, 320)).clone();// frame.clone();//frame(cv::Rect(1250, 0, 640, 640)).clone();//frame.clone();// frame.clone();//
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(croppedFrame, bufferLength);
|
|
int height = croppedFrame.rows;
|
|
int width = croppedFrame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(croppedFrame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(croppedFrame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
}
|
|
}
|
|
cv::imshow("ANS Object Tracking", croppedFrame);
|
|
if (cv::waitKey(30) == 27) // Wait for 'esc' key press to exit
|
|
{
|
|
break;
|
|
}
|
|
croppedFrame.release();
|
|
}
|
|
capture.release();
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int GPUEngineUnitTest(std::string modelFilePath, std::string videoFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.2;
|
|
float modelConfThreshold = 0.2;
|
|
float modelNMSThreshold = 0.2;
|
|
int modelType = 4;//TENSORRT
|
|
int detectorType = 1;
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType,1, 1);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
std::cout << "begin read video" << std::endl;
|
|
cv::VideoCapture capture(videoFilePath);
|
|
|
|
if (!capture.isOpened()) {
|
|
printf("could not read this video file...\n");
|
|
return -1;
|
|
}
|
|
|
|
std::cout << "end read video" << std::endl;
|
|
|
|
while (true)
|
|
{
|
|
cv::Mat frame;
|
|
if (!capture.read(frame)) // if not success, break loop
|
|
{
|
|
std::cout << "\n Cannot read the video file. please check your video.\n";
|
|
break;
|
|
}
|
|
unsigned int bufferLength = 0;
|
|
cv::Mat croppedFrame = frame.clone();// frame(cv::Rect(1440, 0, 320, 320)).clone();// frame.clone();//frame(cv::Rect(1250, 0, 640, 640)).clone();//frame.clone();// frame.clone();//
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(croppedFrame, bufferLength);
|
|
int height = croppedFrame.rows;
|
|
int width = croppedFrame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(croppedFrame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(croppedFrame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", croppedFrame);
|
|
if (cv::waitKey(30) == 27) // Wait for 'esc' key press to exit
|
|
{
|
|
break;
|
|
}
|
|
croppedFrame.release();
|
|
}
|
|
capture.release();
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int ONNXEngineUnitTest(std::string modelFilePath, std::string videoFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.5;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 3;//ONNX
|
|
int detectorType = 1;
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType,1, 0);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
std::cout << "begin read video" << std::endl;
|
|
cv::VideoCapture capture(videoFilePath);
|
|
|
|
if (!capture.isOpened()) {
|
|
printf("could not read this video file...\n");
|
|
return -1;
|
|
}
|
|
|
|
std::cout << "end read video" << std::endl;
|
|
|
|
while (true)
|
|
{
|
|
cv::Mat frame;
|
|
if (!capture.read(frame)) // if not success, break loop
|
|
{
|
|
std::cout << "\n Cannot read the video file. please check your video.\n";
|
|
break;
|
|
}
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", frame);
|
|
if (cv::waitKey(30) == 27) // Wait for 'esc' key press to exit
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
capture.release();
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int GPUEngineImageTest(std::string modelFilePath, std::string imageFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.5;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 4;//TENSORRT
|
|
int detectorType = 1;
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType,1, 1);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
cv::Mat frame = cv::imread(imageFilePath, cv::IMREAD_COLOR);
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
std::cout << "Result:" << detectionResult << std::endl;
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
std::cout << "Keypoints =[" << GetData<std::string>(result, "extra_info") << "]" << std::endl;
|
|
|
|
}
|
|
}
|
|
|
|
//cv::imshow("ANS Object Tracking", frame);
|
|
//if (cv::waitKey(0) == 0) // Wait for 'esc' key press to exit
|
|
//{
|
|
// std::cout << "End of facial detection.\n";
|
|
//}
|
|
cv::destroyAllWindows();
|
|
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int GPU11EngineImageTest(std::string modelFilePath, std::string imageFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.5;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 4;//TENSORRTyolo11 same as yolov8
|
|
int detectorType = 1;
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType, 1,1);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType,1);
|
|
std::stringstream ss(labelMap);
|
|
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
cv::Mat frame = cv::imread(imageFilePath, cv::IMREAD_COLOR);
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
std::cout << "Result:" << detectionResult << std::endl;
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
std::cout << "Keypoints =[" << GetData<std::string>(result, "extra_info") << "]" << std::endl;
|
|
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", frame);
|
|
if (cv::waitKey(0) == 0) // Wait for 'esc' key press to exit
|
|
{
|
|
std::cout << "End of facial detection.\n";
|
|
}
|
|
cv::destroyAllWindows();
|
|
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int GPU11EngineUnitTest(std::string modelFilePath, std::string videoFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.2;
|
|
float modelConfThreshold = 0.2;
|
|
float modelNMSThreshold = 0.2;
|
|
int modelType = 4;//TENSORRTv11 same as Yolov8
|
|
int detectorType = 1;
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType,1, 1);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
std::cout << "begin read video" << std::endl;
|
|
cv::VideoCapture capture(videoFilePath);
|
|
|
|
if (!capture.isOpened()) {
|
|
printf("could not read this video file...\n");
|
|
return -1;
|
|
}
|
|
|
|
std::cout << "end read video" << std::endl;
|
|
|
|
while (true)
|
|
{
|
|
cv::Mat frame;
|
|
if (!capture.read(frame)) // if not success, break loop
|
|
{
|
|
std::cout << "\n Cannot read the video file. please check your video.\n";
|
|
break;
|
|
}
|
|
unsigned int bufferLength = 0;
|
|
cv::Mat croppedFrame = frame.clone();// frame(cv::Rect(1440, 0, 320, 320)).clone();// frame.clone();//frame(cv::Rect(1250, 0, 640, 640)).clone();//frame.clone();// frame.clone();//
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(croppedFrame, bufferLength);
|
|
int height = croppedFrame.rows;
|
|
int width = croppedFrame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(croppedFrame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(croppedFrame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", croppedFrame);
|
|
if (cv::waitKey(30) == 27) // Wait for 'esc' key press to exit
|
|
{
|
|
break;
|
|
}
|
|
croppedFrame.release();
|
|
}
|
|
capture.release();
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int UnitTests() {
|
|
std::string defaultDir = "C:\\Programs";
|
|
std::string abmodelFilePath = defaultDir + "\\DemoAssets\\ANSAIModels\\anomalibmodel.zip";
|
|
std::string cpumodelFilePath = "C:\\ProgramData\\ANSCENTER\\Shared\\ANS_GenericOD(CPU)_v1.0.zip";
|
|
std::string gpumodelFilePath = defaultDir + "\\DemoAssets\\ANSAIModels\\OptimisedModels\\ANS_GenericOD(GPU)_v1.0.zip";
|
|
|
|
std::string Yolov8OpenVINOModelPath = defaultDir + "\\DemoAssets\\Models\\ANS_GenericOD(CPU)YL8_v1.0.zip";
|
|
std::string Yolov8OTensorRTModelPath = defaultDir + "\\DemoAssets\\ANSAIModels\\OptimisedModels\\PPEGPU.zip";
|
|
|
|
std::string odhubModelPath = defaultDir + "\\DemoAssets\\Models\\openflapmulticat_v1.zip";
|
|
std::string openposeModelPath = defaultDir + "\\ANSAIModels\\ANS_PoseEstimation_v1.0.zip";
|
|
std::string samModelPath = defaultDir + "\\ANSAIModels\\ANS_SAM_v1.0.zip";
|
|
std::string customModelPath = defaultDir + "\\ANLS\\AIModels\\ANSCustomModel_v3.zip";
|
|
|
|
|
|
std::string abImageFilePath = defaultDir + "\\TestImages\\brokenlarge.png";
|
|
std::string customModelImage = defaultDir + "\\ANLS\\AIModels\\LP2.jpg";
|
|
std::string imageDataPath = defaultDir + "\\DemoAssets\\TestImages\\ALPR\\101_EUS664.jpg";
|
|
std::string videoDataPath = defaultDir + "\\DemoAssets\\Videos\\road.mp4";
|
|
std::string videoPPEPath = defaultDir + "\\DemoAssets\\Videos\\Factory1.mp4";
|
|
std::string odhubVideoPath = defaultDir + "\\DemoAssets\\Videos\\openflap.mp4";
|
|
std::string openposeVideoPath = defaultDir + "\\DemoAssets\\Videos\\train.mp4";;
|
|
std::string openposeImagePath = defaultDir + "\\DemoAssets\\TestImages\\ANSCVAImages\\openpose.jpg";
|
|
std::string classroom = defaultDir + "\\DemoAssets\\Videos\\classroom.mp4";
|
|
std::string classroomGPUTest = "C:\\ProgramData\\ANSCENTER\\Shared\\classroom.mp4";
|
|
std::string modelGPUTest = "C:\\ProgramData\\ANSCENTER\\Shared\\ANS_GenericOD(GPU)_v1.0.zip";
|
|
|
|
// OpenVINOEngineUnitTest(Yolov8OpenVINOModelPath, videoDataPath); // Yolov8
|
|
//GPUEngineUnitTest(Yolov8OTensorRTModelPath, videoPPEPath);// yolov8
|
|
// OpenVINOYolov10EngineUnitTestLoop(cpumodelFilePath, classroom);//yolov10
|
|
OpenVINOYolov10EngineUnitTest(cpumodelFilePath, classroom);//yolov10
|
|
|
|
// GPUYolov10EngineUnitTest(modelGPUTest, classroomGPUTest);// yolov10
|
|
//ODHUBAPITest(odhubModelPath, odhubVideoPath);
|
|
|
|
//AnomalibTest(abmodelFilePath, abImageFilePath);
|
|
//FacialDetectorTest(cpumodelFilePath, imageDataPath);
|
|
//HumanPoseTest(openposeModelPath, openposeVideoPath);
|
|
//HumanPoseImageTest(openposeModelPath, openposeImagePath);
|
|
//ANSSAMTest(samModelPath, openflapVideoPath);
|
|
//CustomCodeImageTest(customModelPath, customModelImage);
|
|
//ALPRPipeLineTest(gpumodelFilePath, videoFilePathPipeLine);
|
|
return 0;
|
|
}
|
|
|
|
int FacialDetectorTest(std::string modelFilePath, std::string imagePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.5;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 6;//Facial
|
|
int detectorType = 1; // Detection
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
cv::Mat frame = cv::imread(imagePath, cv::IMREAD_COLOR);
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
std::cout << "Result:" << detectionResult << std::endl;
|
|
delete jpeg_string;
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", frame);
|
|
if (cv::waitKey(0) == 27) // Wait for 'esc' key press to exit
|
|
{
|
|
std::cout << "End of facial detection.\n";
|
|
}
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int AnomalibTest(std::string abmodelFilePath, std::string abImageFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.5;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 10;//Facial
|
|
int detectorType = 2; // Segmentation
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), abmodelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "label map:" << labelMap << std::endl;
|
|
std::string imagePath = abImageFilePath;
|
|
cv::Mat frame = cv::imread(imagePath, cv::IMREAD_COLOR);
|
|
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
std::cout << "Result:" << detectionResult << std::endl;
|
|
delete jpeg_string;
|
|
cv::imshow("ANS Object Tracking", frame);
|
|
if (cv::waitKey(0) == 27) // Wait for 'esc' key press to exit
|
|
{
|
|
std::cout << "End of abnomalib detection.\n";
|
|
}
|
|
cv::destroyAllWindows();
|
|
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int HumanPoseTest(std::string modelFilePath, std::string imagePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.5;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 11;//POSE
|
|
int detectorType = 7; // KEYPOINT
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
|
|
cv::VideoCapture capture(imagePath);
|
|
|
|
if (!capture.isOpened()) {
|
|
printf("could not read this video file...\n");
|
|
return -1;
|
|
}
|
|
while (true)
|
|
{
|
|
cv::Mat frame;
|
|
if (!capture.read(frame)) // if not success, break loop
|
|
{
|
|
std::cout << "\n Cannot read the video file. please check your video.\n";
|
|
break;
|
|
}
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
std::cout << "Keypoints =[" << GetData<std::string>(result, "extra_info") << "]" << std::endl;
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", frame);
|
|
if (cv::waitKey(30) == 27) // Wait for 'esc' key press to exit
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
capture.release();
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int HumanPoseImageTest(std::string modelFilePath, std::string imagePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.5;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 11;//POSE
|
|
int detectorType = 7; // KEYPOINT
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
|
|
cv::Mat frame = cv::imread(imagePath, cv::IMREAD_COLOR);
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
std::cout << "Result:" << detectionResult << std::endl;
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
std::cout << "Keypoints =[" << GetData<std::string>(result, "extra_info") << "]" << std::endl;
|
|
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", frame);
|
|
if (cv::waitKey(0) == 27) // Wait for 'esc' key press to exit
|
|
{
|
|
std::cout << "End of facial detection.\n";
|
|
}
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int ANSSAMTest(std::string modelFilePath, std::string videoPath) {
|
|
ANSCENTER::ANSSAM infHandle;
|
|
std::string licenseKey = "";
|
|
std::string labelmap = "";
|
|
std::string modelZipFilePassword = "";
|
|
ANSCENTER::ModelConfig modelConfig;
|
|
modelConfig.modelConfThreshold = 0.5f;
|
|
infHandle.Initialize(licenseKey, modelConfig, modelFilePath, modelZipFilePassword, labelmap);
|
|
|
|
cv::VideoCapture capture(videoPath);
|
|
if (!capture.isOpened()) {
|
|
printf("could not read this video file...\n");
|
|
return -1;
|
|
}
|
|
while (true)
|
|
{
|
|
cv::Mat frame;
|
|
if (!capture.read(frame)) // if not success, break loop
|
|
{
|
|
std::cout << "\n Cannot read the video file. please check your video.\n";
|
|
break;
|
|
}
|
|
auto start = std::chrono::system_clock::now();
|
|
std::vector<ANSCENTER::Object> masks = infHandle.RunInference(frame);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
|
|
for (int i = 0; i < masks.size(); i++) {
|
|
cv::rectangle(frame, masks.at(i).box, 123, 2);
|
|
|
|
//const cv::Point* pts = (const cv::Point*)cv::Mat(masks.at(i).polygon).data;
|
|
//int npts = cv::Mat(masks.at(i).polygon).rows;
|
|
//polylines(frame, &pts, &npts, 1, true, cv::Scalar(0, 255, 0), 1); // Green color, line thickness 3
|
|
|
|
}
|
|
cv::imshow("ANS Object Tracking", frame);
|
|
if (cv::waitKey(30) == 27) // Wait for 'esc' key press to exit
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
capture.release();
|
|
cv::destroyAllWindows();
|
|
infHandle.Destroy();
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int ODHUBAPITest(std::string modelFilePath, std::string videoFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.7;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 13;//ODHUBAPI ;1 is yolov4 opencv
|
|
int detectorType = 1;
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType,1, 1);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, "", modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
std::cout << "begin read video" << std::endl;
|
|
cv::VideoCapture capture(videoFilePath);
|
|
|
|
if (!capture.isOpened()) {
|
|
printf("could not read this video file...\n");
|
|
return -1;
|
|
}
|
|
|
|
std::cout << "end read video" << std::endl;
|
|
|
|
while (true)
|
|
{
|
|
cv::Mat frame;
|
|
if (!capture.read(frame)) // if not success, break loop
|
|
{
|
|
std::cout << "\n Cannot read the video file. please check your video.\n";
|
|
break;
|
|
}
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", frame);
|
|
if (cv::waitKey(30) == 27) // Wait for 'esc' key press to exit
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
capture.release();
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int ODHUBOpenCVAPITest(std::string modelFilePath, std::string videoFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.7;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 13;//ODHUBAPI ;1 is yolov4 opencv
|
|
int detectorType = 1;
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType,1, 1);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, "", modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
std::cout << "begin read video" << std::endl;
|
|
cv::VideoCapture capture(videoFilePath);
|
|
|
|
if (!capture.isOpened()) {
|
|
printf("could not read this video file...\n");
|
|
return -1;
|
|
}
|
|
|
|
std::cout << "end read video" << std::endl;
|
|
|
|
while (true)
|
|
{
|
|
cv::Mat frame;
|
|
if (!capture.read(frame)) // if not success, break loop
|
|
{
|
|
std::cout << "\n Cannot read the video file. please check your video.\n";
|
|
break;
|
|
}
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", frame);
|
|
if (cv::waitKey(30) == 27) // Wait for 'esc' key press to exit
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
capture.release();
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
|
|
int ODHUBAPIImageTest(std::string modelFilePath, std::string imageFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.7;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 13;//ODHUBAPI ;1 is yolov4 opencv
|
|
int detectorType = 1;
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType,1, 1);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, "", modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
std::cout << "begin read video" << std::endl;
|
|
cv::Mat frame = cv::imread(imageFilePath, cv::IMREAD_COLOR);
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
std::cout << "Result:" << detectionResult << std::endl;
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(255, 0, 0), 1, cv::LINE_AA);
|
|
std::cout << "Keypoints =[" << GetData<std::string>(result, "extra_info") << "]" << std::endl;
|
|
|
|
}
|
|
}
|
|
resize(frame, frame, Size(frame.cols / 2, frame.rows / 2)); // to half size or even smaller
|
|
namedWindow("Display frame", WINDOW_AUTOSIZE);
|
|
cv::imshow("Display frame", frame);
|
|
if (cv::waitKey(0) == 3) // Wait for 'esc' key press to exit
|
|
{
|
|
std::cout << "End of facial detection.\n";
|
|
}
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int ODHUBCVAPIImageTest(std::string modelFilePath, std::string imageFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.7;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 1;//ODHUBAPI ;1 is yolov4 opencv
|
|
int detectorType = 1;
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType, 1,1);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, "", modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
std::cout << "begin read video" << std::endl;
|
|
cv::Mat frame = cv::imread(imageFilePath, cv::IMREAD_COLOR);
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
std::cout << "Result:" << detectionResult << std::endl;
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(255, 0, 0), 1, cv::LINE_AA);
|
|
std::cout << "Keypoints =[" << GetData<std::string>(result, "extra_info") << "]" << std::endl;
|
|
|
|
}
|
|
}
|
|
resize(frame, frame, Size(frame.cols / 2, frame.rows / 2)); // to half size or even smaller
|
|
namedWindow("Display frame", WINDOW_AUTOSIZE);
|
|
cv::imshow("Display frame", frame);
|
|
if (cv::waitKey(0) == 3) // Wait for 'esc' key press to exit
|
|
{
|
|
std::cout << "End of facial detection.\n";
|
|
}
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int CustomCodeImageTest(std::string modelFilePath, std::string imageFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.7;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 16;//Customized
|
|
int detectorType = 1;
|
|
std::string optmizedModelFolder;
|
|
|
|
labelMap = CreateANSODHandle(&infHandle, "", modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
|
|
cv::Mat frame = cv::imread(imageFilePath, cv::IMREAD_COLOR);
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
std::cout << "Result:" << detectionResult << std::endl;
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d", "Test", class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
std::cout << "Keypoints =[" << GetData<std::string>(result, "extra_info") << "]" << std::endl;
|
|
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", frame);
|
|
if (cv::waitKey(0) == 27) // Wait for 'esc' key press to exit
|
|
{
|
|
std::cout << "End of facial detection.\n";
|
|
}
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int FallDetection() {
|
|
|
|
std::string cpumodelFilePath = "C:\\Projects\\ANSVIS\\Models\\ANS_FallDetection(CPU)_v1.0.zip";
|
|
std::string gpumodelFilePath = "C:\\Projects\\ANSVIS\\Models\\ANS_FallDetection(GPU)_v1.0.zip";
|
|
|
|
std::string videoFile = "C:\\Programs\\TrainingWorkingStation\\Projects\\FallDetection\\video\\Fall.mp4";
|
|
std::string MAFallVideo = "C:\\Programs\\DemoAssets\\Videos\\MAFall.mp4";
|
|
|
|
std::string cpumodelFilePathM = "C:\\Programs\\TrainingWorkingStation\\Projects\\FallDetection\\RawModelModified\\ANS_FallDetectionM(CPU)_v1.0.zip";
|
|
std::string gpumodelFilePathM = "C:\\Programs\\TrainingWorkingStation\\Projects\\FallDetection\\RawModelModified\\ANS_FallDetectionM(GPU)_v1.0.zip";
|
|
std::string odhubModelPath = "C:\\Programs\\DemoAssets\\Models\\Fall_ODHUB.zip";
|
|
|
|
//OpenVINOEngineUnitTest(cpumodelFilePathM, videoFile);//yolov8
|
|
//GPUEngineUnitTest(gpumodelFilePath, videoFile);// yolov8
|
|
|
|
ODHUBOpenCVAPITest(odhubModelPath, MAFallVideo);
|
|
return 0;
|
|
}
|
|
int HeadDetection() {
|
|
|
|
std::string cpumodelFilePath = "C:\\Programs\\DemoAssets\\ANSAIModels\\ANS_PeopleHead(CPU)_v1.zip";
|
|
std::string gpumodelFilePath = "C:\\ProgramData\\ANSCENTER\\ANSVIS Server\\Models\\ServerOptimised\\B-IN_ANS_PeopleHead(GPU)_v1.0_6111783b89cda8cf337ad2d60c8b2eea_NVIDIAGeForceRTX4070LaptopGPU.zip";// "C:\\Projects\\ANSVIS\\Models\\ANS_PeopleHead(GPU)_v1.0.zip";
|
|
std::string videoFile = "C:\\Programs\\DemoAssets\\Videos\\video_20.mp4";
|
|
// OpenVINOEngineUnitTest(gpumodelFilePath, videoFile);//yolov8
|
|
//OpenVINOEngineUnitTest(FallModelCPU, FallVideoFile);//yolov8
|
|
//OpenVINOEngineUnitTest(PPECPUMOdel, PPEVideoFile);//yolov8
|
|
|
|
GPUEngineUnitTest(gpumodelFilePath, videoFile);// yolov8
|
|
//GPUEngineUnitTest(PPEGPUMOdel, PPEVideoFile);// yolov8
|
|
|
|
|
|
return 0;
|
|
}
|
|
int FireNSmokeDetection() {
|
|
|
|
std::string cpumodelFilePath = "C:\\Projects\\ANSVIS\\Models\\ANS_FireSmoke(CPU)_v1.0.zip";
|
|
std::string gpumodelFilePath = "C:\\Programs\\ModelExports\\ANS_FireSmoke(GPU)_v1.0\\ANS_FireSmoke(GPU)_v1.0.zip";
|
|
std::string gpumodel10FilePath = "C:\\Programs\\ModelExports\\HoangWork\\ANS_FireSmoke(GPU)_v2.0.zip";
|
|
std::string optimisedModelPath = "C:\\ProgramData\\ANSCENTER\\ANSVIS Server\\Models\\ServerOptimised\\B-IN_ANS_GenericOD(GPU)_v1.0_d52ffdcc7241b541fdcf17f2eff78b89_NVIDIAGeForceRTX4070LaptopGPU.zip";
|
|
std::string optimisedModelPath8 = "C:\\ProgramData\\ANSCENTER\\ANSVIS Server\\Models\\ServerOptimised\\B-IN_ANS_PeopleHead(GPU)_v1.0_6111783b89cda8cf337ad2d60c8b2eea_NVIDIAGeForceRTX4070LaptopGPU.zip";
|
|
std::string videoFile = "C:\\Programs\\DemoAssets\\Videos\\FireNSmoke\\Fire1.mp4";
|
|
|
|
|
|
//GPUYolov10EngineUnitTest(optimisedModelPath, videoFile);// yolov10
|
|
GPUEngineUnitTest(optimisedModelPath8, videoFile);// yolov8
|
|
|
|
//OpenVINOEngineUnitTest(cpumodelFilePath, videoFile);//yolov8
|
|
|
|
//GPUEngineUnitTest(gpumodelFilePath, videoFile);// yolov8
|
|
// ONNXEngineUnitTest(gpumodelFilePath, videoFile);
|
|
|
|
return 0;
|
|
}
|
|
int VehicleDetection() {
|
|
|
|
std::string cpumodelFilePath = "C:\\Programs\\DemoAssets\\ANSAIModels\\ANS_GenericVehicle8(CPU)_v1.0.zip";
|
|
std::string gpumodelFilePath = "C:\\Programs\\DemoAssets\\AIModels\\ODv8xGPUGeneric.zip";
|
|
|
|
std::string cpumodel10FilePath = "C:\\Programs\\DemoAssets\\ANSAIModels\\ANS_GenericVehicle(CPU)_v1.0.zip";
|
|
std::string gpumodel10FilePath = "C:\\Programs\\AIModels\\ANS_GenericOD(GPU)_v1.0.zip";
|
|
|
|
std::string videoFile = "C:\\Programs\\DemoAssets\\Videos\\road.mp4";
|
|
std::string hotelvideoFile = "C:\\Programs\\DemoAssets\\Videos\\video_20.mp4";
|
|
|
|
std::string testModel = "C:\\ProgramData\\ANSCENTER\\ANSVIS Server\\Models\\ServerOptimised\\B-IN_ANS_PeopleHead(GPU)_v1.0_6111783b89cda8cf337ad2d60c8b2eea_NVIDIAGeForceRTX4070LaptopGPU.zip";
|
|
|
|
// std::string testModel = "C:\\ProgramData\\ANSCENTER\\ANSVIS Server\\Models\\ServerOptimised\\B-IN_ANS_PeopleHead(GPU)_v1.0_6111783b89cda8cf337ad2d60c8b2eea_NVIDIARTXA500EmbeddedGPU.zip";
|
|
//GPUYolov10EngineUnitTest(gpumodel10FilePath, videoFile);// yolov10
|
|
//OpenVINOYolov10EngineUnitTestLoop(cpumodel10FilePath, videoFile);//yolov10
|
|
|
|
//OpenVINOEngineUnitTest(testModel, hotelvideoFile);//yolov8
|
|
GPUEngineUnitTest(testModel, hotelvideoFile);// yolov8
|
|
|
|
return 0;
|
|
}
|
|
void TestODHUB() {
|
|
|
|
std::string odhubModelPath = "C:\\Programs\\DemoAssets\\ANSAIModels\\Models\\openflapmulticat_v1.zip";
|
|
std::string odhubVideoPath = "C:\\Programs\\DemoAssets\\Videos\\openflap.mp4";
|
|
ODHUBAPITest(odhubModelPath, odhubVideoPath);
|
|
//ODHUBOpenCVAPITest(odhubModelPath, odhubVideoPath);
|
|
}
|
|
void DissemTest() {
|
|
std::string odhubModelPath = "C:\\Workstation\\CustomerSupport\\Dissem\\EngineTest\\Test_Model Type\\20240705_Waper_1.zip";
|
|
std::string odhubImagePath = "C:\\Workstation\\CustomerSupport\\Dissem\\EngineTest\\Test_Model Type\\0711_10_0051.jpg";
|
|
//ODHUBAPIImageTest(odhubModelPath, odhubImagePath);
|
|
ODHUBCVAPIImageTest(odhubModelPath, odhubImagePath);
|
|
}
|
|
int DissemParallelTest(std::string modelFilePath, std::string imageFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.7;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 13;//ODHUBAPI ;1 is yolov4 opencv
|
|
int detectorType = 1;
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType, 1,1);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, "", modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
std::cout << "begin read video" << std::endl;
|
|
cv::Mat frame = cv::imread(imageFilePath, cv::IMREAD_COLOR);
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
std::cout << "Result:" << detectionResult << std::endl;
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(255, 0, 0), 1, cv::LINE_AA);
|
|
std::cout << "Keypoints =[" << GetData<std::string>(result, "extra_info") << "]" << std::endl;
|
|
|
|
}
|
|
}
|
|
resize(frame, frame, Size(frame.cols / 2, frame.rows / 2)); // to half size or even smaller
|
|
namedWindow("Display frame", WINDOW_AUTOSIZE);
|
|
cv::imshow("Display frame", frame);
|
|
if (cv::waitKey(0) == 3) // Wait for 'esc' key press to exit
|
|
{
|
|
std::cout << "End of facial detection.\n";
|
|
}
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int CustomTest() {
|
|
std::string customModelPath = "C:\\Programs\\DemoAssets\\AIModels\\ANSCustomFaceDetector.zip";
|
|
std::string imageDataPath = "C:\\Projects\\ANSVISCustomFunction\\Examples\\FaceDetector\\test.jpg";
|
|
CustomCodeImageTest(customModelPath, imageDataPath);
|
|
return 0;
|
|
}
|
|
int CocoTest() {
|
|
|
|
std::string gpumodelFilePath = "C:\\ProgramData\\ANSCENTER\\Shared\\ANS_Coco_format(GPU)_1.zip";
|
|
std::string imageFile = "C:\\ProgramData\\ANSCENTER\\Shared\\20240620_132740_256.jpg";
|
|
GPUEngineImageTest(gpumodelFilePath, imageFile);
|
|
|
|
return 0;
|
|
}
|
|
int FaceDetector(std::string modelFilePath, std::string videoFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.5;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 6;//Facial
|
|
int detectorType = 1; // Detection
|
|
// Optimise model
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
std::cout << "begin read video" << std::endl;
|
|
cv::VideoCapture capture(videoFilePath);
|
|
|
|
if (!capture.isOpened()) {
|
|
printf("could not read this video file...\n");
|
|
return -1;
|
|
}
|
|
|
|
std::cout << "end read video" << std::endl;
|
|
|
|
while (true)
|
|
{
|
|
cv::Mat frame;
|
|
if (!capture.read(frame)) // if not success, break loop
|
|
{
|
|
std::cout << "\n Cannot read the video file. please check your video.\n";
|
|
break;
|
|
}
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", frame);
|
|
if (cv::waitKey(30) == 27) // Wait for 'esc' key press to exit
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
capture.release();
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int TiledInferenceTest(std::string modelFilePath, std::string imageFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.55;
|
|
float modelConfThreshold = 5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 14;//
|
|
int detectorType = 1;
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType,1, 1);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, "", modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
|
|
cv::Mat frame = cv::imread(imageFilePath, cv::IMREAD_COLOR);
|
|
|
|
auto start1 = std::chrono::system_clock::now();
|
|
|
|
std::vector<uchar> imageData;
|
|
bool success = cv::imencode(".jpg", frame, imageData);
|
|
if (!success) {
|
|
std::cout << "Failed to encode the image" << std::endl;
|
|
return 0;
|
|
}
|
|
std::string jpegImage(imageData.begin(), imageData.end());
|
|
|
|
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
std::string detectionResult = RunTiledInferenceFromJpegString(&infHandle, jpegImage.c_str(), imageData.size(), 640, 640, 0.2, "TestCam");
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
std::cout << "Result:" << detectionResult << std::endl;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
//cv::putText(frame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
// 0, 0.6, cv::Scalar(255, 0, 0), 1, cv::LINE_AA);
|
|
// std::cout << "Keypoints =[" << GetData<std::string>(result, "extra_info") << "]" << std::endl;
|
|
|
|
}
|
|
}
|
|
//resize(frame, frame, Size(frame.cols / 2, frame.rows / 2)); // to half size or even smaller
|
|
//namedWindow("Display frame", WINDOW_AUTOSIZE);
|
|
cv::imshow("Display frame", frame);
|
|
if (cv::waitKey(0) == 3) // Wait for 'esc' key press to exit
|
|
{
|
|
std::cout << "End of facial detection.\n";
|
|
}
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int NormalInferenceTest(std::string modelFilePath, std::string imageFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.55;
|
|
float modelConfThreshold = 5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 14;//
|
|
int detectorType = 1;
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType,1, 1);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, "", modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
|
|
cv::Mat frame = cv::imread(imageFilePath, cv::IMREAD_COLOR);
|
|
|
|
auto start1 = std::chrono::system_clock::now();
|
|
|
|
std::vector<uchar> imageData;
|
|
bool success = cv::imencode(".jpg", frame, imageData);
|
|
if (!success) {
|
|
std::cout << "Failed to encode the image" << std::endl;
|
|
return 0;
|
|
}
|
|
std::string jpegImage(imageData.begin(), imageData.end());
|
|
|
|
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
std::string detectionResult = RunInferenceFromJpegString(&infHandle, jpegImage.c_str(), imageData.size(), "TestCam");
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
std::cout << "Result:" << detectionResult << std::endl;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
/* cv::putText(frame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(255, 0, 0), 1, cv::LINE_AA);*/
|
|
// std::cout << "Keypoints =[" << GetData<std::string>(result, "extra_info") << "]" << std::endl;
|
|
|
|
}
|
|
}
|
|
//resize(frame, frame, Size(frame.cols / 2, frame.rows / 2)); // to half size or even smaller
|
|
namedWindow("Display frame", WINDOW_AUTOSIZE);
|
|
cv::imshow("Display frame", frame);
|
|
if (cv::waitKey(0) == 3) // Wait for 'esc' key press to exit
|
|
{
|
|
std::cout << "End of facial detection.\n";
|
|
}
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int TiledInferenceTest() {
|
|
std::string modelFilePath = "C:\\ProgramData\\ANSCENTER\\Shared\\ANS_GenericOD(GPU)_v1.0.zip";
|
|
std::string imageFilePath = "C:\\Programs\\DemoAssets\\Images\\SAHI\\smallobjects.jpeg";
|
|
//TiledInferenceTest(modelFilePath, imageFilePath);
|
|
NormalInferenceTest(modelFilePath, imageFilePath);
|
|
return 0;
|
|
}
|
|
int MotionDetection(std::string modelFilePath, std::string videoFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float detectionScoreThreshold = 0.2;
|
|
float modelConfThreshold = 0.48;
|
|
float modelNMSThreshold = 0.48;
|
|
int modelType = 17; // ANSFIRESMOKE
|
|
int detectorType = 1; // Detection
|
|
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), detectionScoreThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
std::cout << "classes:" << classes.size();
|
|
std::cout << "classes:" << classes.size() << std::endl;
|
|
|
|
while (true) {
|
|
std::cout << "begin read video" << std::endl;
|
|
cv::VideoCapture capture(videoFilePath);
|
|
|
|
if (!capture.isOpened()) {
|
|
printf("could not read this video file...\n");
|
|
return -1;
|
|
}
|
|
|
|
std::cout << "end read video" << std::endl;
|
|
|
|
while (true) {
|
|
cv::Mat frame;
|
|
if (!capture.read(frame)) {
|
|
std::cout << "\n Cannot read the video file. Restarting...\n";
|
|
capture.set(cv::CAP_PROP_POS_FRAMES, 0); // Reset to the beginning of the video
|
|
continue;
|
|
}
|
|
|
|
unsigned int bufferLength = 0;
|
|
//cv::Mat croppedFrame = frame(cv::Rect(0, 0, 1920, 1080));
|
|
auto start1 = std::chrono::system_clock::now();
|
|
|
|
//std::vector<uchar> imageData;
|
|
//bool success = cv::imencode(".jpg", frame, imageData);
|
|
//if (!success) {
|
|
// std::cout << "Failed to encode the image" << std::endl;
|
|
// break;
|
|
//}
|
|
//std::string jpegImage(imageData.begin(), imageData.end());
|
|
auto end1 = std::chrono::system_clock::now();
|
|
auto elapsed1 = std::chrono::duration_cast<std::chrono::milliseconds>(end1 - start1);
|
|
//printf("Conversion Time = %lld ms\n", static_cast<long long int>(elapsed1.count()));
|
|
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceFromCV(&infHandle, frame);//RunInferenceFromJpegString(&infHandle, jpegImage.c_str(), imageData.size());// , 100, 100, 0.2);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results")) {
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto prob = GetData<float>(result, "prob");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d:%.2f", classes[class_id], class_id, prob), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", frame);
|
|
if (cv::waitKey(30) == 27) { // Wait for 'esc' key press to exit
|
|
capture.release();
|
|
cv::destroyAllWindows();
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
int MotionDetectionForFireNSmoke() {
|
|
std::string cpumodelFilePath = "C:\\Projects\\ANSVIS\\Models\\ANS_FireSmoke(CPU)_v1.0.zip";
|
|
std::string gpumodelFilePath = "C:\\Projects\\ANSVIS\\Models\\ANS_FireSmoke(GPU)_v1.0.zip";
|
|
std::string videoFile = "C:\\Programs\\DemoAssets\\Videos\\FireNSmoke\\BCA2.mp4";
|
|
//std::string videoFile = "C:\\Programs\\DemoAssets\\Videos\\FireNSmoke\\Fire25m.mp4";
|
|
//std::string videoFile = "C:\\Programs\\DemoAssets\\Videos\\FireNSmoke\\fire2.mp4";
|
|
//std::string videoFile = "C:\\Programs\\DemoAssets\\Videos\\FireNSmoke\\ANSFireFull.mp4";
|
|
|
|
// std::string videoFile = "C:\\Programs\\DemoAssets\\Videos\\video_20.mp4";
|
|
// std::string videoFile = "C:\\Programs\\DemoAssets\\Videos\\road.mp4";
|
|
|
|
//GPUYolov10EngineUnitTest(gpumodel10FilePath, videoFile);// yolov10
|
|
MotionDetection(gpumodelFilePath, videoFile);//yolov10
|
|
|
|
//OpenVINOEngineUnitTest(cpumodelFilePath, videoFile);//yolov8
|
|
//GPUEngineUnitTest(gpumodelFilePath, videoFile);// yolov8
|
|
|
|
return 0;
|
|
}
|
|
int StressTest() {
|
|
std::string gpumodelFilePath = "C:\\Projects\\ANSVIS\\Models\\ANS_PeopleHead(GPU)_v1.0.zip";
|
|
std::string imageFile = "C:\\Programs\\DemoAssets\\Images\\bus.jpg";
|
|
for (int i = 0; i < 100; i++) {
|
|
std::cout << "Test:" << i << std::endl;
|
|
GPUEngineImageTest(gpumodelFilePath, imageFile);
|
|
}
|
|
|
|
}
|
|
int OpenVINOCLEngineImageTest(std::string modelFilePath, std::string imageFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.5;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 5;//OpenVINO
|
|
int detectorType = 0;// Classification
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType,1, 1);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
cv::Mat frame = cv::imread(imageFilePath, cv::IMREAD_COLOR);
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
std::cout << "Result:" << detectionResult << std::endl;
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
std::cout << "Keypoints =[" << GetData<std::string>(result, "extra_info") << "]" << std::endl;
|
|
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", frame);
|
|
if (cv::waitKey(0) == 0) // Wait for 'esc' key press to exit
|
|
{
|
|
std::cout << "End of facial detection.\n";
|
|
}
|
|
cv::destroyAllWindows();
|
|
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int TENSORRTCLEngineImageTest(std::string modelFilePath, std::string imageFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.5;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 4;//OpenVINO
|
|
int detectorType = 0;// Classification
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType,1, 1);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
cv::Mat frame = cv::imread(imageFilePath, cv::IMREAD_COLOR);
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
std::cout << "Result:" << detectionResult << std::endl;
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
std::cout << "Keypoints =[" << GetData<std::string>(result, "extra_info") << "]" << std::endl;
|
|
|
|
}
|
|
}
|
|
|
|
cv::imshow("ANS Object Tracking", frame);
|
|
if (cv::waitKey(0) == 0) // Wait for 'esc' key press to exit
|
|
{
|
|
std::cout << "End of facial detection.\n";
|
|
}
|
|
cv::destroyAllWindows();
|
|
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int TestCL() {
|
|
std::string cpumodelFilePath = "C:\\Programs\\DemoAssets\\AIModels\\ANSFireNSmokeCL(CPU).zip";
|
|
std::string gpumodelFilePath = "C:\\Programs\\DemoAssets\\AIModels\\ANSFireNSmokeCL(GPU).zip";
|
|
|
|
std::string imageFile = "C:\\Programs\\DemoAssets\\TestImages\\FireNSmoke\\smoke\\test1.jpg";
|
|
//std::string imageFile = "C:\\Programs\\DemoAssets\\Images\\bus.jpg";
|
|
TENSORRTCLEngineImageTest(gpumodelFilePath, imageFile);
|
|
}
|
|
int Engine_Test() {
|
|
std::string gpumodelFilePath = "C:\\ProgramData\\ANSCENTER\\Shared\\ANS_GenericOD(GPU)_v1.0.zip";
|
|
std::string imageFile = "C:\\ProgramData\\ANSCENTER\\Shared\\bus.jpg";
|
|
GPUEngineImageTest(gpumodelFilePath, imageFile);
|
|
}
|
|
int SegEngineImageTest(std::string modelFilePath, std::string imageFilePath) {
|
|
boost::property_tree::ptree root;
|
|
boost::property_tree::ptree detectionObjects;
|
|
boost::property_tree::ptree pt;
|
|
std::vector<std::string> classes;
|
|
std::filesystem::path currentPath = std::filesystem::current_path();
|
|
ANSCENTER::ANSODBase* infHandle;
|
|
std::string labelMap;
|
|
std::string licenseKey = "";
|
|
std::string modelZipFilePassword = "";
|
|
float modelThreshold = 0.5;
|
|
float modelConfThreshold = 0.5;
|
|
float modelNMSThreshold = 0.5;
|
|
int modelType = 5;//OpenVINO
|
|
int detectorType = 2;// Segmentation
|
|
std::string optmizedModelFolder;
|
|
// Optimise model
|
|
std::cout << "Optimizing model, please wait...." << std::endl;
|
|
optmizedModelFolder = OptimizeModelStr(modelFilePath.c_str(), modelZipFilePassword.c_str(), modelType, 1,1);
|
|
std::cout << "Model is optmized, run inference...." << std::endl;
|
|
labelMap = CreateANSODHandle(&infHandle, licenseKey.c_str(), modelFilePath.c_str(), modelZipFilePassword.c_str(), modelThreshold, modelConfThreshold, modelNMSThreshold, 1, modelType, detectorType);
|
|
std::stringstream ss(labelMap);
|
|
|
|
while (ss.good())
|
|
{
|
|
std::string substr;
|
|
getline(ss, substr, ',');
|
|
classes.push_back(substr);
|
|
}
|
|
cv::Mat frame = cv::imread(imageFilePath, cv::IMREAD_COLOR);
|
|
unsigned int bufferLength = 0;
|
|
unsigned char* jpeg_string = ANSCENTER::ANSUtilityHelper::CVMatToBytes(frame, bufferLength);
|
|
int height = frame.rows;
|
|
int width = frame.cols;
|
|
auto start = std::chrono::system_clock::now();
|
|
/* measured work */
|
|
std::string detectionResult = RunInferenceBinary(&infHandle, jpeg_string, width, height);
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
printf("Time = %lld ms\n", static_cast<long long int>(elapsed.count()));
|
|
std::cout << "Result:" << detectionResult << std::endl;
|
|
delete jpeg_string;
|
|
|
|
if (!detectionResult.empty()) {
|
|
pt.clear();
|
|
std::stringstream ss;
|
|
ss.clear();
|
|
ss << detectionResult;
|
|
boost::property_tree::read_json(ss, pt);
|
|
BOOST_FOREACH(const boost::property_tree::ptree::value_type & child, pt.get_child("results"))
|
|
{
|
|
const boost::property_tree::ptree& result = child.second;
|
|
const auto class_id = GetData<int>(result, "class_id");
|
|
const auto x = GetData<float>(result, "x");
|
|
const auto y = GetData<float>(result, "y");
|
|
const auto width = GetData<float>(result, "width");
|
|
const auto height = GetData<float>(result, "height");
|
|
cv::rectangle(frame, cv::Rect(x, y, width, height), 123, 2);
|
|
cv::putText(frame, cv::format("%s:%d", classes[class_id], class_id), cv::Point(x, y - 5),
|
|
0, 0.6, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
|
|
std::cout << "Keypoints =[" << GetData<std::string>(result, "extra_info") << "]" << std::endl;
|
|
|
|
}
|
|
}
|
|
|
|
//cv::imshow("ANS Object Tracking", frame);
|
|
//if (cv::waitKey(0) == 0) // Wait for 'esc' key press to exit
|
|
//{
|
|
// std::cout << "End of facial detection.\n";
|
|
//}
|
|
cv::destroyAllWindows();
|
|
|
|
ReleaseANSODHandle(&infHandle);
|
|
std::cout << "End of program.\n";
|
|
return 0;
|
|
}
|
|
int SegmentationTest() {
|
|
std::string segmodelFilePath = "C:\\Programs\\TrainingToolTest\\SegmentationEngine\\SegmeTxtYolo\\Models\\ANS_MySegmentation(CPU)_1.zip";
|
|
// std::string segmodelFilePath = "C:\\Programs\\TrainingToolTest\\SegmentationEngine\\SegmeTxtYolo\\Models\\Yolov8\\ANS_MySegmentation(CPU)_1.zip";
|
|
std::string imageFile = "C:\\Programs\\TrainingToolTest\\SegmentationEngine\\SegmeTxtYolo\\data\\20241220_173948_695.jpg";
|
|
//std::string imageFile = "C:\\Programs\\DemoAssets\\Images\\bus.jpg";
|
|
SegEngineImageTest(segmodelFilePath, imageFile);
|
|
}
|
|
int LocSetTest() {
|
|
std::string gpumodelFilePath = "C:\\Programs\\LocSet\\LocSetGPU_v1.0.zip";
|
|
std::string cpumodelFilePath = "C:\\Programs\\LocSet\\LocSetCPU_v1.0.zip";
|
|
std::string yolov8ModeFilePath = "C:\\Programs\\Yolov8\\Yolov8_General\\ANS_GenericODM.zip";//"C:\\Programs\\LocSet\\LocSet_v1.0.zip";//
|
|
std::string videoFilePath = "C:\\Programs\\LocSet\\loc_set 1.mp4";
|
|
std::string videoFile = "C:\\Programs\\DemoAssets\\Videos\\video_20.mp4";
|
|
Yolov8EngineUnitTest(yolov8ModeFilePath, videoFile);
|
|
//GPUEngineUnitTest(gpumodelFilePath, videoFilePath);
|
|
//OpenVINOEngineUnitTest(cpumodelFilePath, videoFilePath);
|
|
//GPUYolov10EngineUnitTest(cpumodelFilePath, videoFilePath);
|
|
}
|
|
int PPETest() {
|
|
//std::string gpumodelFilePath = "C:\\Programs\\DemoAssets\\ANSAIModels\\Models\\PPEGPU.zip";
|
|
std::string gpumodelFilePath = "C:\\Programs\\Yolov8\\ANS_PPE(GPU)_v3.0.zip";
|
|
std::string videoFilePath = "C:\\Programs\\DemoAssets\\Videos\\Factory1.mp4";
|
|
Yolov8EngineUnitTest(gpumodelFilePath, videoFilePath);
|
|
return 1;
|
|
|
|
}
|
|
int RectifierTest() {
|
|
|
|
std::string Yolov5Model = "C:\\Programs\\Yolov5\\Rectifier_v1.zip";
|
|
std::string videoFilePath = "C:\\Programs\\Yolov5\\rectifier.mp4";
|
|
//std::string videoFile = "C:\\Programs\\DemoAssets\\Videos\\video_20.mp4";
|
|
//GPUEngineUnitTest(yolov5ModeFilePaht, videoFile);//
|
|
Yolov5EngineUnitTest(Yolov5Model, videoFilePath);
|
|
}
|
|
int FaceTest() {
|
|
std::string facemodeFile = "C:\\ProgramData\\ANSCENTER\\Shared\\ANS_GenericFD(GPU)_v1.0.zip";
|
|
std::string video = "C:\\Programs\\DemoAssets\\Videos\\BMIP.mp4";
|
|
FaceDetector(facemodeFile, video);
|
|
return 0;
|
|
}
|
|
int FaceOVTest() {
|
|
std::string facemodeFile = "C:\\ProgramData\\ANSCENTER\\Shared\\ANS_GenericFD(CPU)_v1.0.zip";
|
|
std::string imagePath = "C:\\Programs\\DemoAssets\\TestImages\\Face\\Hoang2.jpg";// "C:\\Programs\\DemoAssets\\Images\\Tien\\80.jpg";
|
|
FacialDetectorTest(facemodeFile, imagePath);// yolov8
|
|
return 0;
|
|
}
|
|
int FaceYoloTest() {
|
|
std::string facecpumodeFile = "C:\\Projects\\ANSVIS\\Models\\ANS_Face(CPU)_v1.0.zip";
|
|
std::string facegpumodeFile = "C:\\Projects\\ANSVIS\\Models\\ANS_Face(GPU)_v1.0.zip";
|
|
std::string video = "C:\\Programs\\DemoAssets\\Videos\\classroom.mp4";
|
|
OpenVINOEngineUnitTest(facecpumodeFile, video);//yolov8
|
|
// GPUEngineUnitTest(facegpumodeFile, video);// yolov8
|
|
return 0;
|
|
}
|
|
int Yolov11RT_Test() {
|
|
std::string gpumodelFilePath = "C:\\Users\\nghia\\Downloads\\Generic11GPU.zip";// "C:\\Programs\\DemoAssets\\AIModels\\ANS_PersonHead(GPU)_1.zip";
|
|
std::string cpumodelFilePath = "C:\\Programs\\DemoAssets\\AIModels\\ODv11nCPUGeneric.zip";
|
|
|
|
std::string imageFile = "C:\\Programs\\DemoAssets\\Images\\bus.jpg";
|
|
std::string videoFile = "C:\\Programs\\DemoAssets\\Videos\\video_20.mp4";
|
|
std::string videoFilePath = "C:\\Programs\\DemoAssets\\Videos\\classroom.mp4";
|
|
|
|
// GPU11EngineImageTest(gpumodelFilePath, imageFile);
|
|
GPUEngineUnitTest(gpumodelFilePath, videoFile);
|
|
//OpenVINOEngineUnitTest(cpumodelFilePath, videoFile);
|
|
}
|
|
int Yolov10RT_Test() {
|
|
std::string gpumodelFilePath = "C:\\ProgramData\\ANSCENTER\\Shared\\ANS_GenericOD(GPU)_v1.0.zip";
|
|
std::string videoFilePath = "C:\\Programs\\DemoAssets\\Videos\\classroom.mp4";
|
|
GPUYolov10EngineUnitTest(gpumodelFilePath, videoFilePath);
|
|
|
|
}
|
|
|
|
int TestYOLOV12() {
|
|
std::string modelPath = "C:\\Programs\\Yolov12\\GenericYolov12.zip";
|
|
std::string videoFile = "C:\\Programs\\DemoAssets\\Videos\\FireNSmoke\\SimFire.mp4";
|
|
Yolov12EngineUnitTest(modelPath, videoFile);
|
|
}
|
|
int GenericModelTest() {
|
|
//std::string cpumodelFilePath = "C:\\ProgramData\\ANSCENTER\\Shared\\ANS_GenericOD(CPU)_v1.0.zip";
|
|
std::string gpumodelFilePath = "C:\\ProgramData\\ANSCENTER\\Shared\\ANS_GenericOD(GPU)_v1.0.zip";// "C:\\ProgramData\\ANSCENTER\\ANSVIS Server\\Models\\B-IN_ANS_PeopleHead(GPU)_v1.0_54a7944906d79395a9840945d3c24b9a.zip";// "C:\\ProgramData\\ANSCENTER\\Shared\\ANS_GenericOD(GPU)_v1.0.zip";
|
|
//std::string gpumodelFilePath = "C:\\ProgramData\\ANSCENTER\\ANSVIS Server\\Models\\ServerOptimised\\B-IN_ANS_GenericOD(GPU)_v1.0_101944350_NVIDIAGeForceRTX4070LaptopGPU.zip";
|
|
std::string videoFile = "E:\\Programs\\DemoAssets\\Videos\\TestFR\\school1.mp4";
|
|
//OpenVINOYolov10EngineUnitTest(cpumodelFilePath, videoFile);//yolov10
|
|
GPUYolov10EngineUnitTest(gpumodelFilePath, videoFile);//yolov10
|
|
return 0;
|
|
}
|
|
int PersonHead() {
|
|
std::string cpumodelFilePath = "C:\\Projects\\ANSVIS\\Models\\ANS_PeopleHead(CPU)_v1.0.zip";
|
|
std::string gpumodelFilePath = "C:\\Projects\\ANSVIS\\Models\\ANS_PeopleHead(CPU)_v1.0.zip";
|
|
std::string videoFile = "C:\\Programs\\DemoAssets\\Videos\\video_20.mp4";
|
|
OpenVINOEngineUnitTest(cpumodelFilePath, videoFile);//yolov8
|
|
return 0;
|
|
}
|
|
int RVATest() {
|
|
std::string rvamodelFilePath = "C:\\Programs\\Braemac\\BR_RVA\\Models\\ANS_BR_RVA(GPU)_1.zip";
|
|
std::string rvaImageFile = "C:\\Programs\\Braemac\\TestData\\2025-07-29-122338.jpg";
|
|
GPU11EngineImageTest(rvamodelFilePath, rvaImageFile);
|
|
return 0;
|
|
}
|