vpt/src/VPT/sort/SnapShot.cpp

#include "SnapShot.h"
#include <time.h>
#ifdef _MSC_VER
        #include <io.h>
        #include <direct.h>
	#include <windows.h>
        #define _ACCESS _access
        #define _MKDIR(a) _mkdir((a))
#else
        #include <unistd.h>
        #include <stdarg.h>
        #include <sys/stat.h>
        #define _ACCESS access
	#define _MKDIR(a) mkdir((a),0755)
	#define DWORD unsigned int
	#define LPVOID void*
#endif

#define ACCESS _ACCESS
#define MKDIR(a) _MKDIR((a))

//static int index = 0;

int CreateDir(char *pszDir)
{
	int i = 0;
	int iRet;
	int iLen = strlen(pszDir);
	if (pszDir[iLen - 1] != '\\' && pszDir[iLen - 1] != '/')
	{
		pszDir[iLen] = '/';
		pszDir[iLen + 1] = '\0';
	}
	iLen = strlen(pszDir);

	if (iLen>2 && ((pszDir[i] == '\\' && pszDir[i + 1] == '\\') || (pszDir[i] == '/' && pszDir[i + 1] == '/')))
	{
		i = 2;
		for (; i <= iLen; i++)
			if (pszDir[i] == '\\' || pszDir[i] == '/')
				break;

		i++;

		for (; i <= iLen; i++)
		{
			if (pszDir[i] == '\\' || pszDir[i] == '/')
			{
				pszDir[i] = '\0';
				iRet = ACCESS(pszDir, 0);
				if (iRet != 0)
				{
					iRet = MKDIR(pszDir);
					if (iRet != 0)
					{
						cout << "Create Folder Failed!" << endl;
						return -1;

					}
				}
				pszDir[i] = '/';

			}
		}
		return 0;
	}


	if (pszDir[i] != '\\' && pszDir[i] != '/')
		i = 0;
	else
		i = 1;
	for (; i <= iLen; i++)
	{
		if (pszDir[i] == '\\' || pszDir[i] == '/')
		{
			pszDir[i] = '\0';
			iRet = ACCESS(pszDir, 0);
			if (iRet != 0)
			{
				iRet = MKDIR(pszDir);
				if (iRet != 0)
				{

					return -1;

				}
			}
			pszDir[i] = '/';

		}
	}
	return 0;
}

void CreateResultFolder(char* resultFolder)
{
	if (strlen(resultFolder) > 240)  //太长
	{
		cout << "Folder Name is too Long!" << endl;
		return;
	}
	//else if (strlen(resultFolder) < 1)  //太短，最少一个字符
	//{
	//	cout << "Folder Name is too Short!" << endl;
	//	return;
	//}

	char childFolder[2][260] = { "SnapshotLittle", "Snapshot" };
	char dir[260];

	sprintf(dir, "%s%s/", resultFolder, childFolder[0]);

	if (CreateDir(dir) != 0)
	{
		cout << "Create Folder Failed!" << endl; return;
	}

	sprintf(dir, "%s%s/", resultFolder, childFolder[1]);
	
	if (CreateDir(dir) != 0)
	{
		cout << "Create Folder Failed!" << endl; return;
	}
}

DWORD ThreadProcess(LPVOID param);

SnapShot::SnapShot(char* ResDir, VIDEO_OBJECT_SNAPSHOT_CALLBACK VideoObjSnapshotCallBack, SNAPSHOT_PARAMETER *ssParam)
{
	if (ResDir == NULL)
	{
		saveSnapshot = false;
		return;
	}
		
	saveSnapshot = true;
	strcpy(mResDir, ResDir);
	int iLen = strlen(mResDir);
	
	if (iLen !=0 && mResDir[iLen - 1] != '\\' && mResDir[iLen - 1] != '/')
	{
		mResDir[iLen] = '/';
		mResDir[iLen + 1] = '\0';
	}

	CreateResultFolder(mResDir);

	mVideoObjSnapshotCallBack = NULL;
	if (VideoObjSnapshotCallBack != NULL)
		mVideoObjSnapshotCallBack = VideoObjSnapshotCallBack;

	checkBoxSize = ssParam->selectFromMinbox;
	checkDistance = ssParam->selectFromMindistance;
	
	memcpy(minBoxSize, ssParam->minBoxsize, sizeof(MRECT)* DETECTTYPE);	  //复制参数
	memcpy(minDistance, ssParam->minDistance, sizeof(int)* EDGES);	      //复制参数

	ProcessThread = boost::thread(ThreadProcess, this);
	beginSaveSnapshot = false;

	saveTimes = 0;
}

