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

#include "stdafx.h"
#include "GeoMative.h"
#include "crossHole/CCrossHoleConfig3DMainDlg.h"
#include "crossHole/C3DSimulationDlg.h"
#include "afxdialogex.h"

extern CGeoMativeApp theApp;
// CCrossHoleConfig3DMainDlg 对话框

IMPLEMENT_DYNAMIC(CCrossHoleConfig3DMainDlg, CDialog)

CCrossHoleConfig3DMainDlg::CCrossHoleConfig3DMainDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CCrossHoleConfig3DMainDlg::IDD, pParent)
{
	m_uiTPamount = 0;
	m_mapDatabaseABMNInfo.clear();
}

CCrossHoleConfig3DMainDlg::~CCrossHoleConfig3DMainDlg()
{
	m_uiTPamount = 0;
	m_mapDatabaseABMNInfo.clear();
}

void CCrossHoleConfig3DMainDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_TAB_AR_CHANGE, m_tabChange);
}


BEGIN_MESSAGE_MAP(CCrossHoleConfig3DMainDlg, CDialog)
	ON_NOTIFY(TCN_SELCHANGE, IDC_TAB_AR_CHANGE, &CCrossHoleConfig3DMainDlg::OnTcnSelchangeTabArChange)
	ON_BN_CLICKED(ID_BTN_LOAD_GEOMETRY, &CCrossHoleConfig3DMainDlg::OnBnClickedBtnLoadGeometry)
	ON_BN_CLICKED(ID_BTN_CREATE, &CCrossHoleConfig3DMainDlg::OnBnClickedBtnCreate)
	ON_BN_CLICKED(ID_BTN_START_SIMULATION, &CCrossHoleConfig3DMainDlg::OnBnClickedBtnStartSimulation)
	ON_BN_CLICKED(ID_BTN_STOP_SIMULATION, &CCrossHoleConfig3DMainDlg::OnBnClickedBtnStopSimulation)
	ON_BN_CLICKED(ID_BTN_CLOSE, &CCrossHoleConfig3DMainDlg::OnBnClickedBtnClose)
	ON_MESSAGE(WM_MSG_UPDATE_CROSSHOLEMAINWND_BTN, &CCrossHoleConfig3DMainDlg::OnMsgCrossHoleMainWndBtn)
	ON_WM_DESTROY()
END_MESSAGE_MAP()

CCrossHoleConfig3DMainDlg* CCrossHoleConfig3DMainDlg::GetInstance()
{
	static CCrossHoleConfig3DMainDlg crossHoleConfig;
	return &crossHoleConfig;
}
// CCrossHoleConfig3DMainDlg 消息处理程序
BOOL CCrossHoleConfig3DMainDlg::OnInitDialog()
{
	CDialog::OnInitDialog();
	if (LANG_ZHCN == g_iUILanguage)
	{
		SetDlgItemText(ID_BTN_LOAD_GEOMETRY, _T("加载坐标"));
		SetDlgItemText(ID_BTN_CREATE, _T("创建"));
		SetDlgItemText(ID_BTN_START_SIMULATION, _T("开始模拟"));
		SetDlgItemText(ID_BTN_STOP_SIMULATION, _T("停止模拟"));
		SetDlgItemText(ID_BTN_CLOSE, _T("关闭"));
		m_tabChange.InsertItem(0, _T("电极坐标"));
		m_tabChange.InsertItem(1, _T("井下"));
		m_tabChange.InsertItem(2, _T("地面"));
		m_tabChange.InsertItem(3, _T("参数"));
	}
	else
	{
		m_tabChange.InsertItem(0, _T("Geometry"));
		m_tabChange.InsertItem(1, _T("BoreHole"));
		m_tabChange.InsertItem(2, _T("Surface"));
		m_tabChange.InsertItem(3, _T("Setting"));
	}
	
	m_tabChange.SetCurSel(1);
	// TODO:  在此添加额外的初始化
	CRect rcDrawCtr;
	GetDlgItem(IDC_STATIC_DRAWING_BOARD)->GetClientRect(&rcDrawCtr);
	//m_DrawingBoardDlg.Create(IDD_DIALOG_DRAWING_BOARD, this);
	CCrosshole3dDrawingBoardDlg::GetInstance()->Create(IDD_DIALOG_DRAWING_BOARD, GetDlgItem(IDC_STATIC_DRAWING_BOARD));
	CCrosshole3dDrawingBoardDlg::GetInstance()->MoveWindow(&rcDrawCtr);
	CCrosshole3dDrawingBoardDlg::GetInstance()->ShowWindow(SW_SHOW);

	C3DSimulationDlg::GetInstance()->Create(IDD_DIALOG_SIMULATION_BOARD, GetDlgItem(IDC_STATIC_DRAWING_BOARD));
	C3DSimulationDlg::GetInstance()->MoveWindow(&rcDrawCtr);
	C3DSimulationDlg::GetInstance()->ShowWindow(SW_HIDE);
	//CCrosshole3dDrawingBoardDlg::GetInstance()->Create(IDD_DIALOG_DRAWING_BOARD, this);
	//CCrosshole3dDrawingBoardDlg::GetInstance()->MoveWindow(&rcDrawCtr);

	CRect rect;
	m_tabChange.GetClientRect(&rect);
	rect.top = rect.top + 25;
	rect.left = rect.left + 2;
	rect.right = rect.right - 2;
	rect.bottom = rect.bottom - 2;
	COption3DGeometryDlg::GetInstance()->Create(IDD_DIALOG_OPTION_3D_GEOMETRY, &m_tabChange);
	COption3DGeometryDlg::GetInstance()->MoveWindow(&rect);

	COption3DBoreholeDlg::GetInstance()->Create(IDD_DIALOG_OPTION_3D_BOREHOLE, &m_tabChange);
	COption3DBoreholeDlg::GetInstance()->MoveWindow(&rect);

	COption3DSurfaceDlg::GetInstance()->Create(IDD_DIALOG_OPTION_3D_SURFACE, &m_tabChange);
	COption3DSurfaceDlg::GetInstance()->MoveWindow(&rect);

	COption3DSettingDlg::GetInstance()->Create(IDD_DIALOG_OPTION_3D_SETTING, &m_tabChange);
	COption3DSettingDlg::GetInstance()->MoveWindow(&rect);

	COption3DGeometryDlg::GetInstance()->ShowWindow(SW_HIDE);
	COption3DBoreholeDlg::GetInstance()->ShowWindow(SW_SHOW);
	COption3DSurfaceDlg::GetInstance()->ShowWindow(SW_HIDE);
	COption3DSettingDlg::GetInstance()->ShowWindow(SW_HIDE);

	GetDlgItem(ID_BTN_START_SIMULATION)->EnableWindow(FALSE);
	GetDlgItem(ID_BTN_STOP_SIMULATION)->EnableWindow(FALSE);

	m_pConnection = theApp.m_pConnection;
	return TRUE;  // return TRUE unless you set the focus to a control
	// 异常:  OCX 属性页应返回 FALSE
}

void CCrossHoleConfig3DMainDlg::OnTcnSelchangeTabArChange(NMHDR *pNMHDR, LRESULT *pResult)
{
	// TODO:  在此添加控件通知处理程序代码
	int iSel = m_tabChange.GetCurSel();
	switch (iSel)
	{
	case EN_OPTION_GEOMETRY:
	{
		COption3DGeometryDlg::GetInstance()->ShowWindow(SW_SHOW);
		COption3DBoreholeDlg::GetInstance()->ShowWindow(SW_HIDE);
		COption3DSurfaceDlg::GetInstance()->ShowWindow(SW_HIDE);
		COption3DSettingDlg::GetInstance()->ShowWindow(SW_HIDE);
	}
	break;
	case EN_OPTION_BOREHOLE:
	{
		COption3DGeometryDlg::GetInstance()->ShowWindow(SW_HIDE);
		COption3DBoreholeDlg::GetInstance()->ShowWindow(SW_SHOW);
		COption3DSurfaceDlg::GetInstance()->ShowWindow(SW_HIDE);
		COption3DSettingDlg::GetInstance()->ShowWindow(SW_HIDE);
	}
	break;
	case EN_OPTION_SURFACE:
	{
		COption3DGeometryDlg::GetInstance()->ShowWindow(SW_HIDE);
		COption3DBoreholeDlg::GetInstance()->ShowWindow(SW_HIDE);
		COption3DSurfaceDlg::GetInstance()->ShowWindow(SW_SHOW);
		COption3DSettingDlg::GetInstance()->ShowWindow(SW_HIDE);
	}
	break;
	case EN_OPTION_SETTING:
	{
		COption3DGeometryDlg::GetInstance()->ShowWindow(SW_HIDE);
		COption3DBoreholeDlg::GetInstance()->ShowWindow(SW_HIDE);
		COption3DSurfaceDlg::GetInstance()->ShowWindow(SW_HIDE);
		COption3DSettingDlg::GetInstance()->ShowWindow(SW_SHOW);
	}
	break;
	default:
		break;
	}
	*pResult = 0;
}

