PhysicalDevice/Detector/Konica/DIOS.Dev.FPD.KonicaDR-64/KonicaCtrl.cpp

#include "stdafx.h"
#include "KonicaCtrl.h"
#include "CCOS.Dev.FPD.KonicaDR.h"
#include "MyPingip.h"


KonicaCtrl* g_pDetector = nullptr;

extern Log4CPP::Logger* gLogger;

#define LOAD_PROC_ADDRESS(handle,func) \
if ((API_##func = (Konica##func)GetProcAddress(handle, #func)) == NULL) \
{ \
FERROR("Error occurs while loading entry point!!! {$}", #func);\
}\


char strAeroSDKini[MAX_PATH] = { 0 };
char strPanelLog[MAX_PATH] = { 0 };
char strXgboxLog[MAX_PATH] = { 0 };
char strECBLog[MAX_PATH] = { 0 };


//========================================================================================
// CallBack Function
//
// You should NOT write code which need much processing time in AeroSDKCallBack().
// The code which need much processing time should be written at outside of AeroSDKCallBack().
// Please refer Section 2.4.1 in AeroSDK Library Manual.
//
// To write the code at outside of AeroSDKCallBack(), we recommend you to use Callback queue. (Ref. SetCallbackQueue/GetCallbackQueue)
//========================================================================================
void _stdcall AeroSDKCallBack(int nType, unsigned int uintParam, char* pstrPanelId, int nXgboxNo)
{
	if (nullptr != g_pDetector)
	{
		g_pDetector->CallBackEvent(nType, uintParam, pstrPanelId, nXgboxNo);
	}
}


KonicaCtrl::KonicaCtrl()
{
	m_pDPC2PanelID = new map<FPDDeviceKonica*, int>();
	m_pPanelID2DPC = new map<int, FPDDeviceKonica*>();
	m_nPanelCount = 0;
	m_nCurrentPanelID = 0;
	m_hSDKModule = nullptr;
	m_nSyncMode = SYNC_AED;
	m_pRawImgBuffer = nullptr;
	m_pPreImgBuffer = nullptr;
	m_pImgBuffer = nullptr;
	m_nImageWidth = 0;
	m_nImageHeight = 0;
	m_nWidthOffset = 0;
	m_nHeightOffset = 0;
	m_nRawImgWidth = 0;
	m_nRawImgHeight = 0;
	m_nPreviewEnable = 0;
	m_nPreImgWidth = 0;
	m_nPreImgHeight = 0;
	m_nAppStatus = APP_STATUS_IDLE;
	m_nSaveRaw = 0;
	m_eCaliType = CCOS_CALIBRATION_TYPE_NONE;
	m_nXwindow = 2000;
	m_nImageNo = 1;
	m_nCurrentLogicMode = AcqMode::NONE;
	m_nCalibrationMode = CCOS_CALIBRATION_MODE_ZSKK;
	m_nCalibrationRounds = 0;
	m_nCalibCurrentCalibrationRound = 0;
	m_nCalibCurrentExposureIndex = 0;
	m_nExposureNumCurrentRound = 0;
	m_pZSKKCalib = nullptr;
	m_strDetectorType = "";
	m_nNotifyStatusTimePeriod = 10000;//默认10秒推一次
	m_nReconnectTimePeriod = 5000;
	m_nDetectorStatus = AEROSDK_PANEL_STATUS_UNKNOWN;
	m_nXgboxNo = 1;
	m_bConnectXgbox = false;

	m_hRespond = CreateEvent(NULL, FALSE, FALSE, NULL);

	m_hStopScanEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hProcessImgEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hDarkEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hGainEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hInitEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hArrayEvent[0] = m_hStopScanEvent;
	m_hArrayEvent[1] = m_hProcessImgEvent;
	m_hArrayEvent[2] = m_hDarkEvent;
	m_hArrayEvent[3] = m_hGainEvent;
	m_hArrayEvent[4] = m_hInitEvent;

	m_hToggleEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hFPDScanThread = nullptr;
	m_hFPDStatusThread = nullptr;
	m_bExit = false;
	m_hReconnectThread = nullptr;

	InitSdkInterface();
}

void KonicaCtrl::InitSdkInterface()
{
	API_AerosdkOpen = nullptr;
	API_AerosdkClose = nullptr;
	API_AerosdkOpenPanel = nullptr;
	API_AerosdkClosePanel = nullptr;
	API_AerosdkChangePriorityConnecttionOfPanel = nullptr;
	API_AerosdkOpenXgbox = nullptr;
	API_AerosdkCloseXgbox = nullptr;
	API_AerosdkStartExposureSequence = nullptr;
	API_AerosdkStartExposureSequenceIt = nullptr;
	API_AerosdkSetReadyBusy = nullptr;
	API_AerosdkCancelExposureSequence = nullptr;
	API_AerosdkCheckImage = nullptr;
	API_AerosdkStartImageResendingSequence = nullptr;
	API_AerosdkStartImageResendingSequenceWithMode = nullptr;
	API_AerosdkStartImageDeleteSequence = nullptr;
	API_AerosdkStartPanelUpdateSequence = nullptr;
	API_AerosdkStartXgboxUpdateSequence = nullptr;
	API_AerosdkGetImageSize = nullptr;
	API_AerosdkGetPreviewImage = nullptr;
	API_AerosdkGetImage = nullptr;
	API_AerosdkSetWirelessMode = nullptr;
	API_AerosdkChangePowerMode = nullptr;
	API_AerosdkGetPanelConnectStatus = nullptr;
	API_AerosdkGetPanelStatusInfo = nullptr;
	API_AerosdkGetPanelBatteryInfo = nullptr;
	API_AerosdkGetPanelSignalInfo = nullptr;
	API_AerosdkGetPanelSettingInfo = nullptr;
	API_AerosdkGetPanelVersionInfo = nullptr;
	API_AerosdkGetPanelConservationInfo = nullptr;
	API_AerosdkGetCradleConservationInfo = nullptr;
	API_AerosdkGetPanelLog = nullptr;
	API_AerosdkGetPanelLastError = nullptr;
	API_AerosdkGetXgboxConnectStatus = nullptr;
	API_AerosdkGetXgboxStatusInfo = nullptr;
	API_AerosdkGetXgboxSettingInfo = nullptr;
	API_AerosdkGetXgboxVersionInfo = nullptr;
	API_AerosdkGetXgboxConservationInfo = nullptr;
	API_AerosdkGetXgboxLog = nullptr;
	API_AerosdkGetXgboxLastError = nullptr;
	API_AerosdkStartGainCalibrationSequence = nullptr;
	API_AerosdkCancelGainCalibrationSequence = nullptr;
	API_AerosdkStartDarkCalibrationSequence = nullptr;
	API_AerosdkGetCalibSignalPercent = nullptr;
	API_AerosdkSetPanelReady = nullptr;
	API_AerosdkSetSsidForSharedPanel = nullptr;
	API_AerosdkSetPanelSensitivity = nullptr;
	API_AerosdkGetPanelGenarationInfo = nullptr;
	API_AerosdkGetPanelResolutionInfo = nullptr;
	API_AerosdkGetImageSizeEx = nullptr;
	API_AerosdkCheckImageEx = nullptr;
	API_AerosdkSetPanelResolution = nullptr;
	API_AerosdkChangeMovingGridSetting = nullptr;
	API_AerosdkGetPanelAlignmentInfo = nullptr;
}


KonicaCtrl::~KonicaCtrl()
{
	if (m_bConnectXgbox)
	{
		// Closing XG-IFBOX (refer Section 8.3.2 of AeroSDK Library Manual)
		API_AerosdkCloseXgbox(m_nXgboxNo);
	}
	if (m_pStPanelStatus[m_nCurrentPanelID]->bConnectState)
	{
		// Closing Panel (refer Section 8.2.2 of AeroSDK Library Manual)
		API_AerosdkClosePanel((char*)m_strDetectorType.c_str());

		// Closing AeroSDK (refer Section 8.1.2 of AeroSDK Library Manual)
		API_AerosdkClose(AEROSDK_OFF, AEROSDK_OFF);
	}
	if (m_hStopScanEvent)
	{
		CloseHandle(m_hStopScanEvent);
		m_hStopScanEvent = nullptr;
	}
	if (m_hGainEvent)
	{
		CloseHandle(m_hGainEvent);
		m_hGainEvent = nullptr;
	}
	if (m_hDarkEvent)
	{
		CloseHandle(m_hDarkEvent);
		m_hDarkEvent = nullptr;
	}
	if (m_hRespond)
	{
		CloseHandle(m_hRespond);
		m_hRespond = nullptr;
	}
	if (m_hToggleEvent)
	{
		CloseHandle(m_hToggleEvent);
		m_hToggleEvent = nullptr;
	}
	if (m_pRawImgBuffer)
	{
		delete[]m_pRawImgBuffer;
		m_pRawImgBuffer = nullptr;
	}
	if (m_pPreImgBuffer)
	{
		delete[]m_pPreImgBuffer;
		m_pPreImgBuffer = nullptr;
	}
	if (m_pImgBuffer)
	{
		delete[]m_pImgBuffer;
		m_pImgBuffer = nullptr;
	}
	if (m_pZSKKCalib)
	{
		delete m_pZSKKCalib;
		m_pZSKKCalib = nullptr;
	}
	if (m_hFPDScanThread)
	{
		CloseHandle(m_hFPDScanThread);
		m_hFPDScanThread = nullptr;
	}
	if (m_hFPDStatusThread)
	{
		CloseHandle(m_hFPDStatusThread);
		m_hFPDStatusThread = nullptr;
	}
	if (m_hReconnectThread)
	{
		CloseHandle(m_hReconnectThread);
		m_hReconnectThread = nullptr;
	}
}


bool KonicaCtrl::DriverEntry(FPDDeviceKonica* pDrvDPC, ResDataObject& Configuration)
{
	printf("======== DriverEntry %p\n", pDrvDPC);
	FINFO("======== DriverEntry {$}", pDrvDPC);

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

	CPanelStatus* p = new CPanelStatus();
	m_pStPanelStatus[m_nPanelCount] = p;

	m_pDPC2PanelID->insert(pair<FPDDeviceKonica*, int>(pDrvDPC, m_nPanelCount));
	m_pPanelID2DPC->insert(pair<int, FPDDeviceKonica*>(m_nPanelCount, pDrvDPC));
	m_nPanelCount++;
	m_ModeConfig = Configuration; //记录配置  --目前只有一个平板，多板时应该分别存储
	//FINFO("Config: {$}", m_ModeConfig.encode());

	try
	{
		m_nCalibrationMode = (CCOS_CALIBRATION_MODE)(int)m_ModeConfig["CalibMode"];
		m_nNotifyStatusTimePeriod = (int)m_ModeConfig["NotifyStatusTimePeriod"];
		m_nReconnectTimePeriod = (int)m_ModeConfig["ReConnectTimePeriod"];
		m_strDetectorType = (string)m_ModeConfig["SerialNumber"];
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Read configuration failed, Error code: {$}", e.what());
	}

	return true;
}


bool KonicaCtrl::Connect(FPDDeviceKonica* pDrvDPC, const char* szWorkPath)
{
	FINFO("======== Connect detector begin");
	printf("======== Connect detector begin \r\n");

	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		FINFO("Not current DPC, return true");
		printf("Not current DPC, return true \r\n");
		return true;
	}

	if (!m_pZSKKCalib)
	{
		m_pZSKKCalib = new CZSKKCalibrationCtrl();
	}

	m_strWorkPath = szWorkPath;
	if (nullptr == m_hFPDScanThread)
	{
		unsigned uThreadId;
		_beginthreadex(NULL, 0, onFPDScanThread, this, 0, &uThreadId);
		m_hFPDScanThread = OpenThread(THREAD_ALL_ACCESS, TRUE, uThreadId);
	}
	SetEvent(m_hInitEvent);

	FINFO("======== Connect over");
	printf("======== Connect over \r\n");
	return true;
}


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

	if (nExamMode == APP_STATUS_WORK_END || nExamMode == APP_STATUS_CAL_END)
	{
		m_pStPanelStatus[m_nCurrentPanelID]->eFPDStatus = eDetStatus::DetStatus_Standby;
	}
}


/***
** 根据采集模式申请图像buffer
***/
bool KonicaCtrl::SetAcqMode(int nMode)
{
	FINFO("======== KonicaCtrl::SetAcqMode mode:{$}", nMode);
	if (m_nCurrentLogicMode == nMode)
	{
		FINFO("Same acq mode,return");
		return true;
	}
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectState)
	{
		FERROR("bConnectState is false, Detector not connected, return");
		return false;
	}

	try
	{
		int nModeCount = (int)m_ModeConfig["ModeTable"].size();
		for (int i = 0; i < nModeCount; i++)
		{
			int nAppModeID = (int)m_ModeConfig["ModeTable"][i]["LogicMode"];
			if (nAppModeID == nMode)
			{
				m_nWidthOffset = (int)m_ModeConfig["ModeTable"][i]["WidthOffset"];
				m_nHeightOffset = (int)m_ModeConfig["ModeTable"][i]["HeightOffset"];
				m_nPreviewEnable = (int)m_ModeConfig["ModeTable"][i]["PreviewEnable"];
				m_nXwindow = (int)m_ModeConfig["ModeTable"][i]["XWindow"];
				m_nSaveRaw = (int)m_ModeConfig["ModeTable"][i]["IsSaveRaw"];
				FINFO("image WidthOffset: {$}, HeightOffset: {$}, m_nPreviewEnable:{$},m_nXwindow:{$},m_nSaveRaw:{$}",
					m_nWidthOffset, m_nHeightOffset, m_nPreviewEnable, m_nXwindow, m_nSaveRaw);

				m_nCurrentLogicMode = nMode;
				break;
			}
		}
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Get config error: {$}", e.what());
		return false;
	}
	
	return true;
}

