PhysicalDevice/Detector/CCOS.Dev.FPDDeviceMould-US/DIOS.Dev.FPD.CalibUnit.cpp

// CCOS.Dev.FPD.DEMO.cpp : 定义 DLL 应用程序的导出函数。
//

#include "stdafx.h"
#include "CCOS.Dev.FPDDeviceMould.hpp"

using namespace CCOS::Dev;
using namespace CCOS::Dev::Detail::Detector;
namespace nsFPD = CCOS::Dev::Detail::Detector;

extern Log4CPP::Logger* gLogger;
//-----------------------------------------------------------------------------
//		CalibUnit
//-----------------------------------------------------------------------------
nsFPD::CalibUnit::CalibUnit()
{
	m_CurrentCalibType = CCOS_CALIBRATION_TYPE_NONE;
	m_CalibStatus = CCOS_CALIBRATION_STATUS_MAX;
	m_strCalibProgress = "0";
	m_strUploadCalibrationFilesResult = "0";
	m_strSaveCalibrationFileFinish = "0";
}

nsFPD::CalibUnit:: ~CalibUnit()
{

}

void OEM_IF nsFPD::CalibUnit::SetEventCenter(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter)
{
	m_EventCenter = EventCenter;
}


RET_STATUS nsFPD::CalibUnit::JSSetSID(std::string in, std::string& out)
{
	Info("SetSID. {$}", in.c_str());
	ResDataObject json;
	json.decode(in.c_str());
	int mode = json[0];
	return SetSID(mode);
}

RET_STATUS nsFPD::CalibUnit::JSActiveCalibration(std::string in, std::string & out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int mode = json[0];

	Info("ActiveCalibration. {$}", in.c_str());
	Info("Calibrationtype is {$}", mode);
	out = "test@ActiveCalibration";
	CCOS_CALIBRATION_TYPE type = CCOS_CALIBRATION_TYPE_NONE;
	if (mode == CCOS_CALIBRATION_TYPE_DARK)
	{
		type = CCOS_CALIBRATION_TYPE_DARK;
	}
	else if (mode == CCOS_CALIBRATION_TYPE_XRAY)
	{
		type = CCOS_CALIBRATION_TYPE_XRAY;
	}
	RET_STATUS bret = ActiveCalibration(type);
	if (RET_STATUS::RET_SUCCEED == bret)
	{
		m_CurrentCalibType = type;
	}
	return bret;
}

RET_STATUS nsFPD::CalibUnit::JSGetRequestedDose(std::string in, std::string& out)
{
	Info("GetRequestedDose");
	string strDoseInfo = "";
	RET_STATUS bret = GetRequestedDose(strDoseInfo);
	if (RET_STATUS::RET_SUCCEED == bret)
	{
		out = strDoseInfo;
	}
	return bret;
}


RET_STATUS nsFPD::CalibUnit::JSSetRequestedDose(std::string in, std::string& out)
{
	Info("SetRequestedDose. \n{$}", in.c_str());
	RET_STATUS nRet = SetRequestedDose(in);
	return nRet;
}


RET_STATUS nsFPD::CalibUnit::SetRequestedDose(std::string in)
{
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::CalibUnit::JSPrepareCalibration(std::string in, std::string& out)
{
	Info("PrepareCalibration.");
	return PrepareCalibration();
}

RET_STATUS nsFPD::CalibUnit::JSStartCalibration(std::string in, std::string& out)
{
	Info("StartCalibration.");
	return StartCalibration();
}

RET_STATUS OEM_IF nsFPD::CalibUnit::PauseCalibration()
{
	Info("PauseCalibration.");

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::JSStopCalibration(std::string in, std::string& out)
{
	Info("StopCalibration.");
	return StopCalibration();
}

RET_STATUS nsFPD::CalibUnit::JSSetCorrectionType(std::string in, std::string & out)
{

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::JSGetCalibStatus(std::string & out)
{
	auto szFDinfo = std::to_string(m_CalibStatus);
	out = szFDinfo;

	return RET_STATUS::RET_SUCCEED;
}

void OEM_IF nsFPD::CalibUnit::SetCalibrationStatus(CCOS_CALIBRATION_STATUS Status)
{
	string strTemp = "";
	switch (Status)
	{
	case CCOS_CALIBRATION_STATUS_ERROR:
		strTemp = "ZSKK_FPD_STATE_ERROR";
		break;
	case CCOS_CALIBRATION_STATUS_STANDBY:
		strTemp = "ZSKK_FPD_STATE_STANDBY";
		break;
	case CCOS_CALIBRATION_STATUS_ACTIVE:
		strTemp = "ZSKK_FPD_STATE_ACTIVE";
		break;
	case CCOS_CALIBRATION_STATUS_RUNNING:
		strTemp = "ZSKK_FPD_STATE_RUNNING";
		break;
	case CCOS_CALIBRATION_STATUS_PAUSE:
		strTemp = "ZSKK_FPD_STATE_PAUSE";
		break;
	case CCOS_CALIBRATION_STATUS_PREPARE:
		strTemp = "ZSKK_FPD_STATE_PREPARE";
		break;
	default:
		break;
	}
	m_CalibStatus = Status;

	auto szFDinfo = std::to_string(Status);
	std::string str = szFDinfo;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::CalibrationStatus, str);

	Info("SetCalibrationStatus. {$}",strTemp.c_str());
	return;
}

CCOS_CALIBRATION_STATUS OEM_IF nsFPD::CalibUnit::GetCalibrationStatus()
{
	return m_CalibStatus;
}

RET_STATUS nsFPD::CalibUnit::JSGetCalibProgress(std::string & out)
{
	out = m_strCalibProgress;
	return RET_STATUS::RET_SUCCEED;
}

void OEM_IF nsFPD::CalibUnit::SetCalibrationProgress(DWORD progress)
{
	auto szFDinfo = std::to_string(progress);
	m_strCalibProgress = szFDinfo;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::CalibrationProgress, m_strCalibProgress);

	Info("SetCalibrationProgress. {$}",progress);
	return;
}
CCOS_CALIBRATION_TYPE OEM_IF nsFPD::CalibUnit::GetCalibrationType()
{
	return m_CurrentCalibType;
}

RET_STATUS nsFPD::CalibUnit::JSUploadCalibrationFiles(std::string in, std::string & out)
{
	ResDataObject json;
	json.decode(in.c_str());
	string mode = "";
	try{
		mode = (string)json[0];
	}
	catch (...)
	{
		return RET_STATUS::RET_FAILED;
	}

	return UploadCalibrationFiles(mode);
}

RET_STATUS nsFPD::CalibUnit::JSGetUploadCalibrationFilesResult(std::string & out)
{
	out = m_strUploadCalibrationFilesResult;
	return RET_STATUS::RET_SUCCEED;
}

void OEM_IF nsFPD::CalibUnit::SetUploadCalibrationFilesResult(bool bResult)
{
	auto szFDinfo = std::to_string(bResult);
	m_strUploadCalibrationFilesResult = szFDinfo;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, "UploadCalibrationFilesResult", m_strUploadCalibrationFilesResult);

	Info("SetUploadCalibrationFilesResult. {$}", bResult);
	return;
}

