Maize Kernel Measurement software 1
Maize Kernel Measurement software V2.0
source code
Beijing Research Center for Information Technology in Agriculture
#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"
#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 )
{
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_kernelSystem
kernelInterface::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()
{
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);
}
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;
}
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(
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 axis
CvPoint &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;
}
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;
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;
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, 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)
);
}
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), 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 axis
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 );
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;
}
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();
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;
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++ )
{
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
{
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 );
{
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 );
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;
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;
{
{
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;
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
{
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 > 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;
}
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),
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);
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(
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, 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)
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();
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*/)
: 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, &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); // red
g_ui_bluecolor=RGB(0,0,255); // blue
g_ui_bkcolor=RGB(11,22,44); // blue
g_ui_textcolor=RGB(0,0,255); // white text
g_ui_redbrush .CreateSolidBrush(g_ui_redcolor); // red background
g_ui_bluebrush .CreateSolidBrush(g_ui_bluecolor); // blue background
g_ui_bkbrush .CreateSolidBrush(g_ui_bkcolor); // blue background
m_strPixelResolution.Format( _T("%.6f"), kernelInterface::s_kernel_param.dPhysicalResolution );