bool KonicaCtrl::ActiveSyncMode(int nSyncMode)
{
	FINFO("======== KonicaCtrl::ActiveSyncMode nSyncMode:{$}", nSyncMode);
	m_nSyncMode = nSyncMode;
	return true;
}

bool KonicaCtrl::PrepareAcquisition(FPDDeviceKonica* pDrvDPC)
{
	FINFO("======== PrepareAcquisition start");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}
	//未初始化、未连接 不执行
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectState)
	{
		FERROR("bConnectState is false, Detector not connected, return");
		return false;
	}

	int nRet = AEROSDK_OK;
	if (m_nSyncMode == SYNC_AED)
	{
		FINFO("Call API_AerosdkStartExposureSequenceIt");
		// Starting Exposure Sequence in AeroSync mode (refer Section 4.3 and 8.4.2 of AeroSDK Library Manual)
		nRet = API_AerosdkStartExposureSequenceIt((char*)m_strDetectorType.c_str(), 0, m_nImageNo, AEROSDK_COOPERATION_AEROSYNC, AEROSDK_INTEGRATION_DEFAULT, AEROSDK_MOVEMODE_NORMAL);
		if (TestError(nRet, "API_AerosdkStartExposureSequenceIt"))
		{
			// If this error often happened, User Program has to StartExposureSequenceIt again
			FERROR("Start Exposure SequenceIt Failure");
			return false;
		}
	}
	else if (m_nSyncMode == SYNC_HARDWARE)
	{
		if (!m_bConnectXgbox)
		{
			FINFO("Call API_AerosdkOpenXgbox");
			nRet = API_AerosdkOpenXgbox(m_nXgboxNo, NULL, strECBLog, strXgboxLog, NULL);
			if (TestError(nRet, "API_AerosdkOpenXgbox"))
			{
				return false;
			}
		}
		
		bool bRet = WaitRespond(30000,"XgboxConnect");
		if (!bRet) 
		{
			return false;
		}
		
		FINFO("Call API_AerosdkStartExposureSequenceIt");
		// Starting Exposure Sequence in AeroSync mode (refer Section 4.3 and 8.4.2 of AeroSDK Library Manual)
		nRet = API_AerosdkStartExposureSequenceIt((char*)m_strDetectorType.c_str(), m_nXgboxNo, m_nImageNo, AEROSDK_COOPERATION_SRM, AEROSDK_INTEGRATION_DEFAULT, AEROSDK_MOVEMODE_NORMAL);
		if (TestError(nRet, "API_AerosdkStartExposureSequenceIt"))
		{
			// Fatal Error
			// This is just a sample program, so program is terminated.
			// But this error can be often happened, so User Program has to StartExposureSequence again
			// after showing the notification on GUI and waiting for operator's recovery procedure.
			FERROR("Start Exposure SequenceIt Failure");
			return false;
		}
	}
	else 
	{
		FERROR("Not support this sync mode:{$}", m_nSyncMode);
		return false;
	}
	
	m_pStPanelStatus[m_nCurrentPanelID]->eFPDStatus = eDetStatus::DetStatus_Work;
	FINFO("======== PrepareAcquisition end");
	return true;
}


bool KonicaCtrl::StartAcquisition(FPDDeviceKonica* pDrvDPC)
{
	FINFO("======== StartAcquisition start");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}
	//未初始化、未连接 不执行
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectState)
	{
		FERROR("bConnectState is false, Detector not connected, return");
		return false;
	}

	m_pStPanelStatus[m_nCurrentPanelID]->eFPDStatus = eDetStatus::DetStatus_Acquire;
	FINFO("======== StartAcquisition end");
	return true;
}


bool KonicaCtrl::StopAcquisition(FPDDeviceKonica* pDrvDPC)
{
	FINFO("======== StopAcquisition start");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectState)
	{
		FERROR("bConnectState is false, Detector not connected, return");
		return false;
	}
	//如果探测器仍为曝光状态 那么取消曝光状态
	int nDetectorStatus = AEROSDK_PANEL_STATUS_UNKNOWN;
	FINFO("Call API_AerosdkGetPanelStatusInfo");
	int nRet = API_AerosdkGetPanelStatusInfo((char*)m_strDetectorType.c_str(), &nDetectorStatus);
	if (TestError(nRet,"API_AerosdkGetPanelStatusInfo"))
	{
		FERROR("Get detector status fail!");
		return false;
	}
	FINFO("nDetectorStatus:{$}", nDetectorStatus);
	if (nDetectorStatus == AEROSDK_PANEL_STATUS_EXPOSURE || nDetectorStatus == AEROSDK_PANEL_STATUS_READY || nDetectorStatus == AEROSDK_PANEL_STATUS_WAIT_READY)
	{
		FINFO("Call API_AerosdkCancelExposureSequence");
		nRet = API_AerosdkCancelExposureSequence((char*)m_strDetectorType.c_str(), m_nImageNo);
		if (TestError(nRet, "API_AerosdkCancelExposureSequence"))
		{
			FERROR("Cancel exposure sequence fail!");
			return false;
		}
	}
	m_pStPanelStatus[m_nCurrentPanelID]->eFPDStatus = eDetStatus::DetStatus_Standby;
	FINFO("======== StopAcquisition end");
	return true;
}


bool KonicaCtrl::ActiveCalibration(FPDDeviceKonica* pDrvDPC, CCOS_CALIBRATION_TYPE eType)
{
	FINFO("======== ActiveCalibration start");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}

	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectState)
	{
		FERROR("bConnectState is false, Detector not connected, return");
		return false;
	}

	StatusFeedback(EVT_STATUS_CALIBRATIOIN, PANEL_EVENT_START);
	m_nAppStatus = APP_STATUS_CAL_BEGIN; //激活校正，置为校正界面
	m_eCaliType = eType;

	if (CCOS_CALIBRATION_TYPE_DARK == m_eCaliType)
	{
		FINFO("Active Dark Calibration");
	}
	if (CCOS_CALIBRATION_TYPE_XRAY == m_eCaliType)
	{
		FINFO("Active Xray Calibration");
		if (m_nCalibrationMode) //厂商校正ActiveCalibration
		{

		}
		else //ZSKK校正
		{
			if (!m_pZSKKCalib)
			{
				FERROR("ZSKK Calibration object is undefined");
			}
			else
			{
				//加载ZSKK的校正文件
				m_pZSKKCalib->m_strRawImgPath = m_strWorkPath + "\\rawdata\\";
				m_pZSKKCalib->m_strRefFilePath = m_strWorkPath + "\\references\\";
				m_pZSKKCalib->m_nFullImgWidth = m_nImageWidth;
				m_pZSKKCalib->m_nFullImgHeight = m_nImageHeight;
				m_pZSKKCalib->m_nReferenceNum = m_nCalibrationRounds;
				m_pZSKKCalib->m_nSaturationValue = 50000;
				//LoadZSKKGainMap 参数为false,意思是开始增益校正
				m_pZSKKCalib->LoadZSKKGainMap(false, m_strDetectorType);
				m_pZSKKCalib->LoadZSKKPixelMap(false, m_strDetectorType);
				FINFO("Load ecom gain and pixel map, references file path: {$}", m_pZSKKCalib->m_strRefFilePath);
			}
		}
	}
	FINFO("======== ActiveCalibration end");
	return true;
}

