huago-corrcet_tools/HuaGoCorrect/HuaGoCorrectDlg.cpp

// HuaGoCorrectDlg.cpp : 实现文件
//

#include "stdafx.h"
#include "HuaGoCorrect.h"
#include "HuaGoCorrectDlg.h"
#include "afxdialogex.h"
#include "scn_config.h"
#include <numeric>
#include "imageprocess.h"
#include "ImageApplyHeaders.h"

using namespace std;

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

#define N_TIME_SEC 1000 //一秒时间间隔
#define N_TIME_SHOW 200 //0.2s刷新显示
#define N_TIMER_SEC 1
#define N_TIMER_SHOW 2

// 用于应用程序“关于”菜单项的 CAboutDlg 对话框

class CAboutDlg : public CDialogEx
{
public:
	CAboutDlg();

// 对话框数据
	enum { IDD = IDD_ABOUTBOX };

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持

// 实现
protected:
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialogEx(CAboutDlg::IDD)
{

}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
END_MESSAGE_MAP()


// CHuaGoCorrectDlg 对话框

CHuaGoCorrectDlg::CHuaGoCorrectDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(CHuaGoCorrectDlg::IDD, pParent)
	,usb_pid(0x7823)
	,usb_vid(0x064b)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
	papercount = 0;
	ls_flat = FALSE;
	m_bExit = FALSE;
	m_hThread = NULL;
	m_bPause = TRUE;
	m_bParamError = FALSE;

	m_iPicIndex = 0;
	m_iflatIndex = -2;

	m_iDpiIndex = 0;
	m_iColorIndex = 0;

	bABlackImage = true;
	bBBlackImage = true;
	bAGrayWhiteImage = true;
	bBGrayWhiteImage = true;
	bAColorWhiteImage = true;
	bAcolr = true;
	bAcolg = true;
	bAcolb = true;
	bBColorWhiteImage = true;
	bBcolr = true;
	bBcolg = true;
	bBcolb = true;
	bAGrayWhiteGain = true;
	bBGrayWhiteGain = true;
	bAColorWhiteGain = true;
	bBColorWhiteGain = true;

	iAMaxStep = 0;
	iAMiddleStep = 0;
	iAMinStep = 0;
	iBMaxStep = 0;
	iBMiddleStep = 0;
	iBMinStep = 0;
	iAERMaxStep = 0;
	iAERMiddleStep = 0;
	iAERMinStep = 0;
	iAEGMaxStep = 0;
	iAEGMiddleStep = 0;
	iAEGMinStep = 0;
	iAEBMaxStep = 0;
	iAEBMiddleStep = 0;
	iAEBMinStep = 0;
	iBERMaxStep = 0;
	iBERMiddleStep = 0;
	iBERMinStep = 0;
	iBEGMaxStep = 0;
	iBEGMiddleStep = 0;
	iBEGMinStep = 0;
	iBEBMaxStep = 0;
	iBEBMiddleStep = 0;
	iBEBMinStep = 0;
	iGainStep = 0;

	b_review = FALSE;
	b_suspend = FALSE;	
}

void CHuaGoCorrectDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_TAB1, m_tab);
	DDX_Control(pDX, IDC_CHECK_BLACK, m_pBlack);
	DDX_Control(pDX, IDC_CHECK_WExposure, m_pWExposure);
	DDX_Control(pDX, IDC_CHECK_WGain, m_pWGain);
	DDX_Control(pDX, IDC_dpi_comboBox, m_ComboxDpi);
	DDX_Control(pDX, IDC_color_comboBox, m_ComboxColor);
	DDX_Control(pDX, IDC_lsFpgaFlat, m_check_FpgaFlat);
	DDX_Text(pDX, IDC_EDIT_HOUR, s_hour);
	DDX_Text(pDX, IDC_EDIT_MINUTE, s_minute);
	DDX_Text(pDX, IDC_EDIT_SECOND, s_second);
	DDX_Control(pDX, IDC_color_comboBox2, twss);
	DDX_Control(pDX, IDC_color_comboBox3, duplex);
	DDX_Control(pDX, IDC_COMBO1, Version);
}

BEGIN_MESSAGE_MAP(CHuaGoCorrectDlg, CDialogEx)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_NOTIFY(TCN_SELCHANGE, IDC_TAB1, &CHuaGoCorrectDlg::OnTcnSelChangeTab)
	ON_BN_CLICKED(IDC_CheckParamSet, &CHuaGoCorrectDlg::OnBnClickedCheckparamset)
	ON_BN_CLICKED(IDC_CheckParamRead, &CHuaGoCorrectDlg::OnBnClickedCheckparamread)
	ON_BN_CLICKED(IDC_BTN_FLAT, &CHuaGoCorrectDlg::OnBnClickedBtnFlat)
	ON_BN_CLICKED(IDC_BTN_FLATM, &CHuaGoCorrectDlg::OnBnClickedBtnFlatm)
	ON_BN_CLICKED(IDC_BTN_BLACKFLAT, &CHuaGoCorrectDlg::OnBnClickedBtnBlackflat)
	ON_BN_CLICKED(IDC_BTN_EXFLAT, &CHuaGoCorrectDlg::OnBnClickedBtnExflat)
	ON_BN_CLICKED(IDC_BTN_GAINFLAT, &CHuaGoCorrectDlg::OnBnClickedBtnGainflat)
	ON_BN_CLICKED(IDC_BTN_CONTINUE, &CHuaGoCorrectDlg::OnBnClickedBtnContinue)
	ON_BN_CLICKED(IDC_BTN_PAUSE, &CHuaGoCorrectDlg::OnBnClickedBtnPause)
	ON_CBN_SELCHANGE(IDC_dpi_comboBox, &CHuaGoCorrectDlg::OnCbnSelChangeDpi)
	ON_CBN_SELCHANGE(IDC_color_comboBox, &CHuaGoCorrectDlg::OnCbnSelChangeColor)
	ON_BN_CLICKED(IDC_BUTTON1, &CHuaGoCorrectDlg::OnBnClickedConfirm)
	ON_BN_CLICKED(IDC_BTN_PARAMCFG, &CHuaGoCorrectDlg::OnBnClickedBtnParamcfg)
	ON_BN_CLICKED(IDC_BUTTON3, &CHuaGoCorrectDlg::OnBnClickedStopScan)
	ON_WM_TIMER()
	ON_MESSAGE(WM_MYMESSAGE, &CHuaGoCorrectDlg::OnMyMessage)
	ON_CBN_SELCHANGE(IDC_COMBO1, &CHuaGoCorrectDlg::OnCbnSelchangeCombo1)
END_MESSAGE_MAP()


// CHuaGoCorrectDlg 消息处理程序

BOOL CHuaGoCorrectDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();
	this->SetWindowTextA("HuaGaoCorrect");
	m_drv.reset(new GScn_Drv());

	m_drv->open(usb_vid);
	int version_num =0;
	int num = 0;
	if (m_drv->device_id == 0)
		MessageBox(TEXT("未找到设备!"), TEXT("提示"), MB_OK | MB_ICONWARNING);
	Version.InsertString(num++, _T("默认"));
	Version.InsertString(num++, _T("G100"));
	//m_tab.InsertItem(2, _T("视图"));
	Version.InsertString(num++, _T("G200"));
	Version.InsertString(num++, _T("G300"));
	Version.InsertString(num++, _T("G400"));
	for (int q = 0; q < 5; q++)
	{
		if ((1 << (q * 4)) & m_drv->device_id)
		{
			version_num = q;
		}

	}
	Version.SetCurSel(version_num);
	//m_drv->open(0x3072, 0x0100,0);
	// 将“关于...”菜单项添加到系统菜单中。

	// IDM_ABOUTBOX 必须在系统命令范围内。
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		BOOL bNameValid;
		CString strAboutMenu;
		bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
		ASSERT(bNameValid);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	// 设置此对话框的图标。当应用程序主窗口不是对话框时，框架将自动
	//  执行此操作
	SetIcon(m_hIcon, TRUE);			// 设置大图标
	SetIcon(m_hIcon, FALSE);		// 设置小图标

	// TODO: 在此添加额外的初始化代码	 
	m_tab.InsertItem(0, _T("A3"));           
	m_tab.InsertItem(1, _T("A4"));   
	//m_tab.InsertItem(2, _T("视图"));
	m_tab.InsertItem(2, _T("CIS检测工具"));
	m_tab.InsertItem(3, _T("畸变检测"));
	m_A3Dlg.Create(IDD_A3_DIALOG, &m_tab);    // 创建第一个标签页   
	m_A4Dlg.Create(IDD_A4_DIALOG, &m_tab); // 创建第二个标签页  
	//m_VisonDlg.Create(IDD_VISION_DIALOG, &m_tab); //创建第三个标签页
	m_CISDlg.Create(IDD_CIS_DIALOG1, &m_tab);
	m_dis.Create(IDD_DIS_DIALOG1, &m_tab);
	//m_CISDlg.Cis_box.SetCurSel(0);
	

	m_tab.GetClientRect(&tabRect);    // 获取标签控件客户区Rect   
	// 调整tabRect，使其覆盖范围适合放置标签页   
	tabRect.left += 1;                  
	tabRect.right -= 1;   
	tabRect.top += 25;   
	tabRect.bottom -= 1;   

	// 根据调整好的tabRect放置m_A3Dlg子对话框，并设置为显示   
	m_A3Dlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);   
	// 根据调整好的tabRect放置m_A4Dlg子对话框，并设置为隐藏   
	m_A4Dlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_SHOWWINDOW); 
	// 根据调整好的tabRect放置m_VisonDlg子对话框，并设置为隐藏   
	//m_VisonDlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_SHOWWINDOW);
	m_CISDlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
	m_dis.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
	m_tab.SetCurSel(1);

	m_ComboxDpi.InsertString(0, _T("300")); 
	m_ComboxDpi.InsertString(1, _T("200"));
	m_ComboxDpi.InsertString(2, _T("150"));
	m_ComboxDpi.SetCurSel(1);
	twss.InsertString(0, _T("A4"));
	twss.InsertString(1, _T("A3"));
	twss.InsertString(2, _T("自动裁剪"));
	twss.SetCurSel(0);
	duplex.InsertString(0, _T("单面"));
	duplex.InsertString(1, _T("双面"));
	duplex.SetCurSel(0);
	m_ComboxColor.InsertString(0, _T("gray")); 
	m_ComboxColor.InsertString(1, _T("color")); 
	m_ComboxColor.SetCurSel(1);
	m_drv->set_decompress_pix_type(TWPT_RGB);

	m_check_FpgaFlat.SetCheck(0);
	m_pBlack.SetCheck(0);
	m_pWExposure.SetCheck(0);
	m_pWGain.SetCheck(0);

	m_drv->SetPath(GetMainApp()->path);

	n_hour = 0;
	n_minute = 0;
	n_second = 0;
	s_hour = "00";
	s_minute = "00";
	s_second = "00";
	UpdateData(FALSE);

	//InitButton();

	//开启校正线程
	unsigned threadId;	
	// Create the thread.
	m_hThread = (HANDLE)::_beginthreadex( NULL, 0, &CorrectThread, this, 0, &threadId);

	return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
}

void CHuaGoCorrectDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialogEx::OnSysCommand(nID, lParam);
	}
}

// 如果向对话框添加最小化按钮，则需要下面的代码
//  来绘制该图标。对于使用文档/视图模型的 MFC 应用程序，
//  这将由框架自动完成。

void CHuaGoCorrectDlg::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 CHuaGoCorrectDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

unsigned WINAPI CHuaGoCorrectDlg::CorrectThread(void* pCorrect)
{
	CHuaGoCorrectDlg *pDlg = (CHuaGoCorrectDlg *)pCorrect;
	if (pDlg != NULL)
	{
		pDlg->CorrectThreadFunc();
	}
	return 0;
}

void CHuaGoCorrectDlg::CorrectThreadFunc()
{
	BOOL bNewConnect = FALSE;  //是否一个新连接
	while (!m_bExit)
	{
		m_deviceLock.Lock();

		if(true != m_bPause)
		{
			m_drv->FlatA4();
		    Sleep(28000);

			if(1 == m_pBlack.GetCheck())
			{
				if(1 == m_pWExposure.GetCheck())
				{
					if(0 == m_pWGain.GetCheck())
					{
						CorrectWhiteGain();
					}
					else
					{
						m_bPause = true;
					}
				}
				else
				{
					CorrectWhiteImage();
				}
			}
			else
			{
				CorrectBlackImage();
			}
		}
		m_deviceLock.Unlock();
	}
}

BOOL CHuaGoCorrectDlg::PreCreateWindow(CREATESTRUCT & cs)
{

	cs.style = cs.style&~WS_MAXIMIZEBOX&~WS_SYSMENU&~WS_MINIMIZEBOX;

	if (!CDialogEx::PreCreateWindow(cs))

		return FALSE;

	// TODO: Modify the Window class or styles here by modifying 

	// the CREATESTRUCT cs 



	return TRUE;
}

void CHuaGoCorrectDlg::OnTcnSelChangeTab(NMHDR *pNMHDR, LRESULT *pResult)
{
	// TODO: 在此添加控件通知处理程序代码
	*pResult = 0;
	RefreshTabChange();	
}

void CHuaGoCorrectDlg::RefreshTabChange()
{
	CRect tabRect;    // 标签控件客户区的Rect   

	// 获取标签控件客户区Rect，并对其调整，以适合放置标签页   
	m_tab.GetClientRect(&tabRect);
	tabRect.left += 1;
	tabRect.right -= 1;
	tabRect.top += 25;
	tabRect.bottom -= 1;
	int currentselect = m_tab.GetCurSel();
	switch (currentselect)
	{
	case 0:
		m_A3Dlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_SHOWWINDOW);
		m_A4Dlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
		//m_VisonDlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
		m_CISDlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
		m_dis.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
		break;
	case 1:
		//m_check_FpgaFlat.SetCheck(1);
		m_A3Dlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
		m_A4Dlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_SHOWWINDOW);
		//m_VisonDlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
		m_CISDlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
		m_dis.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
		break;
	//case 2:
	//	m_A3Dlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
	//	m_A4Dlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
	//	m_VisonDlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_SHOWWINDOW);
	//	m_CISDlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
	//	m_dis.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
	//	break;
	case 2:
		m_A3Dlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
		m_A4Dlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
		//m_VisonDlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
		m_CISDlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_SHOWWINDOW);
		m_dis.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
		m_CISDlg.SetGscan_drv(m_drv.get());
		break;
	case 3:
		m_A3Dlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
		m_A4Dlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
		//m_VisonDlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
		m_CISDlg.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_HIDEWINDOW);
		m_dis.SetWindowPos(NULL, tabRect.left, tabRect.top, tabRect.Width(), tabRect.Height(), SWP_SHOWWINDOW);
		m_dis.setgcn_drv(m_drv.get());
		break;
	default:
		break;
	}

		m_CISDlg.SetEnableGetImage(currentselect == 2);
		m_dis.SetEnableGetImage(currentselect == 3);
}

