tea_cv/tea_cv_api.cpp

#include <string.h>
#include <fstream>

#include "tea_cv_api.h"
#include "data_def.h"
#include "data_def_api.h"
#include "config.h"
//#include "optimal_angle.h"
//#include "cut_point_rs.h"
//#include "cut_point_sc.h"
#include "logger.h"
#include "utils.h"
#include "imstorage_manager.h"
#include "tea_sorter.h"
#include "chessboard.h"




extern CRITICAL_SECTION g_cs;
namespace graft_cv
{

	char *g_version_str = "0.1.3";

	//configure
	string g_conf_file = "./tcv_conf.yml";	
	ConfigParam g_cp;

	//logger
	ofstream g_logger_ofs;
	CGcvLogger g_logger = CGcvLogger(
		g_logger_ofs,
		CGcvLogger::file_and_terminal,
		CGcvLogger::debug,
		"./tcv.log");	

	//image saver
	
	CImStoreManager* g_pImStore=0;

	//implement	
	CTeaSort g_tg = CTeaSort(g_cp, img_type::tea_grab, &g_logger);
	CTeaSort g_tc = CTeaSort(g_cp, img_type::tea_cut, &g_logger);
	CChessboard g_cb = CChessboard(g_cp, &g_logger);

	//??¶àÏß³ÌÓÐÎÊÌâ
	map<string, cv::Mat> g_img_cache;
	

	//1 log path
	int cv_set_logpath(char*lpath)
	{	
		try{
			string mp = g_logger.getPath();
			string np(lpath);
			if(mp==np){
				return 0;
			}

			g_logger_ofs.close();
			g_logger_ofs.open(lpath,ofstream::out | ofstream::app);
			string tmp = currTime() +" [WELCOME] ===========start logger===========\n";
			
			g_logger_ofs<<tmp;
			g_logger_ofs.flush();
			cout<<tmp<<endl;
			g_logger.setPath(string(lpath));
			return 0;
		}
		catch(...){
			g_logger.ERRORINFO("set log path failed");
			return 1;
		}
	}
	//2  0-debug, 1-info, 2-warning, 3-error
	int cv_set_loglevel(int lev)
	{	
		if(lev <0 || lev>3){
			g_logger.ERRORINFO("log level error: should in [0,1,2,3]  0-debug, 1-info, 2-warning, 3-error");
			return 1;
		}
		try{
			switch(lev){
			case 0:
				g_logger.setLevel(CGcvLogger::debug);
				break;
			case 1:
				g_logger.setLevel(CGcvLogger::info);
				break;
			case 2:
				g_logger.setLevel(CGcvLogger::warning);
				break;
			case 3:
				g_logger.setLevel(CGcvLogger::error);
				break;
			default:
				g_logger.ERRORINFO("log level error: should in [0,1,2,3]  0-debug, 1-info, 2-warning, 3-error");
				return 1;
			}
			return 0;
		}
		catch(...){
			g_logger.ERRORINFO("set log level failed");
			return 1;
		}
	}
	//3
	int cv_init_image_saver()
	{		
		if( g_cp.image_save){
			if(g_pImStore){
				string folder;
				g_pImStore->getStoreDir(folder);
				if(folder!=g_cp.image_depository){				
					delete g_pImStore;
					g_pImStore = new CImStoreManager();
					g_pImStore->setStoreDir(g_cp.image_depository);
					g_pImStore->setStoreDays(g_cp.image_backup_days);
				}

			}
			else{
				g_pImStore = new CImStoreManager();
				g_pImStore->setStoreDir(g_cp.image_depository);
				g_pImStore->setStoreDays(g_cp.image_backup_days);
			}
		}
		else{
			if(g_pImStore){
				delete g_pImStore;
				g_pImStore=0;
			}			
		}		
		g_tg.set_image_saver(&g_pImStore);
		g_tc.set_image_saver(&g_pImStore);
		g_cb.set_image_saver(&g_pImStore);
		return 0;
	}
	

	//4
	int cv_init(char*conf)
	{
		//InitializeCriticalSection(&g_cs);
		CGCvConfig conf_contrainer = CGCvConfig();
		conf_contrainer.setConfParam(&g_cp);
		if(conf){
			//read configures
			ifstream ifs(conf);
			if(!ifs.good()){return 1;}			
			ifs.close();
			memset(&g_cp,0,sizeof(ConfigParam));

			cv::FileStorage fs(conf, cv::FileStorage::READ);
			conf_contrainer.read(fs["conf_parameters"]);	
			fs.release();
			g_conf_file = conf;
			
			
		}
		else{
			ifstream ifs(g_conf_file);
			if(!ifs.good()){return 1;}			
			ifs.close();
			memset(&g_cp,0,sizeof(ConfigParam));
			
			//read configures
			cv::FileStorage fs(g_conf_file, cv::FileStorage::READ);
			conf_contrainer.read(fs["conf_parameters"]);	
			fs.release();
			
		}
		string pinfo = get_cparam_info(&g_cp);
		g_logger.INFO(string("lib version: ")+string(g_version_str));
		g_logger.INFO(string("load parameters:\n")+pinfo);
		
		return 0;
	};