/***
* 接受曝光图像
***/
bool KonicaCtrl::AcceptCalibration()
{
	FINFO("======== AcceptCalibration");
	if (m_nCalibrationMode)//厂商校正AcceptCalibration
	{
		//不做处理
	}
	else //ZSKK校正
	{
		WORD* pImageBuffer = nullptr;
		//这里要注意使用的image buffer是哪个，裁剪和不裁剪是不一样的
		if (m_nWidthOffset != 0 || m_nHeightOffset != 0)
		{
			pImageBuffer = m_pImgBuffer;
		}
		else 
		{
			pImageBuffer = m_pRawImgBuffer;
		}

		if (m_nCalibCurrentExposureIndex == 1)
		{
			m_pZSKKCalib->AddImageToPixMap(pImageBuffer);
			m_pZSKKCalib->AverageZSKKGainMap(pImageBuffer, m_nCalibCurrentCalibrationRound - 1, true);
		}
		else
		{
			m_pZSKKCalib->AverageZSKKGainMap(pImageBuffer, m_nCalibCurrentCalibrationRound - 1, false); //曝光第几轮
		}
	}
	return true;
}

/***
* 拒绝曝光图像
***/
bool KonicaCtrl::RejectCalibration()
{
	FINFO("======== RejectCalibration");
	return true;
}

/***
* 设置校正轮数
***/
void KonicaCtrl::SetCalibRounds(int nCalibRounds)
{
	m_nCalibrationRounds = nCalibRounds;
	FINFO("======== Set CalibrationRounds: {$}", m_nCalibrationRounds);
}

bool KonicaCtrl::GetCalibrationStep(int nCalibCurrentCalibrationRound, int nCalibrationRounds, int nCalibCurrentExposureIndex, int nExposureNumCurrentRound)
{
	m_nCalibCurrentCalibrationRound = nCalibCurrentCalibrationRound;
	m_nCalibrationRounds = nCalibrationRounds;
	m_nCalibCurrentExposureIndex = nCalibCurrentExposureIndex;
	m_nExposureNumCurrentRound = nExposureNumCurrentRound;
	FINFO("Calibration Step===Round: {$}/{$}, ExposureNum: {$}/{$}", nCalibCurrentCalibrationRound, nCalibrationRounds,
		nCalibCurrentExposureIndex, nExposureNumCurrentRound);
	return true;
}


//使探测器ready
bool KonicaCtrl::PrepareCalibration(FPDDeviceKonica* pDrvDPC)
{
	FINFO("======== PrepareCalibration start");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectState)
	{
		FERROR("bConnectState is false, Detector not connected, return");
		return false;
	}

	if (CCOS_CALIBRATION_TYPE_DARK == m_eCaliType)
	{
		FINFO("PrepareCalibration -- DARK");
		if (m_nCalibrationMode)//厂商校正PrepareCalibration
		{
			
		}
		else 
		{
			
		}
	}
	else if (CCOS_CALIBRATION_TYPE_XRAY == m_eCaliType)
	{
		FINFO("PrepareCalibration -- XRAY");
		bool ret = PrepareAcquisition(pDrvDPC);
		if (ret)
		{
			FINFO("PrepareCalibration PrepareAcquisition success!");
		}
		else
		{
			FERROR("PrepareCalibration PrepareAcquisition fail!");
			return false;
		}
	}
	FINFO("======== PrepareCalibration end");
	return true;
}


//软同步调用接口，其它同步模式没有动作
bool KonicaCtrl::StartCalibration(FPDDeviceKonica* pDrvDPC)
{
	FINFO("======== StartCalibration start");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}

	//未初始化、未连接 不执行
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectState)
	{
		FERROR("bConnectState is false, Detector not connected, return");
		return false;
	}

	if (CCOS_CALIBRATION_TYPE_DARK == m_eCaliType)
	{
		FINFO("StartCalibration DARK");
		StatusFeedback(EVT_STATUS_CALIBRATIOIN, PANEL_EVENT_END_OK);
		m_pStPanelStatus[m_nCurrentPanelID]->eFPDStatus = eDetStatus::DetStatus_Offset;
	}
	else if (CCOS_CALIBRATION_TYPE_XRAY == m_eCaliType)
	{
		FINFO("StartCalibration XRAY");
		bool ret = StartAcquisition(pDrvDPC);
		if (!ret)
		{
			return false;
		}
		m_pStPanelStatus[m_nCurrentPanelID]->eFPDStatus = eDetStatus::DetStatus_XrayCalibration;
	}
	FINFO("======== StartCalibration end");
	return true;
}


/***
** 说明：终止校正
***/
bool KonicaCtrl::AbortCalibration(FPDDeviceKonica* pDrvDPC)
{
	FINFO("======== AbortCalibration start");
	m_eCaliType = CCOS_CALIBRATION_TYPE_NONE; //恢复初值

	if (m_nCalibrationMode) //厂商校正AbortCalibration
	{

	}
	else
	{
		FINFO("Reload Gain Map And Pixel Map");
		//重新加载增益校正文件
		if (!m_pZSKKCalib->LoadZSKKGainMap(true, m_strDetectorType))
		{
			Warn("Load ZSKK Gain calibration failed");
		}
		//放弃坏点校正并重新加载原来的坏点校正文件
		m_pZSKKCalib->AbortZSKKPixMap(m_strDetectorType);
	}
	m_nAppStatus = APP_STATUS_CAL_END;
	FINFO("======== AbortCalibration over");
	return true;
}

bool KonicaCtrl::StopCalibration(FPDDeviceKonica* pDrvDPC)
{
	FINFO("======== StopCalibration");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectState)
	{
		FERROR("bConnectState is false, Detector not connected, return");
		return false;
	}

	m_nAppStatus = APP_STATUS_CAL_END;
	return true;
}

/***
** 说明：获取校正时间
** 连接成功后，校正完成后 获取
***/
bool KonicaCtrl::GetCalibrationTime(int nDetectorID)
{
	if (nDetectorID == -1)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	else
	{
		InfoFeedback(EVT_INFO_CALIBRATIOIN_TIME, nDetectorID, 0, 0, "0");
		InfoFeedback(EVT_INFO_CALIBRATIOIN_TIMEL, nDetectorID, 0, 0, "0");
	}

	return true;
}

/***
** 说明：结束校正
** DPC处理完校正报告后调用，此处上传map、报告等文件
***/
bool KonicaCtrl::CompleteCalibration(FPDDeviceKonica* pDrvDPC)
{
	FINFO("======== CompleteCalibration calib type {$}", (int)m_eCaliType);
	if (m_eCaliType == CCOS_CALIBRATION_TYPE_DARK)
	{
		printf("DARK DARK Calib over \r\n");
		FINFO("DARK Calib over");
	}
	else if (m_eCaliType == CCOS_CALIBRATION_TYPE_XRAY)
	{
		printf("XRAY Calib over \r\n");
		FINFO("XRAY Calib over");
		GetCalibrationTime();
		m_nAppStatus = APP_STATUS_CAL_END;
	}

	return true;
}

bool KonicaCtrl::SaveCalibrationFile()
{
	FINFO("======== Save Calibration File");
	StatusFeedback(EVT_STATUS_SAVECALIB, PANEL_EVENT_START);
	if (m_nCalibrationMode)//厂商校正SaveCalibrationFile
	{
		//不做处理
	}
	else
	{
		FINFO("Save ZSKK Calibration File");
		m_pZSKKCalib->StoreZSKKGainMap(m_strDetectorType);
		m_pZSKKCalib->StoreZSKKPixMap(m_strDetectorType);
	}

	StatusFeedback(EVT_STATUS_SAVECALIB, PANEL_EVENT_END);
	//更新配置文件中校正日期和时间
	SYSTEMTIME stCurrentTime = { 0 };
	GetLocalTime(&stCurrentTime);
	FINFO("save calib file time: {$04d}/{$02d}/{$02d} {$02d}:{$02d}:{$02d}:{$03d}",
		stCurrentTime.wYear, stCurrentTime.wMonth, stCurrentTime.wDay,
		stCurrentTime.wHour, stCurrentTime.wMinute, stCurrentTime.wSecond, stCurrentTime.wMilliseconds);

	FINFO("======== Save Calibration File over");
	return true;
}

CCOS_CALIBRATION_TYPE KonicaCtrl::GetCalibType()
{
	FINFO("======== GetCalibType {$}", (int)m_eCaliType);
	return m_eCaliType;
}


bool KonicaCtrl::LoadDll(string strWorkPath)
{
	FINFO("LoadDll start");
	string strSDKPath = "";
	try
	{
		strSDKPath = (string)m_ModeConfig["SDKPath"];
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Read configuration failed! reason: {$}", e.what());
		return false;
	}

	string workpath = strWorkPath + strSDKPath;
	string drvpath = workpath + "\\Aerosdk.dll";
	FINFO("SDK path:{$}", drvpath);
	SetDllDirectory(workpath.c_str());
	m_hSDKModule = LoadLibrary(drvpath.c_str());
	if (m_hSDKModule == nullptr)
	{
		DWORD dw = GetLastError();
		FERROR("Load {$} failed! error code: {$}", drvpath.c_str(), dw);
		return false;
	}

	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkOpen);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkClose);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkOpenPanel);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkClosePanel);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkChangePriorityConnecttionOfPanel);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkOpenXgbox);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkCloseXgbox);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkStartExposureSequence);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkStartExposureSequenceIt);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkSetReadyBusy);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkCancelExposureSequence);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkCheckImage);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkStartImageResendingSequence);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkStartImageResendingSequenceWithMode);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkStartImageDeleteSequence);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkStartPanelUpdateSequence);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkStartXgboxUpdateSequence);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetImageSize);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetPreviewImage);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetImage);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkSetWirelessMode);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkChangePowerMode);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetPanelConnectStatus);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetPanelStatusInfo);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetPanelBatteryInfo);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetPanelSignalInfo);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetPanelSettingInfo);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetPanelVersionInfo);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetPanelConservationInfo);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetCradleConservationInfo);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetPanelLog);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetPanelLastError);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetXgboxConnectStatus);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetXgboxStatusInfo);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetXgboxSettingInfo);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetXgboxVersionInfo);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetXgboxConservationInfo);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetXgboxLog);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetXgboxLastError);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkStartGainCalibrationSequence);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkCancelGainCalibrationSequence);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkStartDarkCalibrationSequence);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetCalibSignalPercent);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkSetPanelReady);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkSetSsidForSharedPanel);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkSetPanelSensitivity);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetPanelGenarationInfo);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetPanelResolutionInfo);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetImageSizeEx);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkCheckImageEx);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkSetPanelResolution);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkChangeMovingGridSetting);
	LOAD_PROC_ADDRESS(m_hSDKModule, AerosdkGetPanelAlignmentInfo);

	FINFO("LoadDll end");
	return true;
}