void CCrossHoleConfig3DMainDlg::ChangeTabPage(EN_TAB_PAGE pageType, std::vector<STBoreHolePoints> vecPoints,STBoreHoleParam stBoreholeParam)
{
	if (vecPoints.size() <= 0)
	{
		ASSERT(vecPoints.size() > 0);
		return;
	}

	switch (pageType)
	{
	case EN_OPTION_GEOMETRY:
	break;
	case EN_OPTION_BOREHOLE:
	{
		COption3DGeometryDlg::GetInstance()->AddCoordinatesPoints(EN_BOREHOLE_TYPE, vecPoints);
		m_tabChange.SetCurSel(0);
		COption3DGeometryDlg::GetInstance()->ShowWindow(SW_SHOW);
		COption3DBoreholeDlg::GetInstance()->ShowWindow(SW_HIDE);
	}
	break;
	case EN_OPTION_SURFACE:
	{
		COption3DGeometryDlg::GetInstance()->AddCoordinatesPoints(EN_SURFACE_TYPE, vecPoints);
		m_tabChange.SetCurSel(0);
		COption3DGeometryDlg::GetInstance()->ShowWindow(SW_SHOW);
		COption3DSurfaceDlg::GetInstance()->ShowWindow(SW_HIDE);
	}
	break;
	default:
		break;
	}

	COption3DGeometryDlg::GetInstance()->AddElecCoordinatesInfo(stBoreholeParam);
		
}

void CCrossHoleConfig3DMainDlg::OnBnClickedBtnLoadGeometry()
{
	/*if (C3DSimulationDlg::GetInstance()->IsSimulating())
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("正在模拟跑极不能操作"));
		else
			MessageBoxEx(NULL, _T("Running is being simulated and cannot be operated"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		return;
	}
	C3DSimulationDlg::GetInstance()->ShowWindow(SW_HIDE);
	CCrosshole3dDrawingBoardDlg::GetInstance()->ShowWindow(SW_SHOW);

	// TODO:  在此添加控件通知处理程序代码
	CFileDialog cfd(TRUE, _T(".geomative"), _T("*.geomative"), OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("geomative Files(*.geomative)|*.txt||"), NULL);
	if (IDOK == cfd.DoModal())
	{
		CString strRawContent;
		BOOL bRes = FALSE;
		CStdioFile csf;
		int i = 0;
		UINT32 uiID = 1;//ID
		UINT iExists = 0;
		char* pCurContent = NULL;
		STBoreHolePoints stPoints;
		std::map<int, std::vector<STBoreHolePoints>> mapBoreholePoints;//保存从Geomative文件读取到的borehole所有的点
		std::vector<STBoreHolePoints> vecBoreholePoints;
		std::vector<STBoreHolePoints> vecNoSortBoreholePoints;
		std::vector<STBoreHolePoints> vecSurfacePoints;//保存从Geomative文件读取到的surface所有的点
		bRes = csf.Open(cfd.GetPathName(), CStdioFile::modeReadWrite);
		if (bRes)
		{
			while (csf.ReadString(strRawContent))
			{
				OutputDebugString(strRawContent+_T("\n"));	

				pCurContent = _tcstok(strRawContent.GetBuffer(), _T(","));
				stPoints.uiID = uiID;
				stPoints.uiElecID = atoi(pCurContent);
				i = 0;
				while ((pCurContent = _tcstok(NULL, _T(","))))
				{
					switch (i)
					{
					case 0://X
						stPoints.fX = atof(pCurContent);
						break;
					case 1://Y
						stPoints.fY = atof(pCurContent);
						 break;
					case 2://Z
						stPoints.fZ = atof(pCurContent); 
						break;
					default:
						break;
					}
					i++; 
				}

				//地表
				if (stPoints.fZ >= -0.000001 && stPoints.fZ < 0.000001)
				{
					vecSurfacePoints.push_back(stPoints);
				}
				else
				{
					iExists = mapBoreholePoints.count(stPoints.fX);
					if (0 == iExists)
					{
						vecBoreholePoints.push_back(stPoints);
						mapBoreholePoints[stPoints.fX] = vecBoreholePoints;
						vecBoreholePoints.clear();
					}
					else
					{
						mapBoreholePoints[stPoints.fX].push_back(stPoints);
					}
				}
				vecNoSortBoreholePoints.push_back(stPoints);
				uiID++;
			}
			csf.Close();
		}

		COption3DGeometryDlg::GetInstance()->DeleteCoordinatesPoint();
		//添加List列表
		COption3DGeometryDlg::GetInstance()->AddNoSortCoordinatesFromFile(vecNoSortBoreholePoints);

		//从Geomative文件加载的坐标传给画板和模拟窗口
		CCrosshole3dDrawingBoardDlg::GetInstance()->DeleteCoordinatesPoint();
		C3DSimulationDlg::GetInstance()->DeleteCoordinatesPoint();
		if (mapBoreholePoints.size() > 0)
		{
			CCrosshole3dDrawingBoardDlg::GetInstance()->AddBoreholePointToVector(mapBoreholePoints);
			C3DSimulationDlg::GetInstance()->AddBoreholePointToVector(mapBoreholePoints);
		}
		if (vecSurfacePoints.size() > 0)
		{
			CCrosshole3dDrawingBoardDlg::GetInstance()->AddSurfacePointsToVector(vecSurfacePoints);
			C3DSimulationDlg::GetInstance()->AddSurfacePointsToVector(vecSurfacePoints);
		}
		
	}*/
}

std::vector<int> CCrossHoleConfig3DMainDlg::CalcLValue(std::vector<STBoreHolePoints> vecPointBH1, std::vector<STBoreHolePoints> vecPointBH2)
{
	std::vector<int> vecLValue;
	UINT uiBH1 = 0, uiBH2 = 0;
	uiBH1 = vecPointBH1.size();
	uiBH2 = vecPointBH2.size();
	if (0 == uiBH1 || 0 == uiBH2)
		return vecLValue;

	int iMinN = min(uiBH1, uiBH2);
	//向正无穷取整
	int iMaxL = iMinN / 3;
	if (0 != iMinN % 3)
	{
		iMaxL++;
	}

	//向正无穷取整
	int iMinL = iMinN / 10;
	if (0 != iMinN % 10)
	{
		iMinL++;
	}

	//向正无穷取整
	int iDL = iMinN / 15;
	if (0 != iMinN % 15)
	{
		iDL++;
	}

	//向负无穷取整
	int iN = (iMaxL - iMinL) / iDL;

	int iL = 0;
	//OutputDebugString(_T("zm:CCrossHoleConfig3DMainDlg::GenerateTestPoints 生成L的取值："));
	for (int i = 0; i <= iN; i++)
	{
		iL = iMinL + i*iDL;
		vecLValue.push_back(iL);
		//OutputDebugString("" + iL);
	}
	//OutputDebugString("\n\n");
	return vecLValue;
}
struct Points
{
	UINT32		A;
	UINT32		B;
	UINT32		M;
	UINT32		N;
	Points()
	{
		memset(this, 0, sizeof(Points));
	}
};

