@file base: VKObject.h 单一绘制图元基类 **/10.1007/s110… · Web viewIplImage* pSubObject, CvPoint pt1, CvPoint pt2, double & dScale, double & dMaxArea,

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"


#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_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(){


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 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;


}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,&center,&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 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 );


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 );


cvErode( kernelInterface::s_localObjMaskImage, kernelInterface::s_localObjMaskImage, NULL, kernelInterface::s_kernel_param.n_dKernelMorphSize*2 );


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 );




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;{


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,&center,&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 );

}


{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,&center,&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);

}}


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));


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,&center,&radius );ki.center = center;ki,radius = radius;vecMultiSeg.push_back(ki);

}}



{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);


cvFindContours( pKernelImage,storage, &contour,sizeof( CvContour ),mode,CV_CHAIN_APPROX_NONE,cvPoint(0,0))

std::vector<double> vecArea;std::vector<CvScalar> vecScalar;


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,&center,&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); // 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


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


|| 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;}


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(){


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 ){


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(){


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,


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;

}}

}


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 );


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();


}

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())


{ 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("黑体")


);}

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);


}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);


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;\

}


#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){


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;


}

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){



}

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){


}


}

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 (pEnum != NULL){



}

CString m_strDataTag = L"Test";{

CMFCPropertyGridProperty* pCurObj = new


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);

}{


_T("图像宽度"), (_variant_t) (int)kernelInterface::s_nCameraImageWidth,

_T("图像宽度"));pProp->AllowEdit( FALSE );pCurObj->AddSubItem(pProp);

}{


_T("图像高度"), (_variant_t) (int)kernelInterface::s_nCameraImageHeight,

_T("图像高度"));pProp->AllowEdit( FALSE );pCurObj->AddSubItem(pProp);

}}

pCurObj->Expand(FALSE);pGridPropertyCtrl->AddProperty(pCurObj);

}{


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));


_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)


{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);


_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);{


_T("自动白平衡"), (_variant_t) strStatus,

_T("自动白平衡：ON or OFF"));InitEnumUI(

GX_ENUM_BALANCE_WHITE_AUTO, pProp, kernelInterface::s_kernel_param.m_nAutoWhiteBalance);

pCurObj->AddSubItem(pProp);}{



_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);{



_T("触发模式"), (_variant_t) m_strDataTag,

_T("文件头"));InitEnumUI(

GX_ENUM_TRIGGER_MODE, pProp, kernelInterface::s_kernel_param.m_bTriggerMode);

pProp->AllowEdit( FALSE );pCurObj->AddSubItem(pProp);

}{


_T("触发源"), (_variant_t) m_strDataTag,


GX_ENUM_TRIGGER_SOURCE, pProp, kernelInterface::s_kernel_param.m_bTriggerSource);


}{


_T("触发极性"), (_variant_t) m_strDataTag,


GX_ENUM_TRIGGER_ACTIVATION, pProp, kernelInterface::s_kernel_param.m_bTriggerActive);


}

pCurObj->AllowEdit( FALSE );pCurObj->Expand(FALSE);pGridPropertyCtrl->AddProperty(pCurObj);


}

if (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,


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;

}


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();


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);


}

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(){


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();


}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;}


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);


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;


}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);


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);


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()


{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;}


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 (pEnum != NULL){



}emStatus = GXGetEnum(m_hDevice, emFeatureID, &nEnumValue);if (emStatus != GX_STATUS_SUCCESS){

if (pEnum != NULL){



}pComboBox->ResetContent();for (uint32_t i = 0; i < nEntryNum; i++){

pComboBox->SetItemData(pComboBox->AddString( A2W(pEnum[i].szSymbolic) ), (uint32_t)pEnum[i].nValue);


if (pEnum[i].nValue == nEnumValue){

nCursel = i;}

}pComboBox->SetCurSel(nCursel);if (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;

}


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,


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;

}

Documents

@file base: VKObject.h 单一绘制图元基类 **/10.1007/s110… · Web viewIplImage* pSubObject, CvPoint pt1, CvPoint pt2, double & dScale, double & dMaxArea,