// Initialize
void KonicaCtrl::Initialize(StAerosdkLogInfo* sLogInfo,char* strSdkPath, char* strAeroSDKini, char* strPanelLog, char* strXGBOXLog, char* strECBLog)
{
	FINFO("Initialize strSdkPath:{$}", strSdkPath);
	if (sLogInfo) 
	{
		ZeroMemory(sLogInfo, sizeof(StAerosdkLogInfo));
		sLogInfo->intLogLevel = AEROSDK_LOG_DEBUG;
		sprintf_s(sLogInfo->strSdkLog, sizeof(sLogInfo->strSdkLog), "%s%s", strSdkPath, "\\Log\\AeroSDK.log");
		sprintf_s(sLogInfo->strKmfLog, sizeof(sLogInfo->strKmfLog), "%s%s", strSdkPath, "\\Log\\KmfLog.log");
	}

	if (strAeroSDKini) 
	{
		sprintf_s(strAeroSDKini, MAX_PATH, "%s%s", strSdkPath, "\\Conf\\AerosdkSetting.ini");
	}

	if (strPanelLog)
	{
		sprintf_s(strPanelLog, MAX_PATH, "%s%s", strSdkPath, "\\Log\\Panel.log");
	}

	if (strXGBOXLog)
	{
		sprintf_s(strXGBOXLog, MAX_PATH, "%s%s", strSdkPath, "\\Log\\XGBOX.log");
	}

	if (strECBLog)
	{
		sprintf_s(strECBLog, MAX_PATH, "%s%s", strSdkPath, "\\Log\\ECB.log");
	}
}


/***
** 连接探测器
***/
bool KonicaCtrl::OpenDetector()
{
	FINFO("OpenDetector start");
	string strSdkPath = "";
	int nRet = -1;

	try
	{
		strSdkPath = (string)m_ModeConfig["SDKPath"];
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Read configuration failed, Error code: {$}", e.what());
		return false;
	}
	string strWorkpath = m_strWorkPath + strSdkPath;
	FINFO("OpenDetector strWorkpath:{$}", strWorkpath);

	StAerosdkLogInfo sLogInfo;
	Initialize(&sLogInfo, (char*)strWorkpath.c_str(), strAeroSDKini, strPanelLog, strXgboxLog, strECBLog);

	//注册回调
	FINFO("Call API_AerosdkOpen");
	nRet = API_AerosdkOpen(AeroSDKCallBack, strAeroSDKini, AEROSDK_ON, &sLogInfo);
	if (TestError(nRet, "API_AerosdkOpen"))
	{
		return false;
	}

	//连接探测器
	FINFO("Call API_AerosdkOpenPanel");
	nRet = API_AerosdkOpenPanel((char*)m_strDetectorType.c_str(), NULL, NULL, strPanelLog, NULL);
	if (TestError(nRet, "API_AerosdkOpenPanel"))
	{
		FINFO("Call API_AerosdkClose");
		API_AerosdkClose(AEROSDK_OFF, AEROSDK_OFF);
		return false;
	}

	FINFO("OpenDetector end");
	return true;
}


/***
** 初始化探测器
***/
bool KonicaCtrl::InitDetector()
{
	FINFO("InitDetector start");
	int nRet = -1;

	//输出探测器版本信息、序列号等
	nRet = ShowDetectorInfo();
	if (nRet != AEROSDK_OK)
	{
		FERROR("Get detector info fail!");
		return false;
	}

	//开启单独的线程每隔一段时间调一下接口读取探测器的温度和电量和wifi信号
	if (nullptr == m_hFPDStatusThread)
	{
		unsigned uThreadId;
		_beginthreadex(NULL, 0, onFPDStatusThread, this, 0, &uThreadId);
		m_hFPDStatusThread = OpenThread(THREAD_ALL_ACCESS, TRUE, uThreadId);
	}

	try
	{
		int nModeCount = (int)m_ModeConfig["ModeTable"].size();
		for (int i = 0; i < nModeCount; i++)
		{
			int nAppModeID = (int)m_ModeConfig["ModeTable"][i]["LogicMode"];
			if (nAppModeID == AcqMode::RAD)
			{
				m_nImageWidth = (int)m_ModeConfig["ModeTable"][i]["ImageWidth"];
				m_nImageHeight = (int)m_ModeConfig["ModeTable"][i]["ImageHeight"];
				break;
			}
		}
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Get config error: {$}", e.what());
		return false;
	}

	if (m_nCalibrationMode)//厂商校正InitDetector
	{
	}
	else
	{
		Info("Load ZSKK Reference file");
		m_pZSKKCalib->m_strRawImgPath = m_strWorkPath + "\\rawdata\\";
		m_pZSKKCalib->m_strRefFilePath = m_strWorkPath + "\\references\\";
		//读取配置文件中RAD模式的高和宽
		m_pZSKKCalib->m_nFullImgWidth = m_nImageWidth;
		m_pZSKKCalib->m_nFullImgHeight = m_nImageHeight;
		m_pZSKKCalib->m_nSaturationValue = 50000;
		if (!m_pZSKKCalib->LoadZSKKGainMap(true, m_strDetectorType))
		{
			Warn("Load ZSKK Gain calibration failed");
		}
		if (!m_pZSKKCalib->LoadZSKKPixelMap(true, m_strDetectorType))
		{
			Warn("Load ZSKK Defect calibration failed");
		}
	}

	FINFO("InitDetector end");
	return true;
}


