Hu Chunming / vpt_proj

#include <time.h>
#include "ErrorInfo.h"
#include "CD.h"
#include "libuctools.h"
#include "ObjCls.h"

//#include "ga_model_gpu.h"
//#include "ga_model_init_gpu.h"

#include "ga_model.h"
#include "ga_model_init.h"

int checkTime()
{
	struct tm* info;
	int nYear, nMonth, nDay;
	time_t raw;
	time(&raw);
	info = localtime(&raw);
	nYear = info->tm_year + 1900;
	nMonth = info->tm_mon + 1;
	nDay = info->tm_mday;

	if (nYear == 2018 || (nYear == 2019 && nMonth<7))
		return 1;
	else
	{
		printf("版本过期，请联系开发商！中科院自动化所模式识别实验室图像视频组\n");
		return -1;
	}
}


int CD_Init(void *&handle, CD_PARAM vparam, char* resDir, VIDEO_OBJECT_SNAPSHOT_CALLBACK VideoObjSnapshotCallBack/* = NULL*/)
{
	if (checkTime() != 1)
		return FAILED;

	int res = SUCCESS;

	handle = new objDetector;	//申请对象
	memcpy((void *)&((objDetector *)handle)->param, (void *)&vparam, sizeof(CD_PARAM));
	((objDetector *)handle)->ssdResult = new CDTOOLS_Result[vparam.maxResultCount];

	int flag = 0;	//返回值 默认为SUCCEEDED：0

	CDTOOLS_PARAMS param;
	//	param.initnetpath = "caffe2-detection-model/model_CPU/model_init.pb";
	//	param.predictnetpath = "caffe2-detection-model/model_CPU/model.pb";
	param.initnetpath = NULL;
	param.predictnetpath = NULL;


//----------------- 13类结构化 ---------------------//
/*
  param.initnetArray = (unsigned char*)ga_model_init;
	param.initnetArrayLen = ga_model_init_len;
	param.predictnetArray = (unsigned char*)ga_model;
	param.predictnetArrayLen = ga_model_len;
	param.mode = GPU_MODE;
 
  param.gpuid = 0;
	param.flag_glog = 1;
	param.test_size = 360;
	param.test_max_size = 640;
	param.fpn_coarsest_stride = 32;
	param.submean = "3 0 0 0";
	param.variance = "3 255.0 255.0 255.0";
 */
 //----------------- 13类结构化 ---------------------//
 
 
 
 //----------------- 猫和狗结构化 ---------------------//

  param.initnetArray = (unsigned char*)ga_model_init;
	param.initnetArrayLen = ga_model_init_len;
	param.predictnetArray = (unsigned char*)ga_model;
	param.predictnetArrayLen = ga_model_len;
	param.mode = GPU_MODE;
 
  param.gpuid = 0;
	param.flag_glog = 1;
	param.test_size = 800;
	param.test_max_size = 1333;
	param.fpn_coarsest_stride = 32;
	param.submean = "3 102.9801 115.9465 122.7717";
	param.variance = "3 1.0 1.0 1.0";
 
 //----------------- 猫和狗结构化 ---------------------//
 
 
 
//----------------- 9类结构化（自用单路人车物） ---------------------//
	//GPU调用
	/*param.initnetArray = (unsigned char*)ga_model_init_gpu;
	param.initnetArrayLen = ga_model_init_gpu_len;
	param.predictnetArray = (unsigned char*)ga_model_gpu;
	param.predictnetArrayLen = ga_model_gpu_len;
	param.mode = GPU_MODE;
*/

	//CPU调用
	/*param.initnetArray = (unsigned char*)ga_model_init_cpu;
	param.initnetArrayLen = ga_model_init_cpu_len;
	param.predictnetArray = (unsigned char*)ga_model_cpu;
	param.predictnetArrayLen = ga_model_cpu_len;
	param.mode = CPU_MODE;*/

/*
	param.gpuid = 0;
	param.flag_glog = 1;
	param.test_size = 480;
	param.test_max_size = 1333;
	param.fpn_coarsest_stride = 32;
	param.submean = "3 0 0 0";
	param.variance = "3 255.0 255.0 255.0";
*/
//----------------- 9类结构化（自用单路人车物） ---------------------//
  
	res = Ctools_DInit(((objDetector *)handle)->detector, &param);

	//拌线初始化
	((objDetector *)handle)->tracker = new Sort(/*lineArray, linecount, DETECTTYPE*/);
	((objDetector *)handle)->snapshotHelper = new SnapShot(resDir, VideoObjSnapshotCallBack, vparam.SnaoshotParameter);

((objDetector *)handle)->frameCounter = FusionInterval;
	return res;
}

