#include "StdAfx.h"
|
#include "RadientControl.h"
|
#include "FrameBufferController.h"
|
|
MIL_ID g_MilApplication_Radient = M_NULL; /* Application identifier. */
|
int g_nGrabberCount_Radient = 0; // grabber count
|
|
// 调试
|
#define GRAB_DEBUG_ENABLE 0 // 置 0 关闭所有调试输出与转存
|
#define GRAB_DUMP_DIR _T("D:\\Dump") // 输出目录
|
|
//==========================================================================================================================================================================
|
// Grabber Radient
|
CGrabberRadient::CGrabberRadient()
|
{
|
m_nEndFrameIdx = m_nStartFrameIdx = 0;
|
m_nSetBufferIdx = 0;
|
m_nScanIndex = 0;
|
m_nAllocatedGrabBufSize = 0;
|
m_isGrabbing = FALSE;
|
m_isLiveGrab = FALSE;
|
m_pFrameBuffer = NULL;
|
|
bUART_Connect[0] = FALSE;
|
bUART_Connect[1] = FALSE;
|
}
|
|
CGrabberRadient::~CGrabberRadient()
|
{
|
if (m_pFrameBuffer != NULL) {
|
delete m_pFrameBuffer;
|
m_pFrameBuffer = NULL;
|
}
|
}
|
|
BOOL CGrabberRadient::Initialize(void *pParam, int *pErrorCode,int iBoard)
|
{
|
_GRABBER_INIT_PARAM_ *pParameter = (_GRABBER_INIT_PARAM_ *)pParam;
|
if(NULL == pParameter) {
|
return FALSE;
|
}
|
m_Param = *pParameter;
|
|
CString strDCF;
|
strDCF = m_Param.cDCFPath;
|
|
if (g_nGrabberCount_Radient == 0) {
|
MappAlloc(M_NULL, M_DEFAULT, &g_MilApplication_Radient);
|
}
|
g_nGrabberCount_Radient++;
|
|
// 分配系统
|
MsysAlloc(M_SYSTEM_RADIENTEVCL, m_Param.nBoardIdx, M_DEFAULT, &m_MilSystem);
|
if (CheckLastError()) {
|
return FALSE;
|
}
|
|
// 分配 digitizer，M_DEV0/M_DEV1 区分 CH0/CH1
|
MIL_INT nDev = m_Param.nBoardCh;
|
MdigAlloc(m_MilSystem, nDev, strDCF, M_DEFAULT, &m_MilDigitizer);
|
if (CheckLastError()) {
|
MIL_INT nErrorCode = 0;
|
MappGetError(M_GLOBAL, &nErrorCode);
|
g_pLog->DisplayMessage(_T("Digitizer Alloc Error | BoardIdx=%d, BoardCh=%d, DCF=\"%s\", MIL_Error=%ld"), m_Param.nBoardIdx, m_Param.nBoardCh, strDCF, nErrorCode);
|
return FALSE;
|
}
|
g_pLog->DisplayMessage(_T("Digitizer Alloc | BoardIdx=%d, BoardCh=%d, DCF=\"%s\""), m_Param.nBoardIdx, m_Param.nBoardCh, strDCF);
|
|
// 查询真实尺寸
|
MIL_INT nSizeX = 0, nSizeY = 0, nBands = 1, nType = 0;
|
MdigInquire(m_MilDigitizer, M_SIZE_X, &nSizeX);
|
MdigInquire(m_MilDigitizer, M_SIZE_Y, &nSizeY);
|
MdigInquire(m_MilDigitizer, M_SIZE_BAND, &nBands);
|
MdigInquire(m_MilDigitizer, M_TYPE, &nType);
|
|
// 用硬件实际值覆盖配置
|
if (m_Param.nFrameWidth != (int)nSizeX || m_Param.nFrameHeight != (int)nSizeY) {
|
g_pLog->DisplayMessage(_T("Digitizer Size sync: cfg %dx%d -> hw %dx%d"), m_Param.nFrameWidth, m_Param.nFrameHeight, (int)nSizeX, (int)nSizeY);
|
m_Param.nFrameWidth = (int)nSizeX;
|
m_Param.nFrameHeight = (int)nSizeY;
|
}
|
|
// 分配缓冲
|
for (int j = 0; j < BUFFERING_SIZE_MAX; j++) {
|
MbufAlloc2d(m_MilSystem, m_Param.nFrameWidth, m_Param.nFrameHeight, (/*nType ? nType : */8 + M_UNSIGNED), M_IMAGE + M_GRAB + M_PROC, &m_Milbufgrab[j]);
|
}
|
|
if (CheckLastError()) {
|
return FALSE;
|
}
|
|
/*
|
INT nExposureTimer = m_Param.nExposure*1000;
|
INT nExposureTimerDelay = m_Param.nExposureDelay*1000;
|
|
MdigControl(m_MilDigitizer, M_GRAB_EXPOSURE_TIME+M_TIMER1, nExposureTimer); //10us
|
MdigControl(m_MilDigitizer, M_GRAB_EXPOSURE_TIME_DELAY+M_TIMER1, nExposureTimerDelay); //10us
|
|
if(m_Param.nImgFlipX == 1)
|
SetImageFlipX(TRUE);
|
else
|
SetImageFlipX(FALSE);
|
*/
|
|
// 抓取控制
|
MdigControl(m_MilDigitizer, M_GRAB_MODE, M_ASYNCHRONOUS);
|
MdigControl(m_MilDigitizer, M_GRAB_TIMEOUT, M_INFINITE);
|
if (CheckLastError()) {
|
return FALSE;
|
}
|
|
m_DigitizerStatus.status = M_STOP;
|
|
return TRUE;
|
}
|
|
BOOL CGrabberRadient::SetImageFlipX(BOOL bOn)
|
{
|
if (bOn == TRUE) {
|
MdigControl(m_MilDigitizer, M_GRAB_DIRECTION_X, M_REVERSE);
|
}
|
else {
|
MdigControl(m_MilDigitizer, M_GRAB_DIRECTION_X, M_FORWARD);
|
}
|
|
return TRUE;
|
}
|
|
BOOL CGrabberRadient::CheckLastError()
|
{
|
MIL_INT nErrorCode;
|
if(MappGetError(M_GLOBAL, &nErrorCode)) {
|
int iCam = m_Param.nCameraIdx;
|
int iScan = m_Param.nCameraScan;
|
int iBoard = m_Param.nBoardIdx;
|
int iBoardCh = m_Param.nBoardCh;
|
|
CString strMsg;
|
strMsg.Format(_T("[Board=%d,ch=%d] [Camera=%d,Scan=%d] MIL Error Code : %d"), iBoard,iBoardCh,iCam,iScan, nErrorCode);
|
g_pLog->DisplayMessage(strMsg);
|
|
return TRUE;
|
}
|
|
return FALSE;
|
}
|
|
BOOL CGrabberRadient::InitializeBuffer(void *pParam)
|
{
|
_GRABBER_INIT_PARAM_ *pParameter = (_GRABBER_INIT_PARAM_ *)pParam;
|
if (NULL == pParameter) {
|
g_pLog->DisplayMessage(_T("InitializeBuffer : pParameter is NULL"));
|
return FALSE;
|
}
|
|
m_Param = *pParameter;
|
return CreateGrabBuffer(m_Param.nScanCount, m_Param.nGrabBufCount, m_Param.nFrameWidth, m_Param.nFrameHeight);
|
}
|
|
BOOL CGrabberRadient::Deinitialize(void)
|
{
|
if (IsGrabbing()) {
|
GrabScanStop();
|
}
|
|
g_nGrabberCount_Radient--;
|
|
for(int i = 0; i < BUFFERING_SIZE_MAX ;i++) {
|
MbufFree(m_Milbufgrab[i]);
|
}
|
|
MdigFree(m_MilDigitizer);
|
MsysFree(m_MilSystem);
|
|
if (g_nGrabberCount_Radient == 0) {
|
MappFree(g_MilApplication_Radient);
|
}
|
|
return TRUE;
|
}
|
|
BOOL CGrabberRadient::GrabLiveStart(int nExposure)
|
{
|
if (IsGrabbing()) {
|
g_pLog->DisplayMessage(_T("Start Live Acq : IsGrabbing -> Stop Acq %d"), m_nEndFrameIdx);
|
GrabScanStop();
|
Sleep(100);
|
}
|
|
m_nStartFrameIdx = 0;
|
m_nEndFrameIdx = 0;
|
m_nSetBufferIdx = -1;
|
m_nScanIndex = 0;
|
|
if(m_DigitizerStatus.status == M_STOP) {
|
m_DigitizerStatus.status = M_FREE_START;
|
m_DigitizerStatus.nCount = 0;
|
m_DigitizerStatus.nIndex = m_Param.nCameraScan;
|
|
MdigProcess(m_MilDigitizer,&m_Milbufgrab[0],BUFFERING_SIZE_MAX, M_START, M_DEFAULT, (MIL_BUF_HOOK_FUNCTION_PTR)CallbackFreeRunFunction, this);
|
}
|
|
m_isGrabbing = TRUE;
|
m_isLiveGrab = TRUE;
|
g_pLog->DisplayMessage(_T("Start Live Acq"));
|
|
return TRUE;
|
}
|
|
BOOL CGrabberRadient::GrabScanStart(int iScan, BOOL bFreeRun, int nPeriod, int nExposure, BOOL bAuto)
|
{
|
int nCameraIdx = m_Param.nCameraIdx;
|
g_pLog->DisplayMessage(_T("%d Start Acq : Camera=%d, Scan=%d, GrabFrameCount=%d, FrameHeight=%d"), m_Param.nBoardIdx, nCameraIdx, iScan, g_pStatus->GetGrabFrameCount(nCameraIdx, iScan), m_Param.nFrameHeight);
|
|
if (IsGrabbing()) {
|
g_pLog->DisplayMessage(_T("%d Start Acq : Camera=%d, Scan=%d, IsGrabbing -> Stop Acq %d"), m_Param.nBoardIdx, nCameraIdx, iScan, m_nEndFrameIdx);
|
GrabScanStop();
|
Sleep(100);
|
}
|
|
m_nStartFrameIdx = 0;
|
m_nEndFrameIdx = 0;
|
m_nSetBufferIdx = -1;
|
m_nScanIndex = iScan;
|
|
if (bAuto == TRUE) {
|
int nDigitizer = 0;
|
|
if (bFreeRun == FALSE) {
|
SetTriggerMode(TRUE);
|
|
/* Start the processing. The processing function is called for every frame grabbed. */
|
if (m_DigitizerStatus.status == M_STOP) {
|
m_DigitizerStatus.status = M_START;
|
m_DigitizerStatus.nCount = 0;
|
m_DigitizerStatus.nIndex = iScan;
|
|
MdigProcess(m_MilDigitizer, &m_Milbufgrab[0], BUFFERING_SIZE_MAX, M_START, M_DEFAULT, (MIL_BUF_HOOK_FUNCTION_PTR)CallbackHookFunction, this);
|
}
|
}
|
else {
|
if (m_DigitizerStatus.status == M_STOP) {
|
m_DigitizerStatus.status = M_FREE_START;
|
m_DigitizerStatus.nCount = 0;
|
m_DigitizerStatus.nIndex = iScan;
|
|
MdigProcess(m_MilDigitizer, &m_Milbufgrab[0], BUFFERING_SIZE_MAX, M_START, M_DEFAULT, (MIL_BUF_HOOK_FUNCTION_PTR)CallbackFreeRunFunction, this);
|
}
|
}
|
|
m_isGrabbing = TRUE;
|
m_isLiveGrab = FALSE;
|
}
|
else {
|
SimulationGrab(iScan);
|
}
|
|
return TRUE;
|
}
|
|
void CGrabberRadient::SimulationGrab(int iScan)
|
{
|
if (m_pFrameBuffer == NULL) {
|
return;
|
}
|
|
int nFrameCnt = m_pFrameBuffer->GetFrameCount();
|
|
m_nEndFrameIdx = nFrameCnt;
|
m_nSetBufferIdx = nFrameCnt - 1;
|
|
for (int i = 0; i < nFrameCnt; i++) {
|
SetInsertFrame(iScan, i);
|
}
|
}
|
|
BOOL CGrabberRadient::GrabScanStop(void)
|
{
|
g_pLog->DisplayMessage(_T("%d StopAcq : Camera %d, Scan %d, Grab %d, End %d"), m_Param.nBoardIdx, m_Param.nCameraIdx, m_nScanIndex, m_nSetBufferIdx, m_nEndFrameIdx);
|
|
CString strMsg;
|
if (m_DigitizerStatus.status == M_START) {
|
MdigProcess(m_MilDigitizer, &m_Milbufgrab[0], BUFFERING_SIZE_MAX, M_STOP, M_DEFAULT, (MIL_BUF_HOOK_FUNCTION_PTR)CallbackHookFunction, this);
|
m_DigitizerStatus.nIndex = m_nScanIndex;
|
m_DigitizerStatus.status = M_STOP;
|
}
|
else if (m_DigitizerStatus.status == M_FREE_START) {
|
MdigProcess(m_MilDigitizer, &m_Milbufgrab[0], BUFFERING_SIZE_MAX, M_STOP, M_DEFAULT, (MIL_BUF_HOOK_FUNCTION_PTR)CallbackFreeRunFunction, this);
|
m_DigitizerStatus.nIndex = m_nScanIndex;
|
m_DigitizerStatus.status = M_STOP;
|
}
|
|
m_isGrabbing = FALSE;
|
m_isLiveGrab = FALSE;
|
|
return TRUE;
|
}
|
|
BOOL CGrabberRadient::IsGrabbing(void)
|
{
|
return m_isGrabbing;
|
}
|
|
int CGrabberRadient::IsAcqFrame(int nFrameNo, int nThreadIdx)
|
{
|
return m_nSetBufferIdx - nFrameNo;
|
}
|
|
LPBYTE CGrabberRadient::GetFrameHeaderLine(int iScan,int nLine, BOOL* bSuccess)
|
{
|
if (m_pFrameBuffer == NULL) {
|
return NULL;
|
}
|
return m_pFrameBuffer->GetFrameHeaderLine(iScan,nLine);
|
}
|
|
LPBYTE CGrabberRadient::GetFrameHeader(int iScan,int nFrameNo, BOOL* bRet)
|
{
|
if (m_pFrameBuffer == NULL) {
|
return NULL;
|
}
|
return m_pFrameBuffer->GetFrameBuferHeader(iScan, nFrameNo);
|
}
|
|
BOOL CGrabberRadient::GetSmallImage(int iScan, LPBYTE lpIn, int nXStart, int nYStart, int nXSize, int nYSize, BOOL bMustMapping)
|
{
|
int nBufSizeX = m_Param.nFrameWidth;
|
int nBufSizeY = m_Param.nFrameHeight;
|
|
if (nXStart < 0 || nYStart < 0) {
|
g_pLog->DisplayMessage(_T("GetSmallImage : Invalid Start Position X=%d, Y=%d"), nXStart, nYStart);
|
return FALSE;
|
}
|
|
if (nXStart + nXSize > nBufSizeX) {
|
g_pLog->DisplayMessage(_T("GetSmallImage : Invalid X Size Start=%d, Size=%d, BufferSizeX=%d"), nXStart, nXSize, nBufSizeX);
|
return FALSE;
|
}
|
|
if (nYStart + nYSize > nBufSizeY * GetEndFrameIdx()) {
|
g_pLog->DisplayMessage(_T("GetSmallImage : Invalid Y Size Start=%d, Size=%d, BufferSizeY=%d"), nYStart, nYSize, nBufSizeY);
|
return FALSE;
|
}
|
|
int nStartFrameNo = nYStart / nBufSizeY;
|
int nEndFrameNo = (nYStart + nYSize) / nBufSizeY;
|
LPBYTE lpHeadAddr = GetFrameHeader(iScan, nStartFrameNo);
|
if (!lpHeadAddr) {
|
g_pLog->DisplayMessage(_T("GetSmallImage : GetFrameHeader Failed for Scan %d, Frame %d"), iScan, nStartFrameNo);
|
return FALSE;
|
}
|
LPBYTE lpStart = lpHeadAddr + (nYStart % nBufSizeY) * nBufSizeX + nXStart;
|
|
int nLine = 0;
|
for (int i = 0; i < nYSize; i++) {
|
memcpy(lpIn + i * nXSize, lpStart + nLine * nBufSizeX, nXSize);
|
if (nStartFrameNo <= nEndFrameNo && (nYStart + i + 1) % nBufSizeY == 0) {
|
lpHeadAddr = GetFrameHeader(iScan, ++nStartFrameNo);
|
lpStart = lpHeadAddr + nXStart;
|
nLine = 0;
|
}
|
else {
|
nLine++;
|
}
|
}
|
|
return TRUE;
|
}
|
|
void CGrabberRadient::SetSimulFrame(int nFrame)
|
{
|
return;
|
}
|
|
BOOL CGrabberRadient::Processing(long HookType, MIL_ID HookId)
|
{
|
if (m_pFrameBuffer == NULL) {
|
return FALSE;
|
}
|
|
m_nEndFrameIdx++; //Count
|
m_nSetBufferIdx++; //index
|
|
int nCameraIdx = m_Param.nCameraIdx;
|
if (m_nEndFrameIdx > g_pStatus->GetGrabFrameCount(nCameraIdx, m_nScanIndex)) {
|
GrabScanStop();
|
g_pStatus->SetGrabEnd(nCameraIdx, m_nScanIndex);
|
g_pLog->DisplayMessage(_T("%d Over Grab Count : Stop Grab [Cam:%d][Scan:%d] - EndFrameIdx=%d FrameCount=%d"), m_Param.nBoardIdx, nCameraIdx, m_nScanIndex, m_nEndFrameIdx, g_pStatus->GetGrabFrameCount(nCameraIdx, m_nScanIndex));
|
return TRUE;
|
}
|
|
if (m_nSetBufferIdx > m_pFrameBuffer->GetFrameCount()) {
|
GrabScanStop();
|
g_pStatus->SetGrabEnd(nCameraIdx, m_nScanIndex);
|
g_pLog->DisplayMessage(_T("%d BufferIndex Overflow : Stop Grab [Cam:%d][Scan:%d] - FrameIdx=%d BufferCount=%d"), m_Param.nBoardIdx, nCameraIdx, m_nScanIndex, m_nEndFrameIdx, m_pFrameBuffer->GetFrameCount());
|
return TRUE;
|
}
|
|
MIL_ID ModifiedImage = 0;
|
LPBYTE pBuffer = m_pFrameBuffer->GetFrameBuferHeader(m_nScanIndex, m_nSetBufferIdx);
|
if (pBuffer == NULL) {
|
GrabScanStop();
|
g_pStatus->SetGrabEnd(nCameraIdx, m_nScanIndex);
|
g_pLog->DisplayMessage(_T("%d BufferPointer NULL : Stop Grab [Cam:%d][Scan:%d] - FrameIdx=%d BufferCount=%d"), m_Param.nBoardIdx, nCameraIdx, m_nScanIndex, m_nEndFrameIdx, m_pFrameBuffer->GetFrameCount());
|
return TRUE;
|
}
|
|
MdigGetHookInfo(HookId, M_MODIFIED_BUFFER + M_BUFFER_ID, &ModifiedImage);
|
MbufControl(ModifiedImage, M_LOCK, M_DEFAULT);
|
MbufGet2d(ModifiedImage, 0, 0, m_Param.nFrameWidth, m_Param.nFrameHeight, pBuffer);
|
MbufControl(ModifiedImage, M_UNLOCK, M_DEFAULT);
|
|
SetInsertFrame(m_nScanIndex, m_nSetBufferIdx);
|
|
#if GRAB_DEBUG_ENABLE
|
// 调试用的详细日志
|
g_pLog->DisplayMessage(
|
_T("[Grab-Processing] FrameAcquired | Board=%d Cam=%d Scan=%d FrameIdx=%d BufIdx=%d Size=%dx%d BufCount=%d"),
|
m_Param.nBoardIdx,
|
m_Param.nCameraIdx,
|
m_nScanIndex,
|
m_nEndFrameIdx,
|
m_nSetBufferIdx,
|
m_Param.nFrameWidth,
|
m_Param.nFrameHeight,
|
m_pFrameBuffer->GetFrameCount()
|
);
|
#endif // GRAB_DEBUG_ENABLE
|
|
return TRUE;
|
}
|
|
BOOL CGrabberRadient::DumpCurrentBuffer(LPBYTE pBuffer, LPCTSTR pszDir)
|
{
|
if (!pszDir || !*pszDir) {
|
g_pLog->DisplayMessage(_T("Dump invalid dir"));
|
return FALSE;
|
}
|
|
const MIL_INT W = m_Param.nFrameWidth;
|
const MIL_INT H = m_Param.nFrameHeight;
|
|
MIL_INT bits = 8;
|
if (m_MilDigitizer) {
|
MdigInquire(m_MilDigitizer, M_SIZE_BIT, &bits);
|
}
|
const MIL_INT milType = (bits > 8) ? (16 + M_UNSIGNED) : (8 + M_UNSIGNED);
|
|
if (CreateDirectory(pszDir, nullptr) == 0) {
|
DWORD e = GetLastError();
|
if (e != ERROR_ALREADY_EXISTS) {
|
g_pLog->DisplayMessage(_T("DumpFB CreateDirectory failed (%lu): %s"), e, pszDir);
|
return FALSE;
|
}
|
}
|
|
MIL_ID img = M_NULL;
|
MbufAlloc2d(m_MilSystem, W, H, milType, M_IMAGE + M_PROC, &img);
|
if (img == M_NULL) {
|
g_pLog->DisplayMessage(_T("DumpFB MbufAlloc2d failed: %dx%dx%dbit"), (int)W, (int)H, (int)bits);
|
return FALSE;
|
}
|
|
static LONG sSeq = 0;
|
LONG seq = InterlockedIncrement(&sSeq);
|
|
MbufPut2d(img, 0, 0, W, H, pBuffer);
|
|
CString path;
|
path.Format(_T("%s\\Cam%d_Scan%d_seq%06ld.tif"), pszDir, m_Param.nCameraIdx, m_nScanIndex, (long)seq);
|
|
MIL_INT dummy = 0;
|
MappGetError(M_GLOBAL, &dummy);
|
|
MbufExport((MIL_CONST_TEXT_PTR)(LPCTSTR)path, M_TIFF, img);
|
|
MIL_INT err = 0;
|
if (MappGetError(M_GLOBAL, &err)) {
|
g_pLog->DisplayMessage(_T("DumpFB export failed (MIL_ERR=%lld): %s"), err, path);
|
}
|
|
MbufFree(img);
|
return TRUE;
|
}
|
|
long MFTYPE CGrabberRadient::CallbackHookFunction(long HookType, MIL_ID HookId, void MPTYPE *HookDataPtr)
|
{
|
if (GetThreadPriority(GetCurrentThread()) != THREAD_PRIORITY_HIGHEST) {
|
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
|
g_pLog->DisplayMessage(_T("[Grab] CallbackHookFunction : thread priority set to HIGHEST"));
|
}
|
|
MIL_ID nEventDig = M_NULL;
|
CGrabberRadient *pRadient = (CGrabberRadient*)HookDataPtr;
|
if (nullptr == pRadient){
|
return 0;
|
}
|
|
MdigGetHookInfo(HookId, M_DIGITIZER_ID, &nEventDig);
|
if (nEventDig != pRadient->m_MilDigitizer) {
|
g_pLog->DisplayMessage(_T("CallbackHookFunction : HookId %lld does not match Digitizer %lld"), HookId, pRadient->m_MilDigitizer);
|
return 0;
|
}
|
|
return pRadient->Processing(HookType, HookId) ? 0 : 1;
|
}
|
|
long MFTYPE CGrabberRadient::CallbackFreeRunFunction(long HookType, MIL_ID HookId, void MPTYPE *HookDataPtr)
|
{
|
if (GetThreadPriority(GetCurrentThread()) != THREAD_PRIORITY_HIGHEST) {
|
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
|
g_pLog->DisplayMessage(_T("CallbackFreeRunFunction : thread priority set to HIGHEST"));
|
}
|
|
MIL_ID nEventDig = M_NULL;
|
CGrabberRadient *pRadient = (CGrabberRadient*)HookDataPtr;
|
if (nullptr == pRadient) {
|
return 0;
|
}
|
|
MdigGetHookInfo(HookId, M_DIGITIZER_ID, &nEventDig);
|
if (nEventDig != pRadient->m_MilDigitizer) {
|
g_pLog->DisplayMessage(_T("CallbackFreeRunFunction : HookId %lld does not match Digitizer %lld"), HookId, pRadient->m_MilDigitizer);
|
return 0;
|
}
|
|
if(pRadient->m_isLiveGrab == TRUE) {
|
pRadient->m_nSetBufferIdx = 0;
|
int nCameraIdx = pRadient->m_Param.nCameraIdx;
|
|
LPBYTE pBuffer = pRadient->m_pFrameBuffer->GetFrameBuferHeader(pRadient->m_nScanIndex, pRadient->m_nSetBufferIdx);
|
if(pBuffer == NULL) {
|
pRadient->GrabScanStop();
|
g_pStatus->SetGrabEnd(nCameraIdx, pRadient->m_nScanIndex);
|
g_pLog->DisplayMessage(_T("%d Over Grab Buffer Stop Grab[%d][%d] - %d"), pRadient->m_Param.nBoardIdx, pRadient->m_nScanIndex, pRadient->m_nEndFrameIdx,pRadient->m_pFrameBuffer->GetFrameCount());
|
return TRUE;
|
}
|
|
MIL_ID ModifiedImage = 0;
|
MdigGetHookInfo(HookId, M_MODIFIED_BUFFER + M_BUFFER_ID, &ModifiedImage);
|
MbufControl(ModifiedImage, M_LOCK, M_DEFAULT);
|
MbufGet2d(ModifiedImage, 0, 0, pRadient->m_Param.nFrameWidth, pRadient->m_Param.nFrameHeight, pBuffer);
|
MbufControl(ModifiedImage, M_UNLOCK, M_DEFAULT);
|
|
/*
|
int iGrab = pRadient->m_nSetBufferIdx%pRadient->m_Param.nGrabBufCount;
|
MbufGet(pRadient->m_MilImageChild[iGrab],pBuffer);
|
*/
|
|
#if GRAB_DEBUG_ENABLE
|
// 打印采集详细信息
|
g_pLog->DisplayMessage(
|
_T("[Grab-FreeRun] FrameAcquired | Board=%d Cam=%d Scan=%d FrameIdx=%d BufIdx=%d Size=%dx%d BufCount=%d"),
|
pRadient->m_Param.nBoardIdx,
|
pRadient->m_Param.nCameraIdx,
|
pRadient->m_nScanIndex,
|
pRadient->m_nEndFrameIdx,
|
pRadient->m_nSetBufferIdx,
|
pRadient->m_Param.nFrameWidth,
|
pRadient->m_Param.nFrameHeight,
|
pRadient->m_pFrameBuffer->GetFrameCount()
|
);
|
|
// 调试用的图像转存
|
pRadient->DumpCurrentBuffer(pBuffer, GRAB_DUMP_DIR);
|
#endif // GRAB_DEBUG_ENABLE
|
|
return TRUE;
|
}
|
|
return 0;
|
}
|
|
BOOL CGrabberRadient::CreateGrabBuffer(int nScanCount,int nBufSize, int nBufSizeX, int nBufSizeY)
|
{
|
SIZE_T nTempBufferSize= nBufSize;
|
SIZE_T nTempFrmCX = nBufSizeX;
|
SIZE_T nTempFrmCY = nBufSizeY;
|
SIZE_T nTotalBufferSize= nTempBufferSize * nTempFrmCX * nTempFrmCY;
|
m_nAllocatedGrabBufSize = nBufSize;
|
|
if (m_pFrameBuffer != NULL) {
|
delete m_pFrameBuffer;
|
m_pFrameBuffer = NULL;
|
}
|
|
m_pFrameBuffer = new CFrameBufferController;
|
if (TRUE == m_pFrameBuffer->CreateBuffer(m_Param.nCameraIdx, nBufSizeX, nBufSizeY, nBufSize, nScanCount)) {
|
g_pLog->DisplayMessage(_T("Create Buffer success!:Id[%d],Frame[%d,%d],Cnt[%d]"),m_Param.nCameraIdx,nBufSizeX,nBufSizeY,nBufSize);
|
}
|
else {
|
g_pLog->DisplayMessage(_T("Create Buffer Fail!:Id[%d],Frame[%d,%d],Cnt[%d]"),m_Param.nCameraIdx,nBufSizeX,nBufSizeY,nBufSize);
|
return FALSE;
|
}
|
|
return TRUE;
|
}
|
|
void CGrabberRadient::ClearBuffer()
|
{
|
if (m_pFrameBuffer != NULL) {
|
m_pFrameBuffer->ClearBuffer();
|
}
|
}
|
|
void CGrabberRadient::ClearGrabIdx()
|
{
|
CSingleLock MyLock(&m_csIdxLock);
|
MyLock.Lock();
|
|
g_pLog->DisplayMessage(_T("Board : %d Clear.."), m_lBord);
|
|
m_dqCallbackFrame.clear();
|
MyLock.Unlock();
|
}
|
|
BOOL CGrabberRadient::SetInsertFrame(int iScan,int iFrame)
|
{
|
CSingleLock MyLock(&m_csIdxLock);
|
MyLock.Lock();
|
|
stFrameIndex stFrame(iScan,iFrame);
|
m_dqCallbackFrame.push_back(stFrame);
|
MyLock.Unlock();
|
|
return TRUE;
|
}
|
|
BOOL CGrabberRadient::FindGrabIdx(int iScan, int iFrame)
|
{
|
CSingleLock MyLock(&m_csIdxLock);
|
MyLock.Lock();
|
|
BOOL bRet = FALSE;
|
stFrameIndex stFrame;
|
for (dqGrabIdxIt it = m_dqCallbackFrame.begin(); it != m_dqCallbackFrame.end(); it++) {
|
stFrame = *it;
|
if (stFrame.nScanIdx == iScan) {
|
if (stFrame.nFrameIdx < iFrame) {
|
bRet = TRUE;
|
}
|
}
|
}
|
MyLock.Unlock();
|
|
return bRet;
|
}
|
|
int CGrabberRadient::GetGrabFrameCount()
|
{
|
return (int)m_dqCallbackFrame.size();
|
}
|
|
stFrameIndex CGrabberRadient::GetGrabFrameNoRemove()
|
{
|
stFrameIndex stPop(-1, -1);
|
|
CSingleLock MyLock(&m_csIdxLock);
|
MyLock.Lock();
|
if(IsHasGrabFrame() == FALSE) {
|
MyLock.Unlock();
|
return stPop;
|
}
|
|
stPop = m_dqCallbackFrame.front();
|
|
TRACE("Pop Frame Lock[%d]\r\n", stPop.nFrameIdx);
|
MyLock.Unlock();
|
return stPop;
|
}
|
|
stFrameIndex CGrabberRadient::GetGrabFrame()
|
{
|
stFrameIndex stPop(-1, -1);
|
CSingleLock MyLock(&m_csIdxLock);
|
MyLock.Lock();
|
if(IsHasGrabFrame() == FALSE) {
|
MyLock.Unlock();
|
return stPop;
|
}
|
|
stPop = m_dqCallbackFrame.front();
|
m_dqCallbackFrame.pop_front();
|
|
TRACE("Pop Frame Lock[%d]\r\n", stPop.nFrameIdx);
|
MyLock.Unlock();
|
return stPop;
|
}
|
|
BOOL CGrabberRadient::IsHasGrabFrame()
|
{
|
return !m_dqCallbackFrame.empty();
|
}
|
|
BOOL CGrabberRadient::SetTriggerMode( BOOL bExTrigger )
|
{
|
if (m_MilDigitizer == M_NULL) {
|
g_pLog->DisplayMessage(_T("SetTriggerMode failed: digitizer is NULL"));
|
return FALSE;
|
}
|
|
INT nExposureTimer = m_Param.nExposure * 1000;
|
INT nExposureTimerDelay = m_Param.nExposureDelay * 1000;
|
//MdigControl(m_MilDigitizer, M_CAMERALINK_CC1_SOURCE, M_GRAB_EXPOSURE + M_TIMER1);
|
//MdigControl(m_MilDigitizer, M_GRAB_EXPOSURE + M_TIMER1, M_ENABLE);
|
//MdigControl(m_MilDigitizer, M_GRAB_EXPOSURE_SOURCE + M_TIMER1, bExTrigger ? M_HARDWARE : M_CONTINUOUS);
|
//MdigControl(m_MilDigitizer, M_GRAB_EXPOSURE_TIME + M_TIMER1, nExposureTimer);
|
//MdigControl(m_MilDigitizer, M_GRAB_EXPOSURE_TIME_DELAY + M_TIMER1, nExposureTimerDelay);
|
g_pLog->DisplayMessage(_T("TriggerMode=%s, Exp(ns)=%d, Delay(ns)=%d"), bExTrigger ? _T("External") : _T("Live"), nExposureTimer, nExposureTimerDelay);
|
|
return TRUE;
|
}
|
|
BOOL CGrabberRadient::DumpBufferAsOneImage(int iScan, LPCTSTR pszPath)
|
{
|
if (!m_pFrameBuffer) {
|
g_pLog->DisplayMessage(_T("Dump m_pFrameBuffer is NULL"));
|
return FALSE;
|
}
|
|
const int nFramesAlloc = m_pFrameBuffer->GetFrameCount();
|
const int nFramesGrab = GetEndFrameIdx();
|
const int nFrames = (nFramesGrab > 0 && nFramesGrab <= nFramesAlloc) ? nFramesGrab : nFramesAlloc;
|
if (nFrames <= 0) {
|
return FALSE;
|
}
|
|
const MIL_INT W = m_Param.nFrameWidth;
|
const MIL_INT H = m_Param.nFrameHeight;
|
|
// 保持真实位深（8/10/12/16bit -> 8/16bit缓冲）
|
MIL_INT bits = 8;
|
if (m_MilDigitizer) {
|
MdigInquire(m_MilDigitizer, M_SIZE_BIT, &bits);
|
}
|
|
const int bpp = (int)((bits + 7) / 8);
|
const MIL_INT type = (bpp >= 2) ? (16 + M_UNSIGNED) : (8 + M_UNSIGNED);
|
|
// 拼接成一张长图
|
MIL_ID img = M_NULL;
|
MbufAlloc2d(m_MilSystem, W, H * nFrames, type, M_IMAGE + M_PROC, &img);
|
if (img == M_NULL) {
|
return FALSE;
|
}
|
|
for (int f = 0; f < nFrames; ++f) {
|
LPBYTE src = m_pFrameBuffer->GetFrameBuferHeader(iScan, f);
|
if (!src) {
|
break;
|
}
|
|
MbufPut2d(img, 0, (MIL_INT)f * H, W, H, src);
|
}
|
|
MbufExport((MIL_CONST_TEXT_PTR)(LPCTSTR)pszPath, M_TIFF, img);
|
|
MIL_INT err = 0;
|
if (MappGetError(M_GLOBAL, &err)) {
|
g_pLog->DisplayMessage(_T("DumpBufferAsOneImage Error : %d"), err);
|
return FALSE;
|
}
|
|
MbufFree(img);
|
return TRUE;
|
}
|