int KonicaCtrl::ShowDetectorInfo()
{
	FINFO("Getting Detector Info");
	int nRet = AEROSDK_OK;
	/*API_AerosdkGetPanelSettingInfo;
	API_AerosdkGetPanelVersionInfo;
	API_AerosdkGetPanelConservationInfo;
	API_AerosdkGetCradleConservationInfo;
	API_AerosdkGetXgboxStatusInfo;
	API_AerosdkGetXgboxSettingInfo;
	API_AerosdkGetXgboxVersionInfo;
	API_AerosdkGetXgboxConservationInfo;
	API_AerosdkGetPanelGenarationInfo;
	API_AerosdkGetPanelResolutionInfo;
	API_AerosdkGetPanelAlignmentInfo;*/

	//后续可改为从配置文件中读取
	int nPanelResolution = AEROSDK_RESOLUTION_NORMAL;//老板子1417HQ 不支持高分辨率的模式
	// Set resolution type.
	FINFO("Call API_AerosdkSetPanelResolution");
	nRet = API_AerosdkSetPanelResolution((char*)m_strDetectorType.c_str(), nPanelResolution);
	if (TestError(nRet, "API_AerosdkSetPanelResolution"))
	{
		FERROR("AerosdkSetPanelResolution Failure.");
		return nRet;
	}

	FINFO("Call API_AerosdkGetPanelResolutionInfo");
	nRet = API_AerosdkGetPanelResolutionInfo((char*)m_strDetectorType.c_str(), &nPanelResolution);
	if(TestError(nRet,"API_AerosdkGetPanelResolutionInfo"))
	{
		return nRet;
	}
	FINFO("Panel resolution:{$}", nPanelResolution);

	// Check whether High resolution is supported by the Panel or not.
	if (AEROSDK_RESOLUTION_HIGH & nPanelResolution)
	{
		// Acquisition of preview image size as High resolution.
		FINFO("Call API_AerosdkGetImageSizeEx");
		nRet = API_AerosdkGetImageSizeEx((char*)m_strDetectorType.c_str(), AEROSDK_IMAGE_PREVIEW, AEROSDK_RESOLUTION_HIGH, &m_nPreImgWidth, &m_nPreImgHeight);
		if (TestError(nRet, "API_AerosdkGetImageSizeEx"))
		{
			FERROR("AerosdkGetImageSizeEx AEROSDK_RESOLUTION_HIGH/AEROSDK_IMAGE_PREVIEW Failure.");
			return nRet;
		}
		FINFO("Preview Size (High Resolution)  width:{$} Height:{$}", m_nPreImgWidth, m_nPreImgHeight);

		// Acquisition of final image size as High resolution.
		FINFO("Call API_AerosdkGetImageSizeEx");
		nRet = API_AerosdkGetImageSizeEx((char*)m_strDetectorType.c_str(), AEROSDK_IMAGE_EXPOSURE, AEROSDK_RESOLUTION_HIGH, &m_nRawImgWidth, &m_nRawImgHeight);
		if (TestError(nRet, "API_AerosdkGetImageSizeEx"))
		{
			FERROR("AerosdkGetImageSizeEx AEROSDK_RESOLUTION_HIGH/AEROSDK_IMAGE_EXPOSURE Failure.");
			return nRet;
		}
		FINFO("Exposure Size (High Resolution)  width:{$} Height:{$}", m_nRawImgWidth, m_nRawImgHeight);
	}

	// Check whether Normal resolution is supported by the Panel or not.
	if (AEROSDK_RESOLUTION_NORMAL & nPanelResolution)
	{
		// Acquisition of preview image size as Normal resolution.
		FINFO("Call API_AerosdkGetImageSizeEx");
		nRet = API_AerosdkGetImageSizeEx((char*)m_strDetectorType.c_str(), AEROSDK_IMAGE_PREVIEW, AEROSDK_RESOLUTION_NORMAL, &m_nPreImgWidth, &m_nPreImgHeight);
		if (TestError(nRet, "API_AerosdkGetImageSizeEx"))
		{
			FERROR("AerosdkGetImageSizeEx AEROSDK_RESOLUTION_NORMAL/AEROSDK_IMAGE_PREVIEW Failure.");
			return nRet;
		}
		FINFO("Preview Size (Normal Resolution)  width:{$} Height:{$}", m_nPreImgWidth, m_nPreImgHeight);

		// Acquisition of final image size as Normal resolution.
		FINFO("Call API_AerosdkGetImageSizeEx");
		nRet = API_AerosdkGetImageSizeEx((char*)m_strDetectorType.c_str(), AEROSDK_IMAGE_EXPOSURE, AEROSDK_RESOLUTION_NORMAL, &m_nRawImgWidth, &m_nRawImgHeight);
		if (TestError(nRet, "API_AerosdkGetImageSizeEx"))
		{
			FERROR("AerosdkGetImageSizeEx AEROSDK_RESOLUTION_NORMAL/AEROSDK_IMAGE_EXPOSURE Failure.");
			return nRet;
		}
		FINFO("Exposure Size (High Resolution)  width:{$} Height:{$}", m_nRawImgWidth, m_nRawImgHeight);
	}

	ConfFeedback(EVT_CONF_PREVIEW_WIDTH, m_nCurrentPanelID, "PreviewImageWidth", m_nPreImgWidth);
	ConfFeedback(EVT_CONF_PREVIEW_HIGHT, m_nCurrentPanelID, "PreviewImageHeight", m_nPreImgHeight);
	ConfFeedback(EVT_CONF_RAW_WIDTH, m_nCurrentPanelID, "FullImageWidth", m_nRawImgWidth);
	ConfFeedback(EVT_CONF_RAW_HIGHT, m_nCurrentPanelID, "FullImageHeight", m_nRawImgHeight);

	if (m_pPreImgBuffer != nullptr)
	{
		delete[] m_pPreImgBuffer;
		m_pPreImgBuffer = nullptr;
	}
	m_pPreImgBuffer = new WORD[m_nPreImgWidth * m_nPreImgHeight];
	if (m_pRawImgBuffer != nullptr)
	{
		delete[] m_pRawImgBuffer;
		m_pRawImgBuffer = nullptr;
	}
	m_pRawImgBuffer = new WORD[m_nRawImgWidth * m_nRawImgHeight];
	if (m_pImgBuffer != nullptr)
	{
		delete[] m_pImgBuffer;
		m_pImgBuffer = nullptr;
	}
	m_pImgBuffer = new WORD[m_nRawImgWidth * m_nRawImgHeight];
	
	StAerosdkPanelSettingInfo settingInfo;
	FINFO("Call API_AerosdkGetPanelSettingInfo");
	nRet = API_AerosdkGetPanelSettingInfo((char*)m_strDetectorType.c_str(), &settingInfo);
	if (TestError(nRet, "API_AerosdkGetPanelSettingInfo"))
	{
		FERROR("API_AerosdkGetPanelSettingInfo Failure.");
		return nRet;
	}
	FINFO("Panel ID:{$},Panel size:{$}", settingInfo.strPanelId, settingInfo.intPanelSize);

	StAerosdkPanelVersionInfo versionInfo;
	FINFO("Call API_AerosdkGetPanelVersionInfo");
	nRet = API_AerosdkGetPanelVersionInfo((char*)m_strDetectorType.c_str(), &versionInfo);
	if (TestError(nRet, "API_AerosdkGetPanelVersionInfo"))
	{
		FERROR("API_AerosdkGetPanelVersionInfo Failure.");
		return nRet;
	}
	FINFO("Firmware dll version:{$}.{$}.{$}.{$}", (int)versionInfo.ucharDllVersion[0], (int)versionInfo.ucharDllVersion[1], (int)versionInfo.ucharDllVersion[2], (int)versionInfo.ucharDllVersion[3]);
	FINFO("Generic version:{$}.{$}.{$}.{$}", (int)versionInfo.ucharAllVersion[0], (int)versionInfo.ucharAllVersion[1], (int)versionInfo.ucharAllVersion[2], (int)versionInfo.ucharAllVersion[3]);
	FINFO("Communication control boot version:{$}.{$}.{$}.{$}", (int)versionInfo.ucharFwComnBootVersion[0], (int)versionInfo.ucharFwComnBootVersion[1], (int)versionInfo.ucharFwComnBootVersion[2], (int)versionInfo.ucharFwComnBootVersion[3]);
	FINFO("Communication control firmware version:{$}.{$}.{$}.{$}", (int)versionInfo.ucharFwComnVersion[0], (int)versionInfo.ucharFwComnVersion[1], (int)versionInfo.ucharFwComnVersion[2], (int)versionInfo.ucharFwComnVersion[3]);
	FINFO("Power control boot version:{$}.{$}.{$}.{$}", (int)versionInfo.ucharFwPowerBootVersion[0], (int)versionInfo.ucharFwPowerBootVersion[1], (int)versionInfo.ucharFwPowerBootVersion[2], (int)versionInfo.ucharFwPowerBootVersion[3]);
	FINFO("Power control firmware version:{$}.{$}.{$}.{$}", (int)versionInfo.ucharFwPowerVersion[0], (int)versionInfo.ucharFwPowerVersion[1], (int)versionInfo.ucharFwPowerVersion[2], (int)versionInfo.ucharFwPowerVersion[3]);
	FINFO("FPGA version:{$}.{$}.{$}.{$}", (int)versionInfo.ucharFpgaVersion[0], (int)versionInfo.ucharFpgaVersion[1], (int)versionInfo.ucharFpgaVersion[2], (int)versionInfo.ucharFpgaVersion[3]);

	unsigned int nShootCount = 0;
	FINFO("Call API_AerosdkGetPanelConservationInfo");
	nRet = API_AerosdkGetPanelConservationInfo((char*)m_strDetectorType.c_str(), &nShootCount);
	if (TestError(nRet, "API_AerosdkGetPanelConservationInfo"))
	{
		FERROR("API_AerosdkGetPanelConservationInfo Failure.");
		return nRet;
	}
	FINFO("Panel Conservation info:{$}", nShootCount);

	int nConnectCount = 0;
	FINFO("Call API_AerosdkGetCradleConservationInfo");
	nRet = API_AerosdkGetCradleConservationInfo((char*)m_strDetectorType.c_str(), &nConnectCount);
	if (TestError(nRet, "API_AerosdkGetCradleConservationInfo"))
	{
		FERROR("API_AerosdkGetCradleConservationInfo Failure.");
		return nRet;
	}
	FINFO("Cradle connect count:{$}", nConnectCount);

	return nRet;
}


bool KonicaCtrl::ActiveDetector(FPDDeviceKonica* pDrvDPC, bool bActive)
{
	FINFO("========ActiveDetector bActive:{$}", bActive);
	
	if (bActive)
	{
		if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
		{
			printf("Not current DPC, return\n");
			FERROR("Not current DPC, return");
			return false;
		}
		//未初始化、未连接 不执行
		if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectState)
		{
			FERROR("bConnectState is false, Detector not connected, return");
			return false;
		}
	}
	else 
	{
		bool bRet = StopAcquisition(pDrvDPC);
		if (bRet) 
		{
			FERROR("StopAcquisition fail!");
			return false;
		}
	}

	return true;
}


unsigned __stdcall KonicaCtrl::onFPDScanThread(PVOID pvoid)
{
	FINFO("onFPDScanThread start");
	KonicaCtrl* pOpr = (KonicaCtrl*)pvoid;

	while (!pOpr->m_bExit)
	{
		DWORD dwRet = WaitForMultipleObjects(SCAN_EVENT_COUNT, pOpr->m_hArrayEvent, FALSE, INFINITE);
		if (WAIT_OBJECT_0 == dwRet) //m_hStopScanEvent
		{
			pOpr->m_bExit = true;
		}
		else if (WAIT_OBJECT_0 + 1 == dwRet) //m_hProcessImgEvent
		{
			pOpr->OnProcessImg();
		}
		else if (WAIT_OBJECT_0 + 2 == dwRet) //m_hDarkEvent
		{
			pOpr->StartDarkCalibration();
		}
		else if (WAIT_OBJECT_0 + 3 == dwRet) //m_hGainEvent
		{
			pOpr->StartGainCalibration();
		}
		else if (WAIT_OBJECT_0 + 4 == dwRet) //m_hInitEvent
		{
			pOpr->InitFPD();
		}
	}
	SetEvent(pOpr->m_hToggleEvent);
	FINFO("onFPDScanThread end");
	return 0;
}

/***
** 说明：检查探测器状态线程
***/
unsigned __stdcall KonicaCtrl::onFPDStatusThread(PVOID pvoid)
{
	FINFO("onFPDStatusThread start");
	KonicaCtrl* pOpr = (KonicaCtrl*)pvoid;
	int nRet = 0;
	int nBatteryValue = 0;//0-100
	//AEROSDK_PANEL_BATTERY_LITTLE(1) | AEROSDK_PANEL_BATTERY_ENOUGH(2) | AEROSDK_PANEL_BATTERY_CHARGE(3)
	int nBatteryStatus = 0;
	//  0 : Outside the range
	//	1 : Low(about 1 third of 3)
	//	2 : Medium(about 2 thirds of 3)
	//	3 : High
	int nSignalStrength = 0;

	while (!pOpr->m_bExit)
	{
		if (!pOpr->m_pStPanelStatus[pOpr->m_nCurrentPanelID]->bConnectState)
		{
			FERROR("Detector is not connected!");
			Sleep(pOpr->m_nNotifyStatusTimePeriod);
			continue;
		}
		FINFO("Call API_AerosdkGetPanelBatteryInfo");
		nRet = pOpr->API_AerosdkGetPanelBatteryInfo((char*)pOpr->m_strDetectorType.c_str(),&nBatteryValue,&nBatteryStatus);
		if (pOpr->TestError(nRet, "API_AerosdkGetPanelBatteryInfo"))
		{
			FERROR("Get detector battery info error!");
		}
		else
		{
			FINFO("nBatteryValue:{$},nBatteryStatus:{$}", nBatteryValue, nBatteryStatus);
			pOpr->StatusFeedback(EVT_STATUS_BATTERY_VALUE, nBatteryValue, "", pOpr->m_nCurrentPanelID);
		}
		FINFO("Call API_AerosdkGetPanelSignalInfo");
		nRet = pOpr->API_AerosdkGetPanelSignalInfo((char*)pOpr->m_strDetectorType.c_str(),&nSignalStrength);
		if (pOpr->TestError(nRet, "API_AerosdkGetPanelSignalInfo"))
		{
			FERROR("Get detector wifi info error!");
		}
		else
		{
			pOpr->StatusFeedback(EVT_STATUS_WIFI, nSignalStrength, "", pOpr->m_nCurrentPanelID);
		}

		//不能获取温度信息
		//pOpr->StatusFeedback(EVT_STATUS_TEMPERATURE, 0, "", pOpr->m_nCurrentPanelID, stInfo.temperature.maxTemperature);

		Sleep(pOpr->m_nNotifyStatusTimePeriod);
	}

	FINFO("onFPDStatusThread end");
	return 0;
}