void CHuaGoCorrectDlg::Scan()
{  
	hgConfigClass cf;
	CONFIGPARAMS configItem;
	if(m_iColorIndex == 0)
	{
		cf.setTwPixelType(TWPT_GRAY);
		configItem.Pixtype = TWPT_GRAY;
	}
	else
	{
		cf.setTwPixelType(TWPT_RGB);
		configItem.Pixtype = TWPT_RGB;
	}

	if (twss.GetCurSel() == 0)
	{
		cf.settwSS(TWSS_A3);
		configItem.PaperSize = A3;
	}
	else if(twss.GetCurSel()==1)
	{
		cf.settwSS(TWSS_A4);
		configItem.PaperSize = A4;
	}
	else
	{
		cf.settwSS(TWSS_A4);
		configItem.PaperSize = USStatement;
	}
	if(m_ComboxDpi.GetCurSel() == 0)
	{
		cf.setResolution(300.0);
		configItem.Resolution = 300;
	}
	else if(m_ComboxDpi.GetCurSel() == 1)
	{
		cf.setResolution(200.0);
		configItem.Resolution = 200;
	}
	else
	{
		cf.setResolution(150.0);
		configItem.Resolution = 150;
	}

	cf.setDoubleFeedEnable(FALSE);
	cf.setStapleEnable(FALSE);
	configItem.Duplex = 0;

	if(0 == m_check_FpgaFlat.GetCheck())
	{
		cf.setIsConrrect(TRUE);
	}
	else
	{
		cf.setIsConrrect(FALSE);
	}
	bool b_save_origin = ((CButton*)(GetDlgItem(IDC_CHECK3)))->GetCheck() == 1;
	bool b_save_origin_fixed = ((CButton*)(GetDlgItem(IDC_CHECK4)))->GetCheck() == 1;
	m_drv->save_config(b_save_origin, b_save_origin_fixed);
	UpdateList(configItem, true);
	m_drv->setlist(m_iaList);
	m_dis.updatadistorionparam();
	m_dis.d_distortonoaram = m_dis.getdistorionparam();
	UINT32 cfg_Value =cf.GetData();
	USBCB usbcb = { CONFIGURED_DATA , cfg_Value,0 };
	m_drv->Config_Scanner(&usbcb);
	BOOL isduplex = duplex.GetCurSel();
	m_CISDlg.isduplex = isduplex;
	m_drv->SetIsDuplex(isduplex);
	Sleep(2000);

	m_drv->Scanner_StartScan(0);

	if (b_review||b_suspend)
		KillTimer(N_TIMER_SEC);
	b_review = FALSE;
	b_suspend = FALSE;
	n_hour = 0;
	n_minute = 0;
	n_second = 0;
	SetTimer(N_TIMER_SEC, N_TIME_SEC, NULL);
	SetTimer(N_TIMER_SHOW, N_TIME_SHOW, NULL);
}
static  map<pair<TwSS, float>, CSize> dpiDct;
static void initialDictionary()
{
	//A3
	dpiDct.insert(pair<pair<TwSS, float>, CSize>(pair<TwSS, float>(A3, 100), CSize(1169, 1653)));
	dpiDct.insert(pair<pair<TwSS, float>, CSize>(pair<TwSS, float>(A3, 150), CSize(1753, 2480)));
	dpiDct.insert(pair<pair<TwSS, float>, CSize>(pair<TwSS, float>(A3, 200), CSize(2338, 3307)));
	dpiDct.insert(pair<pair<TwSS, float>, CSize>(pair<TwSS, float>(A3, 240), CSize(2806, 3968)));
	dpiDct.insert(pair<pair<TwSS, float>, CSize>(pair<TwSS, float>(A3, 300), CSize(3507, 4960)));

	//A4
	dpiDct.insert(pair<pair<TwSS, float>, CSize>(pair<TwSS, float>(A4, 100), CSize(826, 1169)));
	dpiDct.insert(pair<pair<TwSS, float>, CSize>(pair<TwSS, float>(A4, 150), CSize(1240, 1753)));
	dpiDct.insert(pair<pair<TwSS, float>, CSize>(pair<TwSS, float>(A4, 200), CSize(1653, 2338)));
	dpiDct.insert(pair<pair<TwSS, float>, CSize>(pair<TwSS, float>(A4, 240), CSize(1984, 2806)));
	dpiDct.insert(pair<pair<TwSS, float>, CSize>(pair<TwSS, float>(A4, 300), CSize(2480, 3507)));

	//1.5倍A3
	dpiDct.insert(pair<pair<TwSS, float>, CSize>(pair<TwSS, float>(USStatement, 100), CSize(1169, (LONG)(1653 * 1.5))));
	dpiDct.insert(pair<pair<TwSS, float>, CSize>(pair<TwSS, float>(USStatement, 150), CSize(1753, (LONG)(2480 * 1.5))));
	dpiDct.insert(pair<pair<TwSS, float>, CSize>(pair<TwSS, float>(USStatement, 200), CSize(2338, (LONG)(3307 * 1.5))));
	dpiDct.insert(pair<pair<TwSS, float>, CSize>(pair<TwSS, float>(USStatement, 240), CSize(2806, (LONG)(3968 * 1.5))));
	dpiDct.insert(pair<pair<TwSS, float>, CSize>(pair<TwSS, float>(USStatement, 300), CSize(3507, (LONG)(4960 * 1.5))));

	/*dpiDct[{USStatement, 50.0f}] = { 585, (LONG)(827 * 1.5) };
	dpiDct[{USStatement, 75.0f}] = { 877, (LONG)(1240 * 1.5) };
	dpiDct[{USStatement, 100.0f}] = { 1169, (LONG)(1653 * 1.5) };
	dpiDct[{USStatement, 150.0f}] = { 1753, (LONG)(2480 * 1.5) };
	dpiDct[{USStatement, 200.0f}] = { 2338, (LONG)(3307 * 1.5) };
	dpiDct[{USStatement, 240.0f}] = { 2806, (LONG)(3968 * 1.5) };
	dpiDct[{USStatement, 300.0f}] = { 3507, (LONG)(4960 * 1.5) };
	dpiDct[{USStatement, 400.0f}] = { 4677, (LONG)(6614 * 1.5) };
	dpiDct[{USStatement, 600.0f}] = { 7015, (LONG)(9921 * 1.5) };*/
}
static CSize getSize(TwSS paperType, float dpi)
{
	CSize retSize;
	map<pair<TwSS, float>, CSize>::iterator iter;
	iter = dpiDct.find(pair<TwSS, float>(paperType, dpi));
	if (iter != dpiDct.end()) {
		retSize = (*iter).second;
		return retSize;
	}
	return CSize(2338, 3307);
}
void CHuaGoCorrectDlg::UpdateList(CONFIGPARAMS configParams, bool canUpdate)
{
	m_iaList.clear();

	CSize fixedSize = getSize((TwSS)configParams.PaperSize, 200.0f);
	bool autocrop = (TwSS)configParams.PaperSize == TwSS::USStatement;
	m_iaList.push_back(std::shared_ptr<CImageApply>(new CImageApplyAutoCrop(true, true, true, cv::Size(fixedSize.cx, fixedSize.cy), true)));

	if (configParams.Pixtype != 0)
	{
		m_iaList.push_back(std::shared_ptr<CImageApply>(new CImageApplySharpen()));
	}

	if (configParams.Pixtype == 0)	//threshold
		m_iaList.push_back(std::shared_ptr<CImageApply>(new CImageApplyBWBinaray(CImageApplyBWBinaray::THRESH_BINARY)));

	if (configParams.Resolution != 200.0)
	{
		CImageApplyResize* apply;
		if (true) {
			double ratio = configParams.Resolution / 200.0;
			apply = new CImageApplyResize(CImageApplyResize::RATIO, cv::Size(0, 0), ratio, ratio);
		}
		else {
			CSize dSize = getSize((TwSS)configParams.PaperSize, configParams.Resolution);
			apply = new CImageApplyResize(CImageApplyResize::DSIZE, cv::Size(dSize.cx, dSize.cy), 1.0, 1.0);
		}
		m_iaList.push_back(std::shared_ptr< CImageApply>(apply));
	}
}
void CHuaGoCorrectDlg::OnBnClickedCheckparamset()
{
	// TODO: 在此添加控件通知处理程序代码
	if (!m_drv->IsConnected())
	{
		MessageBox("扫描仪未连接！");
		return;
	}

	int iSel = m_tab.GetCurSel();
	if(iSel == 0)
	{
		A3ParamSet();
	}
	else
	{
		//A4ParamSet();
		CorrectCMDUpdate();
	}
}


void CHuaGoCorrectDlg::OnBnClickedCheckparamread()
{
	// TODO: 在此添加控件通知处理程序代码
	if (!m_drv->IsConnected())
	{
		MessageBox("扫描仪未连接！");
		return;
	}

	if (m_tab.GetCurSel() == 1)
	{
		try
		{
			int offset = 0;
			UINT iDes[128] = {0};
			byte bValue[512] = {0};
			byte *read = m_drv->GetFlatData();

			for(int i = 0; i < 512; i++)
			{
				bValue[i] = read[i];
			}

			for (int j = 0; j < 128; j++)
			{
				int value = (int)((bValue[offset+0] & 0xFF)
					| ((bValue[offset + 1] & 0xFF) << 8)
					| ((bValue[offset + 2] & 0xFF) << 16)
					| ((bValue[offset + 3] & 0xFF) << 24));

				iDes[j] = value;
				offset += 4;
			}

			int flatType = m_A4Dlg.m_A4FlatModel.GetCurSel();
			int startindex = -1;
			switch (flatType)
			{
			case 0://彩色平场校正0~29
				startindex = 3;
				break;
			case 1://彩色校正30~59
				startindex = 63;
				break;
			case 2://灰度平场校正60~89
				startindex = 33;
				break;
			case 3://灰度校正90~120
				startindex = 93;
				break;
			default:
				break;
			}

			int iValues[30] = {0};
			int j = 0;
			for(int i = startindex; i < startindex+30; i++)
			{
				iValues[j] = iDes[i];
				j++;
			}

			if (startindex!=-1)
			{
				m_A4Dlg.updateA4Config(iValues);
			}
		}
		catch (Exception)
		{

			throw;
		}
	}
	else
	{
		byte *buffer = m_drv->GetCisPara();
		byte bValue[30] = {0};

		for(int i = 0; i < 30; i++)
		{
			bValue[i] = buffer[i];
		}

		//m_A3Dlg.updateA3Config(bValue);
	}
}


void CHuaGoCorrectDlg::OnBnClickedBtnFlat()
{
	// TODO: 在此添加控件通知处理程序代码
	m_iflatIndex = -2;

	((CButton*)GetDlgItem(IDC_CheckParamSet))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_CheckParamRead))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_FLATM))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_BLACKFLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_EXFLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_GAINFLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_FLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_CONTINUE))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BUTTON1))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_PARAMCFG))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_PAUSE))->EnableWindow(TRUE);

	if (!m_drv->IsConnected())
	{
		MessageBox("扫描仪未连接！");
		return;
	}

	if (m_tab.GetCurSel() == 1)
	{
		if(m_bParamError == true)
		{
			m_drv->reset();
			m_bParamError = false;
		}
		else
		{
			m_drv->reset();
			m_drv->DevStateChange();
		}

		//m_drv->FlatA4();
		//Sleep(28000);
		//m_iflatIndex += 2;
		m_bPause = false;
		
		//ShowFrontImage(m_iflatIndex);
		//Sleep(500);
		//m_iflatIndex += 2;
		//ShowFrontImage(m_iflatIndex);
		//CorrectBlackImage(m_iflatIndex);
		//MessageBox("校正完成");
	}
	else
	{
		/*
		if(1 == m_A3Dlg.m_200dpi_gray.GetCheck())
		{
			m_drv->FlatA3(0x40);
			Sleep(2000);
			m_drv->Stop_scan();
			Sleep(1000);
			m_iflatIndex += 2;
			ShowFrontImage(m_iflatIndex);
			Sleep(500);
			m_iflatIndex += 2;
			ShowFrontImage(m_iflatIndex);
			MessageBox("校正完成");
			m_drv->DevStateChange();
		}

		if(1 == m_A3Dlg.m_200dpi_color.GetCheck())
		{
			m_drv->FlatA3(0x60);
			Sleep(2000);
			m_drv->Stop_scan();
			Sleep(1000);
			m_iflatIndex += 2;
			ShowFrontImage(m_iflatIndex);
			Sleep(500);
			m_iflatIndex += 2;
			ShowFrontImage(m_iflatIndex);
			MessageBox("校正完成");
			m_drv->DevStateChange();
		}

		if(1 == m_A3Dlg.m_300dpi_gray.GetCheck())
		{
			m_drv->FlatA3(0x00);
			Sleep(2000);
			m_drv->Stop_scan();
			Sleep(1000);
			m_iflatIndex += 2;
			ShowFrontImage(m_iflatIndex);
			Sleep(500);
			m_iflatIndex += 2;
			ShowFrontImage(m_iflatIndex);
			MessageBox("校正完成");
			m_drv->DevStateChange();
		}

		if(1 == m_A3Dlg.m_300dpi_color.GetCheck())
		{
			m_drv->FlatA3(0x20);
			Sleep(2000);
			m_drv->Stop_scan();
			Sleep(1000);
			m_iflatIndex += 2;
			ShowFrontImage(m_iflatIndex);
			Sleep(500);
			m_iflatIndex += 2;
			ShowFrontImage(m_iflatIndex);
			MessageBox("校正完成");
			m_drv->DevStateChange();
		}
		*/
	}
}

void CHuaGoCorrectDlg::A3ParamSet()
{
	CString csParam;
	/*
	UINT adpara = m_A3Dlg.m_gray_gain_f;
	adpara = (adpara | (m_A3Dlg.m_gray_gain_b << 8));
	adpara = (adpara | (m_A3Dlg.m_gray_offset_f << 16));
	adpara = (adpara | (m_A3Dlg.m_gray_offset_b << 24));
	m_drv->SendrAdPara(adpara);

	Sleep(500);
	UINT Rgbadpara = m_A3Dlg.m_rgb_gain_f;
	Rgbadpara = (Rgbadpara | (m_A3Dlg.m_rgb_gain_b << 8));
	Rgbadpara = (Rgbadpara | (m_A3Dlg.m_rgb_offset_f << 16));
	Rgbadpara = (Rgbadpara | (m_A3Dlg.m_rgb_offset_b << 24));
	m_drv->SendrRgbAdPara(Rgbadpara);

	Sleep(500);
	//SenGRPara(0x011000a0);
	UINT GRtimepara = ((m_A3Dlg.m_Redtime << 16) | m_A3Dlg.m_Graytime);
	m_drv->SenGRPara(GRtimepara);

	Sleep(500);
	//SenGBPara(0x01ba0215);
	UINT GBtimepara = ((m_A3Dlg.m_Bluetime << 16) | m_A3Dlg.m_Greentime);
	m_drv->SenGBPara(GBtimepara);

	MessageBox("参数发送成功");
	*/
}

