graft_cv/imstorage_manager.cpp

#include "stdafx.h"
#include <io.h>
#include <time.h>
#include <stdio.h>
#include <pcl\io\ply_io.h>
#include <pcl\point_types.h>
#include "imstorage_manager.h"

//namespace graft_gcv
//{


CRITICAL_SECTION g_cs;
CRITICAL_SECTION g_cs_pcd;

void getFiles( string path, vector<string>& files, time_t clean_time )
{
    //文件句柄
    long   hFile   =   0;
    //文件信息
    struct _finddata_t fileinfo;
    string p;
    if((hFile = _findfirst(p.assign(path).append("\\*").c_str(),&fileinfo)) !=  -1)
    {
        do
        {
            //如果是目录,迭代之
            //如果不是,加入列表
            if((fileinfo.attrib &  _A_SUBDIR))
            {
                if(strcmp(fileinfo.name,".") != 0  &&  strcmp(fileinfo.name,"..") != 0)
                    getFiles( p.assign(path).append("\\").append(fileinfo.name), files ,clean_time);
            }
            else
            {
				if(clean_time>fileinfo.time_create){
					files.push_back(p.assign(path).append("\\").append(fileinfo.name) );
				}
            }
        }while(_findnext(hFile, &fileinfo)  == 0);
        _findclose(hFile);
    }
}
bool g_thread_run=false;
bool g_thread_run_saver=true;
bool g_thread_run_saver_pcd = true;
int WINAPI TheadFuncClearn(LPVOID lpParam)
{
    ThreadParamClean*  threadParam = (ThreadParamClean *) lpParam;    
	string folder =threadParam->folder;	
	int store_days = threadParam->store_days;
	bool* state = threadParam->state;
	int cnt=0;
	__time64_t dtime = store_days*86400;
	//cout<<"folder: "<<folder<<endl;
	time_t scan_time = time(NULL);
	while(folder.size()>0)
    {
		if(!(*state)){break;}   
		if(time(NULL)-scan_time < 3600000){
			Sleep(500);
			continue;
		}
		vector<string>filenames;
		time_t clean_time = time(NULL) - dtime;		
		getFiles(folder,filenames,clean_time);
		scan_time = time(NULL);
		for(size_t i=0;i<filenames.size();++i){			
			//delete the file
			remove(filenames[i].c_str());
		}
		
    }
    return 0;
}
int WINAPI TheadFuncSave(LPVOID lpParam)
{
	ThreadParamSave*  threadParam = (ThreadParamSave *) lpParam;
    int nIndex = threadParam->nIndex;
    queue<ImgParam>* imgQ =threadParam->imgQ;	
    while(true)
    {		
		if(!g_thread_run_saver){break;}
		if(imgQ->size()==0){
			Sleep(50);
			continue;
		}
		try{
			EnterCriticalSection(&g_cs);
			ImgParam& im_info = imgQ->front();
			cv::imwrite(im_info.img_name,im_info.image);
			//cout<<im_info.img_name<<"\t"<<imgQ->size()<<endl;
			imgQ->pop();		
		}
		catch(...){
			//int tes = 0;
		}
		LeaveCriticalSection(&g_cs);
    }
    return 0;
}
int WINAPI TheadFuncSavePcd(LPVOID lpParam)
{
	ThreadParamSavePcd*  threadParam = (ThreadParamSavePcd *)lpParam;
	int nIndex = threadParam->nIndex;
	queue<PcdParam>* pcdQ = threadParam->pcdQ;
	while (true)
	{
		if (!g_thread_run_saver_pcd) { break; }
		if (pcdQ->size() == 0) {
			Sleep(50);
			continue;
		}
		try {
			EnterCriticalSection(&g_cs_pcd);
			PcdParam& pcd_info = pcdQ->front();
			pcl::io::savePLYFile(pcd_info.pcd_name, *pcd_info.pcd, true);			
			//cout<<im_info.img_name<<"\t"<<imgQ->size()<<endl;
			pcdQ->pop();
		}
		catch (...) {
			//int tes = 0;
		}
		LeaveCriticalSection(&g_cs_pcd);
	}
	return 0;
}
	