void KonicaCtrl::OnProcessImg()
{
	FINFO("OnProcessImg start");
	Sleep(200);
	StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON);
	int nRet = -1;

	//获取图像
	if (m_nWidthOffset != 0 || m_nHeightOffset != 0)
	{
		FINFO("Begin get effect image");
		printf("Begin get effect image \r\n");
		if (!GetEffectiveImage(m_pImgBuffer, m_pRawImgBuffer, m_nRawImgWidth))
		{
			return;
		}
		FINFO("Get effect image over");
		printf("Get effect image over \r\n");
		//非校正状态才应用校正文件 校正时不使用校正文件
		if (m_nAppStatus != APP_STATUS_CAL_BEGIN && m_nCalibrationMode == CCOS_CALIBRATION_MODE_ZSKK)
		{
			FINFO("Apply ZSKK Calibration File");
			m_pZSKKCalib->m_nGridSuppressed = 6;
			m_pZSKKCalib->ApplyZSKKReference(m_nImageHeight, m_nImageWidth, m_pImgBuffer);
		}
		
		DataFeedback(EVT_DATA_RAW_IMAGE, m_pImgBuffer);
		if (m_nSaveRaw)
		{
			SaveRawFunc(m_pImgBuffer, m_nImageWidth, m_nImageHeight);
		}
	}
	else
	{
		if (m_nAppStatus != APP_STATUS_CAL_BEGIN && m_nCalibrationMode == CCOS_CALIBRATION_MODE_ZSKK)
		{
			FINFO("Apply ZSKK Calibration File");
			m_pZSKKCalib->m_nGridSuppressed = 6;
			m_pZSKKCalib->ApplyZSKKReference(m_nRawImgHeight, m_nRawImgWidth, m_pRawImgBuffer);
		}
		DataFeedback(EVT_DATA_RAW_IMAGE, m_pRawImgBuffer);
		if (m_nSaveRaw)
		{
			SaveRawFunc(m_pRawImgBuffer, m_nRawImgWidth, m_nRawImgHeight);
		}
	}
	StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_OFF);

	FINFO("OnProcessImg end");
}


void KonicaCtrl::StartDarkCalibration()
{
	FINFO("dark calibration start");
	
	FINFO("dark calibration end");
}


void KonicaCtrl::StartGainCalibration()
{
	FINFO("StartGainCalibration start");

	FINFO("StartGainCalibration end");
}


void KonicaCtrl::InitFPD()
{
	FINFO("InitFPD start");
	StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_START);
	if (!LoadDll(m_strWorkPath))
	{
		ErrorFeedback(EVT_ERR_INIT_FAILED, "true");
		StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END_ERROR); //初始化失败
		return;
	}
	
	if (!OpenDetector())
	{
		printf("Connect detector failed \r\n");
		FINFO("Connect detector failed");
		ErrorFeedback(EVT_ERR_COMMUNICATE, "true");
		StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END); //初始化时连接失败
	}
	else
	{
		if (!InitDetector())
		{
			printf("Init detector failed, Connect failed \r\n");
			FINFO("Init detector failed, Connect failed");
			ErrorFeedback(EVT_ERR_INIT_FAILED, "true");
			StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END_ERROR); //初始化失败
		}
		else
		{
			m_pStPanelStatus[m_nCurrentPanelID]->bInitOver = true;
			StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END_OK);
		}
	}
	FINFO("InitFPD end");
}


void KonicaCtrl::SaveRawFunc(WORD* pInImg, int nImgWidth, int nImgHeight, string strFrameID)
{
	FILE* fp;
	string strFileName = "";
	if (strFrameID == "")
	{
		strFileName = m_strWorkPath + "\\Image\\Raw.raw";
	}
	else 
	{
		strFileName = m_strWorkPath + "\\Image\\Frame" + strFrameID + ".raw";
	}
	FINFO("image file name:{$}", strFileName);
	if ((fp = fopen(strFileName.c_str(), "wb")) == NULL)
	{
		DWORD dw = GetLastError();
		FERROR("fopen {$} failed, error code:{$}", strFileName, dw);
		return;
	}
	fwrite(pInImg, sizeof(WORD), (size_t)nImgWidth * (size_t)nImgHeight, fp);
	fclose(fp);
	FINFO("Save image over");
}


/***
** 裁剪图像
** pOutImg: 裁剪后图像;	pInImg: 裁剪前图像;	nInWidth: 裁剪前图像宽度
***/
bool KonicaCtrl::GetEffectiveImage(WORD* pOutImg, WORD* pInImg, int nInWidth)
{
	if (pOutImg == NULL || pInImg == NULL || nInWidth < 0)
	{
		FERROR("Illegal parameter, can not get effective image");
		return false;
	}
	try
	{
		for (int i = 0; i < m_nImageHeight; i++)
		{
			memcpy(pOutImg + i * m_nImageWidth, pInImg + (i + m_nHeightOffset) * nInWidth + m_nWidthOffset, m_nImageWidth * sizeof(WORD));
		}
	}
	catch (...)
	{
		FERROR("Get effective image crashed");
		return false;
	}
	return true;
}


bool KonicaCtrl::IsConnected(string strIP)
{
	FINFO("Check ping {$}", strIP);

	CMyPingip obPingIp;
	//StatusFeedback(EVT_STATUS_PING, 0, "true");
	if (!obPingIp.PingFunction(strIP.c_str()))
	{
		FINFO("ping {$} Failed", strIP);
		//StatusFeedback(EVT_STATUS_PING, 0, "false");
		return false;
	}
	return true;
}


/***
** 等待探测器操作执行完毕
***/
bool KonicaCtrl::WaitRespond(int nTimeOut, const char* szAction)
{
	FINFO("--- WaitRespond({$}), {$}ms ---", szAction, nTimeOut);
	DWORD dwRet = WaitForSingleObject(m_hRespond, nTimeOut);
	if (dwRet == WAIT_TIMEOUT)
	{
		FERROR("time out in wait response, action:{$}", szAction);
		return false;
	}
	return true;
}


void KonicaCtrl::StopWaiting(const char* szAction)
{
	FINFO("--- Stop waiting respond, {$} ---", szAction);
	SetEvent(m_hRespond);
}


/***
** 检测接口是否有错误，true：有错；false：没错
***/
bool KonicaCtrl::TestError(int nRet, const char* szFuncName, bool bShowTrue)
{
	if (nRet == AEROSDK_OK)
	{
		if (bShowTrue)
		{
			FINFO("{$} executed successfully", szFuncName);
		}
		return false;
	}
	else
	{
		char strPanelErrorInfo[16] = { 0 };
		char strXgboxErrorInfo[16] = { 0 };
		API_AerosdkGetPanelLastError((char*)m_strDetectorType.c_str(), strPanelErrorInfo);
		API_AerosdkGetXgboxLastError(m_nXgboxNo, strXgboxErrorInfo);
		FERROR("{$} return error, error code:{$}, panel error info:{$}, xgbox error info:{$}", szFuncName, nRet, strPanelErrorInfo, strXgboxErrorInfo);
		return true;
	}
}