void CD_ResetTracker(void * handle/*, int maxResultCountVPT_Line * lineArray = NULL, int linecount = 0*/)
{
	objDetector* tools = (objDetector*)handle;
	/*if (tools->ssdResult)
	{
	delete[] tools->ssdResult;
	}
	tools->param.maxResultCount = maxResultCount;
	tools->ssdResult = new CDTOOLS_Result[maxResultCount];*/

	tools->tracker->Release();
	delete tools->tracker;
	tools->tracker = NULL;

	tools->tracker = new Sort(/*lineArray, linecount, DETECTTYPE*/);	//新接口 无需流量统计和快照
}


//辅助函数：数据预处理
float VPTmeanSub[3] = { 103.52, 116.28, 123.675 };
float VPTVariance[3] = { 57.375, 57.12, 58.395 };
void datapreprocess(float * blob, int width, int height, int channels, int batchsize)
{

	int datasize_ = width * height;
	for (int c = 0; c < 3; c++)
	{
		for (int i = 0; i < width * height; i++)
		{
			blob[datasize_ * c + i] = ((blob[datasize_ * c + i]) - VPTmeanSub[c]) / VPTVariance[c];
		}
	}

}


int VPT_ProcessLastFrame(void * handle/*, unsigned char * rgb, int width, int height, FT_Result * result*/)
{
	objDetector* tools = (objDetector*)handle;
	//CDTOOLS_Result ssdResult[MAX_OBJ_COUNT_TEST];

	vector< vector <float>> detectResult;	//转化为跟踪所需要的输入
	int index = 0;
	bool isUseDet = false;
	vector<int> deleteTrackers;

	int ObjCount = tools->tracker->updateLastFrame(deleteTrackers);

//void SaveSnapshot(vector<int> deleteTrackers);
			tools->snapshotHelper->SaveSnapshot(deleteTrackers);

			vector<vector<float>>().swap(detectResult);
			detectResult.clear();

			vector<int>().swap(deleteTrackers);
			deleteTrackers.clear();


	return 0;
}