	//5
	void cv_set_param(ConfigParam&cp)
	{
		g_cp = cp;	
		string pinfo = get_cparam_info(&g_cp);
		g_logger.INFO(string("set parameters:\n")+pinfo);
	};
	int cv_set_param_from_file(char*conf)
	{
		if (conf == 0) {
			return 1;
		}
		ConfigParam cp;
		CGCvConfig conf_contrainer = CGCvConfig();
		conf_contrainer.setConfParam(&g_cp);
		//read configures
		ifstream ifs(conf);
		if (!ifs.good()) { return 1; }
		ifs.close();
		
		memset(&g_cp, 0, sizeof(ConfigParam));

		cv::FileStorage fs(conf, cv::FileStorage::READ);
		conf_contrainer.read(fs["conf_parameters"]);
		fs.release();
		g_conf_file = conf;
		return 0;

	}
	
	//6
	int cv_release()
	{
		if(g_pImStore){
			delete g_pImStore;
			g_pImStore = 0;
		}
		//DeleteCriticalSection(&g_cs);
		return 0;
	}
	
	//7
	void cv_get_conf_file(char*buff)
	{
		strcpy_s(buff, g_conf_file.size()+1, g_conf_file.c_str());
	};

	//8
	void cv_save_param(char* conf_file/*=0*/)
	{
		//save configures
		CGCvConfig conf_contrainer = CGCvConfig();
		conf_contrainer.setConfParam(&g_cp);
		if(conf_file){
			cv::FileStorage fs(
				conf_file,
				cv::FileStorage::WRITE
				);
			fs<<"conf_parameters";	
			fs<<conf_contrainer;		
			fs.release();	
		}
		else{
			cv::FileStorage fs(
				g_conf_file, 
				cv::FileStorage::WRITE
				);
			fs<<"conf_parameters";	
			fs<<conf_contrainer;		
			fs.release();	
		}
	}
	//9
	void cv_get_param(ConfigParam&cp)
	{
		cp = g_cp;		
	};
	//10
	void get_version(char* buf)
	{			
		strcpy_s(buf, strlen(g_version_str)+1,g_version_str);
	};
	
	//11
	int tea_grab_point(
		ImgInfo* imginfo,
		PositionInfo& posinfo,
		const char* fn
		)
	{
		memset(&posinfo,0,sizeof(PositionInfo));
		try{
			int r = g_tg.load_model();	
			if (r != 0) {
				g_logger.ERRORINFO("model load failed");
				return 1;
			}
			r = g_tg.detect(imginfo, posinfo, fn);
			return r;						
		}
		catch(std::exception &err){
			g_logger.ERRORINFO(err.what());
			return 1;
		}
		catch(string& msg){
			g_logger.ERRORINFO(msg);
			return 1;
		}		
		catch(...){
			g_logger.ERRORINFO("unknown error");
			return 1;
		}
		return 0;
		
	}

	//12
	int tea_cut_point(
		ImgInfo* imginfo,
		PositionInfo& posinfo,
		const char* fn
	)
	{
		memset(&posinfo, 0, sizeof(PositionInfo));
		try {
			int r = g_tc.load_model();
			if (r != 0) {
				g_logger.ERRORINFO("model load failed");
				return 1;
			}
			r = g_tc.detect(imginfo, posinfo, fn);
			return r;
		}
		catch (std::exception &err) {
			g_logger.ERRORINFO(err.what());
			return 1;
		}
		catch (string& msg) {
			g_logger.ERRORINFO(msg);
			return 1;
		}
		catch (...) {
			g_logger.ERRORINFO("unknown error");
			return 1;
		}
		return 0;

	}

	//13
	int chessboard_corners(
		ImgInfo*imginfo,
		PositionInfo& posinfo,
		int corner_row,
		int corner_col,
		int x0,
		int y0,
		int width,
		int height,
		const char* fn)
	{
		memset(&posinfo, 0, sizeof(PositionInfo));
		try {			
			int r = g_cb.detect(imginfo,
				posinfo,
				corner_row,
				corner_col,
				x0,
				y0,
				width,
				height,
				fn);
			return r;
		}
		catch (std::exception &err) {
			g_logger.ERRORINFO(err.what());
			return 1;
		}
		catch (string& msg) {
			g_logger.ERRORINFO(msg);
			return 1;
		}
		catch (...) {
			g_logger.ERRORINFO("unknown error");
			return 1;
		}
		return 0;
	}


};