PhysicalDevice/Detector/Rayence/DIOS.Dev.FPD.Rayence/Detector_Rayence.cpp

#include "stdafx.h"
#include "Detector_Rayence.h"
#include "CCOS.Dev.FPD.Rayence.h"

extern Log4CPP::Logger* gLogger;

Detector_Rayence* g_pDetector = nullptr;
Detector_Rayence* g_pRayenceInstance = nullptr;
LogicClient* m_pSynClient;

void CALLBACK G_Rayence_InfoMessage(int nCode, TCHAR* szMessage)
{
	g_pRayenceInstance->CALLBACK_InfoMessage(nCode, szMessage);
}

void CALLBACK G_Rayence_OnEvent(tVDACQ_CallBackRec* ACBR)
{
	g_pRayenceInstance->CALLBACK_Acquisition(ACBR);
}

void CALLBACK G_Rayence_OnDarkEvent(tVDACQ_CallBackRec* ACBR)
{
	g_pRayenceInstance->CALLBACK_Dark_Acquisition(ACBR);
}

Detector_Rayence::Detector_Rayence()
	:m_pFrm1x1Buffer{},
	m_pFrm2x2Buffer{},
	m_pDark1x1Buffer{},
	m_pDark2x2Buffer{},
	m_pFrm1x1AveBuffer{},
	m_pFrm2x2AveBuffer{},
	m_pOneShotBuffer{},
	m_pFullImgBuffer{},
	m_hOffsetThreadStatus{},
	m_hOffsetThread{},
	m_nPanelCount{},
	m_nCurrentPanelID{},
	m_nImageWidth{},
	m_nImageHeight{},
	m_nFrmWidth{},
	m_nFrmHeight{},
	m_nCropLeft{},
	m_nCropRight{},
	m_nCropTop{},
	m_nCropBottom{},
	m_nRawImgHeight{},
	m_nRawImgWidth{},
	m_nAveCount{},
	m_nBinningMode{},
	m_nCalBinning{},
	m_nFrmAveBufSize{},
	m_strLastLogicMode{},
	m_strCurrentLogicMode{},
	m_strWorkPath{},
	m_nImageIndex{},
	m_fFrameRate{},
	m_nCalModeId{},
	m_nCalToAcqNum{},
	m_nExposureTime{},
	m_nFlags{},
	m_nRecvCount{},
	m_nSensitivity{},
	m_nSkipNum{},
	m_nExamMode(APP_STATUS::APP_STATUS_MAX),
	m_nExiThreshold(200),
	m_bRayAcqing(false),
	m_bSaveRaw(false),
	m_bOffsetBuffer(false),
	m_bAbortOffset(false),
	m_bCalOffset(false),
	m_bCalGain(false),
	m_bCalBPM(false),
	m_bDoOffset(false),
	m_bRayenceConnect(false),
	m_bRefreshAllMode(false),
	m_eCaliType(CCOS_CALIBRATION_TYPE::CCOS_CALIBRATION_TYPE_NONE),
	m_eStatus(eDetStatus::DetStatus_NotInit)
{
	g_pRayenceInstance = this;
	m_pDPC2PanelID = new map<void*, int>();
	m_pPanelID2DPC = new map<int, void*>();
	
	InitializeCriticalSection(&m_cs); 

	//work with sync box for Rad
	m_pSynClient = new LogicClient("V3_FullUCB", "NSQ", "", false);
	if (m_pSynClient->Open("ccosChannel", ALL_ACCESS))
	{
		FDEBUG("Ccos_V3 Create V3_FullUCB Client success");
	}
}

Detector_Rayence::~Detector_Rayence()
{
	if (m_pFullImgBuffer != nullptr)
	{
		delete[] m_pFullImgBuffer;
		m_pFullImgBuffer = nullptr;
	}

	if (m_pSynClient)
	{
		if (!m_pSynClient->IsClosed())
		{
			m_pSynClient->Close();
		}
		delete m_pSynClient;
		m_pSynClient = nullptr;
	}
}

bool Detector_Rayence::DriverEntry(void* pDrvDPC, ResDataObject& Configuration)
{
	FINFO("--Func-- DriverEntry {$}", pDrvDPC);

	map<void*, int>::iterator DPCsIter = m_pDPC2PanelID->find(pDrvDPC);
	if (DPCsIter != m_pDPC2PanelID->end())
	{
		FERROR("This DPC already exist");
		return false;
	}

	m_pDPC2PanelID->insert(pair<void*, int>(pDrvDPC, m_nPanelCount));
	m_pPanelID2DPC->insert(pair<int, void*>(m_nPanelCount, pDrvDPC));
	m_nPanelCount++;
	m_ModeConfig = Configuration; //记录配置  --目前只有一个平板，多板时应该分别存储
	return true;
}

bool Detector_Rayence::Connect(void* pDrvDPC, const char* szWorkPath)
{
	FINFO("Connect detector begin");

	std::string strSensitivity;

	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		Debug("Not current DPC, return true");
		return true;
	}

	m_strWorkPath = szWorkPath;

	try
	{
		int nModeCount = m_ModeConfig["ModeTable"].size();
		for (int i = 0; i < nModeCount; i++)
		{
			FINFO("mode count:{$}", i);
		}
		m_nExiThreshold = (int)m_ModeConfig["ExiThreshold"];
		m_strSDKPath = (std::string)m_ModeConfig["SDKPath"];
		m_strModulePath = (std::string)m_ModeConfig["DetectorModePath"];
		m_nSensitivity = (int)m_ModeConfig["Sensitivity"];
		m_bCalOffset = (int)m_ModeConfig["UseOffsetCalibration"];
		m_bCalGain = (int)m_ModeConfig["UseGainCalibration"];
		m_bCalBPM = (int)m_ModeConfig["UseBPMCalibration"];
		m_nExposureTime = (int)m_ModeConfig["ExposureTime"];

		switch (m_nSensitivity)
		{
		case 0:
			strSensitivity = "High Sensitivity";
			break;
		case 1:
			strSensitivity = "Mid High Sensitivity";
			break;
		case 2:
			strSensitivity = "middle";
			break;
		case 3:
			strSensitivity = "Mid Low";
			break;
		case 4:
			strSensitivity = "Low";
			break;
		default:
			FERROR("Sensitivity FERROR Paramer");
			break;
		}
		FINFO("Rayence Use Senisitivity: {$}", strSensitivity);
		FINFO("Load Calibration Offset: {$}, Gain: {$}, BPM: {$}", m_bCalOffset, m_bCalGain, m_bCalBPM);
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Get config FERROR: {$}", e.what());
		return false;
	}

	std::string strModulePath;
	strModulePath = m_strWorkPath + m_strModulePath + "\\CCOS.Dev.FPD.RayenceX64.dll";
	FINFO("ModulePath : {$}", strModulePath);
	std::string strVersion;
	strVersion = GetFileVersion(strModulePath);
	FINFO("======================={$}=======================", strVersion);
	

	if (!OpenDetector())
	{
		FERROR("Open detector failed, Connect failed \n");
		return false;
	}

	FINFO("Connect over");
	return true;
}

void Detector_Rayence::DisConnect()
{
	FINFO("DisConnect with detector");
	if (eDetStatus::DetStatus_XrayCalibration == GetRayenceDPCStatus() || eDetStatus::DetStatus_Offset == GetRayenceDPCStatus())
	{
		FINFO("DisConnect Calling StopCalibration");
	}

	if (m_pFrm1x1Buffer)
	{
		delete[] m_pFrm1x1Buffer;
		m_pFrm1x1Buffer = nullptr;
	}

	if (m_pFrm2x2Buffer)
	{
		delete[] m_pFrm2x2Buffer;
		m_pFrm2x2Buffer = nullptr;
	}

	if (m_pDark1x1Buffer)
	{
		delete[] m_pDark1x1Buffer;
		m_pDark1x1Buffer = nullptr;
	}

	if (m_pDark2x2Buffer)
	{
		delete[] m_pDark2x2Buffer;
		m_pDark2x2Buffer = nullptr;
	}

	if (m_pFrm1x1AveBuffer)
	{
		delete[] m_pFrm1x1AveBuffer;
		m_pFrm1x1AveBuffer = nullptr;
	}

	if (m_pFrm2x2AveBuffer)
	{
		delete[] m_pFrm2x2AveBuffer;
		m_pFrm2x2AveBuffer = nullptr;
	}

	if (m_pOneShotBuffer)
	{
		delete[] m_pOneShotBuffer;
		m_pOneShotBuffer = nullptr;
	}
	
	FINFO("Disconnect Detector Over");
}

void Detector_Rayence::EnterExamMode(int nExamMode)
{
	switch (nExamMode)
	{
	case APP_STATUS_WORK_BEGIN:
		FINFO("Enter into Exam Windows");
		m_nExamMode = APP_STATUS_WORK_BEGIN;
		break;
	case APP_STATUS_WORK_END:
		FINFO("Quit Exam Windows");
		m_nExamMode = APP_STATUS_WORK_END;
		break;
	case APP_STATUS_DETSHARE_BEGIN:
		FINFO("Enter into Detector Share Windows");
		m_nExamMode = APP_STATUS_DETSHARE_BEGIN;
		break;
	case APP_STATUS_DETSHAR_END:
		m_nExamMode = APP_STATUS_IDLE;
		FINFO("Quit Detector Share Windows");
		m_nExamMode = APP_STATUS_DETSHAR_END;
		break;
	case APP_STATUS_CAL_BEGIN:
		FINFO("Enter into Calibration Windows");
		m_nExamMode = APP_STATUS_CAL_BEGIN;
		break;
	case APP_STATUS_CAL_END:
		FINFO("Quit Calibration Windows");
		m_nExamMode = APP_STATUS_CAL_END;
		break;
	case APP_STATUS_WORK_IN_SENSITIVITY:
		FINFO("Enter into sensitivity test interface");
		m_nExamMode = APP_STATUS_WORK_IN_SENSITIVITY;
		break;
	default:
		break;
	}

	if (APP_STATUS_WORK_END == m_nExamMode)
	{
		if (eDetStatus::DetStatus_Acquire == GetRayenceDPCStatus())
		{
			m_Intf.rVDACQ_Abort(rACQ_CallBackRec);
			m_Intf.rVDACQ_Close(rACQ_CallBackRec);
		}
	}
}

