wangchongwu
/
StdTracker_Board_App
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'be948f7bab'
${ noResults }
StdTracker_Board_App/hi3403/demo/AI_API_demo.cpp

1358 lines
46 KiB
Raw Normal View History Unescape

包含目标识别和目标跟踪的流水线式调用仿真 HI3403
3 weeks ago
/*
* @Author: turboLIU
* @Date: 2023-06-12 14:13:24
* @LastEditTime: 2025-06-26 09:36:32
* @Description: Do not edit
* @FilePath: /Algo_ACL_Common/demo/AI_API_demo.cpp
*/
// #include <type_traits>
#include <unistd.h>
#include <thread>
#include <sys/time.h>
#include <dirent.h>
#include <sys/stat.h>
// #include <pthread.h>
#include "AI_API.h"
#include "detection_type_api.h"
// #include "environment.h"
#include "opencv2/opencv.hpp"
// #include "utils.h"
#define IMAGECOUNT 500
// #define IMAGEWIDTH 512
// #define IMAGEHEIGHT 512
#define GSTREAM NV12
#define IMAGEWIDTH_VIS 1920
#define IMAGEHEIGHT_VIS 1088
#define IMAGEWIDTH_IR 640
#define IMAGEHEIGHT_IR 512
#define InitWithJson 1
#define UseGDVideoFrame 0
// #define TESTIMAGEVIS "../models/Detect/quantImages/1488264581.jpg"
// #define TESTIMAGEIR "../models/Detect/quantImages/webwxgetmsgimg.jpeg"
// static bool TESTVIS = false;
// static bool TESTIR = false;
static std::string VIDEONAME = "1970010100052511";
static std::string IMGFOLDER = "../models/Detect/test_images/" + VIDEONAME;
static std::string DSTFOLDER = "./results/";
// std::vector<std::string> imgnames;
bool stopFlag = false;
static unsigned char SegDet_Colors[36] = {255,0,0, 0,255,0, 0,0,255,
100,100,0, 0,100,100, 100,0,100,
100,100,100, 50,100,50, 50,50,100,
100,50,50, 20,60,120, 120,60,20};
int GetDirNames(std::string dirpath, std::vector<std::string> &filenames){
DIR* pdir;
struct dirent *ptr;
int ret;
pdir = opendir(dirpath.c_str());
if(!pdir){
printf("dripath not exist, path: %s\n", dirpath.c_str());
return -1;
}
while ((ptr = readdir(pdir)) != NULL)
{
if(strcmp(ptr->d_name, ".") != 0 && strcmp(ptr->d_name, "..") != 0){
filenames.push_back(dirpath + "/" + ptr->d_name);
}
}
closedir(pdir);
return 0;
}
float getDtimeMiliSecond(timeval starttime, timeval endtime){
float dtime;
dtime = 1000000 * (endtime.tv_sec - starttime.tv_sec) + (endtime.tv_usec - starttime.tv_usec);
dtime = dtime/1000000;
return dtime * 1000;
}
std::vector<int> get_color(int cls){
cls += 1;
int stride = 200;
std::vector<int> clr = {0,0,0};
for(int k=0; k<cls; k++){
int i = k % 3;
clr[i] += stride;
}
for(int k = 0; k< 3; k++){
clr[k] = clr[k] %255;
}
return clr;
}
void draw_dotted_line(cv::Mat img, cv::Point2f p1, cv::Point2f p2, cv::Scalar color, int thickness)
{
float n = 15; //虚点间隔
float w = p2.x - p1.x, h = p2.y - p1.y;
float l = sqrtf(w * w + h * h);
int m = l / n;
n = l / m; // 矫正虚点间隔，使虚点数为整数
cv::circle(img, p1, 1, color, thickness); // 画起点
cv::circle(img, p2, 1, color, thickness); // 画终点
// 画中间点
if (p1.y == p2.y) // 水平线：y = m
{
float x1 = std::min(p1.x, p2.x);
float x2 = std::max(p1.x, p2.x);
for (float x = x1 + n; x < x2; x = x + n)
cv::circle(img, cv::Point2f(x, p1.y), 1, color, thickness);
}
else if (p1.x == p2.x) // 垂直线, x = m
{
float y1 = std::min(p1.y, p2.y);
float y2 = std::max(p1.y, p2.y);
for (float y = y1 + n; y < y2; y = y + n)
cv::circle(img, cv::Point2f(p1.x, y), 1, color, thickness);
}
else // 倾斜线，与x轴、y轴都不垂直或平行
{
// 直线方程的两点式：(y-y1)/(y2-y1)=(x-x1)/(x2-x1) -> y = (y2-y1)*(x-x1)/(x2-x1)+y1
float m = n * abs(w) / l;
float k = h / w;
float x1 = std::min(p1.x, p2.x);
float x2 = std::max(p1.x, p2.x);
for (float x = x1 + m; x < x2; x = x + m)
cv::circle(img, cv::Point2f(x, k * (x - p1.x) + p1.y), 1, color, thickness);
}
}
void draw_dotted_rect(cv::Mat img, cv::Point2f p1, cv::Point2f p2, cv::Scalar color, int thickness){
cv::Point2f lt(p1.x, p1.y);
cv::Point2f rt(p2.x, p1.y);
cv::Point2f lb(p1.x, p2.y);
cv::Point2f rb(p2.x, p2.y);
draw_dotted_line(img, lt, rt, color, thickness);
draw_dotted_line(img, rt, rb, color, thickness);
draw_dotted_line(img, lb, rb, color, thickness);
draw_dotted_line(img, lt, lb, color, thickness);
return;
}
void swapYUV_I420toNV12(unsigned char* i420bytes, unsigned char* nv12bytes, int width, int height)
{
int nLenY = width * height;
int nLenU = nLenY / 4;
memcpy(nv12bytes, i420bytes, width * height);
for (int i = 0; i < nLenU; i++)
{
nv12bytes[nLenY + 2 * i] = i420bytes[nLenY + i]; // U
nv12bytes[nLenY + 2 * i + 1] = i420bytes[nLenY + nLenU + i]; // V
}
}
void BGR2YUV_nv12(cv::Mat src, cv::Mat &dst)
{
int w_img = src.cols;
int h_img = src.rows;
dst = cv::Mat(h_img*1.5, w_img, CV_8UC1, cv::Scalar(0));
cv::Mat src_YUV_I420(h_img*1.5, w_img, CV_8UC1, cv::Scalar(0)); //YUV_I420
cvtColor(src, src_YUV_I420, cv::COLOR_BGR2YUV_I420);
swapYUV_I420toNV12(src_YUV_I420.data, dst.data, w_img, h_img);
}
template<typename T>
int draw_mask(cv::Mat &showImg, TenMat* mask){
float alpha = 0.5;
int inwidth = mask->width;
int inheight = mask->height;
int depth = showImg.channels();
T* maskdata = (T*)mask->data;
for(int i=0; i<inheight; i++){
for(int j=0; j<inwidth; j++){
uint8_t uvalue = (uint8_t)maskdata[i*inwidth + j];
std::vector<int> color = get_color(uvalue);
for(int k=0; k<depth; k++){
showImg.data[i*inwidth*depth + j*depth + k] \
= (uint8_t)((1-alpha)*showImg.data[i*inwidth*depth + j*depth + k] + alpha * color.at(k));
}
}
}
return 0;
}
int draw_dets(cv::Mat &showImg, std::vector<objinfo> dets){
int ret = 0;
for(auto det: dets){
int x1 = det.x1;
int x2 = det.x2;
int y1 = det.y1;
int y2 = det.y2;
int cls = det.classNum;
std::vector<int> color = {SegDet_Colors[3*cls + 0], SegDet_Colors[3*cls + 1], SegDet_Colors[3*cls + 2]};//get_color(cls);
cv::rectangle(showImg, cv::Point(x1,y1), cv::Point(x2,y2), cv::Scalar(color[0],color[1],color[2]),2);
// draw_dotted_rect(resizedImg, cv::Point2f(det.x1, det.y1), cv::Point2f(det.x2, det.y2), cv::Scalar(color[0],color[1],color[2]),4);
char name[50];
sprintf(name, "%d_%.3f", det.classNum, det.score);
cv::putText(showImg, name, cv::Point(x1,y1), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(color[0],color[1],color[2]), 4);
}
return ret;
}
int test_class(){
int ret = 0;
// bool initWithJson = true;
// bool useGDVideo = true;
std::string visdetmodelname = "../models/Detect/atlas200/xh.xu/507A_IR_20241111_dynamic.om";
std::string visdetparamname = "../models/Detect/atlas200/xh.xu/507A_IR_20241111_dynamic.json";
// build class
DETECTION_API* detAPI = new DETECTION_API();
if(InitWithJson){
ret = detAPI->AIGOinit(visdetmodelname.c_str(), visdetparamname.c_str(), 0);
}else{
detAPI->netWidth = 640;
detAPI->netHeight = 640;
detAPI->clsnum = 15;
detAPI->anchors = {{10,13, 16,30, 33,23},{30,61, 62,45, 59,119},{116,90, 156,198, 373,326}};
// 标签标请咨询对应的算法工程师
uint32_t modelclass[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14};
uint32_t standerclass[] = {10000, 20000, 30000, 40000, 50000,
60000, 70000, 80000, 90000, 100000,
110000, 120000, 130000, 140000, 150000};
ret = detAPI->AIGOinit(visdetmodelname.c_str(), 0);
if(ret){
printf("init error with ret=%d\n", ret);
return ret;
}
ret = detAPI->AIGOsetLabelMap(modelclass, standerclass, sizeof(modelclass)/sizeof(uint32_t));
if(ret){
printf("setLabelMap error with ret=%d\n", ret);
return ret;
}
}
std::string visdetimgname = "../models/Detect/quantImages/IR_test_tank.avi_000147.jpg";
std::string vissegimgname = "../models/Segment/test_images_vl/20230704_102059.MP4_20230711_195345.335.bmp";
float timecost = 0;
float durtime = 0;
struct timeval st, et;
cv::Mat visdetImage = cv::imread(visdetimgname);
cv::cvtColor(visdetImage, visdetImage, cv::COLOR_BGR2RGB);
if(visdetImage.empty()){
printf("read image error %s\n", visdetimgname.c_str());
return 1;
}
cv::Mat visdetresize, vissegresize;
cv::resize(visdetImage, visdetresize, cv::Size(detAPI->netWidth, detAPI->netHeight));
// char* zerosInput = (char*)malloc(visdetresize.cols*visdetresize.rows*visdetresize.channels() * sizeof(char));
cv::Mat NV12Matvis, NV12Matir;
// convert BGR to NV12
BGR2YUV_nv12(visdetresize, NV12Matvis);
std::vector<objinfo> dets;
GD_VIDEO_FRAME_S* config = (GD_VIDEO_FRAME_S*)malloc(sizeof(GD_VIDEO_FRAME_S));
for(int i =0; i<1; i++){
ImgMat imgvis;
if(UseGDVideoFrame){
if(GSTREAM == NV12){
imgvis.data = NULL;
imgvis.inlayout = NV12;
imgvis.depth = 1;
// Y
config->u64VirAddr[0] = NV12Matvis.data;
// UV
config->u64VirAddr[1] = NV12Matvis.data + visdetresize.cols * visdetresize.rows;
config->u32Stride[0] = visdetresize.cols;
config->u32Stride[1] = visdetresize.rows;
}else if(GSTREAM == RGB || GSTREAM == BGR){
imgvis.data = NULL;
imgvis.inlayout = RGB;
imgvis.depth = visdetresize.channels();
config->u64VirAddr[0] = visdetresize.data;
config->u32Stride[0] = visdetresize.cols;
}
imgvis.width = visdetresize.cols;
imgvis.height = visdetresize.rows;
imgvis.layout = HWC;
imgvis.mode = VIS;
imgvis.timestamp = i;
imgvis.cfg = (long long)config;
}else{
if(GSTREAM == NV12){
imgvis.data = NV12Matvis.data;
imgvis.inlayout = NV12;
imgvis.depth = 1;
}else if(GSTREAM == RGB || GSTREAM == BGR){
imgvis.data = visdetresize.data;
imgvis.inlayout = RGB;
imgvis.depth = visdetresize.channels();
}
imgvis.width = visdetresize.cols;
imgvis.height = visdetresize.rows;
imgvis.layout = HWC;
imgvis.mode = VIS;
imgvis.timestamp = i;
imgvis.cfg = (long long)config;
}
// printf("loop ImgMat * %p", &img);
gettimeofday(&st, NULL);
// imgvis.data = (unsigned char*)zerosInput;
dets.clear();
ret = detAPI->AIGOpreprocess(imgvis, true);
ret = detAPI->AIGOinfer();
ret = detAPI->AIGOpostprocess(dets);
printf("result dets %d\n", dets.size());
gettimeofday(&et, NULL);
durtime = getDtimeMiliSecond(st, et);
printf("runsync cost: %.3f", durtime);
timecost += durtime;
}
printf("avg timecost is: %f\n", timecost/IMAGECOUNT);
for(auto d : dets){
std::vector<int> color = get_color(d.classNum);
cv::rectangle(visdetresize, cv::Point2d(d.x1, d.y1), cv::Point2d(d.x2, d.y2), cv::Scalar(color.at(0), color.at(1), color.at(2)), 2);
char name[50];
sprintf(name, "%d_%.4f", d.classNum, d.score);
cv::putText(visdetresize, name, cv::Point2d(d.x1, d.y1), cv::FONT_HERSHEY_COMPLEX, 1, cv::Scalar(color.at(0), color.at(1), color.at(2)), 1);
// cv::putText(img, )
}
cv::imwrite("./result.jpg", visdetresize);
ret = detAPI->AIGOdeinit();
printf("\n---------------------current model size: %dx%d\n", visdetresize.cols, visdetresize.rows);
printf("\n-----------end--------------\n");
sleep(2);
}
template<typename T>
void run_folder(T* classor, std::string imgfolder){
int ret = 0;
std::vector<std::string> imgnames;
ret = GetDirNames(imgfolder, imgnames);
if(ret){
printf("get images error\n");
exit(1);
}
std::sort(imgnames.begin(), imgnames.end());
struct timeval st,et;
float durtime = 0;
for(int i=0; i<imgnames.size(); i++){
GD_VIDEO_FRAME_S* config = (GD_VIDEO_FRAME_S*)malloc(sizeof(GD_VIDEO_FRAME_S));
gettimeofday(&st, NULL);
cv::Mat img = cv::imread(imgnames.at(i));
int ww = img.cols;
int hh = img.rows;
cv::Mat resizeImage;
cv::resize(img, resizeImage, cv::Size(960,768));
cv::Rect roi(960/2 - 512/2, 768/2-512/2, 512,512);
cv::Mat roiImg = resizeImage(roi);
cv::Mat NV12Mat;
BGR2YUV_nv12(roiImg, NV12Mat);
ImgMat frame;
frame.data = NV12Mat.data;
frame.width = roiImg.cols;
frame.height = roiImg.rows;
frame.depth = 1;
frame.layout = HWC;
frame.inlayout = NV12;
frame.mode = IR;
config->u32FrameCnt = i;
config->u32Width = frame.width;
config->u32Height = frame.height;
frame.cfg = (long long)config;
gettimeofday(&et, NULL);
durtime = getDtimeMiliSecond(st, et);
if(durtime < 40){
usleep((40 - durtime)*1000); // 满足25hz的帧间隔
}
ret = classor->AIGOrunAsync(frame, true);
if(ret){
printf("\nERROR\n");
}
// sleep(0.04);
}
stopFlag = true;
// free(config);
}
template<typename T>
void get_folder_result(T* classor, std::string imgfolder){
int ret = 0;
std::vector<std::string> imgnames;
ret = GetDirNames(imgfolder, imgnames);
std::sort(imgnames.begin(), imgnames.end());
std::string dstpath = DSTFOLDER;
std::vector<objinfo> dets;
TenMat* mask = (TenMat*)malloc(sizeof(TenMat));
mask->data = (void*)malloc(2000*2000*3); // 尽量分配足够空间
mask->dataByte = 2000*2000*3;
float alpha = 0.5;
bool drawed = true;
int timestamp = 0;
long long cfg = 0;
int last_timestamp = 0;
GD_VIDEO_FRAME_S* config = NULL;
while (timestamp + 1 < imgnames.size())
{
sleep(0.01);
if constexpr (std::is_same<T, DETECTION_API>::value){
dets.clear();
ret = classor->AIGOgetResult(cfg, dets, true);
if(ret == -1)break;
if(ret == 0){
config = (GD_VIDEO_FRAME_S*)cfg;
cv::Mat im = cv::imread(imgnames.at(config->u32FrameCnt));
timestamp = config->u32FrameCnt;
printf("\ntimestamp: %d get result -------\n", timestamp);
last_timestamp = timestamp;
// dets.insert(dets.end(), visdets.begin(), visdets.end());
if(drawed){
printf("get_result det=%d\n", dets.size());
cv::Mat showImg;
cv::resize(im, showImg, cv::Size(config->u32Width, config->u32Height));
ret = draw_dets(showImg, dets);
char savename[100];
sprintf(savename, "%s/%08d.jpg", dstpath.c_str(), timestamp);
cv::imwrite(savename, showImg);
// drawed = false;
}
free(config);
}
if(ret == 1){
usleep(10);
}
}else if constexpr(std::is_same<T, SEGMENTION_API>::value){
ret = classor->AIGOgetResult(cfg, mask, true);
if(ret == -1)break;
if(ret == 0){
config = (GD_VIDEO_FRAME_S*)cfg;
cv::Mat im = cv::imread(imgnames.at(config->u32FrameCnt));
timestamp = config->u32FrameCnt;
printf("\ntimestamp: %d get result -------\n", timestamp);
last_timestamp = timestamp;
cv::Mat showImg;
cv::resize(im, showImg, cv::Size(config->u32Width, config->u32Height));
if(drawed){
if(mask->type == AI_FLOAT){
ret = draw_mask<float>(showImg, mask);
}else if(mask->type == AI_UINT8){
ret = draw_mask<uint8_t>(showImg, mask);
}else if(mask->type == AI_INT32){
ret = draw_mask<int32_t>(showImg, mask);
}
if(ret){
printf("draw mask error\n");
}
// drawed = false;
char savename[100];
sprintf(savename, "%s/%08d.jpg", dstpath.c_str(), timestamp);
cv::imwrite(savename, showImg);
}
free(config);
}else if(ret == 1){
usleep(10);
}
free(mask->data);
free(mask);
}else{
return;
}
}
}
template<typename T>
void run_image_(T* classor, ImgMat img){
int ret = 0;
GD_VIDEO_FRAME_S* config = (GD_VIDEO_FRAME_S*)img.cfg;
for(int i=0; i<IMAGECOUNT; i++){
// config->u32FrameCnt = i;
// img.cfg = (long long)config;
// if(i == IMAGECOUNT/2){
// printf("\n-------sleeping 60seconds--------\n");
// sleep(60);
// }
config->u32FrameCnt = i;
img.cfg = (long long)config;
ret = classor->AIGOrunAsync(img, false);
if(ret){
printf("\nERROR\n");
}
sleep(0.5);
}
stopFlag = true;
// free(config);
}
template<typename T>
void run_image_sync(T* classor, ImgMat img){
int ret = 0;
cv::Mat showImg;
bool draw = true;
std::vector<objinfo> dets;
// GD_VIDEO_FRAME_S* config = (GD_VIDEO_FRAME_S*)img.cfg;
for(int i=0; i<IMAGECOUNT; i++){
dets.clear();
ret = classor->AIGOpreprocess(img, true);
ret = classor->AIGOinfer();
ret = classor->AIGOpostprocess(dets);
if(ret){
printf("\nERROR\n");
}
sleep(0.5);
}
// if(draw){
// if(GSTREAM == NV12){
// cv::Mat nv12Mat(int(img.height*1.5), img.width, CV_8UC1, img.data);
// cv::cvtColor(nv12Mat, showImg, cv::COLOR_YUV2BGR_NV12);
// }else{
// showImg = cv::Mat(cv::Size(img.height, img.width), CV_8UC3, img.data);
// }
// ret = draw_dets(showImg, dets);
// cv::imwrite("./result.jpg", showImg);
// draw = false;
// }
}
template<typename T>
void get_result_(T* classor, ImgMat img){
int ret = 0;
cv::Mat showImg;
void* data = (void*)malloc(img.width*img.height*3);
if(UseGDVideoFrame){
GD_VIDEO_FRAME_S * config = (GD_VIDEO_FRAME_S*)img.cfg;
if(GSTREAM == NV12){
printf("memcpy Y\n");
for(int i=0; i<img.height; i++){
memcpy(data+i*img.width,
config->u64VirAddr[0]+i*config->u32Stride[0],
img.width);
}
printf("memcpy UV\n");
for(int i=0; i<img.height/2; i++){
memcpy(data+img.width*img.height + i*img.width,
config->u64VirAddr[1]+i*config->u32Stride[1],
img.width);
}
cv::Mat nv12Mat(int(img.height*1.5), img.width, CV_8UC1, data);
cv::cvtColor(nv12Mat, showImg, cv::COLOR_YUV2BGR_NV12);
}else{
showImg = cv::Mat(cv::Size(img.height, img.width), CV_8UC3, config->u64VirAddr[0]);
}
}else{
if(GSTREAM == NV12){
cv::Mat nv12Mat(int(img.height*1.5), img.width, CV_8UC1, img.data);
cv::cvtColor(nv12Mat, showImg, cv::COLOR_YUV2BGR_NV12);
}else{
showImg = cv::Mat(cv::Size(img.height, img.width), CV_8UC3, img.data);
}
}
bool drawed = false;
int timestamp = 0;
long long cfg = 0;
int last_timestamp = 0;
GD_VIDEO_FRAME_S* config = NULL;
while (timestamp+1 < IMAGECOUNT)
{
sleep(0.01);
if constexpr (std::is_same<T, DETECTION_API>::value){
std::vector<objinfo> dets;
ret = classor->AIGOgetResult(cfg, dets, true);
if(ret == -1)break;
if(ret == 0){
// dets.insert(dets.end(), visdets.begin(), visdets.end());
if(drawed){
printf("get_result det=%d\n", dets.size());
ret = draw_dets(showImg, dets);
cv::imwrite("./result.jpg", showImg);
drawed = false;
}
config = (GD_VIDEO_FRAME_S*)cfg;
timestamp = config->u32FrameCnt;
printf("\ntimestamp: %d get result -------\n", timestamp);
last_timestamp = timestamp;
}
if(ret == 1){
usleep(10);
}
}else if constexpr(std::is_same<T, SEGMENTION_API>::value){
TenMat* mask = (TenMat*)malloc(sizeof(TenMat));
// mask->width = img.width;
// mask->height = img.height;
// mask->depth = 1;
// mask->dataByte = mask->height*mask->width*sizeof(float); //
mask->data = (void*)malloc(2000*2000*3); // 尽量分配足够空间
mask->dataByte = 2000*2000*3;
float alpha = 0.5;
ret = classor->AIGOgetResult(cfg, mask, true);
if(ret == -1)break;
if(ret == 0){
if(drawed){
if(mask->type == AI_FLOAT){
ret = draw_mask<float>(showImg, mask);
}else if(mask->type == AI_UINT8){
ret = draw_mask<uint8_t>(showImg, mask);
}else if(mask->type == AI_INT32){
ret = draw_mask<int32_t>(showImg, mask);
}
if(ret){
printf("draw mask error\n");
// return ret;
}
drawed = false;
cv::imwrite("../models/Segment/result1.jpg", showImg);
}
config = (GD_VIDEO_FRAME_S*)cfg;
timestamp = config->u32FrameCnt;
printf("\ntimestamp: %d get result -------\n", timestamp);
last_timestamp = timestamp;
}else if(ret == 1){
usleep(10);
}
free(mask->data);
free(mask);
}else{
return;
}
}
}
template<typename T>
void run_image_cfg(T* detector, ImgMat img){
int ret = 0;
GD_VIDEO_FRAME_S* config = (GD_VIDEO_FRAME_S*)malloc(sizeof(GD_VIDEO_FRAME_S));
ImgMat tmpimg;
memcpy(&tmpimg, &img, sizeof(ImgMat));
for(int i=0; i<IMAGECOUNT; i++){
if(GSTREAM == RGB || GSTREAM == BGR){
config->u64VirAddr[0] = tmpimg.data;
config->u32Stride[0] = tmpimg.width;
img.data = NULL;
}else if(GSTREAM == NV12 || GSTREAM == NV21){
config->u64VirAddr[0] = tmpimg.data;
config->u64VirAddr[1] = (unsigned char*)tmpimg.data + tmpimg.width*tmpimg.height;
config->u32Stride[0] = tmpimg.width;
config->u32Stride[1] = tmpimg.width;
img.data = NULL;
}else{
printf("\nGSTREAM not support\n");
exit(1);
}
config->u32FrameCnt = i;
img.cfg = (long long)config;
// img.cfg = i;
printf("\n------cfg %p--%p--%p--\n", img.cfg, config->u64VirAddr[0], config->u64VirAddr[1]);
ret = detector->AIGOrunAsync(img, false);
if(ret){
printf("\nERROR\n");
}
// sleep(1);
}
stopFlag = true;
free(config);
}
int test_class_async(){
int ret = 0;
// bool InitWithJson = false;
// bool useGDVideo = true;
std::string imgname = "../models/Detect/quantImages/1488264581.jpg";
std::string modelname = "../models/Detect/1684x/vis_common_headers_1280x1024_bm1684x_F16_false.bmodel";
std::string paramname = "../models/Detect/1684x/vis_common_headers_1280x1024_bm1684x_F16_false.json";
// build class
DETECTION_API* detAPI = new DETECTION_API();
if(InitWithJson){
ret = detAPI->AIGOinit(modelname.c_str(), paramname.c_str(), 0);
}else{
detAPI->netWidth = 512;
detAPI->netHeight = 512;
detAPI->clsnum = 15;
// detAPI->anchors = {{10,13, 16,30, 33,23},{30,61, 62,45, 59,119},{116,90, 156,198, 373,326}};
detAPI->anchors = {{11,19, 23,30, 28,68},{62,53, 51,138, 123,130},{103,265, 217,371, 563,321}}; // x2500
// 标签标请咨询对应的算法工程师
uint32_t modelclass[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14};
uint32_t standerclass[] = {10000, 20000, 30000, 40000, 50000,
60000, 70000, 80000, 90000, 100000,
110000, 120000, 130000, 140000, 150000};
ret = detAPI->AIGOinit(modelname.c_str(), 0);
if(ret){
printf("init error with ret=%d\n", ret);
return ret;
}
ret = detAPI->AIGOsetLabelMap(modelclass, standerclass, sizeof(modelclass)/sizeof(uint32_t));
if(ret){
printf("setLabelMap error with ret=%d\n", ret);
return ret;
}
}
printf("get det threshold\n");
ret = detAPI->AIGOsetConfThr(0.3, 60000); // 设置 conf阈值 时调用, 仅展示调用方式
if(ret){
printf("set det threshold error\n");
return ret;
}
printf("\nclasses setted\n");
ret = detAPI->AIGOsetNMSThr(0.45); // 设置 nms阈值 时调用, 仅展示调用方式
float timecost = 0;
float durtime = 0;
struct timeval st, et;
cv::Mat detImage = cv::imread(imgname);
cv::cvtColor(detImage, detImage, cv::COLOR_BGR2RGB);
if(detImage.empty()){
printf("read image error %s\n", imgname.c_str());
return 1;
}
cv::Mat detresize;
cv::resize(detImage, detresize, cv::Size(detAPI->netWidth, detAPI->netHeight));
char* zerosInput = (char*)malloc(detresize.cols*detresize.rows*detresize.channels() * sizeof(char));
cv::Mat NV12Mat;
BGR2YUV_nv12(detresize, NV12Mat);
std::vector<objinfo> dets;
GD_VIDEO_FRAME_S* config = (GD_VIDEO_FRAME_S*)malloc(sizeof(GD_VIDEO_FRAME_S));
// 传建输入参数
ImgMat imgvis;
if(UseGDVideoFrame){
if(GSTREAM == NV12){
imgvis.data = NULL;
imgvis.inlayout = NV12;
imgvis.depth = 1;
// Y
config->u64VirAddr[0] = NV12Mat.data;
// UV
config->u64VirAddr[1] = NV12Mat.data + detresize.cols * detresize.rows;
config->u32Stride[0] = detresize.cols;
config->u32Stride[1] = detresize.cols;
}else if(GSTREAM == RGB || GSTREAM == BGR){
imgvis.data = NULL;
imgvis.inlayout = RGB;
imgvis.depth = detresize.channels();
config->u64VirAddr[0] = detresize.data;
config->u32Stride[0] = detresize.cols;
}
imgvis.width = detresize.cols;
imgvis.height = detresize.rows;
imgvis.layout = HWC;
imgvis.mode = VIS;
// imgvis.timestamp = i;
imgvis.cfg = (long long)config;
}else{
if(GSTREAM == NV12){
imgvis.data = NV12Mat.data;
imgvis.inlayout = NV12;
imgvis.depth = 1;
}else if(GSTREAM == RGB || GSTREAM == BGR){
imgvis.data = detresize.data;
imgvis.inlayout = RGB;
imgvis.depth = detresize.channels();
}
imgvis.width = detresize.cols;
imgvis.height = detresize.rows;
imgvis.layout = HWC;
imgvis.mode = VIS;
// imgvis.timestamp = i;
imgvis.cfg = (long long)config;
}
gettimeofday(&st, NULL);
// imgvis.data = (unsigned char*)zerosInput;
std::thread feed_data, result_data;
feed_data = std::thread(run_image_<DETECTION_API>, detAPI, imgvis);
result_data = std::thread(get_result_<DETECTION_API>, detAPI, imgvis);
feed_data.join();
result_data.join();
printf("result dets %d\n", dets.size());
gettimeofday(&et, NULL);
durtime = getDtimeMiliSecond(st, et);
printf("runAsync cost: %.3f\n", durtime/IMAGECOUNT);
timecost += durtime;
printf("avg timecost is: %f\n", timecost/IMAGECOUNT);
ret = detAPI->AIGOdeinit();
printf("\n---------------------current model size: %dx%d\n", imgvis.width, imgvis.height);
printf("\n-----------end--------------\n");
sleep(2);
}
int test_segment_async(){
int ret = 0;
std::string testimg = "../models/Segment/quantImages/s729_VL.jpg";
std::string modelname = "../models/Segment/bm1684x/seg_1280_1024_vis_gray_1280x1024_bm1684x_F16_false.bmodel";
std::string cfgfile = "../models/Segment/bm1684x/seg_1280_1024_vis_gray_1280x1024_bm1684x_F16_false.json";
SEGMENTION_API* segmemtor = new SEGMENTION_API();
ret = segmemtor->AIGOinit(modelname.c_str(), cfgfile.c_str(), 0);
if(ret){
printf("AIGO init error with ret=%d\n", ret);
return ret;
}
// building ImgMat
cv::Mat org = cv::imread(testimg, cv::IMREAD_COLOR);
cv::Mat resizeImg;
cv::resize(org, resizeImg, cv::Size(segmemtor->netWidth, segmemtor->netHeight));
cv::Mat NV12Mat;
BGR2YUV_nv12(resizeImg, NV12Mat);
GD_VIDEO_FRAME_S* config = (GD_VIDEO_FRAME_S*)malloc(sizeof(GD_VIDEO_FRAME_S));
// 传建输入参数
ImgMat imgvis;
if(UseGDVideoFrame){
if(GSTREAM == NV12){
imgvis.data = NULL;
imgvis.inlayout = NV12;
imgvis.depth = 1;
// Y
config->u64VirAddr[0] = NV12Mat.data;
// UV
config->u64VirAddr[1] = NV12Mat.data + resizeImg.cols * resizeImg.rows;
config->u32Stride[0] = resizeImg.cols;
config->u32Stride[1] = resizeImg.cols;
}else if(GSTREAM == RGB || GSTREAM == BGR){
imgvis.data = NULL;
imgvis.inlayout = RGB;
imgvis.depth = resizeImg.channels();
config->u64VirAddr[0] = resizeImg.data;
config->u32Stride[0] = resizeImg.cols;
}
imgvis.width = resizeImg.cols;
imgvis.height = resizeImg.rows;
imgvis.layout = HWC;
imgvis.mode = VIS;
// imgvis.timestamp = i;
imgvis.cfg = (long long)config;
}else{
if(GSTREAM == NV12){
imgvis.data = NV12Mat.data;
imgvis.inlayout = NV12;
imgvis.depth = 1;
}else if(GSTREAM == RGB || GSTREAM == BGR){
imgvis.data = resizeImg.data;
imgvis.inlayout = RGB;
imgvis.depth = resizeImg.channels();
}
imgvis.width = resizeImg.cols;
imgvis.height = resizeImg.rows;
imgvis.layout = HWC;
imgvis.mode = VIS;
// imgvis.timestamp = i;
imgvis.cfg = (long long)config;
}
float timecost = 0;
float durtime = 0;
struct timeval st, et;
gettimeofday(&st, NULL);
// imgvis.data = (unsigned char*)zerosInput;
std::thread feed_data, result_data;
// {
// feed_data = std::thread(run_image_, detAPI, imgvis);
// result_data = std::thread(get_result_, detAPI, imgvis, std::ref(dets));
// }
// if(!InitWithJson){
// // feed_data = std::thread(run_image_, detAPI, img);
// // result_data = std::thread(get_result_, detAPI, std::ref(dets));
feed_data = std::thread(run_image_<SEGMENTION_API>, segmemtor, imgvis);
result_data = std::thread(get_result_<SEGMENTION_API>, segmemtor, imgvis);
// }else{
// feed_data = std::thread(run_image_cfg, detAPI, imgvis);
// result_data = std::thread(get_result_cfg, detAPI, std::ref(dets));
// }
feed_data.join();
result_data.join();
gettimeofday(&et, NULL);
durtime = getDtimeMiliSecond(st, et);
printf("runAsync cost: %.3f\n", durtime/IMAGECOUNT);
timecost += durtime;
printf("avg timecost is: %f\n", timecost/IMAGECOUNT);
printf("\n---------------------current model size: %dx%d\n", segmemtor->netWidth, segmemtor->netHeight);
printf("\n-----------end--------------\n");
ret = segmemtor->AIGOdeinit();
sleep(2);
return ret;
}
int test_segment_sync(){
int ret = 0;
std::string testimg = "../models/Segment/quantImages/VIS/20230704_102059.MP4_20230711_195345.335.bmp";
std::string modelname = "../models/Segment/atlas200/vis_segment_dynamicShape_nv12_fp16.om";
std::string cfgfile = "../models/Segment/atlas200/vis_segment_dynamicShape_nv12_fp16.json";
SEGMENTION_API* segmemtor = new SEGMENTION_API();
ret = segmemtor->AIGOinit(modelname.c_str(), cfgfile.c_str(), 0);
if(ret){
printf("AIGO init error with ret=%d\n", ret);
return ret;
}
// building ImgMat
cv::Mat org = cv::imread(testimg, cv::IMREAD_COLOR);
cv::Mat resizeImg;
cv::resize(org, resizeImg, cv::Size(segmemtor->netWidth, segmemtor->netHeight));
cv::Mat NV12Mat;
BGR2YUV_nv12(resizeImg, NV12Mat);
GD_VIDEO_FRAME_S* config = (GD_VIDEO_FRAME_S*)malloc(sizeof(GD_VIDEO_FRAME_S));
// 传建输入参数
ImgMat imgvis;
if(UseGDVideoFrame){
if(GSTREAM == NV12){
imgvis.data = NULL;
imgvis.inlayout = NV12;
imgvis.depth = 1;
// Y
config->u64VirAddr[0] = NV12Mat.data;
// UV
config->u64VirAddr[1] = NV12Mat.data + resizeImg.cols * resizeImg.rows;
config->u32Stride[0] = resizeImg.cols;
config->u32Stride[1] = resizeImg.cols;
}else if(GSTREAM == RGB || GSTREAM == BGR){
imgvis.data = NULL;
imgvis.inlayout = RGB;
imgvis.depth = resizeImg.channels();
config->u64VirAddr[0] = resizeImg.data;
config->u32Stride[0] = resizeImg.cols;
}
imgvis.width = resizeImg.cols;
imgvis.height = resizeImg.rows;
imgvis.layout = HWC;
imgvis.mode = VIS;
// imgvis.timestamp = i;
imgvis.cfg = (long long)config;
}else{
if(GSTREAM == NV12){
imgvis.data = NV12Mat.data;
imgvis.inlayout = NV12;
imgvis.depth = 1;
}else if(GSTREAM == RGB || GSTREAM == BGR){
imgvis.data = resizeImg.data;
imgvis.inlayout = RGB;
imgvis.depth = resizeImg.channels();
}
imgvis.width = resizeImg.cols;
imgvis.height = resizeImg.rows;
imgvis.layout = HWC;
imgvis.mode = VIS;
// imgvis.timestamp = i;
imgvis.cfg = (long long)config;
}
float timecost = 0;
float durtime = 0;
struct timeval st, et;
gettimeofday(&st, NULL);
ret = segmemtor->AIGOpreprocess(imgvis, true);
if(ret){
printf("preprocess error\n");
return 1;
}
ret = segmemtor->AIGOinfer();
if(ret){
printf("infer error\n");
return 1;
}
TenMat* mask = (TenMat*)malloc(sizeof(TenMat));
mask->width = imgvis.width;
mask->height = imgvis.height;
mask->depth = 1;
// mask->dataByte = mask->height*mask->width*sizeof(float); //
mask->data = NULL;//(void*)malloc(mask->dataByte);
ret = segmemtor->AIGOpostprocess(mask);
if(ret){
printf("postprocess error");
return 1;
}
if(mask->type == AI_FLOAT){
ret = draw_mask<float>(resizeImg, mask);
}else if(mask->type == AI_UINT8){
ret = draw_mask<uint8_t>(resizeImg, mask);
}else if(mask->type == AI_INT32){
ret = draw_mask<int32_t>(resizeImg, mask);
}
if(ret){
printf("draw mask error\n");
return ret;
}
// cv::Mat maskcv(cv::Size(mask->height, mask->width), CV_8UC3, mask->data);
// cv::imwrite("../models/Segment/mask.jpg", maskcv);
cv::imwrite("../models/Segment/result.jpg", resizeImg);
free(mask);
free(config);
ret = segmemtor->AIGOdeinit();
if(ret){
printf("AIGOdeinit error\n");
return ret;
}
free(segmemtor);
sleep(1);
return ret;
}
int test_segment(bool useAsync){
if(useAsync){
return test_segment_async();
}else{
return test_segment_sync();
}
}
int test_sync_multi(){
int ret = 0;
int envNum = 2;
std::string visdetmodelname = "../models/Detect/hisi3403/hq.han/3403_2class_rpn.om";
std::string visdetparamname = "../models/Detect/hisi3403/hq.han/3403_2class_rpn.json";
std::vector<DETECTION_API*> apis;
std::vector<std::thread> runthreads, getthreads;
for(int i=0; i<envNum; i++){
DETECTION_API* detapi = new DETECTION_API();
ret = detapi->AIGOinit(visdetmodelname.c_str(), visdetparamname.c_str(), 0);
if(ret){
printf("init error with ret=%d\n", ret);
return ret;
}
apis.push_back(detapi);
// std::thread runthread, getthread;
// runthreads.push_back(runthread);
// getthreads.push_back(getthread);
}
std::string visdetimgname = "../models/Detect/quantImages/1488264581.jpg";
std::string vissegimgname = "../models/Segment/test_images_vl/20230704_102059.MP4_20230711_195345.335.bmp";
float timecost = 0;
float durtime = 0;
struct timeval st, et;
cv::Mat visdetImage = cv::imread(visdetimgname);
cv::cvtColor(visdetImage, visdetImage, cv::COLOR_BGR2RGB);
if(visdetImage.empty()){
printf("read image error %s\n", visdetimgname.c_str());
return 1;
}
cv::Mat visdetresize, vissegresize;
cv::resize(visdetImage, visdetresize, cv::Size(apis.at(0)->netWidth, apis.at(0)->netHeight));
// char* zerosInput = (char*)malloc(visdetresize.cols*visdetresize.rows*visdetresize.channels() * sizeof(char));
cv::Mat NV12Matvis, NV12Matir;
// convert BGR to NV12
BGR2YUV_nv12(visdetresize, NV12Matvis);
std::vector<objinfo> dets;
GD_VIDEO_FRAME_S* config = (GD_VIDEO_FRAME_S*)malloc(sizeof(GD_VIDEO_FRAME_S));
ImgMat imgvis;
if(UseGDVideoFrame){
if(GSTREAM == NV12){
imgvis.data = NULL;
imgvis.inlayout = NV12;
imgvis.depth = 1;
// Y
config->u64VirAddr[0] = NV12Matvis.data;
// UV
config->u64VirAddr[1] = NV12Matvis.data + visdetresize.cols * visdetresize.rows;
config->u32Stride[0] = visdetresize.cols;
config->u32Stride[1] = visdetresize.rows;
}else if(GSTREAM == RGB || GSTREAM == BGR){
imgvis.data = NULL;
imgvis.inlayout = RGB;
imgvis.depth = visdetresize.channels();
config->u64VirAddr[0] = visdetresize.data;
config->u32Stride[0] = visdetresize.cols;
}
imgvis.width = visdetresize.cols;
imgvis.height = visdetresize.rows;
imgvis.layout = HWC;
imgvis.mode = VIS;
imgvis.timestamp = 0;
imgvis.cfg = (long long)config;
}else{
if(GSTREAM == NV12){
imgvis.data = NV12Matvis.data;
imgvis.inlayout = NV12;
imgvis.depth = 1;
}else if(GSTREAM == RGB || GSTREAM == BGR){
imgvis.data = visdetresize.data;
imgvis.inlayout = RGB;
imgvis.depth = visdetresize.channels();
}
imgvis.width = visdetresize.cols;
imgvis.height = visdetresize.rows;
imgvis.layout = HWC;
imgvis.mode = VIS;
imgvis.timestamp = 0;
imgvis.cfg = (long long)config;
}
for(int i=0; i<envNum; i++){
// std::thread runthread = std::thread(run_image_sync<DETECTION_API>, apis.at(i), imgvis);
runthreads.push_back(std::thread(run_image_sync<DETECTION_API>, apis.at(i), imgvis));
}
for(int i=0; i<envNum; i++){
runthreads.at(i).join();
}
printf("result dets %d\n", dets.size());
for(DETECTION_API* api : apis){
ret = api->AIGOdeinit();
if(ret){
printf("AIGOdeinit error with ret=%d\n", ret);
return ret;
}
}
printf("sleeping\n");
sleep(15);
return 0;
}
int test_async_multi(){
int ret = 0;
int envNum = 3;
std::string visdetmodelname = "../models/Detect/atlas200/hq.han/732_VL_dynamic_nms_nv12_0609.om";
std::string visdetparamname = "../models/Detect/atlas200/hq.han/732_VL_dynamic_nms_nv12_0609.json";
std::vector<DETECTION_API*> apis;
std::vector<std::thread> runthreads, getthreads;
for(int i=0; i<envNum; i++){
DETECTION_API* detapi = new DETECTION_API();
ret = detapi->AIGOinit(visdetmodelname.c_str(), visdetparamname.c_str(), 0);
if(ret){
printf("init error with ret=%d\n", ret);
return ret;
}
apis.push_back(detapi);
// std::thread runthread, getthread;
// runthreads.push_back(runthread);
// getthreads.push_back(getthread);
}
std::string visdetimgname = "../models/Detect/quantImages/1488264581.jpg";
std::string vissegimgname = "../models/Segment/test_images_vl/20230704_102059.MP4_20230711_195345.335.bmp";
float timecost = 0;
float durtime = 0;
struct timeval st, et;
cv::Mat visdetImage = cv::imread(visdetimgname);
cv::cvtColor(visdetImage, visdetImage, cv::COLOR_BGR2RGB);
if(visdetImage.empty()){
printf("read image error %s\n", visdetimgname.c_str());
return 1;
}
cv::Mat visdetresize, vissegresize;
cv::resize(visdetImage, visdetresize, cv::Size(apis.at(0)->netWidth, apis.at(0)->netHeight));
// char* zerosInput = (char*)malloc(visdetresize.cols*visdetresize.rows*visdetresize.channels() * sizeof(char));
cv::Mat NV12Matvis, NV12Matir;
// convert BGR to NV12
BGR2YUV_nv12(visdetresize, NV12Matvis);
std::vector<objinfo> dets;
GD_VIDEO_FRAME_S* config = (GD_VIDEO_FRAME_S*)malloc(sizeof(GD_VIDEO_FRAME_S));
ImgMat imgvis;
if(UseGDVideoFrame){
if(GSTREAM == NV12){
imgvis.data = NULL;
imgvis.inlayout = NV12;
imgvis.depth = 1;
// Y
config->u64VirAddr[0] = NV12Matvis.data;
// UV
config->u64VirAddr[1] = NV12Matvis.data + visdetresize.cols * visdetresize.rows;
config->u32Stride[0] = visdetresize.cols;
config->u32Stride[1] = visdetresize.rows;
}else if(GSTREAM == RGB || GSTREAM == BGR){
imgvis.data = NULL;
imgvis.inlayout = RGB;
imgvis.depth = visdetresize.channels();
config->u64VirAddr[0] = visdetresize.data;
config->u32Stride[0] = visdetresize.cols;
}
imgvis.width = visdetresize.cols;
imgvis.height = visdetresize.rows;
imgvis.layout = HWC;
imgvis.mode = VIS;
imgvis.timestamp = 0;
imgvis.cfg = (long long)config;
}else{
if(GSTREAM == NV12){
imgvis.data = NV12Matvis.data;
imgvis.inlayout = NV12;
imgvis.depth = 1;
}else if(GSTREAM == RGB || GSTREAM == BGR){
imgvis.data = visdetresize.data;
imgvis.inlayout = RGB;
imgvis.depth = visdetresize.channels();
}
imgvis.width = visdetresize.cols;
imgvis.height = visdetresize.rows;
imgvis.layout = HWC;
imgvis.mode = VIS;
imgvis.timestamp = 0;
imgvis.cfg = (long long)config;
}
for(int i=0; i<envNum; i++){
runthreads.push_back(std::thread(run_image_<DETECTION_API>, apis.at(i), imgvis));
getthreads.push_back(std::thread(get_result_<DETECTION_API>, apis.at(i), imgvis));
}
for(int i=0; i<envNum; i++){
runthreads.at(i).join();
getthreads.at(i).join();
}
printf("result dets %d\n", dets.size());
for(DETECTION_API* api : apis){
ret = api->AIGOdeinit();
if(ret){
printf("AIGOdeinit error with ret=%d\n", ret);
return ret;
}
}
}
int test_multi_class(bool useAsync){
if(useAsync){
return test_async_multi();
}else{
// for(int i=0; i<10;i++){
// test_sync_multi();
// }
return test_sync_multi();
// sleep(10);
// return 0;
}
};
int test_initdeinit(){
int ret = 0;
int envNum = 2;
std::string visdetmodelname = "../models/Detect/hisi3403/hq.han/yolov5_1280_704_2class_nv12_8_nms.om";
std::string visdetparamname = "../models/Detect/hisi3403/hq.han/yolov5_1280_704_2class_nv12_8_nms.json";
std::vector<DETECTION_API*> apis;
std::vector<std::thread> runthreads, getthreads;
// DETECTION_API* detapi = new DETECTION_API();
// ret = detapi->AIGOinit(visdetmodelname.c_str(), visdetparamname.c_str(), 0);
// if(ret){
// printf("init error with ret=%d\n", ret);
// return ret;
// }
// ret = detapi->AIGOdeinit();
// if(ret){
// printf("AIGOdeinit error with ret=%d\n", ret);
// return ret;
// }
// delete detapi;
// detapi = NULL;
for(int i=0; i<envNum; i++){
DETECTION_API* detapi = new DETECTION_API();
ret = detapi->AIGOinit(visdetmodelname.c_str(), visdetparamname.c_str(), 0);
if(ret){
printf("init error with ret=%d\n", ret);
return ret;
}
apis.push_back(detapi);
}
printf("init done sleeping");
sleep(5);
for(DETECTION_API* api : apis){
ret = api->AIGOdeinit();
if(ret){
printf("AIGOdeinit error with ret=%d\n", ret);
return ret;
}
delete api;
api = NULL;
}
printf("sleeping\n");
sleep(15);
}
int main(){
// cpu_set_t mask;
// CPU_ZERO(&mask);
// CPU_SET(0, &mask);
// if (pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) == -1) {
// printf("warning: could not set CPU affinity, continuing...\n");
// }
int ret = 0;
ret = Init_ACL();
// ret = test_class();
// ret = test_class_async();
// ret = test_segment(true);
ret = test_multi_class(false);
// ret = test_initdeinit();
ret= Uninit_ACL();
return ret;
}