SnapShot::~SnapShot()
{
	ProcessThread.interrupt();   //中断处理线程
	ProcessThread.join();        //等待处理线程结束了 函数继续

	mVideoObjSnapshotCallBack = NULL;
}

void SnapShot::SnapshotProcess(VPT_Result *result, cv::Mat img, vector<int> deleteTrackers, int frameCount)
{

	if (saveSnapshot)
	{
 
		for (int i = 0; i < result->objCount; i++)
		{
			if (snapshots.find(result->obj[i].id) == snapshots.end())
      	AddSnapshot(result->obj[i], img, frameCount);
			else 
				UpdateSnapshot(result->obj[i], img, frameCount);
		}

		SaveSnapshot(deleteTrackers);
	}
 
}

void SnapShot::AddSnapshot(VPT_ObjInfo object, cv::Mat img, int frameCount)
{
	OBJECT_SNAPSHOT_INFO newObjInfo;
	newObjInfo.objInfo.left = object.left;
	newObjInfo.objInfo.right = object.right;
	newObjInfo.objInfo.top = object.top;
	newObjInfo.objInfo.bottom = object.bottom;
	newObjInfo.objInfo.objectID = object.id;
	newObjInfo.objInfo.objectIndex = object.index;
	newObjInfo.objInfo.taskFrameCount = frameCount;

	newObjInfo.area = (newObjInfo.objInfo.right - newObjInfo.objInfo.left) * (newObjInfo.objInfo.top - newObjInfo.objInfo.bottom);
	
	//double begin = 0, end = 0;
	//begin = clock();

	//cv::Rect rect(newObjInfo.objInfo.left, newObjInfo.objInfo.top, newObjInfo.objInfo.right - newObjInfo.objInfo.left, newObjInfo.objInfo.bottom - newObjInfo.objInfo.top);
	//img(rect).copyTo(newObjInfo.objImg);  /*newObjInfo.objImg = img(rect);*/ 
	img.copyTo(newObjInfo.objImg);    //保存原图

	/*end = clock();
	printf("Copy Once Time: %.2f   \n", end - begin);*/

	newObjInfo.flags[0] = newObjInfo.objInfo.left < minDistance[0] + SCALE_OUT ? 0 : 1;           //left
	newObjInfo.flags[1] = newObjInfo.objInfo.top < minDistance[1] + SCALE_OUT ? 0 : 1;            //top
	newObjInfo.flags[2] = newObjInfo.objInfo.right > img.cols - minDistance[2] - SCALE_OUT ? 0 : 1;   //right
	newObjInfo.flags[3] = newObjInfo.objInfo.bottom > img.rows - minDistance[3] - SCALE_OUT ? 0 : 1;     //bottom
	

	snapshots[newObjInfo.objInfo.objectID] = newObjInfo;
  snapshots[newObjInfo.objInfo.objectID].voteIndex.insert(snapshots[newObjInfo.objInfo.objectID].voteIndex.begin(), DETECTTYPE, 0);
  snapshots[newObjInfo.objInfo.objectID].voteIndex[newObjInfo.objInfo.objectIndex]++;
}


//******** 判断面积是否合法函数 **********//
// 目的：选取框最大最完整的那帧
// 1. 比之前面积小的不要
// 2. 突变的面积不要
bool SnapShot::LegalArea(int maxArea, int lastArea, int left, int top, int right, int bottom)
{
	//不需要通过MINBOX来判断，直接返回true
	if (checkBoxSize == false)
		return true;

	int newArea = (bottom - top)*(right - left);
	if (newArea < maxArea)
		return false;
	else if ((newArea - lastArea) / lastArea > 0.5)  //阈值测试之后再确定，看是否需要分种类来确定不同的阈值
		return false;
	else return true;
}


//******** 判断位置是否合法函数 **********//
// 目的：剔除掉靠近摄像头时，面积最大，但是检测物体已经不完整的情况
// 1. 设定阈值，靠近边缘不要了（阈值目前设定为自身宽高的20%）
bool SnapShot::LegalPos(bitset<EDGESIZE> flags, int left, int top, int right, int bottom, int imgHeight, int imgWidth)
{
	//不需要通过MINDISTANCE来判断，直接返回true
	if (checkDistance == false)
		return true;

	int pos[4] = { left, top, right, bottom };
	int edges[4] = { 0, 0, imgWidth, imgHeight };

	for (int i = 0; i < EDGESIZE; i++)
	{
		if (flags[i])  //是需要判断的边
		{
			if (abs(pos[i] - edges[i]) < minDistance[i])
				return false;
		}
	}
	return true;
}