void KonicaCtrl::CallBackEvent(int nType, unsigned int uintParam, char* pstrPanelId, int nXgboxNo)
{
	FINFO("CallBackEvent Type:{$},uintParam:{$},pstrPanelId:{$},intXgboxNo:{$}", nType, uintParam, pstrPanelId, nXgboxNo);
	int nRet = AEROSDK_OK;
	switch (nType)
	{
	case AEROSDK_CBTYPE_PANEL_CONNECTTED_WIRE:
		// AeroSDK-Panel connection detection [wired]
		FINFO("Panel ID {$} is connect wired.", pstrPanelId);
		if (strcmp(m_strDetectorType.c_str(), pstrPanelId) == 0)
		{
		}
		m_pStPanelStatus[m_nCurrentPanelID]->bConnectState = true;
		StatusFeedback(EVT_STATUS_PANEL, PANEL_CONNECT);
		break;
	case AEROSDK_CBTYPE_PANEL_CONNECTTED_WIRELESS:
		// AeroSDK-Panel connection detection [wireless]
		FINFO("Panel ID {$} is connect wireless.", pstrPanelId);
		if (strcmp(m_strDetectorType.c_str(), pstrPanelId) == 0)
		{
		}
		m_pStPanelStatus[m_nCurrentPanelID]->bConnectState = true;
		StatusFeedback(EVT_STATUS_PANEL, PANEL_CONNECT);
		break;
	case AEROSDK_CBTYPE_PANEL_DISCONNECT:
		// AeroSDK-Panel disconnection detection
		FINFO("Panel ID {$} disconnect.", pstrPanelId);
		if (strcmp(m_strDetectorType.c_str(), pstrPanelId) == 0)
		{
		}
		m_pStPanelStatus[m_nCurrentPanelID]->bConnectState = false;
		StatusFeedback(EVT_STATUS_PANEL, PANEL_CLOSE);
		if (nullptr == m_hReconnectThread)
		{
			unsigned uThreadId;
			_beginthreadex(NULL, 0, onReconnectThread, this, 0, &uThreadId);
			m_hReconnectThread = OpenThread(THREAD_ALL_ACCESS, TRUE, uThreadId);
		}
		break;
	case AEROSDK_CBTYPE_PANEL_STATUS:
		// Panel status notification
		FINFO("Detector status notification {$}", uintParam);
		if (strcmp(m_strDetectorType.c_str(), pstrPanelId) == 0)
		{
			m_nDetectorStatus = uintParam;
			// In order to know the change of Panel status and show on GUI (outside of AeroSDKCallBack), the event should be set as follows.
			// Especially, when AerosdkStartExposureSequenceIt () is used, this code is needed in order to handle "Wait Ready"  or "Read Out" event at outside of AeroSDKCallBack.
			switch (m_nDetectorStatus)
			{
			case AEROSDK_PANEL_STATUS_UNKNOWN:
				FINFO("UNKNOWN");
				break;
			case AEROSDK_PANEL_STATUS_INITIALIZE:
				FINFO("INITIALIZE");
				break;
			case AEROSDK_PANEL_STATUS_SLEEP:
				FINFO("SLEEP");
				break;
			case AEROSDK_PANEL_STATUS_STANDBY:
				FINFO("STANDBY");
				break;
			case AEROSDK_PANEL_STATUS_READY:
				FINFO("READY");
				if (m_nSyncMode == SYNC_AED)
				{
					StatusFeedback(EVT_STATUS_PANEL, PANEL_STANDBY);//AEROSDK_PANEL_STATUS_READY
				}
				break;
			case AEROSDK_PANEL_STATUS_EXPOSURE:
				FINFO("EXPOSURE");
				StatusFeedback(EVT_STATUS_PANEL, PANEL_XRAY_ON);
				break;
			case AEROSDK_PANEL_STATUS_SHUTDOWN:
				FINFO("SHUTDOWN");
				break;
			case AEROSDK_PANEL_STATUS_UPDATE:
				FINFO("UPDATE");
				break;
			case AEROSDK_PANEL_STATUS_MAINTENANCE:
				FINFO("MAINTENANCE");
				break;
			case AEROSDK_PANEL_STATUS_WAIT_READY:
				FINFO("WAIT_READY");
				if (m_nSyncMode == SYNC_AED)
				{
					// When AeroSync Button is pushed, User Program has to make the Panel Ready status.
					FINFO("Call API_AerosdkSetPanelReady");
					nRet = API_AerosdkSetPanelReady((char*)m_strDetectorType.c_str());
					if (TestError(nRet, "API_AerosdkSetPanelReady"))
					{
						FERROR("AerosdkSetPanelReady Failure!");
					}
				}
				break;
			case AEROSDK_PANEL_STATUS_READOUT:
				FINFO("READOUT");
				break;
			case AEROSDK_PANEL_STATUS_ERROR:
				FINFO("ERROR");
				break;
			default:
				break;
			}
		}
		break;
	case AEROSDK_CBTYPE_PANEL_BATTERY_STATUS:
		// Panel battery status notification
		// Panel wireless signal strength notification
		FINFO("Detector battery status notification");
		if (strcmp(m_strDetectorType.c_str(), pstrPanelId) == 0)
		{
		}
		break;
	case AEROSDK_CBTYPE_PANEL_SIGNAL_STATUS:
		// Panel mounted notification
		FINFO("Detector signal status notification");
		if (strcmp(m_strDetectorType.c_str(), pstrPanelId) == 0)
		{
		}
		break;
	case AEROSDK_CBTYPE_PANEL_MOUNTED:
		// Panel switch pressed-down notification
		FINFO("Detector mounted notification");
		if (strcmp(m_strDetectorType.c_str(), pstrPanelId) == 0)
		{
		}
		break;
	case AEROSDK_CBTYPE_PANEL_SWITCH_PUSHED:
		FINFO("Switch pushed notification");
		if (strcmp(m_strDetectorType.c_str(), pstrPanelId) == 0)
		{
		}
		break;
	case AEROSDK_CBTYPE_PANEL_PULSESYNC_STATUS:
		FINFO("AEROSDK_CBTYPE_PANEL_PULSESYNC_STATUS");
		if (strcmp(m_strDetectorType.c_str(), pstrPanelId) == 0)
		{
		}
		break;
	case AEROSDK_CBTYPE_PANEL_ALIGNMENT_STATUS:
		FINFO("AEROSDK_CBTYPE_PANEL_ALIGNMENT_STATUS");
		if (strcmp(m_strDetectorType.c_str(), pstrPanelId) == 0)
		{
		}
		break;
	case AEROSDK_CBTYPE_PANEL_READY_TIMEOUT:
		// Ready timeout notification
		// After several minutes has passed, the Wiress Panel will enter into Standby mode.
		FERROR("Ready timeout notification");
		if (strcmp(m_strDetectorType.c_str(), pstrPanelId) == 0)
		{
			//set ready timeout error
			// Difference from AeroSDKSampleIt.cpp  <ADD COMMENT>
			// If you want to know when this timeout happens (at READY or WAIT READY), you have to check the "uintParam";
				
			//g_bReadyTimeoutError = true;

			// If you want to enter into exposure sequence, call AerosdkStartExposureSequenceIt function again.
		}
		break;
	case AEROSDK_CBTYPE_PANEL_START_IMAGE:
		// Image transfer start notification
		FINFO("Image transfer start notnotificationify");
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_PREVIEW1:
		// Preview1 image receiving completion notification
		FINFO("Preview1 image arrived");
		//if (m_nPreviewEnable)
		//{
		//	// Receiving Preview1 image from SDK (refer Section 4.4.1 and 8.9.3 of AeroSDK Library Manual)
		//  FINFO("Call API_AerosdkGetPreviewImage");
		//	nRet = API_AerosdkGetPreviewImage((char*)m_strDetectorType.c_str(), m_nImageNo, AEROSDK_IMAGE_PREVIEW1, m_nPreImgWidth, m_nPreImgHeight, m_pPreImgBuffer);
		//	if (TestError(nRet, "API_AerosdkGetPreviewImage1"))
		//	{
		//		FERROR("AerosdkGetPreviewImage-AEROSDK_IMAGE_PREVIEW1 Failure!");
		//		break;
		//	}
		//	DataFeedback(EVT_DATA_PREVIEW_IMAGE, m_pPreImgBuffer);
		//}
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_PREVIEW2:
		// Preview2 image receiving completion notification
		FINFO("Preview2 image arrived");
		//if (m_nPreviewEnable)
		//{
		//	FINFO("Call API_AerosdkGetPreviewImage");
		//	nRet = API_AerosdkGetPreviewImage((char*)m_strDetectorType.c_str(), m_nImageNo, AEROSDK_IMAGE_PREVIEW2, m_nPreImgWidth, m_nPreImgHeight, m_pPreImgBuffer);
		//	if (TestError(nRet, "API_AerosdkGetPreviewImage2"))
		//	{
		//		FERROR("AerosdkGetPreviewImage-AEROSDK_IMAGE_PREVIEW2 Failure!");
		//		break;
		//	}
		//	DataFeedback(EVT_DATA_PREVIEW_IMAGE, m_pPreImgBuffer);
		//}
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_IMAGE:
		// Final image receiving completion notification
		FINFO("Final image arrived");
		m_nImageNo++;
		StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON);
		// Receiving final image from SDK (refer Section 4.4.1 and 8.9.4 of AeroSDK Library Manual)
		FINFO("Call API_AerosdkGetImage");
		nRet = API_AerosdkGetImage((char*)m_strDetectorType.c_str(), m_nImageNo, m_nRawImgWidth, m_nRawImgHeight, m_pRawImgBuffer);
		if (TestError(nRet, "API_AerosdkGetImage"))
		{
			FERROR("Get final image Failure!");
			break;
		}

		FINFO("m_nWidthOffset:{$},m_nHeightOffset:{$}", m_nWidthOffset, m_nHeightOffset);
		if (m_nWidthOffset != 0 || m_nHeightOffset != 0)
		{
			FINFO("Begin get effect image");
			if (!GetEffectiveImage(m_pImgBuffer, m_pRawImgBuffer, m_nRawImgWidth))
			{
				return;
			}
			FINFO("Get effect image over");
			if (m_nAppStatus != APP_STATUS_CAL_BEGIN && m_nCalibrationMode == CCOS_CALIBRATION_MODE_ZSKK)
			{
				FINFO("Apply ZSKK Calibration File");
				m_pZSKKCalib->m_nGridSuppressed = 6;
				m_pZSKKCalib->ApplyZSKKReference(m_nImageHeight, m_nImageWidth, m_pImgBuffer);
			}
			DataFeedback(EVT_DATA_RAW_IMAGE, m_pImgBuffer);
			if (m_nSaveRaw)
			{
				SaveRawFunc(m_pImgBuffer, m_nImageWidth, m_nImageHeight);
			}
		}
		else
		{
			if (m_nAppStatus != APP_STATUS_CAL_BEGIN && m_nCalibrationMode == CCOS_CALIBRATION_MODE_ZSKK)
			{
				FINFO("Apply ZSKK Calibration File");
				m_pZSKKCalib->m_nGridSuppressed = 6;
				m_pZSKKCalib->ApplyZSKKReference(m_nRawImgHeight, m_nRawImgWidth, m_pRawImgBuffer);
			}
			DataFeedback(EVT_DATA_RAW_IMAGE, m_pRawImgBuffer);
			if (m_nSaveRaw)
			{
				SaveRawFunc(m_pRawImgBuffer, m_nRawImgWidth, m_nRawImgHeight);
			}
		}
		StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_OFF);
		break;
	case AEROSDK_CBTYPE_PANEL_ERROR_IMAGETRANSFER:
		// Image transfer error
		FERROR("Image transfer error notification");
		if (strcmp(m_strDetectorType.c_str(), pstrPanelId) == 0)
		{
			// set image transfer error
			//g_intImageTransferError = uintParam;
		}
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_RETRANSFER:
		// Image resending completion notification
		FINFO("Image resending completion notification");
		break;
	case AEROSDK_CBTYPE_PANEL_UPDATE_STATUS:
		// Panel firmware update status notification
		FINFO("Panel firmware update status notification");
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_UPDATE:
		FINFO("Panel firmware update success");
		break;
	case AEROSDK_CBTYPE_PANEL_UPDATE_ERROR:
		// Panel firmware update error notification
		FERROR("Panel firmware update error notification");
		break;
	case AEROSDK_CBTYPE_PANEL_GAINCALIB_RESULT:	
		// Gain calibration result notification
		FINFO("Gain calibration result notification");
		break;
	case AEROSDK_CBTYPE_PANEL_DARKCALIB_PASSAGE:
		// Dark calibration progress notification
		FINFO("Dark calibration progress notification");
		break;
	case AEROSDK_CBTYPE_PANEL_DARKCALIB_RESULT:
		// Dark calibration result notification
		FINFO("Dark calibration result notification");
		break;
	case AEROSDK_CBTYPE_PANEL_OPEN_ERROR:
		// Panel open error after retry
		FERROR("Panel open fail!");
		break;
	case AEROSDK_CBTYPE_PANEL_DETECT_ERROR:
		// Panel error detection
		FERROR("Panel error detection");
		break;
	case AEROSDK_CBTYPE_PANEL_ERROR_CANCELED:
		// Panel error cancellation
		FERROR("Panel error cancellation");
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_DYNAMIC_IMAGE:
		FINFO("AEROSDK_CBTYPE_PANEL_DONE_DYNAMIC_IMAGE");
		break;
	case AEROSDK_CBTYPE_PANEL_DYNAMIC_IMAGE_FRAMECOUNT:	
		FINFO("AEROSDK_CBTYPE_PANEL_DYNAMIC_IMAGE_FRAMECOUNT");
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_DYNAMIC_RETRANSFER:	
		FINFO("AEROSDK_CBTYPE_PANEL_DONE_DYNAMIC_RETRANSFER");
		break;
	case AEROSDK_CBTYPE_XGBOX_CONNECTTED:
		// AeroSDK - XG-IFBOX connection detection; In AeroSync Mode, this callback does not happen.
		FINFO("XgBox connect notification");
		if (m_nXgboxNo == nXgboxNo)
		{
			m_bConnectXgbox = true;
			StopWaiting("XgboxConnect");
		}
		break;
	case AEROSDK_CBTYPE_XGBOX_DISCONNECT:
		// AeroSDK - XG-IFBOX disconnection detection; In AeroSync Mode, this callback does not happen.
		FINFO("XgBox disconnect notification");
		if (m_nXgboxNo == nXgboxNo)
		{
			m_bConnectXgbox = false;
		}
		break;
	case AEROSDK_CBTYPE_XGBOX_PREPARE_ON:
		// Prepare Signal On Detection; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_PREPARE_ON");
		if (m_nSyncMode == SYNC_HARDWARE
			&& m_nXgboxNo == nXgboxNo
			&& m_nDetectorStatus == AEROSDK_PANEL_STATUS_READY
			&& m_pStPanelStatus[m_nCurrentPanelID]->bConnectState == true
			&& m_bConnectXgbox == true)
		{
			FINFO("Call API_AerosdkSetReadyBusy");
			nRet = API_AerosdkSetReadyBusy(nXgboxNo, uintParam, m_nImageNo, AEROSDK_READY);
			if (TestError(nRet,"API_AerosdkSetReadyBusy"))
			{
				FERROR("AerosdkSetReadyBusy Failure!");
			}
			if (m_nSyncMode == SYNC_HARDWARE)
			{
				StatusFeedback(EVT_STATUS_PANEL, PANEL_STANDBY);//AEROSDK_CBTYPE_XGBOX_PREPARE_ON
			}
		}
		else 
		{
			// This means your User Program blocks (does not allow) XG-IFBOX and generator to turn on Exposure signal.
			// Please refer Section 3.4.1 and 8.4.3 of AeroSDK Library Manual.
			FINFO("Call API_AerosdkSetReadyBusy");
			nRet = API_AerosdkSetReadyBusy(nXgboxNo, uintParam, 0, AEROSDK_BUSY);
			if (TestError(nRet, "API_AerosdkSetReadyBusy"))
			{
				FERROR("AerosdkSetReadyBusy Failure!");
			}
		}
		break;
	case AEROSDK_CBTYPE_XGBOX_EXPOSURE_ON:
		// Exposure Signal On Detection; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_EXPOSURE_ON");
		break;
	case AEROSDK_CBTYPE_XGBOX_KMREADY_ON:
		// KM_Ready Signal On Detection; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_KMREADY_ON");
		break;
	case AEROSDK_CBTYPE_XGBOX_KMREADY_OFF:
		// KM_Ready Signal Off Detection; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_KMREADY_OFF");
		break;
	case AEROSDK_CBTYPE_XGBOX_EXPOSURE_OFF:
		// Exposure Signal Off Detection; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_EXPOSURE_OFF");
		break;
	case AEROSDK_CBTYPE_XGBOX_PREPARE_OFF:
		// Prepare Signal Off Detection; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_PREPARE_OFF");
		break;
	case AEROSDK_CBTYPE_XGBOX_EXPOSUREON_TIMEOUT:
		// Exposure switch pressed down timeout; In AeroSync Mode, this callback does not happen.
		FERROR("AEROSDK_CBTYPE_XGBOX_PREPARE_OFF");
		break;
	case AEROSDK_CBTYPE_XGBOX_ILLEGAL_SWITCH_SEQUENCE:
		// Switch sequence interruption; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_PREPARE_OFF");
		break;
	case AEROSDK_CBTYPE_XGBOX_UPDATE_STATUS:
		// XG-IFBOX firmware update status notification; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_PREPARE_OFF");
		break;
	case AEROSDK_CBTYPE_XGBOX_DONE_UPDATE:
		// XG-IFBOX firmware update completion notification; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_PREPARE_OFF");
		break;
	case AEROSDK_CBTYPE_XGBOX_UPDATE_ERROR:
		// XG-IFBOX firmware update error notification; In AeroSync Mode, this callback does not happen.
		FERROR("AEROSDK_CBTYPE_XGBOX_PREPARE_OFF");
		break;
	case AEROSDK_CBTYPE_XGBOX_OPEN_ERROR:
		// XG-IFBOX open error; In AeroSync Mode, this callback does not happen.
		FERROR("AEROSDK_CBTYPE_XGBOX_PREPARE_OFF");
		break;
	case AEROSDK_CBTYPE_XGBOX_DETECT_ERROR:
		// XG-IFBOX error detection; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_PREPARE_OFF");
		break;
	case AEROSDK_CBTYPE_XGBOX_ERROR_CANCELED:
		// XG-IFBOX error cancellation; In AeroSync Mode, this callback does not happen.
		FERROR("AEROSDK_CBTYPE_XGBOX_PREPARE_OFF");
		break;
	case AEROSDK_CBTYPE_PANEL_XGBOX_CONNECTED_WIRE:
		// Panel -- XG-IFBOX connection is detected (in wired mode) after it was disconnected.
		FINFO("AEROSDK_CBTYPE_XGBOX_PREPARE_OFF");
		break;
	case AEROSDK_CBTYPE_PANEL_XGBOX_CONNECTED_WIRELESS:
		// Panel -- XG-IFBOX connection is detected (in wireless mode) after it was disconnected.
		FINFO("AEROSDK_CBTYPE_XGBOX_PREPARE_OFF");
		break;
	case AEROSDK_CBTYPE_PANEL_XGBOX_DISCONNECT:
		// Panel -- XG-IFBOX is disconnected.
		FINFO("AEROSDK_CBTYPE_XGBOX_PREPARE_OFF");
		break;
	case AEROSDK_CBTYPE_PANEL_WARNING_DO_CALIBRATION:
		// Warning to let User Program prompt end-users to make calibration of Panel
		FINFO("AEROSDK_CBTYPE_XGBOX_PREPARE_OFF");
		break;
	case AEROSDK_CBTYPE_END_EXPOSURE_SEQUENCE:		
		// Exposure sequence end notification
		FINFO("Exposure sequence end notification");
		if (strcmp(m_strDetectorType.c_str(), pstrPanelId) == 0)
		{
			// Append callback queue
			// These need much processing time, so the code should be written at outside of AeroSDKCallBack().
		}
		break;
	case AEROSDK_CBTYPE_END_IMAGERESENDING_SEQUENCE:	
		// Image resending sequence end notification
		FINFO("Image resending sequence end notification");
		break;
	case AEROSDK_CBTYPE_END_DELETEIMAGE_SEQUENCE:	
		// Image discarding sequence end notification
		FINFO("Image discarding sequence end notification");
		break;
	case AEROSDK_CBTYPE_END_PANEL_UPDATE_SEQUENCE:		
		// Panel firmware update sequence end notification
		FINFO("Panel firmware update sequence end notification");
		break;
	case AEROSDK_CBTYPE_END_XGBOX_UPDATE_SEQUENCE:
		// XG-IFBOX firmware update sequence end notification; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_END_XGBOX_UPDATE_SEQUENCE");
		break;
	case AEROSDK_CBTYPE_END_PANEL_GAINCALIB_SEQUENCE:	
		// Gain calibration sequence end notification
		FINFO("Gain calibration sequence end notification");
		break;
	case AEROSDK_CBTYPE_END_PANEL_DARKCALIB_SEQUENCE:	
		// Dark calibration sequence end notification
		FINFO("Dark calibration sequence end notification");
		break;
	case AEROSDK_CBTYPE_END_UNSHOTIMAGE_SEQUENCE:
		FINFO("AEROSDK_CBTYPE_END_UNSHOTIMAGE_SEQUENCE");
		break;
	case AEROSDK_CBTYPE_END_DYNAMIC_EXPOSURE_SEQUENCE:
		FINFO("AEROSDK_CBTYPE_END_DYNAMIC_EXPOSURE_SEQUENCE");
		break;
	case AEROSDK_CBTYPE_END_DYNAMIC_IMAGERESENDING_SEQUENCE:
		FINFO("AEROSDK_CBTYPE_END_DYNAMIC_IMAGERESENDING_SEQUENCE");
		break;
	default:
		FWARN("CallBackEvent default type:{$}", nType);
		break;
	}
}


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


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


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


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


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


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