void CHuaGoCorrectDlg::A4ParamSet()
{
	if (!m_drv->IsConnected())
	{
		MessageBox("扫描仪未连接！");
		return;
	}

	switch (m_A4Dlg.m_A4FlatModel.GetCurSel())
	{
		case 0:
			{
				UINT gains[30] = {0};
				byte gain[512] = {0};
				byte gain_data[524] = {0};

				m_A4Dlg.UpdateData(TRUE);
				gains[0] = m_A4Dlg.m_tbxFRExposure;
				gains[1] = m_A4Dlg.m_tbxFGExposure;
				gains[2] = m_A4Dlg.m_tbxFBExposure;
				gains[3] = m_A4Dlg.m_tbxBRExposure;
				gains[4] = m_A4Dlg.m_tbxBGExposure;
				gains[5] = m_A4Dlg.m_tbxBBExposure;
				gains[6] = m_A4Dlg.m_tbxF1Gain;
				gains[7] = m_A4Dlg.m_tbxF2Gain;
				gains[8] = m_A4Dlg.m_tbxF3Gain;
				gains[9] = m_A4Dlg.m_tbxF4Gain;
				gains[10] = m_A4Dlg.m_tbxF5Gain;
				gains[11] = m_A4Dlg.m_tbxF6Gain;
				gains[12] = m_A4Dlg.m_tbxB1Gain;
				gains[13] = m_A4Dlg.m_tbxB2Gain;
				gains[14] = m_A4Dlg.m_tbxB3Gain;
				gains[15] = m_A4Dlg.m_tbxB4Gain;
				gains[16] = m_A4Dlg.m_tbxB5Gain;
				gains[17] = m_A4Dlg.m_tbxB6Gain;
				gains[18] = m_A4Dlg.m_tbxF1Offset;
				gains[19] = m_A4Dlg.m_tbxF2Offset;
				gains[20] = m_A4Dlg.m_tbxF3Offset;
				gains[21] = m_A4Dlg.m_tbxF4Offset;
				gains[22] = m_A4Dlg.m_tbxF5Offset;
				gains[23] = m_A4Dlg.m_tbxF6Offset;
				gains[24] = m_A4Dlg.m_tbxB1Offset;
				gains[25] = m_A4Dlg.m_tbxB2Offset;
				gains[26] = m_A4Dlg.m_tbxB3Offset;
				gains[27] = m_A4Dlg.m_tbxB4Offset;
				gains[28] = m_A4Dlg.m_tbxB5Offset;
				gains[29] = m_A4Dlg.m_tbxB6Offset;
				m_A4Dlg.UpdateData(FALSE);

				intToByte(gains, gain, 30);
				USBCBA4 ubc;
				ubc.u32_Command =  SEND_COLORCORRECT_FLAT;
				ubc.u32_Count = 120;
				memcpy(ubc.buffer,gain,512);
				ubc.u32_Data = 0;

				int length = sizeof(ubc);
				memmove(gain_data,&ubc,length); 

				m_drv->SendColorCorrentFlat(gain_data,length);
			}
			break;
		case 1:
			{
				UINT gains[30] = {0};
				byte gain[512] = {0};
				byte gain_data[524] = {0};

				m_A4Dlg.UpdateData(TRUE);
				gains[0] = m_A4Dlg.m_tbxFRExposure;
				gains[1] = m_A4Dlg.m_tbxFGExposure;
				gains[2] = m_A4Dlg.m_tbxFBExposure;
				gains[3] = m_A4Dlg.m_tbxBRExposure;
				gains[4] = m_A4Dlg.m_tbxBGExposure;
				gains[5] = m_A4Dlg.m_tbxBBExposure;
				gains[6] = m_A4Dlg.m_tbxF1Gain;
				gains[7] = m_A4Dlg.m_tbxF2Gain;
				gains[8] = m_A4Dlg.m_tbxF3Gain;
				gains[9] = m_A4Dlg.m_tbxF4Gain;
				gains[10] = m_A4Dlg.m_tbxF5Gain;
				gains[11] = m_A4Dlg.m_tbxF6Gain;
				gains[12] = m_A4Dlg.m_tbxB1Gain;
				gains[13] = m_A4Dlg.m_tbxB2Gain;
				gains[14] = m_A4Dlg.m_tbxB3Gain;
				gains[15] = m_A4Dlg.m_tbxB4Gain;
				gains[16] = m_A4Dlg.m_tbxB5Gain;
				gains[17] = m_A4Dlg.m_tbxB6Gain;
				gains[18] = m_A4Dlg.m_tbxF1Offset;
				gains[19] = m_A4Dlg.m_tbxF2Offset;
				gains[20] = m_A4Dlg.m_tbxF3Offset;
				gains[21] = m_A4Dlg.m_tbxF4Offset;
				gains[22] = m_A4Dlg.m_tbxF5Offset;
				gains[23] = m_A4Dlg.m_tbxF6Offset;
				gains[24] = m_A4Dlg.m_tbxB1Offset;
				gains[25] = m_A4Dlg.m_tbxB2Offset;
				gains[26] = m_A4Dlg.m_tbxB3Offset;
				gains[27] = m_A4Dlg.m_tbxB4Offset;
				gains[28] = m_A4Dlg.m_tbxB5Offset;
				gains[29] = m_A4Dlg.m_tbxB6Offset;
				m_A4Dlg.UpdateData(FALSE);

				intToByte(gains, gain, 30);
				USBCBA4 ubcColor;
				ubcColor.u32_Command =  SEND_COLOR_FLAT;
				ubcColor.u32_Count = 120;
				memcpy(ubcColor.buffer,gain,512);
				ubcColor.u32_Data = 0;

				int length = sizeof(ubcColor);
				memmove(gain_data,&ubcColor,length); 

				m_drv->SendColorFlat(gain_data,length);
			}
			break;
		case 2:
			{
				UINT gains[30] = {0};
				byte gain[512] = {0};
				byte gain_data[524] = {0};

				m_A4Dlg.UpdateData(TRUE);
				gains[0] = m_A4Dlg.m_tbxFRExposure;
				gains[1] = m_A4Dlg.m_tbxFGExposure;
				gains[2] = m_A4Dlg.m_tbxFBExposure;
				gains[3] = m_A4Dlg.m_tbxBRExposure;
				gains[4] = m_A4Dlg.m_tbxBGExposure;
				gains[5] = m_A4Dlg.m_tbxBBExposure;
				gains[6] = m_A4Dlg.m_tbxF1Gain;
				gains[7] = m_A4Dlg.m_tbxF2Gain;
				gains[8] = m_A4Dlg.m_tbxF3Gain;
				gains[9] = m_A4Dlg.m_tbxF4Gain;
				gains[10] = m_A4Dlg.m_tbxF5Gain;
				gains[11] = m_A4Dlg.m_tbxF6Gain;
				gains[12] = m_A4Dlg.m_tbxB1Gain;
				gains[13] = m_A4Dlg.m_tbxB2Gain;
				gains[14] = m_A4Dlg.m_tbxB3Gain;
				gains[15] = m_A4Dlg.m_tbxB4Gain;
				gains[16] = m_A4Dlg.m_tbxB5Gain;
				gains[17] = m_A4Dlg.m_tbxB6Gain;
				gains[18] = m_A4Dlg.m_tbxF1Offset;
				gains[19] = m_A4Dlg.m_tbxF2Offset;
				gains[20] = m_A4Dlg.m_tbxF3Offset;
				gains[21] = m_A4Dlg.m_tbxF4Offset;
				gains[22] = m_A4Dlg.m_tbxF5Offset;
				gains[23] = m_A4Dlg.m_tbxF6Offset;
				gains[24] = m_A4Dlg.m_tbxB1Offset;
				gains[25] = m_A4Dlg.m_tbxB2Offset;
				gains[26] = m_A4Dlg.m_tbxB3Offset;
				gains[27] = m_A4Dlg.m_tbxB4Offset;
				gains[28] = m_A4Dlg.m_tbxB5Offset;
				gains[29] = m_A4Dlg.m_tbxB6Offset;
				m_A4Dlg.UpdateData(FALSE);

				intToByte(gains, gain, 30);
				USBCBA4 ubcGrayC;
				ubcGrayC.u32_Command =  SEND_GRAYCORRECT_FLAT;
				ubcGrayC.u32_Count = 120;
				memcpy(ubcGrayC.buffer,gain,512);
				ubcGrayC.u32_Data = 0;

				int length = sizeof(ubcGrayC);
				memmove(gain_data,&ubcGrayC,length); 

				m_drv->SendGrayCorrectFlat(gain_data,length);
			}
			break;
		case 3:
			{
				UINT gains[30] = {0};
				byte gain[512] = {0};
				byte gain_data[524] = {0};

				m_A4Dlg.UpdateData(TRUE);
				gains[0] = m_A4Dlg.m_tbxFRExposure;
				gains[1] = m_A4Dlg.m_tbxFGExposure;
				gains[2] = m_A4Dlg.m_tbxFBExposure;
				gains[3] = m_A4Dlg.m_tbxBRExposure;
				gains[4] = m_A4Dlg.m_tbxBGExposure;
				gains[5] = m_A4Dlg.m_tbxBBExposure;
				gains[6] = m_A4Dlg.m_tbxF1Gain;
				gains[7] = m_A4Dlg.m_tbxF2Gain;
				gains[8] = m_A4Dlg.m_tbxF3Gain;
				gains[9] = m_A4Dlg.m_tbxF4Gain;
				gains[10] = m_A4Dlg.m_tbxF5Gain;
				gains[11] = m_A4Dlg.m_tbxF6Gain;
				gains[12] = m_A4Dlg.m_tbxB1Gain;
				gains[13] = m_A4Dlg.m_tbxB2Gain;
				gains[14] = m_A4Dlg.m_tbxB3Gain;
				gains[15] = m_A4Dlg.m_tbxB4Gain;
				gains[16] = m_A4Dlg.m_tbxB5Gain;
				gains[17] = m_A4Dlg.m_tbxB6Gain;
				gains[18] = m_A4Dlg.m_tbxF1Offset;
				gains[19] = m_A4Dlg.m_tbxF2Offset;
				gains[20] = m_A4Dlg.m_tbxF3Offset;
				gains[21] = m_A4Dlg.m_tbxF4Offset;
				gains[22] = m_A4Dlg.m_tbxF5Offset;
				gains[23] = m_A4Dlg.m_tbxF6Offset;
				gains[24] = m_A4Dlg.m_tbxB1Offset;
				gains[25] = m_A4Dlg.m_tbxB2Offset;
				gains[26] = m_A4Dlg.m_tbxB3Offset;
				gains[27] = m_A4Dlg.m_tbxB4Offset;
				gains[28] = m_A4Dlg.m_tbxB5Offset;
				gains[29] = m_A4Dlg.m_tbxB6Offset;
				m_A4Dlg.UpdateData(FALSE);

				intToByte(gains, gain, 30);
				USBCBA4 ubcGray;
				ubcGray.u32_Command =  SEND_GRAY_FLAT;
				ubcGray.u32_Count = 120;
				memcpy(ubcGray.buffer,gain,512);
				ubcGray.u32_Data = 0;

				int length = sizeof(ubcGray);
				memmove(gain_data,&ubcGray,length); 

				m_drv->SendGrayFlat(gain_data,length);
			}
			break;
		default:
			break;
	}
}

//int转byte
void  CHuaGoCorrectDlg::intToByte(UINT *src,byte *bytes,int iLength)
{
	int offset = 0;

	for (int i = 0; i < iLength; i++)
	{
		bytes[offset + 3] = (byte)((src[i] >> 24) & 0xFF);
		bytes[offset + 2] = (byte)((src[i] >> 16) & 0xFF);
		bytes[offset + 1] = (byte)((src[i] >> 8) & 0xFF);
		bytes[offset + 0] = (byte)(src[i] & 0xFF);
		offset += 4;
	}
}

//byte转int
void CHuaGoCorrectDlg::bytesToInt(byte* bytes,UINT *des, int iLength) 
{
	UINT iTemp[128] = {0};
	int offset = 0;

	for (int i = 0; i < iLength; i++)
	{
		int value = (int)((bytes[offset+0] & 0xFF)
			| ((bytes[offset + 1] & 0xFF) << 8)
			| ((bytes[offset + 2] & 0xFF) << 16)
			| ((bytes[offset + 3] & 0xFF) << 24));

		iTemp[i] = value;
		offset += 4;
	}

	memcpy(des,iTemp,128);

	return;
}

int CHuaGoCorrectDlg::Mat2CImage(Mat *mat, CImage &img) 
{
	if (!mat || mat->empty())
		return -1;
	int nBPP = mat->channels() * 8;
	img.Create(mat->cols, mat->rows, nBPP);
	if (nBPP == 8)
	{
		static RGBQUAD pRGB[256];
		for (int i = 0; i < 256; i++)
			pRGB[i].rgbBlue = pRGB[i].rgbGreen = pRGB[i].rgbRed = i;
		img.SetColorTable(0, 256, pRGB);
	}
	uchar* psrc = mat->data;
	uchar* pdst = (uchar*)img.GetBits();
	int imgPitch = img.GetPitch();
	for (int y = 0; y < mat->rows; y++)
	{
		memcpy(pdst, psrc, mat->cols*mat->channels());//mat->step is incorrect for those images created by roi (sub-images!)
		psrc += mat->step;
		pdst += imgPitch;
	}

	return 0;
}

static int Bcycle = 0;
static int WEcycle = 0;
static int WGcycle = 0;
void CHuaGoCorrectDlg::CorrectBlackImage()
{
	cv::Mat mPicFrontImage;
	cv::Mat mPicBackImage;
	cv::Mat mPicImage;

	Bcycle++;
	CString csCycle;
	csCycle.Format("循环处理第%d次", Bcycle);
	GetDlgItem(IDC_STATIC_BLACK)->SetWindowText(csCycle);
	
	int ret = m_drv->aquire_image(mPicImage,0);

	if (ret)
	{
		XdPrint("Failed - could not acquire image");
		return;
	}

	if (mPicImage.empty())
	{
		XdPrint("Failed - could not acquire image");
		return;
	}

	mPicFrontImage = mPicImage(cv::Rect(0,0,mPicImage.cols/2,mPicImage.rows)).clone();
	mPicBackImage = mPicImage(cv::Rect(mPicImage.cols/2,0,mPicImage.cols/2,mPicImage.rows)).clone();
	
	vector<uchar> rf;
	vector<uchar> gf;
	vector<uchar> bf;
	vector<uchar> rb;
	vector<uchar> gb;
	vector<uchar> bb;

	int nSizef = 0;
	int nCountf = 0;//统计0出现的次数
	int maxValuef = 0;  //最大值
	int minValuef = 0;  //最小值
	int sumf = 0;
	double meanf = 0.0;

	int iAAddStep = 0;
	int iAPlusStep = 0;

	if(bABlackImage)
	{
		histogram_bit32(mPicFrontImage.data,mPicFrontImage.rows,mPicFrontImage.cols,rf,gf,bf);
		nSizef = rf.size();
		nCountf = count(rf.begin(),rf.end(),0);//统计0出现的次数
		/*
		maxValuef = (int)*max_element(rf.begin(),rf.end());  //最大值
		minValuef = (int)*min_element(rf.begin(),rf.end());  //最小值
		sumf = accumulate(rf.begin(), rf.end(), 0);
		meanf =  sumf / rf.size();  //均值
		*/
		if(nCountf > 10)
		{
			iAMinStep = iAMiddleStep;

			iAAddStep = iAMinStep + (iAMaxStep - iAMinStep)/2;

			m_A4Dlg.m_sFlatCorrection.ColorCorrection[9] = iAAddStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[10] = iAAddStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[11] = iAAddStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[12] = iAAddStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[13] = iAAddStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[14] = iAAddStep;

			m_A4Dlg.m_sFlatCorrection.GrayCorrection[9] = iAAddStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[10] = iAAddStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[11] = iAAddStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[12] = iAAddStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[13] = iAAddStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[14] = iAAddStep;

			if(iAAddStep != iAMiddleStep)
			{
				iAMiddleStep = iAAddStep;
			}
			else
			{
				CString csMessage;
				csMessage.Format("暗场A面参数需要调整,0值出现次数%d,最大值为%d",nCountf,iAMaxStep);
				MessageBox(csMessage);
				if(m_bParamError != true)
				{
					InitButton();
					m_bPause = true;
					m_bParamError = true;
					Bcycle = 0;
					return;
				}
			}
		}
		else if(nCountf == 0)
		{
			iAMaxStep = iAMiddleStep;

			iAPlusStep = (iAMaxStep - (iAMaxStep - iAMinStep)/2);

			m_A4Dlg.m_sFlatCorrection.ColorCorrection[9] = iAPlusStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[10] = iAPlusStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[11] = iAPlusStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[12] = iAPlusStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[13] = iAPlusStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[14] = iAPlusStep;

			m_A4Dlg.m_sFlatCorrection.GrayCorrection[9] = iAPlusStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[10] = iAPlusStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[11] = iAPlusStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[12] = iAPlusStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[13] = iAPlusStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[14] = iAPlusStep;

			if(iAPlusStep != iAMiddleStep)
			{
				iAMiddleStep = iAPlusStep;
			}
			else
			{
				CString csMessage;
				csMessage.Format("暗场A面参数需要调整,0值出现次数%d,最小值为%d",nCountf,iAPlusStep);
				MessageBox(csMessage);
				if(m_bParamError != true)
				{
					InitButton();
					m_bPause = true;
					m_bParamError = true;
					Bcycle = 0;
					return;
				}
			}
		}
		else
		{
			bABlackImage = false;
		}

		CString csABlack;
		csABlack.Format("%d---%d", nCountf,m_A4Dlg.m_sFlatCorrection.GrayCorrection[9]);
		GetDlgItem(IDC_STATIC_AOFFSET)->SetWindowText(csABlack);
	}
	
	int nSizeb = 0;
	int nCountb = 0;//统计100出现的次
	int maxValueb = 0;  //最大值
	int minValueb = 0;  //最小值
	int sumb = 0;
	double meanb =  0.0;  //均值

	int iBAddStep = 0;
	int iBPlusStep = 0;

	if(bBBlackImage)
	{
		//WriteLog("处理背面图片");
		histogram_bit32(mPicBackImage.data,mPicBackImage.rows,mPicBackImage.cols,rb,gb,bb);
		nSizeb = rb.size();
		nCountb = count(rb.begin(),rb.end(),0);//统计100出现的次
		/*
		maxValueb = (int)*max_element(rb.begin(),rb.end());  //最大值
		minValueb = (int)*min_element(rb.begin(),rb.end());  //最小值
		sumb = accumulate(rb.begin(), rb.end(), 0);
		meanb =  sumb / rb.size();  //均值
		*/

		//WriteLog("调整背面偏置");
		if(nCountb > 10)
		{
			iBMinStep = iBMiddleStep;

			iBAddStep = (iBMinStep + (iBMaxStep - iBMinStep)/2);

			m_A4Dlg.m_sFlatCorrection.ColorCorrection[24] = iBAddStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[25] = iBAddStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[26] = iBAddStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[27] = iBAddStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[28] = iBAddStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[29] = iBAddStep;

			m_A4Dlg.m_sFlatCorrection.GrayCorrection[24] = iBAddStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[25] = iBAddStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[26] = iBAddStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[27] = iBAddStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[28] = iBAddStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[29] = iBAddStep;

			if(iBAddStep != iBMiddleStep)
			{
				iBMiddleStep = iBAddStep;
			}
			else
			{
				CString csMessage;
				csMessage.Format("暗场B面参数需要调整,0值出现次数%d,最大值为%d",nCountb,iBMaxStep);
				MessageBox(csMessage);
				if(m_bParamError != true)
				{
					InitButton();
					m_bPause = true;
					m_bParamError = true;
					Bcycle = 0;
					return;
				}
			}
		}
		else if(nCountb == 0)
		{
			iBMaxStep = iBMiddleStep;

			iBPlusStep = iBMaxStep - (iBMaxStep - iBMinStep)/2;

			m_A4Dlg.m_sFlatCorrection.ColorCorrection[24] = iBPlusStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[25] = iBPlusStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[26] = iBPlusStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[27] = iBPlusStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[28] = iBPlusStep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[29] = iBPlusStep;

			m_A4Dlg.m_sFlatCorrection.GrayCorrection[24] = iBPlusStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[25] = iBPlusStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[26] = iBPlusStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[27] = iBPlusStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[28] = iBPlusStep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[29] = iBPlusStep;

			if(iBPlusStep != iBMiddleStep)
			{
				iBMiddleStep = iBPlusStep;
			}
			else
			{
				CString csMessage;
				csMessage.Format("暗场B面参数需要调整,0值出现次数%d,最小值为%d",nCountb,iBPlusStep);
				MessageBox(csMessage);
				if(m_bParamError != true)
				{
					InitButton();
					m_bPause = true;
					m_bParamError = true;
					Bcycle = 0;
					return;
				}
			}
		}
		else
		{
			bBBlackImage = false;
		}

		CString csBBlack;
		csBBlack.Format("%d---%d", nCountb,m_A4Dlg.m_sFlatCorrection.ColorCorrection[24]);
		GetDlgItem(IDC_STATIC_BOFFSET)->SetWindowText(csBBlack);
	}

	mPicImage.release();
	mPicFrontImage.release();
	mPicBackImage.release();

	if(!bABlackImage && !bBBlackImage)
	{
		//MessageBox("暗场校正完成");
		//WriteLog("暗场校正完成");
		GetDlgItem(IDC_STATIC_STATUES)->SetWindowText(_T("暗场校正完成"));
		m_pBlack.SetCheck(1);

		if(0 == m_pWExposure.GetCheck())
		{
			CorrectWhiteImage();
		}
		else
		{
			((CButton*)GetDlgItem(IDC_CheckParamSet))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_CheckParamRead))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_BTN_FLATM))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_BTN_BLACKFLAT))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_BTN_EXFLAT))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_BTN_GAINFLAT))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_BTN_FLAT))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_BTN_CONTINUE))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_BUTTON1))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_BTN_PARAMCFG))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_BTN_PAUSE))->EnableWindow(FALSE);

			m_bPause = true;
		}
	}
	else
	{
		GetDlgItem(IDC_STATIC_STATUES)->SetWindowText(_T("正在处理暗场校正..."));
		m_A4Dlg.WriteParamFile();
		CyclePro();
	}
}