void SnapShot::UpdateSnapshot(VPT_ObjInfo object, cv::Mat img, int frameCount)
{
	//**************** 策略一 *************************//
	//选取面积最大的，剔除掉突变的
	//选取那些远离边框位置的
	int maxArea = (snapshots[object.id].objInfo.right - snapshots[object.id].objInfo.left)*(snapshots[object.id].objInfo.bottom - snapshots[object.id].objInfo.top);
	if (LegalArea(maxArea, snapshots[object.id].area, object.left, object.top, object.right, object.bottom) 
		&& LegalPos(snapshots[object.id].flags, object.left, object.top, object.right, object.bottom, img.rows, img.cols))
	{
		snapshots[object.id].objInfo.left = object.left;
		snapshots[object.id].objInfo.right = object.right;
		snapshots[object.id].objInfo.top = object.top;
		snapshots[object.id].objInfo.bottom = object.bottom;
		snapshots[object.id].objInfo.objectID = object.id;
		snapshots[object.id].objInfo.taskFrameCount = frameCount;
		snapshots[object.id].voteIndex[object.index]++;
		snapshots[object.id].objImg.release();

		//cv::Rect rect(snapshots[object.id].objInfo.left, snapshots[object.id].objInfo.top,
		//	snapshots[object.id].objInfo.right - snapshots[object.id].objInfo.left, snapshots[object.id].objInfo.bottom - snapshots[object.id].objInfo.top);
		//img(rect).copyTo(snapshots[object.id].objImg);  /*newObjInfo.objImg = img(rect);*/ 

		img.copyTo(snapshots[object.id].objImg);    ////保存原图，快照效果不好时，可以适当的外扩
	}
	snapshots[object.id].area = (snapshots[object.id].objInfo.right - snapshots[object.id].objInfo.left) * (snapshots[object.id].objInfo.top - snapshots[object.id].objInfo.bottom);
}

static string type1[DETECTTYPE] = { "person", "bike", "motor", "tricycle", "car", "bigbus", "lorry", "tractor", "midibus" };

DWORD ThreadProcess(LPVOID param)
{
	SnapShot *pThreadParam = (SnapShot *)param;

	try
	{
		while (true)
		{
			if (pThreadParam->beginSaveSnapshot)
			{
				{
					boost::mutex::scoped_lock lock(pThreadParam->threadMutex);
					pThreadParam->deleteID = pThreadParam->tempDeleteID;
					pThreadParam->tempDeleteID.clear();
					pThreadParam->beginSaveSnapshot = false;
				}
        
				for (int i = 0; i < pThreadParam->deleteID.size(); i++)
				{
					char imgName[260];
					sprintf(imgName, "%sSnapshot/%d.jpg", pThreadParam->mResDir, pThreadParam->deleteID[i]);
					imwrite(imgName, pThreadParam->snapshots[pThreadParam->deleteID[i]].objImg);
					
                          
					cv::Mat littleImg;
					cv::Rect rect(pThreadParam->snapshots[pThreadParam->deleteID[i]].objInfo.left, pThreadParam->snapshots[pThreadParam->deleteID[i]].objInfo.top,
						pThreadParam->snapshots[pThreadParam->deleteID[i]].objInfo.right - pThreadParam->snapshots[pThreadParam->deleteID[i]].objInfo.left,
						pThreadParam->snapshots[pThreadParam->deleteID[i]].objInfo.bottom - pThreadParam->snapshots[pThreadParam->deleteID[i]].objInfo.top);
					pThreadParam->snapshots[pThreadParam->deleteID[i]].objImg(rect).copyTo(littleImg);
					
					char objName[260];
					sprintf(objName, "%sSnapshotLittle/%d.jpg", pThreadParam->mResDir, pThreadParam->deleteID[i]/*, type1[pThreadParam->snapshots[pThreadParam->deleteID[i]].objInfo.objectIndex].c_str()*/);
					imwrite(objName, littleImg);
                        
					/*strcpy(snapshots[deleteTrackers[i]].objInfo.firstPicPath, imgName);
					strcpy(snapshots[deleteTrackers[i]].objInfo.secondPicPath, objName);
					
					if (mVideoObjSnapshotCallBack != NULL)
					mVideoObjSnapshotCallBack(&snapshots[deleteTrackers[i]].objInfo);


					char objName[260];
					sprintf(objName, "%sSnapshotLittle//%d.jpg", pThreadParam->mResDir, pThreadParam->deleteID[i]);
					imwrite(objName, pThreadParam->snapshots[pThreadParam->deleteID[i]].objImg);*/
					int maxCount = 0;
					int index = 0;
					for (int ii = 0; ii < DETECTTYPE; ii++)
					{
						if (pThreadParam->snapshots[pThreadParam->deleteID[i]].voteIndex[ii] > maxCount)
						{
							maxCount = pThreadParam->snapshots[pThreadParam->deleteID[i]].voteIndex[ii];
							index = ii;
						}
					}

					pThreadParam->snapshots[pThreadParam->deleteID[i]].objInfo.objectIndex = index;
					strcpy(pThreadParam->snapshots[pThreadParam->deleteID[i]].objInfo.firstPicPath, objName);
					strcpy(pThreadParam->snapshots[pThreadParam->deleteID[i]].objInfo.secondPicPath, objName);

					if (pThreadParam->mVideoObjSnapshotCallBack != NULL)
						pThreadParam->mVideoObjSnapshotCallBack(&pThreadParam->snapshots[pThreadParam->deleteID[i]].objInfo);


					pThreadParam->snapshots[pThreadParam->deleteID[i]].objImg.release();
					pThreadParam->snapshots.erase(pThreadParam->snapshots.find(pThreadParam->deleteID[i]));
				}
				pThreadParam->deleteID.clear();
				
			}
			
			boost::this_thread::sleep(boost::posix_time::milliseconds(10));
		}
	}
	catch (...)
	{
		std::cout << "Save Process Thread is Finished" << std::endl;
	}

	return 0;
}