RET_STATUS nsFPD::CalibUnit::JSGetSupportCalibrationType(std::string& out)
{
	ResDataObject tmp;
	if (Support_DarkCalib())
	{
		tmp.add("Offset", CCOS_CALIBRATION_TYPE_DARK);
	}
	if (Support_XrayCalib())
	{
		tmp.add("Gain", CCOS_CALIBRATION_TYPE_XRAY);
	}
	if (tmp.size() > 0)
	{
		out = tmp.encode();
	}
	else
	{
		out = "";
		return RET_STATUS::RET_NOSUPPORT;
	}
	return RET_STATUS::RET_SUCCEED;
}

bool nsFPD::CalibUnit::Support_DarkCalib()
{
	return false;
}

bool nsFPD::CalibUnit::Support_XrayCalib()
{
	return false;
}


RET_STATUS nsFPD::CalibUnit::JSGetHaveImgCalibration(std::string& out)
{
	if (Support_HaveImageCalib())
	{
		out =  "1";
	}
	else
	{
		out =  "0";
	}
	Info("JSGetHaveImgCalibration out:{$}",out.c_str());
	return RET_STATUS::RET_SUCCEED;
}

bool nsFPD::CalibUnit::Support_HaveImageCalib()
{
	return false;
}


RET_STATUS nsFPD::CalibUnit::JSGetCalibrationStep(std::string in, std::string& out)
{
	Info("GetCalibrationStep. \n{$}", in.c_str());
	ResDataObject jsonInput;
	jsonInput.decode(in.c_str());
	int nDetectorID = 0;
	string strCalibrationStepInfo;
	try
	{
		//
	}
	catch (...)
	{
		Error("GetCalibrationStep parameter error");
		return RET_STATUS::RET_FAILED;
	}
	RET_STATUS nRet = GetCalibrationStep(nDetectorID, strCalibrationStepInfo);
	out = strCalibrationStepInfo;
	return nRet;
}


RET_STATUS nsFPD::CalibUnit::GetCalibrationStep(int nDetectorID, std::string& strCalibrationStepInfo)
{
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::CalibUnit::JSAcceptCalibration(std::string in, std::string& out)
{
	RET_STATUS nRet = AcceptCalibration();
	return nRet;
}


RET_STATUS nsFPD::CalibUnit::AcceptCalibration()
{
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::CalibUnit::JSRejectCalibration(std::string in, std::string& out)
{
	RET_STATUS nRet = RejectCalibration();
	return nRet;
}


RET_STATUS nsFPD::CalibUnit::RejectCalibration()
{
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::CalibUnit::JSSaveCalibrationFile(std::string in, std::string& out)
{
	Info("SaveCalibrationFile.\n{$}", in.c_str());
	ResDataObject jsonInput;
	jsonInput.decode(in.c_str());
	bool bSaveFlag = false;
	try
	{
		bSaveFlag = (bool)jsonInput[0];
	}
	catch (...)
	{
		Error("SaveCalibrationFile parameter error");
		return RET_STATUS::RET_FAILED;
	}
	RET_STATUS nRet = SaveCalibrationFile(bSaveFlag);
	return nRet;
}


RET_STATUS nsFPD::CalibUnit::SaveCalibrationFile(bool bSaveFlag)
{
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::CalibUnit::JSGetSaveCalibrationFileFinish(std::string& out)
{
	out = m_strSaveCalibrationFileFinish;
	return RET_STATUS::RET_SUCCEED;
}


void OEM_IF nsFPD::CalibUnit::SetSaveCalibrationFileFinish(bool bResult)
{
	string strFPDInfo = std::to_string(bResult);
	m_strSaveCalibrationFileFinish = strFPDInfo;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, "SaveCalibrationFileFinish", m_strSaveCalibrationFileFinish);

	Info("SetSaveCalibrationFileFinish. {$}", strFPDInfo);
	return;
}