void Detector_Rayence::CALLBACK_InfoMessage(int nCode, TCHAR* szMessage)
{
	FINFO("InfoMessage: Code: {$}, Message: {$}", nCode, szMessage);
	if (nCode == 16842754)
	{
		m_bRayenceConnect = true;
	}
	if (nCode == 16908289)
	{
		m_bRayAcqing = true;
	}
	if (nCode == 16908290)
	{
		m_bRayAcqing = false;
	}
}

void Detector_Rayence::HandleCaptureRecvEvent(tVDACQ_CallBackRec* ACBR, bool bIsCaptureRaw)
{
	FINFO("ACBR->rEvent cVDACQ_ECaptureRecv m_eStatus:{$}", (int)m_eStatus);

	if (m_eStatus == eDetStatus::DetStatus_Acquire)
	{
		if (m_strCurrentExamType == "RAD")
		{
			FINFO("Rad Mode...");
		}
		else if (m_strCurrentExamType == "CF")
		{
			FINFO("CF Mode...");
		}
		else if (m_strCurrentExamType == "PF")
		{
			FINFO("PF Mode...");
		}

		if (m_bSaveRaw)
		{
			FINFO("Begin save Raw");
			char szTemp[30] = { 0 };
			string strFileName = m_strWorkPath + "\\Image";
			if (m_strCurrentExamType == "Rad")
			{
				strFileName += "\\Image_Rad.raw";
			}
			else
			{
				sprintf_s(szTemp, "\\Image_%d.raw", m_nImageIndex);
				strFileName += szTemp;
			}
			std::filesystem::path file_path{ strFileName.c_str() };
			std::ofstream file_stream(file_path, std::ios::binary);
			if (!file_stream.is_open())
			{
				FERROR("Open Save File Failed");
			}
			unsigned int nTempSize = m_nFrmWidth * m_nFrmHeight * 2;
			if (m_nBinningMode == 0)
			{
				file_stream.write(reinterpret_cast<const char*>(m_pFrm1x1Buffer), nTempSize);
			}
			if (m_nBinningMode == 1)
			{
				file_stream.write(reinterpret_cast<const char*>(m_pFrm2x2Buffer), nTempSize);
			}
			
			file_stream.close();
		}
		m_nImageIndex++;
		OnProcessImage(ACBR->rCaptureFrames, bIsCaptureRaw);
	}
}

std::string Detector_Rayence::GetFileVersion(std::string strFilePathName)
{
	DWORD dwVerSize = GetFileVersionInfoSize(strFilePathName.c_str(), NULL);
	if (dwVerSize == 0)
	{
		return "";
	}

	LPVOID pVersionBuffer = malloc(dwVerSize);
	GetFileVersionInfo(strFilePathName.c_str(), 0, dwVerSize, pVersionBuffer);

	VS_FIXEDFILEINFO* pInfo;
	UINT nInfoLen;
	std::string strVersion = "";

	if (VerQueryValue(pVersionBuffer, _T("\\"), (void**)&pInfo, &nInfoLen))
	{
		strVersion = to_string(HIWORD(pInfo->dwFileVersionMS)) + "." + to_string(LOWORD(pInfo->dwFileVersionMS)) + "."
			+ to_string(HIWORD(pInfo->dwFileVersionLS)) + "." + to_string(LOWORD(pInfo->dwFileVersionLS));
	}

	return strVersion;
}

float Detector_Rayence::SetFluPPS(float fPPS)
{
	FINFO("Set Flu FrameRate : {$}", fPPS);
	m_fFrameRate = fPPS;

	if (m_fFrameRate == 30)
	{
		m_fFrameRate = 7;
	}

	if (m_strCurrentExamType == "CF")
	{
		FINFO("SetFrameRate: {$}", m_fFrameRate);
		m_Intf.rVDACQ_SetFrameRate(m_fFrameRate);
	}
	
	return m_fFrameRate;
}

void Detector_Rayence::GetFluPPS(float& fFluPPS)
{
	fFluPPS = m_fFrameRate;
}

bool Detector_Rayence::SetAcqMode(std::string strMode)
{
	FINFO("SetAcqMode nMode:{$}",strMode);
	if (m_strCurrentLogicMode == strMode)
	{
		FINFO("Same mode, return");
		return true;
	}
	m_strCurrentLogicMode = ""; //恢复初值
	m_Intf.rVDACQ_SetCaptureExposureTime(m_nExposureTime);//设置Rad采集的积分时间

	if (eDetStatus::DetStatus_Acquire == GetRayenceDPCStatus())
	{
		m_Intf.rVDACQ_Abort(rACQ_CallBackRec);
		m_Intf.rVDACQ_Close(rACQ_CallBackRec);
	}
	m_Intf.rVDACQ_SetSensitivity(0);
	try
	{
		int nModeCount = m_ModeConfig["ModeTable"].size();
		for (int i = 0; i < nModeCount; i++)
		{
			std::string strAppMode = (std::string)m_ModeConfig["ModeTable"][i]["ExamType"];//SetAcqMode
			if (strAppMode == strMode)
			{
				m_strCurrentExamType = (std::string)m_ModeConfig["ModeTable"][i]["ExamType"];
				m_bSaveRaw = (int)m_ModeConfig["ModeTable"][i]["IsSaveRaw"];
				m_nBinningMode = (int)m_ModeConfig["ModeTable"][i]["BinningMode"];
				m_nCropLeft = (int)m_ModeConfig["ModeTable"][i]["CropLeft"];
				m_nCropRight = (int)m_ModeConfig["ModeTable"][i]["CropRight"];
				m_nCropTop = (int)m_ModeConfig["ModeTable"][i]["CropTop"];
				m_nCropBottom = (int)m_ModeConfig["ModeTable"][i]["CropBottom"];
				FINFO("Crop left: {$}, top: {$}, right: {$}, bottom: {$}",
					m_nCropLeft, m_nCropTop, m_nCropRight, m_nCropBottom);
				FINFO("ExamType: {$}, SaveRaw: {$}", m_strCurrentExamType, m_bSaveRaw);
				m_strCurrentLogicMode = strMode;
				
				break;
			}
		}
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Read configuration failed, FERROR code: {$}", e.what());
		return false;
	}

	if (m_strLastLogicMode != m_strCurrentLogicMode || GetRayenceDPCStatus() != eDetStatus::DetStatus_Acquire)
	{
		if (m_strCurrentExamType == "RAD")//PrepareAcquisition
		{
			m_Intf.rVDACQ_SetBinning(m_nBinningMode);
			m_Intf.rVDACQ_GetFrameDim(&m_nFrmWidth, &m_nFrmHeight);
			m_Intf.rVDACQ_SetFrameDim(m_nFrmWidth, m_nFrmHeight);

			FINFO("Rad BinningMode: {$}, FrameSize Width: {$}, Height: {$}", m_nBinningMode, m_nFrmWidth, m_nFrmHeight);

			if (m_nBinningMode == 0)
			{
				if (m_pFrm1x1Buffer == nullptr)
				{
					unsigned int nTempSize = m_nFrmWidth * m_nFrmHeight;
					m_pFrm1x1Buffer = new short[nTempSize];
				}
			}
			
			if (m_nBinningMode == 1)
			{
				if (m_pFrm2x2Buffer == nullptr)
				{
					unsigned int nTempSize = m_nFrmWidth * m_nFrmHeight;
					m_pFrm2x2Buffer = new short[nTempSize];
				}
			}

			if (m_pOneShotBuffer == nullptr)
			{
				unsigned int nTempSize = m_nFrmHeight * m_nFrmWidth;
				m_pOneShotBuffer = new short[nTempSize];
			}
			else
			{
				delete[] m_pOneShotBuffer;
				unsigned int nTempSize = m_nFrmWidth * m_nFrmHeight;
				m_pOneShotBuffer = new short[nTempSize];
			}

			m_Intf.rVDACQ_GetFGRec(&m_qFGRec);
			m_qFGRec.rCalFlags = 0;
			if (m_bCalOffset)
			{
				m_qFGRec.rCalFlags |= cVDC_FCalOffs;
			}
			if (m_bCalGain)
			{
				m_qFGRec.rCalFlags |= cVDC_FCalGain;
			}
			if (m_bCalBPM)
			{
				m_qFGRec.rCalFlags |= cVDC_FBadPixMap;
			}

			m_qFGRec.rFG_Control = 0;
			m_Intf.rVDACQ_SetFGRec(&m_qFGRec);

			m_Intf.rVDACQ_SetOneShot(1);
			m_Intf.rVDACQ_SetOneShot_Trigger(0);
		}
		else if (m_strCurrentExamType == "PF")
		{
			m_Intf.rVDACQ_SetBinning(m_nBinningMode);
			m_Intf.rVDACQ_GetFrameDim(&m_nFrmWidth, &m_nFrmHeight);
			m_Intf.rVDACQ_SetFrameDim(m_nFrmWidth, m_nFrmHeight);

			if (nullptr != m_pFullImgBuffer)
			{
				delete[] m_pFullImgBuffer;
				m_pFullImgBuffer = nullptr;
			}

			m_nImageWidth = m_nFrmWidth - m_nCropLeft - m_nCropRight;
			m_nImageHeight = m_nFrmHeight - m_nCropBottom - m_nCropTop;
			m_nRawImgHeight = m_nFrmHeight;
			m_nRawImgWidth = m_nFrmWidth;

			if (m_nBinningMode == 0)
			{
				if (m_pFrm1x1Buffer == nullptr)
				{
					unsigned int nTempSize = m_nFrmWidth * m_nFrmHeight;
					m_pFrm1x1Buffer = new short[nTempSize];
				}
			}

			if (m_nBinningMode == 1)
			{
				if (m_pFrm2x2Buffer == nullptr)
				{
					unsigned int nTempSize = m_nFrmWidth * m_nFrmHeight;
					m_pFrm2x2Buffer = new short[nTempSize];
				}
			}

			m_pFullImgBuffer = new WORD[(size_t)m_nImageWidth * (size_t)m_nImageHeight];

			FINFO("PF FrameRate: {$}, BinningMode: {$}, FrameSize Width: {$}, Height: {$}", m_fFrameRate, m_nBinningMode, m_nFrmWidth, m_nFrmHeight);

			m_Intf.rVDACQ_GetFGRec(&m_qFGRec);
			m_qFGRec.rCalFlags = 0;
			if (m_bCalOffset)
			{
				m_qFGRec.rCalFlags |= cVDC_FCalOffs;
			}
			if (m_bCalGain)
			{
				m_qFGRec.rCalFlags |= cVDC_FCalGain;
			}
			if (m_bCalBPM)
			{
				m_qFGRec.rCalFlags |= cVDC_FBadPixMap;
			}

			m_qFGRec.rFG_Control |= cVDACQ_FGC_CaptureCalHandler;
			m_Intf.rVDACQ_SetFGRec(&m_qFGRec);

			m_Intf.rVDACQ_SetOneShot(0);
			m_Intf.rVDACQ_SetDynamic_Trigger(1);
		}
		else if (m_strCurrentExamType == "CF")
		{
			m_Intf.rVDACQ_SetFrameRate(m_fFrameRate);
			m_Intf.rVDACQ_SetBinning(m_nBinningMode);
			m_Intf.rVDACQ_GetFrameDim(&m_nFrmWidth, &m_nFrmHeight);
			m_Intf.rVDACQ_SetFrameDim(m_nFrmWidth, m_nFrmHeight);

			if (nullptr != m_pFullImgBuffer)
			{
				delete[] m_pFullImgBuffer;
				m_pFullImgBuffer = nullptr;
			}

			m_nImageWidth = m_nFrmWidth - m_nCropLeft - m_nCropRight;
			m_nImageHeight = m_nFrmHeight - m_nCropBottom - m_nCropTop;
			m_nRawImgHeight = m_nFrmHeight;
			m_nRawImgWidth = m_nFrmWidth;

			if (m_nBinningMode == 0)
			{
				if (m_pFrm1x1Buffer == nullptr)
				{
					unsigned int nTempSize = m_nFrmWidth * m_nFrmHeight;
					m_pFrm1x1Buffer = new short[nTempSize];
				}
			}

			if (m_nBinningMode == 1)
			{
				if (m_pFrm2x2Buffer == nullptr)
				{
					unsigned int nTempSize = m_nFrmWidth * m_nFrmHeight;
					m_pFrm2x2Buffer = new short[nTempSize];
				}
			}

			m_pFullImgBuffer = new WORD[(size_t)m_nImageWidth * (size_t)m_nImageHeight];

			FINFO("CF FrameRate: {$}, BinningMode: {$}, FrameSize Width: {$}, Height: {$}", m_fFrameRate, m_nBinningMode, m_nFrmWidth, m_nFrmHeight);

			m_Intf.rVDACQ_GetFGRec(&m_qFGRec);
			m_qFGRec.rCalFlags = 0;
			if (m_bCalOffset)
			{
				m_qFGRec.rCalFlags |= cVDC_FCalOffs;
			}
			if (m_bCalGain)
			{
				m_qFGRec.rCalFlags |= cVDC_FCalGain;
			}
			if (m_bCalBPM)
			{
				m_qFGRec.rCalFlags |= cVDC_FBadPixMap;
			}

			m_qFGRec.rFG_Control |= cVDACQ_FGC_CaptureCalHandler;
			m_Intf.rVDACQ_SetFGRec(&m_qFGRec);

			m_Intf.rVDACQ_SetOneShot(0);
			m_Intf.rVDACQ_SetDynamic_Trigger(0);
		}
	}

	m_nCalBinning = m_nBinningMode;
	FINFO("Cal BinningMode : {$}", m_nCalBinning);

	return true;
}