void CHuaGoCorrectDlg::CorrectWhiteImage()
{
	cv::Mat mPicWGImage;
	cv::Mat mPicWCImage;
	cv::Mat matGFImage;
	cv::Mat matGBImage;
	cv::Mat matCFImage;
	cv::Mat matCBImage;

	WEcycle++;
	CString csCycle;
	csCycle.Format("循环处理第%d次", WEcycle);
	GetDlgItem(IDC_STATIC_WE)->SetWindowText(csCycle);

	int retg = m_drv->aquire_image(mPicWGImage,1);
	int retc = m_drv->aquire_image(mPicWCImage,3);

	if (retg && retc)
	//if (retg)
	{
		XdPrint("Failed - could not acquire image");
		return;
	}

	if (mPicWGImage.empty() && mPicWCImage.empty())
	//if (mPicWGImage.empty())
	{
		XdPrint("Failed - could not acquire image");
		return;
	}

	matGFImage = mPicWGImage(cv::Rect(0,0,mPicWGImage.cols/2,mPicWGImage.rows)).clone();
	matGBImage = mPicWGImage(cv::Rect(mPicWGImage.cols/2,0,mPicWGImage.cols/2,mPicWGImage.rows)).clone();
	
	matCFImage = mPicWCImage(cv::Rect(0,0,mPicWCImage.cols/2,mPicWCImage.rows)).clone();
	matCBImage = mPicWCImage(cv::Rect(mPicWCImage.cols/2,0,mPicWCImage.cols/2,mPicWCImage.rows)).clone();

	int igstep = 10;
	if(bAGrayWhiteImage)
	{
		vector<uchar> rgf;
		vector<uchar> ggf;
		vector<uchar> bgf;
		int sumf = 0;
		double meanf = 0.0;

		histogram_bit32(matGFImage.data,matGFImage.rows,matGFImage.cols,rgf,ggf,bgf);
		sumf = accumulate(rgf.begin(), rgf.end(), 0);
		meanf =  sumf / rgf.size();  //均值

		if(meanf < 145.00)
		{
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[0] += igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[1] += igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[2] += igstep;
		}
		else if(meanf > 155.00)
		{
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[0] -= igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[1] -= igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[2] -= igstep;
		}
		else
		{
			bAGrayWhiteImage = false;
		}

		CString csAGray,csAGraylog;
		csAGray.Format("%0.1f---%d", meanf,m_A4Dlg.m_sFlatCorrection.GrayCorrection[0]);
		csAGraylog.Format("灰度A面：%0.1f---%d", meanf,m_A4Dlg.m_sFlatCorrection.GrayCorrection[0]);
		GetDlgItem(IDC_STATIC_AExposure)->SetWindowText(csAGray);
		WriteLog(csAGraylog);
	}

	if(bBGrayWhiteImage)
	{
		vector<uchar> rgb;
		vector<uchar> ggb;
		vector<uchar> bgb;
		int sumb = 0;
		double meanb =  0.0;  //均值
		histogram_bit32(matGBImage.data,matGBImage.rows,matGBImage.cols,rgb,ggb,bgb);
		sumb = accumulate(rgb.begin(), rgb.end(), 0);
		meanb =  sumb / rgb.size();  //均值

		if(meanb < 145.00)
		{
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[15] += igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[16] += igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[17] += igstep;
		}
		else if(meanb > 155.00)
		{
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[15] -= igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[16] -= igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[17] -= igstep;
		}
		else
		{
			bBGrayWhiteImage = false;
		}

		CString csBGray,csBGraylog;
		csBGray.Format("%0.1f---%d", meanb,m_A4Dlg.m_sFlatCorrection.GrayCorrection[15]);
		csBGraylog.Format("灰度B面：%0.1f---%d", meanb,m_A4Dlg.m_sFlatCorrection.GrayCorrection[15]);
		GetDlgItem(IDC_STATIC_BExposure)->SetWindowText(csBGray);
		WriteLog(csBGraylog);
	}

	if(bAColorWhiteImage)
	{
		vector<uchar> rcf;
		vector<uchar> gcf;
		vector<uchar> bcf;
		int sumrf = 0;
		int sumgf = 0;
		int sumbf = 0;
		double meanrf = 0.0;
		double meangf = 0.0;
		double meanbf = 0.0;

		histogram_bit32(matCFImage.data,matCFImage.rows,matCFImage.cols,rcf,gcf,bcf);
		sumrf = accumulate(rcf.begin(), rcf.end(), 0);
		meanrf =  sumrf / rcf.size();  //均值
		sumgf = accumulate(gcf.begin(), gcf.end(), 0);
		meangf =  sumgf / gcf.size();  //均值
		sumbf = accumulate(bcf.begin(), bcf.end(), 0);
		meanbf =  sumbf / bcf.size();  //均值

		int iAERAddStep = 0;
		int iAEGAddStep = 0;
		int iAEBAddStep = 0;
		int iAERPlusStep = 0;
		int iAEGPlusStep = 0;
		int iAEBPlusStep = 0;

		if(bAcolr)
		{
			if(meanrf < 148.00)
			{
				iAERMinStep = iAERMiddleStep;

				iAERAddStep = iAERMinStep + (iAERMaxStep - iAERMinStep)/2;

				m_A4Dlg.m_sFlatCorrection.ColorCorrection[0] = iAERAddStep;

				if(iAERAddStep != iAERMiddleStep)
				{
					iAERMiddleStep = iAERAddStep;
				}
				else
				{
					CString csMessage;
					csMessage.Format("白场彩色A面R参数需要调整,均值为%d,最大值为%d",meanrf,iAERMaxStep);
					MessageBox(csMessage);
					if(m_bParamError != true)
					{
						InitButton();
						m_bPause = true;
						m_bParamError = true;
						WEcycle = 0;
						return;
					}
				}
			}
			else if(meanrf > 152.00)
			{
				iAERMaxStep = iAERMiddleStep;

				iAERPlusStep = (iAERMaxStep - (iAERMaxStep - iAERMinStep)/2);

				m_A4Dlg.m_sFlatCorrection.ColorCorrection[0] = iAERPlusStep;

				if(iAERPlusStep != iAERMiddleStep)
				{
					iAERMiddleStep = iAERPlusStep;
				}
				else
				{
					CString csMessage;
					csMessage.Format("白场彩色A面R参数需要调整,均值为%d,最小值为%d",meanrf,iAERPlusStep);
					MessageBox(csMessage);
					//MessageBox("白场彩色A面R参数需要调整");
					if(m_bParamError != true)
					{
						InitButton();
						m_bPause = true;
						m_bParamError = true;
						WEcycle = 0;
						return;
					}
				}
			}
			else
			{
				bAcolr = false;
			}
		}

		if(bAcolg)
		{
			if(meangf < 148.00)
			{
				iAEGMinStep = iAEGMiddleStep;

				iAEGAddStep = iAEGMinStep + (iAEGMaxStep - iAEGMinStep)/2;

				m_A4Dlg.m_sFlatCorrection.ColorCorrection[1] = iAEGAddStep;

				if(iAEGAddStep != iAEGMiddleStep)
				{
					iAEGMiddleStep = iAEGAddStep;
				}
				else
				{
					CString csMessage;
					csMessage.Format("白场彩色A面G参数需要调整,均值为%d,最大值为%d",meangf,iAEGMaxStep);
					MessageBox(csMessage);
					//MessageBox("白场彩色A面G参数需要调整");
					if(m_bParamError != true)
					{
						InitButton();
						m_bPause = true;
						m_bParamError = true;
						WEcycle = 0;
						return;
					}
				}
			}
			else if(meangf > 152.00)
			{
				iAEGMaxStep = iAEGMiddleStep;

				iAEGPlusStep = (iAEGMaxStep - (iAEGMaxStep - iAEGMinStep)/2);

				m_A4Dlg.m_sFlatCorrection.ColorCorrection[1] = iAEGPlusStep;    //m_tab.SetCurSel(1);

				if(iAEGPlusStep != iAEGMiddleStep)
				{
					iAEGMiddleStep = iAEGPlusStep;
				}
				else
				{
					CString csMessage;
					csMessage.Format("白场彩色A面G参数需要调整,均值为%d,最小值为%d",meangf,iAEGPlusStep);
					MessageBox(csMessage);
					//MessageBox("白场彩色A面G参数需要调整");
					if(m_bParamError != true)
					{
						InitButton();
						m_bPause = true;
						m_bParamError = true;
						WEcycle = 0;
						return;
					}
				}
			}
			else
			{
				bAcolg = false;
			}
		}

		if(bAcolb)
		{
			if(meanbf < 148.00)
			{
				iAEBMinStep = iAEBMiddleStep;

				iAEBAddStep = iAEBMinStep + (iAEBMaxStep - iAEBMinStep)/2;

				m_A4Dlg.m_sFlatCorrection.ColorCorrection[2] = iAEBAddStep;

				if(iAEBAddStep != iAEBMiddleStep)
				{
					iAEBMiddleStep = iAEBAddStep;
				}
				else
				{
					CString csMessage;
					csMessage.Format("白场彩色A面B参数需要调整,均值为%d,最大值为%d",meanbf,iAEBMaxStep);
					MessageBox(csMessage);
					//MessageBox("白场彩色A面B参数需要调整");
					if(m_bParamError != true)
					{
						InitButton();
						m_bPause = true;
						m_bParamError = true;
						WEcycle = 0;
						return;
					}
				}
			}
			else if(meanbf > 152.00)
			{
				iAEBMaxStep = iAEBMiddleStep;

				iAEBPlusStep = (iAEBMaxStep - (iAEBMaxStep - iAEBMinStep)/2);

				m_A4Dlg.m_sFlatCorrection.ColorCorrection[2] = iAEBPlusStep;

				if(iAEBPlusStep != iAEBMiddleStep)
				{
					iAEBMiddleStep = iAEBPlusStep;
				}
				else
				{
					CString csMessage;
					csMessage.Format("白场彩色A面B参数需要调整,均值为%d,最小值为%d",meanbf,iAEBPlusStep);
					MessageBox(csMessage);
					//MessageBox("白场彩色A面B参数需要调整");
					if(m_bParamError != true)
					{
						InitButton();
						m_bPause = true;
						m_bParamError = true;
						WEcycle = 0;
						return;
					}
				}
			}
			else
			{
				bAcolb = false;
			}
		}

		if(!bAcolr && !bAcolg && !bAcolb)
		{
			bAColorWhiteImage = false;
		}

		CString csColorR,csColorG,csColorB,csAColorlog;
		csColorR.Format("%0.1f---%d", meanrf,m_A4Dlg.m_sFlatCorrection.ColorCorrection[0]);
		GetDlgItem(IDC_STATIC_ARExposure)->SetWindowText(csColorR);

		csColorG.Format("%0.1f---%d", meangf,m_A4Dlg.m_sFlatCorrection.ColorCorrection[1]);
		GetDlgItem(IDC_STATIC_AGExposure)->SetWindowText(csColorG);

		csColorB.Format("%0.1f---%d", meanbf,m_A4Dlg.m_sFlatCorrection.ColorCorrection[2]);
		GetDlgItem(IDC_STATIC_ABExposure)->SetWindowText(csColorB);

		csAColorlog.Format("彩色A面：R分量:%0.1f---%d, G分量:%0.1f---%d, B分量:%0.1f---%d", meanrf,m_A4Dlg.m_sFlatCorrection.ColorCorrection[0],meangf,m_A4Dlg.m_sFlatCorrection.ColorCorrection[1],meanbf,m_A4Dlg.m_sFlatCorrection.ColorCorrection[2]);
		WriteLog(csAColorlog);
	}


	if(bBColorWhiteImage)
	{
		vector<uchar> rcb;
		vector<uchar> gcb;
		vector<uchar> bcb;
		int sumrb = 0;
		int sumgb = 0;
		int sumbb = 0;
		double meanrb = 0.0;
		double meangb = 0.0;
		double meanbb = 0.0;

		histogram_bit32(matCBImage.data,matCBImage.rows,matCBImage.cols,rcb,gcb,bcb);
		sumrb = accumulate(rcb.begin(), rcb.end(), 0);
		meanrb =  sumrb / rcb.size();  //均值
		sumgb = accumulate(gcb.begin(), gcb.end(), 0);
		meangb =  sumgb / gcb.size();  //均值
		sumbb = accumulate(bcb.begin(), bcb.end(), 0);
		meanbb =  sumbb / bcb.size();  //均值

		int iBERAddStep = 0;
		int iBEGAddStep = 0;
		int iBEBAddStep = 0;
		int iBERPlusStep = 0;
		int iBEGPlusStep = 0;
		int iBEBPlusStep = 0;

		if(bBcolr)
		{
			if(meanrb < 148.00)
			{
				iBERMinStep = iBERMiddleStep;

				iBERAddStep = iBERMinStep + (iBERMaxStep - iBERMinStep)/2;

				m_A4Dlg.m_sFlatCorrection.ColorCorrection[15] = iBERAddStep;

				if(iBERAddStep != iBERMiddleStep)
				{
					iBERMiddleStep = iBERAddStep;
				}
				else
				{
					CString csMessage;
					csMessage.Format("白场彩色B面R参数需要调整,均值为%d,最大值为%d",meanrb,iBERMaxStep);
					MessageBox(csMessage);
					//MessageBox("白场彩色B面R参数需要调整");
					if(m_bParamError != true)
					{
						InitButton();
						m_bPause = true;
						m_bParamError = true;
						WEcycle = 0;
						return;
					}
				}
			}
			else if(meanrb > 152.00)
			{
				iBERMaxStep = iBERMiddleStep;

				iBERPlusStep = (iBERMaxStep - (iBERMaxStep - iBERMinStep)/2);

				m_A4Dlg.m_sFlatCorrection.ColorCorrection[15] = iBERPlusStep;

				if(iBERPlusStep != iBERMiddleStep)
				{
					iBERMiddleStep = iBERPlusStep;
				}
				else
				{
					CString csMessage;
					csMessage.Format("白场彩色A面B参数需要调整,均值为%d,最小值为%d",meanrb,iBERPlusStep);
					MessageBox(csMessage);
					//MessageBox("白场彩色B面R参数需要调整");
					if(m_bParamError != true)
					{
						InitButton();
						m_bPause = true;
						m_bParamError = true;
						WEcycle = 0;
						return;
					}
				}
			}
			else
			{
				bBcolr = false;
			}
		}

		if(bBcolg)
		{
			if(meangb < 148.00)
			{
				iBEGMinStep = iBEGMiddleStep;

				iBEGAddStep = iBEGMinStep + (iBEGMaxStep - iBEGMinStep)/2;

				m_A4Dlg.m_sFlatCorrection.ColorCorrection[16] = iBEGAddStep;

				if(iBEGAddStep != iBEGMiddleStep)
				{
					iBEGMiddleStep = iBEGAddStep;
				}
				else
				{
					CString csMessage;
					csMessage.Format("白场彩色B面G参数需要调整,均值为%d,最大值为%d",meangb,iBEGMaxStep);
					MessageBox(csMessage);
					//MessageBox("白场彩色B面G参数需要调整");
					if(m_bParamError != true)
					{
						InitButton();
						m_bPause = true;
						m_bParamError = true;
						WEcycle = 0;
						return;
					}
				}
			}
			else if(meangb > 152.00)
			{
				iBEGMaxStep = iBEGMiddleStep;

				iBEGPlusStep = (iBEGMaxStep - (iBEGMaxStep - iBEGMinStep)/2);

				m_A4Dlg.m_sFlatCorrection.ColorCorrection[16] = iBEGPlusStep;

				if(iBEGPlusStep != iBEGMiddleStep)
				{
					iBEGMiddleStep = iBEGPlusStep;
				}
				else
				{
					CString csMessage;
					csMessage.Format("白场彩色B面G参数需要调整,均值为%d,最小值为%d",meangb,iBEGPlusStep);
					MessageBox(csMessage);
					//MessageBox("白场彩色B面G参数需要调整");
					if(m_bParamError != true)
					{
						InitButton();
						m_bPause = true;
						m_bParamError = true;
						WEcycle = 0;
						return;
					}
				}
			}
			else
			{
				bBcolg = false;
			}
		}

		if(bBcolb)
		{
			if(meanbb < 148.00)
			{
				iBEBMinStep = iBEBMiddleStep;

				iBEBAddStep = iBEBMinStep + (iBEBMaxStep - iBEBMinStep)/2;

				m_A4Dlg.m_sFlatCorrection.ColorCorrection[17] = iBEBAddStep;

				if(iBEBAddStep != iBEBMiddleStep)
				{
					iBEBMiddleStep = iBEBAddStep;
				}
				else
				{
					CString csMessage;
					csMessage.Format("白场彩色B面G参数需要调整,均值为%d,最大值为%d",meanbb,iBEBMaxStep);
					MessageBox(csMessage);
					//MessageBox("白场彩色B面B参数需要调整");
					if(m_bParamError != true)
					{
						InitButton();
						m_bPause = true;
						m_bParamError = true;
						WEcycle = 0;
						return;
					}
				}
			}
			else if(meanbb > 152.00)
			{
				iBEBMaxStep = iBEBMiddleStep;

				iBEBPlusStep = (iBEBMaxStep - (iBEBMaxStep - iBEBMinStep)/2);

				m_A4Dlg.m_sFlatCorrection.ColorCorrection[17] = iBEBPlusStep;

				if(iBEBPlusStep != iBEBMiddleStep)
				{
					iBEBMiddleStep = iBEBPlusStep;
				}
				else
				{
					CString csMessage;
					csMessage.Format("白场彩色B面B参数需要调整,均值为%d,最小值为%d",meanbb,iBEBPlusStep);
					MessageBox(csMessage);
					//MessageBox("白场彩色B面B参数需要调整");
					if(m_bParamError != true)
					{
						InitButton();
						m_bPause = true;
						m_bParamError = true;
						WEcycle = 0;
						return;
					}
				}
			}
			else
			{
				bBcolb = false;
			}
		}

		if(!bBcolr && !bBcolg && !bBcolb)
		{
			bBColorWhiteImage = false;
		}

		CString csColorR,csColorG,csColorB,csBColorlog;
		csColorR.Format("%0.1f---%d", meanrb,m_A4Dlg.m_sFlatCorrection.ColorCorrection[15]);
		GetDlgItem(IDC_STATIC_BRExposure)->SetWindowText(csColorR);

		csColorG.Format("%0.1f---%d", meangb,m_A4Dlg.m_sFlatCorrection.ColorCorrection[16]);
		GetDlgItem(IDC_STATIC_BGExposure)->SetWindowText(csColorG);

		csColorB.Format("%0.1f---%d", meanbb,m_A4Dlg.m_sFlatCorrection.ColorCorrection[17]);
		GetDlgItem(IDC_STATIC_BBExposure)->SetWindowText(csColorB);

		csBColorlog.Format("彩色B面：R分量:%0.1f---%d, G分量:%0.1f---%d, B分量:%0.1f---%d", meanrb,m_A4Dlg.m_sFlatCorrection.ColorCorrection[15],meangb,m_A4Dlg.m_sFlatCorrection.ColorCorrection[16],meanbb,m_A4Dlg.m_sFlatCorrection.ColorCorrection[17]);
		WriteLog(csBColorlog);
	}

	mPicWGImage.release();
	mPicWCImage.release();
	matGFImage.release();
	matGBImage.release();
	matCFImage.release();
	matCBImage.release();

	if(!bAGrayWhiteImage && !bBGrayWhiteImage && !bAColorWhiteImage && !bBColorWhiteImage)
	{
		//MessageBox("白场校正完成");
		GetDlgItem(IDC_STATIC_STATUES2)->SetWindowText(_T("白场曝光校正完成"));
		m_pWExposure.SetCheck(1);

		if(0 == m_pWGain.GetCheck())
		{
			CorrectWhiteGain();
		}
		else
		{
			((CButton*)GetDlgItem(IDC_CheckParamSet))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_CheckParamRead))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_BTN_FLATM))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_BTN_BLACKFLAT))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_BTN_EXFLAT))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_BTN_GAINFLAT))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_BTN_FLAT))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_BTN_CONTINUE))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_BUTTON1))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_BTN_PARAMCFG))->EnableWindow(TRUE);
			((CButton*)GetDlgItem(IDC_BTN_PAUSE))->EnableWindow(FALSE);

			m_bPause = true;
		}
	}
	else
	{
		GetDlgItem(IDC_STATIC_STATUES2)->SetWindowText(_T("正在处理白场曝光校正..."));
		m_A4Dlg.WriteParamFile();
		CyclePro();
	}
}

