#include "stdafx.h" #include "Detector_Rayence.h" #include "CCOS.Dev.FPD.Rayence.h" extern Log4CPP::Logger* //mLog::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(); m_pPanelID2DPC = new map(); InitializeCriticalSection(&m_cs); //work with sync box for Rad m_pSynClient = new LogicClient("V3_FullUCB", "NSQ", "", false); if (m_pSynClient->Open("ccosChannel", ALL_ACCESS)) { //mLog::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) { //mLog::FINFO("--Func-- DriverEntry {$}", pDrvDPC); map::iterator DPCsIter = m_pDPC2PanelID->find(pDrvDPC); if (DPCsIter != m_pDPC2PanelID->end()) { //mLog::FERROR("This DPC already exist"); return false; } m_pDPC2PanelID->insert(pair(pDrvDPC, m_nPanelCount)); m_pPanelID2DPC->insert(pair(m_nPanelCount, pDrvDPC)); m_nPanelCount++; m_ModeConfig = Configuration; //记录配置 --目前只有一个平板，多板时应该分别存储 return true; } bool Detector_Rayence::Connect(void* pDrvDPC, const char* szWorkPath) { //mLog::FINFO("Connect detector begin"); std::string strSensitivity; if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID) { //mLog::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++) { //mLog::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: //mLog::FERROR("Sensitivity FERROR Paramer"); break; } //mLog::FINFO("Rayence Use Senisitivity: {$}", strSensitivity); //mLog::FINFO("Load Calibration Offset: {$}, Gain: {$}, BPM: {$}", m_bCalOffset, m_bCalGain, m_bCalBPM); } catch (ResDataObjectExption& e) { //mLog::FERROR("Get config FERROR: {$}", e.what()); return false; } std::string strModulePath; strModulePath = m_strWorkPath + m_strModulePath + "\\CCOS.Dev.FPD.RayenceX64.dll"; //mLog::FINFO("ModulePath : {$}", strModulePath); std::string strVersion; strVersion = GetFileVersion(strModulePath); //mLog::FINFO("======================={$}=======================", strVersion); if (!OpenDetector()) { //mLog::FERROR("Open detector failed, Connect failed \n"); return false; } //mLog::FINFO("Connect over"); return true; } void Detector_Rayence::DisConnect() { //mLog::FINFO("DisConnect with detector"); if (eDetStatus::DetStatus_XrayCalibration == GetRayenceDPCStatus() || eDetStatus::DetStatus_Offset == GetRayenceDPCStatus()) { //mLog::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; } //mLog::FINFO("Disconnect Detector Over"); } void Detector_Rayence::EnterExamMode(int nExamMode) { switch (nExamMode) { case APP_STATUS_WORK_BEGIN: //mLog::FINFO("Enter into Exam Windows"); m_nExamMode = APP_STATUS_WORK_BEGIN; break; case APP_STATUS_WORK_END: //mLog::FINFO("Quit Exam Windows"); m_nExamMode = APP_STATUS_WORK_END; break; case APP_STATUS_DETSHARE_BEGIN: //mLog::FINFO("Enter into Detector Share Windows"); m_nExamMode = APP_STATUS_DETSHARE_BEGIN; break; case APP_STATUS_DETSHAR_END: m_nExamMode = APP_STATUS_IDLE; //mLog::FINFO("Quit Detector Share Windows"); m_nExamMode = APP_STATUS_DETSHAR_END; break; case APP_STATUS_CAL_BEGIN: //mLog::FINFO("Enter into Calibration Windows"); m_nExamMode = APP_STATUS_CAL_BEGIN; break; case APP_STATUS_CAL_END: //mLog::FINFO("Quit Calibration Windows"); m_nExamMode = APP_STATUS_CAL_END; break; case APP_STATUS_WORK_IN_SENSITIVITY: //mLog::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) { //mLog::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) { //mLog::FINFO("ACBR->rEvent cVDACQ_ECaptureRecv m_eStatus:{$}", (int)m_eStatus); if (m_eStatus == eDetStatus::DetStatus_Acquire) { if (m_strCurrentExamType == "RAD") { //mLog::FINFO("Rad Mode..."); } else if (m_strCurrentExamType == "CF") { //mLog::FINFO("CF Mode..."); } else if (m_strCurrentExamType == "PF") { //mLog::FINFO("PF Mode..."); } if (m_bSaveRaw) { //mLog::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()) { //mLog::FERROR("Open Save File Failed"); } unsigned int nTempSize = m_nFrmWidth * m_nFrmHeight * 2; if (m_nBinningMode == 0) { file_stream.write(reinterpret_cast(m_pFrm1x1Buffer), nTempSize); } if (m_nBinningMode == 1) { file_stream.write(reinterpret_cast(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) { //mLog::FINFO("Set Flu FrameRate : {$}", fPPS); m_fFrameRate = fPPS; if (m_fFrameRate == 30) { m_fFrameRate = 7; } if (m_strCurrentExamType == "CF") { //mLog::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) { //mLog::FINFO("SetAcqMode nMode:{$}",strMode); if (m_strCurrentLogicMode == strMode) { //mLog::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"]; //mLog::FINFO("Crop left: {$}, top: {$}, right: {$}, bottom: {$}", m_nCropLeft, m_nCropTop, m_nCropRight, m_nCropBottom); //mLog::FINFO("ExamType: {$}, SaveRaw: {$}", m_strCurrentExamType, m_bSaveRaw); m_strCurrentLogicMode = strMode; break; } } } catch (ResDataObjectExption& e) { //mLog::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); //mLog::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]; //mLog::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]; //mLog::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; //mLog::FINFO("Cal BinningMode : {$}", m_nCalBinning); return true; } bool Detector_Rayence::PrepareAcquisition(void* pDrvDPC) { //mLog::FINFO("PrepareAcquisition"); bool bRet = false; if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID) { //mLog::FERROR("Not current DPC, return"); return bRet; } //mLog::FINFO("PrepareAcquisition m_strLastLogicMode:{$},m_strCurrentLogicMode:{$}", m_strLastLogicMode, m_strCurrentLogicMode); return true; } bool Detector_Rayence::StartAcquisition(void* pDrvDPC) { //mLog::FINFO("StartAcquisition"); bool bRet = false; if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID) { //mLog::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") { //mLog::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") { //mLog::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) { //mLog::FERROR("Illegal exam mode"); } else { bRet = true; } return bRet; } bool Detector_Rayence::StopAcquisition(void* pDrvDPC) { //mLog::FINFO("StopAcquisition "); bool bRet = false; StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_OFF); if (m_strCurrentExamType != "RAD") { if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID) { //mLog::FERROR("Not current DPC, return"); return bRet; } if (eDetStatus::DetStatus_Acquire == GetRayenceDPCStatus()) { //mLog::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 { //mLog::FINFO("Not in acquire status"); //切换到静态采集后，进入了ready状态。但此时可以不开始采集，切换到别的模式， bRet = true; } } else { bRet = true; } return bRet; } bool Detector_Rayence::StartOffset(void* pDrvDPC, bool isAll, std::vector& m_vDetectorModeList) { //mLog::FINFO("StartOffset"); bool bRet = false; m_bAbortOffset = false; if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID) { //mLog::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; //mLog::FINFO("AveBuffer Height:{$}, Width:{$}", m_vecDetMode[i].imageHeight, m_vecDetMode[i].imageWidth); m_nCalModeId = m_vecDetMode[i].ModeID; //mLog::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]; //mLog::FINFO("1x1 Dark Buffer"); } if (m_nCalModeId == 1 && m_pDark2x2Buffer == nullptr) { m_pDark2x2Buffer = new short[nTempSize]; //mLog::FINFO("2x2 Dark Buffer"); } } m_bOffsetBuffer = true; } if (m_bRayAcqing) { //mLog::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() { //mLog::FINFO("Abort Offset"); if (eDetStatus::DetStatus_Offset == GetRayenceDPCStatus() && m_bRayAcqing) { //mLog::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) { //mLog::FINFO("Offset not begin"); } return true; } bool Detector_Rayence::ActiveCalibration(void* pDrvDPC, CCOS_CALIBRATION_TYPE eType) { //mLog::FINFO("ActiveCalibration"); if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID) { //mLog::FERROR("Not current DPC, return"); return false; } if ("" == m_strCurrentLogicMode) { //mLog::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) { //mLog::FINFO("PrepareCalibration"); bool bRet = false; if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID) { //mLog::FERROR("Not current DPC, return"); return bRet; } if (GetRayenceDPCStatus() != eDetStatus::DetStatus_XrayCalibration) { //mLog::FINFO("Current status is not XrayCalibration, return succeed"); return true; } return bRet; } bool Detector_Rayence::StartCalibration(void* pDrvDPC) { //mLog::FINFO("StartCalibration"); bool bRet = false; if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID) { //mLog::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) { //mLog::FINFO("StopCalibration"); bool bRet = false; if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID) { //mLog::FERROR("Not current DPC, return"); return bRet; } //mLog::FINFO("StopCalibration Calling StopCalibration"); bRet = true; return bRet; } bool Detector_Rayence::OpenDetector() { //mLog::FINFO("OpenDetector"); //mLog::FINFO("Calling InitializeLibrary"); if (!LoadRayenceDLL()) { //mLog::FERROR("Connect Detector Failed, Load Dll is failed"); return false; } //mLog::FINFO("Call RegisterCallbackInfo"); m_Intf.rVD_RegisterCallbackInfo(G_Rayence_InfoMessage); //mLog::FINFO("Open Detector Success--->"); return true; } bool Detector_Rayence::LoadRayenceDLL() { //mLog::FINFO("Start Load Rayence DLL"); //mLog::FINFO("work path: {$}", m_strWorkPath); //mLog::FINFO("Set SDK Path: {$}", m_strSDKPath); std::string strTempPath; strTempPath = m_strWorkPath + m_strSDKPath; if (SetDllDirectory(strTempPath.c_str()) == 0) { DWORD dw = GetLastError(); //mLog::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)) { //mLog::FERROR("Load Rayence dll failed"); auto dw = GetLastError(); //mLog::FERROR("FERROR Code : {$}", dw); return false; } //mLog::FINFO("LoadRayenceDll Over"); return true; } bool Detector_Rayence::CalculateEXI(WORD* pImgData, int nImgWidth, int nImgHeight, int nImageBit, int nThreshold) { int nROIXL = static_cast(0.3 * nImgWidth); int nROIXR = static_cast(0.7 * nImgWidth); int nROIYL = static_cast(0.3 * nImgHeight); int nROIYR = static_cast(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; } //mLog::FINFO("Image EXI:{$}, Threshold:{$}", nEXI, nThreshold); if (nEXI >= nThreshold) { //mLog::FINFO("Image has xray!"); return true;//有x射线 } return false; } bool Detector_Rayence::CheckImageExi(WORD* pImgData, int nImgWidth, int nImgHeight, WORD dwExiThrethold) { //mLog::FINFO("Begin Check Image EXI"); if (dwExiThrethold <= 0) { return true; } //mLog::FINFO("Check image exi..."); bool bResult = CalculateEXI(pImgData, nImgWidth, nImgHeight, 16, dwExiThrethold); if (bResult) { return true; } //mLog::FINFO("Check image exi---black Image"); return false; } bool Detector_Rayence::OpenRefreshOffset() { //mLog::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(pParam); if (pCurrentPanelOpr == nullptr) { //mLog::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) { //mLog::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; //mLog::FINFO("AveBuffer Height:{$}, Width:{$}", m_vecDetMode[i].imageHeight, m_vecDetMode[i].imageWidth); m_nCalModeId = m_vecDetMode[i].ModeID; //mLog::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; //mLog::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; //mLog::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]; //mLog::FINFO("1x1 Dark Buffer"); } if (m_nCalModeId == 1 && m_pDark2x2Buffer == nullptr) { unsigned int nTempSize = m_nFrmWidth * m_nFrmHeight; m_pDark2x2Buffer = new short[nTempSize]; //mLog::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)); } } //mLog::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; } } //mLog::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; //mLog::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); } //mLog::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) { //mLog::FINFO("[Get RefreshOffsetStatus Event]"); } else if (dwResult == WAIT_TIMEOUT) { ::TerminateThread(m_hOffsetThread, 0); //mLog::FWARN("Kill RefreshOffset Thread"); } if (m_hOffsetThreadStatus != nullptr) { CloseHandle(m_hOffsetThreadStatus); m_hOffsetThreadStatus = nullptr; } OffsetProgressFeedback(EVT_INFO_OFFSET_STATUS, 1); m_hOffsetThread = nullptr; //mLog::FINFO("---Exit Refresh Offset Status Thread---"); return true; } //nIndex 缺省-1，当使用缺省值时代表是静态模式，图像名不记录序号 void Detector_Rayence::OnProcessImage(int CaptureFrame, bool bIsCaptureRaw) { //mLog::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) { //mLog::FERROR("CropImageMargin fail!!"); } else { //mLog::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)) { //mLog::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)) { //mLog::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)) { //mLog::FWARN("Image EXI too low"); return false; } DataFeedback(EVT_DATA_RAW_IMAGE, m_pFrm2x2Buffer); } } if (m_bSaveRaw) { //mLog::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()) { //mLog::FERROR("Open Save File Failed"); } if (bImageCrop) { unsigned int nTempSize = m_nImageWidth * m_nImageHeight * 2; file_stream.write(reinterpret_cast(m_pFullImgBuffer), nTempSize); } else { unsigned int nTempSize = m_nRawImgWidth * m_nRawImgHeight * 2; if (Binning == 0) file_stream.write(reinterpret_cast(m_pFrm1x1Buffer), nTempSize); if (Binning == 1) file_stream.write(reinterpret_cast(m_pFrm2x2Buffer), nTempSize); } file_stream.close(); //mLog::FINFO("Save Flu CropImage Over"); } }; if (!Process_Image(m_nBinningMode, CaptureFrame)) { return; } //if (m_nBinningMode == 0) //{ // if (m_pFrm1x1Buffer == nullptr) // { // //mLog::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) // { // //mLog::FERROR("CropImageMargin fail!!"); // } // else // { // //mLog::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)) // { // //mLog::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)) // { // //mLog::FWARN("Image EXI too low"); // return; // } // DataFeedback(EVT_DATA_RAW_IMAGE, m_pFrm1x1Buffer); // } // if (m_bSaveRaw) // { // //mLog::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()) // { // //mLog::FERROR("Open Save File Failed"); // } // if (bImageCrop) // { // unsigned int nTempSize = m_nImageWidth * m_nImageHeight * 2; // file_stream.write(reinterpret_cast(m_pFullImgBuffer), nTempSize); // } // else // { // unsigned int nTempSize = m_nRawImgWidth * m_nRawImgHeight * 2; // file_stream.write(reinterpret_cast(m_pFrm1x1Buffer), nTempSize); // } // file_stream.close(); // //mLog::FINFO("Save Flu CropImage Over"); // } //} //if (m_nBinningMode == 1) //{ // if (m_pFrm2x2Buffer == nullptr) // { // //mLog::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) // { // //mLog::FERROR("CropImageMargin fail!!"); // } // else // { // //mLog::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)) // { // //mLog::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)) // { // //mLog::FWARN("Image EXI too low"); // return; // } // DataFeedback(EVT_DATA_RAW_IMAGE, m_pFrm2x2Buffer); // } // if (m_bSaveRaw) // { // //mLog::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()) // { // //mLog::FERROR("Open Save File Failed"); // } // if (bImageCrop) // { // unsigned int nTempSize = m_nImageWidth * m_nImageHeight * 2; // file_stream.write(reinterpret_cast(m_pFullImgBuffer), nTempSize); // } // else // { // unsigned int nTempSize = m_nRawImgWidth * m_nRawImgHeight * 2; // file_stream.write(reinterpret_cast(m_pFrm2x2Buffer), nTempSize); // } // file_stream.close(); // //mLog::FINFO("Save CropImage Over"); // } //} } void Detector_Rayence::OnRadImageEvt(int CaptureFrame, bool bIsCaptureRaw) { //mLog::FINFO("OnProcessImage "); if (m_pOneShotBuffer == nullptr) { //mLog::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)) { //mLog::FWARN("Image EXI too low"); return; } DataFeedback(EVT_DATA_RAW_IMAGE, m_pFullImgBuffer); if (m_bSaveRaw) { //mLog::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()) { //mLog::FERROR("Open Save File Failed"); } unsigned int nTempSize = m_nImageWidth * m_nImageHeight * 2; file_stream.write(reinterpret_cast(m_pFullImgBuffer), nTempSize); file_stream.close(); //mLog::FINFO("Save Rad CropImage Over"); } StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_OFF); if (eDetStatus::DetStatus_Acquire == GetRayenceDPCStatus()) { //mLog::FINFO("Calling StopAcquisition"); m_Intf.rVDACQ_Abort(rACQ_CallBackRec); m_Intf.rVDACQ_Close(rACQ_CallBackRec); SetRayenceDPCStatus(eDetStatus::DetStatus_Standby); //停止采集，设置状态 } else { //mLog::FINFO("Not in acquire status"); } } bool Detector_Rayence::StartGainCalibration() { //mLog::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; } //mLog::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; //mLog::FINFO("Set driver status: {$}", strStatus.c_str()); } else { //mLog::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) { //mLog::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; //mLog::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")); //mLog::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)); //mLog::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; } //mLog::FINFO("CALLBACK_Acquisition type:{$}, event:{$}", ACBR->rType, ACBR->rEvent); switch (ACBR->rType) { case cVDACQ_ETTrace: case cVDACQ_ETTraceT: { switch (ACBR->rEvent) { case cVDACQ_EAbort: { //mLog::FINFO("ACBR->rEvent cVDACQ_EAbort"); break; } case cVDACQ_EClose: { //mLog::FINFO("ACBR->rEvent cVDACQ_EClose"); break; } case cVDACQ_EAT_Ready: { //mLog::FINFO("AED Ready"); break; } case cVDACQ_ECapture: { //mLog::FINFO("ACBR->rEvent cVDACQ_ECapture"); break; } case cVDACQ_ECapturePerc: { //mLog::FINFO("ACBR->rEvent cVDACQ_ECapturePerc"); break; } case cVDACQ_ECaptureRecv: { //mLog::FINFO("Flu Image Arrive"); HandleCaptureRecvEvent(ACBR, false); break; } case cVDACQ_EIdle: { //mLog::FINFO("ACBR->rEvent cVDACQ_EIdle"); break; } case cVDACQ_EAT_Wait: { //mLog::FINFO("AED Wait"); break; } case cVDACQ_ECaptureFrame: { //mLog::FINFO("ACBR->rEvent cVDACQ_ECaptureFrame"); OnRadImageEvt(ACBR->rCaptureFrames, false); break; } case cVDACQ_ECapture2_Receive: { //mLog::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"); //mLog::FDEBUG("V3_FullUCB Client execute [SetDirectExpSignal][{$}]", XWindow); if (XWindow == 1) { StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON); } } else { //mLog::FDEBUG("V3_FullUCB Client is Close"); } } else { //mLog::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"); //mLog::Debug("V3_FullUCB Client execute [SetDirectExpSignal][{$}]", "1"); StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON); } else { //mLog::Debug("V3_FullUCB Client is Close"); } } else { //mLog::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"); //mLog::Debug("V3_FullUCB Client execute [SetDirectExpSignal][{$}]", "0"); } else { //mLog::Debug("V3_FullUCB Client is Close"); } } else { //mLog::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; } //mLog::FINFO("CALLBACK_Acquisition type:{$}, event:{$}", ACBR->rType, ACBR->rEvent); switch (ACBR->rType) { case cVDACQ_ETTrace: case cVDACQ_ETTraceT: { switch (ACBR->rEvent) { case cVDACQ_EAbort: { //mLog::FINFO("ACBR->rEvent cVDACQ_EAbort"); ErrorFeedback(EVT_ERR_OFFSET_FAILED); break; } case cVDACQ_EClose: { //mLog::FINFO("ACBR->rEvent cVDACQ_EClose"); break; } case cVDACQ_EAT_Ready: { //mLog::FINFO("AED Ready"); break; } case cVDACQ_ECapture: { //mLog::FINFO("ACBR->rEvent cVDACQ_ECapture"); break; } case cVDACQ_ECapturePerc: { //mLog::FINFO("ACBR->rEvent cVDACQ_ECapturePerc"); break; } case cVDACQ_ECaptureRecv: { //mLog::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) { //mLog::FINFO("m_nCalToAcqNum: {$}", m_nCalToAcqNum); //mLog::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; //mLog::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) { //mLog::FINFO("m_nCalToAcqNum: {$}", m_nCalToAcqNum); //mLog::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; //mLog::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) { //mLog::FINFO("m_nCalToAcqNum: {$}", m_nCalToAcqNum); //mLog::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; //mLog::FINFO("one offset complete"); } }*/ } break; } case cVDACQ_EIdle: { //mLog::FINFO("ACBR->rEvent cVDACQ_EIdle"); break; } case cVDACQ_EAT_Wait: { //mLog::FINFO("AED Wait"); break; } case cVDACQ_ECaptureFrame: { //mLog::FINFO("ACBR->rEvent cVDACQ_ECaptureFrame"); break; } case cVDACQ_ECapture2_Receive: { //mLog::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); }