bool Detector_Rayence::PrepareAcquisition(void* pDrvDPC)
{
	FINFO("PrepareAcquisition");
	bool bRet = false;
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		FERROR("Not current DPC, return");
		return bRet;
	}

	FINFO("PrepareAcquisition m_strLastLogicMode:{$},m_strCurrentLogicMode:{$}", m_strLastLogicMode, m_strCurrentLogicMode);

	return true;
}

bool Detector_Rayence::StartAcquisition(void* pDrvDPC)
{
	FINFO("StartAcquisition");
	bool bRet = false;
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		FERROR("Not current DPC, return");
		return bRet;
	}

	if (m_strLastLogicMode != m_strCurrentLogicMode || GetRayenceDPCStatus() != eDetStatus::DetStatus_Acquire)
	{
		if (m_strCurrentExamType == "RAD")//PrepareAcquisition
		{
			m_Intf.rVDACQ_SetCaptureBuf(m_pOneShotBuffer);

			if (m_nBinningMode == 0)
			{
				rACQ_CallBackRec = m_Intf.rVDACQ_Connect(cVDACQ_FBright, G_Rayence_OnEvent, NULL, (short*)m_pFrm1x1Buffer, 0);
			}
			
			if (m_nBinningMode == 1)
			{
				rACQ_CallBackRec = m_Intf.rVDACQ_Connect(cVDACQ_FBright, G_Rayence_OnEvent, NULL, (short*)m_pFrm2x2Buffer, 0);
			}

			if (rACQ_CallBackRec != nullptr)
			{
				SetRayenceDPCStatus(eDetStatus::DetStatus_Acquire); //Rad模式激活采集，设置状态
			}

			m_Intf.rVDACQ_StartFrame(rACQ_CallBackRec);
		}
		else if (m_strCurrentExamType == "PF")
		{
			FINFO("Start PF Acquisition");
			if (m_nBinningMode == 0)
			{
				rACQ_CallBackRec = m_Intf.rVDACQ_Connect(cVDACQ_FBright, G_Rayence_OnEvent, NULL, (short*)m_pFrm1x1Buffer, 0);
			}

			if (m_nBinningMode == 1)
			{
				rACQ_CallBackRec = m_Intf.rVDACQ_Connect(cVDACQ_FBright, G_Rayence_OnEvent, NULL, (short*)m_pFrm2x2Buffer, 0);
			}

			if (rACQ_CallBackRec != nullptr)
			{
				SetRayenceDPCStatus(eDetStatus::DetStatus_Acquire); //PF模式激活采集，设置状态
			}

			m_Intf.rVDACQ_StartFrame(rACQ_CallBackRec);
			StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON);
		}
		else if (m_strCurrentExamType == "CF")
		{

			FINFO("Start CF Acquisition");
			if (m_nBinningMode == 0)
			{
				rACQ_CallBackRec = m_Intf.rVDACQ_Connect(cVDACQ_FBright, G_Rayence_OnEvent, NULL, (short*)m_pFrm1x1Buffer, 0);
			}

			if (m_nBinningMode == 1)
			{
				rACQ_CallBackRec = m_Intf.rVDACQ_Connect(cVDACQ_FBright, G_Rayence_OnEvent, NULL, (short*)m_pFrm2x2Buffer, 0);
			}

			if (rACQ_CallBackRec != nullptr)
			{
				SetRayenceDPCStatus(eDetStatus::DetStatus_Acquire); //CF模式激活采集，设置状态
			}

			m_Intf.rVDACQ_StartFrame(rACQ_CallBackRec);
			StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON);
		}
	}

	m_bRayAcqing = true;
	/*StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON);*/

	if ("" == m_strCurrentLogicMode)
	{
		FERROR("Illegal exam mode");
	}
	else
	{
		bRet = true;
	}
	return bRet;
}

bool Detector_Rayence::StopAcquisition(void* pDrvDPC)
{
	FINFO("StopAcquisition ");
	bool bRet = false;

	StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_OFF);

	if (m_strCurrentExamType != "RAD")
	{
		if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
		{
			FERROR("Not current DPC, return");
			return bRet;
		}

		if (eDetStatus::DetStatus_Acquire == GetRayenceDPCStatus())
		{
			FINFO("Calling StopAcquisition");
			m_Intf.rVDACQ_Abort(rACQ_CallBackRec);
			m_Intf.rVDACQ_Close(rACQ_CallBackRec);
			m_bRayAcqing = false;
			bRet = true;
			SetRayenceDPCStatus(eDetStatus::DetStatus_Standby); //停止采集，设置状态
		}
		else
		{
			FINFO("Not in acquire status");

			//切换到静态采集后，进入了ready状态。但此时可以不开始采集，切换到别的模式，
			bRet = true;
		}
	}
	else
	{
		bRet = true;
	}
	
	return bRet;
}

bool Detector_Rayence::StartOffset(void* pDrvDPC, bool isAll, std::vector<DetectorMode>& m_vDetectorModeList)
{
	FINFO("StartOffset");
	bool bRet = false;

	m_bAbortOffset = false;

	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		FERROR("Not current DPC, return");
		return false;
	}

	m_bRefreshAllMode = isAll;

	m_vecDetMode = m_vDetectorModeList;

	if (!m_bOffsetBuffer)
	{
		for (size_t i = 0; i < m_vecDetMode.size(); i++)
		{
			unsigned int nTempSize = m_vecDetMode[i].imageHeight * m_vecDetMode[i].imageWidth;
			FINFO("AveBuffer Height:{$}, Width:{$}", m_vecDetMode[i].imageHeight, m_vecDetMode[i].imageWidth);
			m_nCalModeId = m_vecDetMode[i].ModeID;
			FINFO("Calling StartDarkCalibration, modeid:({$})", m_nCalModeId);

			if (m_pFrm1x1AveBuffer == nullptr && m_nCalModeId == 0)
			{
				m_pFrm1x1AveBuffer = new int[nTempSize];
				memset(m_pFrm1x1AveBuffer, 0, nTempSize * sizeof(int));
			}
			if (m_pFrm2x2AveBuffer == nullptr && m_nCalModeId == 1)
			{
				m_pFrm2x2AveBuffer = new int[nTempSize];
				memset(m_pFrm2x2AveBuffer, 0, nTempSize * sizeof(int));
			}

			if (m_nCalModeId == 0 && m_pDark1x1Buffer == nullptr)
			{
				m_pDark1x1Buffer = new short[nTempSize];
				FINFO("1x1 Dark Buffer");
			}
			if (m_nCalModeId == 1 && m_pDark2x2Buffer == nullptr)
			{
				m_pDark2x2Buffer = new short[nTempSize];
				FINFO("2x2 Dark Buffer");
			}
		}
		m_bOffsetBuffer = true;
	}

	if (m_bRayAcqing)
	{
		FINFO("FPD not Ready");
		OffsetProgressFeedback(EVT_INFO_OFFSET_STATUS, 1);
		return true;
	}

	OffsetProgressFeedback(EVT_INFO_OFFSET_PROGRESS, 0);
	m_nRecvCount = 0;

	OpenRefreshOffset();

	return true;
}

bool Detector_Rayence::AbortOffset()
{
	FINFO("Abort Offset");

	if (eDetStatus::DetStatus_Offset == GetRayenceDPCStatus() && m_bRayAcqing)
	{
		FINFO("Calling AbortOffset");
		m_Intf.rVDACQ_Abort(rACQ_CallBackRec);
		m_Intf.rVDACQ_Close(rACQ_CallBackRec);

		m_bAbortOffset = true;
		m_bDoOffset = false;
		m_bRayAcqing = false;
		StatusFeedback(EVT_STATUS_PANEL, PANEL_STANDBY);
		SetRayenceDPCStatus(eDetStatus::DetStatus_Standby); //停止采集，设置状态
	}

	if (!m_bRayAcqing)
	{
		FINFO("Offset not begin");
	}
	return true;
}