CImStoreManager::CImStoreManager()
	:m_storeDays(7)
	,m_storeDir(""),
	m_workHandle(0),
	m_workHandleSave(0),
	m_workHandleSavePcd(0)
{	
	InitializeCriticalSection(&g_cs);
	ThreadParamSave paramSave;
	paramSave.nIndex = 0;
	//paramSave.state = &g_thread_run;
	paramSave.imgQ = &m_images;
	m_workHandleSave = CreateThread(
		NULL, 
		0, 
		(LPTHREAD_START_ROUTINE)TheadFuncSave,
		(LPVOID)&paramSave, 
		NULL, 
		NULL);

	InitializeCriticalSection(&g_cs_pcd);
	ThreadParamSavePcd paramSavePcd;
	paramSavePcd.nIndex = 0;
	//paramSave.state = &g_thread_run;
	paramSavePcd.pcdQ = &m_pcds;
	m_workHandleSavePcd = CreateThread(
		NULL,
		0,
		(LPTHREAD_START_ROUTINE)TheadFuncSavePcd,
		(LPVOID)&paramSavePcd,
		NULL,
		NULL);
	Sleep(500);
}
CImStoreManager::~CImStoreManager(){
	g_thread_run=false;
	g_thread_run_saver=false;
	g_thread_run_saver_pcd = false;
	HANDLE handles[3];
	handles[0]=m_workHandle;
	handles[1]=m_workHandleSave;
	handles[2] = m_workHandleSavePcd;
	WaitForMultipleObjects(3,handles,TRUE,500);
	DeleteCriticalSection(&g_cs);
	DeleteCriticalSection(&g_cs_pcd);

}

void CImStoreManager::restart_start_worker()
{	
	ThreadParamClean param_clean;
	param_clean.folder = m_storeDir;
	param_clean.store_days = m_storeDays;
	param_clean.state = &g_thread_run;
	g_thread_run=false;
	if(m_workHandle){
		WaitForSingleObject(m_workHandle,INFINITE);		
		CloseHandle(m_workHandle);
	}
	g_thread_run=true;
	m_workHandle = CreateThread(
		NULL, 
		0, 
		(LPTHREAD_START_ROUTINE)TheadFuncClearn,
		(LPVOID)&param_clean, 
		NULL, 
		NULL);	
	Sleep(500);
}
int CImStoreManager::setStoreDir(string& folder)
{
	int stat = _access(folder.c_str(),0);
	if (stat==0){
		m_storeDir = folder;
		g_thread_run=false;
		restart_start_worker();
	}
	else{
		return 1;
	}
	return 0;
}
void CImStoreManager::getStoreDir(string& folder)
{
	folder = m_storeDir;
}
void CImStoreManager::setStoreDays(int days)
{
	if(days>0){
		m_storeDays = days;
		g_thread_run=false;
		restart_start_worker();
	}
}
bool CImStoreManager::is_valid_folder()
{
	int stat = _access(m_storeDir.c_str(),0);
	if(stat==0){return true;}
	else{return false;}
}

int CImStoreManager::saveImage(cv::Mat&img,string name_id)
{	
	if(!is_valid_folder()){return 1;}
	if(img.empty()){return 1;}
	string tar_file = m_storeDir+"/"+name_id+".jpg";
	ImgParam imgp;
	imgp.img_name=tar_file;
	imgp.image = img.clone();
	EnterCriticalSection(&g_cs);
	m_images.push(imgp);
	//cout<<"=========="<<imgp.img_name<<endl;
	LeaveCriticalSection(&g_cs);
	
	return 0;
}

int CImStoreManager::saveBinPly(
	pcl::PointCloud<pcl::PointXYZ>::Ptr pcd, 
	string name_id)
{
	if (!is_valid_folder()) { return 1; }
	if (pcd->points.size()==0) { return 1; }
	
	EnterCriticalSection(&g_cs_pcd);
	string tar_file = m_storeDir + "/" + name_id + ".ply";		
	PcdParam pcdp;
	pcdp.pcd.reset(new pcl::PointCloud<pcl::PointXYZ>);
	pcdp.pcd_name = tar_file;
	pcl::copyPointCloud(*pcd, *pcdp.pcd);	
	
	m_pcds.push(pcdp);
	//cout<<"=========="<<pcdp.pcd_name<<endl;
	LeaveCriticalSection(&g_cs_pcd);

	return 0;
}
//};