graft_cv/graft_cv_api.cpp

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

#include "graft_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 "cut_point_rs_reid.h"

#include "grab_point_rs.h"

extern CRITICAL_SECTION g_cs;
namespace graft_cv
{

	char *g_version_str = "0.6.10";

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

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

	//image saver
	
	CImStoreManager* g_pImStore=0;

	//implement
	//COptimalAnglePart g_oa = COptimalAnglePart(g_cp,&g_logger);
	CCotyledonAngle g_oa = CCotyledonAngle(g_cp,&g_logger);
	CRootStockCutPoint g_rs_cp = CRootStockCutPoint(g_cp,&g_logger);
	CRootStockCutPointReid g_rs_cp_reid = CRootStockCutPointReid(g_cp,&g_logger);
	CScionCutPoint g_sc_cp = CScionCutPoint(g_cp,&g_logger);

	CRootStockGrabPoint g_rs_gp(g_cp, &g_logger);

	CSolaCutPointReid g_sola_rs = CSolaCutPointReid(g_cp, 1, &g_logger);
	CSolaCutPointReid g_sola_sc = CSolaCutPointReid(g_cp, 0, &g_logger);

	//
	map<string, cv::Mat> g_img_cache;
	

	//0 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;
		}
	}
	// 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;
		}
	}

	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_oa.set_image_saver(&g_pImStore);
		g_rs_cp.set_image_saver(&g_pImStore);
		g_sc_cp.set_image_saver(&g_pImStore);
		return 0;
	}

	GCV_API int cv_release()
	{
		if(g_pImStore){
			delete g_pImStore;
			g_pImStore = 0;
		}
		//DeleteCriticalSection(&g_cs);
		return 0;
	}

	//1
	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;
	};
	//2
	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;

	}
	//3
	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();	
		}
	}
	//4
	void cv_get_param(ConfigParam&cp)
	{
		cp = g_cp;		
	};
	//5
	void get_version(char* buf)
	{			
		strcpy_s(buf, strlen(g_version_str)+1,g_version_str);
	};
	
	//6
	void cv_get_conf_file(char*buff)
	{
		strcpy_s(buff, g_conf_file.size()+1, g_conf_file.c_str());
	};

	//7
	/*int rs_oa_init()
	{
		return g_oa.reset();		
	};*/
	//8
	/*int rs_oa_append(
		ImgInfo* imginfo,
		PositionInfo& posinfo
		)
	{
		memset(&posinfo,0,sizeof(PositionInfo));
		try{
			g_oa.append(imginfo, posinfo);			
			
		}
		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;
	};*/
	//
	int sola_grab_point(
		float* points,
		int pixel_size,
		int pt_size, 
		int dtype,
		PositionInfo& posinfo,
		const char* fn/*=0*/
	)
	{
		memset(&posinfo, 0, sizeof(PositionInfo));
		try {
			int rst = g_rs_gp.load_data(points, pixel_size, pt_size, fn);
			if (rst <= 0) {
				g_logger.ERRORINFO("invalid points");
				return 1;
			}
			int oa = g_rs_gp.grab_point_detect(dtype, posinfo);
			if (oa != 0) {
				g_logger.ERRORINFO("no points");
				return 1;
			}
		}
		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;

	}


	//9
	int rs_oa_get_result(
		ImgInfo* imginfo,
		PositionInfo& posinfo
		)
	{
		memset(&posinfo,0,sizeof(PositionInfo));
		try{
			double oa = g_oa.angle_recognize(imginfo, posinfo);
			
		}
		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;
		
	}

	//10
	int rs_cut_point(
		ImgInfo* imginfo, 
		PositionInfo& posinfo
		)		
	{
		memset(&posinfo,0,sizeof(PositionInfo));
		try{
			g_rs_cp.up_point_detect(
				imginfo,
				cv::Mat(),
				posinfo, 
				g_img_cache
				);
		}
		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;
		
	}

	//11
	int rs_cut_point_reid(ImgInfo*imginfo , const char* pre_img_id, PositionInfo& posinfo)
	{
		memset(&posinfo,0,sizeof(PositionInfo));
		try{
			g_rs_cp_reid.cut_point_reid(
				imginfo,
				cv::Mat(),
				pre_img_id,
				posinfo,
				g_img_cache
				);
		}
		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;		
	}

	// 
	int sola_cut_point_reid(ImgInfo*imginfo, int sola_type, PositionInfo& posinfo)
	{
		memset(&posinfo, 0, sizeof(PositionInfo));
		try {
			if (sola_type == 0) {
				g_sola_sc.cut_point_reid(imginfo, cv::Mat(), posinfo);
			}
			else {
				g_sola_rs.cut_point_reid(imginfo, cv::Mat(), posinfo);
			}			
		}
		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 sc_cut_point(
		ImgInfo* imginfo, 
		PositionInfo& posinfo
		)
	{
		memset(&posinfo,0,sizeof(PositionInfo));
		try{
			g_sc_cp.up_point_detect(
				imginfo,
				cv::Mat(),
				posinfo
				);
		}
		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;
	}

};