void CHuaGoCorrectDlg::CorrectWhiteGain()
{
	cv::Mat mPicWGImage;
	cv::Mat mPicWCImage;
	cv::Mat matGFImage;
	cv::Mat matGBImage;
	cv::Mat matCFImage;
	cv::Mat matCBImage;

	WGcycle++;
	CString csCycle;
	csCycle.Format("循环处理第%d次", WGcycle);
	GetDlgItem(IDC_STATIC_WG)->SetWindowText(csCycle);

	int retg = m_drv->aquire_image(mPicWGImage,1);
	int retc = m_drv->aquire_image(mPicWCImage,3);

	if (retg && retc)
	{
		XdPrint("Failed - could not acquire image");
		return;
	}

	if (mPicWGImage.empty() && mPicWCImage.empty())
	{
		XdPrint("Failed - could not acquire image");
		return;
	}

	matGFImage = mPicWGImage(cv::Rect(0,0,mPicWGImage.cols/2,mPicWGImage.rows)).clone();
	matGBImage = mPicWGImage(cv::Rect(mPicWGImage.cols/2,0,mPicWGImage.cols/2,mPicWGImage.rows)).clone();
	matCFImage = mPicWCImage(cv::Rect(0,0,mPicWCImage.cols/2,mPicWCImage.rows)).clone();
	matCBImage = mPicWCImage(cv::Rect(mPicWCImage.cols/2,0,mPicWCImage.cols/2,mPicWCImage.rows)).clone();

	int igstep = 5;
	if(bAGrayWhiteGain)
	{
		vector<uchar> rgf;
		vector<uchar> ggf;
		vector<uchar> bgf;
		int sumf = 0;
		double meanf = 0.0;
		//int kk = m_matFImage.channels();
		histogram_bit32(matGFImage.data,matGFImage.rows,matGFImage.cols,rgf,ggf,bgf);
		sumf = accumulate(rgf.begin(), rgf.end(), 0);
		meanf =  sumf / rgf.size();  //均值

		if(meanf < 200.00)
		{
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[3] += igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[4] += igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[5] += igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[6] += igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[7] += igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[8] += igstep;
		}
		else if(meanf > 225.00)
		{
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[3] -= igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[4] -= igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[5] -= igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[6] -= igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[7] -= igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[8] -= igstep;
		}
		else
		{
			bAGrayWhiteGain = false;
		}

		CString csAGray;
		csAGray.Format("%d", m_A4Dlg.m_sFlatCorrection.GrayCorrection[3]);
		GetDlgItem(IDC_STATIC_AGain)->SetWindowText(csAGray);
	}

	if(bBGrayWhiteGain)
	{
		vector<uchar> rgb;
		vector<uchar> ggb;
		vector<uchar> bgb;
		int sumb = 0;
		double meanb =  0.0;  //均值
		histogram_bit32(matGBImage.data,matGBImage.rows,matGBImage.cols,rgb,ggb,bgb);
		sumb = accumulate(rgb.begin(), rgb.end(), 0);
		meanb =  sumb / rgb.size();  //均值

		if(meanb < 200.00)
		{
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[18] += igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[19] += igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[20] += igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[21] += igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[22] += igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[23] += igstep;
		}
		else if(meanb > 225.00)
		{
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[18] -= igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[19] -= igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[20] -= igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[21] -= igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[22] -= igstep;
			m_A4Dlg.m_sFlatCorrection.GrayCorrection[23] -= igstep;
		}
		else
		{
			bBGrayWhiteGain = false;
		}

		CString csBGray;
		csBGray.Format("%d", m_A4Dlg.m_sFlatCorrection.GrayCorrection[18]);
		GetDlgItem(IDC_STATIC_BGain)->SetWindowText(csBGray);
	}

	int icstep = 5;
	if(bAColorWhiteGain)
	{
		vector<uchar> rcf;
		vector<uchar> gcf;
		vector<uchar> bcf;
		int sumrf = 0;
		int sumgf = 0;
		int sumbf = 0;
		double meanrf = 0.0;
		double meangf = 0.0;
		double meanbf = 0.0;

		//int kk = m_matFImage.channels();
		histogram_bit32(matCFImage.data,matCFImage.rows,matCFImage.cols,rcf,gcf,bcf);
		sumrf = accumulate(rcf.begin(), rcf.end(), 0);
		meanrf =  sumrf / rcf.size();  //均值
		sumgf = accumulate(gcf.begin(), gcf.end(), 0);
		meangf =  sumgf / gcf.size();  //均值
		sumbf = accumulate(bcf.begin(), bcf.end(), 0);
		meanbf =  sumbf / bcf.size();  //均值

		if((meanrf < 200.00) || (meangf < 200.00) || (meanbf < 200.00))
		{
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[3] += igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[4] += igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[5] += igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[6] += igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[7] += igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[8] += igstep;
		}
		else if((meanrf > 225.00) || (meangf > 225.00) || (meanbf > 225.00))
		{
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[3] -= igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[4] -= igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[5] -= igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[6] -= igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[7] -= igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[8] -= igstep;
		}
		else
		{
			bAColorWhiteGain = false;
		}

		CString csColor;
		csColor.Format("%d", m_A4Dlg.m_sFlatCorrection.ColorCorrection[3]);
		GetDlgItem(IDC_STATIC_ACGain)->SetWindowText(csColor);
	}

	if(bBColorWhiteGain)
	{
		vector<uchar> rcb;
		vector<uchar> gcb;
		vector<uchar> bcb;
		int sumrb = 0;
		int sumgb = 0;
		int sumbb = 0;
		double meanrb = 0.0;
		double meangb = 0.0;
		double meanbb = 0.0;

		//int kk = m_matFImage.channels();
		histogram_bit32(matCBImage.data,matCBImage.rows,matCBImage.cols,rcb,gcb,bcb);
		sumrb = accumulate(rcb.begin(), rcb.end(), 0);
		meanrb =  sumrb / rcb.size();  //均值
		sumgb = accumulate(gcb.begin(), gcb.end(), 0);
		meangb =  sumgb / gcb.size();  //均值
		sumbb = accumulate(bcb.begin(), bcb.end(), 0);
		meanbb =  sumbb / bcb.size();  //均值

		if((meanrb < 200.00) || (meangb < 200.00) || (meanbb < 200.00))
		{
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[18] += igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[19] += igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[20] += igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[21] += igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[22] += igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[23] += igstep;
		}
		else if((meanrb > 225.00) || (meangb > 225.00) || (meanbb > 225.00))
		{
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[18] -= igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[19] -= igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[20] -= igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[21] -= igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[22] -= igstep;
			m_A4Dlg.m_sFlatCorrection.ColorCorrection[23] -= igstep;
		}
		else
		{
			bBColorWhiteGain = false;
		}

		CString csColor;
		csColor.Format("%d", m_A4Dlg.m_sFlatCorrection.ColorCorrection[18]);
		GetDlgItem(IDC_STATIC_BCGain)->SetWindowText(csColor);
	}

	mPicWGImage.release();
	mPicWCImage.release();
	matGFImage.release();
	matGBImage.release();
	matCFImage.release();
	matCBImage.release();

	if(!bAGrayWhiteGain && !bBGrayWhiteGain && !bAColorWhiteGain && !bBColorWhiteGain)
	{
		GetDlgItem(IDC_STATIC_STATUES3)->SetWindowText(_T("白场增益校正完成"));
		m_pWGain.SetCheck(1);
		CorrectFinish();
	}
	else
	{
		GetDlgItem(IDC_STATIC_STATUES3)->SetWindowText(_T("正在处理白场增益校正..."));
		m_A4Dlg.WriteParamFile();
		CyclePro();
	}
}