//int VPT_Process(void * handle, unsigned char *bgr, int width, int height, int channels, int frameCount, VPT_Result *result, vector<int> &deleteTrackers, VPT_TrafficResult* traffic, bool showTrack)
int CD_Process(void * handle, unsigned char *bgr, int width, int height, int channels, int frameCount, CD_Result *result,/* int maxResultCount,*/ bool showTrack)
{
	objDetector* tools = (objDetector*)handle;
	//CDTOOLS_Result ssdResult[MAX_OBJ_COUNT_TEST];

	Mat img(height, width, CV_8UC3, bgr);
	vector< vector <float>> detectResult;	//转化为跟踪所需要的输入
	int index = 0;
	bool isUseDet = false;
	vector<int> deleteTrackers;

	if (tools->frameCounter == FusionInterval || tools->isInitFrame)
	{
 
		int objcount = Ctools_Detector(tools->detector, bgr, width, height, channels, tools->ssdResult, tools->param.maxResultCount, NULL);

//cout <<"objcount: " << objcount << endl;

		for (int i = 0; i < objcount; ++i)
		{
			const CDTOOLS_Result& d = tools->ssdResult[i];// Detection format: [image_id, label, score, xmin, ymin, xmax, ymax)
			const float score = d.boxinfo[4];

			//cout << score << " " << THRESHOLD << endl;

			if (score >= THRESHOLD)  //更改为left top right bottom score index
			{
				vector <float> obj;
				obj.push_back(d.boxinfo[0]);
				obj.push_back(d.boxinfo[1]);
				obj.push_back(d.boxinfo[2]);
				obj.push_back(d.boxinfo[3]);
				obj.push_back(d.boxinfo[4]);
				obj.push_back(d.boxinfo[5]);
				detectResult.push_back(obj);

				/*dResult->obj[index].id = ObjID++;
				dResult->obj[index].index = d.boxinfo[5] - 1;
				dResult->obj[index].left = d.boxinfo[0] ;
				dResult->obj[index].top = d.boxinfo[1] ;
				dResult->obj[index].right = d.boxinfo[2] ;
				dResult->obj[index].bottom = d.boxinfo[3];

				dResult->obj[index].center_x = (dResult->obj[i].right - dResult->obj[i].left) / 2;
				dResult->obj[index].center_y = (dResult->obj[i].bottom - dResult->obj[i].top) / 2;
				dResult->obj[index].confidence = d.boxinfo[4];*/

				index++;
			}
		}

		//dResult->objCount = index;
		result->objCount = detectResult.size();

		//VPT_Result temp;
    tools->isInitFrame = false;
		tools->frameCounter = 0;
		isUseDet = true;
		
	}
	tools->frameCounter++;

	//for (int j = 0; j < FusionInterval; j++)	//跳帧：检测一帧，跟踪 (FusionInterval - 1)帧 
	//{
		int objCount = tools->tracker->update(width, height, isUseDet, detectResult, result->obj, deleteTrackers);
//cout <<"sort objcount: " << objCount << endl;
		/*if (j == 0)
		{*/
			//memcpy(result->obj, temp.obj, sizeof(VPT_Result));	//只返回第一帧带检测的结果
			result->objCount = objCount;

			tools->snapshotHelper->SnapshotProcess(result, img, deleteTrackers, frameCount);

			vector<vector<float>>().swap(detectResult);
			detectResult.clear();

			vector<int>().swap(deleteTrackers);
			deleteTrackers.clear();

		//}
	//}


	if (showTrack)
		tools->tracker->addTracker(&img);

	return 0;
}

//int VPT_ProcessImage(void * handle, unsigned char * bgr, int width, int height, int channels, VPT_Result * result)
//{
//	objDetector* tools = (objDetector*)handle;
//
//	if (bgr == NULL || width == 0 || height == 0)	//图像数据错误
//		return -1;
//
//	clock_t begin = clock();
//
//	CDTOOLS_Result ssdResult[50];
//	
//	int count  = Ctools_Detector(tools->detector, bgr, width, height, 3, ssdResult, datapreprocess);	//
//	clock_t end = clock();
//	
//	for (int i = 0; i < count; i++)
//	{
//		const CDTOOLS_Result& d = ssdResult[i];// Detection format: [image_id, label, score, xmin, ymin, xmax, ymax)
//		const float score = d.boxinfo[5];
//
//		result->obj[i].id = i;
//		result->obj[i].left = d.boxinfo[0];	// bbout[i][0];
//		result->obj[i].top = d.boxinfo[1];	//bbout[i][1];
//		result->obj[i].right = d.boxinfo[2];	//bbout[i][2];
//		result->obj[i].bottom = d.boxinfo[3];	//bbout[i][3];
//		result->obj[i].confidence = d.boxinfo[4];
//		result->obj[i].index = d.boxinfo[5] - 1; // bbout[i][4];
//	}
//
//	result->objCount = count;
//	return count;
//}

void CD_Release(void *&handle)
{
	objDetector* tools = (objDetector*)handle;
 
 VPT_ProcessLastFrame(tools);
 sleep(500);
 

	if (tools && tools->detector)
	{
		Ctools_DRelease(tools->detector);
		tools->detector = NULL;
	}

	if (tools && tools->ssdResult)
	{
		delete[] tools->ssdResult;
		tools->ssdResult = NULL;
	}

	if (tools)
	{
		delete tools;
		tools = NULL;
	}
}