bool KonicaCtrl::UpdateCalibMode(CCOS_CALIBRATION_MODE eCalibMode)
{
	FINFO("========UpdateCalibMode eCalibMode:{$}", (int)eCalibMode);
	m_nCalibrationMode = eCalibMode;
	return true;
}

void KonicaCtrl::SetNotifyStatusTimePeriod(int nTime)
{
	FINFO("========SetNotifyStatusTimePeriod nTime:{$}", nTime);
	m_nNotifyStatusTimePeriod = nTime;
}

void KonicaCtrl::SetReconnectTimePeriod(int nTime)
{
	FINFO("========SetReconnectTimePeriod nTime:{$}", nTime);
	m_nReconnectTimePeriod = nTime;
}

/***
** 说明：重连探测器线程
***/
unsigned __stdcall KonicaCtrl::onReconnectThread(PVOID pvoid)
{
	FINFO("Reconnect detector thread start");
	KonicaCtrl* pOpr = (KonicaCtrl*)pvoid;

	while (!pOpr->m_pStPanelStatus[pOpr->m_nCurrentPanelID]->bConnectState)
	{
		pOpr->OpenDetector();
		Sleep(pOpr->m_nReconnectTimePeriod);
	}

	FINFO("Leave reconnect detector thread");
	return 0;
}