void CHuaGoCorrectDlg::CorrectFinish()
{
	for(int i = 0; i < 30; i++)
	{
		m_A4Dlg.m_sFlatCorrection.GrayFlat[i] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[i];
	}

	m_A4Dlg.m_sFlatCorrection.GrayFlat[3] += 24;
	m_A4Dlg.m_sFlatCorrection.GrayFlat[4] += 24;
	m_A4Dlg.m_sFlatCorrection.GrayFlat[5] += 24;
	m_A4Dlg.m_sFlatCorrection.GrayFlat[6] += 24;
	m_A4Dlg.m_sFlatCorrection.GrayFlat[7] += 24;
	m_A4Dlg.m_sFlatCorrection.GrayFlat[8] += 24;
	m_A4Dlg.m_sFlatCorrection.GrayFlat[18] += 24;
	m_A4Dlg.m_sFlatCorrection.GrayFlat[19] += 24;
	m_A4Dlg.m_sFlatCorrection.GrayFlat[20] += 24;
	m_A4Dlg.m_sFlatCorrection.GrayFlat[21] += 24;
	m_A4Dlg.m_sFlatCorrection.GrayFlat[22] += 24;
	m_A4Dlg.m_sFlatCorrection.GrayFlat[23] += 24;

	for(int j = 0; j < 30; j++)
	{
		m_A4Dlg.m_sFlatCorrection.ColorFlat[j] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[j];
	}

	m_A4Dlg.m_sFlatCorrection.ColorFlat[3] += 24;
	m_A4Dlg.m_sFlatCorrection.ColorFlat[4] += 24;
	m_A4Dlg.m_sFlatCorrection.ColorFlat[5] += 24;
	m_A4Dlg.m_sFlatCorrection.ColorFlat[6] += 24;
	m_A4Dlg.m_sFlatCorrection.ColorFlat[7] += 24;
	m_A4Dlg.m_sFlatCorrection.ColorFlat[8] += 24;
	m_A4Dlg.m_sFlatCorrection.ColorFlat[18] += 24;
	m_A4Dlg.m_sFlatCorrection.ColorFlat[19] += 24;
	m_A4Dlg.m_sFlatCorrection.ColorFlat[20] += 24;
	m_A4Dlg.m_sFlatCorrection.ColorFlat[21] += 24;
	m_A4Dlg.m_sFlatCorrection.ColorFlat[22] += 24;
	m_A4Dlg.m_sFlatCorrection.ColorFlat[23] += 24;

	m_A4Dlg.WriteParamFile();
	CorrectEndUpdate();

	MessageBox("校正完成");

	((CButton*)GetDlgItem(IDC_CheckParamSet))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_CheckParamRead))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BTN_FLATM))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BTN_BLACKFLAT))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BTN_EXFLAT))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BTN_GAINFLAT))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BTN_FLAT))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BTN_CONTINUE))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BUTTON1))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BTN_PARAMCFG))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BTN_PAUSE))->EnableWindow(FALSE);

	m_bPause = true;
}

void CHuaGoCorrectDlg::ShowFrontImage(int index)
{
	m_matFImage.release();
	m_matBImage.release();

	int retf = m_drv->aquire_image(m_matFImage,index);
	int retb = m_drv->aquire_image(m_matBImage,index+2);

	if (retf && retb)
	{
		XdPrint("Failed - could not acquire image");
		return;
	}

	if (m_matFImage.empty() && m_matBImage.empty())
	{
		XdPrint("Failed - could not acquire image");
		return;
	}

	CRect rectf,rectb;
	cv::Size winfSize(rectf.right, rectf.bottom);
	cv::Size winbSize(rectb.right, rectb.bottom);

	// Resize the source to the size of the destination image if necessary
	cv::Mat cvImgFTmp(winfSize, CV_8UC3);
	cv::Mat cvImgBTmp(winbSize, CV_8UC3);

	if (m_matFImage.size() != winfSize)
	{
		cv::resize(m_matFImage, cvImgFTmp, winfSize);
	}
	else
	{
		cvImgFTmp = m_matFImage;
	}

	if (m_matBImage.size() != winbSize)
	{
		cv::resize(m_matBImage, cvImgBTmp, winbSize);
	}
	else
	{
		cvImgBTmp = m_matBImage;
	}

	CImage imgfDst,imgbDst;
	Mat2CImage(&cvImgFTmp, imgfDst);
	Mat2CImage(&cvImgBTmp, imgbDst);
	//imgfDst.Draw(GetDlgItem(IDC_STATIC_PIC1)->GetDC()->GetSafeHdc(), rectf);
	//Sleep(500);
	//imgbDst.Draw(GetDlgItem(IDC_STATIC_PIC2)->GetDC()->GetSafeHdc(), rectb);
}

void CHuaGoCorrectDlg::ShowBackImage(int index)
{
	m_matFImage.release();
	m_matBImage.release();
	int retf = m_drv->aquire_image(m_matFImage,index);
	int retb = m_drv->aquire_image(m_matBImage,index+1);

	if (retf && retb)
	{
		XdPrint("Failed - could not acquire image");
		return;
	}

	if (m_matFImage.empty() && m_matBImage.empty())
	{
		XdPrint("Failed - could not acquire image");
		return;
	};

	CRect rectf,rectb;
	//GetDlgItem(IDC_STATIC_PIC1)->GetClientRect(&rectf);
	//GetDlgItem(IDC_STATIC_PIC2)->GetClientRect(&rectb);
	cv::Size winfSize(rectf.right, rectf.bottom);
	cv::Size winbSize(rectb.right, rectb.bottom);

	// Resize the source to the size of the destination image if necessary
	cv::Mat cvImgFTmp(winfSize, CV_8UC3);
	cv::Mat cvImgBTmp(winbSize, CV_8UC3);

	if (m_matFImage.size() != winfSize)
	{
		cv::resize(m_matFImage, cvImgFTmp, winfSize);
	}
	else
	{
		cvImgFTmp = m_matFImage;
	}

	if (m_matBImage.size() != winbSize)
	{
		cv::resize(m_matBImage, cvImgBTmp, winbSize);
	}
	else
	{
		cvImgBTmp = m_matBImage;
	}

	CImage imgfDst,imgbDst;
	Mat2CImage(&cvImgFTmp, imgfDst);
	Mat2CImage(&cvImgBTmp, imgbDst);
	//imgfDst.Draw(GetDlgItem(IDC_STATIC_PIC1)->GetDC()->GetSafeHdc(), rectf);
	//Sleep(500);
	//imgbDst.Draw(GetDlgItem(IDC_STATIC_PIC2)->GetDC()->GetSafeHdc(), rectb);
}


void CHuaGoCorrectDlg::CyclePro()
{
	
	UINT gains_Color[30] = {0};
	UINT gains_Gray[30] = {0};
	byte gain_Color[512] = {0};
	byte gain_Gray[512] = {0};
	byte gain_data_Color[524] = {0};
	byte gain_data_Gray[524] = {0};

	//WriteLog("偏置赋值");

	gains_Color[0] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[2];
	gains_Color[1] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[1];
	gains_Color[2] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[0];
	gains_Color[3] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[17];
	gains_Color[4] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[16];
	gains_Color[5] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[15];
	gains_Color[6] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[5];
	gains_Color[7] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[4];
	gains_Color[8] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[3];
	gains_Color[9] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[8];
	gains_Color[10] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[7];
	gains_Color[11] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[6];
	gains_Color[12] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[20];
	gains_Color[13] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[19];
	gains_Color[14] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[18];
	gains_Color[15] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[23];
	gains_Color[16] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[22];
	gains_Color[17] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[21];
	gains_Color[18] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[11];
	gains_Color[19] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[10];
	gains_Color[20] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[9];
	gains_Color[21] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[14];
	gains_Color[22] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[13];
	gains_Color[23] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[12];
	gains_Color[24] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[26];
	gains_Color[25] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[25];
	gains_Color[26] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[24];
	gains_Color[27] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[29];
	gains_Color[28] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[28];
	gains_Color[29] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[27];

	gains_Gray[0] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[2];
	gains_Gray[1] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[1];
	gains_Gray[2] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[0];
	gains_Gray[3] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[17];
	gains_Gray[4] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[16];
	gains_Gray[5] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[15];
	gains_Gray[6] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[5];
	gains_Gray[7] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[4];
	gains_Gray[8] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[3];
	gains_Gray[9] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[8];
	gains_Gray[10] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[7];
	gains_Gray[11] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[6];
	gains_Gray[12] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[20];
	gains_Gray[13] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[19];
	gains_Gray[14] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[18];
	gains_Gray[15] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[23];
	gains_Gray[16] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[22];
	gains_Gray[17] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[21];
	gains_Gray[18] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[11];
	gains_Gray[19] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[10];
	gains_Gray[20] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[9];
	gains_Gray[21] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[14];
	gains_Gray[22] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[13];
	gains_Gray[23] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[12];
	gains_Gray[24] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[26];
	gains_Gray[25] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[25];
	gains_Gray[26] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[24];
	gains_Gray[27] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[29];
	gains_Gray[28] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[28];
	gains_Gray[29] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[27];

	intToByte(gains_Color, gain_Color, 30);
	intToByte(gains_Gray, gain_Gray, 30);

	Sleep(1000);

	USBCBA4 ubc_Color;
	ubc_Color.u32_Command =  SEND_COLORCORRECT_FLAT;
	ubc_Color.u32_Count = 120;
	memcpy(ubc_Color.buffer,gain_Color,512);
	ubc_Color.u32_Data = 0;
	int length_Color = sizeof(ubc_Color);
	memmove(gain_data_Color,&ubc_Color,length_Color); 
	WriteLog("下发彩色平场校正指令");
	m_drv->SendColorCorrentFlat(gain_data_Color,length_Color);

	Sleep(2000);

	USBCBA4 ubc_Gray;
	ubc_Gray.u32_Command =  SEND_GRAYCORRECT_FLAT;
	ubc_Gray.u32_Count = 120;
	memcpy(ubc_Gray.buffer,gain_Gray,512);
	ubc_Gray.u32_Data = 0;
	int length_Gray = sizeof(ubc_Gray);
	memmove(gain_data_Gray,&ubc_Gray,length_Gray); 
	WriteLog("下发灰度平场校正指令");
	m_drv->SendGrayCorrectFlat(gain_data_Gray,length_Gray);
	
	Sleep(2000);
	
	//OnBnClickedBtnFlat();
	//WriteLog("图片队列清空");
	m_drv->reset();
	//WriteLog("开始平场校正");
	/*
	m_drv->FlatA4Conrrect();
	Sleep(28000);
	//WriteLog("暗场校正");

	if(1 == m_pBlack.GetCheck())
	{
		if(1 == m_pWExposure.GetCheck())
		{
			if(0 == m_pWGain.GetCheck())
			{
				CorrectWhiteGain();
			}
		}
		else
		{
			CorrectWhiteImage();
		}
	}
	else
	{
		CorrectBlackImage();
	}
	*/
}

void CHuaGoCorrectDlg::WriteLog(CString msg)
{
	if (!msg.IsEmpty())
	{
		FILE *pFile = fopen(".//log//CorrectLog.log", "a+");
		if (pFile != NULL)
		{
			char cTime[32];
			CTime currTime = CTime::GetCurrentTime();
			_snprintf(cTime, 30, "[%04d-%02d-%02d %02d:%02d:%02d]", 
				currTime.GetYear(), currTime.GetMonth(), currTime.GetDay(), 
				currTime.GetHour(), currTime.GetMinute(), currTime.GetSecond());
			fwrite(cTime, 1, strlen(cTime), pFile);
			fwrite(msg, 1, strlen(msg), pFile);
			fwrite("\n", 1, 1, pFile);
			fclose(pFile);
		}
	}
}