float CCrossHoleConfig3DMainDlg::GetUniSptXPos(int iA, int iB, int iM, int iN)
{
	//16-39的区间为1维脚本和3维脚本，不支持
	//在这里只支持2维脚本
	// 	if (m_iAR > 16 && m_iAR < 39)		//2D脚本装置类型
	// 	{
	// 		AfxMessageBox(_T("Universal script only supprot 2D script."));
	// 		return -1;
	// 	}
	int iMin = 100000, iMax = 0, iTotalVal = 0;
	int iDataArr[4] = { iA, iB, iM, iN };
	int iNegativeCnt = 0;//非正整数的个数
	for (int i = 0; i < 4; i++)
	{
		if (iDataArr[i] > 0)
		{
			if (iDataArr[i] > iMax)
			{
				iMax = iDataArr[i];
			}
			if (iDataArr[i] < iMin)
			{
				iMin = iDataArr[i];
			}
			iTotalVal += iDataArr[i];
		}
		else
			iNegativeCnt++;
	}
	//如果全部是正整数(四级装置)，则此时iTotalVal表示的是四个数的总和，那么需要剪掉最大的和最小的
	if (0 == iNegativeCnt)
		return (iTotalVal - iMin - iMax)*1.0 / 2;

	//如果此时是三级装置，那么此时只需要减掉最小值即可
	if (1 == iNegativeCnt)
		return (iTotalVal - iMin)*1.0 / 2;

	//如果是二级装置，则不需进行再处理
	if (2 == iNegativeCnt)
		return iTotalVal*1.0 / 2;

	CString strErr;
	if (LANG_ZHCN == g_iUILanguage)
	{
		strErr.Format(_T("GetUniSptXPos错误,负值%d"), iNegativeCnt);
		AfxMessageBox(strErr);
	}
	else
	{
		strErr.Format(_T("GetUniSptXPos error,number of negative is %d"), iNegativeCnt);
		MessageBoxEx(NULL, strErr, STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
	}
	return -1;
}
/*
void CCrossHoleConfig3DMainDlg::TwoBoreholeGenerateScriptFromAM(std::vector<STBoreHolePoints> vecPointBH1, std::vector<STBoreHolePoints> vecPointBH2)
{
	//两个孔,组合
	CString strLog;
	int iCompare = 0;
	int i = 0;
	int j = 0;
	double dK = 0.0;
	float fAM = 0.0;
	float fAM2 = 0.0;
	float fBM = 0.0;
	float fBM2 = 0.0;
	float fAN = 0.0;
	float fAN2 = 0.0;
	float fBN = 0.0;
	float fBN2 = 0.0;
	CSptRecord* pSptRecord = NULL;
	STBoreholeABMN stBoreholeABMN;
	//std::vector<int> vecLValue = CalcLValue(vecPointBH1, vecPointBH2);
	//std::vector<int>::iterator iter = vecLValue.begin();
	std::vector<STBoreHolePoints>::iterator iterBH1 = vecPointBH1.begin();
	std::vector<STBoreHolePoints>::iterator iterBH2 = vecPointBH2.begin();
	int iBH1Size = vecPointBH1.size();
	int iBH2Size = vecPointBH2.size();
	for (iterBH1 = vecPointBH1.begin(); iterBH1 != vecPointBH1.end(); iterBH1++)
	{
		for (iterBH2 = vecPointBH2.begin(); iterBH2 != vecPointBH2.end(); iterBH2++)
		{
			if (EN_SURFACE_TYPE == iterBH2->eType)
			{
				//直线
				fAM = (iterBH1 + i)->fZ - (iterBH1 + i + *iter)->fZ;
				fAM2 = -(iterBH1 + i)->fZ - (iterBH1 + i + *iter)->fZ;
				fBN = (iterBH2 + j + *iter)->fX - (iterBH2 + j)->fX;
				fBN2 = fBN;//待确认,地表2AM

				//三角形
				fBM = sqrt(pow(iterBH1->fX - (iterBH2 + j)->fX, 2) + pow((iterBH1 + i + *iter)->fZ, 2));
				fBM2 = sqrt(pow(iterBH1->fX - (iterBH2 + j)->fX, 2) + pow(-(iterBH1 + i + *iter)->fZ, 2));
				fAN = sqrt(pow((iterBH1 + i)->fZ, 2) + pow((iterBH2 + j + *iter)->fX - iterBH1->fX, 2));
				fAN2 = sqrt(pow(-(iterBH1 + i)->fZ, 2) + pow((iterBH2 + j + *iter)->fX - iterBH1->fX, 2));
			}
			else
			{
				//直线
				fAM = (iterBH1 + i)->fZ - (iterBH1 + i + *iter)->fZ;
				fAM2 = -(iterBH1 + i)->fZ - (iterBH1 + i + *iter)->fZ;
				fBN = (iterBH2 + j)->fZ - (iterBH2 + j + *iter)->fZ;
				fBN2 = -(iterBH2 + j)->fZ - (iterBH2 + j + *iter)->fZ;

				//三角形
				fBM = sqrt(pow((iterBH2 + j)->fZ - (iterBH1 + i + *iter)->fZ, 2) + pow(iterBH2->fX - iterBH1->fX, 2));
				fBM2 = sqrt(pow(-(iterBH2 + j)->fZ - (iterBH1 + i + *iter)->fZ, 2) + pow(iterBH2->fX - iterBH1->fX, 2));
				fAN = sqrt(pow((iterBH1 + i)->fZ - (iterBH2 + j + *iter)->fZ, 2) + pow(iterBH2->fX - iterBH1->fX, 2));
				fAN2 = sqrt(pow(-(iterBH1 + i)->fZ - (iterBH2 + j + *iter)->fZ, 2) + pow(iterBH2->fX - iterBH1->fX, 2));
			}


			dK = 4 * 3.1415926 / (1 / fAM + 1 / fAM2 - 1 / fBM - 1 / fBM2 - 1 / fAN - 1 / fAN2 + 1 / fBN + 1 / fBN2);
			pSptRecord = new CSptRecord;
			pSptRecord->m_iN = 1;//默认为1
			pSptRecord->m_iC1 = (iterBH1 + i)->uiElecID;
			pSptRecord->m_iP2 = (iterBH2 + j + *iter)->uiElecID;
			pSptRecord->m_iP1 = (iterBH1 + i + *iter)->uiElecID;
			pSptRecord->m_iC2 = (iterBH2 + j)->uiElecID;
			pSptRecord->m_fK = dK;
			pSptRecord->m_fSptXPos = GetUniSptXPos(pSptRecord->m_iC1, pSptRecord->m_iC2, pSptRecord->m_iP1, pSptRecord->m_iP2);

			stBoreholeABMN.uiAElecID = pSptRecord->m_iC1;
			stBoreholeABMN.uiBElecID = pSptRecord->m_iC2;
			stBoreholeABMN.uiMElecID = pSptRecord->m_iP1;
			stBoreholeABMN.uiNElecID = pSptRecord->m_iP2;
			m_vecAllBoreholeABMN.push_back(stBoreholeABMN);
			//pSptRecord->m_iTsn = m_pChannel.m_sptRecArray.GetSize()+1;
			m_pChannel.m_sptRecArray.Add(pSptRecord);
			iCompare++;
			strLog.Format(_T("iCompare=%d,L=%d,A=%d(z=%f),B=%d(z=%f),M=%d(z=%f),N=%d(z=%f),k=%lf\n"), \
				iCompare, *iter, (iterBH1 + i)->uiElecID, (iterBH1 + i)->fZ, (iterBH2 + j)->uiElecID, (iterBH2 + j)->fZ, (iterBH1 + i + *iter)->uiElecID, (iterBH1 + i + *iter)->fZ, (iterBH2 + j + *iter)->uiElecID, (iterBH2 + j + *iter)->fZ, dK);
			OutputDebugString(strLog);
		}
	}
}*/
void CCrossHoleConfig3DMainDlg::OneBoreHoleGenerateScriptAM(std::map<int, std::vector<STBoreHolePoints>> mapPointBH)
{
	std::map<int, std::vector<STBoreHolePoints>>::iterator iter = mapPointBH.begin();
	for (; iter != mapPointBH.end(); iter++)
	{
		OneBoreHoleGenerateScriptAM(iter->second);
	}
}
void CCrossHoleConfig3DMainDlg::OneBoreHoleGenerateScriptAM(std::vector<STBoreHolePoints> vecPointBH)
{
	//std::vector<STBoreHolePoints>::iterator iterBH1 = vecPointBH.begin();//孔1
	//std::vector<STBoreHolePoints>::iterator iterBH2 = vecPointBH.begin();//孔1
	CString strLog;
	double dK = 0.0;
	float fAM, fAM2, fBM, fBM2, fAN, fAN2, fBN, fBN2;
	int i, j;
	//先取同一个孔内的AM计算
	//孔1 A
	int iSize = vecPointBH.size();
	STDatabaseABMNInfo stDatabaseABMNInfo;
	map<int, STDatabaseABMNInfo> mapM;
	map<int, map<int, STDatabaseABMNInfo>> mapB;
	map<int, map<int, map<int, STDatabaseABMNInfo>>>::iterator iterFindA;
	map<int, map<int, STDatabaseABMNInfo>>::iterator iterFindB;
	map<int, STDatabaseABMNInfo>::iterator iterFindM;
	//for (iterBH1 = vecPointBH.begin(); ++iterBH1 != vecPointBH.end(); iterBH1++)
	for (i = 0; i < iSize - 1; i++)
	{
		//同一个孔的M
		//for (; iterBH2 != vecPointBH.end(); iterBH2++)
		for (j = i + 1; j < iSize; j++)
		{				//直线
			fAM = vecPointBH.at(i).fZ - vecPointBH.at(j).fZ;
			fAM2 = -vecPointBH.at(j).fZ - vecPointBH.at(i).fZ;
			//fAM2 = - vecPointBH.at(i).fZ - vecPointBH.at(j).fZ ;

			//dK = 4 * 3.1415926 / (1 / fAM + 1 / fAM2 - 1 / fBM - 1 / fBM2 - 1 / fAN - 1 / fAN2 /*+ 1 / fBN + 1 / fBN2*/);
			dK = 4 * 3.1415926 / (1 / fAM + 1 / fAM2);			
			stDatabaseABMNInfo.uiAElecID = vecPointBH.at(i).uiElecID;
			stDatabaseABMNInfo.uiBElecID = -1;
			stDatabaseABMNInfo.uiMElecID = vecPointBH.at(j).uiElecID;
			stDatabaseABMNInfo.uiNElecID = -1;
			stDatabaseABMNInfo.iTrace = 1;//默认为1
			stDatabaseABMNInfo.fK = dK;
			m_vecAllBoreholeABMNInfo.push_back(stDatabaseABMNInfo);

			iterFindA = m_mapDatabaseABMNInfo.find(stDatabaseABMNInfo.uiAElecID);
			mapB.clear();
			mapM.clear();
			if (iterFindA != m_mapDatabaseABMNInfo.end())
			{
				iterFindB = iterFindA->second.find(stDatabaseABMNInfo.uiBElecID);
				if (iterFindB != iterFindA->second.end())
				{
					iterFindM = iterFindB->second.find(stDatabaseABMNInfo.uiMElecID);
					if (iterFindM != iterFindB->second.end())
					{
						AfxMessageBox(_T("生成测点AB相同，存在M值相同\n"));
					}
					else
					{
						iterFindB->second.insert(make_pair(stDatabaseABMNInfo.uiMElecID, stDatabaseABMNInfo));
					}
				}
				else
				{
					mapM[stDatabaseABMNInfo.uiMElecID] = stDatabaseABMNInfo;
					iterFindA->second.insert(make_pair(stDatabaseABMNInfo.uiBElecID, mapM));
				}
			}
			else
			{
				mapM[stDatabaseABMNInfo.uiMElecID] = stDatabaseABMNInfo;
				mapB[stDatabaseABMNInfo.uiBElecID] = mapM;
				m_mapDatabaseABMNInfo[stDatabaseABMNInfo.uiAElecID] = mapB;
			}
			m_uiTPamount++;
		}
	}
}

void CCrossHoleConfig3DMainDlg::TwoBoreHoleGenerateScriptAM(int iDirectionType, std::vector<STBoreHolePoints> vecPointBH1, std::vector<STBoreHolePoints> vecPointBH2)
{
	//两个孔,组合
	//std::vector<int> vecLValue = CalcLValue(vecPointBH1, vecPointBH2);
	//std::vector<int>::iterator iter = vecLValue.begin();
// 	std::vector<STBoreHolePoints>::iterator iterBH1 = vecPointBH1.begin();//孔1
// 	std::vector<STBoreHolePoints>::iterator iterBH1ex = vecPointBH1.begin();//孔1
// 	std::vector<STBoreHolePoints>::iterator iterBH2 = vecPointBH2.begin();//孔2
// 	std::vector<STBoreHolePoints>::iterator iterBH2ex = vecPointBH2.begin();//孔2
// 	int iBH1Size = vecPointBH1.size();
// 	int iBH2Size = vecPointBH2.size();
	int i,j;
	double dK = 0.0;
	float fAM, fAM2, fBM, fBM2, fAN, fAN2, fBN, fBN2;
	UINT32 uiBH1Size = vecPointBH1.size();
	UINT32 uiBH2Size = vecPointBH2.size();

	STDatabaseABMNInfo stDatabaseABMNInfo;
	map<int, STDatabaseABMNInfo> mapM;
	map<int, map<int, STDatabaseABMNInfo>> mapB;
	map<int, map<int, map<int, STDatabaseABMNInfo>>>::iterator iterFindA;
	map<int, map<int, STDatabaseABMNInfo>>::iterator iterFindB;
	map<int, STDatabaseABMNInfo>::iterator iterFindM;
	//先取同一个孔内的AM计算
	//孔1 A
	//for (iterBH1 = vecPointBH1.begin(); ++iterBH1 != vecPointBH1.end(); iterBH1++)
	for (i = 0; i < uiBH1Size; i++)
	{
		//同一个孔的M
		//for (iterBH1ex = ++iterBH1; iterBH1ex != vecPointBH1.end(); iterBH1ex++)
		for (j = 0; j < uiBH2Size; j++)
		{
			/*if (EN_SURFACE_TYPE == iterBH2->eType)
			{
			//直线
			fAM = iterBH1->fZ - iterBH1->fZ;
			fAM2 = -(iterBH1 + i)->fZ - (iterBH1 + i + *iter)->fZ;
			fBN = (iterBH2 + j + *iter)->fX - (iterBH2 + j)->fX;
			fBN2 = fBN;//待确认,地表2AM

			//三角形
			fBM = sqrt(pow(iterBH1->fX - (iterBH2 + j)->fX, 2) + pow((iterBH1 + i + *iter)->fZ, 2));
			fBM2 = sqrt(pow(iterBH1->fX - (iterBH2 + j)->fX, 2) + pow(-(iterBH1 + i + *iter)->fZ, 2));
			fAN = sqrt(pow((iterBH1 + i)->fZ, 2) + pow((iterBH2 + j + *iter)->fX - iterBH1->fX, 2));
			fAN2 = sqrt(pow(-(iterBH1 + i)->fZ, 2) + pow((iterBH2 + j + *iter)->fX - iterBH1->fX, 2));
			}
			else*/
			{
				if ((iDirectionType & 1)//只有X方向测线
					|| (iDirectionType & 2)//只有Y方向测线
					|| (iDirectionType & 3))//x,y方向
				{
					fAM = sqrt(pow((vecPointBH1.at(i).fY - vecPointBH2.at(j).fY), 2) + pow((vecPointBH1.at(i).fX - vecPointBH2.at(j).fX), 2));
					fAM2 = sqrt(pow((vecPointBH1.at(i).fY - vecPointBH2.at(j).fY), 2) + pow((vecPointBH1.at(i).fX - vecPointBH2.at(j).fX), 2));
				}
				else if (iDirectionType & 4)//只有Z方向测线
				{
					fAM = sqrt(pow((vecPointBH1.at(i).fZ - vecPointBH2.at(j).fZ), 2) + pow((vecPointBH1.at(i).fX - vecPointBH2.at(j).fX), 2));
					fAM2 = sqrt(pow((vecPointBH1.at(i).fZ - vecPointBH2.at(j).fZ), 2) + pow((vecPointBH1.at(i).fX - vecPointBH2.at(j).fX), 2));
				}
				else if (iDirectionType & 6)//y,z方向
				{
					fAM = sqrt(pow((vecPointBH1.at(i).fZ - vecPointBH2.at(j).fZ), 2) + pow((vecPointBH1.at(i).fY - vecPointBH2.at(j).fY), 2));
					fAM2 = sqrt(pow((vecPointBH1.at(i).fZ - vecPointBH2.at(j).fZ), 2) + pow((vecPointBH1.at(i).fY - vecPointBH2.at(j).fY), 2));
				}
				else if (iDirectionType & 5)//x,z方向
				{
					fAM = sqrt(pow((vecPointBH1.at(i).fZ - vecPointBH2.at(j).fZ), 2) + pow((vecPointBH1.at(i).fX - vecPointBH2.at(j).fX), 2));
					fAM2 = sqrt(pow((vecPointBH1.at(i).fZ - vecPointBH2.at(j).fZ), 2) + pow((vecPointBH1.at(i).fX - vecPointBH2.at(j).fX), 2));
				}
				
				//三角形
				//fBM = sqrt(pow((iterBH2 + j)->fZ - (iterBH1 + i + *iter)->fZ, 2) + pow(iterBH2->fX - iterBH1->fX, 2));
				//fBM2 = sqrt(pow(-(iterBH2 + j)->fZ - (iterBH1 + i + *iter)->fZ, 2) + pow(iterBH2->fX - iterBH1->fX, 2));
				//fAN = sqrt(pow((iterBH1 + i)->fZ - (iterBH2 + j + *iter)->fZ, 2) + pow(iterBH2->fX - iterBH1->fX, 2));
				//fAN2 = sqrt(pow(-(iterBH1 + i)->fZ - (iterBH2 + j + *iter)->fZ, 2) + pow(iterBH2->fX - iterBH1->fX, 2));
			}

			dK = 4 * 3.1415926 / (1 / fAM + 1 / fAM2);
			stDatabaseABMNInfo.uiAElecID = vecPointBH1.at(i).uiElecID;
			stDatabaseABMNInfo.uiBElecID = -1;
			stDatabaseABMNInfo.uiMElecID = vecPointBH2.at(j).uiElecID;
			stDatabaseABMNInfo.uiNElecID = -1;
			stDatabaseABMNInfo.iTrace = 1;//默认为1
			stDatabaseABMNInfo.fK = dK;
			m_vecAllBoreholeABMNInfo.push_back(stDatabaseABMNInfo);

			iterFindA = m_mapDatabaseABMNInfo.find(stDatabaseABMNInfo.uiAElecID);
			mapB.clear();
			mapM.clear();
			if (iterFindA != m_mapDatabaseABMNInfo.end())
			{
				iterFindB = iterFindA->second.find(stDatabaseABMNInfo.uiBElecID);
				if (iterFindB != iterFindA->second.end())
				{
					iterFindM = iterFindB->second.find(stDatabaseABMNInfo.uiMElecID);
					if (iterFindM != iterFindB->second.end())
					{
						AfxMessageBox(_T("生成测点AB相同，存在M值相同\n"));
					}
					else
					{
						iterFindB->second.insert(make_pair(stDatabaseABMNInfo.uiMElecID, stDatabaseABMNInfo));
					}
				}
				else
				{
					mapM[stDatabaseABMNInfo.uiMElecID] = stDatabaseABMNInfo;
					iterFindA->second.insert(make_pair(stDatabaseABMNInfo.uiBElecID, mapM));
				}
			}
			else
			{
				mapM[stDatabaseABMNInfo.uiMElecID] = stDatabaseABMNInfo;
				mapB[stDatabaseABMNInfo.uiBElecID] = mapM;
				m_mapDatabaseABMNInfo[stDatabaseABMNInfo.uiAElecID] = mapB;
			}
			m_uiTPamount++;
		}
	}
}

void CCrossHoleConfig3DMainDlg::TwoBoreholeGenerateScript(std::vector<STBoreHolePoints> vecPointBH1, std::vector<STBoreHolePoints> vecPointBH2)
{
	//两个孔,组合
	CString strLog;
	std::vector<int> vecLValue = CalcLValue(vecPointBH1, vecPointBH2);
	std::vector<int>::iterator iter = vecLValue.begin();
	std::vector<STBoreHolePoints>::iterator iterBH1 = vecPointBH1.begin();
	std::vector<STBoreHolePoints>::iterator iterBH2 = vecPointBH2.begin();
	int iBH1Size = vecPointBH1.size();
	int iBH2Size = vecPointBH2.size();
	int iCompare = 0;
	int i = 0;
	int j = 0;
	double dK = 0.0;
	float fAM, fAM2, fBM, fBM2, fAN, fAN2, fBN, fBN2;
	float fBHDistance = 0.0;
	STDatabaseABMNInfo stDatabaseABMNInfo;
	map<int, STDatabaseABMNInfo> mapM;
	map<int, map<int, STDatabaseABMNInfo>> mapB;
	map<int, map<int, map<int, STDatabaseABMNInfo>>>::iterator iterFindA;
	map<int, map<int, STDatabaseABMNInfo>>::iterator iterFindB;
	map<int, STDatabaseABMNInfo>::iterator iterFindM;
	//L取值
	for (; iter != vecLValue.end(); iter++)
	{
		//遍历第一个孔的电极
		for (i = 0; i < iBH1Size - *iter; i++)
		{
			//遍历第二个孔的电极
			for (j = 0; j < iBH2Size - *iter; j++)
			{
				/*if (EN_SURFACE_TYPE == iterBH1->eType)
				{
				//直线
				fAM = (iterBH1 + i + *iter)->fX-(iterBH1 + i)->fX;
				fAM2 = fAM;//待确认,地表2AM
				fBN = (iterBH2 + j)->fZ - (iterBH2 + j + *iter)->fZ;
				fBN2 = -(iterBH2 + j)->fZ - (iterBH2 + j + *iter)->fZ;

				//三角形
				fBM = sqrt(pow((iterBH2 + j)->fZ, 2) + pow((iterBH1 + i + *iter)->fX - iterBH2->fX, 2));
				fBM2 = sqrt(pow(-(iterBH2 + j)->fZ, 2) + pow((iterBH1 + i + *iter)->fX - iterBH2->fX, 2));
				fAN = sqrt(pow((iterBH2 + j + *iter)->fZ, 2) + pow((iterBH1 + i)->fX - iterBH2->fX, 2));
				fAN2 = sqrt(pow(-(iterBH2 + j + *iter)->fZ, 2) + pow((iterBH1 + i)->fX - iterBH2->fX, 2));
				}
				else*/
				//生成脚本时，地表的坐标时添加在最后的，所以只有第二个孔为地表的情况
				if (EN_SURFACE_TYPE == iterBH2->eType)
				{
					//直线
					fAM = (iterBH1 + i)->fZ - (iterBH1 + i + *iter)->fZ;
					fAM2 = -(iterBH1 + i)->fZ - (iterBH1 + i + *iter)->fZ;
					fBN = (iterBH2 + j + *iter)->fX - (iterBH2 + j)->fX;
					fBN2 = fBN;//待确认,地表2AM

					//三角形
					fBM = sqrt(pow(iterBH1->fX - (iterBH2 + j)->fX, 2) + pow((iterBH1 + i + *iter)->fZ, 2));
					fBM2 = sqrt(pow(iterBH1->fX - (iterBH2 + j)->fX, 2) + pow(-(iterBH1 + i + *iter)->fZ, 2));
					fAN = sqrt(pow((iterBH1 + i)->fZ, 2) + pow((iterBH2 + j + *iter)->fX - iterBH1->fX, 2));
					fAN2 = sqrt(pow(-(iterBH1 + i)->fZ, 2) + pow((iterBH2 + j + *iter)->fX - iterBH1->fX, 2));
				}
				else
				{
					//直线
					if ((iterBH1 + i)->fZ > (iterBH1 + i + *iter)->fZ)
						fAM = (iterBH1 + i)->fZ - (iterBH1 + i + *iter)->fZ;
					else
						fAM = (iterBH1 + i + *iter)->fZ - (iterBH1 + i)->fZ;

					//A的镜像为正数
					fAM2 = -(iterBH1 + i)->fZ - (iterBH1 + i + *iter)->fZ;

					if ((iterBH2 + j)->fZ > (iterBH2 + j + *iter)->fZ)
						fBN = (iterBH2 + j)->fZ - (iterBH2 + j + *iter)->fZ;
					else
						fBN = (iterBH2 + j + *iter)->fZ - (iterBH2 + j)->fZ;
					
					//B的镜像为正数
					fBN2 = -(iterBH2 + j)->fZ - (iterBH2 + j + *iter)->fZ;

					//三角形
					fBHDistance = sqrt(pow(iterBH2->fX - iterBH1->fX, 2) + pow(iterBH2->fY - iterBH1->fY, 2));
					if ((iterBH2 + j)->fZ > (iterBH1 + i + *iter)->fZ)
						fBM = sqrt(pow((iterBH2 + j)->fZ - (iterBH1 + i + *iter)->fZ, 2) + pow(fBHDistance, 2));
					else
						fBM = sqrt(pow((iterBH1 + i + *iter)->fZ - (iterBH2 + j)->fZ, 2) + pow(fBHDistance, 2));

					fBM2 = sqrt(pow(-(iterBH2 + j)->fZ - (iterBH1 + i + *iter)->fZ, 2) + pow(fBHDistance, 2));
					if ((iterBH1 + i)->fZ > (iterBH2 + j + *iter)->fZ)
						fAN = sqrt(pow((iterBH1 + i)->fZ - (iterBH2 + j + *iter)->fZ, 2) + pow(fBHDistance, 2));
					else
						fAN = sqrt(pow((iterBH2 + j + *iter)->fZ - (iterBH1 + i)->fZ, 2) + pow(fBHDistance, 2));
					fAN2 = sqrt(pow(-(iterBH1 + i)->fZ - (iterBH2 + j + *iter)->fZ, 2) + pow(fBHDistance, 2));
				}


				dK = 4 * 3.1415926 / (1 / fAM + 1 / fAM2 - 1 / fBM - 1 / fBM2 - 1 / fAN - 1 / fAN2 + 1 / fBN + 1 / fBN2);
				stDatabaseABMNInfo.uiAElecID = (iterBH1 + i)->uiElecID;
				stDatabaseABMNInfo.uiBElecID = (iterBH2 + j)->uiElecID;
				stDatabaseABMNInfo.uiMElecID = (iterBH1 + i + *iter)->uiElecID;
				stDatabaseABMNInfo.uiNElecID = (iterBH2 + j + *iter)->uiElecID;
				stDatabaseABMNInfo.iTrace = 1;//默认为1
				stDatabaseABMNInfo.fK = dK;
				stDatabaseABMNInfo.fSptXPos = GetUniSptXPos(stDatabaseABMNInfo.uiAElecID, stDatabaseABMNInfo.uiBElecID, stDatabaseABMNInfo.uiMElecID, stDatabaseABMNInfo.uiNElecID);
				m_vecAllBoreholeABMNInfo.push_back(stDatabaseABMNInfo);

				iterFindA = m_mapDatabaseABMNInfo.find(stDatabaseABMNInfo.uiAElecID);
				mapB.clear();
				mapM.clear();
				if (iterFindA != m_mapDatabaseABMNInfo.end())
				{
					iterFindB = iterFindA->second.find(stDatabaseABMNInfo.uiBElecID);
					if (iterFindB != iterFindA->second.end())
					{
						iterFindM = iterFindB->second.find(stDatabaseABMNInfo.uiMElecID);
						if (iterFindM != iterFindB->second.end())
						{
							AfxMessageBox(_T("生成测点AB相同，存在M值相同\n"));
						}
						else
						{
							iterFindB->second.insert(make_pair(stDatabaseABMNInfo.uiMElecID, stDatabaseABMNInfo));
						}
					}
					else
					{
						mapM[stDatabaseABMNInfo.uiMElecID] = stDatabaseABMNInfo;
						iterFindA->second.insert(make_pair(stDatabaseABMNInfo.uiBElecID, mapM));
					}
				}
				else
				{
					mapM[stDatabaseABMNInfo.uiMElecID] = stDatabaseABMNInfo;
					mapB[stDatabaseABMNInfo.uiBElecID] = mapM;
					m_mapDatabaseABMNInfo[stDatabaseABMNInfo.uiAElecID] = mapB;
				}
				m_uiTPamount++;
			}

		}
	}
}

//写入数据库
BOOL CCrossHoleConfig3DMainDlg::SaveTestPointToDB()
{
	m_pConnection = theApp.m_pConnection;
	m_pConnection->BeginTrans();
	//将AMNB信息吸入数据库---------------begin------------------
	_RecordsetPtr pRecSCID = NULL;
	_CommandPtr pCmdIns = NULL;
	pCmdIns.CreateInstance(_uuidof(Command));
	pCmdIns->ActiveConnection = m_pConnection;

	CString strSql, strCN, strCurTime;
	CGUCodeCreator guCodeCreator;
	strCN = guCodeCreator.GenerateGUIDCode();

	m_uiEamount = COption3DGeometryDlg::GetInstance()->GetAllCoordinatesPointsCount();

	//检查脚本是否已存在
	pRecSCID.CreateInstance(_uuidof(Recordset));
	strSql.Format(_T("select * from scon where Sname = '%s' and Stype=2"), m_strScriptName);
	pRecSCID->Open(strSql.AllocSysString(), _variant_t((IDispatch*)m_pConnection, true), adOpenStatic, adLockOptimistic, adCmdText);
	if ((long)VAL_ZERO != pRecSCID->GetRecordCount())
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("脚本已经存在."));
		else
			MessageBoxEx(NULL, _T("Script has been alreay exists"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		pRecSCID->Close();
		m_pConnection->RollbackTrans();
		return FALSE;
	}
	pRecSCID->Close();

	CString strPoleDistance,strTemp;
	strPoleDistance.Empty();
	std::vector<STBoreHoleParam> vecAllElecCoordinatesInfo = COption3DGeometryDlg::GetInstance()->GetAllElecCoordinatesInfo();
	for (std::vector<STBoreHoleParam>::iterator iter = vecAllElecCoordinatesInfo.begin(); iter != vecAllElecCoordinatesInfo.end(); iter++)
	{
		//x,y,z,电极间距
		strTemp.Empty();
		strTemp.Format(_T("%.2f,%.2f,%.2f,%.2f;"), iter->fX, iter->fY, iter->fZ,iter->fElecSpacing);
		strPoleDistance += strTemp;
	}
	
	SYSTEMTIME st;
	GetLocalTime(&st);
	strCurTime.Format(_T("%4d-%2d-%2d"), st.wYear, st.wMonth, st.wDay);
	strSql.Format(_T("insert into scon(CN,Sname,Stype,Eamount,CHamount,TPamount,definer,DEdate,SCdesc,Rect,RectLoc,PoleDistance,PoleStep,WellMaxDepth) "
		"values('%s','%s',%d,%d,%d,%d,'%s',#%s#,'%s','%s', '%s', '%s', '%s',%.4f)"),
		strCN,
		m_strScriptName,
		2,//3D
		m_uiEamount,
		1,//目前二维都是得到的1，暂填
		m_uiTPamount,
		m_strOperator,//定义人暂时为空，是否需要支持
		strCurTime,
		m_strNote,//脚本描述
		"",//pCreate3DSptDlg->GetRect(),
		"",//pCreate3DSptDlg->GetPoleStart(),
		strPoleDistance,//pCreate3DSptDlg->GetPoleDistance(),
		"",
		COption3DBoreholeDlg::GetInstance()->GetMaxWellDepth());//pCreate3DSptDlg->GetPoleStep());
	
	pCmdIns->CommandText = strSql.AllocSysString();
	pCmdIns->Execute(NULL, NULL, adCmdText);

	//取得scon表中ID最大的ITEM
	DWORD dwSConID = 0;
	DWORD dwCHID = 0;
	pRecSCID.CreateInstance(_uuidof(Recordset));
	pRecSCID->Open(_T("select max(ID) as ID from scon"), _variant_t((IDispatch*)m_pConnection, true), adOpenStatic, adLockOptimistic, adCmdText);
	if ((long)VAL_ZERO != pRecSCID->GetRecordCount())//返回1
	{
		dwSConID = (DWORD)pRecSCID->GetCollect(_T("ID")).ulVal;
	}
	pRecSCID->Close();

	strSql.Format(_T("insert into channel(SCID,CHnumber,AR) values(%u,%d,%d) "),
		dwSConID,
		1,//pChannel->m_iChNumber
		AR_CROSS_HOLE_GEOMATIVE);
	pCmdIns->CommandText = strSql.AllocSysString();
	pCmdIns->Execute(NULL, NULL, adCmdText);

	strSql.Format(_T("select ID from channel where SCID = %d"), dwSConID);
	pRecSCID->Open(strSql.AllocSysString(), _variant_t((IDispatch*)m_pConnection, true), adOpenStatic, adLockOptimistic, adCmdText);
	if ((long)VAL_ZERO != pRecSCID->GetRecordCount())
	{
		dwCHID = (DWORD)pRecSCID->GetCollect(_T("ID")).ulVal;
	}
	pRecSCID->Close();

	//多通道装置，排序
	if (0 != theApp.m_ucIsMultiChannel)//if (EN_MULTI_CHANNEL == theApp.m_ucIsMultiChannel)
	{
		map<int, map<int, map<int, STDatabaseABMNInfo>>>::iterator iterA = m_mapDatabaseABMNInfo.begin();
		map<int, map<int, STDatabaseABMNInfo>>::iterator iterB;
		map<int, STDatabaseABMNInfo>::iterator iterM;
		int iTSN = 0;
		for (; iterA != m_mapDatabaseABMNInfo.end(); iterA++)
		{
			for (iterB = iterA->second.begin(); iterB != iterA->second.end(); iterB++)
			{
				for (iterM = iterB->second.begin(); iterM != iterB->second.end(); iterM++)
				{
					strSql.Format(_T("insert into script3d(CHID,TSN,C1,C2,P1,P2,K,N) values(%u,%d,%d,%d,%d,%d,%.2f,%d) "),
						dwCHID,
						iTSN + 1,
						iterM->second.uiAElecID,
						iterM->second.uiBElecID,
						iterM->second.uiMElecID,
						iterM->second.uiNElecID,
						iterM->second.fK,
						iterM->second.iTrace);
					OutputDebugString(strSql + _T("\n"));
					pCmdIns->CommandText = strSql.AllocSysString();
					try
					{
						pCmdIns->Execute(NULL, NULL, adCmdText);
					}
					catch (_com_error e)
					{
						//hHook = SetWindowsHookEx(WH_CBT, (HOOKPROC)CBTHookProc, AfxGetInstanceHandle(), NULL);
						AfxMessageBox((LPCTSTR)e.Description());
					}
					iTSN++;
				}
			}
		}
	}
	else if (0 == theApp.m_ucIsMultiChannel)//单通道，不需要排序
	{
		int iTestPointNum = m_vecAllBoreholeABMNInfo.size();
		//CSptRecord* sptRecord = NULL;
		for (int i = 0; i < iTestPointNum; i++)
		{
			//sptRecord = (CSptRecord*)m_pChannel.m_sptRecArray.GetAt(i);
			strSql.Format(_T("insert into script3d(CHID,TSN,C1,C2,P1,P2,K,N) values(%u,%d,%d,%d,%d,%d,%.2f,%d) "),
				dwCHID,
				i + 1,
				m_vecAllBoreholeABMNInfo[i].uiAElecID,
				m_vecAllBoreholeABMNInfo[i].uiBElecID,
				m_vecAllBoreholeABMNInfo[i].uiMElecID,
				m_vecAllBoreholeABMNInfo[i].uiNElecID,
				m_vecAllBoreholeABMNInfo[i].fK,
				m_vecAllBoreholeABMNInfo[i].iTrace);
			OutputDebugString(strSql + _T("\n"));
			pCmdIns->CommandText = strSql.AllocSysString();
			try
			{
				pCmdIns->Execute(NULL, NULL, adCmdText);
			}
			catch (_com_error e)
			{
				//hHook = SetWindowsHookEx(WH_CBT, (HOOKPROC)CBTHookProc, AfxGetInstanceHandle(), NULL);
				AfxMessageBox((LPCTSTR)e.Description());
			}
		}
	}
	//将AMNB信息吸入数据库---------------end------------------

	//将脚本电极坐标信息写入数据库---------begin--------------
	std::vector<STBoreHolePoints> vecAllCoordinates = COption3DGeometryDlg::GetInstance()->GetAllCoordinatesPoints();
	std::vector<STBoreHolePoints>::iterator iter = vecAllCoordinates.begin();
	for (int i =1; iter != vecAllCoordinates.end(); iter++,i++)
	{
		strSql.Format(_T("insert into TCoordinatesInfo(SSN,ScriptCN,ElectrodeID,X,Y,Z) values(%d,'%s',%d,%f,%f,%f)"),i, strCN, iter->uiElecID, iter->fX, iter->fY, iter->fZ);
		pCmdIns->CommandText = strSql.AllocSysString();
		try
		{
			pCmdIns->Execute(NULL, NULL, adCmdText);
		}
		catch (_com_error e)
		{
			AfxMessageBox((LPCTSTR)e.Description());
		}
	}
	//将脚本电极坐标信息写入数据库---------end--------------

	m_pConnection->CommitTrans();
	return TRUE;
}

void CCrossHoleConfig3DMainDlg::OnBnClickedBtnCreate()
{
	// TODO:  在此添加控件通知处理程序代码	
	if (C3DSimulationDlg::GetInstance()->IsSimulating())
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("正在模拟跑极不能操作"));
		else
			MessageBoxEx(NULL, _T("Running is being simulated and cannot be operated"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		return;
	}
	C3DSimulationDlg::GetInstance()->ShowWindow(SW_HIDE);
	CCrosshole3dDrawingBoardDlg::GetInstance()->ShowWindow(SW_SHOW);

	m_vecAllBoreholeABMNInfo.clear();
	m_iMediumType = COption3DSettingDlg::GetInstance()->GetMediumType();
	if (m_iMediumType < 0)
	{
		return;
	}

	m_strScriptName = COption3DSettingDlg::GetInstance()->GetScriptName();
	if (m_strScriptName.IsEmpty())
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("脚本名称不能为空"));
		else
			MessageBoxEx(NULL, _T("Script name cannot be empty"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		return;
	}

	m_strOperator = COption3DSettingDlg::GetInstance()->GetOperator();
	m_strNote = COption3DSettingDlg::GetInstance()->GetNote();

	m_strTimeInterval = COption3DSettingDlg::GetInstance()->GetTimeInterval();
	if (m_strTimeInterval.IsEmpty())
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("时间间隔不能为空"));
		else
			MessageBoxEx(NULL, _T("Time interval cannot be empty"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		return;
	}

	//重置电极总数
	m_uiTPamount = 0;
	m_mapDatabaseABMNInfo.clear();
	//先只生产脚本测点，其他的情况后面再加
	//获取孔的数目
	int iBHNum = 0;
	map<STWellPoints, vector<STBoreHolePoints>> mapBoreholePoint = COption3DGeometryDlg::GetInstance()->GetBoreholeCoordinates();
	if (mapBoreholePoint.size() > 0)
	{
		iBHNum = mapBoreholePoint.size();
	}

	//获取地表的坐标
	std::map<int, std::vector<STBoreHolePoints>> mapSurfaceXDirecitionPoint = COption3DGeometryDlg::GetInstance()->GetSurfaceXDirectionCoordinates();
	iBHNum += mapSurfaceXDirecitionPoint.size();
	std::map<int, std::vector<STBoreHolePoints>> mapSurfaceYDirecitionPoint = COption3DGeometryDlg::GetInstance()->GetSurfaceYDirectionCoordinates();
	iBHNum += mapSurfaceYDirecitionPoint.size();
	//std::vector<STBoreHolePoints> vecSurface = COption3DGeometryDlg::GetInstance()->GetSurfaceCoordinates();
	//m_iMediumType 0:跨孔(Geomative) 1:井地井(Geomative)
	if (mapSurfaceXDirecitionPoint.size() > 0 
		|| mapSurfaceYDirecitionPoint.size() >0)
	{
		if (0 == m_iMediumType)
		{
			if (LANG_ZHCN == g_iUILanguage)
				AfxMessageBox(_T("跨孔装置不需要地表"));
			else
				MessageBoxEx(NULL, _T("Cross-hole devices do not require a surface"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
			return;
		}
		//iBHNum++;
		//mapBoreholePoint[iBHNum] = vecSurface;
	}
	else
	{
		if (1 == m_iMediumType)
		{
			if (LANG_ZHCN == g_iUILanguage)
				AfxMessageBox(_T("井地井装置需要地表"));
			else
				MessageBoxEx(NULL, _T("Well to well equipment requires surface"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
			return;
		}
	}

	/*CString strLog;
	strLog.Format(_T("zm:当前井数目:%d\n"), iBHNum);
	OutputDebugString(strLog);*/
	if (iBHNum > 0)
	{
		if (iBHNum == 1)
		{
			if (LANG_ZHCN == g_iUILanguage)
				AfxMessageBox(_T("跨孔必须两孔或以上"));
			else
				MessageBoxEx(NULL, _T("Span holes must be two or more"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		}
		else
		{			
			std::map<STWellPoints, std::vector<STBoreHolePoints>>::iterator iterWell = mapBoreholePoint.begin();
			std::map<int, std::vector<STBoreHolePoints>>::iterator iterSurfaceX = mapSurfaceXDirecitionPoint.begin();
			std::map<int, std::vector<STBoreHolePoints>>::iterator iterSurfaceY = mapSurfaceYDirecitionPoint.begin();
			//AM装置需要单口井遍历AM
			switch (m_iMediumType)
			{
			case 2://AR_CROSS_HOLE_GEOMATIVE_AM:
				if (mapBoreholePoint.size() > 0)
				{
					for (iterWell = mapBoreholePoint.begin(); iterWell != mapBoreholePoint.end(); iterWell++)
					{
						OneBoreHoleGenerateScriptAM(iterWell->second);						
					}
				}				
				if (mapSurfaceXDirecitionPoint.size() > 0)
				{
					OneBoreHoleGenerateScriptAM(mapSurfaceXDirecitionPoint);
				}
				if (mapSurfaceYDirecitionPoint.size() > 0)
				{
					OneBoreHoleGenerateScriptAM(mapSurfaceYDirecitionPoint);
				}
				break;
			default:
				break;
			}

			//井 + 井
			map<STWellPoints, vector<STBoreHolePoints>>::iterator iterWellEx = mapBoreholePoint.begin();
			for (iterWell = mapBoreholePoint.begin(); iterWell != mapBoreholePoint.end(); iterWell++)
			{
				iterWellEx = iterWell;
				iterWellEx++;
				for (; iterWellEx != mapBoreholePoint.end(); iterWellEx++)
				{
					switch (m_iMediumType)
					{
					case 2://AR_CROSS_HOLE_GEOMATIVE_AM:
						TwoBoreHoleGenerateScriptAM(EN_CABLE_DIRECTION_Z | EN_CABLE_DIRECTION_Z, iterWell->second, iterWellEx->second);
						break;
					default:
						TwoBoreholeGenerateScript(iterWell->second, iterWellEx->second);
						break;
					}
				}
			}

			//井 + 地表X方向
			for (iterWell = mapBoreholePoint.begin(); iterWell != mapBoreholePoint.end(); iterWell++)
			{
				for (iterSurfaceX = mapSurfaceXDirecitionPoint.begin(); iterSurfaceX != mapSurfaceXDirecitionPoint.end(); iterSurfaceX++)
				{
					switch (m_iMediumType)
					{
					case 2://AR_CROSS_HOLE_GEOMATIVE_AM:
						TwoBoreHoleGenerateScriptAM(EN_CABLE_DIRECTION_Z|EN_CABLE_DIRECTION_X, iterWell->second, iterSurfaceX->second);
						break;
					default:
						TwoBoreholeGenerateScript(iterWell->second, iterSurfaceX->second);
						break;
					}						
				}
			}

			//井 + 地表Y方向
			for (iterWell = mapBoreholePoint.begin(); iterWell != mapBoreholePoint.end(); iterWell++)
			{
				for (iterSurfaceY = mapSurfaceYDirecitionPoint.begin(); iterSurfaceY != mapSurfaceYDirecitionPoint.end(); iterSurfaceY++)
				{
					switch (m_iMediumType)
					{
					case 2://AR_CROSS_HOLE_GEOMATIVE_AM:
						TwoBoreHoleGenerateScriptAM(EN_CABLE_DIRECTION_Z|EN_CABLE_DIRECTION_Y, iterWell->second, iterSurfaceY->second);
						break;
					default:
						TwoBoreholeGenerateScript(iterWell->second, iterSurfaceY->second);
						break;
					}
				}
			}

			//地表X + 地表Y
			for (iterSurfaceX = mapSurfaceXDirecitionPoint.begin(); iterSurfaceX != mapSurfaceXDirecitionPoint.end(); iterSurfaceX++)
			{
				for (iterSurfaceY = mapSurfaceYDirecitionPoint.begin(); iterSurfaceY != mapSurfaceYDirecitionPoint.end(); iterSurfaceY++)
				{
					switch (m_iMediumType)
					{
					case 2://AR_CROSS_HOLE_GEOMATIVE_AM:
						TwoBoreHoleGenerateScriptAM(EN_CABLE_DIRECTION_X|EN_CABLE_DIRECTION_Y, iterSurfaceX->second, iterSurfaceY->second);
						break;
					default:
						TwoBoreholeGenerateScript(iterSurfaceX->second, iterSurfaceY->second);
						break;
					}
				}
			}
			
			//写入数据库
			BOOL bRes = SaveTestPointToDB();
			if (bRes)
			{
				if (LANG_ZHCN == g_iUILanguage)
					AfxMessageBox(_T("创建成功"));
				else
					MessageBoxEx(NULL, _T("Create success"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
				//关闭当前窗口？更新到脚本列表

				::SendMessage(AfxGetApp()->GetMainWnd()->m_hWnd, WM_REFRESH, (WPARAM)OP_SPT_SYN, (LPARAM)VAL_ZERO);
			}
		}
	}

	GetDlgItem(ID_BTN_START_SIMULATION)->EnableWindow(TRUE);
}

void CCrossHoleConfig3DMainDlg::OnBnClickedBtnStartSimulation()
{
	// TODO:  在此添加控件通知处理程序代码
	CCrosshole3dDrawingBoardDlg::GetInstance()->ShowWindow(FALSE);
	C3DSimulationDlg::GetInstance()->ShowWindow(SW_SHOW);
	
	if (!m_strTimeInterval.IsEmpty())
	{
		m_strTimeInterval = COption3DSettingDlg::GetInstance()->GetTimeInterval();
	}
	C3DSimulationDlg::GetInstance()->SetTimeInterval(atoi(m_strTimeInterval));
	C3DSimulationDlg::GetInstance()->SetSingleChannelSimulationRunMethod(m_vecAllBoreholeABMNInfo);
	C3DSimulationDlg::GetInstance()->SetMultiChannelSimulationRunMethod(m_mapDatabaseABMNInfo);
	C3DSimulationDlg::GetInstance()->StartSimulation();
	GetDlgItem(ID_BTN_START_SIMULATION)->EnableWindow(FALSE);
	GetDlgItem(ID_BTN_STOP_SIMULATION)->EnableWindow(TRUE);
	GetDlgItem(ID_BTN_CLOSE)->EnableWindow(FALSE);
}


void CCrossHoleConfig3DMainDlg::OnBnClickedBtnStopSimulation()
{
	// TODO:  在此添加控件通知处理程序代码
	C3DSimulationDlg::GetInstance()->StopSimulation();
	GetDlgItem(ID_BTN_START_SIMULATION)->EnableWindow(TRUE);
	GetDlgItem(ID_BTN_STOP_SIMULATION)->EnableWindow(FALSE);
	GetDlgItem(ID_BTN_CLOSE)->EnableWindow(TRUE);
}


void CCrossHoleConfig3DMainDlg::OnBnClickedBtnClose()
{
	CDialog::OnOK();
	// TODO:  在此添加控件通知处理程序代码
}

LRESULT CCrossHoleConfig3DMainDlg::OnMsgCrossHoleMainWndBtn(WPARAM wParam, LPARAM lParam)
{
	OnBnClickedBtnStopSimulation();
	return 0;
}

void CCrossHoleConfig3DMainDlg::OnDestroy()
{
	OnBnClickedBtnStopSimulation();

	//清空窗口信息
	COption3DGeometryDlg::GetInstance()->DeleteCoordinatesPoint();
	CCrosshole3dDrawingBoardDlg::GetInstance()->DeleteCoordinatesPoint();
	CDialog::OnDestroy();	
	// TODO:  在此处添加消息处理程序代码
}