void SnapShot::SaveSnapshot(vector<int> deleteTrackers)
{
	for (int i = 0; i < deleteTrackers.size(); i++)
	{
		int width = snapshots[deleteTrackers[i]].objInfo.right - snapshots[deleteTrackers[i]].objInfo.left;
		int height = snapshots[deleteTrackers[i]].objInfo.bottom - snapshots[deleteTrackers[i]].objInfo.top;
		
		if (width > minBoxSize[snapshots[deleteTrackers[i]].objInfo.objectIndex].width && height > minBoxSize[snapshots[deleteTrackers[i]].objInfo.objectIndex].height)
		{
			saveTimes++;
		//	cout << saveTimes << endl;
			boost::mutex::scoped_lock lock(threadMutex);
			tempDeleteID.push_back(deleteTrackers[i]);  //将需要保存快照的ID传入
		}
		else
		{
			snapshots[deleteTrackers[i]].objImg.release();
			snapshots.erase(snapshots.find(deleteTrackers[i]));
		}
	}

	if (!tempDeleteID.empty())
	{
		boost::mutex::scoped_lock lock(threadMutex);
		beginSaveSnapshot = true;
	}
}

//char imgName[260];
//sprintf(imgName, "%sSnapshot//%d.jpg", mResDir, deleteTrackers[i]);
//imwrite(imgName, snapshots[deleteTrackers[i]].objImg);
//
//Mat objImg;
///*Rect rect(snapshots[deleteTrackers[i]].objInfo.left, snapshots[deleteTrackers[i]].objInfo.top,
//snapshots[deleteTrackers[i]].objInfo.right - snapshots[deleteTrackers[i]].objInfo.left, snapshots[deleteTrackers[i]].objInfo.bottom - snapshots[deleteTrackers[i]].objInfo.top);*/
////snapshots[deleteTrackers[i]].objImg/*(rect)*/.copyTo(objImg); 
//
//char objName[260];
//sprintf(objName, "%sSnapshotLittle//%d.jpg", mResDir, deleteTrackers[i]);
///*imwrite(objName, objImg);*/
//
//strcpy(snapshots[deleteTrackers[i]].objInfo.firstPicPath, imgName);
//strcpy(snapshots[deleteTrackers[i]].objInfo.secondPicPath, objName);
//
//if (mVideoObjSnapshotCallBack != NULL)
//mVideoObjSnapshotCallBack(&snapshots[deleteTrackers[i]].objInfo);