void CHuaGoCorrectDlg::CorrectCMDUpdate()
{
	//GetDlgItem(IDC_STATIC_SHOW)->SetWindowText(_T("校正参数下发"));
	//WriteLog(csCycle);
	m_A4Dlg.SaveNewParam(m_A4Dlg.m_iSelIndex);

	UINT gains_Color[30] = {0};
	UINT Color[30] = {0};
	UINT gains_Gray[30] = {0};
	UINT Gray[30] = {0};
	byte gain_Color[512] = {0};
	byte Colors[512] = {0};
	byte gain_Gray[512] = {0};
	byte Grays[512] = {0};
	byte gain_data_Color[524] = {0};
	byte data_Color[524] = {0};
	byte gain_data_Gray[524] = {0};
	byte data_Gray[524] = {0};

	gains_Color[0] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[0];
	gains_Color[1] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[1];
	gains_Color[2] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[2];
	gains_Color[3] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[15];
	gains_Color[4] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[16];
	gains_Color[5] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[17];
	gains_Color[6] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[3];
	gains_Color[7] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[4];
	gains_Color[8] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[5];
	gains_Color[9] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[6];
	gains_Color[10] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[7];
	gains_Color[11] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[8];
	gains_Color[12] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[18];
	gains_Color[13] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[19];
	gains_Color[14] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[20];
	gains_Color[15] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[21];
	gains_Color[16] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[22];
	gains_Color[17] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[23];
	gains_Color[18] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[9];
	gains_Color[19] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[10];
	gains_Color[20] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[11];
	gains_Color[21] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[12];
	gains_Color[22] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[13];
	gains_Color[23] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[14];
	gains_Color[24] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[24];
	gains_Color[25] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[25];
	gains_Color[26] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[26];
	gains_Color[27] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[27];
	gains_Color[28] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[28];
	gains_Color[29] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[29];

	Color[0] = m_A4Dlg.m_sFlatCorrection.ColorFlat[0];
	Color[1] = m_A4Dlg.m_sFlatCorrection.ColorFlat[1];
	Color[2] = m_A4Dlg.m_sFlatCorrection.ColorFlat[2];
	Color[3] = m_A4Dlg.m_sFlatCorrection.ColorFlat[15];
	Color[4] = m_A4Dlg.m_sFlatCorrection.ColorFlat[16];
	Color[5] = m_A4Dlg.m_sFlatCorrection.ColorFlat[17];
	Color[6] = m_A4Dlg.m_sFlatCorrection.ColorFlat[3];
	Color[7] = m_A4Dlg.m_sFlatCorrection.ColorFlat[4];
	Color[8] = m_A4Dlg.m_sFlatCorrection.ColorFlat[5];
	Color[9] = m_A4Dlg.m_sFlatCorrection.ColorFlat[6];
	Color[10] = m_A4Dlg.m_sFlatCorrection.ColorFlat[7];
	Color[11] = m_A4Dlg.m_sFlatCorrection.ColorFlat[8];
	Color[12] = m_A4Dlg.m_sFlatCorrection.ColorFlat[18];
	Color[13] = m_A4Dlg.m_sFlatCorrection.ColorFlat[19];
	Color[14] = m_A4Dlg.m_sFlatCorrection.ColorFlat[20];
	Color[15] = m_A4Dlg.m_sFlatCorrection.ColorFlat[21];
	Color[16] = m_A4Dlg.m_sFlatCorrection.ColorFlat[22];
	Color[17] = m_A4Dlg.m_sFlatCorrection.ColorFlat[23];
	Color[18] = m_A4Dlg.m_sFlatCorrection.ColorFlat[9];
	Color[19] = m_A4Dlg.m_sFlatCorrection.ColorFlat[10];
	Color[20] = m_A4Dlg.m_sFlatCorrection.ColorFlat[11];
	Color[21] = m_A4Dlg.m_sFlatCorrection.ColorFlat[12];
	Color[22] = m_A4Dlg.m_sFlatCorrection.ColorFlat[13];
	Color[23] = m_A4Dlg.m_sFlatCorrection.ColorFlat[14];
	Color[24] = m_A4Dlg.m_sFlatCorrection.ColorFlat[24];
	Color[25] = m_A4Dlg.m_sFlatCorrection.ColorFlat[25];
	Color[26] = m_A4Dlg.m_sFlatCorrection.ColorFlat[26];
	Color[27] = m_A4Dlg.m_sFlatCorrection.ColorFlat[27];
	Color[28] = m_A4Dlg.m_sFlatCorrection.ColorFlat[28];
	Color[29] = m_A4Dlg.m_sFlatCorrection.ColorFlat[29];

	gains_Gray[0] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[0];
	gains_Gray[1] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[1];
	gains_Gray[2] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[2];
	gains_Gray[3] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[15];
	gains_Gray[4] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[16];
	gains_Gray[5] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[17];
	gains_Gray[6] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[3];
	gains_Gray[7] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[4];
	gains_Gray[8] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[5];
	gains_Gray[9] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[6];
	gains_Gray[10] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[7];
	gains_Gray[11] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[8];
	gains_Gray[12] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[18];
	gains_Gray[13] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[19];
	gains_Gray[14] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[20];
	gains_Gray[15] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[21];
	gains_Gray[16] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[22];
	gains_Gray[17] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[23];
	gains_Gray[18] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[9];
	gains_Gray[19] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[10];
	gains_Gray[20] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[11];
	gains_Gray[21] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[12];
	gains_Gray[22] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[13];
	gains_Gray[23] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[14];
	gains_Gray[24] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[24];
	gains_Gray[25] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[25];
	gains_Gray[26] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[26];
	gains_Gray[27] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[27];
	gains_Gray[28] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[28];
	gains_Gray[29] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[29];

	Gray[0] = m_A4Dlg.m_sFlatCorrection.GrayFlat[0];
	Gray[1] = m_A4Dlg.m_sFlatCorrection.GrayFlat[1];
	Gray[2] = m_A4Dlg.m_sFlatCorrection.GrayFlat[2];
	Gray[3] = m_A4Dlg.m_sFlatCorrection.GrayFlat[15];
	Gray[4] = m_A4Dlg.m_sFlatCorrection.GrayFlat[16];
	Gray[5] = m_A4Dlg.m_sFlatCorrection.GrayFlat[17];
	Gray[6] = m_A4Dlg.m_sFlatCorrection.GrayFlat[3];
	Gray[7] = m_A4Dlg.m_sFlatCorrection.GrayFlat[4];
	Gray[8] = m_A4Dlg.m_sFlatCorrection.GrayFlat[5];
	Gray[9] = m_A4Dlg.m_sFlatCorrection.GrayFlat[6];
	Gray[10] = m_A4Dlg.m_sFlatCorrection.GrayFlat[7];
	Gray[11] = m_A4Dlg.m_sFlatCorrection.GrayFlat[8];
	Gray[12] = m_A4Dlg.m_sFlatCorrection.GrayFlat[18];
	Gray[13] = m_A4Dlg.m_sFlatCorrection.GrayFlat[19];
	Gray[14] = m_A4Dlg.m_sFlatCorrection.GrayFlat[20];
	Gray[15] = m_A4Dlg.m_sFlatCorrection.GrayFlat[21];
	Gray[16] = m_A4Dlg.m_sFlatCorrection.GrayFlat[22];
	Gray[17] = m_A4Dlg.m_sFlatCorrection.GrayFlat[23];
	Gray[18] = m_A4Dlg.m_sFlatCorrection.GrayFlat[9];
	Gray[19] = m_A4Dlg.m_sFlatCorrection.GrayFlat[10];
	Gray[20] = m_A4Dlg.m_sFlatCorrection.GrayFlat[11];
	Gray[21] = m_A4Dlg.m_sFlatCorrection.GrayFlat[12];
	Gray[22] = m_A4Dlg.m_sFlatCorrection.GrayFlat[13];
	Gray[23] = m_A4Dlg.m_sFlatCorrection.GrayFlat[14];
	Gray[24] = m_A4Dlg.m_sFlatCorrection.GrayFlat[24];
	Gray[25] = m_A4Dlg.m_sFlatCorrection.GrayFlat[25];
	Gray[26] = m_A4Dlg.m_sFlatCorrection.GrayFlat[26];
	Gray[27] = m_A4Dlg.m_sFlatCorrection.GrayFlat[27];
	Gray[28] = m_A4Dlg.m_sFlatCorrection.GrayFlat[28];
	Gray[29] = m_A4Dlg.m_sFlatCorrection.GrayFlat[29];

	intToByte(gains_Color, gain_Color, 30);
	intToByte(Color, Colors, 30);
	intToByte(gains_Gray, gain_Gray, 30);
	intToByte(Gray, Grays, 30);

	Sleep(1000);
	
	USBCBA4 ubc_Color;
	ubc_Color.u32_Command =  SEND_COLORCORRECT_FLAT;
	ubc_Color.u32_Count = 120;
	memcpy(ubc_Color.buffer,gain_Color,512);
	ubc_Color.u32_Data = 0;
	int length_Color = sizeof(ubc_Color);
	memmove(gain_data_Color,&ubc_Color,length_Color); 
	m_drv->SendColorCorrentFlat(gain_data_Color,length_Color);
	
	Sleep(1000);

	USBCBA4 ubc_Colors;
	ubc_Colors.u32_Command =  SEND_COLOR_FLAT;
	ubc_Colors.u32_Count = 120;
	memcpy(ubc_Colors.buffer,Colors,512);
	ubc_Colors.u32_Data = 0;
	int length_Colors = sizeof(ubc_Colors);
	memmove(data_Color,&ubc_Colors,length_Colors); 
	m_drv->SendColorFlat(data_Color,length_Colors);

	Sleep(1000);
	
	USBCBA4 ubc_Gray;
	ubc_Gray.u32_Command =  SEND_GRAYCORRECT_FLAT;
	ubc_Gray.u32_Count = 120;
	memcpy(ubc_Gray.buffer,gain_Gray,512);
	ubc_Gray.u32_Data = 0;
	int length_Gray = sizeof(ubc_Gray);
	memmove(gain_data_Gray,&ubc_Gray,length_Gray); 
	m_drv->SendGrayCorrectFlat(gain_data_Gray,length_Gray);
	
	Sleep(1000);

	USBCBA4 ubc_Grays;
	ubc_Grays.u32_Command =  SEND_GRAY_FLAT;
	ubc_Grays.u32_Count = 120;
	memcpy(ubc_Grays.buffer,Grays,512);
	ubc_Grays.u32_Data = 0;
	int length_Grays = sizeof(ubc_Grays);
	memmove(data_Gray,&ubc_Grays,length_Grays); 
	m_drv->SendGrayFlat(data_Gray,length_Grays);

	//m_A4Dlg.WriteParamFile();

	MessageBox(_T("校正参数设置成功"));
}

void CHuaGoCorrectDlg::CorrectEndUpdate()
{
	UINT gains_Color[30] = {0};
	UINT Color[30] = {0};
	UINT gains_Gray[30] = {0};
	UINT Gray[30] = {0};
	byte gain_Color[512] = {0};
	byte Colors[512] = {0};
	byte gain_Gray[512] = {0};
	byte Grays[512] = {0};
	byte gain_data_Color[524] = {0};
	byte data_Color[524] = {0};
	byte gain_data_Gray[524] = {0};
	byte data_Gray[524] = {0};

	gains_Color[0] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[2];
	gains_Color[1] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[1];
	gains_Color[2] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[0];
	gains_Color[3] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[17];
	gains_Color[4] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[16];
	gains_Color[5] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[15];
	gains_Color[6] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[5];
	gains_Color[7] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[4];
	gains_Color[8] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[3];
	gains_Color[9] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[8];
	gains_Color[10] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[7];
	gains_Color[11] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[6];
	gains_Color[12] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[20];
	gains_Color[13] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[19];
	gains_Color[14] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[18];
	gains_Color[15] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[23];
	gains_Color[16] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[22];
	gains_Color[17] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[21];
	gains_Color[18] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[11];
	gains_Color[19] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[10];
	gains_Color[20] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[9];
	gains_Color[21] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[14];
	gains_Color[22] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[13];
	gains_Color[23] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[12];
	gains_Color[24] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[26];
	gains_Color[25] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[25];
	gains_Color[26] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[24];
	gains_Color[27] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[29];
	gains_Color[28] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[28];
	gains_Color[29] = m_A4Dlg.m_sFlatCorrection.ColorCorrection[27];

	Color[0] = m_A4Dlg.m_sFlatCorrection.ColorFlat[2];
	Color[1] = m_A4Dlg.m_sFlatCorrection.ColorFlat[1];
	Color[2] = m_A4Dlg.m_sFlatCorrection.ColorFlat[0];
	Color[3] = m_A4Dlg.m_sFlatCorrection.ColorFlat[17];
	Color[4] = m_A4Dlg.m_sFlatCorrection.ColorFlat[16];
	Color[5] = m_A4Dlg.m_sFlatCorrection.ColorFlat[15];
	Color[6] = m_A4Dlg.m_sFlatCorrection.ColorFlat[5];
	Color[7] = m_A4Dlg.m_sFlatCorrection.ColorFlat[4];
	Color[8] = m_A4Dlg.m_sFlatCorrection.ColorFlat[3];
	Color[9] = m_A4Dlg.m_sFlatCorrection.ColorFlat[8];
	Color[10] = m_A4Dlg.m_sFlatCorrection.ColorFlat[7];
	Color[11] = m_A4Dlg.m_sFlatCorrection.ColorFlat[6];
	Color[12] = m_A4Dlg.m_sFlatCorrection.ColorFlat[20];
	Color[13] = m_A4Dlg.m_sFlatCorrection.ColorFlat[19];
	Color[14] = m_A4Dlg.m_sFlatCorrection.ColorFlat[18];
	Color[15] = m_A4Dlg.m_sFlatCorrection.ColorFlat[23];
	Color[16] = m_A4Dlg.m_sFlatCorrection.ColorFlat[22];
	Color[17] = m_A4Dlg.m_sFlatCorrection.ColorFlat[21];
	Color[18] = m_A4Dlg.m_sFlatCorrection.ColorFlat[11];
	Color[19] = m_A4Dlg.m_sFlatCorrection.ColorFlat[10];
	Color[20] = m_A4Dlg.m_sFlatCorrection.ColorFlat[9];
	Color[21] = m_A4Dlg.m_sFlatCorrection.ColorFlat[14];
	Color[22] = m_A4Dlg.m_sFlatCorrection.ColorFlat[13];
	Color[23] = m_A4Dlg.m_sFlatCorrection.ColorFlat[12];
	Color[24] = m_A4Dlg.m_sFlatCorrection.ColorFlat[26];
	Color[25] = m_A4Dlg.m_sFlatCorrection.ColorFlat[25];
	Color[26] = m_A4Dlg.m_sFlatCorrection.ColorFlat[24];
	Color[27] = m_A4Dlg.m_sFlatCorrection.ColorFlat[29];
	Color[28] = m_A4Dlg.m_sFlatCorrection.ColorFlat[28];
	Color[29] = m_A4Dlg.m_sFlatCorrection.ColorFlat[27];

	gains_Gray[0] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[2];
	gains_Gray[1] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[1];
	gains_Gray[2] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[0];
	gains_Gray[3] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[17];
	gains_Gray[4] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[16];
	gains_Gray[5] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[15];
	gains_Gray[6] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[5];
	gains_Gray[7] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[4];
	gains_Gray[8] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[3];
	gains_Gray[9] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[8];
	gains_Gray[10] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[7];
	gains_Gray[11] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[6];
	gains_Gray[12] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[20];
	gains_Gray[13] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[19];
	gains_Gray[14] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[18];
	gains_Gray[15] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[23];
	gains_Gray[16] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[22];
	gains_Gray[17] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[21];
	gains_Gray[18] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[11];
	gains_Gray[19] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[10];
	gains_Gray[20] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[9];
	gains_Gray[21] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[14];
	gains_Gray[22] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[13];
	gains_Gray[23] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[12];
	gains_Gray[24] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[26];
	gains_Gray[25] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[25];
	gains_Gray[26] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[24];
	gains_Gray[27] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[29];
	gains_Gray[28] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[28];
	gains_Gray[29] = m_A4Dlg.m_sFlatCorrection.GrayCorrection[27];

	Gray[0] = m_A4Dlg.m_sFlatCorrection.GrayFlat[2];
	Gray[1] = m_A4Dlg.m_sFlatCorrection.GrayFlat[1];
	Gray[2] = m_A4Dlg.m_sFlatCorrection.GrayFlat[0];
	Gray[3] = m_A4Dlg.m_sFlatCorrection.GrayFlat[17];
	Gray[4] = m_A4Dlg.m_sFlatCorrection.GrayFlat[16];
	Gray[5] = m_A4Dlg.m_sFlatCorrection.GrayFlat[15];
	Gray[6] = m_A4Dlg.m_sFlatCorrection.GrayFlat[5];
	Gray[7] = m_A4Dlg.m_sFlatCorrection.GrayFlat[4];
	Gray[8] = m_A4Dlg.m_sFlatCorrection.GrayFlat[3];
	Gray[9] = m_A4Dlg.m_sFlatCorrection.GrayFlat[8];
	Gray[10] = m_A4Dlg.m_sFlatCorrection.GrayFlat[7];
	Gray[11] = m_A4Dlg.m_sFlatCorrection.GrayFlat[6];
	Gray[12] = m_A4Dlg.m_sFlatCorrection.GrayFlat[20];
	Gray[13] = m_A4Dlg.m_sFlatCorrection.GrayFlat[19];
	Gray[14] = m_A4Dlg.m_sFlatCorrection.GrayFlat[18];
	Gray[15] = m_A4Dlg.m_sFlatCorrection.GrayFlat[23];
	Gray[16] = m_A4Dlg.m_sFlatCorrection.GrayFlat[22];
	Gray[17] = m_A4Dlg.m_sFlatCorrection.GrayFlat[21];
	Gray[18] = m_A4Dlg.m_sFlatCorrection.GrayFlat[11];
	Gray[19] = m_A4Dlg.m_sFlatCorrection.GrayFlat[10];
	Gray[20] = m_A4Dlg.m_sFlatCorrection.GrayFlat[9];
	Gray[21] = m_A4Dlg.m_sFlatCorrection.GrayFlat[14];
	Gray[22] = m_A4Dlg.m_sFlatCorrection.GrayFlat[13];
	Gray[23] = m_A4Dlg.m_sFlatCorrection.GrayFlat[12];
	Gray[24] = m_A4Dlg.m_sFlatCorrection.GrayFlat[26];
	Gray[25] = m_A4Dlg.m_sFlatCorrection.GrayFlat[25];
	Gray[26] = m_A4Dlg.m_sFlatCorrection.GrayFlat[24];
	Gray[27] = m_A4Dlg.m_sFlatCorrection.GrayFlat[29];
	Gray[28] = m_A4Dlg.m_sFlatCorrection.GrayFlat[28];
	Gray[29] = m_A4Dlg.m_sFlatCorrection.GrayFlat[27];

	intToByte(gains_Color, gain_Color, 30);
	intToByte(Color, Colors, 30);
	intToByte(gains_Gray, gain_Gray, 30);
	intToByte(Gray, Grays, 30);

	Sleep(1000);
	
	USBCBA4 ubc_Color;
	ubc_Color.u32_Command =  SEND_COLORCORRECT_FLAT;
	ubc_Color.u32_Count = 120;
	memcpy(ubc_Color.buffer,gain_Color,512);
	ubc_Color.u32_Data = 0;
	int length_Color = sizeof(ubc_Color);
	memmove(gain_data_Color,&ubc_Color,length_Color); 
	m_drv->SendColorCorrentFlat(gain_data_Color,length_Color);
	
	Sleep(1000);

	USBCBA4 ubc_Colors;
	ubc_Colors.u32_Command =  SEND_COLOR_FLAT;
	ubc_Colors.u32_Count = 120;
	memcpy(ubc_Colors.buffer,Colors,512);
	ubc_Colors.u32_Data = 0;
	int length_Colors = sizeof(ubc_Colors);
	memmove(data_Color,&ubc_Colors,length_Colors); 
	m_drv->SendColorFlat(data_Color,length_Colors);

	Sleep(1000);
	
	USBCBA4 ubc_Gray;
	ubc_Gray.u32_Command =  SEND_GRAYCORRECT_FLAT;
	ubc_Gray.u32_Count = 120;
	memcpy(ubc_Gray.buffer,gain_Gray,512);
	ubc_Gray.u32_Data = 0;
	int length_Gray = sizeof(ubc_Gray);
	memmove(gain_data_Gray,&ubc_Gray,length_Gray); 
	m_drv->SendGrayCorrectFlat(gain_data_Gray,length_Gray);
	
	Sleep(1000);

	USBCBA4 ubc_Grays;
	ubc_Grays.u32_Command =  SEND_GRAY_FLAT;
	ubc_Grays.u32_Count = 120;
	memcpy(ubc_Grays.buffer,Grays,512);
	ubc_Grays.u32_Data = 0;
	int length_Grays = sizeof(ubc_Grays);
	memmove(data_Gray,&ubc_Grays,length_Grays); 
	m_drv->SendGrayFlat(data_Gray,length_Grays);

	//m_A4Dlg.WriteParamFile();

	switch (m_A4Dlg.m_iSelIndex)   
	{     
	case 0:
		m_A4Dlg.default0param();
		break;      
	case 1:
		m_A4Dlg.default1param();
		break;
	case 2:
		m_A4Dlg.default2param();
		break;      
	case 3:
		m_A4Dlg.default3param();
		break; 
	default:   
		break;   
	}  

	GetDlgItem(IDC_STATIC_SHOW)->SetWindowText(_T("校正参数设置成功"));
}