bool Detector_Rayence::ActiveCalibration(void* pDrvDPC, CCOS_CALIBRATION_TYPE eType)
{
	FINFO("ActiveCalibration");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		FERROR("Not current DPC, return");
		return false;
	}

	if ("" == m_strCurrentLogicMode)
	{
		FERROR("Illegal exam mode");
		return false;
	}

	if (CCOS_CALIBRATION_TYPE_XRAY == eType)
	{
		SetRayenceDPCStatus(eDetStatus::DetStatus_XrayCalibration);
	}
	m_eCaliType = eType;
	return true;
}

/***
** 校正时响应上层调用的FramePrep
***/
bool Detector_Rayence::PrepareCalibration(void* pDrvDPC)
{
	FINFO("PrepareCalibration");
	bool bRet = false;
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		FERROR("Not current DPC, return");
		return bRet;
	}

	if (GetRayenceDPCStatus() != eDetStatus::DetStatus_XrayCalibration)
	{
		FINFO("Current status is not XrayCalibration, return succeed");
		return true;
	}

	return bRet;
}

bool Detector_Rayence::StartCalibration(void* pDrvDPC)
{
	FINFO("StartCalibration");
	bool bRet = false;
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		FERROR("Not current DPC, return");
		return bRet;
	}
	if (CCOS_CALIBRATION_TYPE_DARK == m_eCaliType)
	{
		bRet = true;
	}
	else if (CCOS_CALIBRATION_TYPE_XRAY == m_eCaliType)
	{
		bRet = StartGainCalibration();
	}
	return bRet;
}

bool Detector_Rayence::StopCalibration(void* pDrvDPC)
{
	FINFO("StopCalibration");
	bool bRet = false;

	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		FERROR("Not current DPC, return");
		return bRet;
	}

	FINFO("StopCalibration Calling StopCalibration");
	
	bRet = true;

	return bRet;
}

bool Detector_Rayence::OpenDetector()
{
	FINFO("OpenDetector");
	FINFO("Calling InitializeLibrary");

	if (!LoadRayenceDLL())
	{
		FERROR("Connect Detector Failed, Load Dll is failed");
		return false;
	}
	
	FINFO("Call RegisterCallbackInfo");
	m_Intf.rVD_RegisterCallbackInfo(G_Rayence_InfoMessage);

	FINFO("Open Detector Success--->");
	return true;
}

bool Detector_Rayence::LoadRayenceDLL()
{
	FINFO("Start Load Rayence DLL");

	FINFO("work path: {$}", m_strWorkPath);
	FINFO("Set SDK Path: {$}", m_strSDKPath);
	std::string strTempPath;
	strTempPath = m_strWorkPath + m_strSDKPath;

	if (SetDllDirectory(strTempPath.c_str()) == 0)
	{
		DWORD dw = GetLastError();
		FERROR("Load {$} Failed! FERROR Code : {$}", strTempPath, dw);
	}

	std::string strIniPath;
	strIniPath = strTempPath + "\\VADAV_FGM_64.ini";
	const char* section = "Settings";
	const char* key = "HomeDir";

	const char* newValue = strTempPath.c_str();
	WritePrivateProfileString(section, key, newValue, strIniPath.c_str());

	std::string strDllPath;
	strDllPath = strTempPath + "\\VADAV_FGM_64.dll";

	if (!VADAV_MapDLL(strDllPath.c_str(), &m_Intf))
	{
		FERROR("Load Rayence dll failed");
		auto dw = GetLastError();
		FERROR("FERROR Code : {$}", dw);
		return false;
	}

	FINFO("LoadRayenceDll Over");

	return true;
}

bool Detector_Rayence::CalculateEXI(WORD* pImgData, int nImgWidth, int nImgHeight, int nImageBit, int nThreshold)
{
	int nROIXL = static_cast<int>(0.3 * nImgWidth);
	int nROIXR = static_cast<int>(0.7 * nImgWidth);
	int nROIYL = static_cast<int>(0.3 * nImgHeight);
	int nROIYR = static_cast<int>(0.7 * nImgHeight);

	WORD* pSrc = NULL;
	long nCount = 0;
	DWORD64 nSum = 0;
	int nEXI = 0;
	try
	{
		for (int i = nROIYL; i < nROIYR; i++)
		{
			pSrc = pImgData + (i * nImgWidth);
			for (int j = nROIXL; j < nROIXR; j++)
			{
				nSum += *(pSrc + j);
				nCount++;
			}
		}
		nEXI = (int)(nSum / nCount);
	}
	catch (...)
	{
		return false;
	}

	FINFO("Image EXI:{$}, Threshold:{$}", nEXI, nThreshold);

	if (nEXI >= nThreshold)
	{
		FINFO("Image has xray!");
		return true;//有x射线
	}

	return false;
}

bool Detector_Rayence::CheckImageExi(WORD* pImgData, int nImgWidth, int nImgHeight, WORD dwExiThrethold)
{
	FINFO("Begin Check Image EXI");
	if (dwExiThrethold <= 0)
	{
		return true;
	}
	FINFO("Check image exi...");
	bool bResult = CalculateEXI(pImgData, nImgWidth, nImgHeight, 16, dwExiThrethold);
	if (bResult)
	{
		return true;
	}
	FINFO("Check image exi---black Image");

	return false;
}

bool Detector_Rayence::OpenRefreshOffset()
{
	FINFO("---Begin Refresh Offset Thread---");

	m_hOffsetThreadStatus = CreateEvent(NULL, FALSE, FALSE, NULL);
	if (nullptr == m_hOffsetThread)
	{
		unsigned uThreadId;
		_beginthreadex(NULL, 0, RefreshOffsetThread, this, 0, &uThreadId);
		m_hOffsetThread = OpenThread(THREAD_ALL_ACCESS, TRUE, uThreadId);
	}

	return true;
}

UINT Detector_Rayence::RefreshOffsetThread(LPVOID pParam)
{
	Detector_Rayence* pCurrentPanelOpr = reinterpret_cast<Detector_Rayence*>(pParam);
	if (pCurrentPanelOpr == nullptr)
	{
		FERROR("Refresh Offset Status Thread parameter FERROR");
	}

	pCurrentPanelOpr->PerformRefreshOffset();

	pCurrentPanelOpr->CloseRefreshOffset();

	return 0;
}

bool Detector_Rayence::PerformRefreshOffset()
{
	m_Intf.rVDACQ_Abort(rACQ_CallBackRec);
	m_Intf.rVDACQ_Close(rACQ_CallBackRec);
	if (m_bRefreshAllMode)
	{
		FINFO("Refresh all mode offset begin");

		for (size_t i = 0; i < m_vecDetMode.size(); i++)
		{
			if (!m_bAbortOffset)
			{
				unsigned int nTempSize = m_vecDetMode[i].imageHeight * m_vecDetMode[i].imageWidth;
				FINFO("AveBuffer Height:{$}, Width:{$}", m_vecDetMode[i].imageHeight, m_vecDetMode[i].imageWidth);
				m_nCalModeId = m_vecDetMode[i].ModeID;
				FINFO("Calling StartDarkCalibration, modeid:({$})", m_nCalModeId);

				/*if (m_pFrm1x1AveBuffer == nullptr && m_nCalModeId == 0)
				{
					m_pFrm1x1AveBuffer = new int[nTempSize];
					memset(m_pFrm1x1AveBuffer, 0, nTempSize * sizeof(int));
				}
				if (m_pFrm2x2AveBuffer == nullptr && m_nCalModeId == 1)
				{
					m_pFrm2x2AveBuffer = new int[nTempSize];
					memset(m_pFrm2x2AveBuffer, 0, nTempSize * sizeof(int));
				}*/

				SetRayenceDPCStatus(eDetStatus::DetStatus_Offset);
				m_bDoOffset = true;
				int nFrameRate = m_vecDetMode[i].FrameRate;
				int nBinningMode = m_vecDetMode[i].binningMode;
				m_nCalToAcqNum = m_vecDetMode[i].CalImgNum;
				FINFO("FrameRate:{$}, BinningMode:{$}, m_nCalToAcqNum: {$}", nFrameRate, nBinningMode, m_nCalToAcqNum);
				m_Intf.rVDACQ_SetFrameRate(nFrameRate);
				m_Intf.rVDACQ_SetBinning(nBinningMode);
				m_Intf.rVDACQ_GetFrameDim(&m_nFrmWidth, &m_nFrmHeight);
				m_Intf.rVDACQ_SetFrameDim(m_nFrmWidth, m_nFrmHeight);

				m_Intf.rVDACQ_GetFGRec(&m_qFGRec);

				m_qFGRec.rCalFlags = 0;
				m_Intf.rVDACQ_SetFGRec(&m_qFGRec);

				m_Intf.rVDACQ_SetOneShot(0);
				m_Intf.rVDACQ_SetDynamic_Trigger(0);

				m_nFlags = GET_DARK;

				FINFO("New FrmHeight: {$}, New FrmWidth: {$}", m_nFrmHeight, m_nFrmWidth);

				/*if (m_nCalModeId == 0 && m_pDark1x1Buffer == nullptr)
				{
					unsigned int nTempSize = m_nFrmWidth * m_nFrmHeight;
					m_pDark1x1Buffer = new short[nTempSize];
					FINFO("1x1 Dark Buffer");
				}
				if (m_nCalModeId == 1 && m_pDark2x2Buffer == nullptr)
				{
					unsigned int nTempSize = m_nFrmWidth * m_nFrmHeight;
					m_pDark2x2Buffer = new short[nTempSize];
					FINFO("2x2 Dark Buffer");
				}*/

				if (m_nCalModeId == 0)
				{
					rACQ_CallBackRec = m_Intf.rVDACQ_Connect(cVDACQ_FDark, G_Rayence_OnDarkEvent, NULL, m_pDark1x1Buffer, 0);
				}
				if (m_nCalModeId == 1)
				{
					rACQ_CallBackRec = m_Intf.rVDACQ_Connect(cVDACQ_FDark, G_Rayence_OnDarkEvent, NULL, m_pDark2x2Buffer, 0);
				}
				
				while (m_bDoOffset)
				{
					Sleep(10);
				}
				OffsetProgressFeedback(EVT_INFO_OFFSET_PROGRESS, (int)(i + 1));
			}
		}

		FINFO("Refresh all mode offset over");
	}
	else
	{
		for (size_t i = 0; i < m_vecDetMode.size(); i++)
		{
			if (m_nCalBinning == m_vecDetMode[i].binningMode)
			{
				m_nCalModeId = m_vecDetMode[i].ModeID;
			}
		}

		FINFO("Calling StartDarkCalibration, modeid:({$})", m_nCalModeId);
		SetRayenceDPCStatus(eDetStatus::DetStatus_Offset);
		m_bDoOffset = true;
		int nFrameRate = m_vecDetMode[m_nCalModeId].FrameRate;
		int nBinningMode = m_vecDetMode[m_nCalModeId].binningMode;
		m_nCalToAcqNum = m_vecDetMode[m_nCalModeId].CalImgNum;
		FINFO("FrameRate:{$}, BinningMode:{$}, m_nCalToAcqNum: {$}", nFrameRate, nBinningMode, m_nCalToAcqNum);
		m_Intf.rVDACQ_SetOneShot(0);
		m_Intf.rVDACQ_SetDynamic_Trigger(0);
		m_Intf.rVDACQ_SetFrameRate(nFrameRate);
		m_Intf.rVDACQ_SetBinning(nBinningMode);

		m_Intf.rVDACQ_GetFGRec(&m_qFGRec);

		m_qFGRec.rCalFlags = 0;
		m_Intf.rVDACQ_SetFGRec(&m_qFGRec);

		m_nFlags = GET_DARK;

		m_Intf.rVDACQ_GetFrameDim(&m_nFrmWidth, &m_nFrmHeight);
		m_Intf.rVDACQ_SetFrameDim(m_nFrmWidth, m_nFrmHeight);

		if (m_nCalModeId == 0)
		{
			rACQ_CallBackRec = m_Intf.rVDACQ_Connect(cVDACQ_FDark, G_Rayence_OnDarkEvent, NULL, m_pDark1x1Buffer, 0);
		}
		if (m_nCalModeId == 1)
		{
			rACQ_CallBackRec = m_Intf.rVDACQ_Connect(cVDACQ_FDark, G_Rayence_OnDarkEvent, NULL, m_pDark2x2Buffer, 0);
		}

		while (m_bDoOffset)
		{
			Sleep(10);
		}

		m_Intf.rVDACQ_GetFGRec(&m_qFGRec);
		m_qFGRec.rCalFlags = 0;
		if (m_bCalOffset)
		{
			m_qFGRec.rCalFlags |= cVDC_FCalOffs;
		}
		if (m_bCalGain)
		{
			m_qFGRec.rCalFlags |= cVDC_FCalGain;
		}
		if (m_bCalBPM)
		{
			m_qFGRec.rCalFlags |= cVDC_FBadPixMap;
		}

		m_qFGRec.rFG_Control = 0;
		m_Intf.rVDACQ_SetFGRec(&m_qFGRec);

		if (m_strCurrentExamType == "PF")
		{
			m_Intf.rVDACQ_SetOneShot(0);
			m_Intf.rVDACQ_SetDynamic_Trigger(1);
		}

		FINFO("Refresh mode:{$} offset over.", m_nCalModeId);
		OffsetProgressFeedback(EVT_INFO_OFFSET_PROGRESS, 1);
	}

	SetEvent(m_hOffsetThreadStatus);
	return true;
}

