Maize Kernel Measurement software V2.0 source code Beijing Research Center for Information Technology in Agriculture
Maize Kernel Measurement software V2.0source code
Beijing Research Center for Information Technology in Agriculture
Maize Kernel Measurement software 1
#pragma once#include "kernelInterface.h"class kernelSuspendControlDlg;class kernelProjectDlg;class kernelCameraControlDlg;class kernelDetectDlg;class kernelRTImgTipDlg;
class AFX_CLASS_EXPORT CkernelMeasureAppDlg : public CDialogEx{ public:
CkernelMeasureAppDlg(CWnd* pParent = NULL);enum { IDD = IDD_KERNELMEASUREAPP_DIALOG };
protected:virtual void DoDataExchange(CDataExchange* pDX);kernelInterface m_kernelInterface;streamKZSystem m_kernelSystem;kernelSuspendControlDlg * m_kernelSuspendControlDlg;kernelProjectDlg* m_pkernelProjectDlg;kernelCameraControlDlg * m_pkernelCameraControlDlg;kernelDetectDlg *m_pkernelDetectDlg;kernelRTImgTipDlg *m_pkernelRTImgTipDlg;
protected:HICON m_hIcon; virtual BOOL OnInitDialog();afx_msg void OnPaint();afx_msg HCURSOR OnQueryDragIcon();DECLARE_MESSAGE_MAP()
public:virtual INT_PTR DoModal();virtual BOOL PreTranslateMessage(MSG* pMsg);virtual void Serialize(CArchive& ar);afx_msg void OnDestroy();afx_msg void OnSize(UINT nType, int cx, int cy);afx_msg void OnTimer(UINT_PTR nIDEvent);//afx_msg void OnBnClickedButtonKernelPro();//afx_msg void OnBnClickedButtonKernelDevice();afx_msg void OnBnClickedButtonGo();virtual void OnFinalRelease();
};
#include "stdafx.h"#include "kernelMeasureApp.h"#include "kernelMeasureAppDlg.h"
Maize Kernel Measurement software 2
#include "afxdialogex.h"#include "kernelInterface.h"#include "kernelSuspendControlDlg.h"#include "duCheckRegister.h"#include "CommonParams.h"#include "streamKernelSet.h"
CkernelMeasureAppDlg::CkernelMeasureAppDlg(CWnd* pParent /*=NULL*/): CDialogEx(CkernelMeasureAppDlg::IDD, pParent)
{m_hIcon = AfxGetApp()->LoadIcon(IDI_ICON_KERNEL_APP); m_kernelSuspendControlDlg = NULL;
}
void CkernelMeasureAppDlg::DoDataExchange(CDataExchange* pDX){
CDialogEx::DoDataExchange(pDX);}
BEGIN_MESSAGE_MAP(CkernelMeasureAppDlg, CDialogEx)ON_WM_PAINT()ON_WM_QUERYDRAGICON()ON_WM_DESTROY()ON_WM_SIZE()ON_WM_TIMER()//ON_BN_CLICKED(IDC_BUTTON_KERNEL_PRO,
&CkernelMeasureAppDlg::OnBnClickedButtonKernelPro)//ON_BN_CLICKED(IDC_BUTTON_KERNEL_DEVICE,
&CkernelMeasureAppDlg::OnBnClickedButtonKernelDevice)ON_BN_CLICKED(IDC_BUTTON_GO, &CkernelMeasureAppDlg::OnBnClickedButtonGo)
END_MESSAGE_MAP()
BOOL CkernelMeasureAppDlg::OnInitDialog(){
CDialogEx::OnInitDialog();CString m_strTips;CString m_strRegisterTime;duCheckRegister check;CORNREGISTERSTRU infoREG;BOOL bRes = check.IsRegistered( infoREG );
if( infoREG.bUseREG ){
if( bRes )
Maize Kernel Measurement software 3
{streamKernelSet sParams;sParams.readini();sParams.m_strUserLabel.Format( _T("%s"),
STRUSERTYPES[infoREG.nUserType] );sParams.writeini();
}else{
return FALSE;}
}
m_hIcon = AfxGetApp()->LoadIcon(IDI_ICON_KERNEL_APP);
SetIcon(m_hIcon, TRUE); // 设置大图标SetIcon(m_hIcon, FALSE); // 设置小图标m_pkernelProjectDlg = new kernelProjectDlg( &m_kernelSystem, this );m_pkernelProjectDlg->ShowWindow( SW_SHOW );m_pkernelCameraControlDlg = new kernelCameraControlDlg( this,
&m_kernelSystemkernelInterface::RegisterWnd( m_pkernelDetectDlg );m_pkernelCameraControlDlg->ShowWindow(SW_SHOW);
if( ! m_kernelSuspendControlDlg ){
m_kernelSuspendControlDlg = new kernelSuspendControlDlg( &m_kernelSystem, this, 1);
m_kernelSuspendControlDlg->m_pkernelProjectDlg = m_pkernelProjectDlg ;
m_kernelSuspendControlDlg->m_pkernelCameraControlDlg= m_pkernelCameraControlDlg;
m_kernelSuspendControlDlg->m_pkernelDetectDlg = m_pkernelDetectDlg ;
m_kernelSuspendControlDlg->m_pkernelRTImgTipDlg = m_pkernelRTImgTipDlg ;
m_kernelSuspendControlDlg->ArragePanels( KERNELPANEL_PRO );}m_kernelSuspendControlDlg->ShowWindow( SW_SHOW );m_kernelSuspendControlDlg->BringWindowToTop();return TRUE;
}
void CkernelMeasureAppDlg::OnPaint(){
Maize Kernel Measurement software 4
if (IsIconic()){
CPaintDC dc(this);SendMessage(WM_ICONERASEBKGND,
reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);int cxIcon = GetSystemMetrics(SM_CXICON);int cyIcon = GetSystemMetrics(SM_CYICON);CRect rect;GetClientRect(&rect);int x = (rect.Width() - cxIcon + 1) / 2;int y = (rect.Height() - cyIcon + 1) / 2;dc.DrawIcon(x, y, m_hIcon);
}else{
CDialogEx::OnPaint();}
}
HCURSOR CkernelMeasureAppDlg::OnQueryDragIcon(){
return static_cast<HCURSOR>(m_hIcon);}
INT_PTR CkernelMeasureAppDlg::DoModal(){
return CDialogEx::DoModal();}
BOOL CkernelMeasureAppDlg::PreTranslateMessage(MSG* pMsg){
if( pMsg->message == WM_KEYDOWN ){
if(pMsg->wParam == VK_RETURN|| pMsg->wParam == VK_ESCAPE )
{::TranslateMessage(pMsg);::DispatchMessage(pMsg);return TRUE; // DO NOT process further
}}return CDialogEx::PreTranslateMessage(pMsg);
}
Maize Kernel Measurement software 5
void CkernelMeasureAppDlg::Serialize(CArchive& ar){
if (ar.IsStoring()){ // storing code}else{ // loading code}
}
void CkernelMeasureAppDlg::OnDestroy(){
CDialogEx::OnDestroy();}
void CkernelMeasureAppDlg::OnSize(UINT nType, int cx, int cy){
CDialogEx::OnSize(nType, cx, cy);}
void CkernelMeasureAppDlg::OnTimer(UINT_PTR nIDEvent){
CDialogEx::OnTimer(nIDEvent);}
void CkernelMeasureAppDlg::OnFinalRelease(){
if( m_pkernelProjectDlg ){
delete m_pkernelProjectDlg;m_pkernelProjectDlg = NULL;
}if( m_pkernelCameraControlDlg ){
delete m_pkernelCameraControlDlg;m_pkernelCameraControlDlg = NULL;
}if( m_pkernelDetectDlg ){
delete m_pkernelDetectDlg;m_pkernelDetectDlg = NULL;
}
Maize Kernel Measurement software 6
if( m_pkernelRTImgTipDlg ){
delete m_pkernelRTImgTipDlg;m_pkernelRTImgTipDlg = NULL;
}if( m_kernelSuspendControlDlg ){
delete m_kernelSuspendControlDlg;m_kernelSuspendControlDlg = NULL;
}
CDialogEx::OnFinalRelease();}
#pragma once#include "afx.h"#include "duDHCamera.h"#include "streamKernelSet.h"#include "duKernelCamera_FC.h"#include "streamKernels.h"#include <vector>using namespace std;
class AFX_CLASS_EXPORT kernelInterface :public CObject
{public:
kernelInterface(void);~kernelInterface(void);static /*CStreamParams*/streamKernelSet s_kernel_param;static unsigned int s_nCameraImageHeight;static unsigned int s_nCameraImageWidth ;static streamCamera* s_cameraBase; static BOOL RegisterWnd( CWnd* pDrawWnd ); static duBKcodeBook* s_duBKcodeBook; static CString g_strOneBKKernelImage;static IplImage* s_localObjMaskImage;
static kernelRes s_localBKRes; static std::vector<KernelInfo> s_localBKObjects; static BOOL DrawBKObjectsAndCalculate( IplImage* pSource ); static CCriticalSection m_csData; static BOOL ComputeBKObject(streamKernel& kernel,kernelRes& KRes);static BOOL SplitSingleKernel(
Maize Kernel Measurement software 7
IplImage* pSourceRGB, IplImage* pSubObject, CvPoint pt1, CvPoint pt2, double & dScale,
double & dMaxArea,CvPoint ptOrigin = cvPoint(0,0) );
static BOOL DetermineSingleKernelGeometry(
IplImage* pSourceRGB, // 用于绘图的原始图像CvSeq *contour, // 籽粒的轮廓double &dLen,double &dWid,CvPoint &ptM0, // main axisCvPoint &ptM1,CvPoint &ptS0, // CvPoint &ptS1);
static BOOL PictureWindows(const CString &strPicFile, CString &sError);};
#include "StdAfx.h"#include "kernelInterface.h"#include "duKernelCamera.h"#include "duCheckRegister.h" streamKernelSet kernelInterface::s_kernel_param;streamCamera* kernelInterface::s_cameraBase = NULL;
IplImage* kernelInterface::s_localObjMaskImage;duBKcodeBook* kernelInterface::s_duBKcodeBook = NULL;CString kernelInterface::g_strOneBKKernelImage = _T("");
kernelRes kernelInterface::s_localBKRes;std::vector<KernelInfo> kernelInterface::s_localBKObjects;
kernelInterface::kernelInterface(void){
kernelInterface::s_kernel_param.readini();
streamCamera::SetCameraType( kernelInterface::s_kernel_param.m_nTypeCamera );
if( kernelInterface::s_kernel_param.m_nTypeCamera == DHCAMERA ){
s_cameraBase = new duKernelCamera/*streamCamera*/;kernelInterface::s_nCameraImageHeight = 964;kernelInterface::s_nCameraImageWidth = 1292;
Maize Kernel Measurement software 8
}else{
s_cameraBase = new duKernelCamera_FC/*streamCamera*/;}{
DU_CAMERA_BASE_INFO cinfo = kernelInterface::s_cameraBase->GetCameraDescrip();
CString strDesp;strDesp.Format( L"%s",
cinfo.strModelName);
kernelInterface::s_kernel_param.m_strCameraType = strDesp;kernelInterface::s_kernel_param.writeini();
}}
kernelInterface::~kernelInterface(void){
if( s_cameraBase->m_bDevOpened ){
s_cameraBase->CloseDevice();}delete s_cameraBase;s_cameraBase = NULL;
if( kernelInterface::s_localObjMaskImage ){
cvReleaseImage( & kernelInterface::s_localObjMaskImage);}
if( kernelInterface::s_duBKcodeBook ){
delete kernelInterface::s_duBKcodeBook;kernelInterface::s_duBKcodeBook = NULL;
}
kernelInterface::s_kernel_param.writeini();}
BOOL kernelInterface:: RegisterWnd( CWnd* pDrawWnd ){
if( !pDrawWnd )return FALSE;
Maize Kernel Measurement software 9
kernelInterface::s_cameraBase->m_wndDrawImage = pDrawWnd;return TRUE;
}
BOOL kernelInterface::DrawBKObjectsAndCalculate( IplImage* pSource ){
USES_CONVERSION;if( !s_duBKcodeBook )
return FALSE;
if( !s_duBKcodeBook->duImaskCodeBook )return FALSE;
if( !pSource )return FALSE;
IplImage* pSourceExR = cvCreateImage( cvGetSize(pSource), 8, 1 );IplImage* pSourceExR_bin = cvCreateImage( cvGetSize(pSource), 8, 1 );{
IplImage* pR = cvCreateImage( cvGetSize(pSource), pSource->depth, 1 );
IplImage* pG = cvCreateImage( cvGetSize(pSource), pSource->depth, 1 );
IplImage* pB = cvCreateImage( cvGetSize(pSource), pSource->depth, 1 );
cvSplit( pSource, pB, pG, pR, NULL );duImageLib_CV::cvSuperColor(pR, pG, pB, pSourceExR, 2, -1, -1, FALSE
);
cvReleaseImage( &pR );cvReleaseImage( &pG );cvReleaseImage( &pB );
IplImage* pSourceExR_bin_otsu = cvCreateImage( cvGetSize(pSource), 8, 1 );
duImageLib_CV::cvThresholdOtsu( pSourceExR_bin, pSourceExR_bin_otsu );
{CvMemStorage * storage = cvCreateMemStorage(0);CvSeq * contour = 0;CvSeq * contmax = 0;int mode = CV_RETR_EXTERNAL;
Maize Kernel Measurement software 10
cvFindContours( pSourceExR_bin_otsu,storage, &contour, sizeof( CvContour ), mode, CV_CHAIN_APPROX_NONE, cvPoint(0,0));
int nIDObj = 0;int nIDValidObj = 0;for(;contour;contour = contour->h_next){
int area = fabs(cvContourArea( contour, CV_WHOLE_SEQ ));if( area < 10 )
continue; cvDrawContours(
pSource, contour, CV_RGB(0, 0, 255),//cvScalar(255),CV_RGB(255, 0, 255),//cvScalar(255),0,2, 8,cvPoint(0,0));
}cvReleaseMemStorage( &storage );
}cvReleaseImage( &pSourceExR_bin_otsu );
}CvScalar meanValsExR = cvAvg( pSourceExR );
if( kernelInterface::s_localObjMaskImage == NULL ){
kernelInterface::s_localObjMaskImage = cvCreateImage( cvGetSize(s_duBKcodeBook->duImaskCodeBook), 8, 1);
}
cvCopy(s_duBKcodeBook->duImaskCodeBook, kernelInterface::s_localObjMaskImage );
{cvDilate( kernelInterface::s_localObjMaskImage,
Maize Kernel Measurement software 11
kernelInterface::s_localObjMaskImage, NULL, kernelInterface::s_kernel_param.n_dKernelMorphSize );
cvErode( kernelInterface::s_localObjMaskImage, kernelInterface::s_localObjMaskImage, NULL, kernelInterface::s_kernel_param.n_dKernelMorphSize*2 );
cvDilate( kernelInterface::s_localObjMaskImage, kernelInterface::s_localObjMaskImage, NULL, kernelInterface::s_kernel_param.n_dKernelMorphSize );
s_localBKObjects.clear();{
CvMemStorage * storage = cvCreateMemStorage(0);CvSeq * contour = 0;CvSeq * contmax = 0;int mode = CV_RETR_EXTERNAL;
cvFindContours( kernelInterface::s_localObjMaskImage,storage, &contour,sizeof( CvContour ),mode,CV_CHAIN_APPROX_NONE,cvPoint(0,0));
int nIDObj = 0;int nIDValidObj = 0;for(;contour;contour = contour->h_next){
int area = fabs(cvContourArea( contour, CV_WHOLE_SEQ )); CvRect rc = cvBoundingRect( contour );IplImage *pSubObject = cvCreateImage( cvGetSize(pSource), 8,
1 );cvZero( pSubObject );{
cvDrawContours(pSubObject, contour, cvScalar(255),cvScalar(255),0,CV_FILLED,8,cvPoint(0,0)
Maize Kernel Measurement software 12
);}
CvScalar meanVals = cvAvg( pSourceExR, pSubObject );double dFillingRate = area / (double)(rc.width*rc.height);double dWidScale = fabs( rc.width / (double)rc.height );if(
area > kernelInterface::s_kernel_param.m_dAreaMin_Kernel &&dFillingRate >
kernelInterface::s_kernel_param.m_dFillingRate_Kernel && dWidScale <
kernelInterface::s_kernel_param.m_dWidScale_Kernel && (1/dWidScale) <
kernelInterface::s_kernel_param.m_dLengthScale_Kernel&& meanVals.val[0] > meanValsExR.val[0])
{cvDrawContours(
pSource, contour, CV_RGB(0, 0, 255),//cvScalar(255),CV_RGB(0, 255, 255),//cvScalar(255),0,3, 8,cvPoint(0,0));
cvDrawContours(kernelInterface::s_localObjMaskImage, contour, cvScalar(255),cvScalar(255),0,CV_FILLED,8,cvPoint(0,0));
{CvPoint2D32f center;float radius;cvMinEnclosingCircle( contour,¢er,&radius );cvDrawCircle( pSource, cvPointFrom32f(center),
Maize Kernel Measurement software 13
radius, cvScalar(0,255,255), 3, 8, 0 );}
CvBox2D box = cvMinAreaRect2( contour );CvPoint2D32f ptf[4];cvBoxPoints( box, ptf );
CvPoint pt[4];pt[0] = cvPointFrom32f(ptf[0]);pt[1] = cvPointFrom32f(ptf[1]);pt[2] = cvPointFrom32f(ptf[2]);
pt[3] = cvPointFrom32f(ptf[3]);、for ( int ii=0; ii<3; ii++ ){
if( ii== 0 )cvDrawLine( pSource, pt[3], pt[0],
cvScalar(255,0,0), 1 );cvDrawLine( pSource, pt[ii], pt[ii+1],
cvScalar(255,0,0), 1 );}
KernelInfo ki;BOOL bUSED = TRUE;if( bUSED ){
double dLen;double dWid;CvPoint ptM0; // main axisCvPoint ptM1;CvPoint ptS0; // CvPoint ptS1;BOOL bDeter = DetermineSingleKernelGeometry(
pSource,contour,dLen,dWid,ptM0, ptM1,ptS0,ptS1);
cvDrawLine( pSource, ptM0, ptM1, cvScalar(0,0,255), 2 );
Maize Kernel Measurement software 14
cvDrawLine( pSource, ptS0, ptS1, cvScalar(0,255,0), 1, CV_AA );
ki.dMainAxisLen = dLen;ki.dSecondAxisLen = dWid;
ki.ptMain1 = ptM0;ki.ptMain2 = ptM1;ki.ptSecond1 = ptS0;ki.ptSecond2 = ptS1;
}else {
double ddis01 = sqrt( (ptf[0].y-ptf[1].y)*(ptf[0].y-ptf[1].y) + (ptf[0].x-ptf[1].x)*(ptf[0].x-ptf[1].x) );
double ddis12 = sqrt( (ptf[2].y-ptf[1].y)*(ptf[2].y-ptf[1].y) + (ptf[2].x-ptf[1].x)*(ptf[2].x-ptf[1].x) );
CvPoint ptMain[2];CvPoint ptSecond[2];if( ddis01 > ddis12 ){
ptMain[0].x = (pt[0].x + pt[3].x)/2;ptMain[0].y = (pt[0].y + pt[3].y)/2;ptMain[1].x = (pt[1].x + pt[2].x)/2;ptMain[1].y = (pt[1].y + pt[2].y)/2;
ptSecond[0].x = (pt[0].x + pt[1].x)/2;ptSecond[0].y = (pt[0].y + pt[1].y)/2;ptSecond[1].x = (pt[3].x + pt[2].x)/2;ptSecond[1].y = (pt[3].y + pt[2].y)/2;
}else{
ptMain[0].x = (pt[0].x + pt[1].x)/2;ptMain[0].y = (pt[0].y + pt[1].y)/2;ptMain[1].x = (pt[3].x + pt[2].x)/2;ptMain[1].y = (pt[3].y + pt[2].y)/2;
ptSecond[0].x = (pt[0].x + pt[3].x)/2;ptSecond[0].y = (pt[0].y + pt[3].y)/2;ptSecond[1].x = (pt[1].x + pt[2].x)/2;ptSecond[1].y = (pt[1].y + pt[2].y)/2;
}
Maize Kernel Measurement software 15
cvDrawLine( pSource, ptMain[0], ptMain[1], cvScalar(0,0,255), 2 );
cvDrawLine( pSource, ptSecond[0], ptSecond[1], cvScalar(0,255,0), 1 );
ki.dMainAxisLen = ddis01 > ddis12 ? ddis01 : ddis12;ki.dSecondAxisLen = ddis01 <= ddis12 ? ddis01 :
ddis12;
ki.ptMain1 = ptMain[0];ki.ptMain2 = ptMain[1];ki.ptSecond1 = ptSecond[0];ki.ptSecond2 = ptSecond[1];
}ki.nID = ++nIDValidObj;ki.dArea = area;ki.dFillRate = dFillingRate;ki.box = box;ki.rect = rc;
ki.pt1 = pt[0];ki.pt2 = pt[1];ki.pt3 = pt[2];ki.pt4 = pt[3];s_localBKObjects.push_back(ki);
}cvReleaseImage( &pSubObject );
}cvReleaseMemStorage( &storage );
}s_localBKRes.m_nNum_Kernels = s_localBKObjects.size();BOOL bDirectCalKernel = TRUE;
if( bDirectCalKernel ){
double dValScaleLower = kernelInterface::s_kernel_param.m_dKernelStatisticFactorLower;
double dValScaleUpper = kernelInterface::s_kernel_param.m_dKernelStatisticFactorUpper;
double dKernelLen = 0.f;double dKernelWid = 0.f;double dKernelArea = 0.f;int nKernels = s_localBKObjects.size();
Maize Kernel Measurement software 16
if( nKernels > 0 ){
CString strTip;std::vector<CString> vecTips;int nKernels = s_localBKObjects.size();strTip.Format( _T("kernel number: %d"), nKernels );vecTips.push_back( strTip );{
std::sort( s_localBKObjects.begin(), s_localBKObjects.end(), KernelAreaCompGreater );
strTip.Format( _T("kernel area range: %9.3f - %9.3f"), s_localBKObjects[0].dArea, s_localBKObjects[s_localBKObjects.size()-1].dArea );
vecTips.push_back( strTip );int num = 0;dKernelArea = 0;for ( int k=nKernels*dValScaleLower;
k<=nKernels*dValScaleUpper; k++){
dKernelArea += s_localBKObjects[k].dArea;num++;
}
if( num > 0 ){
dKernelArea = dKernelArea / num;}strTip.Format( _T("Selected kernel area: %d (pixels)"),
(int)dKernelArea );vecTips.push_back( strTip );s_localBKRes.m_dMaxArea_Kernel =
s_localBKObjects[0].dArea ;s_localBKRes.m_dMinArea_Kernel =
s_localBKObjects[s_localBKObjects.size()-1].dArea;}{
std::sort( s_localBKObjects.begin(), s_localBKObjects.end(), KernelMainAxisLenCompGreater );
strTip.Format( _T("kernel main axis length range: %9.3f - %9.3f"), s_localBKObjects[0].dMainAxisLen, s_localBKObjects[s_localBKObjects.size()-1].dMainAxisLen );
vecTips.push_back( strTip );int num = 0;dKernelLen = 0;
Maize Kernel Measurement software 17
for ( int k=nKernels*dValScaleLower; k<=nKernels*dValScaleUpper; k++)
{dKernelLen += s_localBKObjects[k].dMainAxisLen;num++;
}if( num > 0 ){
dKernelLen = dKernelLen / num;}strTip.Format( _T("Selected kernel length: %d (pixels)"),
(int)dKernelLen );vecTips.push_back( strTip );s_localBKRes.m_dLen_Kernels = dKernelLen;
}{
std::sort( s_localBKObjects.begin(), s_localBKObjects.end(), KernelMainAxisLenCompGreater );
strTip.Format( _T("kernel second axis length range: %9.3f - %9.3f"), s_localBKObjects[0].dSecondAxisLen, s_localBKObjects[s_localBKObjects.size()-1].dSecondAxisLen );
vecTips.push_back( strTip );
int num = 0;dKernelWid = 0;for ( int k=nKernels*dValScaleLower;
k<=nKernels*dValScaleUpper; k++){
dKernelWid += s_localBKObjects[k].dSecondAxisLen;num++;
}if( num > 0 ){
dKernelWid = dKernelWid / num;}
strTip.Format( _T("Selected kernel width: %d (pixels)"), (int)dKernelWid );
vecTips.push_back( strTip );s_localBKRes.m_dWid_Kernels = dKernelWid;
}}for ( int n=0; n<s_localBKObjects.size(); n++ ){
Maize Kernel Measurement software 18
s_localBKObjects[n].nID = n+1;
CString strTag;strTag.Format( _T("%d"), s_localBKObjects[n].nID );CvFont font; cvInitFont( &font, CV_FONT_HERSHEY_COMPLEX, 1, 1, 1, 1, 8 ); cvPutText( pSource, W2A(strTag),
CvPoint( (int)s_localBKObjects[n].box.center.x, (int)s_localBKObjects[n].box.center.y ), &font, CV_RGB(255,0,255) );
}s_localBKRes.m_nNum_Kernels = nKernels;
}}
cvReleaseImage( &pSourceExR_bin );cvReleaseImage( &pSourceExR );
}
CCriticalSection kernelInterface::m_csData;BOOL kernelInterface::ComputeBKObject(streamKernel& kernel, kernelRes& KRes ){
USES_CONVERSION;
if( !s_cameraBase->duGetPixelDataRGB() )return FALSE;
if( !s_duBKcodeBook )return FALSE;
if( !s_duBKcodeBook->duImaskCodeBook )return FALSE;
if( !kernelInterface::s_localObjMaskImage )return FALSE;
CSingleLock dataLock( &m_csData );dataLock.Lock();IplImage *iplImage = cvLoadImage( W2A(kernel.m_strImageFile) );if( s_kernel_param.m_nTypeCamera == 0 ){
cvFlip(iplImage, iplImage, 0 );}else
Maize Kernel Measurement software 19
{cvSmooth(iplImage, iplImage, CV_GAUSSIAN/*CV_MEDIAN*/, 5 );
}
s_cameraBase->duGetPixelDataRGB(),3*kernelInterface::s_nCameraImageWidth);IplImage* pSource = cvCreateImage( cvGetSize(iplImage), iplImage->depth,
iplImage->nChannels );cvCopy( iplImage, pSource );cvSmooth(pSource, pSource, CV_GAUSSIAN/*CV_MEDIAN*/, 5 );
cvDilate( kernelInterface::s_localObjMaskImage, kernelInterface::s_localObjMaskImage, NULL, kernelInterface::s_kernel_param.n_dKernelMorphSize );
cvErode( kernelInterface::s_localObjMaskImage, kernelInterface::s_localObjMaskImage, NULL, kernelInterface::s_kernel_param.n_dKernelMorphSize*2 );
cvDilate( kernelInterface::s_localObjMaskImage, kernelInterface::s_localObjMaskImage, NULL, kernelInterface::s_kernel_param.n_dKernelMorphSize );
CString strTip;CString strResPath =
duImageProcess_ITK::GetFilePathName(KRes.m_filename);
if( CORNREGISTERSTRU::GetUserType( kernelInterface::s_kernel_param.m_strUserLabel) == CORN_DEVELOPER )
{{
strTip.Format( L"%s\\bk_pMask.png", strResPath );cvSaveImage( W2A(strTip), kernelInterface::s_localObjMaskImage );
}{
strTip.Format( L"%s\\bk_source.png", strResPath );cvSaveImage( W2A(strTip), pSource );
}
}IplImage* pResult = cvCreateImage( cvGetSize(pSource), pSource->depth,
pSource->nChannels );cvZero( pResult );CString strObjRGBMasked;cvAddS( pSource,CvScalar(0), pResult,
kernelInterface::s_localObjMaskImage );
Maize Kernel Measurement software 20
{strObjRGBMasked.Format( L"%s\\bk_first_seg.png", strResPath );cvSaveImage( W2A(strObjRGBMasked), pResult );
}{
for ( int i=0; i<s_localBKObjects.size(); i++ ){
cvDrawLine( pSource, s_localBKObjects[i].ptMain1, s_localBKObjects[i].ptMain2, cvScalar(0,0,255), 2 );
cvDrawLine( pSource, s_localBKObjects[i].ptSecond1, s_localBKObjects[i].ptSecond2, cvScalar(0,255,0), 1 );
cvDrawLine( pSource, s_localBKObjects[i].pt1, s_localBKObjects[i].pt2, cvScalar(255,0,0), 1 );
cvDrawLine( pSource, s_localBKObjects[i].pt2, s_localBKObjects[i].pt3, cvScalar(255,0,0), 1 );
cvDrawLine( pSource, s_localBKObjects[i].pt3, s_localBKObjects[i].pt4, cvScalar(255,0,0), 1 );
cvDrawLine( pSource, s_localBKObjects[i].pt4, s_localBKObjects[i].pt1, cvScalar(255,0,0), 1 );
CString strTag;strTag.Format( _T("%d"), s_localBKObjects[i].nID );CvFont font; cvInitFont( &font, CV_FONT_HERSHEY_COMPLEX, 0.5, 0.5, 1, 1, 8 ); cvPutText( pSource, W2A(strTag),
CvPoint( (int)s_localBKObjects[i].box.center.x,(int)s_localBKObjects[i].box.center.y ),&font, CV_RGB(255,0,255));
}
strTip.Format( L"%s\\bk_效果图.png", strResPath );cvSaveImage( W2A(strTip), pSource );
} {
IplImage* pKernelImage_scalar = cvCreateImage(cvGetSize(pResult), 8, 1 );
BOOL bPreciseMode = TRUE; if( bPreciseMode ){
cvCvtColor( pResult, pKernelImage_scalar, CV_RGB2GRAY );IplImage* pMultiSegmentedObj = cvCreateImage(
cvGetSize(pKernelImage_scalar), 8, 1 );
Maize Kernel Measurement software 21
streamKernel::MultiLevelThresholdTwoPath(kernelInterface::s_kernel_param,// 1,pKernelImage_scalar,pMultiSegmentedObj ,strObjRGBMasked);
std::vector<KernelInfo> vecMultiSeg;int nIDValidObj = 0;{
CvMemStorage * storage = cvCreateMemStorage(0);CvSeq * contour = 0;CvSeq * contmax = 0;int mode = CV_RETR_EXTERNAL;
cvFindContours( pMultiSegmentedObj,storage, &contour,sizeof( CvContour ),mode,CV_CHAIN_APPROX_NONE, cvPoint(0,0));
for(;contour;contour = contour->h_next){
int area = fabs(cvContourArea( contour, CV_WHOLE_SEQ )); CvRect rc = cvBoundingRect( contour );double dFillRate = area / (double)(rc.width*rc.height);double dWidScale = fabs( rc.width / (double)rc.height );
if( area >
kernelInterface::s_kernel_param.m_dAreaMin_Kernel )
{KernelInfo ki;ki.nID = ++nIDValidObj;ki.dArea = area;ki.rect = rc;
Maize Kernel Measurement software 22
CvPoint2D32f center;float radius;cvMinEnclosingCircle( contour,¢er,&radius );ki.center = center;ki,radius = radius;
vecMultiSeg.push_back(ki);cvDrawCircle( pSource, cvPointFrom32f(center),
radius, cvScalar(0,255,255), 3, 8, 0 );
CString strTag;strTag.Format( _T("%d"), nIDValidObj );CvFont font; cvInitFont( &font, CV_FONT_HERSHEY_COMPLEX, 1.1, 1.1,
1, 1, 8 ); cvPutText( pSource, W2A(strTag),
cvPointFrom32f(center),&font, CV_RGB(0,255,255));
}}
cvReleaseMemStorage( &storage );}
{
strTip.Format( L"%s\\bk_效果图_2.png", strResPath );cvSaveImage( W2A(strTip), pSource );
}
if( CORNREGISTERSTRU::GetUserType( kernelInterface::s_kernel_param.m_strUserLabel) == CORN_DEVELOPER )
{CString strSegmented;strSegmented.Format( _T("%s\\bk_obj_seg.png"), strResPath );cvSaveImage( W2A(strSegmented), pMultiSegmentedObj );strSegmented.Format( _T("%s\\bk_obj_scalar.png"),
strResPath );cvSaveImage( W2A(strSegmented), pKernelImage_scalar );
}KRes.m_nNum_Kernels = vecMultiSeg.size();std::vector<kernelRes> vecValidSingleKernel;{
Maize Kernel Measurement software 23
{CvMemStorage * storage = cvCreateMemStorage(0);CvSeq * contour = 0;CvSeq * contmax = 0;int mode = CV_RETR_EXTERNAL;
cvFindContours( kernelInterface::s_localObjMaskImage,storage, &contour,sizeof( CvContour ),mode,CV_CHAIN_APPROX_NONE, cvPoint(0,0));
int nIDObj = 0;for(;contour;contour = contour->h_next){
int area = fabs(cvContourArea( contour, CV_WHOLE_SEQ ));
if( area < kernelInterface::s_kernel_param.m_dAreaMin_Kernel )
continue;nIDObj++;CvPoint2D32f center;float radius;cvMinEnclosingCircle( contour,¢er,&radius );int nContainKernel = 0;for ( int ii=0; ii<vecMultiSeg.size(); ii++ ){
double dis = sqrtf((center.x -
vecMultiSeg[ii].center.x)*(center.x - vecMultiSeg[ii].center.x) +(center.y -
vecMultiSeg[ii].center.y)*(center.y - vecMultiSeg[ii].center.y) );
if( dis < radius ) nContainKernel ++;
}{
double dLen;double dWid;CvPoint ptM0;
Maize Kernel Measurement software 24
CvPoint ptM1;CvPoint ptS0;CvPoint ptS1;BOOL bDeter = DetermineSingleKernelGeometry(
pSource,contour,dLen,dWid,ptM0,ptM1,ptS0, ptS1);
cvDrawLine( pSource, ptM0, ptM1, cvScalar(0,0,255), 2 );
cvDrawLine( pSource, ptS0, ptS1, cvScalar(0,255,0), 1, CV_AA );
kernelRes kr;kr.m_dLen_Kernels = dLen;kr.m_dWid_Kernels = dWid;vecValidSingleKernel.push_back(kr);
}}
cvReleaseMemStorage( &storage );}
if( vecValidSingleKernel.size() > 0 ){
double daver_len = 0;double daver_wid = 0;for ( int kk=0; kk<vecValidSingleKernel.size(); kk++ ){
daver_len += vecValidSingleKernel[kk].m_dLen_Kernels;daver_wid += vecValidSingleKernel[kk].m_dWid_Kernels;
}
KRes.m_dLen_Kernels = daver_len /(int)vecValidSingleKernel.size();
KRes.m_dWid_Kernels = daver_wid /(int)vecValidSingleKernel.size();
}else
Maize Kernel Measurement software 25
{KRes.m_dLen_Kernels = s_localBKRes.m_dLen_Kernels;KRes.m_dWid_Kernels = s_localBKRes.m_dWid_Kernels;
}}cvReleaseImage( &pMultiSegmentedObj );
}else{
cvCvtColor( pResult, pKernelImage_scalar, CV_RGB2GRAY );IplImage* pMultiSegmentedObj = cvCreateImage(
cvGetSize(pKernelImage_scalar), 8, 1 );streamKernel::MultiLevelThresholdTwoPath(
kernelInterface::s_kernel_param,pKernelImage_scalar,pMultiSegmentedObj ,strObjRGBMasked);
std::vector<KernelInfo> vecMultiSeg;int nIDValidObj = 0;{
CvMemStorage * storage = cvCreateMemStorage(0);CvSeq * contour = 0;CvSeq * contmax = 0;int mode = CV_RETR_EXTERNAL;cvFindContours(
pMultiSegmentedObj,storage,&contour,sizeof( CvContour ),mode,CV_CHAIN_APPROX_NONE,cvPoint(0,0));
for(;contour;contour = contour->h_next){
int area = fabs(cvContourArea( contour, CV_WHOLE_SEQ ));CvRect rc = cvBoundingRect( contour );double dFillRate = area / (double)(rc.width*rc.height);double dWidScale = fabs( rc.width / (double)rc.height );
if(area >
Maize Kernel Measurement software 26
kernelInterface::s_kernel_param.m_dAreaMin_Kernel){
KernelInfo ki;ki.nID = ++nIDValidObj;ki.dArea = area;ki.rect = rc; CvPoint2D32f center;float radius;cvMinEnclosingCircle( contour,¢er,&radius );ki.center = center;ki,radius = radius;vecMultiSeg.push_back(ki);
}}
cvReleaseMemStorage( &storage );}
if( CORNREGISTERSTRU::GetUserType( kernelInterface::s_kernel_param.m_strUserLabel) == CORN_DEVELOPER )
{CString strSegmented;strSegmented.Format( _T("%s\\bk_obj_seg.png"), strResPath );cvSaveImage( W2A(strSegmented), pMultiSegmentedObj );strSegmented.Format( _T("%s\\bk_obj_scalar.png"),
strResPath );cvSaveImage( W2A(strSegmented), pKernelImage_scalar );
}
KRes.m_nNum_Kernels = vecMultiSeg.size();KRes.m_dLen_Kernels = s_localBKRes.m_dLen_Kernels;KRes.m_dWid_Kernels = s_localBKRes.m_dWid_Kernels;cvReleaseImage( &pMultiSegmentedObj );
}cvReleaseImage( &pKernelImage_scalar );
}
cvReleaseImageHeader( &iplImage );cvReleaseImage ( &pResult );cvReleaseImage( &pSource );s_localBKRes.m_strKernelIni = KRes.m_strKernelIni;KRes.writeini();dataLock.Unlock(); return TRUE;
Maize Kernel Measurement software 27
}
BOOL kernelInterface::SplitSingleKernel( IplImage* pSourceRGB, IplImage* pSubObject, CvPoint pt1, CvPoint pt2, double & dScale, double
& dMaxArea,CvPoint ptOrigin)
{USES_CONVERSION;
IplImage *pKernelImage = pSubObject;
cvDrawLine( pKernelImage, pt1, pt2, CvScalar(0), 3);
CvMemStorage * storage = cvCreateMemStorage(0);CvSeq * contour = 0;CvSeq * contmax = 0;int mode = CV_RETR_EXTERNAL;
cvFindContours( pKernelImage,storage, &contour,sizeof( CvContour ),mode,CV_CHAIN_APPROX_NONE,cvPoint(0,0))
std::vector<double> vecArea;std::vector<CvScalar> vecScalar;
for(;contour;contour = contour->h_next){
int area = fabs(cvContourArea( contour, CV_WHOLE_SEQ )); vecArea.push_back( area );{
IplImage* pSubSub = cvCreateImage( cvGetSize(pSourceRGB), 8, 1 );cvZero( pSubSub );
cvDrawContours(pSubSub, contour, cvScalar(255),
Maize Kernel Measurement software 28
cvScalar(255),0,CV_FILLED,8,cvPoint(0,0));
CvScalar meanscal, sdvscal;cvAvgSdv(pSourceRGB,&meanscal,&sdvscal,pSubSub );vecScalar.push_back( meanscal );cvReleaseImage( &pSubSub );
}
if( vecArea.size()==2 ){
double ds1 = vecScalar[0].val[0]+vecScalar[0].val[1]+vecScalar[0].val[2];
double ds2 = vecScalar[1].val[0]+vecScalar[1].val[1]+vecScalar[1].val[2];
dMaxArea = ds1>ds2?ds1:ds2;
double dmax = vecArea[0] > vecArea[1] ? vecArea[0] : vecArea[1];double dmin = vecArea[0] < vecArea[1] ? vecArea[0] : vecArea[1];
if( abs(dmin)>1e-6 ){
dScale = dmax/dmin;return TRUE;
}}return FALSE;
}
BOOL kernelInterface:: PictureWindows(const CString &strPicFile, CString &sError){
CString strSystemDir=L"";::GetSystemDirectory(strSystemDir.GetBuffer(256), 256);strSystemDir.ReleaseBuffer();
CString strRundll = strSystemDir + L"\\rundll32.exe";
CString strParm;strParm.Format( L"%s//shimgvw.dll imageview_fullscreen %s",
strSystemDir, strPicFile);
Maize Kernel Measurement software 29
HINSTANCE hNewExe = ShellExecute(NULL, L"Open", strRundll, strParm, NULL, SW_SHOW);
if ((DWORD)hNewExe <= 32){
CString sFormat;sFormat.Format( L"return value:%d\n", (DWORD)hNewExe);sError = sFormat;return FALSE;
}
return TRUE;}
BOOL kernelInterface::DetermineSingleKernelGeometry(IplImage* pSourceRGB,CvSeq *contour,double &dLen,double &dWid,CvPoint &ptM0, CvPoint &ptM1,CvPoint &ptS0, CvPoint &ptS1)
{int area = fabs(cvContourArea( contour, CV_WHOLE_SEQ ));if( area < kernelInterface::s_kernel_param.m_dAreaMin_Kernel )
return FALSE;
CvPoint2D32f center;float radius;cvMinEnclosingCircle( contour,¢er,&radius );
CvRect rc = cvBoundingRect( contour );CvBox2D box = cvMinAreaRect2( contour );CvPoint2D32f ptf[4];cvBoxPoints( box, ptf ); CvPoint pt[4];pt[0] = cvPointFrom32f(ptf[0]);pt[1] = cvPointFrom32f(ptf[1]);pt[2] = cvPointFrom32f(ptf[2]);pt[3] = cvPointFrom32f(ptf[3]);{
IplImage* pKernelBin = cvCreateImage(
Maize Kernel Measurement software 30
cvGetSize(pSourceRGB),8, 1);
cvDrawContours(pKernelBin, contour, cvScalar(255),cvScalar(255),0,CV_FILLED);
IplImage *pSubObject = cvCreateImage( cvGetSize(pKernelBin), 8, 1 );IplImage *pSubObject1 = cvCreateImage( cvGetSize(pKernelBin), 8,
1 );IplImage *pSubObject2 = cvCreateImage( cvGetSize(pKernelBin), 8,
1 );cvCopy( pKernelBin, pSubObject );cvCopy( pKernelBin, pSubObject1 );cvCopy( pKernelBin, pSubObject2 );{
double d02 = sqrt( (ptf[0].y-ptf[1].y)*(ptf[0].y-ptf[1].y) + (ptf[0].x-ptf[1].x)*(ptf[0].x-ptf[1].x) );
double d24 = sqrt( (ptf[2].y-ptf[1].y)*(ptf[2].y-ptf[1].y) + (ptf[2].x-ptf[1].x)*(ptf[2].x-ptf[1].x) );
CvPoint d4,d6;CvPoint d5,d7;d4.x = (int)(ptf[0].x + ptf[1].x)/2;d4.y = (int)(ptf[0].y + ptf[1].y)/2;d6.x = (int)(ptf[3].x + ptf[2].x)/2;d6.y = (int)(ptf[3].y + ptf[2].y)/2;
d7.x = (int)(ptf[0].x + ptf[3].x)/2;d7.y = (int)(ptf[0].y + ptf[3].y)/2;d5.x = (int)(ptf[1].x + ptf[2].x)/2;d5.y = (int)(ptf[1].y + ptf[2].y)/2;double scale57=0; double scale46=0;double dMaxArea57=0;double dMaxArea46=0;BOOL bok1 = SplitSingleKernel( pSourceRGB, pSubObject1, d4, d6,
scale57, dMaxArea57, CvPoint( rc.x, rc.y ) );BOOL bok2 = SplitSingleKernel( pSourceRGB, pSubObject2, d5, d7,
Maize Kernel Measurement software 31
scale46, dMaxArea46, CvPoint( rc.x, rc.y ) );if( dMaxArea46 > dMaxArea57){
dLen = sqrtf( (d4.x-d6.x)*(d4.x-d6.x) + (d4.y-d6.y)*(d4.y-d6.y) );
dWid = sqrtf( (d5.x-d7.x)*(d5.x-d7.x) + (d5.y-d7.y)*(d5.y-d7.y) );
ptM0 = d4; ptM1 = d6; ptS0 = d5; ptS1 = d7;
}else{
dLen = sqrtf( (d5.x-d7.x)*(d5.x-d7.x) + (d5.y-d7.y)*(d5.y-d7.y) );
dWid = sqrtf( (d4.x-d6.x)*(d4.x-d6.x) + (d4.y-d6.y)*(d4.y-d6.y) );
ptM0 = d5; ptM1 = d7; ptS0 = d4; ptS1 = d6;
}
}cvReleaseImage( &pSubObject );cvReleaseImage( &pSubObject1 );cvReleaseImage( &pSubObject2 );cvReleaseImage( &pKernelBin );
}return TRUE;
}
#pragma once#include "streamcamera.h"#include "inc/GxIAPI.h"#include "inc/DxImageProc.h"#include "SerialPort.h"#include "afxwin.h"#include "afxcmn.h"#include "tlhelp32.h"#include "Psapi.h"#pragma comment(lib,"Psapi.lib")class AFX_CLASS_EXPORT duCommonCameraDlg : public CBkDialogST{
DECLARE_DYNAMIC(duCommonCameraDlg)
Maize Kernel Measurement software 32
public:
duCommonCameraDlg(CWnd* pParent = NULL); // 标准构造函数duCommonCameraDlg(
CString strObj ,
CWnd* pParent = NULL); // 标准构造函数virtual ~duCommonCameraDlg();
enum { IDD = IDD_DIALOG_COMMON_CAMERA };
CWnd* m_pParent;CString m_strObjName;
public:CBrush g_ui_redbrush;CBrush g_ui_bluebrush;CBrush g_ui_bkbrush;COLORREF g_ui_redcolor;COLORREF g_ui_bluecolor;COLORREF g_ui_textcolor;COLORREF g_ui_bkcolor;void DrawStringInStyle(
CDC* pDC,int nFontHeight,Gdiplus::Point & pt,CString strTip,Gdiplus::Color clr,int nlineWid,CString strFont);
BOOL OpenFromOutSide();
public:void UpCameraUI();CButtonST m_btnOpenDevice;CFont m_fntPropList;void SetPropListFont();
HICON m_hIconRed; //串口打开时的红灯图标句柄HICON m_hIconOff; //串口关闭时的指示图标句柄HICON m_hIconGreen;
protected:virtual void DoDataExchange(CDataExchange* pDX); DECLARE_MESSAGE_MAP()
virtual BOOL OnInitDialog();
Maize Kernel Measurement software 33
CMFCPropertyGridCtrl m_propGridCtrl_Camera;afx_msg LRESULT OnPropertyChanged(WPARAM,LPARAM); afx_msg void OnBnClickedMfcbuttonOpenDevice();
afx_msg void OnBnClickedMfcbuttonSaveImg();CStatic m_ctrlIconCameraOpenoff;virtual BOOL PreTranslateMessage(MSG* pMsg);
afx_msg void OnBnClickedButtonAutoCalibration();double m_dPSNR_bk;afx_msg void OnBnClickedButtonModifyPixelResolution();CString m_strPixelResolution;
public:virtual INT_PTR DoModal();virtual BOOL Create(LPCTSTR lpszTemplateName, CWnd* pParentWnd = NULL);virtual void OnFinalRelease();virtual void Serialize(CArchive& ar);afx_msg BOOL OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct);afx_msg HBRUSH OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor);afx_msg void OnPaint();afx_msg void OnSize(UINT nType, int cx, int cy);afx_msg void OnTimer(UINT_PTR nIDEvent);
afx_msg void OnStnClickedMfcpropertygridCamera();};
#include "stdafx.h"#include "kernelMeasureDll.h"#include "duCommonCameraDlg.h"#include "afxdialogex.h"#include "kernelInterface.h"IMPLEMENT_DYNAMIC(duCommonCameraDlg, CBkDialogST)
duCommonCameraDlg::duCommonCameraDlg(CWnd* pParent /*=NULL*/): CBkDialogST(duCommonCameraDlg::IDD, pParent), m_dPSNR_bk(0), m_strPixelResolution(_T("0.031")){}
duCommonCameraDlg::duCommonCameraDlg(CString strObj,CWnd* pParent /*=NULL*/)
Maize Kernel Measurement software 34
: CBkDialogST(duCommonCameraDlg::IDD, pParent), m_dPSNR_bk(0), m_strPixelResolution(_T("0.031"))
{m_strObjName = strObj;this->m_pParent = pParent;EnableAutomation();
HMODULE hDLL = GetModuleHandle(_T("kernelMeasureDll.dll"));HINSTANCE hEXE = AfxGetResourceHandle();AfxSetResourceHandle((HINSTANCE)hDLL);BOOL bCreated = CBkDialogST::Create( duCommonCameraDlg::IDD,
CWnd::FromHandle(pParent->GetSafeHwnd()));
if ( !bCreated ){
AfxMessageBox( _T("创建面板失败,资源共享问题。"));}
SUCCEEDED(bCreated);
AfxSetResourceHandle(hEXE); }
duCommonCameraDlg::~duCommonCameraDlg(){}
void duCommonCameraDlg::DoDataExchange(CDataExchange* pDX){
CBkDialogST::DoDataExchange(pDX);
DDX_Control(pDX, IDC_MFCPROPERTYGRID_CAMERA, m_propGridCtrl_Camera);DDX_Control(pDX, IDC_MFCBUTTON_OPEN_DEVICE, m_btnOpenDevice);DDX_Control(pDX, IDC_STATIC_CAMERA_OPENOFF, m_ctrlIconCameraOpenoff);DDX_Text(pDX, IDC_EDIT_BK_PSNR, m_dPSNR_bk);DDX_Text(pDX, IDC_EDIT_PIXEL_RESOLUTION, m_strPixelResolution);
}
BEGIN_MESSAGE_MAP(duCommonCameraDlg, CBkDialogST)ON_REGISTERED_MESSAGE(AFX_WM_PROPERTY_CHANGED, OnPropertyChanged)ON_BN_CLICKED(IDC_MFCBUTTON_OPEN_DEVICE,
&duCommonCameraDlg::OnBnClickedMfcbuttonOpenDevice)ON_BN_CLICKED(IDC_MFCBUTTON_SAVE_IMG,
Maize Kernel Measurement software 35
&duCommonCameraDlg::OnBnClickedMfcbuttonSaveImg)ON_BN_CLICKED(IDC_BUTTON_AUTO_CALIBRATION, &duCommonCameraDlg::OnBnClickedButtonAutoCalibration)ON_BN_CLICKED(IDC_BUTTON_MODIFY_PIXEL_RESOLUTION, &duCommonCameraDlg::OnBnClickedButtonModifyPixelResolution)ON_WM_COPYDATA()ON_WM_CTLCOLOR()ON_WM_PAINT()ON_WM_SIZE()ON_WM_TIMER()ON_STN_CLICKED(IDC_MFCPROPERTYGRID_CAMERA, &duCommonCameraDlg::OnStnClickedMfcpropertygridCamera)END_MESSAGE_MAP()
void duCommonCameraDlg::SetPropListFont(){
::DeleteObject( m_fntPropList.Detach() );
LOGFONT lf;afxGlobalData.fontRegular.GetLogFont(&lf);
NONCLIENTMETRICS info;info.cbSize = sizeof(lf);
afxGlobalData.GetNonClientMetrics(info);lf.lfHeight = info.lfMenuFont.lfHeight;lf.lfWidth = info.lfMenuFont.lfWidth;lf.lfItalic = info.lfMenuFont.lfItalic;m_fntPropList.CreateFontIndirect(&lf);
m_propGridCtrl_Camera.SetFont( &m_fntPropList );}
BOOL duCommonCameraDlg::OnInitDialog(){
CBkDialogST::OnInitDialog();g_ui_redcolor =RGB(255,0,0); // redg_ui_bluecolor =RGB(0,0,255); // blueg_ui_bkcolor =RGB(11,22,44); // blueg_ui_textcolor =RGB(0,0,255); // white textg_ui_redbrush .CreateSolidBrush(g_ui_redcolor); // red backgroundg_ui_bluebrush .CreateSolidBrush(g_ui_bluecolor); // blue backgroundg_ui_bkbrush .CreateSolidBrush(g_ui_bkcolor); // blue background
Maize Kernel Measurement software 36
m_strPixelResolution.Format( _T("%.6f"), kernelInterface::s_kernel_param.dPhysicalResolution );
{GX_STATUS emStatus = GX_STATUS_SUCCESS;emStatus = GXInitLib();if (emStatus != GX_STATUS_SUCCESS){
// e_camera->ShowErrorString(emStatus);exit(0);
}
UpCameraUI();}
{
m_propGridCtrl_Camera.EnableHeaderCtrl(TRUE, L"属性项", L"值项");m_propGridCtrl_Camera.EnableDescriptionArea(TRUE);m_propGridCtrl_Camera.SetVSDotNetLook();m_propGridCtrl_Camera.AdjustLayout();m_propGridCtrl_Camera.MarkModifiedProperties();HDITEM item; item.cxy=120; item.mask=HDI_WIDTH; m_propGridCtrl_Camera.GetHeaderCtrl().SetItem(0, new HDITEM(item));
}
short shBtnColor = 30;m_btnOpenDevice.SetIcon(IDI_ICON_CAMERA_OPEN);m_btnOpenDevice.OffsetColor(CButtonST::BTNST_COLOR_FG_IN, shBtnColor);m_btnOpenDevice.DrawFlatFocus(TRUE);m_btnOpenDevice.SetFlat(FALSE);m_hIconRed = AfxGetApp()->LoadIcon(IDI_ICON_RED);m_hIconOff = AfxGetApp()->LoadIcon(IDI_ICON_OFF);m_ctrlIconCameraOpenoff.SetIcon( m_hIconOff );this->UpdateData(FALSE);return TRUE; // return TRUE unless you set the focus to a control
}
BOOL duCommonCameraDlg::PreTranslateMessage(MSG* pMsg){
if( pMsg->message == WM_KEYDOWN ){
if(pMsg->wParam == VK_RETURN
Maize Kernel Measurement software 37
|| pMsg->wParam == VK_ESCAPE ){
::TranslateMessage(pMsg);::DispatchMessage(pMsg);return TRUE; // DO NOT process further
}}
return CBkDialogST::PreTranslateMessage(pMsg);}
LRESULT duCommonCameraDlg::OnPropertyChanged (WPARAM,LPARAM lParam) {
CMFCPropertyGridProperty* pProp = (CMFCPropertyGridProperty*) lParam;
CString name = pProp->GetName();COleVariant oleval = pProp->GetValue();double dChanged;bool bChanged;
if ( name.CompareNoCase( _T("触发模式")) == 0 ||name.CompareNoCase( _T("触发源")) == 0 ||name.CompareNoCase( _T("触发极性")) == 0 ||name.CompareNoCase( _T("自动白平衡")) == 0 ||name.CompareNoCase( _T("白平衡通道")) == 0 ||name.CompareNoCase( _T("白平衡系数")) == 0 ||name.CompareNoCase( _T("曝光")) == 0 ||name.CompareNoCase( _T("增益")) == 0 )
{kernelInterface::s_cameraBase-
>UpdateObjFromPropList( &m_propGridCtrl_Camera, pProp );}
return 0;}
#include "duKernelCamera.h"BOOL duCommonCameraDlg::OpenFromOutSide(){
if( kernelInterface::s_cameraBase->m_bDevOpened ){
return TRUE;}
Maize Kernel Measurement software 38
else{
BOOL bOpen = kernelInterface::s_cameraBase->OpenDevice();
if( !bOpen ){
AfxMessageBox( _T("无法打开相机") );kernelInterface::s_cameraBase->m_bDevOpened = FALSE;return FALSE;
}else{
kernelInterface::s_cameraBase->m_bDevOpened = TRUE;kernelInterface::s_cameraBase-
>FillPropGridCtrl( &m_propGridCtrl_Camera );if( kernelInterface::s_cameraBase ){
kernelInterface::s_cameraBase->StartCapture();}
}}
UpCameraUI();this->UpdateData(FALSE);
return TRUE;}
void duCommonCameraDlg::OnBnClickedMfcbuttonOpenDevice(){
if( kernelInterface::s_cameraBase->m_bDevOpened ){
BOOL bOk = kernelInterface::s_cameraBase->CloseDevice();if( bOk )
kernelInterface::s_cameraBase->m_bDevOpened = FALSE;else
kernelInterface::s_cameraBase->m_bDevOpened = TRUE;}else{
BOOL bOpen = kernelInterface::s_cameraBase->OpenDevice();
if( !bOpen ){
Maize Kernel Measurement software 39
AfxMessageBox( _T("无法打开相机") );kernelInterface::s_cameraBase->m_bDevOpened = FALSE;
}else{
kernelInterface::s_cameraBase->m_bDevOpened = TRUE;kernelInterface::s_cameraBase-
>FillPropGridCtrl( &m_propGridCtrl_Camera );if( kernelInterface::s_cameraBase ){
kernelInterface::s_cameraBase->StartCapture();}
}}
UpCameraUI();
this->UpdateData(FALSE);}
void duCommonCameraDlg::UpCameraUI(){
if( kernelInterface::s_cameraBase->m_bDevOpened ){
m_btnOpenDevice.SetWindowTextW(L"关闭摄像机");m_ctrlIconCameraOpenoff.SetIcon( m_hIconRed );
}else{
m_btnOpenDevice.SetWindowTextW(L"打开摄像机");m_ctrlIconCameraOpenoff.SetIcon( m_hIconOff );
}}void duCommonCameraDlg::OnBnClickedMfcbuttonSaveImg(){
USES_CONVERSION;
CString strPre;SYSTEMTIME sysTime;GetLocalTime(&sysTime);strPre.Format( L"Captured%.4d_%.2d_%.2d_%.2d_%.2d_%.2d_%.3d.jpg",
sysTime.wYear,sysTime.wMonth,sysTime.wDay,
Maize Kernel Measurement software 40
sysTime.wHour,sysTime.wMinute,sysTime.wSecond,sysTime.wMilliseconds);
CString strFileName ;strFileName.Format( _T("%s\\%s"),
kernelInterface::s_kernel_param.m_strWorkPathName, strPre );
kernelInterface::s_cameraBase->SaveImage( strFileName);CString sError;kernelInterface::PictureWindows( strFileName, sError );ShellExecuteW(this->m_hWnd, L"open", L"mspaint.exe", (strFileName), L"",
SW_SHOW );}
void duCommonCameraDlg::OnBnClickedButtonAutoCalibration(){
if( kernelInterface::s_cameraBase->m_bDevOpened && kernelInterface::s_cameraBase->m_bIsSnap )
{double dPR=0.f;BOOL bSuc = kernelInterface::s_cameraBase-
>CalculatePixelResolutionByCoin( dPR,kernelInterface::s_nCameraImageWidth,kernelInterface::s_nCameraImageHeight);
if( bSuc && abs(dPR) > 1e-6 ){
CString strTip;
strTip.Format( _T("检测到圆直径为:%6.2f,按照一元硬币(直径 2.5cm)换算?"), dPR );
AfxGetApp()->m_pszAppName = _T("籽粒考种-分辨率自动校正");if( IDYES == AfxMessageBox(strTip, MB_ICONEXCLAMATION|
MB_YESNO ) ){
strTip.Format( _T("%.6f"), 2.5/dPR );m_strPixelResolution = strTip;
}}
}
Maize Kernel Measurement software 41
else{
CString strCalibrationFile = L"";LPCTSTR szFilter;
szFilter = _T(" 标 定 文 件 (*.jpg)|*.jpg|(*.png)|*.png|(*.bmp)|*.bmp|All(*.*)|*.*|");
CFileDialog cFileDialog(TRUE, NULL, NULL, OFN_ALLOWMULTISELECT|OFN_FILEMUSTEXIST|OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, szFilter);
CONST DWORD nMaxFile = 1024*1024; WCHAR* pbFileNameBuf = new WCHAR[nMaxFile]; if ( NULL == pbFileNameBuf ) {
return ; // E_OUTOFMEMORY } memset(pbFileNameBuf, 0, nMaxFile);
cFileDialog.m_pOFN->lpstrFile = pbFileNameBuf; cFileDialog.m_pOFN->nMaxFile = nMaxFile;
if ( IDOK == cFileDialog.DoModal() ) {
POSITION pos = cFileDialog.GetStartPosition(); while ( NULL != pos ) {
CString strName = cFileDialog.GetNextPathName(pos); strCalibrationFile = strName;
} }
if ( NULL != pbFileNameBuf ) {
delete[] pbFileNameBuf; pbFileNameBuf = NULL;
}
CFileFind finder;if( !finder.FindFile(strCalibrationFile) )
return;
{double dPR=0.f;BOOL bSuc = kernelInterface::s_cameraBase-
>CalculatePixelCalibration( strCalibrationFile, dPR );
Maize Kernel Measurement software 42
if( bSuc && abs(dPR) > 1e-6 ){
m_strPixelResolution.Format( _T(".6f"), dPR );// m_dPixelResolution = dPR;
}}
}
this->UpdateData(FALSE);}
void duCommonCameraDlg::OnBnClickedButtonModifyPixelResolution(){
USES_CONVERSION;this->UpdateData(TRUE);
double dPixelResolution = atof( W2A(m_strPixelResolution) ); if( abs(dPixelResolution) < 1e-9 || abs(dPixelResolution) > 1e8 ){
AfxMessageBox( L"像素尺寸不合理" );return;
}{
kernelInterface::s_kernel_param.dPhysicalResolution = dPixelResolution;
kernelInterface::s_kernel_param.writeini();}
}
INT_PTR duCommonCameraDlg::DoModal(){
return CBkDialogST::DoModal();}
BOOL duCommonCameraDlg::Create(LPCTSTR lpszTemplateName, CWnd* pParentWnd){
return CBkDialogST::Create(lpszTemplateName, pParentWnd);}
void duCommonCameraDlg::OnFinalRelease(){
CBkDialogST::OnFinalRelease();
Maize Kernel Measurement software 43
}
void duCommonCameraDlg::Serialize(CArchive& ar){
if (ar.IsStoring()){}else{}
}
BOOL duCommonCameraDlg::OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct){
return CBkDialogST::OnCopyData(pWnd, pCopyDataStruct);}
HBRUSH duCommonCameraDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor){
{HBRUSH hbr; switch (nCtlColor) { case CTLCOLOR_EDIT:case CTLCOLOR_MSGBOX:
switch (pWnd->GetDlgCtrlID()){ case IDC_EDIT_PIXEL_RESOLUTION: case IDC_EDIT_BK_PSNR:
pDC->SetBkColor(g_ui_bkcolor); pDC->SetBkMode(TRANSPARENT); pDC->SetTextColor(g_ui_redcolor); hbr =g_ui_bkbrush;break;
default: hbr=CDialog::OnCtlColor(pDC,pWnd,nCtlColor); break;
} break;
case CTLCOLOR_STATIC:case CTLCOLOR_BTN:case CTLCOLOR_LISTBOX:
switch (pWnd->GetDlgCtrlID())
Maize Kernel Measurement software 44
{ case IDC_STATIC:
pDC->SetBkMode( TRANSPARENT );pDC->SetTextColor(g_ui_bluecolor); hbr = (HBRUSH)::GetStockObject(NULL_BRUSH);
break;default:
hbr=CDialog::OnCtlColor(pDC,pWnd,nCtlColor);}break;
default:hbr=CDialog::OnCtlColor(pDC,pWnd,nCtlColor);
}return hbr; // return brush
}}void duCommonCameraDlg::OnPaint(){
CPaintDC dc(this); CRect rcClient;this->GetClientRect( &rcClient );CDC MemDC; CBitmap MemBitmap; MemDC.CreateCompatibleDC(&dc); MemBitmap.CreateCompatibleBitmap( &dc, rcClient.Width(),
rcClient.Height() ); CBitmap *pOldBit=MemDC.SelectObject(&MemBitmap); MemDC.FillSolidRect(0,0, rcClient.Width(),
rcClient.Height() ,RGB(204,236,255)); {
CString strTip = m_strObjName;int nFontHeight = 20;Gdiplus::Point pt;pt.X = 40;pt.Y = 10;DrawStringInStyle
(&MemDC,nFontHeight,pt,strTip,Gdiplus::Color(255,0,0),2,
_T("黑体")
Maize Kernel Measurement software 45
);}
dc.BitBlt(0,0, rcClient.Width(), rcClient.Height() ,&MemDC,0,0,SRCCOPY); MemBitmap.DeleteObject(); MemDC.DeleteDC();
}
void duCommonCameraDlg::DrawStringInStyle(CDC* pDC,int nFontHeight,Gdiplus::Point & pt,CString strTip,Gdiplus::Color clr,int nlineWid,CString strFont)
{Graphics graph(*pDC);Graphics graphics(*pDC);graphics.SetSmoothingMode(SmoothingModeAntiAlias);graphics.SetInterpolationMode(InterpolationModeHighQualityBicubic);
FontFamily fontFamily(/*L"黑体"*/ strFont );StringFormat strformat;
GraphicsPath path;path.AddString(
strTip ,wcslen(strTip ),&fontFamily,FontStyleRegular,nFontHeight,pt,&strformat);
Pen pen(Color(255,255,0,0),2 );pen.SetColor( clr );nlineWid = nlineWid <= 0 ? 1 :nlineWid;pen.SetWidth( nlineWid );graphics.DrawPath(&pen,&path);
}
void duCommonCameraDlg::OnSize(UINT nType, int cx, int cy){
CBkDialogST::OnSize(nType, cx, cy);
Maize Kernel Measurement software 46
}void duCommonCameraDlg::OnTimer(UINT_PTR nIDEvent){
CBkDialogST::OnTimer(nIDEvent);}void duCommonCameraDlg::OnStnClickedMfcpropertygridCamera(){}
#pragma once#include "streamcamera.h"#include "streamKernelSet.h"class AFX_CLASS_EXPORT duKernelCamera: public streamCamera{public:
duKernelCamera(void);~duKernelCamera(void);GX_FRAME_CALLBACK_PARAM *pMyCallback;
public:
public:virtual BOOL LoadCameraIni(){ return TRUE; };virtual BOOL SaveCameraIni(){return TRUE; };virtual BOOL OpenDevice();virtual BOOL CloseDevice(); virtual BOOL StartCapture();virtual BOOL StopCapture();virtual CString SaveImage( CString strFileName = L"" );virtual unsigned char* duGetPixelData(){
return m_pBufferRaw;};virtual unsigned char* duGetPixelDataRGB(){
return m_pBufferRGB;};
virtual BITMAPINFO* duGetBITMAPINFO(){return m_pBmpInfo;
};
virtual void UpdateObjFromPropList( CMFCPropertyGridCtrl* pGridPropertyCtrl, CMFCPropertyGridProperty *pGridProperty);
static void __stdcall OnFrameCallbackFun(GX_FRAME_CALLBACK_PARAM* pFrame);
Maize Kernel Measurement software 47
void ShowErrorString(GX_STATUS emErrorStatus);GX_STATUS InitDevice();GX_STATUS SetPixelFormat8bit();GX_STATUS GetDeviceParam();void GetImageImproveParam();bool PrepareForShowImg();void UnPrepareForShowImg();void InitEnumUI(
GX_FEATURE_ID emFeatureID, CComboBox *pComboBox, bool bIsImplement);
void InitEnumUI(GX_FEATURE_ID emFeatureID, CMFCPropertyGridProperty *pPropertyGrid, int nSelected // dujj now value);
void duDrawImage(BYTE *pImageBuf, int nImageSize) ;void duSaveImage();
BOOL SaveKernelImage( CString strImage );virtual void ForceUpdate();virtual DU_CAMERA_BASE_INFO GetCameraDescrip() ;
};
#include "StdAfx.h"#include "duKernelCamera.h"#include "duImageProcess_ITK.h"#include "CommonParams.h"#include "kernelDetectDlg.h"#include "kernelInterface.h"#define WHITE_BALANCE_RNTRY 3 #define GX_VERIFY(emStatus) \
if (emStatus != GX_STATUS_SUCCESS)\{\
ShowErrorString(emStatus); \return ;\
} #define GX_VERIFY_RETURN(emStatus) \
if (emStatus != GX_STATUS_SUCCESS)\{\
ShowErrorString(emStatus); \return FALSE;\
}
Maize Kernel Measurement software 48
#define VERIFY_STATUS_RET(emStatus) \if (emStatus != GX_STATUS_SUCCESS) \
{\return emStatus;\
}\
duKernelCamera::duKernelCamera( ):m_strFilePath(""){
kernelInterface::s_localObjMaskImage = NULL;pMyCallback = NULL;memset(m_chBmpBuf,0,sizeof(m_chBmpBuf));GX_STATUS emStatus = GX_STATUS_SUCCESS;emStatus = GXInitLib();if (emStatus != GX_STATUS_SUCCESS){
ShowErrorString(emStatus);exit(0);
}
CString strDate = L"";char szName[MAX_PATH] = {0};CString strAppFullName = L""; m_strFilePath = duImageProcess_ITK::GetModulePathName();
}
duKernelCamera::~duKernelCamera(void){
if( m_bDevOpened )CloseDevice();
if( pMyCallback ){
delete pMyCallback;pMyCallback = NULL;
}if( kernelInterface::s_localObjMaskImage ){
cvReleaseImage( &kernelInterface::s_localObjMaskImage );kernelInterface::s_localObjMaskImage = NULL;
}}
void duKernelCamera::ShowErrorString(GX_STATUS emErrorStatus){
Maize Kernel Measurement software 49
USES_CONVERSION;
char chErrorInof[512] = {0};size_t nSize = 512;GX_STATUS emStatus = GX_STATUS_ERROR;
emStatus = GXGetLastError (&emErrorStatus, chErrorInof, &nSize);if (emStatus != GX_STATUS_SUCCESS){
m_lbCameraInfo.AddItem( L"GXGetLastError接口调用失败!" );m_lbCameraInfo.SelectItem( m_lbCameraInfo.GetCount()-1);
MessageBox("GXGetLastError接口调用失败!");}else{
m_lbCameraInfo.AddItem( A2W(chErrorInof) );m_lbCameraInfo.SelectItem( m_lbCameraInfo.GetCount()-1);MessageBox((LPCTSTR)chErrorInof);
}}void duKernelCamera::InitEnumUI(GX_FEATURE_ID emFeatureID, CMFCPropertyGridProperty *pPropertyGrid,
int nSelected ){
USES_CONVERSION;if ((pPropertyGrid == NULL) )//|| !bIsImplement){
return;}
GX_ENUM_DESCRIPTION *pEnum = NULL;GX_STATUS emStatus = GX_STATUS_ERROR;size_t nbufferSize = 0;uint32_t nEntryNum = 0;int64_t nEnumValue = -1;int nCursel = 0;double dValue = 0;emStatus = GXGetEnumEntryNums(m_hDevice, emFeatureID, &nEntryNum);GX_VERIFY(emStatus);nbufferSize = nEntryNum * sizeof(GX_ENUM_DESCRIPTION);pEnum = new GX_ENUM_DESCRIPTION[nEntryNum];if (pEnum == NULL){
return;
Maize Kernel Measurement software 50
}
emStatus = GXGetEnumDescription(m_hDevice, emFeatureID, pEnum, &nbufferSize);
if (emStatus != GX_STATUS_SUCCESS){
if (pEnum != NULL){
delete []pEnum;pEnum = NULL;
}ShowErrorString(emStatus);return;
}
emStatus = GXGetEnum(m_hDevice, emFeatureID, &nEnumValue);if (emStatus != GX_STATUS_SUCCESS){
if (pEnum != NULL){
delete []pEnum;pEnum = NULL;
}ShowErrorString(emStatus);return;
}
for (uint32_t i = 0; i < nEntryNum; i++){
pPropertyGrid->AddOption( A2W(pEnum[i].szSymbolic), FALSE );pPropertyGrid->SetData( (uint32_t)pEnum[i].nValue );if (pEnum[i].nValue == nSelected){
nCursel = i;}
}
pPropertyGrid->SetValue( A2W(pEnum[nCursel].szSymbolic) );
if (pEnum != NULL){
delete []pEnum;pEnum = NULL;
}
Maize Kernel Measurement software 51
}
void duKernelCamera::FillPropGridCtrl( CMFCPropertyGridCtrl* pGridPropertyCtrl ){
USES_CONVERSION;if ( !pGridPropertyCtrl )
return;pGridPropertyCtrl->RemoveAll();
GX_FEATURE_ID emFeatureID = GX_ENUM_TRIGGER_MODE;
GX_ENUM_DESCRIPTION *pEnum = NULL;GX_STATUS emStatus = GX_STATUS_ERROR;size_t nbufferSize = 0;uint32_t nEntryNum = 0;int64_t nEnumValue = -1;int nCursel = 0;double dValue = 0;emStatus = GXGetEnumEntryNums(m_hDevice, emFeatureID, &nEntryNum);GX_VERIFY(emStatus);nbufferSize = nEntryNum * sizeof(GX_ENUM_DESCRIPTION);pEnum = new GX_ENUM_DESCRIPTION[nEntryNum];
if (pEnum == NULL){
return;}emStatus = GXGetEnum(m_hDevice, emFeatureID, &nEnumValue);
if (emStatus != GX_STATUS_SUCCESS){
if (pEnum != NULL){
delete []pEnum;pEnum = NULL;
}ShowErrorString(emStatus);return;
}
CString m_strDataTag = L"Test";{
CMFCPropertyGridProperty* pCurObj = new
Maize Kernel Measurement software 52
CMFCPropertyGridProperty(_T("基本信息"), 0, TRUE);{
{CMFCPropertyGridProperty* pProp = new
CMFCPropertyGridProperty(
_T("设备句柄"), (_variant_t) (int)m_hDevice,
_T("设备句柄"));pProp->AllowEdit( FALSE );pCurObj->AddSubItem(pProp);
}{
CMFCPropertyGridProperty* pProp = new CMFCPropertyGridProperty(
_T("图像大小"), (_variant_t) (int)m_nPayLoadSize,
_T("图像大小"));pProp->AllowEdit( FALSE );pCurObj->AddSubItem(pProp);
}{
CMFCPropertyGridProperty* pProp = new CMFCPropertyGridProperty(
_T("图像宽度"), (_variant_t) (int)kernelInterface::s_nCameraImageWidth,
_T("图像宽度"));pProp->AllowEdit( FALSE );pCurObj->AddSubItem(pProp);
}{
CMFCPropertyGridProperty* pProp = new CMFCPropertyGridProperty(
_T("图像高度"), (_variant_t) (int)kernelInterface::s_nCameraImageHeight,
_T("图像高度"));pProp->AllowEdit( FALSE );pCurObj->AddSubItem(pProp);
}}
pCurObj->Expand(FALSE);pGridPropertyCtrl->AddProperty(pCurObj);
}{
Maize Kernel Measurement software 53
int nVal = 10;CMFCPropertyGridProperty* pCurObj = new
CMFCPropertyGridProperty(_T("参数调控"), 0, TRUE);{
GX_STATUS emStatus = GX_STATUS_ERROR;CString strTemp = L"";double dValue = 0.0;GX_FLOAT_RANGE stFloatRange;emStatus = GXGetFloatRange(m_hDevice, GX_FLOAT_EXPOSURE_TIME,
&stFloatRange);GX_VERIFY(emStatus);
if (stFloatRange.dInc == 0){
return;}
kernelInterface::s_kernel_param.m_dShutterInc = stFloatRange.dInc;
nVal = (int)kernelInterface::s_kernel_param.m_dExposure;
strTemp.Format( L" 曝 光 (%.2f~%.2f)%s", stFloatRange.dMin, stFloatRange.dMax, A2W(stFloatRange.szUnit));
CMFCPropertyGridProperty* pProp = new CMFCPropertyGridProperty(
_T("曝光"), (_variant_t) (int)nVal, strTemp );
pProp->EnableSpinControl(TRUE, (int)(stFloatRange.dMin / kernelInterface::s_kernel_param.m_dShutterInc), (int)(stFloatRange.dMax / kernelInterface::s_kernel_param.m_dShutterInc));
pCurObj->AddSubItem(pProp);emStatus = GXSetFloat( m_hDevice, GX_FLOAT_EXPOSURE_TIME,
kernelInterface::s_kernel_param.m_dExposure);}
{GX_STATUS emStatus = GX_STATUS_ERROR;CString strRange = L"";double dGainVal = 0;GX_FLOAT_RANGE stFloatRange;emStatus = GXGetFloatRange(m_hDevice, GX_FLOAT_GAIN,
&stFloatRange);GX_VERIFY(emStatus);
if (stFloatRange.dInc == 0)
Maize Kernel Measurement software 54
{return;
}kernelInterface::s_kernel_param.m_dGainInc = stFloatRange.dInc;nVal = (int)(dGainVal /
kernelInterface::s_kernel_param.m_dGainInc);
strRange.Format( L" 增 益 (%.2f~%.2f)", stFloatRange.dMin, stFloatRange.dMax);
CMFCPropertyGridProperty* pProp = new CMFCPropertyGridProperty(
_T("增益"), (_variant_t) nVal, strRange);
pProp->EnableSpinControl(TRUE, (int)(stFloatRange.dMin/kernelInterface::s_kernel_param.m_dGainInc), (int)(stFloatRange.dMax/kernelInterface::s_kernel_param.m_dGainInc) );
pProp->AllowEdit( TRUE );pCurObj->Expand(TRUE);pCurObj->AddSubItem(pProp);emStatus = GXSetFloat( m_hDevice, GX_FLOAT_GAIN,
kernelInterface::s_kernel_param.m_dGain);}
pGridPropertyCtrl->AddProperty(pCurObj);}{
CString strStatus = L"On";CMFCPropertyGridProperty* pCurObj = new
CMFCPropertyGridProperty(_T("白平衡"), 0, TRUE);{
CMFCPropertyGridProperty* pProp = new CMFCPropertyGridProperty(
_T("自动白平衡"), (_variant_t) strStatus,
_T("自动白平衡:ON or OFF"));InitEnumUI(
GX_ENUM_BALANCE_WHITE_AUTO, pProp, kernelInterface::s_kernel_param.m_nAutoWhiteBalance);
pCurObj->AddSubItem(pProp);}{
CMFCPropertyGridProperty* pProp = new CMFCPropertyGridProperty(
Maize Kernel Measurement software 55
_T("白平衡通道"), (_variant_t) strStatus,
_T("白平衡通道"));InitEnumUI(
GX_ENUM_BALANCE_RATIO_SELECTOR, pProp, kernelInterface::s_kernel_param.m_nRatioSelector);
pProp->AllowEdit( TRUE );pCurObj->AddSubItem(pProp);
}{
GX_STATUS emStatus = GX_STATUS_SUCCESS;double dValue = 0.0;CString strTemp = _T(""), strTemp2 = _T("");;GX_FLOAT_RANGE stFloatRange;emStatus =
GXGetFloatRange(m_hDevice,GX_FLOAT_BALANCE_RATIO,&stFloatRange);GX_VERIFY(emStatus);
strTemp.Format( L" 白 平 衡 系 数 (%.2f~%.2f)",stFloatRange.dMin,stFloatRange.dMax);
emStatus = GXGetFloat(m_hDevice, GX_FLOAT_BALANCE_RATIO, &dValue);
GX_VERIFY(emStatus);
kernelInterface::s_kernel_param.m_dBalanceRatio = dValue;CMFCPropertyGridProperty* pProp = new CMFCPropertyGridProperty(
_T("白平衡系数"), (_variant_t) kernelInterface::s_kernel_param.m_dBalanceRatio, strTemp);
pProp->AllowEdit( TRUE );pCurObj->AddSubItem(pProp);
}pCurObj->Expand(TRUE);pGridPropertyCtrl->AddProperty(pCurObj);
}{
CMFCPropertyGridProperty* pCurObj = new
CMFCPropertyGridProperty(_T("触发控制"), 0, TRUE);{
CMFCPropertyGridProperty* pProp = new CMFCPropertyGridProperty(
Maize Kernel Measurement software 56
_T("触发模式"), (_variant_t) m_strDataTag,
_T("文件头"));InitEnumUI(
GX_ENUM_TRIGGER_MODE, pProp, kernelInterface::s_kernel_param.m_bTriggerMode);
pProp->AllowEdit( FALSE );pCurObj->AddSubItem(pProp);
}{
CMFCPropertyGridProperty* pProp = new CMFCPropertyGridProperty(
_T("触发源"), (_variant_t) m_strDataTag,
_T("文件头"));InitEnumUI(
GX_ENUM_TRIGGER_SOURCE, pProp, kernelInterface::s_kernel_param.m_bTriggerSource);
pProp->AllowEdit( FALSE );pCurObj->AddSubItem(pProp);
}{
CMFCPropertyGridProperty* pProp = new CMFCPropertyGridProperty(
_T("触发极性"), (_variant_t) m_strDataTag,
_T("文件头"));InitEnumUI(
GX_ENUM_TRIGGER_ACTIVATION, pProp, kernelInterface::s_kernel_param.m_bTriggerActive);
pProp->AllowEdit( FALSE );pCurObj->AddSubItem(pProp);
}
pCurObj->AllowEdit( FALSE );pCurObj->Expand(FALSE);pGridPropertyCtrl->AddProperty(pCurObj);
Maize Kernel Measurement software 57
}
if (pEnum != NULL){
delete []pEnum;pEnum = NULL;
}{
GX_STATUS emStatus = GX_STATUS_SUCCESS;emStatus = GXSetEnum( m_hDevice, GX_ENUM_TRIGGER_MODE,
kernelInterface::s_kernel_param.m_bTriggerMode);emStatus = GXSetEnum( m_hDevice, GX_ENUM_TRIGGER_SOURCE,
kernelInterface::s_kernel_param.m_bTriggerSource);emStatus = GXSetEnum( m_hDevice, GX_ENUM_TRIGGER_ACTIVATION,
kernelInterface::s_kernel_param.m_bTriggerActive);
emStatus = GXSetEnum( m_hDevice, GX_ENUM_BALANCE_WHITE_AUTO, kernelInterface::s_kernel_param.m_nAutoWhiteBalance);
emStatus = GXSetEnum( m_hDevice, GX_ENUM_BALANCE_RATIO_SELECTOR, kernelInterface::s_kernel_param.m_nRatioSelector);
emStatus = GXSetFloat( m_hDevice, GX_FLOAT_BALANCE_RATIO, kernelInterface::s_kernel_param.m_dBalanceRatio);
emStatus = GXSetFloat( m_hDevice, GX_FLOAT_EXPOSURE_TIME, kernelInterface::s_kernel_param.m_dExposure);
emStatus = GXSetFloat( m_hDevice, GX_FLOAT_GAIN, kernelInterface::s_kernel_param.m_dGain);
}}void duKernelCamera::ForceUpdate(){
if( !m_bDevOpened )return;
{GX_STATUS emStatus = GX_STATUS_ERROR;int64_t nValue = 0;emStatus = GXSetFloat(m_hDevice,GX_FLOAT_EXPOSURE_TIME,
kernelInterface::s_kernel_param.m_dExposure);}{
GX_STATUS emStatus = GX_STATUS_ERROR;int64_t nValue = 0;
emStatus = GXSetFloat(m_hDevice, GX_FLOAT_GAIN,
Maize Kernel Measurement software 58
kernelInterface::s_kernel_param.m_dGain);}
}void duKernelCamera::UpdateObjFromPropList( CMFCPropertyGridCtrl* pGridPropertyCtrl, CMFCPropertyGridProperty *pGridProperty){
CString name = pGridProperty->GetName();COleVariant oleval = pGridProperty->GetValue();double dChanged;bool bChanged;
if ( name.CompareNoCase( _T("触发模式")) == 0 ){
GX_STATUS emStatus = GX_STATUS_SUCCESS;CString strStatus = oleval.bstrVal;int64_t nEnumVal = (int64_t)pGridProperty->GetData();if( strStatus.CompareNoCase(L"Off") == 0 ){
nEnumVal = GX_TRIGGER_MODE_OFF;}else{
nEnumVal = GX_TRIGGER_MODE_ON;}emStatus = GXSetEnum( m_hDevice, GX_ENUM_TRIGGER_MODE, nEnumVal);
kernelInterface::s_kernel_param.m_bTriggerMode = nEnumVal;}
if ( name.CompareNoCase( _T("触发源")) == 0 ){
GX_STATUS emStatus = GX_STATUS_SUCCESS;CString strStatus = oleval.bstrVal;int64_t nEnumVal = (int64_t)pGridProperty->GetData();if( strStatus.CompareNoCase(L"Software") == 0 ){
nEnumVal = GX_TRIGGER_SOURCE_SOFTWARE;}else{
nEnumVal = GX_TRIGGER_SOURCE_LINE0;}emStatus = GXSetEnum( m_hDevice, GX_ENUM_TRIGGER_SOURCE, nEnumVal);kernelInterface::s_kernel_param.m_bTriggerSource = nEnumVal;
}
Maize Kernel Measurement software 59
if ( name.CompareNoCase( _T("触发极性")) == 0 ){
GX_STATUS emStatus = GX_STATUS_SUCCESS;CString strStatus = oleval.bstrVal;int64_t nEnumVal = (int64_t)pGridProperty->GetData();if( strStatus.CompareNoCase(L"RisingEdge") == 0 ){
nEnumVal = GX_TRIGGER_ACTIVATION_FALLINGEDGE;}else{
nEnumVal = GX_TRIGGER_ACTIVATION_RISINGEDGE;}emStatus = GXSetEnum( m_hDevice, GX_ENUM_TRIGGER_ACTIVATION,
nEnumVal);kernelInterface::s_kernel_param.m_bTriggerActive = nEnumVal;
}
if ( name.CompareNoCase( _T("自动白平衡")) == 0 ){
GX_STATUS emStatus = GX_STATUS_SUCCESS;CString strStatus = oleval.bstrVal;int64_t nEnumVal = (int64_t)pGridProperty->GetData();if( strStatus.CompareNoCase(L"Off") == 0 ){
nEnumVal = GX_BALANCE_WHITE_AUTO_OFF;}else if( strStatus.CompareNoCase(L"Continuous") == 0 ){
nEnumVal = GX_BALANCE_WHITE_AUTO_CONTINUOUS;}else{
nEnumVal = GX_BALANCE_WHITE_AUTO_ONCE;}emStatus = GXSetEnum(m_hDevice, GX_ENUM_BALANCE_WHITE_AUTO,
nEnumVal);GX_VERIFY(emStatus);kernelInterface::s_kernel_param.m_nAutoWhiteBalance = (int)nEnumVal;
}
if ( name.CompareNoCase( _T("白平衡通道")) == 0 ){
GX_STATUS emStatus = GX_STATUS_SUCCESS;CString strStatus = oleval.bstrVal;int64_t nEnumVal = pGridProperty->GetData();
Maize Kernel Measurement software 60
if( strStatus.CompareNoCase(L"Red") == 0 ){
nEnumVal = GX_BALANCE_RATIO_SELECTOR_RED;}else if( strStatus.CompareNoCase(L"Green") == 0 ){
nEnumVal = GX_BALANCE_RATIO_SELECTOR_GREEN;}else{
nEnumVal = GX_BALANCE_RATIO_SELECTOR_BLUE;}emStatus = GXSetEnum(m_hDevice, GX_ENUM_BALANCE_RATIO_SELECTOR,
nEnumVal);kernelInterface::s_kernel_param.m_nRatioSelector = nEnumVal;
}
if ( name.CompareNoCase( _T("白平衡系数")) == 0 ){
kernelInterface::s_kernel_param.m_dBalanceRatio = oleval.dblVal;GX_STATUS emStatus = GX_STATUS_SUCCESS;emStatus =
GXSetFloat(m_hDevice,GX_FLOAT_BALANCE_RATIO,kernelInterface::s_kernel_param.m_dBalanceRatio);
}
if ( name.CompareNoCase( _T("曝光")) == 0 ){
GX_STATUS emStatus = GX_STATUS_ERROR;int64_t nValue = 0;nValue = oleval.intVal;
kernelInterface::s_kernel_param.m_dExposure = nValue * kernelInterface::s_kernel_param.m_dShutterInc;
emStatus = GXSetFloat(m_hDevice,GX_FLOAT_EXPOSURE_TIME, kernelInterface::s_kernel_param.m_dExposure);
}
if ( name.CompareNoCase( _T("增益")) == 0 ){
GX_STATUS emStatus = GX_STATUS_ERROR;int64_t nValue = 0;nValue = oleval.intVal;kernelInterface::s_kernel_param.m_dGain = nValue *
kernelInterface::s_kernel_param.m_dGainInc;emStatus = GXSetFloat(m_hDevice, GX_FLOAT_GAIN,
kernelInterface::s_kernel_param.m_dGain);
Maize Kernel Measurement software 61
}
return ;}BOOL duKernelCamera::OpenDevice(){
GX_STATUS emStatus = GX_STATUS_SUCCESS;uint32_t nDevNum = 0;GX_OPEN_PARAM stOpenParam;stOpenParam.accessMode = GX_ACCESS_EXCLUSIVE;stOpenParam.openMode = GX_OPEN_INDEX;stOpenParam.pszContent = "1";emStatus = GXUpdateDeviceList(&nDevNum, 1000);if (emStatus != GX_STATUS_SUCCESS){
return FALSE;}if (nDevNum <= 0){
return FALSE;}emStatus = GXOpenDevice(&stOpenParam, &m_hDevice);if (emStatus != GX_STATUS_SUCCESS){
return FALSE;}m_bDevOpened = TRUE;emStatus = InitDevice();if (emStatus != GX_STATUS_SUCCESS){
return FALSE;}emStatus = GetDeviceParam();if (emStatus != GX_STATUS_SUCCESS){
return FALSE;}GetImageImproveParam();kernelInterface::s_kernel_param.UpdateDataAccordingToCam();return TRUE;
}
BOOL duKernelCamera::StartCapture(){
Maize Kernel Measurement software 62
GX_STATUS emStatus = GX_STATUS_ERROR;if( m_bIsSnap ){
StopCapture();}if (! PrepareForShowImg()){
AfxMessageBox(L"为图像显示分配资源失败!");return FALSE;
}emStatus = GXRegisterCaptureCallback((GX_DEV_HANDLE)m_hDevice, this,
OnFrameCallbackFun);if (emStatus != GX_STATUS_SUCCESS){
UnPrepareForShowImg();ShowErrorString(emStatus);return FALSE;
}emStatus = GXSendCommand((GX_DEV_HANDLE)m_hDevice,
GX_COMMAND_ACQUISITION_START);if (emStatus != GX_STATUS_SUCCESS){
UnPrepareForShowImg();ShowErrorString(emStatus);return FALSE;
}m_bIsSnap = TRUE;return TRUE;
}BOOL duKernelCamera::StopCapture(){
GX_STATUS emStatus = GX_STATUS_SUCCESS;emStatus = GXSendCommand((GX_DEV_HANDLE)m_hDevice,
GX_COMMAND_ACQUISITION_STOP);if (emStatus != GX_STATUS_SUCCESS)
return FALSE;emStatus = GXUnregisterCaptureCallback((GX_DEV_HANDLE)m_hDevice);if (emStatus != GX_STATUS_SUCCESS)
return FALSE;return TRUE;m_bIsSnap = FALSE;
UnPrepareForShowImg();
Maize Kernel Measurement software 63
}GX_STATUS duKernelCamera::InitDevice(){
GX_STATUS emStatus = GX_STATUS_SUCCESS;emStatus = GXSetEnum(m_hDevice,GX_ENUM_ACQUISITION_MODE,
GX_ACQ_MODE_CONTINUOUS);VERIFY_STATUS_RET(emStatus);emStatus = SetPixelFormat8bit(); return emStatus;
}GX_STATUS duKernelCamera::SetPixelFormat8bit(){
GX_STATUS emStatus = GX_STATUS_SUCCESS;int64_t nPixelSize = 0;uint32_t nEnmuEntry = 0;size_t nBufferSize = 0;BOOL bIs8bit = TRUE;GX_ENUM_DESCRIPTION *pEnumDescription = NULL;GX_ENUM_DESCRIPTION *pEnumTemp = NULL;emStatus = GXGetEnum(m_hDevice, GX_ENUM_PIXEL_SIZE, &nPixelSize);VERIFY_STATUS_RET(emStatus);if (nPixelSize == GX_PIXEL_SIZE_BPP8){
return GX_STATUS_SUCCESS;}else{
emStatus = GXGetEnumEntryNums(m_hDevice, GX_ENUM_PIXEL_FORMAT, &nEnmuEntry);
VERIFY_STATUS_RET(emStatus);nBufferSize = nEnmuEntry * sizeof(GX_ENUM_DESCRIPTION);pEnumDescription = new GX_ENUM_DESCRIPTION[nEnmuEntry];emStatus = GXGetEnumDescription(m_hDevice,
GX_ENUM_PIXEL_FORMAT, pEnumDescription, &nBufferSize);if (emStatus != GX_STATUS_SUCCESS){
if (pEnumDescription != NULL){
delete []pEnumDescription;pEnumDescription = NULL;
}
return emStatus;}
Maize Kernel Measurement software 64
for (uint32_t i = 0; i<nEnmuEntry; i++){
if ((pEnumDescription[i].nValue & GX_PIXEL_8BIT) == GX_PIXEL_8BIT)
{emStatus = GXSetEnum(m_hDevice, GX_ENUM_PIXEL_FORMAT,
pEnumDescription[i].nValue);break;
}}if (pEnumDescription != NULL){
delete []pEnumDescription;pEnumDescription = NULL;
}}
return emStatus;}GX_STATUS duKernelCamera::GetDeviceParam(){
GX_STATUS emStatus = GX_STATUS_ERROR;bool bColorFliter = false;
int64_t nImageHeight; ///< 原始图像高int64_t nImageWidth; ///< 原始图像宽emStatus = GXGetInt(m_hDevice, GX_INT_PAYLOAD_SIZE, &m_nPayLoadSize);VERIFY_STATUS_RET(emStatus);emStatus = GXGetInt(m_hDevice, GX_INT_WIDTH, &nImageWidth);VERIFY_STATUS_RET(emStatus);bool bsupported = kernelInterface::s_kernel_param.m_bColorFilter;emStatus = GXIsImplemented(m_hDevice, GX_ENUM_PIXEL_COLOR_FILTER, &
bsupported); kernelInterface::s_kernel_param.m_bColorFilter = bsupported;VERIFY_STATUS_RET(emStatus);if (kernelInterface::s_kernel_param.m_bColorFilter){
emStatus = GXGetEnum(m_hDevice, GX_ENUM_PIXEL_COLOR_FILTER, &m_nPixelColorFilter);
VERIFY_STATUS_RET(emStatus);}bsupported = kernelInterface::s_kernel_param.m_bBalanceRatioSelector; emStatus = GXIsImplemented(m_hDevice, GX_ENUM_BALANCE_RATIO_SELECTOR, &
bsupported); kernelInterface::s_kernel_param.m_bColorFilter = bsupported;VERIFY_STATUS_RET(emStatus);emStatus = GXGetInt(m_hDevice, GX_INT_HEIGHT, &nImageHeight);
Maize Kernel Measurement software 65
kernelInterface::s_nCameraImageHeight = nImageHeight;kernelInterface::s_nCameraImageWidth = nImageWidth;
return emStatus;}void duKernelCamera::GetImageImproveParam(){
if (!kernelInterface::s_kernel_param.m_bColorFilter){
return;}
GX_STATUS emStatus = GX_STATUS_SUCCESS;VxInt32 nStatus = DX_OK;emStatus = GXGetInt(m_hDevice, GX_INT_CONTRASTPARAM, &m_nContrast);if (emStatus != GX_STATUS_SUCCESS){
return ;}emStatus = GXGetInt(m_hDevice, GX_INT_COLORCORRECTIONPARAM,
&m_nColorCorrection);if (emStatus != GX_STATUS_SUCCESS){
return ;}emStatus = GXGetFloat(m_hDevice, GX_FLOAT_GAMMAPARAM,
&kernelInterface::s_kernel_param.m_dGamma);if (emStatus != GX_STATUS_SUCCESS){
return ;}do {
nStatus = DxGetGammatLut(kernelInterface::s_kernel_param.m_dGamma, NULL, &m_nLutLength);
if (nStatus != DX_OK){
break;}m_pGammaLut = new BYTE[m_nLutLength];if (m_pGammaLut == NULL){
nStatus = DX_NOT_ENOUGH_SYSTEM_MEMORY;break;
Maize Kernel Measurement software 66
}nStatus = DxGetGammatLut(kernelInterface::s_kernel_param.m_dGamma,
m_pGammaLut, &m_nLutLength);if (nStatus != DX_OK){
break;}nStatus =
DxGetContrastLut((int)kernelInterface::s_kernel_param.m_nContrast, NULL, &m_nLutLength);
if (nStatus != DX_OK){
break;}m_pContrastLut = new BYTE[m_nLutLength];if (m_pContrastLut == NULL){
nStatus = DX_NOT_ENOUGH_SYSTEM_MEMORY;break;
}nStatus =
DxGetContrastLut((int)kernelInterface::s_kernel_param.m_nContrast, m_pContrastLut, &m_nLutLength);
if (nStatus != DX_OK){
break;}
} while (0);if (nStatus != DX_OK){
if (m_pGammaLut != NULL){
delete[] m_pGammaLut;m_pGammaLut = NULL;
}if (m_pContrastLut != NULL){
delete[] m_pContrastLut;m_pContrastLut = NULL;
}return;
}}BOOL duKernelCamera::CloseDevice()
Maize Kernel Measurement software 67
{GX_STATUS emStatus = GX_STATUS_SUCCESS;if (m_bIsSnap){
emStatus = GXSendCommand(m_hDevice, GX_COMMAND_ACQUISITION_STOP);if (emStatus != GX_STATUS_SUCCESS){
return FALSE;}emStatus = GXUnregisterCaptureCallback(m_hDevice);if (emStatus != GX_STATUS_SUCCESS){
return FALSE;}m_bIsSnap = FALSE;UnPrepareForShowImg();
}emStatus = GXCloseDevice(m_hDevice);if (emStatus != GX_STATUS_SUCCESS){
return FALSE;}m_bDevOpened = FALSE;m_hDevice = NULL;if (m_pGammaLut != NULL){
delete[] m_pGammaLut;m_pGammaLut = NULL;
}if (m_pContrastLut != NULL){
delete[] m_pContrastLut;m_pContrastLut = NULL;
}return TRUE;
}void duKernelCamera::InitEnumUI(GX_FEATURE_ID emFeatureID, CComboBox *pComboBox, bool bIsImplement){
USES_CONVERSION;if ((pComboBox == NULL) || !bIsImplement){
return;}
Maize Kernel Measurement software 68
GX_ENUM_DESCRIPTION *pEnum = NULL;GX_STATUS emStatus = GX_STATUS_ERROR;size_t nbufferSize = 0;uint32_t nEntryNum = 0;int64_t nEnumValue = -1;int nCursel = 0;double dValue = 0;emStatus = GXGetEnumEntryNums(m_hDevice, emFeatureID, &nEntryNum);GX_VERIFY(emStatus);nbufferSize = nEntryNum * sizeof(GX_ENUM_DESCRIPTION);pEnum = new GX_ENUM_DESCRIPTION[nEntryNum];if (pEnum == NULL){
return;}
emStatus = GXGetEnumDescription(m_hDevice, emFeatureID, pEnum, &nbufferSize);
if (emStatus != GX_STATUS_SUCCESS){
if (pEnum != NULL){
delete []pEnum;pEnum = NULL;
}ShowErrorString(emStatus);return;
}emStatus = GXGetEnum(m_hDevice, emFeatureID, &nEnumValue);if (emStatus != GX_STATUS_SUCCESS){
if (pEnum != NULL){
delete []pEnum;pEnum = NULL;
}ShowErrorString(emStatus);return;
}pComboBox->ResetContent();for (uint32_t i = 0; i < nEntryNum; i++){
pComboBox->SetItemData(pComboBox->AddString( A2W(pEnum[i].szSymbolic) ), (uint32_t)pEnum[i].nValue);
Maize Kernel Measurement software 69
if (pEnum[i].nValue == nEnumValue){
nCursel = i;}
}pComboBox->SetCurSel(nCursel);if (pEnum != NULL){
delete []pEnum;pEnum = NULL;
}}bool duKernelCamera::PrepareForShowImg(){
m_pBmpInfo = (BITMAPINFO *)m_chBmpBuf;m_pBmpInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);m_pBmpInfo->bmiHeader.biWidth =
(LONG)kernelInterface::s_nCameraImageWidth;m_pBmpInfo->bmiHeader.biHeight =
(LONG)kernelInterface::s_nCameraImageHeight;
m_pBmpInfo->bmiHeader.biPlanes = 1;m_pBmpInfo->bmiHeader.biBitCount = 24;m_pBmpInfo->bmiHeader.biCompression = BI_RGB;m_pBmpInfo->bmiHeader.biSizeImage = 0;m_pBmpInfo->bmiHeader.biXPelsPerMeter = 0;m_pBmpInfo->bmiHeader.biYPelsPerMeter = 0;m_pBmpInfo->bmiHeader.biClrUsed = 0;m_pBmpInfo->bmiHeader.biClrImportant = 0;m_pBufferRGB = new BYTE[(size_t)(kernelInterface::s_nCameraImageWidth *
kernelInterface::s_nCameraImageHeight * 3)];if (m_pBufferRGB == NULL){
return false;}m_pBufferRaw = new BYTE[(size_t)m_nPayLoadSize];if (m_pBufferRaw == NULL){
delete []m_pBufferRGB;m_pBufferRGB = NULL;return false;
}return true;
}
Maize Kernel Measurement software 70
void duKernelCamera::UnPrepareForShowImg(){
if (m_pBufferRGB != NULL){
delete []m_pBufferRGB;m_pBufferRGB = NULL;
}if (m_pBufferRaw != NULL){
delete []m_pBufferRaw;m_pBufferRaw = NULL;
}}CString duKernelCamera::SaveImage(CString strFileName) {
DWORD dwImageSize = (DWORD)(kernelInterface::s_nCameraImageWidth * kernelInterface::s_nCameraImageHeight * 3);
BITMAPFILEHEADER stBfh = {0};DWORD dwBytesRead = 0;SYSTEMTIME sysTime;if( strFileName.CompareNoCase( _T("")) == 0 ){
GetLocalTime(&sysTime);strFileName.Format( L"%s\\old_Captured%.4d_%.2d_%.2d_%.2d_%.2d_%.2d_
%.3d.bmp", kernelInterface::s_kernel_param.m_strWorkPathName,sysTime.wYear,sysTime.wMonth,sysTime.wDay,sysTime.wHour,sysTime.wMinute,sysTime.wSecond,sysTime.wMilliseconds);
}stBfh.bfType = (WORD)'M' << 8 | 'B';stBfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);stBfh.bfSize = stBfh.bfOffBits + dwImageSize; HANDLE hFile = ::CreateFile(strFileName,
GENERIC_WRITE,0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,
Maize Kernel Measurement software 71
NULL);if (hFile != INVALID_HANDLE_VALUE) {
::WriteFile(hFile, &stBfh, sizeof(BITMAPFILEHEADER), &dwBytesRead, NULL);
::WriteFile(hFile, m_pBmpInfo, sizeof(BITMAPINFOHEADER), &dwBytesRead, NULL);
::WriteFile(hFile, m_pBufferRGB, dwImageSize, &dwBytesRead, NULL);
CloseHandle(hFile);}return strFileName;
}
BOOL duKernelCamera::SaveKernelImage( CString strImage ){
USES_CONVERSION;if( !m_pBufferRGB )
return FALSE;
IplImage* iplImage = cvCreateImageHeader(cvSize(kernelInterface::s_nCameraImageWidth,kernelInterface::s_nCameraImageHeight),
IPL_DEPTH_8U,3);
cvSetData(iplImage, m_pBufferRGB,3*kernelInterface::s_nCameraImageWidth);
CvRect rcROI;rcROI.x = 0;rcROI.y = 0;rcROI.width = kernelInterface::s_nCameraImageWidth;rcROI.height = kernelInterface::s_nCameraImageHeight;cvSetImageROI( iplImage, rcROI );cvSaveImage( W2A(strImage), iplImage );cvReleaseImageHeader( &iplImage );return TRUE;
}