void CHuaGoCorrectDlg::OnBnClickedBtnFlatm()
{
	// TODO: 在此添加控件通知处理程序代码
	if (!m_drv->IsConnected())
	{
		MessageBox("扫描仪未连接！");
		return;
	}

	m_drv->reset();
	m_drv->DevStateChange();
	GetDlgItem(IDC_STATIC_NUM)->SetWindowText("0");
	GetDlgItem(IDC_STATIC_SHOW)->SetWindowText(_T(""));

	if (m_tab.GetCurSel() == 1)
	{

		m_drv->FlatA4();

/*
		if (b_review||b_suspend)
			KillTimer(N_TIMER_SEC);
		b_review = FALSE;
		b_suspend = FALSE;
		n_hour = 0;
		n_minute = 0;
		n_second = 0;
		SetTimer(N_TIMER_SEC, N_TIME_SEC, NULL);
		SetTimer(N_TIMER_SHOW, N_TIME_SHOW, NULL);*/

		//Sleep(28000);
		//MessageBox("校正完成");

		//OnBnClickedStopScan();
	}
	else
	{

	}
}

void CHuaGoCorrectDlg::FSongleCorrect()
{
	m_drv->reset();
	m_drv->DevStateChange();

	GetDlgItem(IDC_STATIC_SHOW)->SetWindowText(_T(""));
	m_drv->FlatA4();

	SetTimer(N_TIMER_SEC, N_TIME_SEC, NULL);
	SetTimer(N_TIMER_SHOW, N_TIME_SHOW, NULL);
}


void CHuaGoCorrectDlg::OnCancel()
{
	// TODO: 在此添加专用代码和/或调用基类
	m_CISDlg.set_config();
	m_dis.updatadistorionparam();
	if (IDOK != AfxMessageBox("确定要退出服务器吗？", MB_ICONQUESTION|MB_OKCANCEL))
	{		
		return;
	}

	m_bExit = TRUE;
	CDialogEx::OnCancel();
}


void CHuaGoCorrectDlg::OnBnClickedBtnBlackflat()
{
	// TODO: 在此添加控件通知处理程序代码
	((CButton*)GetDlgItem(IDC_CheckParamSet))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_CheckParamRead))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_FLATM))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_BLACKFLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_EXFLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_GAINFLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_FLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_CONTINUE))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BUTTON1))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_PARAMCFG))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_PAUSE))->EnableWindow(TRUE);

	iAMaxStep = iAMaxStep * 2;
	if(iAMaxStep > 255)
	{
		iAMaxStep = 255;
	}
	iAMiddleStep = iAMaxStep;
	iAMinStep = 0;

	iBMaxStep = iBMaxStep * 2;
	if(iBMaxStep > 255)
	{
		iBMaxStep = 255;
	}
	iBMiddleStep = iBMaxStep;
	iBMinStep = 0;

	m_pWExposure.SetCheck(1);
	m_pWGain.SetCheck(1);
	m_bPause = false;
}


void CHuaGoCorrectDlg::OnBnClickedBtnExflat()
{
	// TODO: 在此添加控件通知处理程序代码
	((CButton*)GetDlgItem(IDC_CheckParamSet))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_CheckParamRead))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_FLATM))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_BLACKFLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_EXFLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_GAINFLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_FLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_CONTINUE))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BUTTON1))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_PARAMCFG))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_PAUSE))->EnableWindow(TRUE);

	iAERMaxStep = iAERMaxStep * 2;
	if(iAERMaxStep > 900)
	{
		iAERMaxStep = 900;
	}
	iAERMiddleStep = iAERMaxStep;
	iAERMinStep = 0;

	iAEGMaxStep = iAEGMaxStep * 2;
	if(iAEGMaxStep > 900)
	{
		iAEGMaxStep = 900;
	}
	iAEGMiddleStep = iAEGMaxStep;
	iAEGMinStep = 0;

	iAEBMaxStep = iAEBMaxStep * 2;
	if(iAEBMaxStep > 900)
	{
		iAEBMaxStep = 900;
	}
	iAEBMiddleStep = iAEBMaxStep;
	iAEBMinStep = 0;

	iBERMaxStep = iBERMaxStep * 2;
	if(iBERMaxStep > 900)
	{
		iBERMaxStep = 900;
	}
	iBERMiddleStep = iBERMaxStep;
	iBERMinStep = 0;

	iBEGMaxStep = iBEGMaxStep * 2;
	if(iBEGMaxStep > 900)
	{
		iBEGMaxStep = 900;
	}
	iBEGMiddleStep = iBEGMaxStep;
	iBEGMinStep = 0;

	iBEBMaxStep = iBEBMaxStep * 2;
	if(iBEBMaxStep > 900)
	{
		iBEBMaxStep = 900;
	}
	iBEBMiddleStep = iBEBMaxStep;
	iBEBMinStep = 0;

	m_pBlack.SetCheck(1);
	m_pWGain.SetCheck(1);
	m_bPause = false;
}


void CHuaGoCorrectDlg::OnBnClickedBtnGainflat()
{
	// TODO: 在此添加控件通知处理程序代码
	((CButton*)GetDlgItem(IDC_CheckParamSet))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_CheckParamRead))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_FLATM))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_BLACKFLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_EXFLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_GAINFLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_FLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_CONTINUE))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BUTTON1))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_PARAMCFG))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_PAUSE))->EnableWindow(TRUE);

	m_pBlack.SetCheck(1);
	m_pWExposure.SetCheck(1);
	m_bPause = false;
}


void CHuaGoCorrectDlg::OnBnClickedBtnContinue()
{
	// TODO: 在此添加控件通知处理程序代码
	((CButton*)GetDlgItem(IDC_CheckParamSet))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_CheckParamRead))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_FLATM))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_BLACKFLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_EXFLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_GAINFLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_FLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_CONTINUE))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BUTTON1))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_PARAMCFG))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_PAUSE))->EnableWindow(TRUE);

	m_bPause = false;
}


void CHuaGoCorrectDlg::OnBnClickedBtnPause()
{
	// TODO: 在此添加控件通知处理程序代码
	((CButton*)GetDlgItem(IDC_CheckParamSet))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_CheckParamRead))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BTN_FLATM))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BTN_BLACKFLAT))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BTN_EXFLAT))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BTN_GAINFLAT))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BTN_FLAT))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BTN_CONTINUE))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BUTTON1))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BTN_PARAMCFG))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BTN_PAUSE))->EnableWindow(FALSE);

	m_bPause = true;
}

void CHuaGoCorrectDlg::InitButton()
{
	((CButton*)GetDlgItem(IDC_CheckParamSet))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_CheckParamRead))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_FLATM))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_BLACKFLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_EXFLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_GAINFLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_FLAT))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_CONTINUE))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BUTTON1))->EnableWindow(FALSE);
	((CButton*)GetDlgItem(IDC_BTN_PARAMCFG))->EnableWindow(TRUE);
	((CButton*)GetDlgItem(IDC_BTN_PAUSE))->EnableWindow(FALSE);
}

void CHuaGoCorrectDlg::OnCbnSelChangeDpi()
{
	// TODO: 在此添加控件通知处理程序代码
	m_iDpiIndex = m_ComboxDpi.GetCurSel(); 
}


void CHuaGoCorrectDlg::OnCbnSelChangeColor()
{
	// TODO: 在此添加控件通知处理程序代码
	m_iColorIndex = m_ComboxColor.GetCurSel(); 

	if(0 == m_iColorIndex)
	{
		m_drv->set_decompress_pix_type(TWPT_GRAY);
	}
	else
	{
		//m_drv->set_decompress_pix_type(TJPF_BGR);
		m_drv->set_decompress_pix_type(TWPT_RGB);
	}
}


void CHuaGoCorrectDlg::OnBnClickedConfirm()
{
	// TODO: 在此添加控件通知处理程序代码	
	m_iPicIndex = 0;
	if (!m_drv->IsConnected())
	{
		MessageBox("扫描仪未连接！");
		return;
	}

	GetDlgItem(IDC_STATIC_NUM)->SetWindowText("0");
	m_drv->DevStateChange();
	m_drv->reset();

	Scan();
	papercount = 0;

	//切换到tab3
	//m_tab.SetCurSel(2);
	//RefreshTabChange();
}


void CHuaGoCorrectDlg::OnBnClickedBtnParamcfg()
{
	// TODO: 在此添加控件通知处理程序代码
	if (IDOK == m_ConfigParam.DoModal())
	{
		ConfigParamUpdate();
		m_A4Dlg.LoadCfg();
		m_A4Dlg.default0param();

		((CButton*)GetDlgItem(IDC_CheckParamSet))->EnableWindow(TRUE);
		((CButton*)GetDlgItem(IDC_CheckParamRead))->EnableWindow(TRUE);
		((CButton*)GetDlgItem(IDC_BTN_FLATM))->EnableWindow(TRUE);
		((CButton*)GetDlgItem(IDC_BTN_BLACKFLAT))->EnableWindow(TRUE);
		((CButton*)GetDlgItem(IDC_BTN_EXFLAT))->EnableWindow(TRUE);
		((CButton*)GetDlgItem(IDC_BTN_GAINFLAT))->EnableWindow(TRUE);
		((CButton*)GetDlgItem(IDC_BTN_FLAT))->EnableWindow(TRUE);
		((CButton*)GetDlgItem(IDC_BTN_CONTINUE))->EnableWindow(TRUE);
		((CButton*)GetDlgItem(IDC_BUTTON1))->EnableWindow(TRUE);
		((CButton*)GetDlgItem(IDC_BTN_PARAMCFG))->EnableWindow(TRUE);
		((CButton*)GetDlgItem(IDC_BTN_PAUSE))->EnableWindow(TRUE);
	}
}

void CHuaGoCorrectDlg::ConfigParamUpdate()
{
	iAMaxStep = m_ConfigParam.m_AMaxStep;
	iAMiddleStep = iAMaxStep;
	iAMinStep = m_ConfigParam.m_AMinStep;
	iBMaxStep = m_ConfigParam.m_BMaxStep;
	iBMiddleStep = iBMaxStep;
	iBMinStep = m_ConfigParam.m_BMinStep;

	iAERMaxStep = m_ConfigParam.m_AERMaxStep;
	iAERMiddleStep = iAERMaxStep;
	iAERMinStep = m_ConfigParam.m_AERMinStep;

	iAEGMaxStep = m_ConfigParam.m_AEGMaxStep;
	iAEGMiddleStep = iAEGMaxStep;
	iAEGMinStep = m_ConfigParam.m_AEGMinStep;

	iAEBMaxStep = m_ConfigParam.m_AEBMaxStep;
	iAEBMiddleStep = iAEBMaxStep;
	iAEBMinStep = m_ConfigParam.m_AEBMinStep;

	iBERMaxStep = m_ConfigParam.m_BERMaxStep;
	iBERMiddleStep = iBERMaxStep;
	iBERMinStep = m_ConfigParam.m_BERMinStep;

	iBEGMaxStep = m_ConfigParam.m_BEGMaxStep;
	iBEGMiddleStep = iBEGMaxStep;
	iBEGMinStep = m_ConfigParam.m_BEGMinStep;

	iBEBMaxStep = m_ConfigParam.m_BEBMaxStep;
	iBEBMiddleStep = iBEBMaxStep;
	iBEBMinStep = m_ConfigParam.m_BEBMinStep;

	iGainStep = m_ConfigParam.m_GainStep;
}

afx_msg LRESULT CHuaGoCorrectDlg::OnMyMessage(/*HWND hWnd, UINT Msg, */ WPARAM wParam, LPARAM lParam)
{
	CString sParam = "";
	int nParam = 0;
	nParam = wParam;
	sParam.Format(_T("%d"),nParam);

	if(nParam != 200)
	{
		GetDlgItem(IDC_STATIC_NUM)->SetWindowText(sParam);
		CString sMessage;
		sMessage.Format("当前扫描第%s张图片,累计消耗时间%s%s%s",sParam,s_hour,s_minute,s_second);
		WriteLog(sMessage);
	}
	else
	{
		
		KillTimer(N_TIMER_SEC);
		KillTimer(N_TIMER_SHOW);
// 		GetDlgItem(IDC_STATIC_SHOW)->SetWindowText(_T("校正完成"));
// 		Sleep(5000);
// 		FSongleCorrect();
	}

	return 0;
}


void CHuaGoCorrectDlg::OnBnClickedStopScan()
{
	// TODO: 在此添加控件通知处理程序代码
	b_suspend =!b_suspend;
	if (b_suspend)
	{
		KillTimer(N_TIMER_SEC);
		KillTimer(N_TIMER_SHOW);
		int h1, h2, m1, m2, s1, s2;
		h1 = n_hour / 10;
		h2 = n_hour % 10;
		m1 = n_minute / 10;
		m2 = n_minute % 10;
		s1 = n_second / 10;
		s2 = n_second % 10;
		s_hour.Format("%d%d", h1, h2);
		s_minute.Format("%d%d", m1, m2);
		s_second.Format("%d%d", s1, s2);
		UpdateData(FALSE);
	}

	m_drv->Stop_scan();
// 	else
// 	{
// 		SetTimer(N_TIMER_SEC, N_TIME_SEC, NULL);
// 		SetTimer(N_TIMER_SHOW, N_TIME_SHOW, NULL);
// 	}
}


void CHuaGoCorrectDlg::OnTimer(UINT_PTR nIDEvent)
{
	// TODO: 在此添加消息处理程序代码和/或调用默认值
	switch (nIDEvent)
	{
	case 1:
		{
			if (b_review == FALSE)
			{
				n_second++;
				if (n_second == 60)
				{
					n_second = 0;
					n_minute++;
				}
				if (n_minute == 60)
				{
					n_minute = 0;
					n_hour++;
				}
				/*
				if (n_hour == 1)
					n_hour = 0;

				if (n_minute == 5)
					b_review = TRUE;*/
			}
			else if (b_review)
			{
				n_hour = 0;
				n_minute = 0;
				n_second = 0;
				s_hour.Format("%s", "Re");
				s_minute.Format("%s", "vi");
				s_second.Format("%s", "ew");
			}
		}
	case 2:
		{
			if (b_review == FALSE)
			{
				int h1, h2, m1, m2, s1, s2;
				h1 = n_hour / 10;
				h2 = n_hour % 10;
				m1 = n_minute / 10;
				m2 = n_minute % 10;
				s1 = n_second / 10;
				s2 = n_second % 10;
				s_hour.Format("%d%d", h1, h2);
				s_minute.Format("%d%d", m1, m2);
				s_second.Format("%d%d", s1, s2);
			}
			else if (b_review)
			{
				n_hour = 0;
				n_minute = 0;
				n_second = 0;
				s_hour.Format("%s", "Re");
				s_minute.Format("%s", "vi");
				s_second.Format("%s", "ew");
			}
			UpdateData(FALSE);
		}
	default:
		break;
	}

	CDialogEx::OnTimer(nIDEvent);
}




void CHuaGoCorrectDlg::OnCbnSelchangeCombo1()
{
	// TODO: 在此添加控件通知处理程序代码
	CString num;
	CString text;
	int cursel = Version.GetCurSel();
	num.Format("%d", cursel);
	if(m_drv->isusbopened())
		m_drv->close();

	if(m_drv->device_id==0)
		MessageBox(TEXT("未找到设备!"), TEXT("提示"), MB_OK | MB_ICONWARNING);
    m_drv->open(Version_id[cursel][0], Version_id[cursel][1], 0);
	if (!m_drv->isusbopened())
		MessageBox(TEXT("未找到设备!"), TEXT("提示"), MB_OK | MB_ICONWARNING);
	::WritePrivateProfileString(_T("USB"), _T("Version_num"), _T(num), INI_FILE_NAME);
	
}