bool Detector_Rayence::CloseRefreshOffset()
{
	DWORD dwResult = WaitForSingleObject(m_hOffsetThreadStatus, 1000);
	if (dwResult == WAIT_OBJECT_0)
	{
		FINFO("[Get RefreshOffsetStatus Event]");
	}
	else if (dwResult == WAIT_TIMEOUT)
	{
		::TerminateThread(m_hOffsetThread, 0);
		FWARN("Kill RefreshOffset Thread");
	}

	if (m_hOffsetThreadStatus != nullptr)
	{
		CloseHandle(m_hOffsetThreadStatus);
		m_hOffsetThreadStatus = nullptr;
	}

	OffsetProgressFeedback(EVT_INFO_OFFSET_STATUS, 1);
	m_hOffsetThread = nullptr;
	FINFO("---Exit Refresh Offset Status Thread---");

	return true;
}



//nIndex 缺省-1，当使用缺省值时代表是静态模式，图像名不记录序号
void Detector_Rayence::OnProcessImage(int CaptureFrame, bool bIsCaptureRaw)
{
	FINFO("OnProcessImage CaptureID: {$}", CaptureFrame);

	auto Process_Image = [this](int Binning, int CaptureID)
	{
		int ret = 0;
		bool bImageCrop = false;
		if (m_nCropLeft != 0 || m_nCropTop != 0 || m_nCropRight != 0 || m_nCropBottom != 0)
		{
			if (Binning == 0) 
				ret = CropImageMargin(m_pFullImgBuffer, m_nImageWidth, m_nImageHeight,
					m_pFrm1x1Buffer, m_nRawImgWidth, m_nRawImgHeight, 16,
					m_nCropLeft, m_nCropTop, m_nCropRight, m_nCropBottom);
			if (Binning == 1)
				ret = CropImageMargin(m_pFullImgBuffer, m_nImageWidth, m_nImageHeight,
					m_pFrm2x2Buffer, m_nRawImgWidth, m_nRawImgHeight, 16,
					m_nCropLeft, m_nCropTop, m_nCropRight, m_nCropBottom);

			if (ret)
			{
				FERROR("CropImageMargin fail!!");
			}
			else
			{
				FINFO("CropImageMargin success!");
				bImageCrop = true;
			}
		}

		if (bImageCrop)
		{
			ConfFeedback(EVT_CONF_RAW_WIDTH, m_nCurrentPanelID, "", m_nImageWidth);
			ConfFeedback(EVT_CONF_RAW_HIGHT, m_nCurrentPanelID, "", m_nImageHeight);
		}
		else
		{
			ConfFeedback(EVT_CONF_RAW_WIDTH, m_nCurrentPanelID, "", m_nRawImgWidth);
			ConfFeedback(EVT_CONF_RAW_HIGHT, m_nCurrentPanelID, "", m_nRawImgHeight);
		}

		if (bImageCrop)
		{
			if (!CheckImageExi(m_pFullImgBuffer, m_nImageWidth, m_nImageHeight, m_nExiThreshold))
			{
				FWARN("Image EXI too low");
				return false;
			}

			DataFeedback(EVT_DATA_RAW_IMAGE, m_pFullImgBuffer);
		}
		else
		{
			if (Binning == 0)
			{
				if (!CheckImageExi((WORD*)m_pFrm1x1Buffer, m_nRawImgWidth, m_nRawImgHeight, m_nExiThreshold))
				{
					FWARN("Image EXI too low");
					return false;
				}
				DataFeedback(EVT_DATA_RAW_IMAGE, m_pFrm1x1Buffer);
			}
			if (Binning == 1)
			{
				if (!CheckImageExi((WORD*)m_pFrm2x2Buffer, m_nRawImgWidth, m_nRawImgHeight, m_nExiThreshold))
				{
					FWARN("Image EXI too low");
					return false;
				}
				DataFeedback(EVT_DATA_RAW_IMAGE, m_pFrm2x2Buffer);
			}
		}

		if (m_bSaveRaw)
		{
			FINFO("Begin save Flu CropRaw");
			char szTemp[30] = { 0 };
			string strFileName = m_strWorkPath + "\\Image";
			sprintf_s(szTemp, "\\CropImage_%d.raw", CaptureID);
			strFileName += szTemp;

			std::filesystem::path file_path{ strFileName.c_str() };
			std::ofstream file_stream(file_path, std::ios::binary);
			if (!file_stream.is_open())
			{
				FERROR("Open Save File Failed");
			}
			if (bImageCrop)
			{
				unsigned int nTempSize = m_nImageWidth * m_nImageHeight * 2;
				file_stream.write(reinterpret_cast<const char*>(m_pFullImgBuffer), nTempSize);
			}
			else
			{
				unsigned int nTempSize = m_nRawImgWidth * m_nRawImgHeight * 2;
				if (Binning == 0)
					file_stream.write(reinterpret_cast<const char*>(m_pFrm1x1Buffer), nTempSize);
				if (Binning == 1)
					file_stream.write(reinterpret_cast<const char*>(m_pFrm2x2Buffer), nTempSize);
			}

			file_stream.close();
			FINFO("Save Flu CropImage Over");
		}
	};

	if (!Process_Image(m_nBinningMode, CaptureFrame))
	{
		return;
	}

	//if (m_nBinningMode == 0)
	//{
	//	if (m_pFrm1x1Buffer == nullptr)
	//	{
	//		FERROR("Image Buffer is Null");
	//		return;
	//	}

	//	if (m_nCropLeft != 0 || m_nCropTop != 0 || m_nCropRight != 0 || m_nCropBottom != 0)
	//	{
	//		ret = CropImageMargin(m_pFullImgBuffer, m_nImageWidth, m_nImageHeight,
	//			m_pFrm1x1Buffer, m_nRawImgWidth, m_nRawImgHeight, 16,
	//			m_nCropLeft, m_nCropTop, m_nCropRight, m_nCropBottom);
	//		if (ret)
	//		{
	//			FERROR("CropImageMargin fail!!");
	//		}
	//		else
	//		{
	//			FINFO("CropImageMargin success!");
	//			bImageCrop = true;
	//		}
	//	}

	//	//上图之前回调图像的宽高，使得上层在拷贝内存时是正确的图像大小
	//	if (bImageCrop)
	//	{
	//		ConfFeedback(EVT_CONF_RAW_WIDTH, m_nCurrentPanelID, "", m_nImageWidth);
	//		ConfFeedback(EVT_CONF_RAW_HIGHT, m_nCurrentPanelID, "", m_nImageHeight);
	//	}
	//	else
	//	{
	//		ConfFeedback(EVT_CONF_RAW_WIDTH, m_nCurrentPanelID, "", m_nRawImgWidth);
	//		ConfFeedback(EVT_CONF_RAW_HIGHT, m_nCurrentPanelID, "", m_nRawImgHeight);
	//	}

	//	if (bImageCrop)
	//	{
	//		if (!CheckImageExi(m_pFullImgBuffer, m_nImageWidth, m_nImageHeight, m_nExiThreshold))
	//		{
	//			FWARN("Image EXI too low");
	//			return;
	//		}

	//		DataFeedback(EVT_DATA_RAW_IMAGE, m_pFullImgBuffer);
	//	}
	//	else
	//	{
	//		if (!CheckImageExi((WORD*)m_pFrm1x1Buffer, m_nRawImgWidth, m_nRawImgHeight, m_nExiThreshold))
	//		{
	//			FWARN("Image EXI too low");
	//			return;
	//		}

	//		DataFeedback(EVT_DATA_RAW_IMAGE, m_pFrm1x1Buffer);
	//	}

	//	if (m_bSaveRaw)
	//	{
	//		FINFO("Begin save Flu CropRaw");
	//		char szTemp[30] = { 0 };
	//		string strFileName = m_strWorkPath + "\\Image";
	//		/*if (m_strCurrentExamType == "Rad")
	//		{
	//			strFileName += "\\CropImage_Rad.raw";
	//		}
	//		else
	//		{
	//			sprintf_s(szTemp, "\\CropImage_%d.raw", CaptureFrame);
	//			strFileName += szTemp;
	//		}*/
	//		sprintf_s(szTemp, "\\CropImage_%d.raw", CaptureFrame);
	//		strFileName += szTemp;

	//		std::filesystem::path file_path{ strFileName.c_str() };
	//		std::ofstream file_stream(file_path, std::ios::binary);
	//		if (!file_stream.is_open())
	//		{
	//			FERROR("Open Save File Failed");
	//		}
	//		if (bImageCrop)
	//		{
	//			unsigned int nTempSize = m_nImageWidth * m_nImageHeight * 2;
	//			file_stream.write(reinterpret_cast<const char*>(m_pFullImgBuffer), nTempSize);
	//		}
	//		else
	//		{
	//			unsigned int nTempSize = m_nRawImgWidth * m_nRawImgHeight * 2;
	//			file_stream.write(reinterpret_cast<const char*>(m_pFrm1x1Buffer), nTempSize);
	//		}

	//		file_stream.close();
	//		FINFO("Save Flu CropImage Over");
	//	}
	//}
	//if (m_nBinningMode == 1)
	//{
	//	if (m_pFrm2x2Buffer == nullptr)
	//	{
	//		FERROR("Image Buffer is Null");
	//		return;
	//	}

	//	if (m_nCropLeft != 0 || m_nCropTop != 0 || m_nCropRight != 0 || m_nCropBottom != 0)
	//	{
	//		ret = CropImageMargin(m_pFullImgBuffer, m_nImageWidth, m_nImageHeight,
	//			m_pFrm2x2Buffer, m_nRawImgWidth, m_nRawImgHeight, 16,
	//			m_nCropLeft, m_nCropTop, m_nCropRight, m_nCropBottom);
	//		if (ret)
	//		{
	//			FERROR("CropImageMargin fail!!");
	//		}
	//		else
	//		{
	//			FINFO("CropImageMargin success!");
	//			bImageCrop = true;
	//		}
	//	}

	//	//上图之前回调图像的宽高，使得上层在拷贝内存时是正确的图像大小
	//	if (bImageCrop)
	//	{
	//		ConfFeedback(EVT_CONF_RAW_WIDTH, m_nCurrentPanelID, "", m_nImageWidth);
	//		ConfFeedback(EVT_CONF_RAW_HIGHT, m_nCurrentPanelID, "", m_nImageHeight);
	//	}
	//	else
	//	{
	//		ConfFeedback(EVT_CONF_RAW_WIDTH, m_nCurrentPanelID, "", m_nRawImgWidth);
	//		ConfFeedback(EVT_CONF_RAW_HIGHT, m_nCurrentPanelID, "", m_nRawImgHeight);
	//	}

	//	if (bImageCrop)
	//	{
	//		if (!CheckImageExi(m_pFullImgBuffer, m_nImageWidth, m_nImageHeight, m_nExiThreshold))
	//		{
	//			FWARN("Image EXI too low");
	//			return;
	//		}

	//		DataFeedback(EVT_DATA_RAW_IMAGE, m_pFullImgBuffer);
	//	}
	//	else
	//	{
	//		if (!CheckImageExi((WORD*)m_pFrm2x2Buffer, m_nRawImgWidth, m_nRawImgHeight, m_nExiThreshold))
	//		{
	//			FWARN("Image EXI too low");
	//			return;
	//		}

	//		DataFeedback(EVT_DATA_RAW_IMAGE, m_pFrm2x2Buffer);
	//	}

	//	if (m_bSaveRaw)
	//	{
	//		FINFO("Begin save CropRaw");
	//		char szTemp[30] = { 0 };
	//		string strFileName = m_strWorkPath + "\\Image";
	//		if (m_strCurrentExamType == "Rad")
	//		{
	//			strFileName += "\\CropImage_Rad.raw";
	//		}
	//		else
	//		{
	//			sprintf_s(szTemp, "\\CropImage_%d.raw", CaptureFrame);
	//			strFileName += szTemp;
	//		}
	//		std::filesystem::path file_path{ strFileName.c_str() };
	//		std::ofstream file_stream(file_path, std::ios::binary);
	//		if (!file_stream.is_open())
	//		{
	//			FERROR("Open Save File Failed");
	//		}
	//		if (bImageCrop)
	//		{
	//			unsigned int nTempSize = m_nImageWidth * m_nImageHeight * 2;
	//			file_stream.write(reinterpret_cast<const char*>(m_pFullImgBuffer), nTempSize);
	//		}
	//		else
	//		{
	//			unsigned int nTempSize = m_nRawImgWidth * m_nRawImgHeight * 2;
	//			file_stream.write(reinterpret_cast<const char*>(m_pFrm2x2Buffer), nTempSize);
	//		}

	//		file_stream.close();
	//		FINFO("Save CropImage Over");
	//	}
	//}
		
}

