OTS/OTS_GB/OTSModel/Report/CGBCalculate.cpp

#pragma once
#include "stdafx.h"
#include "CGBCalculate.h"
#include "OTSFieldData.h"
#include "GBImgPropCal.h"
#include "OTSHelper.h"
#include "MultiLang.h"
namespace OTSMODEL
{
	using namespace OTSDATA;
	using namespace OTSIMGPROC;
	CGBCalculate::CGBCalculate(CReportProjFileMgr* rptMgrPtr)
	{
		m_rptMgrPtr = rptMgrPtr;
	}

	CGBCalculate::~CGBCalculate()
	{
	}

	// class methods

	// public 
	CGridDatasList CGBCalculate::GetGBInclusion()
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());
		CGBFieldList listCGBField;

		//CGBFieldMgr pCGBFieldMgr;
		COTSParticleList listOTSParticle;
		COTSParticlePtr pOTSParticle;
		CGBImgPropCal pGBImgPropCal;

		CGridDatasList listGridData;
		listGridData.clear();
		CGridDatasList multGridList;
		multGridList.clear();

		// depart compound source name

		CPropParamPtr currentProp = m_rptMgrPtr->GetCurrentPropParam();
		std::vector<CString> listDataSource = currentProp->GetDataSourceList();
		int nSelectedDataSourceIndex = currentProp->GetDataSourceId();
		CString sDataSourceNames = listDataSource[nSelectedDataSourceIndex];
		std::vector<CString> listSelectedDataSource = COTSHelper::SplitString(sDataSourceNames, _T("+"));

		for (auto strDataSourceName : listSelectedDataSource)
		{
			listCGBField.clear();
			CGridDataPtr pGridData = CGridDataPtr(new CGridData());
			// data source id
			std::vector<CString> listDataSource;
			listDataSource.clear();
			listDataSource = currentProp->GetDataSourceList();
			pGridData->SetDataSourceList(listDataSource);

			int nDataSourceId = currentProp->GetDataSourceId();
			pGridData->SetDataSourceId(nDataSourceId);


			CSmplMsrResultFileMgrPtr rstFileMgrPrt = m_rptMgrPtr->GetASmplMsrResultMgrByFileName(strDataSourceName);

			// sample measurment result file manager
			CSmplMsrResultFileMgr* pSmplMsrResultFileMgr;
			pSmplMsrResultFileMgr = rstFileMgrPrt.get();

			CSmplMsrResultFilePtr pSmplMsrResultFile = pSmplMsrResultFileMgr->GetSmplMsrResultFile();
			COTSSamplePtr pSample = pSmplMsrResultFile->GetSample();

			double dPixelSize = pSample->CalculatePixelSize();
			SetPixSize(dPixelSize);
			CGBFieldList listRawGBFields = CalGBFields(pSmplMsrResultFileMgr);
			listCGBField = listRawGBFields;
			//for each (COTSFieldDataPtr GBfield in listRawGBFields)
			//{
			//	listOTSParticle = GBfield->GetParticleList();
			//	for each (COTSParticlePtr Particle in listOTSParticle)
			//	{
			//		double a_dPartFTD;
			//		double a_dMinWidth;
			//		double a_dMaxLength;
			//		double a_dRatio;
			//		/*pGBImgPropCal.GetParticleFTD(Particle, dPixelSize, a_dPartFTD, a_dMinWidth , a_dMaxLength, a_dRatio);
			//		
			//		Particle->SetFeretDiameter(a_dPartFTD);
			//		
			//		Particle->SetWidth(a_dMinWidth);
			//		Particle->SetHeight(a_dMaxLength);*/

			//	}
			//	//cal stdFrame
			//	CGBFieldDataPtr GBFld(new CGBFieldData());
			//	GBFld->SetParticleList(listOTSParticle,TRUE);
			//	GBFld->SetPosition(GBfield->GetPosition());
			//

			//	listCGBField.push_back(GBFld);
			//}
			CALCULATE_TABLE_TYPE ty = m_rptMgrPtr->GetCurrentPropParam()->GetCalTableType();
			if (ty == CALCULATE_TABLE_TYPE::DIN)
			{
				listGridData = this->GetGridDataListForOneDataSourceDIN(pSmplMsrResultFile->GetAllParticles());
			}
			else
			{
				listGridData = this->GetGridDataListForOneDataSource(listCGBField);
			}
			multGridList.insert(multGridList.end(), listGridData.begin(), listGridData.end());
		}
		return multGridList;
	}
	CGridDatasList CGBCalculate::GetGridDataListForOneDataSource(CGBFieldList listCGBField)
	{
		CGridDatasList listGridData;

		//Definition numbers
		//use the nXLevel array to memory how many fields in each level.
		CONST int LEVEL_LENGTH = 11;
		int nALevel[LEVEL_LENGTH];  //nALevelZero, nALevel_0_5, nALevel_1_0, nALevel_1_5, nALevel_2_0, nALevel_2_5, nALevel_3_0, nALevel_3_5, nALevel_4_0, nALevel_4_5, nALevel_5_0 ;
		int nALevel_w[LEVEL_LENGTH]; //nALevelZero_f, nALevel_0_5_f, nALevel_1_0_f, nALevel_1_5_f, nALevel_2_0_f, nALevel_2_5_f, nALevel_3_0_f, nALevel_3_5_f, nALevel_4_0_f, nALevel_4_5_f, nALevel_5_0_f;
		int nALevel_s[LEVEL_LENGTH];
		int nBLevel[LEVEL_LENGTH]; //nBLevelZero, nBLevel_0_5, nBLevel_1_0, nBLevel_1_5, nBLevel_2_0, nBLevel_2_5, nBLevel_3_0, nBLevel_3_5, nBLevel_4_0, nBLevel_4_5, nBLevel_5_0;
		int nBLevel_w[LEVEL_LENGTH]; //nBLevelZero_f, nBLevel_0_5_f, nBLevel_1_0_f, nBLevel_1_5_f, nBLevel_2_0_f, nBLevel_2_5_f, nBLevel_3_0_f, nBLevel_3_5_f, nBLevel_4_0_f, nBLevel_4_5_f, nBLevel_5_0_f;
		int nBLevel_s[LEVEL_LENGTH];
		int nCLevel[LEVEL_LENGTH]; //nCLevelZero, nCLevel_0_5, nCLevel_1_0, nCLevel_1_5, nCLevel_2_0, nCLevel_2_5, nCLevel_3_0, nCLevel_3_5, nCLevel_4_0, nCLevel_4_5, nCLevel_5_0;
		int nCLevel_w[LEVEL_LENGTH]; //nCLevelZero_f, nCLevel_0_5_f, nCLevel_1_0_f, nCLevel_1_5_f, nCLevel_2_0_f, nCLevel_2_5_f, nCLevel_3_0_f, nCLevel_3_5_f, nCLevel_4_0_f, nCLevel_4_5_f, nCLevel_5_0_f;
		int nCLevel_s[LEVEL_LENGTH];
		int nDLevel[LEVEL_LENGTH];// nDLevelZero, nDLevel_0_5, nDLevel_1_0, nDLevel_1_5, nDLevel_2_0, nDLevel_2_5, nDLevel_3_0, nDLevel_3_5, nDLevel_4_0, nDLevel_4_5, nDLevel_5_0;
		int nDLevel_w[LEVEL_LENGTH]; //nDLevelZero_f, nDLevel_0_5_f, nDLevel_1_0_f, nDLevel_1_5_f, nDLevel_2_0_f, nDLevel_2_5_f, nDLevel_3_0_f, nDLevel_3_5_f, nDLevel_4_0_f, nDLevel_4_5_f, nDLevel_5_0_f;
		int nDLevel_s[LEVEL_LENGTH];
		int nDSulfideLevel[LEVEL_LENGTH];// nDLevelZero, nDLevel_0_5, nDLevel_1_0, nDLevel_1_5, nDLevel_2_0, nDLevel_2_5, nDLevel_3_0, nDLevel_3_5, nDLevel_4_0, nDLevel_4_5, nDLevel_5_0;
		int nDSulfideLevel_w[LEVEL_LENGTH]; //nDLevelZero_f, nDLevel_0_5_f, nDLevel_1_0_f, nDLevel_1_5_f, nDLevel_2_0_f, nDLevel_2_5_f, nDLevel_3_0_f, nDLevel_3_5_f, nDLevel_4_0_f, nDLevel_4_5_f, nDLevel_5_0_f;
		int nDSulfideLevel_s[LEVEL_LENGTH];
		CGBFieldList  listDSFrame;
		//initlize
		for (int i = 0; i < LEVEL_LENGTH; i++)
		{
			nALevel[i] = 0;
			nALevel_w[i] = 0;
			nALevel_s[i] = 0;
			nBLevel[i] = 0;
			nBLevel_w[i] = 0;
			nBLevel_s[i] = 0;
			nCLevel[i] = 0;
			nCLevel_w[i] = 0;
			nCLevel_s[i] = 0;
			nDLevel[i] = 0;
			nDLevel_w[i] = 0;
			nDLevel_s[i] = 0;
			nDSulfideLevel[i] = 0;
			nDSulfideLevel_w[i] = 0;
			nDSulfideLevel_s[i] = 0;
		}


		//loop CGBField list and  cal the level numbers

		for each (CGBFieldDataPtr GBFld in listCGBField)
		{
			//CalLevel mode 
			switch (m_rptMgrPtr->GetCurrentPropParam()->GetCalTableType())
			{
			case CALCULATE_TABLE_TYPE::GB_Method1:
				GBFld->CaculateLevelByMethod1();
				break;
			case CALCULATE_TABLE_TYPE::GB_Method2:
				GBFld->CaculateLevelByMethod2();
				break;
			case CALCULATE_TABLE_TYPE::ASTM:
				GBFld->CaculateLevelASTM();
				break;
			default:
				break;
			}
			GB_GRADE_TYPE levelt = GBFld->GetALevel()->GetThinGrade();
			GB_GRADE_TYPE levelw = GBFld->GetALevel()->GetWideGrade();
			GB_GRADE_TYPE levels = GBFld->GetALevel()->GetSuperGrade();

			SetFrameLevelNo(levelt, nALevel);

			SetFrameLevelNo(levelw, nALevel_w);

			SetFrameLevelNo(levels, nALevel_s);

			levelt = GBFld->GetBLevel()->GetThinGrade();
			levelw = GBFld->GetBLevel()->GetWideGrade();
			levels = GBFld->GetBLevel()->GetSuperGrade();


			SetFrameLevelNo(levelt, nBLevel);

			SetFrameLevelNo(levelw, nBLevel_w);

			SetFrameLevelNo(levels, nBLevel_s);
			levelt = GBFld->GetCLevel()->GetThinGrade();
			levelw = GBFld->GetCLevel()->GetWideGrade();
			levels = GBFld->GetCLevel()->GetSuperGrade();


			SetFrameLevelNo(levelt, nCLevel);

			SetFrameLevelNo(levelw, nCLevel_w);

			SetFrameLevelNo(levels, nCLevel_s);

			levelt = GBFld->GetDLevel()->GetThinGrade();
			levelw = GBFld->GetDLevel()->GetWideGrade();
			levels = GBFld->GetDLevel()->GetSuperGrade();

			SetFrameLevelNo(levelt, nDLevel);

			SetFrameLevelNo(levelw, nDLevel_w);

			SetFrameLevelNo(levels, nDLevel_s);


		}

		//Get ListGrid for Level
		 //CalLevel mode 
		CGridDataPtr AGrid;
		CGridDataPtr BGrid;
		CGridDataPtr CGrid;
		CGridDataPtr DGrid;
		CGridDataPtr DSulfideGrid;
		CGridDataPtr DSGrid;
		CGridDataPtr GBFieldGrid;
		switch (m_rptMgrPtr->GetCurrentPropParam()->GetCalTableType())
		{
		case CALCULATE_TABLE_TYPE::GB_Method1:

			AGrid = GetGridLevel("A", nALevel, nALevel_w, nALevel_s);

			BGrid = GetGridLevel("B", nBLevel, nBLevel_w, nBLevel_s);

			CGrid = GetGridLevel("C", nCLevel, nCLevel_w, nCLevel_s);

			DGrid = GetGridLevel("D", nDLevel, nDLevel_w, nDLevel_s);

			DSGrid = GetGridDSLevel(listCGBField);

			GBFieldGrid = GetGBFieldGrid(listCGBField);

			listGridData.push_back(AGrid);
			listGridData.push_back(BGrid);
			listGridData.push_back(CGrid);
			listGridData.push_back(DGrid);
			listGridData.push_back(DSGrid);
			listGridData.push_back(GBFieldGrid);
			//listGridData
			return listGridData;
			break;
		case CALCULATE_TABLE_TYPE::GB_Method2:

			AGrid = GetGridLevel("A", nALevel, nALevel_w, nALevel_s);

			BGrid = GetGridLevel("B", nBLevel, nBLevel_w, nBLevel_s);

			CGrid = GetGridLevel("C", nCLevel, nCLevel_w, nCLevel_s);

			DGrid = GetGridLevel("D", nDLevel, nDLevel_w, nDLevel_s);

			DSulfideGrid = GetGridLevel("DSulfide", nDSulfideLevel, nDSulfideLevel_w, nDSulfideLevel_s);

			DSGrid = GetGridDSLevel(listCGBField);
			GBFieldGrid = GetGBFieldGrid(listCGBField);

			listGridData.push_back(AGrid);
			listGridData.push_back(BGrid);
			listGridData.push_back(CGrid);
			listGridData.push_back(DGrid);
			listGridData.push_back(DSulfideGrid);
			listGridData.push_back(DSGrid);
			listGridData.push_back(GBFieldGrid);
			//listGridData
			return listGridData;
			break;
		case CALCULATE_TABLE_TYPE::ASTM:

			AGrid = GetGridLevel("A", nALevel, nALevel_w, nALevel_s);

			BGrid = GetGridLevel("B", nBLevel, nBLevel_w, nBLevel_s);

			CGrid = GetGridLevel("C", nCLevel, nCLevel_w, nCLevel_s);

			DGrid = GetGridLevel("D", nDLevel, nDLevel_w, nDLevel_s);

			DSGrid = GetGridDSLevel(listCGBField);

			GBFieldGrid = GetGBFieldGrid(listCGBField);

			listGridData.push_back(AGrid);
			listGridData.push_back(BGrid);
			listGridData.push_back(CGrid);
			listGridData.push_back(DGrid);
			listGridData.push_back(DSGrid);
			listGridData.push_back(GBFieldGrid);
			//listGridData
			return listGridData;
			break;
		default:
			return listGridData;
			break;

		}

	}
	CGridDatasList CGBCalculate::GetGridDataListForOneDataSourceDIN(COTSParticleList listParticle)
	{
		CGridDatasList listGridData;
		COTSParticleList cotsparticlelistA;
		set<COTSParticlePtr> cotsparticlelistB;
		COTSParticleList cotsparticlelistC;
		COTSParticleList cotsparticlelistD;

		//loop CGBField list and  cal the level numbers
		CGBFieldDataPtr GBFld(new CGBFieldData());
		GBFld->SetParticleList(listParticle, TRUE);
		GBFld->CaculateLevelDIN(listParticle);
		cotsparticlelistA = GBFld->listAThinParticles;
		cotsparticlelistB = GBFld->listBThinParticles;
		cotsparticlelistC = GBFld->listCThinParticles;
		cotsparticlelistD = GBFld->listDThinParticles;
		//Get ListGrid for Level
		 //CalLevel mode 
		CGridDataPtr AGrid;
		AGrid = GetGridDIN(cotsparticlelistA, cotsparticlelistB, cotsparticlelistC, cotsparticlelistD);
		listGridData.push_back(AGrid);

		//listGridData
		return listGridData;


	}
	//CGridDataPtr CGBFieldMgr::GetGBFieldGrid(CGBFieldList listCGBField, CGridInPtr a_pGridIn);
	CGridDataPtr CGBCalculate::GetGBFieldGrid(CGBFieldList listCGBField)
	{
		CGridDataPtr pGridData = CGridDataPtr(new CGridData());
		std::vector<CString> listDataSource;
		listDataSource.clear();
		listDataSource = m_rptMgrPtr->GetCurrentPropParam()->GetDataSourceList();
		pGridData->SetDataSourceList(listDataSource);

		int nDataSourceId = m_rptMgrPtr->GetCurrentPropParam()->GetDataSourceId();
		pGridData->SetDataSourceId(nDataSourceId);
		//amounts
		CGridColumnsList listCol;
		listCol.clear();
		int columnNum = 11;//表格总列数 fieldpos 占2列，ABCDDS 占5列，particle占1列,particle 类别占1列，particle宽度占1列
		CGridColumnPtr pColumn;
		for (int i = 0; i < columnNum; i++)
		{
			CString strName;
			CGridRowsList listRows;
			CGridRowPtr pRow;
			switch (i)
			{
			case 0:
				pColumn = CGridColumnPtr(new CGridColumn());
				pColumn->SetName("FieldPosX");
				for (auto GBF : listCGBField)
				{
					for (auto p : GBF->GetParticleList())
					{
						pRow = CGridRowPtr(new CGridRow());
						pRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
						pRow->SetIntValue(GBF->GetPosition().x);
						listRows.push_back(pRow);
					}
				}
				pColumn->SetGridRowsList(listRows);
				listCol.push_back(pColumn);
				break;
			case 1:
				pColumn = CGridColumnPtr(new CGridColumn());
				pColumn->SetName("FieldPosY");
				for (auto GBF : listCGBField)
				{
					for (auto p : GBF->GetParticleList())
					{

						pRow = CGridRowPtr(new CGridRow());
						pRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
						pRow->SetIntValue(GBF->GetPosition().y);
						listRows.push_back(pRow);
					}
				}
				pColumn->SetGridRowsList(listRows);
				listCol.push_back(pColumn);
				break;
			case 2:
				pColumn = CGridColumnPtr(new CGridColumn());
				pColumn->SetName("ALevel");
				for (auto GBF : listCGBField)
				{
					for (auto p : GBF->GetParticleList())
					{
						pRow = CGridRowPtr(new CGridRow());
						pRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
						std::string Athin, Awide, Asuper;
						auto Alevel = GBF->GetALevel();
						auto thin = Alevel->GetThinGrade();
						Athin = GetLevelStr(thin);
						Awide = GetLevelStr(Alevel->GetWideGrade());
						Asuper = GetLevelStr(Alevel->GetSuperGrade());
						pRow->SetStringValue((Athin + "," + Awide + "," + Asuper).c_str());
						listRows.push_back(pRow);
					}
				}
				pColumn->SetGridRowsList(listRows);
				listCol.push_back(pColumn);
				break;
			case 3:
				pColumn = CGridColumnPtr(new CGridColumn());
				pColumn->SetName("BLevel");
				for (auto GBF : listCGBField)
				{
					for (auto p : GBF->GetParticleList())
					{
						pRow = CGridRowPtr(new CGridRow());
						pRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
						std::string thin, wide, super;
						auto level = GBF->GetBLevel();

						thin = GetLevelStr(level->GetThinGrade());
						wide = GetLevelStr(level->GetWideGrade());
						super = GetLevelStr(level->GetSuperGrade());
						pRow->SetStringValue((thin + "," + wide + "," + super).c_str());
						listRows.push_back(pRow);
					}
				}
				pColumn->SetGridRowsList(listRows);
				listCol.push_back(pColumn);
				break;
			case 4:
				pColumn = CGridColumnPtr(new CGridColumn());
				pColumn->SetName("CLevel");
				for (auto GBF : listCGBField)
				{
					for (auto p : GBF->GetParticleList())
					{
						pRow = CGridRowPtr(new CGridRow());
						pRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
						std::string thin, wide, super;
						auto level = GBF->GetCLevel();
						thin = GetLevelStr(level->GetThinGrade());
						wide = GetLevelStr(level->GetWideGrade());
						super = GetLevelStr(level->GetSuperGrade());
						pRow->SetStringValue((thin + "," + wide + "," + super).c_str());
						listRows.push_back(pRow);
					}
				}
				pColumn->SetGridRowsList(listRows);
				listCol.push_back(pColumn);
				break;
			case 5:
				pColumn = CGridColumnPtr(new CGridColumn());
				pColumn->SetName("DLevel");
				for (auto GBF : listCGBField)
				{
					for (auto p : GBF->GetParticleList())
					{
						pRow = CGridRowPtr(new CGridRow());
						pRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
						std::string thin, wide, super;
						auto level = GBF->GetDLevel();
						thin = GetLevelStr(level->GetThinGrade());
						wide = GetLevelStr(level->GetWideGrade());
						super = GetLevelStr(level->GetSuperGrade());
						pRow->SetStringValue((thin + "," + wide + "," + super).c_str());
						listRows.push_back(pRow);
					}
				}
				pColumn->SetGridRowsList(listRows);
				listCol.push_back(pColumn);
				break;
			case 6:
				pColumn = CGridColumnPtr(new CGridColumn());
				pColumn->SetName("DSLevel");
				for (auto GBF : listCGBField)
				{
					for (auto p : GBF->GetParticleList())
					{
						pRow = CGridRowPtr(new CGridRow());
						pRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
						std::string thin, wide, super;
						auto level = GBF->GetDSLevel();
						thin = GetLevelStr(level->GetThinGrade());
						wide = GetLevelStr(level->GetWideGrade());
						super = GetLevelStr(level->GetSuperGrade());
						pRow->SetStringValue((thin + "," + wide + "," + super).c_str());
						listRows.push_back(pRow);
					}
				}
				pColumn->SetGridRowsList(listRows);
				listCol.push_back(pColumn);
				break;
			case 7:
				pColumn = CGridColumnPtr(new CGridColumn());
				pColumn->SetName("DSulfideLevel");
				for (auto GBF : listCGBField)
				{
					for (auto p : GBF->GetParticleList())
					{
						pRow = CGridRowPtr(new CGridRow());
						pRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
						std::string thin, wide, super;
						auto level = GBF->GetDSulfideLevel();
						thin = GetLevelStr(level->GetThinGrade());
						wide = GetLevelStr(level->GetWideGrade());
						super = GetLevelStr(level->GetSuperGrade());
						pRow->SetStringValue((thin + "," + wide + "," + super).c_str());
						listRows.push_back(pRow);
					}
				}
				pColumn->SetGridRowsList(listRows);
				listCol.push_back(pColumn);
				break;
			case 8:
				pColumn = CGridColumnPtr(new CGridColumn());
				pColumn->SetName("Particle");
				for (auto GBF : listCGBField)
				{
					for (auto p : GBF->GetParticleList())
					{
						pRow = CGridRowPtr(new CGridRow());
						pRow->SetParticle(p);
						listRows.push_back(pRow);
					}
				}
				pColumn->SetGridRowsList(listRows);
				listCol.push_back(pColumn);
				break;
			case 9:
				pColumn = CGridColumnPtr(new CGridColumn());
				pColumn->SetName("ParticleGBClass");
				for (auto GBF : listCGBField)
				{
					for (auto p : GBF->GetParticleList())
					{
						int l = (int)GBF->mapAllParticles[p].myType;
						pRow = CGridRowPtr(new CGridRow());
						pRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
						pRow->SetIntValue(l);
						listRows.push_back(pRow);
					}
				}
				pColumn->SetGridRowsList(listRows);
				listCol.push_back(pColumn);
				break;
			case 10:
				pColumn = CGridColumnPtr(new CGridColumn());
				pColumn->SetName("ParticleGBWidthClass");
				for (auto GBF : listCGBField)
				{
					for (auto p : GBF->GetParticleList())
					{
						int w = (int)GBF->mapAllParticles[p].myWidth;
						pRow = CGridRowPtr(new CGridRow());
						pRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
						pRow->SetIntValue(w);
						listRows.push_back(pRow);
					}
				}
				pColumn->SetGridRowsList(listRows);
				listCol.push_back(pColumn);
				break;
			default:
				break;
			}
		}
		pGridData->SetGridColumnList(listCol);

		return pGridData;

	}
	std::string CGBCalculate::GetLevelStr(GB_GRADE_TYPE l)
	{
		std::string s;
		switch (l)
		{
		case GB_GRADE_TYPE::POINT_0_0:
			s = "0";
			break;
		case GB_GRADE_TYPE::POINT_0_5:
			s = "0.5";
			break;
		case GB_GRADE_TYPE::POINT_1_0:
			s = "1";
			break;
		case GB_GRADE_TYPE::POINT_1_5:
			s = "1.5";
			break;
		case GB_GRADE_TYPE::POINT_2_0:
			s = "2";
			break;
		case GB_GRADE_TYPE::POINT_2_5:
			s = "2.5";
			break;
		case GB_GRADE_TYPE::POINT_3_0:
			s = "3";
			break;
		case GB_GRADE_TYPE::POINT_3_5:
			s = "3.5";
			break;
		case GB_GRADE_TYPE::POINT_4_0:
			s = "4";
			break;
		case GB_GRADE_TYPE::POINT_4_5:
			s = "4.5";
			break;
		case GB_GRADE_TYPE::POINT_5_0:
			s = "5";
			break;
		default:
			s = "0";
			break;
		}
		return s;
	}
	//get grid with level ABCD
	CGridDataPtr CGBCalculate::GetGridLevel(CString GridType, int a_nLevel[], int a_nLevel_w[], int a_nLevel_s[])
	{
		CGridDataPtr pGridData = CGridDataPtr(new CGridData());
		std::vector<CString> listDataSource;
		listDataSource.clear();
		listDataSource = m_rptMgrPtr->GetCurrentPropParam()->GetDataSourceList();
		pGridData->SetDataSourceList(listDataSource);

		int nDataSourceId = m_rptMgrPtr->GetCurrentPropParam()->GetDataSourceId();
		pGridData->SetDataSourceId(nDataSourceId);
		//amounts
		CGridColumnsList listCol;
		listCol.clear();
		int columnNum = 11 + 1 + 1;//表格总列数 12个级别再加上前面的“分类”列和“宽度/um”列
		CGridColumnPtr pColumn;
		for (int i = 0; i < columnNum; i++)
		{
			CString strName;
			CGridRowsList listRows;
			CGridRowPtr pRow;
			CString strWidthName1, strWidthName2, strWidthName3;
			switch (i)
			{
			case 0:
				pColumn = CGridColumnPtr(new CGridColumn());

				strName = MultiLang::GetInstance().GetCStringByKey(GBStr1);
				pColumn->SetName(strName);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
				pRow->SetStringValue(MultiLang::GetInstance().GetCStringByKey(GBStr2));
				listRows.push_back(pRow);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
				pRow->SetStringValue(MultiLang::GetInstance().GetCStringByKey(GBStr3));
				listRows.push_back(pRow);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
				pRow->SetStringValue(MultiLang::GetInstance().GetCStringByKey(GBStr4));
				listRows.push_back(pRow);
				pColumn->SetGridRowsList(listRows);

				listCol.push_back(pColumn);
				break;
			case 1:
				pColumn = CGridColumnPtr(new CGridColumn());

				strName = MultiLang::GetInstance().GetCStringByKey(GBStr5);
				pColumn->SetName(strName);

				if (GridType == "A")
				{
					strWidthName1 = "2.0~4.0";
					strWidthName2 = "4.0~12.0";
					strWidthName3 = ">12.0";
				}
				if (GridType == "B")
				{
					strWidthName1 = "2.0~9.0";
					strWidthName2 = "9.0~15.0";
					strWidthName3 = ">15.0";
				}
				if (GridType == "C")
				{
					strWidthName1 = "2.0~5.0";
					strWidthName2 = "5.0~12.0";
					strWidthName3 = ">12.0";
				}
				if (GridType == "D")
				{
					strWidthName1 = "2.0~8.0";
					strWidthName2 = "8.0~13.0";
					strWidthName3 = ">13.0";
				}
				if (GridType == "DSulfide")
				{
					strWidthName1 = "2.0~8.0";
					strWidthName2 = "8.0~13.0";
					strWidthName3 = ">13.0";
				}
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
				pRow->SetStringValue(strWidthName1);
				listRows.push_back(pRow);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
				pRow->SetStringValue(strWidthName2);
				listRows.push_back(pRow);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
				pRow->SetStringValue(strWidthName3);
				listRows.push_back(pRow);
				pColumn->SetGridRowsList(listRows);
				listCol.push_back(pColumn);
				break;
			default:
				pColumn = CGridColumnPtr(new CGridColumn());
				CString name;
				name.Format(_T("%.1f"), (i - 2) / 2.0);//i=2 输出0 i=3 输出0.5 i=4 输出1 以此类推
				pColumn->SetName(name);
				CGridRowsList listRows;

				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				pRow->SetIntValue(a_nLevel[i - 2]);
				listRows.push_back(pRow);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				pRow->SetIntValue(a_nLevel_w[i - 2]);
				listRows.push_back(pRow);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				pRow->SetIntValue(a_nLevel_s[i - 2]);
				listRows.push_back(pRow);
				pColumn->SetGridRowsList(listRows);
				listCol.push_back(pColumn);
				break;
			}
		}
		pGridData->SetGridColumnList(listCol);

		return pGridData;
	}
	CGridDataPtr CGBCalculate::GetGridDSLevel(CGBFieldList listCGBField)
	{
		CGridDataPtr pGridData = CGridDataPtr(new CGridData());
		std::vector<CString> listDataSource;
		listDataSource.clear();
		listDataSource = m_rptMgrPtr->GetCurrentPropParam()->GetDataSourceList();
		pGridData->SetDataSourceList(listDataSource);

		int nDataSourceId = m_rptMgrPtr->GetCurrentPropParam()->GetDataSourceId();
		pGridData->SetDataSourceId(nDataSourceId);
		//amounts
		CGridColumnsList listCol;
		listCol.clear();
		int columnNum = 6;
		CGridColumnPtr pColumn;
		for (int i = 0; i < columnNum; i++)
		{
			CString strName;
			CGridRowsList listRows[6];
			CGridRowPtr pRow;
			CString strWidthName1, strWidthName2, strWidthName3;
			switch (i)
			{
			case 0:
				pColumn = CGridColumnPtr(new CGridColumn());
				strName = MultiLang::GetInstance().GetCStringByKey(GBStr6);
				pColumn->SetName(strName);
				pColumn->SetGridRowsList(listRows[0]);

				listCol.push_back(pColumn);
				break;
			case 1:
				pColumn = CGridColumnPtr(new CGridColumn());

				strName = MultiLang::GetInstance().GetCStringByKey(GBStr7);
				pColumn->SetName(strName);
				pColumn->SetGridRowsList(listRows[1]);
				listCol.push_back(pColumn);
				break;
			case 2:
				pColumn = CGridColumnPtr(new CGridColumn());
				strName = MultiLang::GetInstance().GetCStringByKey(GBStr8);
				pColumn->SetName(strName);
				pColumn->SetGridRowsList(listRows[2]);
				listCol.push_back(pColumn);
				break;
			case 3:
				pColumn = CGridColumnPtr(new CGridColumn());
				strName = "X/mm";
				pColumn->SetName(strName);
				pColumn->SetGridRowsList(listRows[3]);
				listCol.push_back(pColumn);
				break;
			case 4:
				pColumn = CGridColumnPtr(new CGridColumn());
				strName = "Y/mm";
				pColumn->SetName(strName);
				pColumn->SetGridRowsList(listRows[4]);
				listCol.push_back(pColumn);
				break;
			case 5:
				pColumn = CGridColumnPtr(new CGridColumn());
				strName = MultiLang::GetInstance().GetCStringByKey(GBStr9);
				pColumn->SetName(strName);
				pColumn->SetGridRowsList(listRows[5]);
				listCol.push_back(pColumn);
				break;
			}
		}
		for each(CGBFieldDataPtr frame in listCGBField)
		{

			for (int i = 0; i < columnNum; i++)
			{
				CString strName;
				CGridRowsList listRows;
				CGridRowPtr pRow;
				CString strWidthName1, strWidthName2, strWidthName3;
				switch (i)
				{
				case 0:
					pColumn = listCol.at(0);
					pRow = CGridRowPtr(new CGridRow());
					pRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
					pRow->SetIntValue(frame->GetFrameId());
					pColumn->GetRowList().push_back(pRow);

					break;
				case 1:
					pColumn = listCol.at(1);
					pRow = CGridRowPtr(new CGridRow());
					pRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
					pRow->SetIntValue(0);
					pColumn->GetRowList().push_back(pRow);
					break;
				case 2:
					pColumn = listCol.at(2);
					pRow = CGridRowPtr(new CGridRow());
					pRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
					pRow->SetIntValue((int)frame->GetDSLevel()->GetMaxFeretDiameter());
					pColumn->GetRowList().push_back(pRow);
					break;
				case 3:
					pColumn = listCol.at(3);
					pRow = CGridRowPtr(new CGridRow());
					pRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
					pRow->SetIntValue(0);
					pColumn->GetRowList().push_back(pRow);
					break;
				case 4:
					pColumn = listCol.at(4);
					pRow = CGridRowPtr(new CGridRow());
					pRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
					pRow->SetIntValue(0);
					pColumn->GetRowList().push_back(pRow);
					break;
				case 5:
					pColumn = listCol.at(5);
					pRow = CGridRowPtr(new CGridRow());
					pRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
					pRow->SetDoubleValue((double)frame->GetDSLevel()->GetMyDSGrade());
					pColumn->GetRowList().push_back(pRow);
					break;
				}
			}
		}
		pGridData->SetGridColumnList(listCol);

		return pGridData;
	}

	//get grid with level ABCD
	CGridDataPtr CGBCalculate::GetGridDIN(COTSParticleList cotsparticlelistA, set<COTSParticlePtr> cotsparticlelistB, COTSParticleList cotsparticlelistC, COTSParticleList cotsparticlelistD)
	{
		CGridDataPtr pGridData = CGridDataPtr(new CGridData());
		std::vector<CString> listDataSource;
		listDataSource.clear();
		listDataSource = m_rptMgrPtr->GetCurrentPropParam()->GetDataSourceList();
		pGridData->SetDataSourceList(listDataSource);

		int nDataSourceId = m_rptMgrPtr->GetCurrentPropParam()->GetDataSourceId();
		pGridData->SetDataSourceId(nDataSourceId);
		//amounts
		CGridColumnsList listCol;
		listCol.clear();
		int columnNum = 12;//表格总列数 11个级别再加上前面的“分类”列
		CGridColumnPtr pColumn;
		int levA[9] = { 0,0,0,0,0,0,0,0,0 };
		int levB[9] = { 0,0,0,0,0,0,0,0,0 };
		int levC[9] = { 0,0,0,0,0,0,0,0,0 };
		int levD[9] = { 0,0,0,0,0,0,0,0,0 };
		double fg[9] = { 0.05,0.1,0.2,0.5,1,2,5,10,20 };
		//指数
		double ka = 0, kb = 0, kc = 0, kd = 0;
		//统计不同大小颗粒出现次数
		for (auto pParticle : cotsparticlelistA)
		{
			double area = pParticle->GetArea();
			for (int i = 0; i < 8; i++)
			{
				if (area >= fg[i] && area < fg[i + 1])
				{
					levA[i] += 1;
					ka = ka + fg[i];
				}
			}
			if (area >= fg[8])
			{
				levA[8] += 1;
				ka = ka + fg[8];
			}
		}
		for (auto pParticle : cotsparticlelistB)
		{
			double area = pParticle->GetArea();
			for (int i = 0; i < 8; i++)
			{
				if (area >= fg[i] && area < fg[i + 1])
				{
					levB[i] += 1;
					kb = kb + fg[i];
				}
			}
			if (area >= fg[8])
			{
				levB[8] += 1;
				kb = kb + fg[8];
			}
		}
		for (auto pParticle : cotsparticlelistC)
		{
			double area = pParticle->GetArea();
			for (int i = 0; i < 8; i++)
			{
				if (area >= fg[i] && area < fg[i + 1])
				{
					levC[i] += 1;
					kc = kc + fg[i];
				}
			}
			if (area >= fg[8])
			{
				levC[8] += 1;
				kc = kc + fg[8];
			}
		}
		for (auto pParticle : cotsparticlelistD)
		{
			double area = pParticle->GetArea();
			for (int i = 0; i < 8; i++)
			{
				if (area >= fg[i] && area < fg[i + 1])
				{
					levD[i] += 1;
					kd = kd + fg[i];
				}
			}
			if (area >= fg[8])
			{
				levD[8] += 1;
				kd = kd + fg[8];
			}
		}
		double to = kb + kc + kd;
		for (int i = 0; i < columnNum; i++)
		{
			CString strName;
			CGridRowsList listRows;
			CGridRowPtr pRow;
			CString strWidthName1, strWidthName2, strWidthName3, strWidthName4;
			switch (i)
			{
			case 0:
				pColumn = CGridColumnPtr(new CGridColumn());

				strName = "Class";
				pColumn->SetName(strName);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
				pRow->SetStringValue("SS");
				listRows.push_back(pRow);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
				pRow->SetStringValue("OA");
				listRows.push_back(pRow);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
				pRow->SetStringValue("OS");
				listRows.push_back(pRow);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
				pRow->SetStringValue("OG");
				listRows.push_back(pRow);
				pColumn->SetGridRowsList(listRows);

				listCol.push_back(pColumn);
				break;
			case 10:
				pColumn = CGridColumnPtr(new CGridColumn());

				strName = "S";
				pColumn->SetName(strName);
				strWidthName1.Format(_T("%lf"), ka);
				strWidthName2 = "";
				strWidthName3 = "";
				strWidthName4 = "";
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
				pRow->SetDoubleValue(ka);
				listRows.push_back(pRow);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
				pRow->SetDoubleValue(0);
				listRows.push_back(pRow);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
				pRow->SetDoubleValue(0);
				listRows.push_back(pRow);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
				pRow->SetDoubleValue(0);
				listRows.push_back(pRow);
				pColumn->SetGridRowsList(listRows);
				listCol.push_back(pColumn);
				break;
			case 11:
				pColumn = CGridColumnPtr(new CGridColumn());

				strName = "O";
				pColumn->SetName(strName);

				strWidthName1.Format(_T("%lf"), to);
				strWidthName2 = "";
				strWidthName3 = "";
				strWidthName4 = "";
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
				pRow->SetDoubleValue(0);
				listRows.push_back(pRow);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
				pRow->SetDoubleValue(kb);
				listRows.push_back(pRow);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
				pRow->SetDoubleValue(kc);
				listRows.push_back(pRow);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
				pRow->SetDoubleValue(kd);
				listRows.push_back(pRow);
				pColumn->SetGridRowsList(listRows);
				listCol.push_back(pColumn);
				break;
			default:
				pColumn = CGridColumnPtr(new CGridColumn());
				strName.Format("%d", i - 1);
				pColumn->SetName(strName);
				CGridRowsList listRows;
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				pRow->SetIntValue(levA[i - 1]);
				listRows.push_back(pRow);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				pRow->SetIntValue(levB[i - 1]);
				listRows.push_back(pRow);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				pRow->SetIntValue(levC[i - 1]);
				listRows.push_back(pRow);
				pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				pRow->SetIntValue(levD[i - 1]);
				listRows.push_back(pRow);
				pColumn->SetGridRowsList(listRows);
				listCol.push_back(pColumn);
				break;
			}
		}
		pGridData->SetGridColumnList(listCol);

		return pGridData;
	}


	void CGBCalculate::SetFrameLevelNo(GB_GRADE_TYPE a_level, int a_nLevel[])
	{
		a_nLevel[(int)a_level] += 1;

	}


	// calculate GB fields
	CGBFieldList CGBCalculate::CalGBFields(CSmplMsrResultFileMgr* pSmplMgr)
	{
		CGBFieldList m_listGBFields;
		m_listGBFields.clear();
		ASSERT(pSmplMgr);
		if (!pSmplMgr) {
			LogErrorTrace(__FILE__, __LINE__, _T("CalGBFields: invalid m_pSmplMsrResultFileMgr ."));
			return m_listGBFields;
		}

		CSmplMsrResultFilePtr pSmplMsrResultFile = pSmplMgr->GetSmplMsrResultFile();
		ASSERT(pSmplMsrResultFile);
		if (!pSmplMsrResultFile) {
			LogErrorTrace(__FILE__, __LINE__, _T("CalGBFields: invalid pSmplMsrResultFile ."));
			return m_listGBFields;
		}

		COTSSamplePtr pOTSSample = pSmplMsrResultFile->GetSample();
		ASSERT(pOTSSample);
		if (!pOTSSample) {
			LogErrorTrace(__FILE__, __LINE__, _T("CalGBFields: invalid pOTSSample ."));
			return m_listGBFields;
		}

		CSEMDataMsrPtr pEMDataMsrPtr = pOTSSample->GetSEMDataMsr();
		ASSERT(pEMDataMsrPtr);
		if (!pEMDataMsrPtr) {
			LogErrorTrace(__FILE__, __LINE__, _T("CalGBFields: invalid pEMDataMsrPtr ."));
			return m_listGBFields;
		}

		// get field width
		int nOTSFieldWidth = pEMDataMsrPtr->GetScanFieldSize();
		if (nOTSFieldWidth == 0)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CalGBFields: field width is zero ."));
			return m_listGBFields;
		}

		// cal a gb field need how many ots fields rows and columns 
		int nOTSRowsForGBFld, nOTSColumnsForGBFld;
		CalOTSFieldsNo(nOTSRowsForGBFld, nOTSColumnsForGBFld, nOTSFieldWidth);

		if (nOTSRowsForGBFld == 0 || nOTSColumnsForGBFld == 0)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CalGBFields: nOTSRow|nOTSColumn is zero ."));
			return m_listGBFields;
		}

		// scan parameters
		CMsrParamsPtr pMsrParam = pOTSSample->GetMsrParams();
		COTSImageScanParamPtr pImgScanParam = pMsrParam->GetImageScanParam();

		// get image size
		OTS_FIVE_TIES_OPTIONS nImageSizeId = pImgScanParam->GetImagePixelSize();
		int nResulotionId = RESOLUTION_ID_FIRST_TIE + (int)nImageSizeId;
		CSize sizePixelImage = RESOLUTION_VALUE[nResulotionId];

		//use OTSField width cal the OTSField height


		//get OTSfilds list
		COTSFieldDataList allOTSFields;
		allOTSFields = pSmplMsrResultFile->GetFieldData();
		// convert ots fields to gb fields
		if (!OTSFieldToGBField(allOTSFields, &m_listGBFields, nOTSRowsForGBFld, nOTSColumnsForGBFld, sizePixelImage, nOTSFieldWidth))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CalGBFields: call OTSFieldToGBField failed."));
			return m_listGBFields;
		}
		return m_listGBFields;
	}

	// protected

	// cal a gb field need how many ots fields rows and columns 
	void  CGBCalculate::CalOTSFieldsNo(int& a_nRow, int& a_nColumn, int a_nFieldWidth)
	{
		a_nRow = 0;
		a_nColumn = 0;
		if (a_nFieldWidth > 0)
		{
			a_nColumn = (int)ceil((double)GB_FIELD_WIDTH / (double)a_nFieldWidth);
			//OTSField Height always equal to 3 / 4 OTSField Width
			double dFieldHeight = (double)a_nFieldWidth * 3 / 4;
			a_nRow = (int)ceil((double)GB_FIELD_WIDTH / dFieldHeight);
		}
	}

	// Turn OTSField to GBField
	BOOL CGBCalculate::OTSFieldToGBField(COTSFieldDataList allOTSFields, CGBFieldList* m_listGBFields, int nOTSRowsPerGBfld, int nOTSColumnsPerGBFld, CSize sizePixelImage, int nOTSFieldWidth)
	{
		int nFieldHeight = (int)((double)nOTSFieldWidth * 3 / 4);

		// doing nothing if no field at all
		if (allOTSFields.empty())
		{
			LogTrace(__FILE__, __LINE__, _T("CalGBFields: listOTSFields  is empty ."));
			return TRUE;
		}

		// get topleft point and bottomright point of the measurement convered area 
		CPoint pointTopleft, pointBottomright;
		pointTopleft = pointBottomright = allOTSFields[0]->GetPosition();

		//判断有效区域
		for (unsigned int i = 0; i < allOTSFields.size(); i++)
		{
			//get current OTSField Position,the position is in the center of the field
			CPoint poiOTSFieldPosition = allOTSFields[i]->GetPosition();

			pointTopleft.x = min(poiOTSFieldPosition.x, pointTopleft.x);
			pointTopleft.y = min(poiOTSFieldPosition.y, pointTopleft.y);
			pointBottomright.x = max(poiOTSFieldPosition.x, pointBottomright.x);
			pointBottomright.y = max(poiOTSFieldPosition.y, pointBottomright.y);
		}

		// cal ots columns 有效区域内所有的OTScolumn数
		int nOTSColumnNum = ((pointBottomright.x - pointTopleft.x) / nOTSFieldWidth) + 1;

		// cal ots rows有效区域内所有的OTSRow数
		int nOTSRowNum = ((pointBottomright.y - pointTopleft.y) / nFieldHeight) + 1;

		int nPossibleGBFieldRowNum = nOTSRowNum / nOTSRowsPerGBfld;//可能有的国标field行数
		int nPossibleGBFieldColNum = nOTSColumnNum / nOTSColumnsPerGBFld;//列数

		// cal possible GBFields area
		CPoint pointPosibleAreaTopLeft = pointTopleft;
		//CPoint poiPosAreaBottomRight = poiBottomright;
		CPoint pointPossibleAreaBottomRight = pointTopleft;

		pointPosibleAreaTopLeft.x -= nOTSFieldWidth / 2;
		pointPosibleAreaTopLeft.y -= nFieldHeight / 2;

		//pointPossibleAreaBottomRight.x += (nPossibleGBFieldColNum * nOTSColumnsPerGBFld * nOTSFieldWidth - nOTSFieldWidth / 2);
		pointPossibleAreaBottomRight.x += (nPossibleGBFieldColNum * nOTSColumnsPerGBFld * nOTSFieldWidth);
		//pointPossibleAreaBottomRight.y += (nPossibleGBFieldRowNum * nOTSRowsPerGBfld * nFieldHeight - nFieldHeight / 2);
		pointPossibleAreaBottomRight.y += (nPossibleGBFieldRowNum * nOTSRowsPerGBfld * nFieldHeight);
		// form rectangle of GBFields area
		CRect rectOTSFieldsCuted(pointPosibleAreaTopLeft, pointPossibleAreaBottomRight);
		rectOTSFieldsCuted.NormalizeRect();
		if (rectOTSFieldsCuted.IsRectEmpty())
		{
			LogTrace(__FILE__, __LINE__, _T("CalGBFields: GBFields area is empty ."));
			return TRUE;
		}

		// find all OTSFields inside GBFields area  
		COTSFieldDataList OTSFieldsInGBFieldsArea;
		OTSFieldsInGBFieldsArea.clear();
		CPoint poiOTSFieldPosition;

		for (auto OTSField : allOTSFields)
		{
			poiOTSFieldPosition = OTSField->GetPosition();
			//if over the edge
			if (rectOTSFieldsCuted.PtInRect(poiOTSFieldPosition))
			{
				OTSFieldsInGBFieldsArea.push_back(OTSField);
			}
		}

		//get possible OTSFields 
		m_listGBFields->clear();
		CPoint pointGBFieldPosition;
		int nOTSFieldsPerGBField = nOTSRowsPerGBfld * nOTSColumnsPerGBFld;
		for (int i = 0; i < nPossibleGBFieldRowNum; i++)
		{
			for (int j = 0; j < nPossibleGBFieldColNum; j++)
			{

				// cal GB field rectangle
				CPoint poiCurGBFieldTopLeft, poiCurGBFieldBottomRight;

				poiCurGBFieldTopLeft = pointPosibleAreaTopLeft;
				//获得左上角的坐标
				poiCurGBFieldTopLeft.x += nOTSColumnsPerGBFld * j * nOTSFieldWidth;
				poiCurGBFieldTopLeft.y += nOTSRowsPerGBfld * i * nFieldHeight;
				//获得右下角的坐标
				poiCurGBFieldBottomRight.x = poiCurGBFieldTopLeft.x + nOTSColumnsPerGBFld * nOTSFieldWidth;
				poiCurGBFieldBottomRight.y = poiCurGBFieldTopLeft.y + nOTSRowsPerGBfld * nFieldHeight;
				CRect rectGBField(poiCurGBFieldTopLeft, poiCurGBFieldBottomRight);
				rectGBField.NormalizeRect();

				CGBFieldDataPtr pGBFieldData;
				//切割组合的矩形成为GBfield，并处理其中的segment

				pGBFieldData = GetOneGBField(rectGBField, OTSFieldsInGBFieldsArea, nOTSRowsPerGBfld, nOTSColumnsPerGBFld, sizePixelImage, nOTSFieldWidth);
				if (!pGBFieldData)
				{
					continue;
				}
				rectGBField.bottom = rectGBField.top + GB_FIELD_WIDTH;
				rectGBField.right = rectGBField.left + GB_FIELD_WIDTH;


				CPoint poiNewPosition;
				poiNewPosition.x = rectGBField.left + GB_FIELD_WIDTH / 2;
				poiNewPosition.y = rectGBField.top + GB_FIELD_WIDTH / 2;

				pGBFieldData->SetPosition(poiNewPosition);

				// add the GBField into the GBFields list
				m_listGBFields->push_back(pGBFieldData);

			}
		}
		// ok, return TRUE
		return  TRUE;
	}

	// Custom collation rules
	BOOL comp(const COTSFieldDataPtr &a, const COTSFieldDataPtr &b)
	{
		if (a->GetPosition().y <= b->GetPosition().y)
		{
			if (a->GetPosition().y == b->GetPosition().y)
			{
				if (a->GetPosition().x < b->GetPosition().x)
				{
					return TRUE;
				}
			}
			else {
				return TRUE;
			}
		}
		return FALSE;
	}

	//  get the GB field within a rectangle
	CGBFieldDataPtr CGBCalculate::GetOneGBField(CRect a_rectGBField,
		COTSFieldDataList& allOTSFields,
		int nOTSRowsPerGBFld,
		int nOTSColumnsPerGBFld,
		CSize a_sizePixelImage,
		int nOTSFieldWidth)
	{
		// GB Field handle
		CGBFieldDataPtr pGBFieldData = nullptr;

		// get OTS fields within the rectangle
		COTSFieldDataList myOTSFields;
		myOTSFields.clear();
		COTSFieldDataList::iterator itr = allOTSFields.begin();
		while (itr != allOTSFields.end())
		{
			// get an OTS field
			CPoint poiOTSField = (*itr)->GetPosition();

			//check if the field is within the rectangle
			if (a_rectGBField.PtInRect(poiOTSField))
			{
				// found a field 

				// add into the list
				myOTSFields.push_back(*itr);

				// remove the field from the measurement field list 
				// move to the next item
				//itr = allOTSFields.erase(itr);//There's no need to delete the field. gsp
				itr++;
				// jump over
				continue;
			}

			// move to the next item
			itr++;
		}

		// make sure GBFields list has enough OTSFields
		int nOTSFieldsOfAGBField = nOTSRowsPerGBFld * nOTSColumnsPerGBFld;
		if (myOTSFields.size() == nOTSFieldsOfAGBField)
		{
			// sort the GBFields list
			sort(myOTSFields.begin(), myOTSFields.end(), comp);

			// normalize particles for the GBFields
			pGBFieldData = NormalizeParticles(a_rectGBField, myOTSFields, a_sizePixelImage, nOTSFieldWidth);
			pGBFieldData->myReleventOTSFlds = myOTSFields;
		}

		// return GB Field handle
		return pGBFieldData;
	}

	// Custom collation rules
	BOOL compSegment(const COTSSegmentPtr &a, const COTSSegmentPtr &b)
	{
		if (a->GetHeight() <= b->GetHeight())
		{
			if (a->GetHeight() == b->GetHeight())
			{
				if (a->GetStart() < b->GetStart())
				{
					return TRUE;
				}
			}
			else {
				return TRUE;
			}
		}
		return FALSE;
	}

	// normalize particles for the GBFields
	CGBFieldDataPtr CGBCalculate::NormalizeParticles(CRect a_rectGBField, COTSFieldDataList myOTSFields, CSize a_sizePixelImage, int nOTSFieldWidth)
	{
		// inits
		CGBFieldDataPtr pGBFieldData(new CGBFieldData);
		int nFieldHeight = (int)((double)nOTSFieldWidth * 3 / 4);

		//go through all OTS fields form the GB field to get all segments of the GB field
		COTSSegmentsList listGBFieldSegments;
		CPoint pointGBFieldRectTopLeft = a_rectGBField.TopLeft();
		int nBeforeCalNo = 0;
		int nAfterCalNo = 0;
		for (auto OTSField : myOTSFields)
		{
			CPoint pointField = OTSField->GetPosition();
			COTSParticleList myOTSParticles = OTSField->GetParticleList();
			long fieldLeftTopX, fieldLeftTopY;
			CPoint pointCalculate;
			fieldLeftTopX = pointField.x - (nOTSFieldWidth / 2);
			fieldLeftTopY = pointField.y - (nFieldHeight / 2);
			pointCalculate.x = fieldLeftTopX - pointGBFieldRectTopLeft.x;
			pointCalculate.y = fieldLeftTopY - pointGBFieldRectTopLeft.y;
			//found the field's Column and Row 
			int nColum = (int)(((double)pointCalculate.x / (double)nOTSFieldWidth) + 0.5);
			int nRow = (int)(((double)pointCalculate.y / (double)nFieldHeight) + 0.5);
			//function Get GBField's FieldSegments List
			nBeforeCalNo = (int)listGBFieldSegments.size();
			GetGBFieldSegmentsList(nColum, nRow, myOTSParticles, nAfterCalNo, listGBFieldSegments, a_sizePixelImage, nOTSFieldWidth);
			nAfterCalNo = nBeforeCalNo;

		}

		COTSParticleList listNormalizedParticles;

		// get new particles
		GetGBParticles(listGBFieldSegments, listNormalizedParticles);

		// put new particle in the  GB Field
		pGBFieldData->SetParticleList(listNormalizedParticles);
		return pGBFieldData;
	}

	//function Get GBField's FieldSegments List
	BOOL CGBCalculate::GetGBFieldSegmentsList(int a_nColum, int a_nRow, COTSParticleList a_listOTSFieldParticles, int a_nCalNo, COTSSegmentsList &a_listGBFieldSegments, CSize a_sizePixelImage, int a_nFieldWidth)
	{
		CRect rectParticle;
		CPoint poiParticleTopLeft;
		COTSSegmentsList listOTSFieldSegments;
		long nNewStart = 0, nNewLength = 0, nNewHeight;
		long nOffsetX = a_nColum * a_sizePixelImage.cx;
		long nOffsetY = a_nRow * a_sizePixelImage.cy;
		// get one pixel width
		//double dPixelsize = (double)a_nFieldWidth / a_sizePixelImage.cx;
		double dPixelsize = (double)a_sizePixelImage.cx / a_nFieldWidth;
		double dGBwidth = sqrt(0.5) * 1000;
		long nGBpixcel = (long)(dGBwidth * dPixelsize);

		//cal the new  segment coordinate
		for (auto Particle : a_listOTSFieldParticles)
		{
			//get the Particle rect
			rectParticle = Particle->GetParticleRect();
			poiParticleTopLeft = rectParticle.TopLeft();
			listOTSFieldSegments = Particle->GetFeature()->GetSegmentsList();
			for (auto Segment : listOTSFieldSegments)
			{
				BOOL bMerge = (a_nColum > 0) && (Segment->GetStart() == 0);

				// off set the segment
				nNewStart = Segment->GetStart() + nOffsetX;
				nNewHeight = Segment->GetHeight() + nOffsetY;

				// check should we need to keep the segment
				// cal if the Segment in the GB 0.5/m2  
				if (nNewStart > nGBpixcel)
				{
					continue;
				}
				if (nNewHeight > nGBpixcel)
				{
					continue;
				}

				// do we need to cut the segment 
				//if over 0.5m2 cut it
				//get GBField's a_nHeight, long a_nStart, long a_nLength
				nNewLength = Segment->GetLength();
				if (nNewStart + Segment->GetLength() > nGBpixcel)
				{
					nNewLength = (long)(nGBpixcel - nNewStart);
				}

				COTSSegmentPtr pGBFieldSegment(new COTSSegment(nNewHeight, nNewStart, nNewLength));

				//merge the segment
				if (bMerge && MergSegment(a_listGBFieldSegments, pGBFieldSegment, a_nCalNo))
				{
					continue;
				}

				a_listGBFieldSegments.push_back(pGBFieldSegment);
			}
		}
		return TRUE;
	}

	// merge the segment
	BOOL CGBCalculate::MergSegment(COTSSegmentsList &a_listGBFieldSegments, COTSSegmentPtr a_pGBFieldSegment, int a_nCalNo)
	{
		//search merge segments only on last field 
		COTSSegmentsList::iterator itr = a_listGBFieldSegments.begin() + a_nCalNo;
		while (itr != a_listGBFieldSegments.end())
		{
			COTSSegmentPtr pSegmentHead = *itr;
			long nNextX = pSegmentHead->GetStart() + pSegmentHead->GetLength();
			//merge only when height are the same
			if (pSegmentHead->GetHeight() == a_pGBFieldSegment->GetHeight())
			{
				//end to start
				if ((nNextX + 1) == a_pGBFieldSegment->GetStart())
				{
					//merge and return true
					pSegmentHead->SetLength(pSegmentHead->GetLength() + a_pGBFieldSegment->GetLength());
					return TRUE;
				}
			}
			itr++;
		}

		//didn't merge return false
		return FALSE;
	}

	// merge the segment,get new particles
	BOOL CGBCalculate::GetGBParticles(COTSSegmentsList a_listGBFieldSegments, COTSParticleList &a_listNormalizedParticles)
	{
		//change segments to Particles
		COTSFeatureList listFeatures;

		if (a_listGBFieldSegments.size() == 0)
		{
			return FALSE;
		}

		GetFeatureList1(a_listGBFieldSegments, listFeatures);
		ChangeFeaturelist(listFeatures, a_listNormalizedParticles);
		COTSFieldMgr::CalMergedParticleImageProp(a_listNormalizedParticles, PixSize);
		return TRUE;
	}

	// get feature list of up-down segment
	BOOL CGBCalculate::GetFeatureList(COTSSegmentsList& a_listSegments, COTSFeatureList& a_listFeatures)
	{
		a_listFeatures.clear();
		int nStart = 0;
		int nSizeCur = (int)a_listSegments.size();
		COTSSegmentPtr pSegmentCur;
		COTSSegmentPtr pSegmentNew;
		COTSSegmentsList listSegmentNew;
		COTSSegmentPtr pSegment;
		int nHeightCur, nHeightNew;

		while (true)
		{
			nStart = 0;
			pSegmentCur = a_listSegments[nStart];

			nHeightCur = pSegmentCur->GetHeight();

			//save the new temp segment list
			listSegmentNew.clear();

			//get the first Segment to a feature			
			listSegmentNew.push_back(pSegmentCur);
			a_listSegments.erase(a_listSegments.begin());
			if (a_listSegments.size() == 0)
			{
				break;
			}
			nSizeCur--;

			//get the up-down connection segment
			int nindex = 0;
			while (true)
			{

				pSegment = a_listSegments[nindex];

				bool ifConnect = false;
				for (auto seg : listSegmentNew)
				{
					if (seg->UpDownConection(*pSegment))
					{
						pSegmentNew = COTSSegmentPtr(new COTSSegment(*pSegment));
						pSegmentCur = pSegmentNew;
						listSegmentNew.push_back(pSegmentNew);
						a_listSegments.erase(a_listSegments.begin() + nindex);
						nSizeCur--;
						ifConnect = true;
						break;
					}


				}
				if (!ifConnect)
				{
					nindex++;
				}

				if (nindex == nSizeCur || nSizeCur == 0)
				{
					break;
				}

			}

			COTSFeaturePtr pFeature = COTSFeaturePtr(new COTSFeature());
			pFeature->SetSegmentsList(listSegmentNew);
			a_listFeatures.push_back(pFeature);

			nStart++;
			if (nStart == nSizeCur || nSizeCur == 0)
			{
				if (a_listSegments.size() != 0)
				{
					//save the new temp segment list
					listSegmentNew.clear();
					//get the first Segment to a feature			
					listSegmentNew.push_back(pSegmentCur);
					a_listSegments.erase(a_listSegments.begin());
					nSizeCur--;
					COTSFeaturePtr pFeature = COTSFeaturePtr(new COTSFeature());
					pFeature->SetSegmentsList(listSegmentNew);
					a_listFeatures.push_back(pFeature);
				}
				break;
			}

		}

		if ((int)a_listFeatures.size() == 0)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("no particle is found"));
			return FALSE;
		}

		return TRUE;



	}
	BOOL CGBCalculate::GetFeatureList1(COTSSegmentsList& a_listSegments, COTSFeatureList& a_listFeatures)
	{
		COTSSegmentsList listSegmentNew;
		std::map<long, COTSSegmentsList > mapOneLineSegments;
		for each(auto s in a_listSegments)
		{
			mapOneLineSegments[s->GetHeight()].push_back(s);
		}
		std::map<long, COTSSegmentsList >::iterator lineItr = mapOneLineSegments.begin();//find the highest line
		while (lineItr != mapOneLineSegments.end())
		{


			for (auto s = lineItr->second.begin(); s < lineItr->second.end(); )//find  one segment of this line.
			{

				COTSSegmentPtr bottomSeg = *s;
				listSegmentNew.clear();
				listSegmentNew.push_back(*s);
				s = lineItr->second.erase(s);
				std::map<long, COTSSegmentsList >::iterator tempItr = lineItr;
				tempItr++;
				for (; tempItr != mapOneLineSegments.end(); tempItr++)//find all other lines of segments
				{


					for (auto nextLineSegment = tempItr->second.begin(); nextLineSegment < tempItr->second.end();)//find next line's all segments
					{
						if (bottomSeg->UpDownConection(**nextLineSegment))
						{
							listSegmentNew.push_back(*nextLineSegment);
							bottomSeg = *nextLineSegment;
							nextLineSegment = tempItr->second.erase(nextLineSegment);
							break;
						}

						if (tempItr->second.size() > 0)
						{
							nextLineSegment++;
						}
						else
						{
							break;
						}
					}

				}
				COTSFeaturePtr pFeature = COTSFeaturePtr(new COTSFeature());
				pFeature->SetSegmentsList(listSegmentNew);
				//check if this new feature is connected with other found feature.
				COTSSegmentPtr topSeg = listSegmentNew[0];//find the toppest segment of this new feature.
				COTSSegmentPtr bottomSegment = listSegmentNew[listSegmentNew.size() - 1];//find the lowest segment of this new feature.

				bool haveMerged = false;
				for each(auto f in a_listFeatures)
				{
					for (auto seg : f->GetSegmentsList())
					{
						if (bottomSegment->UpDownConection(*seg) || topSeg->UpDownConection(*seg))
						{
							COTSSegmentsList segs = f->GetSegmentsList();
							for (auto s : listSegmentNew)
							{
								segs.push_back(s);

							}

							f->SetSegmentsList(segs);
							haveMerged = true;
							break;
						}
					}
					if (haveMerged)
					{
						break;
					}

				}
				if (!haveMerged)
				{
					a_listFeatures.push_back(pFeature);
				}

				if (lineItr->second.size() == 0)
				{
					break;
				}
			}
			lineItr++;
		}


		return true;
	}
	// change feature into particle
	BOOL CGBCalculate::ChangeFeaturelist(COTSFeatureList& a_listFeatures, COTSParticleList& a_listParticle)
	{
		if (a_listFeatures.size() == 0)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ChangeFeaturelist: there is no feature in the list."));
			return FALSE;
		}
		// compute Rect
		for (auto pFeature : a_listFeatures)
		{
			COTSParticlePtr pParticle = COTSParticlePtr(new COTSParticle());
			COTSFeaturePtr pFeatureNew = COTSFeaturePtr(new COTSFeature(*pFeature.get()));
			pParticle->SetFeature(pFeatureNew);
			if (!pParticle->CalCoverRect())
			{
				LogErrorTrace(__FILE__, __LINE__, _T("ChangeFeaturelist: failed to get particle rect."));
				return FALSE;
			}
			a_listParticle.push_back(pParticle);
		}

		if ((int)a_listParticle.size() == 0)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Can't get particle."));
			return FALSE;
		}

		return TRUE;
	}
	void CGBCalculate::SetPixSize(double p)
	{
		PixSize = p;
	}

}