void Detector_Rayence::OnRadImageEvt(int CaptureFrame, bool bIsCaptureRaw)
{
	FINFO("OnProcessImage ");


	if (m_pOneShotBuffer == nullptr)
	{
		FERROR("Binning Mode 1x1 Image Buffer is Null");
		return;
	}
	CropImageMargin(m_pFullImgBuffer, m_nImageWidth, m_nImageHeight,
		m_pOneShotBuffer, m_nRawImgWidth, m_nRawImgHeight, 16,
		m_nCropLeft, m_nCropTop, m_nCropRight, m_nCropBottom);

	if (!CheckImageExi(m_pFullImgBuffer, m_nImageWidth, m_nImageHeight, m_nExiThreshold))
	{
		FWARN("Image EXI too low");
		return;
	}

	DataFeedback(EVT_DATA_RAW_IMAGE, m_pFullImgBuffer);

	if (m_bSaveRaw)
	{
		FINFO("Begin save Rad CropRaw");
		char szTemp[30] = { 0 };
		string strFileName = m_strWorkPath + "\\Image";
		if (m_strCurrentExamType == "Rad")
		{
			strFileName += "\\CropImage_Rad.raw";
		}
		//else
		//{
		//	sprintf_s(szTemp, "\\CropImage_%d.raw", CaptureFrame);
		//	strFileName += szTemp;
		//}
		std::filesystem::path file_path{ strFileName.c_str() };
		std::ofstream file_stream(file_path, std::ios::binary);
		if (!file_stream.is_open())
		{
			FERROR("Open Save File Failed");
		}
		unsigned int nTempSize = m_nImageWidth * m_nImageHeight * 2;
		file_stream.write(reinterpret_cast<const char*>(m_pFullImgBuffer), nTempSize);
		file_stream.close();
		FINFO("Save Rad CropImage Over");
	}

	StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_OFF);

	if (eDetStatus::DetStatus_Acquire == GetRayenceDPCStatus())
	{
		FINFO("Calling StopAcquisition");
		m_Intf.rVDACQ_Abort(rACQ_CallBackRec);
		m_Intf.rVDACQ_Close(rACQ_CallBackRec);

		SetRayenceDPCStatus(eDetStatus::DetStatus_Standby); //停止采集，设置状态
	}
	else
	{
		FINFO("Not in acquire status");
	}
}

bool Detector_Rayence::StartGainCalibration()
{
	FINFO("StartGainCalibration ");

	return true;
}

//获取只用于本DPC记录的探测器状态
eDetStatus Detector_Rayence::GetRayenceDPCStatus()
{
	string strStatus = "Unknown";
	switch (m_eStatus)
	{
	case eDetStatus::DetStatus_NotInit:
		strStatus = "NotInit";
		break;
	case eDetStatus::DetStatus_NotConn:
		strStatus = "NotConnect";
		break;
	case eDetStatus::DetStatus_Sleep:
		strStatus = "Sleep";
		break;
	case eDetStatus::DetStatus_Standby:
		strStatus = "Standby";
		break;
	case eDetStatus::DetStatus_Work:
		strStatus = "Work";
		break;
	case eDetStatus::DetStatus_Acquire:
		strStatus = "Acquire";
		break;
	case eDetStatus::DetStatus_Offset:
		strStatus = "Offset";
		break;
	case eDetStatus::DetStatus_XrayCalibration:
		strStatus = "XrayCalibration";
		break;
	default:
		break;
	}
	FINFO("Driver status: {$}", strStatus.c_str());
	return m_eStatus;
}

//设置只用于本DPC的探测器状态
bool Detector_Rayence::SetRayenceDPCStatus(eDetStatus status)
{
	string strStatus = "Unknown";
	bool bSetStatus = true;
	switch (status)
	{
	case eDetStatus::DetStatus_NotInit:
		strStatus = "NotIni";
		break;
	case eDetStatus::DetStatus_NotConn:
		strStatus = "NotConn";
		break;
	case eDetStatus::DetStatus_Sleep:
		strStatus = "Sleep";
		break;
	case eDetStatus::DetStatus_Standby:
		strStatus = "Standby";
		break;
	case eDetStatus::DetStatus_Work:
		strStatus = "Work";
		break;
	case eDetStatus::DetStatus_Acquire:
		strStatus = "Acquire";
		break;
	case eDetStatus::DetStatus_Offset:
		strStatus = "Offset";
		break;
	case eDetStatus::DetStatus_XrayCalibration:
		strStatus = "XrayCalibration";
		break;
	default:
		bSetStatus = false;
		break;
	}
	if (bSetStatus)
	{
		m_eStatus = status;
		FINFO("Set driver status: {$}", strStatus.c_str());
	}
	else
	{
		FWARN("{$} {$} is a illegal status", strStatus.c_str(), (int)status);
	}
	return bSetStatus;
}

//参照RFOC动态代码整理的图像裁剪功能
int Detector_Rayence::CropImageMargin(LPVOID pDstData, int& nDstWidth, int& nDstHeight,
	LPVOID pScrData, int nSrcWidth, int nSrcHeight, int nBits,
	int nLeftMargin, int nTopMargin, int nRightMargin, int nBottomMargin)
{
	FINFO("CropImageMargin ");
	if ((pDstData == NULL) || (pScrData == NULL) || (nSrcWidth <= 0) || (nSrcHeight <= 0) || (nBits <= 0))
		return -1;
	if ((nLeftMargin >= nSrcWidth) || (nTopMargin >= nSrcHeight))
		return -1;
	int nBitsToBYTE = (int)((nBits + 7) * 0.125);
	if (nBitsToBYTE < 1)
		return -1;
	int nXL, nXR, nYL, nYR;
	nXL = nLeftMargin;//32
	nYL = nTopMargin;
	if (nSrcWidth - nRightMargin < 0)
		return -1;
	nXR = nSrcWidth - nRightMargin - 1; //2783
	if (nXR < nXL)
		return -1;
	if (nSrcHeight - nBottomMargin < 0)
		return -1;
	nYR = nSrcHeight - nBottomMargin - 1;
	if (nYR < nYL)
		return -1;

	nDstWidth = nXR - nXL + 1;
	nDstHeight = nYR - nYL + 1;

	FINFO("TopCrop:{$};Bottom:{$},nDstWidth:{$},nDstHeight:{$},Bits:{$}", nYL, nYR, nDstWidth, nDstHeight, nBitsToBYTE);

	int i = 0;
#pragma omp parallel private(i) 
	{
#pragma omp for 
		for (i = nYL; i <= nYR; i++)
		{
			::memcpy((WORD*)pDstData + (i - nYL) * nDstWidth, (WORD*)pScrData + (i * nSrcWidth + nXL), nDstWidth * nBitsToBYTE);
		}
	}
	return 0;
}

std::string Detector_Rayence::SaveAveFrames(unsigned short* pBuf, TCHAR* pszFileName)
{
	if (pBuf)
	{
		TCHAR szBuf[MAX_PATH] = { 0 };
		TCHAR szCalDir[MAX_PATH] = { 0 };

		if (pszFileName == NULL)
		{
			switch (m_nFlags)
			{
			case GET_DARK:
				m_Intf.rVDC_GetCalibrationDirectory(szCalDir);
				_stprintf(szBuf, _T("%s\\%s"), szCalDir, _T("dark.raw"));
				FINFO("CalibrationDirectory: {$}", szBuf);
				break;
			case GET_BRIGHT:
				m_Intf.rVDC_GetCalibrationDirectory(szCalDir);
				_stprintf(szBuf, _T("%s\\x%05d.raw"), szCalDir, GetMedian(m_nFrmAveBufSize, pBuf, 15));
				FINFO("CalibrationDirectory: {$}", szBuf);
				break;
			default:
				break;
			}
		}

		FILE* fp = _tfopen(szBuf, _T("wb"));
		if (fp)
		{
			fwrite(pBuf, sizeof(unsigned short), m_nFrmAveBufSize, fp);
			fclose(fp);
		}

		if (m_nCalModeId == 0)
		{
			memset(m_pFrm1x1AveBuffer, 0, m_nFrmAveBufSize * sizeof(int));
		}
		if (m_nCalModeId == 1)
		{
			memset(m_pFrm2x2AveBuffer, 0, m_nFrmAveBufSize * sizeof(int));
		}
		
		return(szBuf);
	}

	return (_T(""));
}

int Detector_Rayence::GetMedian(int nNumPixel, const unsigned short* pData, int nCurPixelPro)
{
	int iMax, iMin;
	int* pHist = iDsp_BuildHistogram(nNumPixel, pData, &iMin, &iMax);
	int nGamut = iMax - iMin + 1;
	int nRes;

	// remove _nCurPixelPro(15%) of points from top
	if (nCurPixelPro > 0)
	{
		int nSumT = (nNumPixel * nCurPixelPro) / 100;
		int nSum = 0;
		int nStartIdx = 0;
		int nStopIdx = nGamut - 1;

		while (nSum < nSumT)
		{
			nSum += pHist[nStopIdx--];
		}

		// remove _nCurPixelPro(15%) of points from bottom
		nSum = 0;
		while (nSum < nSumT)
		{
			nSum += pHist[nStartIdx++];
		}

		// fine median
		nRes = nStartIdx;
		int nMaxNumPoints = pHist[nRes];
		while (nStartIdx++ < nStopIdx)
		{
			if (nMaxNumPoints < pHist[nStartIdx])
			{
				nRes = nStartIdx;
				nMaxNumPoints = pHist[nStartIdx];
			}
		}
	}
	else
	{
		int nSumT = nNumPixel / 2;
		int nSum = 0;
		nRes = 0;

		while ((nSum < nSumT) && (nRes < nGamut))
		{
			nSum += pHist[nRes++];
		}
	}

	delete pHist;

	return (nRes + iMin);
}

void Detector_Rayence::iDsp_FindMinMax(int nNumPix, const unsigned short* psData, int* piMin, int* piMax)
{
	int i, nVal, iMin = 0xFFFF, iMax = -0xFFFF;
	for (i = 0; i < nNumPix; i++)
	{
		nVal = psData[i];
		if (iMin > nVal) { iMin = nVal; }
		if (iMax < nVal) { iMax = nVal; }
	}
	*piMin = iMin;
	*piMax = iMax;
}

int* Detector_Rayence::iDsp_BuildHistogram(int nNumPix, const unsigned short* psData, int* piMin, int* piMax)
{
	int iMin, iMax;
	iDsp_FindMinMax(nNumPix, psData, &iMin, &iMax);
	*piMin = iMin;
	*piMax = iMax;

	int  iGamut = iMax - iMin + 1,
		* pHist = new int[iGamut];
	memset(pHist, 0, iGamut * sizeof(int));
	for (int i = 0; i < nNumPix; i++)
	{
		pHist[psData[i] - iMin]++;
	}
	return pHist;
}

void Detector_Rayence::CALLBACK_Acquisition(tVDACQ_CallBackRec* ACBR)
{
	if (ACBR->rEvent == cVDACQ_ECaptureRecv && m_eStatus == eDetStatus::DetStatus_Standby)
	{
		return;
	}

	FINFO("CALLBACK_Acquisition type:{$}, event:{$}", ACBR->rType, ACBR->rEvent);
	
	switch (ACBR->rType)
	{
		case cVDACQ_ETTrace:
		case cVDACQ_ETTraceT:
		{
			switch (ACBR->rEvent)
			{
				case cVDACQ_EAbort:
				{
					FINFO("ACBR->rEvent cVDACQ_EAbort");
					break;
				}
				case cVDACQ_EClose:
				{
					FINFO("ACBR->rEvent cVDACQ_EClose");
					break;
				}
				case cVDACQ_EAT_Ready:
				{
					FINFO("AED Ready");
					break;
				}
				case cVDACQ_ECapture:
				{
					FINFO("ACBR->rEvent cVDACQ_ECapture");
					break;
				}
				case cVDACQ_ECapturePerc:
				{
					FINFO("ACBR->rEvent cVDACQ_ECapturePerc");
					break;
				}
				case cVDACQ_ECaptureRecv:
				{
					FINFO("Flu Image Arrive");
					HandleCaptureRecvEvent(ACBR, false);
					break;
				}
				case cVDACQ_EIdle:
				{
					FINFO("ACBR->rEvent cVDACQ_EIdle");
					break;
				}
				case cVDACQ_EAT_Wait:
				{
					FINFO("AED Wait");
					break;
				}
				case cVDACQ_ECaptureFrame:
				{
					FINFO("ACBR->rEvent cVDACQ_ECaptureFrame");
					OnRadImageEvt(ACBR->rCaptureFrames, false);
					break;
				}
				case cVDACQ_ECapture2_Receive:
				{
					FINFO("ACBR_>rEvent cVDACQ_ECapture2_Receive");
					HandleCaptureRecvEvent(ACBR, true);
					break;
				}
				case cVDACQ_ECapture2_Expose:
				{
					auto Rad_Sync = [this](int XWindow)
					{
						if (m_pSynClient != nullptr)
						{
							if (!m_pSynClient->IsClosed())
							{
								ResDataObject Request, Response;
								Request.add("P0", XWindow);
								m_pSynClient->Action("SetDirectExpSignal", Request, Response, 4993, "CCOS/DEVICE/SyncBox");
								FDEBUG("V3_FullUCB Client execute [SetDirectExpSignal][{$}]", XWindow);
								if (XWindow == 1)
								{
									StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON);
								}
							}
							else
							{
								FDEBUG("V3_FullUCB Client is Close");
							}
						}
						else
						{
							FDEBUG("V3_FullUCB Client is NULL");
						}
					};
					switch (ACBR->rStatus)
					{
					case cVDACQ_ESStart:
						Rad_Sync(1);
						/*if (m_pSynClient != nullptr)
						{
							if (!m_pSynClient->IsClosed())
							{
								ResDataObject Request, Response;
								Request.add("P0", 1);
								m_pSynClient->Action("SetDirectExpSignal", Request, Response, 4993, "CCOS/DEVICE/SyncBox");
								Debug("V3_FullUCB Client execute [SetDirectExpSignal][{$}]", "1");
								StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON);
							}
							else
							{
								Debug("V3_FullUCB Client is Close");
							}
						}
						else
						{
							Debug("V3_FullUCB Client is NULL");
						}*/
						break;
					case cVDACQ_ESDone:
						Rad_Sync(0);
						/*if (m_pSynClient != nullptr)
						{
							if (!m_pSynClient->IsClosed())
							{
								ResDataObject Request, Response;
								Request.add("P0", 0);
								m_pSynClient->Action("SetDirectExpSignal", Request, Response, 4993, "CCOS/DEVICE/SyncBox");
								Debug("V3_FullUCB Client execute [SetDirectExpSignal][{$}]", "0");
							}
							else
							{
								Debug("V3_FullUCB Client is Close");
							}
						}
						else
						{
							Debug("V3_FullUCB Client is NULL");
						}*/
						break;
					}
					break;
				}
			}
		}
		break;
	default:
		break;
	}
}

void Detector_Rayence::CALLBACK_Dark_Acquisition(tVDACQ_CallBackRec* ACBR)
{
	if (ACBR->rEvent == cVDACQ_ECaptureRecv && m_eStatus == eDetStatus::DetStatus_Standby)
	{
		return;
	}

	FINFO("CALLBACK_Acquisition type:{$}, event:{$}", ACBR->rType, ACBR->rEvent);

	switch (ACBR->rType)
	{
	case cVDACQ_ETTrace:
	case cVDACQ_ETTraceT:
	{
		switch (ACBR->rEvent)
		{
		case cVDACQ_EAbort:
		{
			FINFO("ACBR->rEvent cVDACQ_EAbort");
			ErrorFeedback(EVT_ERR_OFFSET_FAILED);
			break;
		}
		case cVDACQ_EClose:
		{
			FINFO("ACBR->rEvent cVDACQ_EClose");
			break;
		}
		case cVDACQ_EAT_Ready:
		{
			FINFO("AED Ready");
			break;
		}
		case cVDACQ_ECapture:
		{
			FINFO("ACBR->rEvent cVDACQ_ECapture");
			break;
		}
		case cVDACQ_ECapturePerc:
		{
			FINFO("ACBR->rEvent cVDACQ_ECapturePerc");
			break;
		}
		case cVDACQ_ECaptureRecv:
		{
			FINFO("Dark Image Arrive");
			auto Dark_Receive = [this](int ModeID)
			{
				m_nFrmAveBufSize = m_nFrmWidth * m_nFrmHeight;

				if (!m_nAveCount)
				{
					if (ModeID == 0)
						memset(m_pDark1x1Buffer, 0, m_nFrmAveBufSize * sizeof(short));
					if (ModeID == 1)
						memset(m_pDark2x2Buffer, 0, m_nFrmAveBufSize * sizeof(short));
				}

				if (m_nRecvCount >= m_nSkipNum)
				{
					if (m_nFlags == GET_DARK)
					{
						for (size_t i = 0; i < m_nFrmAveBufSize; i++)
						{
							if (ModeID == 0)
								m_pFrm1x1AveBuffer[i] += m_pDark1x1Buffer[i];
							if (ModeID == 1)
								m_pFrm2x2AveBuffer[i] += m_pDark2x2Buffer[i];
						}
					}
					m_nAveCount++;
				}

				if (m_nAveCount >= m_nCalToAcqNum - m_nSkipNum)
				{
					if (m_nFlags == GET_DARK)
					{
						unsigned short* pAveBuf = new unsigned short[m_nFrmAveBufSize];
						memset(pAveBuf, 0, sizeof(unsigned short) * m_nFrmAveBufSize);

						if (m_nAveCount > 0)
						{
							for (int n = 0; n < m_nFrmAveBufSize; n++)
							{
								if (ModeID == 0)
									pAveBuf[n] = (unsigned short)(m_pFrm1x1AveBuffer[n] > 0 ? (m_pFrm1x1AveBuffer[n] / m_nAveCount) : 0);
								if (ModeID == 1)
									pAveBuf[n] = (unsigned short)(m_pFrm2x2AveBuffer[n] > 0 ? (m_pFrm2x2AveBuffer[n] / m_nAveCount) : 0);
							}
							SaveAveFrames(pAveBuf, NULL);
						}

						if (pAveBuf)
						{
							delete[] pAveBuf;
							pAveBuf = nullptr;
						}
					}
				}

				if (m_nRecvCount >= m_nCalToAcqNum)
				{
					FINFO("m_nCalToAcqNum: {$}", m_nCalToAcqNum);
					FINFO("m_nRecvCount: {$}", m_nRecvCount);
					m_Intf.rVDACQ_Abort(rACQ_CallBackRec);
					m_Intf.rVDACQ_Close(rACQ_CallBackRec);
					m_nRecvCount = 0;
					m_nAveCount = 0;
					m_bDoOffset = false;
					SetRayenceDPCStatus(eDetStatus::DetStatus_Standby);
					m_bRayAcqing = false;
					FINFO("one offset complete");
				}
			};
			m_nRecvCount++;
			
			if (m_eStatus == eDetStatus::DetStatus_Offset)
			{
				Dark_Receive(m_nCalModeId);
				/*if (m_nCalModeId == 0)
				{
					if (m_pDark1x1Buffer)
					{
						m_nFrmAveBufSize = m_nFrmWidth * m_nFrmHeight;
						if (!m_nAveCount)
						{
							memset(m_pDark1x1Buffer, 0, m_nFrmAveBufSize * sizeof(short));
						}

						if (m_nRecvCount >= m_nSkipNum)
						{
							if (m_nFlags == GET_DARK)
							{
								for (size_t i = 0; i < m_nFrmAveBufSize; i++)
								{
									m_pFrm1x1AveBuffer[i] += m_pDark1x1Buffer[i];
								}
							}
							m_nAveCount++;
						}
						if (m_nAveCount >= m_nCalToAcqNum - m_nSkipNum)
						{
							if (m_nFlags == GET_DARK)
							{
								unsigned short* pAveBuf = new unsigned short[m_nFrmAveBufSize];
								memset(pAveBuf, 0, sizeof(unsigned short) * m_nFrmAveBufSize);

								if (m_nAveCount > 0)
								{
									for (int n = 0; n < m_nFrmAveBufSize; n++)
									{
										pAveBuf[n] = (unsigned short)(m_pFrm1x1AveBuffer[n] > 0 ? (m_pFrm1x1AveBuffer[n] / m_nAveCount) : 0);
									}
									SaveAveFrames(pAveBuf, NULL);
								}

								if (pAveBuf)
								{
									delete[] pAveBuf;
									pAveBuf = nullptr;
								}
							}
						}
					}
					if (m_nRecvCount >= m_nCalToAcqNum)
					{
						FINFO("m_nCalToAcqNum: {$}", m_nCalToAcqNum);
						FINFO("m_nRecvCount: {$}", m_nRecvCount);
						m_Intf.rVDACQ_Abort(rACQ_CallBackRec);
						m_Intf.rVDACQ_Close(rACQ_CallBackRec);
						m_nRecvCount = 0;
						m_nAveCount = 0;
						m_bDoOffset = false;
						SetRayenceDPCStatus(eDetStatus::DetStatus_Standby);
						m_bRayAcqing = false;
						FINFO("one offset complete");
					}
				}
				if (m_nCalModeId == 1)
				{
					if (m_pDark2x2Buffer)
					{
						m_nFrmAveBufSize = m_nFrmWidth * m_nFrmHeight;
						if (!m_nAveCount)
						{
							memset(m_pDark2x2Buffer, 0, m_nFrmAveBufSize * sizeof(short));
						}

						if (m_nRecvCount >= m_nSkipNum)
						{
							if (m_nFlags == GET_DARK)
							{
								for (size_t i = 0; i < m_nFrmAveBufSize; i++)
								{
									m_pFrm2x2AveBuffer[i] += m_pDark2x2Buffer[i];
								}
							}
							m_nAveCount++;
						}
						if (m_nAveCount >= m_nCalToAcqNum - m_nSkipNum)
						{
							if (m_nFlags == GET_DARK)
							{
								unsigned short* pAveBuf = new unsigned short[m_nFrmAveBufSize];
								memset(pAveBuf, 0, sizeof(unsigned short) * m_nFrmAveBufSize);

								if (m_nAveCount > 0)
								{
									for (int n = 0; n < m_nFrmAveBufSize; n++)
									{
										pAveBuf[n] = (unsigned short)(m_pFrm2x2AveBuffer[n] > 0 ? (m_pFrm2x2AveBuffer[n] / m_nAveCount) : 0);
									}
									SaveAveFrames(pAveBuf, NULL);
								}

								if (pAveBuf)
								{
									delete[] pAveBuf;
									pAveBuf = nullptr;
								}
							}
						}
					}
					if (m_nRecvCount >= m_nCalToAcqNum)
					{
						FINFO("m_nCalToAcqNum: {$}", m_nCalToAcqNum);
						FINFO("m_nRecvCount: {$}", m_nRecvCount);
						m_Intf.rVDACQ_Abort(rACQ_CallBackRec);
						m_Intf.rVDACQ_Close(rACQ_CallBackRec);
						m_nRecvCount = 0;
						m_nAveCount = 0;
						m_bDoOffset = false;
						SetRayenceDPCStatus(eDetStatus::DetStatus_Standby);
						m_bRayAcqing = false;
						FINFO("one offset complete");
					}
				}*/
			}
			break;
		}
		case cVDACQ_EIdle:
		{
			FINFO("ACBR->rEvent cVDACQ_EIdle");
			break;
		}
		case cVDACQ_EAT_Wait:
		{
			FINFO("AED Wait");
			break;
		}
		case cVDACQ_ECaptureFrame:
		{
			FINFO("ACBR->rEvent cVDACQ_ECaptureFrame");
			break;
		}
		case cVDACQ_ECapture2_Receive:
		{
			FINFO("ACBR_>rEvent cVDACQ_ECapture2_Receive");
			break;
		}
		case cVDACQ_ECapture2_Expose:
		{
			break;
		}
		}
	}
	break;
	default:
		break;
	}

}

void Detector_Rayence::ConfFeedback(int nEventID, int nDetectorID, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDeviceRayence*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_CONFIGURATION, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}


void Detector_Rayence::InfoFeedback(int nEventID, int nDetectorID, int nParam1, float fParam2, const char* pszMsg, int nPtrParamLen, void* pParam)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDeviceRayence*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_INFORMATOION, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}


void Detector_Rayence::StatusFeedback(int nEventID, int nParam1, const char* pszMsg, int nDetectorID, float fParam2, int nPtrParamLen, void* pParam)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDeviceRayence*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_STATUS, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}


void Detector_Rayence::DataFeedback(int nEventID, void* pParam, int nParam1, float fParam2, const char* pszMsg, int nPtrParamLen, int nDetectorID)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDeviceRayence*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_DATA, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}


void Detector_Rayence::WarnFeedback(int nEventID, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam, int nDetectorID)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDeviceRayence*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_WARNING, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}


void Detector_Rayence::ErrorFeedback(int nEventID, const char* pszMsg, int nDetectorID, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDeviceRayence*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_ERROR, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}

void Detector_Rayence::OffsetProgressFeedback(int nEventID, int nParam1, const char* pszMsg, int nDetectorID, float fParam2, int nPtrParamLen, void* pParam)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDeviceRayence*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_INFORMATOION, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}

void Detector_Rayence::OffsetStatusFeedback(int nEventID, int nParam1, const char* pszMsg, int nDetectorID, float fParam2, int nPtrParamLen, void* pParam)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDeviceRayence*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_INFORMATOION, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}