OTS/OTS_GB/OTSModel/Report/ReportProjFileMgr.cpp

#pragma once

#include "stdafx.h"
#include "resource.h"
#include "ReportProjFileMgr.h"
#include "MeasureResultInfo.h"
#include "BSEImgFileMgr.h"
#include "PosXrayFileMgr.h"
#include "PartSizeFileMgr.h"
#include "TrioCal.h"
#include "CGBCalculate.h"
#include "GBFieldData.h"
#include "OTSHelper.h"
#include "OTSFileSys.h"
#include "RptParamFileMgr.h"
#include "GBImgPropCal.h"


namespace OTSMODEL {
	using namespace std;
	// constructor
	CReportProjFileMgr::CReportProjFileMgr(CReportProjFilePtr a_pReportProjFile)
	{
		m_pReportProjFile = a_pReportProjFile;
		m_listPropParams.clear();
		m_listSmplMgrs.clear();
		m_bModify = FALSE;
		m_strPathName = _T("");
		m_nWorkingSampeIndex = -1;
		m_nPartSizeIndex = -1;
		//load param file
		CRptParamFileMgr paramFleMgr;
		paramFleMgr.Load(OTSMODEL::OTS_SOFT_PACKAGE_ID::OTSIncA);

		m_rptparamfile = paramFleMgr.GetRptParamFile();
		double dScale = m_rptparamfile->GetScale();

		m_pReportProjFile->SetScale(dScale);

	}

	// destructor
	CReportProjFileMgr::~CReportProjFileMgr()
	{
	}
	CRptParamFilePtr  CReportProjFileMgr::GetRptParamFilePtr()
	{
		return m_rptparamfile;
	}
	// class methods
	// public
	void CReportProjFileMgr::SetPropertyParams(CPropParamsList a_listPropertyParams)
	{
		m_listPropParams.clear();
		m_listPropParams = a_listPropertyParams;

	}

	// property parameters
	CPropParamPtr CReportProjFileMgr::GetPropertyParamImage()
	{
		return m_listPropParams[(int)DISPLAY_PICTURE_TYPE::IMAGE];
	}
	CPropParamPtr CReportProjFileMgr::GetPropertyParamGrid()
	{
		return m_listPropParams[(int)DISPLAY_PICTURE_TYPE::TABLE];
	}
	CPropParamPtr CReportProjFileMgr::GetPropertyParamChart()
	{
		return m_listPropParams[(int)DISPLAY_PICTURE_TYPE::CHART];
	}

	// reset property parameters
	BOOL CReportProjFileMgr::ResetPropertyParams(BOOL a_bClear /*= FALSE*/)
	{

		// clear property parameters list
		if (a_bClear)
		{
			m_listPropParams.clear();
		}

		// get data source names list
		std::vector<CString> listDataSourceNames = GetDataSourceNamesList();

		// data source names list can't be empty
		if (listDataSourceNames.empty())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ResetPropertyParams: empty data source name list."));
			return FALSE;
		}

		// particle STD data 
		CPartSTDDataPtr pPartSTDData = m_pReportProjFile->GetPartSTDData();
		ASSERT(pPartSTDData);
		if (!pPartSTDData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ResetPropertyParams: STD data empty."));
			return FALSE;
		}



		// trio chart mode

		// add property parameters into the list
		if (m_listPropParams.empty())
		{
			//Image display picture's property
			CPropParamPtr pPropParam = CPropParamPtr(new CPropParamImage());
			pPropParam->SetDataSourceList(listDataSourceNames);
			pPropParam->SetDataSourceId(m_nWorkingSampeIndex);
			pPropParam->SetWorkingSTDLib(pPartSTDData);
			pPropParam->SetSizeClassFileFolder(m_rptparamfile->GetSizeFileFolder());
			if (*pPartSTDData.get() == CPartSTDData())
			{
				pPropParam->SetSTDId(0);
			}

			pPropParam->SetType(DISPLAY_PICTURE_TYPE::IMAGE);
			m_listPropParams.push_back(pPropParam);


			//grid table display picture's property
			pPropParam = CPropParamPtr(new CPropParamGrid());
			pPropParam->SetDataSourceList(listDataSourceNames);
			pPropParam->SetDataSourceId(m_nWorkingSampeIndex);
			pPropParam->SetWorkingSTDLib(pPartSTDData);
			pPropParam->SetSizeClassFileFolder(m_rptparamfile->GetSizeFileFolder());
			if (*pPartSTDData.get() == CPartSTDData())
			{
				pPropParam->SetSTDId(0);
			}

			pPropParam->SetType(DISPLAY_PICTURE_TYPE::TABLE);
			m_listPropParams.push_back(pPropParam);
			//chart display picture's property object
			pPropParam = CPropParamPtr(new CPropParamChart());
			pPropParam->SetDataSourceList(listDataSourceNames);
			pPropParam->SetDataSourceId(m_nWorkingSampeIndex);
			pPropParam->SetWorkingSTDLib(pPartSTDData);
			pPropParam->SetSizeClassFileFolder(m_rptparamfile->GetSizeFileFolder());

			pPropParam->SetTriTempFile(m_rptparamfile->GetTriTempFile());

			if (*pPartSTDData.get() == CPartSTDData())
			{
				pPropParam->SetSTDId(0);
			}

			pPropParam->SetType(DISPLAY_PICTURE_TYPE::CHART);
			m_listPropParams.push_back(pPropParam);
		}
		else
		{
			for (auto pPropParam : m_listPropParams)
			{
				pPropParam->SetDataSourceList(listDataSourceNames);
				pPropParam->SetDataSourceId(m_nWorkingSampeIndex);
				pPropParam->SetWorkingSTDLib(pPartSTDData);

			}
		}

		// ok, return TRUE
		return TRUE;
	}

	BOOL CReportProjFileMgr::NewFile()
	{
		// set file name 
		SetPathName(UNTITLED_NEW_FILE_NAME);

		return TRUE;
	}

	// Load 
	BOOL CReportProjFileMgr::Load(CString a_strPathname /*= _T("")*/)
	{
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		// check file name
		a_strPathname.Trim();
		if (a_strPathname.IsEmpty())
		{
			// open
			CFileDialog dlg(TRUE, REPORT_PROJRCT_FILE_EXT, NULL, OFN_FILEMUSTEXIST, REPORT_PROJRCT_FILE_FILTER);
			if (dlg.DoModal() != IDOK)
			{
				// user canceled loading
				LogTrace(__FILE__, __LINE__, _T("Load: user canceled loading."));
				return FALSE;
			}
			a_strPathname = dlg.GetPathName();
		}

		// open the file (for read)


		// create report project file file
		CReportProjFilePtr pReportProjFile = CReportProjFilePtr(new CReportProjFile());

		// load from file


		tinyxml2::XMLDocument doc;
		doc.LoadFile(a_strPathname);//载入xml文件

		tinyxml2::XMLElement *rootNode;
		rootNode = doc.FirstChildElement(RootClassName);
		pReportProjFile->Serialize(false, &doc, rootNode);

		SetPathName(a_strPathname);

		// file version
		CString strFileVersion = pReportProjFile->GetFileVersion();
		DWORD nFileVersion = COTSHelper::GetVersionFromString(strFileVersion);
		if (nFileVersion == 0)
		{
			// invalid file
			LogErrorTrace(__FILE__, __LINE__, _T("Load: invalid sample measure result file %s"), a_strPathname);
			return FALSE;
		}

		// set report project file
		m_pReportProjFile = pReportProjFile;

		// load sample measure result files
		m_listSmplMgrs.clear();
		std::vector<CString> listSmplMsrResultFilePathNames;

		for (auto strSmplMsrResultFilePathName : m_pReportProjFile->GetSmplMsrResultFilePathNames())
		{
			if (strSmplMsrResultFilePathName.IsEmpty())
			{
				// sample measure result file pathname can't be an empty string
				LogTrace(__FILE__, __LINE__, _T("Load: sample measure result file pathname can't be an empty string."));
				SetModify();
				continue;
			}

			// create a sample measure result manager
			CSmplMsrResultFileMgrPtr pSmplMsrResultFileMgr = CSmplMsrResultFileMgrPtr(new CSmplMsrResultFileMgr(strSmplMsrResultFilePathName));
			if (!pSmplMsrResultFileMgr->Load(strSmplMsrResultFilePathName))
			{
				// failed to load sample measure result file
				LogTrace(__FILE__, __LINE__, _T("Load: failed to load sample measure result file (%s)."), strSmplMsrResultFilePathName);
				SetModify();
				continue;
			}

			// this file is ok
			listSmplMsrResultFilePathNames.push_back(strSmplMsrResultFilePathName);
			m_listSmplMgrs.push_back(pSmplMsrResultFileMgr);
		}
		m_pReportProjFile->SetSmplMsrResultFilePathNames(listSmplMsrResultFilePathNames);

		// set working sample
		if (m_listSmplMgrs.size() > 0)
		{
			m_nWorkingSampeIndex = 0;
		}
		else
		{
			m_nWorkingSampeIndex = -1;
		}

		ResetPropertyParams();

		return TRUE;
	}

	// Save 
	BOOL CReportProjFileMgr::Save()
	{
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		// safety check 
		ASSERT(m_pReportProjFile);
		if (!m_pReportProjFile)
		{
			// invalid report project file pointer
			LogErrorTrace(__FILE__, __LINE__, _T("Save: invalid report project file pointer."));
			return FALSE;
		}

		// Save or Save As, if strPathName is not empty, it is exist in the computer, this is a save action
		CString strPathName = GetPathName();

		// is this a new file?
		strPathName.Trim();
		if (strPathName.CompareNoCase(UNTITLED_NEW_FILE_NAME) == 0)
		{
			// this is a new file 

			// return save as result
			return SaveAs();
		}

		// store data to file


		tinyxml2::XMLDocument doc;
		doc.LoadFile(strPathName);//载入xml文件
		doc.Clear();
		tinyxml2::XMLDeclaration* declaration = doc.NewDeclaration();//添加xml文件头申明
		doc.InsertFirstChild(declaration);


		tinyxml2::XMLElement *rootNode;
		rootNode = doc.NewElement(RootClassName);
		doc.InsertEndChild(rootNode);
		m_pReportProjFile->Serialize(true, &doc, rootNode);
		int result = doc.SaveFile(strPathName);
		// set modify flag to FALSE
		SetModify(FALSE);

		// ok, return TRUE
		return TRUE;

	}

	BOOL CReportProjFileMgr::SaveAs()
	{
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		// safety check 
		ASSERT(m_pReportProjFile);
		if (!m_pReportProjFile)
		{
			// invalid report project file pointer
			LogErrorTrace(__FILE__, __LINE__, _T("SaveAs: invalid report project file pointer."));
			return FALSE;
		}

		// save file dialog
		CString strFileName = _T("");

		// file save as dialog
		CFileDialog dlg(FALSE, REPORT_PROJRCT_FILE_EXT, NULL, OFN_OVERWRITEPROMPT, REPORT_PROJRCT_FILE_FILTER);
		if (dlg.DoModal() != IDOK)
		{
			// user canceled loading
			LogTrace(__FILE__, __LINE__, _T("Save: user canceled save."));
			return FALSE;
		}

		// get file pathname
		strFileName = dlg.GetPathName();


		// Open the file


		// store to file

		tinyxml2::XMLDocument doc;
		doc.LoadFile(strFileName);//载入xml文件
		doc.Clear();
		tinyxml2::XMLDeclaration* declaration = doc.NewDeclaration();//添加xml文件头申明
		doc.InsertFirstChild(declaration);


		tinyxml2::XMLElement *rootNode;
		rootNode = doc.NewElement(RootClassName);
		doc.InsertEndChild(rootNode);
		m_pReportProjFile->Serialize(true, &doc, rootNode);
		int result = doc.SaveFile(strFileName);
		// set file modify flag
		m_bModify = FALSE;

		// Set project Path
		SetPathName(strFileName);

		// Ok, return TRUE
		return TRUE;
	}

	BOOL CReportProjFileMgr::IsValid()
	{
		ASSERT(m_pReportProjFile);
		if (!m_pReportProjFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("IsValid: not invalid report project file pointer."));
			return FALSE;
		}

		// triangle template file
		CTriTempFilePtr pTriTemp = m_pReportProjFile->GetTriTemp();



		// Ok, return TRUE
		return TRUE;

	}

	// particle STD data
	CPartSTDDataPtr CReportProjFileMgr::GetPartSTDData()
	{
		// check report project file pointer
		ASSERT(m_pReportProjFile);
		if (!m_pReportProjFile)
		{
			// invalid report project file pointer
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSTDData: invalid report project file pointer."));
			return FALSE;
		}

		return m_pReportProjFile->GetPartSTDData();
	}
	BOOL CReportProjFileMgr::SetPartSTDData(CPartSTDDataPtr a_pPartSTDData)
	{
		// input check
		ASSERT(a_pPartSTDData);
		if (!a_pPartSTDData)
		{
			// invalid particle STD data pointer
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSTDData: invalid particle STD data pointer."));
			return FALSE;
		}

		// check report project file pointer
		ASSERT(m_pReportProjFile);
		if (!m_pReportProjFile)
		{
			// invalid report project file pointer
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSTDData: invalid report project file pointer."));
			return FALSE;
		}

		// create a copy of the particle STD data 
		//CPartSTDDataPtr pPartSTDData = CPartSTDDataPtr(new CPartSTDData(a_pPartSTDData.get()));
		CPartSTDDataPtr pPartSTDData = a_pPartSTDData;

		// set particle STD data
		m_pReportProjFile->SetPartSTDData(pPartSTDData);

		// ok, return TRUE
		return TRUE;
	}

	// sample measure result files
	BOOL CReportProjFileMgr::AddASmplMsrResultMgr(CString a_strPathName /*= _T("")*/)
	{
		/*int tmpFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
		tmpFlag |= _CRTDBG_LEAK_CHECK_DF;
		_CrtSetDbgFlag(tmpFlag);*/

		//_CrtSetBreakAlloc(351380);
		// check report project file pointer
		ASSERT(m_pReportProjFile);
		if (!m_pReportProjFile)
		{
			// invalid report project file pointer
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartSTDData: invalid report project file pointer."));
			return FALSE;
		}

		CSmplMsrResultFileMgrPtr pSmplMsrResultFileMgrPtr = CSmplMsrResultFileMgrPtr(new CSmplMsrResultFileMgr(a_strPathName));

		// load sample result file
		if (!pSmplMsrResultFileMgrPtr->Load(a_strPathName))
		{
			return FALSE;
		}

		//判断新打开的测量结果文件名，是否已经在打开的测量结果列表名中,是的话，不打开,防止同名
		CString strSampleNameNew = pSmplMsrResultFileMgrPtr->GetSmplMsrResultFile()->GetSample()->GetName();
		for (int i = 0; i < m_listSmplMgrs.size(); i++)
		{
			if (m_listSmplMgrs[i]->GetSmplMsrResultFile()->GetSample()->GetName() == strSampleNameNew)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("AddASmplMsrResultMgr: The measurement result name is already included."));
				return FALSE;
			}
		}

		// get the particle STD data of the sample result file
		CPartSTDDataPtr pPartSTDData = pSmplMsrResultFileMgrPtr->GetPartSTDData();
		ASSERT(pPartSTDData);
		if (!pPartSTDData)
		{
			// sample result file particle STD data invalid
			LogErrorTrace(__FILE__, __LINE__, _T("AddASmplMsrResultMgr: sample result file particle STD data invalid."));
			return FALSE;
		}

		// is the first sample result file in the list?
		if (m_listSmplMgrs.empty())
		{
			// yes

			// set particle STD data
			if (!SetPartSTDData(pPartSTDData))
			{
				// failed to call SetPartSTDData method
				LogErrorTrace(__FILE__, __LINE__, _T("AddASmplMsrResultMgr: failed to call SetPartSTDData method."));
				return FALSE;
			}
		}
		else
		{
			// not 

			// check if the particle STD data of the input sample result file is same with the project file
			CPartSTDDataPtr pPartSTDDataProj = m_pReportProjFile->GetPartSTDData();
			ASSERT(pPartSTDDataProj);
			if (!pPartSTDDataProj)
			{
				// invalid report project particle STD data file pointer
				LogErrorTrace(__FILE__, __LINE__, _T("AddASmplMsrResultMgr: invalid report project particle STD data file pointer."));
				return FALSE;
			}
			if (!(*(pPartSTDData.get()) == *(pPartSTDDataProj.get())))
			{
				// the two particle std data dis-matched
				LogTrace(__FILE__, __LINE__, _T("AddASmplMsrResultMgr: the particle std data file of the newly added file is mis-matched with the other files in the report project file."));
				return FALSE;
			}

			//if file name is same and path name is also same, not add
			CString strWorkingFolder = pSmplMsrResultFileMgrPtr->GetWorkingFolderStr();
			// pathname
			CString strPathname = pSmplMsrResultFileMgrPtr->GetPathName();

			auto itr = std::find_if(m_listSmplMgrs.begin(), m_listSmplMgrs.end(), [strWorkingFolder, strPathname](CSmplMsrResultFileMgrPtr p) { return ((p->GetPathName().CompareNoCase(strPathname) == 0) && (p->GetWorkingFolderStr().CompareNoCase(strWorkingFolder) == 0)); });
			if (itr != m_listSmplMgrs.end())
			{
				// the two particle std data dis-matched
				LogTrace(__FILE__, __LINE__, _T("AddASmplMsrResultMgr: the sample measure result file has been inserted into current report file."));
				return FALSE;
			}

		}

		// add the file path name into file path names list
		CString strPathname = pSmplMsrResultFileMgrPtr->GetPathName();
		std::vector<CString> listSmplMsrResultFilePathNames = m_pReportProjFile->GetSmplMsrResultFilePathNames();
		listSmplMsrResultFilePathNames.push_back(strPathname);
		m_pReportProjFile->SetSmplMsrResultFilePathNames(listSmplMsrResultFilePathNames);

		// add the sample result file into sample measure result files list
		m_listSmplMgrs.push_back(pSmplMsrResultFileMgrPtr);

		// set modify flag to TRUE
		SetModify();

		// set working sample
		m_nWorkingSampeIndex = (int)m_listSmplMgrs.size() - 1;

		// reset property parameters
		ResetPropertyParams();

		// ok, return TRUE
		return TRUE;
	}

	void CReportProjFileMgr::SetSmplMsrResultMgrs(CSmplMsrResultFileMgrList a_listSmplMsrResultFileMgr)
	{
		for (auto pSmplMsrResultMgr : a_listSmplMsrResultFileMgr)
		{
			CString strWorkingFolder = pSmplMsrResultMgr->GetWorkingFolderStr();
			CSmplMsrResultFileMgrPtr pSmplMsrResultMgrNew = CSmplMsrResultFileMgrPtr(new CSmplMsrResultFileMgr(strWorkingFolder));


			CString strPathname = pSmplMsrResultMgr->GetPathName();
			pSmplMsrResultMgrNew->SetPathName(strPathname);
			CSmplMsrResultFilePtr pSmplMsrResultFile = pSmplMsrResultMgr->GetSmplMsrResultFile();
			CSmplMsrResultFilePtr pSmplMsrResultFileNew = CSmplMsrResultFilePtr(new CSmplMsrResultFile(pSmplMsrResultFile.get()));
			pSmplMsrResultMgrNew->SetSmplMsrResultFile(pSmplMsrResultFileNew);

			m_listSmplMgrs.push_back(pSmplMsrResultMgrNew);
		}
	}

	CSmplMsrResultFileMgrPtr CReportProjFileMgr::GetASmplMsrResultMgrById(int a_nIndex)
	{
		if (a_nIndex < 0 || a_nIndex >= (int)m_listSmplMgrs.size())
		{
			return nullptr;
		}

		return m_listSmplMgrs[a_nIndex];
	}
	CSmplMsrResultFileMgrPtr CReportProjFileMgr::GetASmplMsrResultMgrByPathName(CString a_strPathName)
	{
		a_strPathName.Trim();
		if (a_strPathName.IsEmpty())
		{
			return nullptr;
		}
		auto itr = std::find_if(m_listSmplMgrs.begin(), m_listSmplMgrs.end(), [a_strPathName](CSmplMsrResultFileMgrPtr p) { return p->GetPathName().CompareNoCase(a_strPathName) == 0; });
		if (itr == m_listSmplMgrs.end())
		{
			return nullptr;
		}
		return *itr;
	}
	CSmplMsrResultFileMgrPtr CReportProjFileMgr::GetASmplMsrResultMgrByFileName(CString a_strFileName)
	{
		a_strFileName.Trim();
		if (a_strFileName.IsEmpty())
		{
			return nullptr;
		}

		auto itr = std::find_if(m_listSmplMgrs.begin(), m_listSmplMgrs.end(), [a_strFileName](CSmplMsrResultFileMgrPtr p)
			{
				CString strDataSource = COTSHelper::GetFileName(p->GetPathName());
				return strDataSource.CompareNoCase(a_strFileName) == 0;
			});
		if (itr == m_listSmplMgrs.end())
		{
			return nullptr;
		}
		return *itr;
	}

	BOOL CReportProjFileMgr::DeleteASmplMsrResultMgrById(int a_nIndex)
	{
		// check the index
		if (a_nIndex < 0 || a_nIndex >= (int)m_listSmplMgrs.size())
		{
			// invalid input sample index
			LogErrorTrace(__FILE__, __LINE__, _T("DeleteSampleByIndex::input sample index"));
			return a_nIndex;
		}

		// delete path from project file;
		std::vector<CString> listSmplMsrResultFilePathNames = m_pReportProjFile->GetSmplMsrResultFilePathNames();

		// check number of file path names
		if ((int)listSmplMsrResultFilePathNames.size() != (int)m_listSmplMgrs.size())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("DeleteASmplMsrResultMgrById: file path names list has different size with sample result file number."));
			return FALSE;
		}

		// calculate new working sample index
		int nNewWorkingSampeIndex;
		if (a_nIndex < m_nWorkingSampeIndex)
		{
			nNewWorkingSampeIndex = m_nWorkingSampeIndex - 1;
		}
		else if (a_nIndex > m_nWorkingSampeIndex)
		{
			nNewWorkingSampeIndex = m_nWorkingSampeIndex;
		}
		else
		{
			// deleting working sample.
			if (a_nIndex == (int)m_listSmplMgrs.size() - 1)
			{
				// this is the last sample, select the above sample as working sample 
				// if this is only sample in the list working sample index will be -1;
				nNewWorkingSampeIndex = m_nWorkingSampeIndex - 1;
			}
			else
			{
				// select next sample as working sample
				nNewWorkingSampeIndex = m_nWorkingSampeIndex;
			}
		}

		// delete the sample 
		m_listSmplMgrs.erase(m_listSmplMgrs.begin() + a_nIndex);

		// the file is modified.
		SetModify();

		// reset working sample index
		m_nWorkingSampeIndex = nNewWorkingSampeIndex;

		// delete the sample path name
		listSmplMsrResultFilePathNames.erase(listSmplMsrResultFilePathNames.begin() + a_nIndex);

		m_pReportProjFile->SetSmplMsrResultFilePathNames(listSmplMsrResultFilePathNames);

		// reset property parameters
		ResetPropertyParams();

		// ok, return TRUE
		return TRUE;
	}

	BOOL CReportProjFileMgr::DeleteASmplMsrResultMgrByPathName(CString a_strPathName)
	{
		// check report project file pointer
		ASSERT(m_pReportProjFile);
		if (!m_pReportProjFile)
		{
			// invalid report project file pointer
			LogErrorTrace(__FILE__, __LINE__, _T("DeleteASmplMsrResultMgrByPathName: invalid report project file pointer."));
			return FALSE;
		}
		a_strPathName.Trim();
		if (a_strPathName.IsEmpty())
		{
			return FALSE;
		}
		auto itrObj = std::find_if(m_listSmplMgrs.begin(), m_listSmplMgrs.end(), [a_strPathName](CSmplMsrResultFileMgrPtr p) { return p->GetPathName().CompareNoCase(a_strPathName) == 0; });
		if (itrObj == m_listSmplMgrs.end())
		{
			// failed to find sample measure result file
			LogErrorTrace(__FILE__, __LINE__, _T("DeleteASmplMsrResultMgrByPathName: failed to find sample measure result file."));
			return FALSE;
		}
		std::vector<CString> listSmplMsrResultFilePathNames = m_pReportProjFile->GetSmplMsrResultFilePathNames();
		auto itrPathName = std::find_if(listSmplMsrResultFilePathNames.begin(), listSmplMsrResultFilePathNames.end(), [a_strPathName](CString strPathName) { return strPathName.CompareNoCase(a_strPathName) == 0; });
		if (itrPathName == listSmplMsrResultFilePathNames.end())
		{
			// failed to find sample measure result file pathname
			LogErrorTrace(__FILE__, __LINE__, _T("DeleteASmplMsrResultMgrByPathName: failed to find sample measure result file pathname."));
			return FALSE;
		}
		m_listSmplMgrs.erase(itrObj);
		//	listSmplMsrResultFilePathNames.erase(itrPathName);
		m_pReportProjFile->GetSmplMsrResultFilePathNames().erase(itrPathName);


		// reset property parameters
		ResetPropertyParams();

		// set modify flag to TRUE
		SetModify();

		// ok, return TRUE
		return TRUE;
	}

	BOOL CReportProjFileMgr::EditASmplMsrResultMgrById(int a_nIndex, CSmplMsrResultFileMgrPtr a_pSmpFileMgr)
	{
		ASSERT(a_pSmpFileMgr);
		if (!a_pSmpFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("EditASmplMsrResultMgrById:invalid sample measure result manager pointer."));
			return FALSE;
		}

		// check if the working sample index
		if (a_nIndex < 0 || a_nIndex >= (int)m_listSmplMgrs.size())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("EditASmplMsrResultMgrById: invalid sample measure result manager index."));
			// invalid working sample index
			return FALSE;
		}

		m_listSmplMgrs.erase(m_listSmplMgrs.begin() + a_nIndex);
		m_listSmplMgrs.insert(m_listSmplMgrs.begin() + a_nIndex, a_pSmpFileMgr);

		return TRUE;
	}


	CSmplMsrResultFileMgrPtr CReportProjFileMgr::GetWorkingSmplMsrReslMgr()
	{
		// check if the working sample index
		if (m_nWorkingSampeIndex < 0 || m_nWorkingSampeIndex >= (int)m_listSmplMgrs.size())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetWorkingSmplMsrReslMgr: invalid working sample measure result manager index."));
			// invalid working sample index
			return FALSE;
		}

		return GetASmplMsrResultMgrById(m_nWorkingSampeIndex);
	}
	CString CReportProjFileMgr::GetWorkingSampleName()
	{
		CString strRet = _T("");

		CSmplMsrResultFileMgrPtr pSmplMsrResultFileMgr = GetWorkingSmplMsrReslMgr();

		ASSERT(pSmplMsrResultFileMgr);
		if (!pSmplMsrResultFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetWorkingSampleName: invalid working sample measure result manager."));
			return _T("");
		}

		CSmplMsrResultFilePtr pSmplMsrResultFile = pSmplMsrResultFileMgr->GetSmplMsrResultFile();

		ASSERT(pSmplMsrResultFile);
		if (!pSmplMsrResultFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetWorkingSampleName: invalid working sample measure result file."));
			return _T("");
		}

		COTSSamplePtr pSample = pSmplMsrResultFile->GetSample();

		ASSERT(pSample);
		if (!pSample)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetWorkingSampleName: invalid working sample."));
			return _T("");
		}

		strRet = pSample->GetName();

		return strRet;
	}

	BOOL CReportProjFileMgr::SetWorkingSmplMsrReslMgr(CSmplMsrResultFileMgrPtr a_pSmplMsrResultMgr)
	{
		ASSERT(a_pSmplMsrResultMgr);
		if (!a_pSmplMsrResultMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetWorkingSmplMsrReslMgr: invalid sample measure result manager pointer."));
			return FALSE;
		}

		if (!EditASmplMsrResultMgrById(m_nWorkingSampeIndex, a_pSmplMsrResultMgr))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetWorkingSmplMsrReslMgr: can't edit working sample measure result file."));
			return FALSE;
		}

		return TRUE;
	}

	CString CReportProjFileMgr::GetFileName()
	{
		// make a copy of file path name
		CString strPathName = m_strPathName;

		// is this a new file?
		strPathName.Trim();
		if (strPathName.CompareNoCase(UNTITLED_NEW_FILE_NAME) == 0)
		{
			return strPathName;
		}

		// get file name
		CString strFileName = COTSHelper::GetFileNameWithoutExtension(strPathName);
		strFileName = COTSHelper::GetFileName(strFileName);

		// return file name
		return strFileName;
	}

	// grid computing
	CGridDatasList CReportProjFileMgr::GridDataTransfer()
	{

		CGridDatasList listGridData;
		listGridData.clear();

		// calculate table type
		CPropParamPtr prop = m_CurrentPropParam;

		//COMPUTE_TABLE_TYPE nCalTableType = a_pGridIn->GetCalTableType();
		BOOL bRet = FALSE;
		TrioCal  trio(this);
		CGBCalculate GBCal(this);
		MeasureResultInfo  Msr(this);
		switch (prop->GetType())
		{
		case DISPLAY_PICTURE_TYPE::IMAGE:
		{
			IMAGE_DISPLAY_TYPE nImgDisType = prop->GetImageDisplayType();
			switch (nImgDisType)
			{
			case IMAGE_DISPLAY_TYPE::GENERAL:
				listGridData = CompDistribution();
				break;
			case  IMAGE_DISPLAY_TYPE::IMAGE_GRID:
			{
				MEASURE_DATA_TYPE meaType = prop->GetMeasureDataType();
				switch (meaType)
				{
				case MEASURE_DATA_TYPE::ALL_PARTICLE:
					listGridData = CompSortClass();
					break;
				case MEASURE_DATA_TYPE::ANYLYSIS_PARTICLE:
					listGridData = CompSortKind();
					break;
				case MEASURE_DATA_TYPE::PARTICALE_SIZE_DISTRIBUTION:
					listGridData = CompSortSize();
					break;
				default:
					break;
				}
				break;
			}

			default:
				break;
			}
			break;
		}

		case DISPLAY_PICTURE_TYPE::TABLE:
		{
			CALCULATE_TABLE_TYPE nCalTableType = prop->GetCalTableType();
			switch (nCalTableType)
			{
			case  CALCULATE_TABLE_TYPE::MEASURE_INFO:
				listGridData = Msr.GetMeasureResultInfo();
				break;
			case CALCULATE_TABLE_TYPE::PARTICALE_GENE_INFO://识别颗粒信息表
				listGridData = CompParticleGenInfo();
				break;
			case  CALCULATE_TABLE_TYPE::PARTICALE_COMP://颗粒成分表，即颗粒识别出的物质名称
				listGridData = CompParticleComponent();
				break;
			case  CALCULATE_TABLE_TYPE::ELEMENT_COMP://元素成分表，即物质的元素百分比
				listGridData = CompElementComponent();
				break;
			case  CALCULATE_TABLE_TYPE::PARTICALE_SIZE_DISTRIBUTION://颗粒尺寸分布
				listGridData = CompParticleSizeDistribution();
				break;
			case  CALCULATE_TABLE_TYPE::AVE_ELEMENT_COMP:
				listGridData = CompAveElemnetComponent();//元素平均重量百分比
				break;
			case  CALCULATE_TABLE_TYPE::GB_Method1:
				listGridData = GBCal.GetGBInclusion();
				break;
			case  CALCULATE_TABLE_TYPE::GB_Method2:
				listGridData = GBCal.GetGBInclusion();
				break;
			case  CALCULATE_TABLE_TYPE::ASTM:
				listGridData = GBCal.GetGBInclusion();
				break;
			case  CALCULATE_TABLE_TYPE::DIN:
				listGridData = GBCal.GetGBInclusion();
				break;

			default:
				break;
			}
			break;
		}

		case DISPLAY_PICTURE_TYPE::CHART:
		{
			CALCULATE_CHART_TYPE nCalChartType = prop->GetCalChartType();
			switch (nCalChartType)
			{
			case  CALCULATE_CHART_TYPE::PARTICALE_COMP:
				listGridData = CompChartParticleComp();
				break;
			case  CALCULATE_CHART_TYPE::ELEMENT_COMP:
				listGridData = CompChartElementComp();
				break;
			case  CALCULATE_CHART_TYPE::PARTICALE_SIZE_DISTRIBUTION:
				listGridData = CompChartParticleSize();
				break;
			case  CALCULATE_CHART_TYPE::TRIO_CHART:
				listGridData = trio.CompParticleTrioInfo();
				break;
			case  CALCULATE_CHART_TYPE::COMMON_FIVE:
				listGridData = CompChartCommonFive();
				break;
			default:
				break;

			}
			break;
		}



		}


		return listGridData;

	}



	// reclassify measure result
	BOOL CReportProjFileMgr::ReClassify()
	{
		ASSERT(m_pReportProjFile);
		if (!m_pReportProjFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ReClassify: empty report project file."));
			return FALSE;
		}

		// particle STD data
		CPartSTDDataPtr pPartSTDData = m_pReportProjFile->GetPartSTDData();
		ASSERT(pPartSTDData);
		if (!pPartSTDData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ReClassify: empty STD file."));
			return FALSE;
		}

		// sample measure result files
		for (auto pSmplMsrResultMgr : m_listSmplMgrs)
		{
			//  particle list, need compute
			COTSParticleList listParticleOld = pSmplMsrResultMgr->GetParticleList();

			//  analysis x-ray list
			CPosXraysList listAnalysisXray = pSmplMsrResultMgr->GetAnalysisXray();

			if (listParticleOld.empty() || listAnalysisXray.empty())
			{
				// need to reload the result
				COTSFieldMgrList listFieldMgr = pSmplMsrResultMgr->GetOTSFldMgrListAndAnalysisXrayList();
				if (listFieldMgr.empty())
				{
					LogErrorTrace(__FILE__, __LINE__, _T("ReClassify: can't reload file."));
					return FALSE;
				}

				if (!pSmplMsrResultMgr->ComputeParticleList())
				{
					LogErrorTrace(__FILE__, __LINE__, _T("ReClassify: can't compute particle list."));
					return FALSE;
				}

				listParticleOld = pSmplMsrResultMgr->GetParticleList();
				listAnalysisXray = pSmplMsrResultMgr->GetAnalysisXray();
			}

			COTSParticleList listAnalysisParticle;
			listAnalysisParticle.clear();


			for (auto pParticle : listParticleOld)
			{
				int nType = pParticle->GetType();

				//All particles that contain X-ray data
				if (nType > (int)OTS_PARTCLE_TYPE::NO_ANALYSIS_X_RAY)
				{
					COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
					listAnalysisParticle.push_back(pParticleNew);
				}

			}

			// 1. Update particle message
			if (!ClassifyParticles(listAnalysisParticle, listAnalysisXray))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("ReClassify: can't classify particle list."));
				return FALSE;
			}

			COTSParticleList listParticle;
			listParticle.clear();

			for (auto pParticle : listParticleOld)
			{
				int nType = pParticle->GetType();
				if (nType < (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED)
				{
					COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
					listParticle.push_back(pParticleNew);
				}
			}

			for (auto pParticle : listAnalysisParticle)
			{
				COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
				listParticle.push_back(pParticleNew);
			}

			CSmplMsrResultFilePtr pSmplMsrResultFile = pSmplMsrResultMgr->GetSmplMsrResultFile();
			ASSERT(pSmplMsrResultFile);
			if (!pSmplMsrResultFile)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("ReClassify: can't get sample measure result file."));
				return FALSE;
			}

			COTSFieldDataList listFieldData = pSmplMsrResultFile->GetFieldData();

			for (auto pFieldData : listFieldData)
			{
				int nID = pFieldData->GetId();

				COTSParticleList listFieldParticle;

				for (auto pParticle : listParticle)
				{
					int nFieldId = pParticle->GetFieldId();

					if (nFieldId == nID)
					{
						COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
						listFieldParticle.push_back(pParticleNew);
					}
				}

				pFieldData->SetParticleList(listFieldParticle);

				//update basedata add code 2019-6-18
				CString strFieldFileFolder = pFieldData->GetFieldFileFolder();
				CString strIncAFilename = strFieldFileFolder + SMPL_MSR_RESULT_INCLUSION_FILE;
				CIncAFileMgrPtr pIncAFileMgr = CIncAFileMgrPtr(new CIncAFileMgr(strIncAFilename));
				pIncAFileMgr->SetParticleList(listFieldParticle, TRUE);
				if (!pIncAFileMgr->Update(strIncAFilename))
				{
					LogErrorTrace(__FILE__, __LINE__, _T("SaveFieldFiles: save inclusion file failed."));
					return FALSE;
				}

			}

			pSmplMsrResultFile->SetFieldData(listFieldData);

			// 2. Update measure result message.
			COTSSamplePtr pSample = pSmplMsrResultFile->GetSample();
			ASSERT(pSample);
			if (!pSample)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("ReClassify: can't get sample pointer."));
				return FALSE;
			}

			CMsrResultsPtr poMsrResults = CMsrResultsPtr(new CMsrResults());

			// go through the particles list
			for (auto pParticle : listParticle)
			{
				// create a measure result item
				CMsrResultItemPtr pMsrResultItem = CMsrResultItemPtr(new CMsrResultItem());
				pMsrResultItem->SetTypeId(pParticle->GetType());
				pMsrResultItem->SetArea((int)(pParticle->GetArea() + 0.5));
				pMsrResultItem->SetNumber(1);

				// add the particle into to field data 
				poMsrResults->CumulateMeasureResults(pMsrResultItem);
			}

			pSample->SetMsrResults(poMsrResults);

			// 3. Update sample STD 
			CMsrParamsPtr poMsrParams = pSample->GetMsrParams();
			ASSERT(poMsrParams);
			if (!poMsrParams)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("ReClassify: can't get sample parameter pointer."));
				return FALSE;
			}

			poMsrParams->SetPartSTDData(pPartSTDData);

			// 4. write sample measure result file.
			// sample measure result file
			CString strFilePathName = pSmplMsrResultMgr->GetPathName();
			if (!pSmplMsrResultMgr->Save(strFilePathName))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("ReClassify: can't get sample pointer."));
				return FALSE;
			}

		}

		return TRUE;
	}

	// get inclusion index
	double CReportProjFileMgr::GetInclusionIndex()
	{
		// get folder name from general parameter.
		ASSERT(m_pReportProjFile);
		if (!m_pReportProjFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetInclusionIndex: Can't find the folder."));
			return -1;
		}
		double dScale = m_pReportProjFile->GetScale();

		double dTotalMeasuredArea = 0.0;
		double dInclusionArea = 0.0;

		CSmplMsrResultFileMgrList m_listSmplMsrResultMgrs;

		for (auto pSmplMsrResultMgr : m_listSmplMsrResultMgrs)
		{
			CSmplMsrResultFilePtr pSmplMsrResultFile = pSmplMsrResultMgr->GetSmplMsrResultFile();

			ASSERT(pSmplMsrResultFile);
			if (!pSmplMsrResultFile)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("GetInclusionIndex: invalid sample measure result file pointer."));
				return -1;
			}

			COTSSamplePtr pSample = pSmplMsrResultFile->GetSample();
			ASSERT(pSample);
			if (!pSample)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("GetInclusionIndex: invalid sample pointer."));
				return -1;
			}

			CMsrResultsPtr poMsrResults = pSample->GetMsrResults();
			ASSERT(poMsrResults);
			if (!poMsrResults)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("GetInclusionIndex: invalid sample measure result pointer."));
				return -1;
			}

			dTotalMeasuredArea += poMsrResults->GetMeasuredArea();

			CMsrResultItemsList listResultItems = poMsrResults->GetResultItems();
			for (auto pItem : listResultItems)
			{
				int nType = pItem->GetTypeId();
				if (nType > (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED)
				{
					dInclusionArea += pItem->GetArea();
				}
			}
		}

		return dInclusionArea / dTotalMeasuredArea * dScale;
	}
	// classify particles
	BOOL CReportProjFileMgr::ClassifyParticles(COTSParticleList& a_listAnalysisParticles, CPosXraysList& a_listAnalysisXRay)
	{
		// make sure the two lists are same size
		int nSize = (int)a_listAnalysisParticles.size();
		if (nSize != (int)a_listAnalysisXRay.size())
		{
			// particles list size is different with x-ray size
			LogErrorTrace(__FILE__, __LINE__, _T("ClassifyParticles: particles list size is different with x-ray size."));
			return FALSE;
		}

		// go through all analysis particles
		for (int i = 0; i < nSize; ++i)
		{
			COTSParticlePtr pParticle = a_listAnalysisParticles[i];
			int nAnalysisXrayId = pParticle->GetAnalysisId();
			if (nAnalysisXrayId < 0 || nAnalysisXrayId >= nSize)
			{
				// particles list size is different with x-ray size
				LogErrorTrace(__FILE__, __LINE__, _T("ClassifyParticles: particles xray id is wrong."));
				return FALSE;
			}

			int nFieldId = pParticle->GetFieldId();

			//using on classify debug,trace fieldid and analysisxrayid
			if (nFieldId == 135 && nAnalysisXrayId == 38)
			{
				int a = 0;
			}

			auto itr = std::find_if(a_listAnalysisXRay.begin(), a_listAnalysisXRay.end(), [nAnalysisXrayId, nFieldId](CPosXrayPtr p) { return (p->GetScanFieldId() == nFieldId && p->GetIndex() == nAnalysisXrayId); });
			if (itr == a_listAnalysisXRay.end())
			{
				return FALSE;
			}

			CPosXrayPtr pXray = *itr;

			if (!ClassifyParticle(pParticle, pXray))
			{
				// failed to call ClassifyParticle method
				LogErrorTrace(__FILE__, __LINE__, _T("ClassifyParticles: failed to call ClassifyParticle method."));
				return FALSE;
			}
		}

		// ok, return TRUE
		return TRUE;
	}

	BOOL CReportProjFileMgr::ClassifyParticle(COTSParticlePtr a_pParticle, CPosXrayPtr a_pXRay)
	{
		// safety check
		ASSERT(m_pReportProjFile);
		if (!m_pReportProjFile)
		{
			// invalid sample pointer.
			LogErrorTrace(__FILE__, __LINE__, _T("ClassifyParticle: invalid sample pointer."));
			return FALSE;
		}
		ASSERT(a_pParticle);
		if (!a_pParticle)
		{
			// invalid particle pointer.
			LogErrorTrace(__FILE__, __LINE__, _T("ClassifyParticle: invalid particle pointer."));
			return FALSE;
		}
		ASSERT(a_pXRay);
		if (!a_pXRay)
		{
			// invalid x-ray pointer.

			LogErrorTrace(__FILE__, __LINE__, _T("ClassifyParticle: invalid x-ray pointer."));
			return FALSE;
		}

		//2019.3.28 code changes
		//initial inclusion ID is NOT_IDENTIFIED
		int nIncId = (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED;
		//get STDData from Reportprojfile
		CPartSTDDataPtr pPartSTDData = m_pReportProjFile->GetPartSTDData();
		//get element chemistries list from xray
		CElementChemistriesList listElementChemistriesOld = a_pXRay->GetElementQuantifyData();

		auto pSample = m_listSmplMgrs[m_nWorkingSampeIndex]->GetSmplMsrResultFile()->GetSample();

		//get the parameter MsrParam object
		CMsrParamsPtr pMsrParam = pSample->GetMsrParams();
		//get the steel technology parameter
		STEEL_TECHNOLOGY steelTech = pMsrParam->GetSteelTechnology();
		//get standard database item which will be used when classify.	

		//third setp.the particle are classified
		if (!COTSClassifyEng::ClassifyXray(pPartSTDData, steelTech, listElementChemistriesOld, nIncId))
		{// invalid x-ray pointer.
			LogErrorTrace(__FILE__, __LINE__, _T("ClassifyParticle: can't identify the particle as any inclusion."));
			return FALSE;
		}
		if (nIncId < 8)
		{
			nIncId = (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED;
		}
		a_pParticle->SetType(nIncId);

		// ok, return TRUE
		return TRUE;
	}


	// protected

	// get data source name list
	std::vector<CString> CReportProjFileMgr::GetDataSourceNamesList()
	{
		std::vector<CString> listDataSourceNames;
		CString strComSourceName = _T("");
		int nComNum = 0;

		for (auto pSmplMsrResultFileMgr : m_listSmplMgrs)
		{
			// sample measure result file
			CString strFilePathName = pSmplMsrResultFileMgr->GetPathName();

			// get data source name
			CString strDataSource = COTSHelper::GetFileName(strFilePathName);

			// get compound source name
			CSmplMsrResultFilePtr pSmplMsrResultFile = pSmplMsrResultFileMgr->GetSmplMsrResultFile();
			ASSERT(pSmplMsrResultFile);
			if (!pSmplMsrResultFile)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("GetDataSourceNamesList: Can't get sample result file pointer."));
				break;
			}

			BOOL bSwitch = pSmplMsrResultFile->GetSwitch();

			if (bSwitch)
			{
				strComSourceName += strDataSource + _T("+");
				nComNum++;
			}

			// add data source name into the list
			listDataSourceNames.push_back(strDataSource);
		}

		if (nComNum > 1)
		{
			//listDataSourceNames.push_back(strComSourceName);
			strComSourceName.TrimRight(_T("+"));//去掉最后的+号
			listDataSourceNames.insert(listDataSourceNames.begin(), strComSourceName);
		}
		return listDataSourceNames;
	}

	std::vector<int> CReportProjFileMgr::GetDataSourcePosList()
	{
		std::vector<int> listDataSourcePos;

		if (!IsHaveMultiDataSource())
		{
			return listDataSourcePos;
		}

		int nPos = -1;

		for (auto pSmplMsrResultFileMgr : m_listSmplMgrs)
		{
			nPos++;

			// get compound source name
			CSmplMsrResultFilePtr pSmplMsrResultFile = pSmplMsrResultFileMgr->GetSmplMsrResultFile();
			ASSERT(pSmplMsrResultFile);
			if (!pSmplMsrResultFile)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("GetDataSourceNamesList: Can't get sample result file pointer."));
				break;
			}

			BOOL bSwitch = pSmplMsrResultFile->GetSwitch();

			if (bSwitch)
			{
				listDataSourcePos.push_back(nPos);
			}

		}

		return listDataSourcePos;
	}
	// get property parameter


	// compute particle general information
	CGridDatasList CReportProjFileMgr::CompParticleGenInfo()
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		CGridDatasList listGridData;
		listGridData.clear();


		// depart compound source name

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

		std::vector<int> listSelectedPos;
		if (IsHaveMultiDataSource() && (int)listSelectedDataSource.size() > 1)
		{
			listSelectedPos = GetDataSourcePosList();
			if ((int)listSelectedPos.size() != (int)listSelectedDataSource.size())
			{
				return listGridData;
			}
		}

		int nIndex = 0;
		for (auto strDataSourceName : listSelectedDataSource)
		{
			CGridDataPtr pGridData = CGridDataPtr(new CGridData());

			//// data source id

			pGridData->SetDataSourceList(m_CurrentPropParam->GetDataSourceList());

			int nDataSourceId = -1;
			if (IsHaveMultiDataSource())
			{
				if (listSelectedDataSource.size() > 1)
				{
					nDataSourceId = listSelectedPos[nIndex];
				}
				else
				{
					nDataSourceId = m_CurrentPropParam->GetDataSourceId() - 1;
				}
			}
			else
			{
				nDataSourceId = m_CurrentPropParam->GetDataSourceId();
			}
			pGridData->SetDataSourceId(nDataSourceId);

			//------------select xray data add 2019-06-15-----------------
			COTSParticleList listParticleAll;
			listParticleAll.clear();

			CPosXraysList listXrayOut;
			listXrayOut.clear();

			CPosXraysList listXray;
			listXray.clear();

			COTSParticleList selectedParts = m_CurrentPropParam->GetSelectParticle();
			// add filter select particle
			COTSParticleList* pSelectedParts;

			listXrayOut = GetAnalysisXrayList(strDataSourceName);

			if (m_CurrentPropParam->GetDataSourceType() == DATA_SOURCE_TYPE::SELECTION)
			{
				listParticleAll = m_CurrentPropParam->GetSelectParticle();

				pSelectedParts = &selectedParts;

				for (auto pParticle : listParticleAll)
				{
					int nIndex = pParticle->GetAnalysisId();
					int nField = pParticle->GetFieldId();

					auto itr = std::find_if(listXrayOut.begin(), listXrayOut.end(), [nIndex, nField](CPosXrayPtr p) { return (p->GetIndex() == nIndex && p->GetScanFieldId() == nField); });
					if (itr == listXrayOut.end())
					{
						continue;
					}
					else
					{
						CPosXrayPtr pXray = *itr;
						listXray.push_back(pXray);
					}
				}
			}
			else
			{
				listParticleAll = GetAnalysisParticleList(strDataSourceName);

				pSelectedParts = &listParticleAll;

				for (auto pXray : listXrayOut)
				{
					//CPosXrayPtr pXrayNew = CPosXrayPtr(new CPosXray(*pXray.get()));
					listXray.push_back(pXray);
				}
			}
			//-----------------------------------------------------------

			//get pixel size
			CSmplMsrResultFileMgrPtr pSmplMsrResultFileMgr = this->GetASmplMsrResultMgrByFileName(strDataSourceName);
			ASSERT(pSmplMsrResultFileMgr);
			if (!pSmplMsrResultFileMgr)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompParticleGenInfo: can't get sample result file manager."));
				return listGridData;
			}

			CSmplMsrResultFilePtr pSmplMsrResultFile = pSmplMsrResultFileMgr->GetSmplMsrResultFile();
			ASSERT(pSmplMsrResultFile);
			if (!pSmplMsrResultFile)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompParticleGenInfo: can't get sample result file."));
				return listGridData;
			}

			COTSSamplePtr pSample = pSmplMsrResultFile->GetSample();
			ASSERT(pSample);
			if (!pSample)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompParticleGenInfo: can't get sample."));
				return listGridData;
			}

			double dPixelSize = pSample->CalculatePixelSize();

			if (!GetGenInfoFromParticleList(*pSelectedParts, listXray, dPixelSize, pGridData))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompParticleGenInfo: can't get general information."));
				return listGridData;
			}

			listGridData.push_back(pGridData);

			nIndex++;

		}

		return listGridData;
	}

	COTSParticleList CReportProjFileMgr::GetAnalysisParticleList(CString a_DataSourceName)
	{

		COTSParticleList listParticleAll;

		// compound sample measure result files
		CSmplMsrResultFileMgrPtr pSmplMsrResultFileMgr = this->GetASmplMsrResultMgrByFileName(a_DataSourceName);

		if (!pSmplMsrResultFileMgr->ComputeParticleList())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetAnalysisParticleList: can't get particle list."));
			return listParticleAll;
		}
		listParticleAll = pSmplMsrResultFileMgr->GetParticleList();
		return listParticleAll;

	}

	CPosXraysList CReportProjFileMgr::GetAnalysisXrayList(CString a_DataSourceName)
	{
		CPosXraysList listAnalysisXray;

		CSmplMsrResultFileMgrPtr pSmplMsrResultFileMgr = this->GetASmplMsrResultMgrByFileName(a_DataSourceName);
		pSmplMsrResultFileMgr->GetOTSFldMgrListAndAnalysisXrayList();
		// should first read x ray data from data base.
		listAnalysisXray = pSmplMsrResultFileMgr->GetAnalysisXray();
		return listAnalysisXray;

	}
	CSTDItemPtr CReportProjFileMgr::GetParticleSTDItem(int STDItemId) {

		// std
		ASSERT(m_pReportProjFile);
		if (!m_pReportProjFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CompParticleGenInfo: empty project file."));
			return nullptr;
		}

		CPartSTDDataPtr pPartSTDData = m_pReportProjFile->GetPartSTDData();
		ASSERT(pPartSTDData);
		if (!pPartSTDData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CompParticleGenInfo: invalid STD data."));
			return nullptr;
		}

		CSTDItemsList listSTDItem = pPartSTDData->GetSTDItemsList();

		if (listSTDItem.empty())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CompParticleGenInfo: empty STD Item."));
			return nullptr;
		}
		auto itr = std::find_if(listSTDItem.begin(), listSTDItem.end(), [STDItemId](CSTDItemPtr p) {return (p->GetSTDId() == STDItemId); });
		if (itr == listSTDItem.end()) //没有找到，标明这是一个未识别颗粒，类型为7
		{

			return nullptr;
		}
		CSTDItemPtr p = *itr;
		return p;
	}
	bool CReportProjFileMgr::GetSTDMapedParticleList(const COTSParticleList& a_listParticle, map<int, COTSParticleList>* mapSameSTDPartList)
	{

		//把颗粒根据类型分组,类型 ID做key，颗粒列表做value

		map<int, COTSParticleList>::iterator partListIter;

		//get the same type particle together
		for (auto pParticle : a_listParticle)
		{
			int nType = pParticle->GetType();

			//只有"NOT_IDENTIFIED"以上的颗粒类型需要考虑
			if (nType >= (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_SIC)
			{

				partListIter = mapSameSTDPartList->find(nType);
				if (partListIter == mapSameSTDPartList->end())
				{
					COTSParticleList listParticle;
					listParticle.push_back(pParticle);
					mapSameSTDPartList->insert(pair<int, COTSParticleList>(nType, listParticle));
				}
				else
				{
					partListIter->second.push_back(pParticle);
				}

			}

		}


		return true;
	}
	// compute particle general information according to particle list
	BOOL CReportProjFileMgr::GetGenInfoFromParticleList(COTSParticleList a_listParticle, CPosXraysList a_listXray, double a_dPixelSize, CGridDataPtr a_pGridData)
	{

		ASSERT(a_pGridData);
		if (!a_pGridData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetGenInfoFromParticleList: invalid grid data pointer."));
			return FALSE;
		}



		COTSParticleList listPartReport;
		map<int, COTSParticleList> mapSameSTDItemPartList;
		this->GetSTDMapedParticleList(a_listParticle, &mapSameSTDItemPartList);
		COTSParticleList listNotIdentified;
		COTSParticleList listSiC;
		COTSParticleList listFeO;
		for (auto partListIter = mapSameSTDItemPartList.begin(); partListIter != mapSameSTDItemPartList.end(); partListIter++)
		{
			if (partListIter->first != (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED)
			{
				listPartReport.insert(listPartReport.end(), partListIter->second.begin(), partListIter->second.end());
			}
			else if (partListIter->first == (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_SIC)
			{
				listSiC = partListIter->second;
			}
			else if (partListIter->first == (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_FEO)
			{
				listFeO = partListIter->second;
			}
			else
			{
				listNotIdentified = partListIter->second;
			}

		}
		listPartReport.insert(listPartReport.end(), listSiC.begin(), listSiC.end());
		listPartReport.insert(listPartReport.end(), listFeO.begin(), listFeO.end());
		listPartReport.insert(listPartReport.end(), listNotIdentified.begin(), listNotIdentified.end());


		int nColumnNum = ((int)(REPORT_PARTICLE_GEN_INFO_GRID_CLUMN::MAX) - (int)(REPORT_PARTICLE_GEN_INFO_GRID_CLUMN::MIN) + 1);
		std::vector<CString> listColumnName;
		LoadColumnString(listColumnName, IDS_PARTICLE_GEN_INFO_START, nColumnNum);

		if ((int)listColumnName.size() != nColumnNum)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CompParticleGenInfo: Can't get column name number."));
			return FALSE;
		}


		//将元素进行分栏显示汇总集合
		vector< CElementChemistriesList> vec_CElementChemistriesList;
		vec_CElementChemistriesList.clear();

		CGridColumnsList listGridColumn;

		for (int i = 0; i < nColumnNum; i++)
		{
			CGridColumnPtr pColumn = CGridColumnPtr(new CGridColumn());
			pColumn->SetName(listColumnName[i]);

			CGridRowsList listGridRows;
			listGridRows.clear();

			int nType = 0;
			int nPos = 0;

			double a_dPartFTD;
			double a_dMinWidth;
			double a_dMaxLength;
			//double a_dRatio;


			switch (i)
			{
			case (int)REPORT_PARTICLE_GEN_INFO_GRID_CLUMN::NAME:
				listGridRows.clear();
				for (auto pParticle : listPartReport)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);

					nType = pParticle->GetType();

					if (nType >= (int)OTS_PARTCLE_TYPE::IDENTIFIED)
					{
						std::string strName = pParticle->TypeName();
						pGridRow->SetStringValue(strName.c_str());
					}
					else
					{
						int nColumnNum = ((int)(REPORT_SORT_CLASS_GRID_CLUMN::MAX) - (int)(REPORT_SORT_CLASS_GRID_CLUMN::MIN) + 1);
						std::vector<CString> listColumnName;
						LoadColumnString(listColumnName, IDS_SORT_CLASS_START, nColumnNum);

						if (nType == (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED)
						{
							pGridRow->SetStringValue(listColumnName[(int)REPORT_SORT_CLASS_GRID_CLUMN::NOT_IDENTIFIED]);//未知颗粒
						}
						else if (nType == (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_SIC)
						{
							pGridRow->SetStringValue(listColumnName[(int)REPORT_SORT_CLASS_GRID_CLUMN::NOT_INCLUSION_SIC]);//SiC
						}
						else if (nType == (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_FEO)
						{
							pGridRow->SetStringValue(listColumnName[(int)REPORT_SORT_CLASS_GRID_CLUMN::NOT_INCLUSION_FEO]);//FeO
						}
					}
					listGridRows.push_back(pGridRow);

					//获取element数据
					int XrayId = pParticle->GetAnalysisId();
					int nFieldId = pParticle->GetFieldId();

					auto itr = std::find_if(a_listXray.begin(), a_listXray.end(), [XrayId, nFieldId](CPosXrayPtr p) { return ((p->GetScanFieldId() == nFieldId) && (p->GetIndex() == XrayId)); });

					CPosXrayPtr pXray = *itr;
					CElementChemistriesList listTpElement = pXray->GetElementQuantifyData();

					//将获取到的元素先都添加到元素的List当中
					vec_CElementChemistriesList.push_back(listTpElement);
				}
				break;
			case (int)REPORT_PARTICLE_GEN_INFO_GRID_CLUMN::IMAGE:
				listGridRows.clear();
				for (auto pParticle : listPartReport)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
					//COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
					pGridRow->SetParticle(pParticle);
					listGridRows.push_back(pGridRow);
				}
				break;
			case (int)REPORT_PARTICLE_GEN_INFO_GRID_CLUMN::MAXLENGTH://最长直径
				listGridRows.clear();
				for (auto pParticle : listPartReport)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);

					a_dMaxLength = pParticle->GetDMax();
					pGridRow->SetDoubleValue(a_dMaxLength);
					listGridRows.push_back(pGridRow);
				}
				break;
			case (int)REPORT_PARTICLE_GEN_INFO_GRID_CLUMN::MINLENGTH://最短直径
				listGridRows.clear();
				for (auto pParticle : listPartReport)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);

					a_dMinWidth = pParticle->GetDMin();
					pGridRow->SetDoubleValue(a_dMinWidth);
					listGridRows.push_back(pGridRow);
				}
				break;
			case (int)REPORT_PARTICLE_GEN_INFO_GRID_CLUMN::AXIALRATIO://长短直径比
				listGridRows.clear();
				for (auto pParticle : listPartReport)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);

					a_dMinWidth = pParticle->GetDMax();
					a_dMaxLength = pParticle->GetDMin();

					double d_axialratio = 0;
					if (a_dMinWidth != 0)
					{
						d_axialratio = a_dMaxLength / a_dMinWidth;
					}

					pGridRow->SetDoubleValue(d_axialratio);
					listGridRows.push_back(pGridRow);
				}
				break;
			case (int)REPORT_PARTICLE_GEN_INFO_GRID_CLUMN::EquivalentCircleDiameter://等效圆直径
				listGridRows.clear();
				//double Diameter;
				for (auto pParticle : listPartReport)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);

					double Diameter = pParticle->GetEqualCircleDiameter();

					pGridRow->SetDoubleValue(Diameter);
					listGridRows.push_back(pGridRow);
				}
				break;
			case (int)REPORT_PARTICLE_GEN_INFO_GRID_CLUMN::FerretDiameter://费雷特直径
				listGridRows.clear();
				for (auto pParticle : listPartReport)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
					a_dPartFTD = (pParticle->GetDMax() + pParticle->GetDMin()) / 2;
					//a_dPartFTD = pParticle->GetFeretDiameter();
					pGridRow->SetDoubleValue(a_dPartFTD);
					listGridRows.push_back(pGridRow);
				}
				break;
			case (int)REPORT_PARTICLE_GEN_INFO_GRID_CLUMN::SIZE:
				listGridRows.clear();
				for (auto pParticle : listPartReport)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
					double dSize = pParticle->GetArea();
					pGridRow->SetDoubleValue(dSize);
					listGridRows.push_back(pGridRow);

					//pParticle->GetFeretDiameter();
				}
				break;

				//2020-4-11 add new calc type
			case (int)REPORT_PARTICLE_GEN_INFO_GRID_CLUMN::PERP: //正交直径
				listGridRows.clear();
				for (auto pParticle : listPartReport)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
					double dPerp = pParticle->GetDPerp();
					pGridRow->SetDoubleValue(dPerp);
					listGridRows.push_back(pGridRow);
				}
				break;

			case (int)REPORT_PARTICLE_GEN_INFO_GRID_CLUMN::PERI: //周长
				listGridRows.clear();
				for (auto pParticle : listPartReport)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
					double dPeri = pParticle->GetPerimeter();
					pGridRow->SetDoubleValue(dPeri);
					listGridRows.push_back(pGridRow);
				}
				break;

			case (int)REPORT_PARTICLE_GEN_INFO_GRID_CLUMN::INSCR: //内接圆直径
				listGridRows.clear();
				for (auto pParticle : listPartReport)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
					double dInscr = pParticle->GetDInscr();
					pGridRow->SetDoubleValue(dInscr);
					listGridRows.push_back(pGridRow);
				}
				break;

			case (int)REPORT_PARTICLE_GEN_INFO_GRID_CLUMN::MEAN: //内接圆平均直径
				listGridRows.clear();
				for (auto pParticle : listPartReport)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
					double dMean = pParticle->GetDMean();
					pGridRow->SetDoubleValue(dMean);
					listGridRows.push_back(pGridRow);
				}
				break;

			case (int)REPORT_PARTICLE_GEN_INFO_GRID_CLUMN::ELONG: //展开长度
				listGridRows.clear();
				for (auto pParticle : listPartReport)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
					double dElong = pParticle->GetDElong();
					pGridRow->SetDoubleValue(dElong);
					listGridRows.push_back(pGridRow);
				}
				break;

			case (int)REPORT_PARTICLE_GEN_INFO_GRID_CLUMN::ASPECT_ELONG: //展开长度比
				listGridRows.clear();
				for (auto pParticle : listPartReport)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
					double dAspectElong = pParticle->GetAspectElong();
					pGridRow->SetDoubleValue(dAspectElong);
					listGridRows.push_back(pGridRow);
				}
				break;

			case (int)REPORT_PARTICLE_GEN_INFO_GRID_CLUMN::ASPECT_MAX: //展开直径比
				listGridRows.clear();
				for (auto pParticle : listPartReport)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
					double dAspectRatio = pParticle->GetAspectRatio();
					pGridRow->SetDoubleValue(dAspectRatio);
					listGridRows.push_back(pGridRow);
				}
				break;

			case (int)REPORT_PARTICLE_GEN_INFO_GRID_CLUMN::Orientation: //朝向角度
				listGridRows.clear();
				for (auto pParticle : listPartReport)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
					double dOrientation = pParticle->GetOrientation();
					pGridRow->SetDoubleValue(dOrientation);
					listGridRows.push_back(pGridRow);
				}
				break;


			}

			pColumn->SetGridRowsList(listGridRows);

			listGridColumn.push_back(pColumn);
		}

		//定义一个不显示的元素字符列表
		vector<CString> vec_NotDisplayed;
		vec_NotDisplayed.clear();

		//上面获取完成vector CElementChemistriesList 后，再对该列表取出不同元素名的所有元素的总数
		vector<CString> vec_CString;
		vec_CString.clear();
		for (auto pListTpElement : vec_CElementChemistriesList)
		{
			for (auto pCElementChemistry : pListTpElement)
			{
				CString ls_CString = pCElementChemistry->GetName();
				//判断是否已经添加完在字符列表中了
				bool b_sfcz = false;
				for (int i = 0; i < vec_CString.size(); i++)
				{
					if (vec_CString[i] == ls_CString)
					{
						b_sfcz = true;
						break;
					}
				}

				//判断是否在不显示的元素列表中
				for (int i = 0; i < vec_NotDisplayed.size(); i++)
				{
					if (vec_NotDisplayed[i] == ls_CString)
					{
						b_sfcz = true;
						break;
					}
				}

				//未添加进列表中，及不在不显示的元素列表中的话，对该元素进行添加
				if (b_sfcz == false)
				{
					vec_CString.push_back(ls_CString);
				}
			}
		}

		////获得了总数后，再添加Column,
		for (unsigned int i = 0; i < vec_CString.size(); i++)
		{
			CGridColumnPtr pColumn = CGridColumnPtr(new CGridColumn());
			pColumn->SetName(vec_CString[i]);

			CGridRowsList listGridRows;
			listGridRows.clear();

			for (auto pParticle : listPartReport)
			{
				CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
				pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);

				int XrayId = pParticle->GetAnalysisId();
				int nFieldId = pParticle->GetFieldId();

				auto itr = std::find_if(a_listXray.begin(), a_listXray.end(), [XrayId, nFieldId](CPosXrayPtr p) { return ((p->GetScanFieldId() == nFieldId) && (p->GetIndex() == XrayId)); });
				if (itr == a_listXray.end())
				{
					break;
				}
				else
				{
					//找到了的情况下，与之对应取出
					CPosXrayPtr pXray = *itr;
					CElementChemistriesList listTpElement = pXray->GetElementQuantifyData();

					for (int k = 0; k < (int)listTpElement.size(); k++)
					{
						if (listTpElement[k]->GetName() == vec_CString[i])
						{
							//对应到了该列，将重量比添加到row中
							pGridRow->SetDoubleValue(listTpElement[k]->GetPercentage());
						}
					}
					//pGridRow->SetDoubleValue(listTpElement[0]->GetPercentage());
				}
				//从该颗粒中，查找与vec_CString[i]对应的元素，找到的话，取出重量比
				listGridRows.push_back(pGridRow);
			}

			pColumn->SetGridRowsList(listGridRows);
			listGridColumn.push_back(pColumn);
		}

		//reset load param file


		//过滤要显示的列
		CGridColumnsList::iterator itr = listGridColumn.begin();
		while (itr != listGridColumn.end())
		{
			if (EstimateShowColumn((*itr)->GetName()) == false)
			{
				itr = listGridColumn.erase(itr);
				continue;
			}
			itr++;
		}

		a_pGridData->SetGridColumnList(listGridColumn);
		return TRUE;
	}

	//判断该列是否要显示
	BOOL CReportProjFileMgr::EstimateShowColumn(CString a_strColName)
	{
		CString str_Area_Enum = "Area";
		CString str_MaxDiameter_Enum = "MaxDiameter";
		CString str_MinDiameter_Enum = "MinDiameter";
		CString str_DiameterRatio_Enum = "DiameterRatio";
		CString str_EquivalentCircleDiameter_Enum = "EquivalentCircleDiameter";
		CString str_FerretDiameter_Enum = "FerretDiameter";

		CString str_Area_CN = "颗粒面积";
		CString str_MaxDiameter_CN = "最长直径";
		CString str_MinDiameter_CN = "最短直径";
		CString str_DiameterRatio_CN = "长短直径比";
		CString str_EquivalentCircleDiameter_CN = "等效圆直径";
		CString str_FerretDiameter_CN = "费雷特直径";

		//最后再根据设置默认显示列名，对不需要显示的列进行屏蔽
		CString s_DefaultComputedColName = m_rptparamfile->GetDefaultComputedColName();
		if (a_strColName.Find(str_Area_CN, 0) > -1 || a_strColName.Find(str_MaxDiameter_CN, 0) > -1 ||
			a_strColName.Find(str_MinDiameter_CN, 0) > -1 || a_strColName.Find(str_DiameterRatio_CN, 0) > -1 ||
			a_strColName.Find(str_EquivalentCircleDiameter_CN, 0) > -1 || a_strColName.Find(str_FerretDiameter_CN, 0) > -1)
		{
			//面积
			if (s_DefaultComputedColName.Find(str_Area_Enum) > -1 && a_strColName.Find(str_Area_CN, 0) > -1)
			{
				return true;
			}

			//最长直径
			if (s_DefaultComputedColName.Find(str_MaxDiameter_Enum) > -1 && a_strColName.Find(str_MaxDiameter_CN, 0) > -1)
			{
				return true;
			}

			//最短直径
			if (s_DefaultComputedColName.Find(str_MinDiameter_Enum) > -1 && a_strColName.Find(str_MinDiameter_CN, 0) > -1)
			{
				return true;
			}

			//长短直径比
			if (s_DefaultComputedColName.Find(str_DiameterRatio_Enum) > -1 && a_strColName.Find(str_DiameterRatio_CN, 0) > -1)
			{
				return true;
			}

			//等效圆直径
			if (s_DefaultComputedColName.Find(str_EquivalentCircleDiameter_Enum) > -1 && a_strColName.Find(str_EquivalentCircleDiameter_CN, 0) > -1)
			{
				return true;
			}

			//费雷特直径
			if (s_DefaultComputedColName.Find(str_FerretDiameter_Enum) > -1 && a_strColName.Find(str_FerretDiameter_CN, 0) > -1)
			{
				return true;
			}

			return false;
		}
		return true;
	}

	// compute particle component
	CGridDatasList CReportProjFileMgr::CompParticleComponent()
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		CGridDatasList listGridData;
		listGridData.clear();


		std::vector<CString> listDataSource = m_CurrentPropParam->GetDataSourceList();
		int nSelectedDataSourceIndex = m_CurrentPropParam->GetDataSourceId();
		CString sDataSourceNames = listDataSource[nSelectedDataSourceIndex];
		std::vector<CString> listSelectedDataSource = COTSHelper::SplitString(sDataSourceNames, _T("+"));
		//int nIndex = 0;
		for (auto strDataSourceName : listSelectedDataSource)
		{
			CGridDataPtr pGridData = CGridDataPtr(new CGridData());

			// data source id

			pGridData->SetDataSourceList(m_CurrentPropParam->GetDataSourceList());


			pGridData->SetDataSourceId(m_CurrentPropParam->GetDataSourceId());
			COTSParticleList* pSelectidParts;
			COTSParticleList listParticleAll;
			COTSParticleList seleParticles;

			// add filter select particle
			if (m_CurrentPropParam->GetDataSourceType() == DATA_SOURCE_TYPE::SELECTION)
			{
				seleParticles = m_CurrentPropParam->GetSelectParticle();
				pSelectidParts = &seleParticles;
			}
			else
			{
				listParticleAll = GetAnalysisParticleList(strDataSourceName);
				pSelectidParts = &listParticleAll;
			}

			//get pixel size
			CSmplMsrResultFileMgrPtr pSmplMsrResultFileMgr = this->GetASmplMsrResultMgrByFileName(strDataSourceName);
			ASSERT(pSmplMsrResultFileMgr);
			if (!pSmplMsrResultFileMgr)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompParticleComponent: can't get sample result file manager."));
				return listGridData;
			}

			CSmplMsrResultFilePtr pSmplMsrResultFile = pSmplMsrResultFileMgr->GetSmplMsrResultFile();
			ASSERT(pSmplMsrResultFile);
			if (!pSmplMsrResultFile)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompParticleComponent: can't get sample result file."));
				return listGridData;
			}

			COTSSamplePtr pSample = pSmplMsrResultFile->GetSample();
			ASSERT(pSample);
			if (!pSample)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompParticleComponent: can't get sample."));
				return listGridData;
			}

			double dPixelSize = pSample->CalculatePixelSize();

			if (!GetComponentFromParticleList(*pSelectidParts, m_CurrentPropParam->GetSizeCalMethodType(), dPixelSize, pGridData))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompParticleComponent: can't get general information."));
				return listGridData;
			}

			listGridData.push_back(pGridData);

		}


		return listGridData;
	}


	BOOL CReportProjFileMgr::GetComponentFromParticleList(COTSParticleList a_listParticle, OTSMODEL::SIZE_CAL_METHOD_TYPE a_nMethod, double a_dPixelSize, CGridDataPtr a_pGridData)
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		ASSERT(a_pGridData);
		if (!a_pGridData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetComponentFromParticleList: invalid grid data pointer."));
			return FALSE;
		}

		//// std
		//ASSERT(m_pReportProjFile);
		//if (!m_pReportProjFile)
		//{
		//	LogErrorTrace(__FILE__, __LINE__, _T("GetComponentFromParticleList: empty project file."));
		//	return FALSE;
		//}

		//CPartSTDDataPtr pPartSTDData = m_pReportProjFile->GetPartSTDData();
		//ASSERT(pPartSTDData);
		//if (!pPartSTDData)
		//{
		//	LogErrorTrace(__FILE__, __LINE__, _T("GetComponentFromParticleList: invalid STD data."));
		//	return FALSE;
		//}

		//CSTDItemsList listSTDItem = pPartSTDData->GetSTDItemsList();

		//if (listSTDItem.empty())
		//{
		//	LogErrorTrace(__FILE__, __LINE__, _T("GetComponentFromParticleList: empty STD Item."));
		//	return FALSE;
		//}


		//get the same type particle together
		map<int, COTSParticleList> mapSameSTDItemPartList;
		map<int, COTSParticleList>::iterator partListIter;
		this->GetSTDMapedParticleList(a_listParticle, &mapSameSTDItemPartList);
		/*CSTDItemsList listHavePartSTDItem;
		for (auto STDItem : listSTDItem)
		{
			auto partListIter = mapSameSTDItemPartList.find(STDItem->GetSTDId());
			if (partListIter != mapSameSTDItemPartList.end())
			{
				listHavePartSTDItem.push_back(STDItem);
			}
		}*/


		int nColumnNum = ((int)(REPORT_PARTICLE_COMPONENT_GRID_CLUMN::MAX) - (int)(REPORT_PARTICLE_COMPONENT_GRID_CLUMN::MIN) + 1);
		std::vector<CString> listColumnName;
		LoadColumnString(listColumnName, IDS_PARTICLE_COMPONENT_START, nColumnNum);

		if ((int)listColumnName.size() != nColumnNum)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetComponentFromParticleList: Can't get column name number."));
			return FALSE;
		}

		CGridColumnsList listGridColumn;
		COTSParticleList listPartReport;
		for (int i = 0; i < nColumnNum; i++)
		{

			CGridColumnPtr pColumn = CGridColumnPtr(new CGridColumn());
			pColumn->SetName(listColumnName[i]);

			CGridRowsList listGridRows;
			listGridRows.clear();

			switch (i)
			{
			case (int)REPORT_PARTICLE_COMPONENT_GRID_CLUMN::NAME:
			{
				// std item name
				listGridRows.clear();
				for (auto STDPart : mapSameSTDItemPartList)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					std::string name = STDPart.second[0]->TypeName();
					//pGridRow->SetStringValue(STDPart->GetName ());
					pGridRow->SetStringValue(name.c_str());
					listGridRows.push_back(pGridRow);
				}

				auto itr = mapSameSTDItemPartList.find((int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED);
				if (itr != mapSameSTDItemPartList.end())
				{
					CGridRowPtr pGridRowUndefined = CGridRowPtr(new CGridRow());
					pGridRowUndefined->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					CString strUndefined;
					strUndefined = MultiLang::GetInstance().GetCStringByKey(IDS_UNDEFINED_PARTICLE);
					pGridRowUndefined->SetStringValue(strUndefined);
					listGridRows.push_back(pGridRowUndefined);
				}

				auto itrSiC = mapSameSTDItemPartList.find((int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_SIC);
				if (itrSiC != mapSameSTDItemPartList.end())
				{
					CGridRowPtr pGridRowSiC = CGridRowPtr(new CGridRow());
					pGridRowSiC->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					CString strSiC;
					strSiC = MultiLang::GetInstance().GetCStringByKey(IDS_SIC);
					pGridRowSiC->SetStringValue(strSiC);
					listGridRows.push_back(pGridRowSiC);
				}

				auto itrFeO = mapSameSTDItemPartList.find((int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_FEO);
				if (itrFeO != mapSameSTDItemPartList.end())
				{
					CGridRowPtr pGridRowFeO = CGridRowPtr(new CGridRow());
					pGridRowFeO->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					CString strFeO;
					strFeO = MultiLang::GetInstance().GetCStringByKey(IDS_FEO);
					pGridRowFeO->SetStringValue(strFeO);
					listGridRows.push_back(pGridRowFeO);
				}
			}
			break;
			case (int)REPORT_PARTICLE_COMPONENT_GRID_CLUMN::COLOUR:
			{
				// std item color
				listGridRows.clear();
				for (auto STDPart : mapSameSTDItemPartList)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					std::string color = STDPart.second[0]->TypeColor();
					pGridRow->SetStringValue(color.c_str());
					listGridRows.push_back(pGridRow);
				}
				auto itr = mapSameSTDItemPartList.find((int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED);
				if (itr != mapSameSTDItemPartList.end())
				{

					CGridRowPtr pGridRowUndefined = CGridRowPtr(new CGridRow());
					pGridRowUndefined->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					CString strUndefinedColour = _T("");
					pGridRowUndefined->SetStringValue(strUndefinedColour);
					listGridRows.push_back(pGridRowUndefined);
				}

				auto itrSiC = mapSameSTDItemPartList.find((int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_SIC);
				if (itrSiC != mapSameSTDItemPartList.end())
				{
					CGridRowPtr pGridRowSiC = CGridRowPtr(new CGridRow());
					pGridRowSiC->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					CString strSiCColour = _T("");
					pGridRowSiC->SetStringValue(strSiCColour);
					listGridRows.push_back(pGridRowSiC);
				}

				auto itrFeO = mapSameSTDItemPartList.find((int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_FEO);
				if (itrFeO != mapSameSTDItemPartList.end())
				{
					CGridRowPtr pGridRowFeO = CGridRowPtr(new CGridRow());
					pGridRowFeO->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					CString strFeOColour = _T("");
					pGridRowFeO->SetStringValue(strFeOColour);
					listGridRows.push_back(pGridRowFeO);
				}
			}
			break;
			case (int)REPORT_PARTICLE_COMPONENT_GRID_CLUMN::PARTICLE_NUM:
			{	// get each type particle num

				int nParticleUndefined = 0;
				int nParticleSiC = 0;
				int nParticleFeO = 0;
				for (auto pSTDItem : mapSameSTDItemPartList)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);

					int nParticleNum = pSTDItem.second.size();



					pGridRow->SetIntValue(nParticleNum);
					listGridRows.push_back(pGridRow);
				}

				CGridRowPtr pGridRowUndefined = CGridRowPtr(new CGridRow());
				pGridRowUndefined->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				auto itr = mapSameSTDItemPartList.find((int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED);
				if (itr != mapSameSTDItemPartList.end())
				{
					nParticleUndefined = itr->second.size();
				}
				else
				{
					nParticleUndefined = 0;
				}

				if (0 != nParticleUndefined)
				{
					pGridRowUndefined->SetIntValue(nParticleUndefined);
					listGridRows.push_back(pGridRowUndefined);
				}

				CGridRowPtr pGridRowSiC = CGridRowPtr(new CGridRow());
				pGridRowSiC->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				auto itrSiC = mapSameSTDItemPartList.find((int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_SIC);
				if (itrSiC != mapSameSTDItemPartList.end())
				{
					nParticleSiC = itrSiC->second.size();
				}
				else
				{
					nParticleSiC = 0;
				}

				if (0 != nParticleSiC)
				{
					pGridRowSiC->SetIntValue(nParticleSiC);
					listGridRows.push_back(pGridRowSiC);
				}

				CGridRowPtr pGridRowFeO = CGridRowPtr(new CGridRow());
				pGridRowFeO->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				auto itrFeO = mapSameSTDItemPartList.find((int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_FEO);
				if (itrFeO != mapSameSTDItemPartList.end())
				{
					nParticleFeO = itrFeO->second.size();
				}
				else
				{
					nParticleFeO = 0;
				}

				if (0 != nParticleFeO)
				{
					pGridRowFeO->SetIntValue(nParticleFeO);
					listGridRows.push_back(pGridRowFeO);
				}


			}
			break;

			case (int)REPORT_PARTICLE_COMPONENT_GRID_CLUMN::AVE_VALUE:
			{
				// get particle average area					
				int nParticleUndefined = 0;

				double dAveValueUndefined = 0;

				int nParticleSiC = 0;
				double dAveValueSiC = 0;

				int nParticleFeO = 0;
				double dAveValueFeO = 0;

				for (auto pSTDPart : mapSameSTDItemPartList)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);

					int nParticleNum = 0;

					double dAveValue = 0;



					COTSParticleList listPartReport = pSTDPart.second;
					for (auto pParticle : listPartReport)
					{

						double dValue = GetValueAsMethod(pParticle, a_nMethod, a_dPixelSize);
						nParticleNum++;

						dAveValue += dValue;
					}

					if (nParticleNum != 0)
					{
						dAveValue = dAveValue / (double)nParticleNum;

					}

					pGridRow->SetDoubleValue(dAveValue);
					listGridRows.push_back(pGridRow);
				}

				CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
				pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
				auto itr = mapSameSTDItemPartList.find((int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED);
				if (itr != mapSameSTDItemPartList.end())
				{
					nParticleUndefined = itr->second.size();
					listPartReport = itr->second;
				}
				else
				{
					nParticleUndefined = 0;
				}


				if (nParticleUndefined != 0)
				{

					for (auto pParticle : listPartReport)
					{
						double dValue = GetValueAsMethod(pParticle, a_nMethod, a_dPixelSize);
						dAveValueUndefined += dValue;
					}
					if (nParticleUndefined != 0)
					{
						dAveValueUndefined = dAveValueUndefined / (double)nParticleUndefined;
					}
					pGridRow->SetDoubleValue(dAveValueUndefined);
					listGridRows.push_back(pGridRow);
				}


				CGridRowPtr pGridRowSiC = CGridRowPtr(new CGridRow());
				pGridRowSiC->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
				auto itrSiC = mapSameSTDItemPartList.find((int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_SIC);
				if (itrSiC != mapSameSTDItemPartList.end())
				{
					nParticleSiC = itrSiC->second.size();
					listPartReport = itrSiC->second;
				}
				else
				{
					nParticleSiC = 0;
				}

				if (nParticleSiC != 0)
				{
					for (auto pParticle : listPartReport)
					{
						double dValue = GetValueAsMethod(pParticle, a_nMethod, a_dPixelSize);
						dAveValueSiC += dValue;
					}
					if (nParticleSiC != 0)
					{
						dAveValueSiC = dAveValueSiC / (double)nParticleSiC;
					}
					pGridRowSiC->SetDoubleValue(dAveValueSiC);
					listGridRows.push_back(pGridRowSiC);
				}

				CGridRowPtr pGridRowFeO = CGridRowPtr(new CGridRow());
				pGridRowFeO->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
				auto itrFeO = mapSameSTDItemPartList.find((int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_FEO);
				if (itrFeO != mapSameSTDItemPartList.end())
				{
					nParticleFeO = itrFeO->second.size();
					listPartReport = itrFeO->second;
				}
				else
				{
					nParticleFeO = 0;
				}

				if (nParticleFeO != 0)
				{
					for (auto pParticle : listPartReport)
					{
						double dValue = GetValueAsMethod(pParticle, a_nMethod, a_dPixelSize);
						dAveValueFeO += dValue;
					}
					if (nParticleFeO != 0)
					{
						dAveValueFeO = dAveValueFeO / (double)nParticleFeO;
					}

					pGridRowFeO->SetDoubleValue(dAveValueFeO);
					listGridRows.push_back(pGridRowFeO);
				}
			}
			break;

			case (int)REPORT_PARTICLE_COMPONENT_GRID_CLUMN::MAX_VALUE:
			{
				// get particle max area				

				double dMaxValueUndefined = 0;
				double dMaxValueSiC = 0;
				double dMaxValueFeO = 0;
				double dMaxValue = 0;
				for (auto pSTDPart : mapSameSTDItemPartList)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);

					dMaxValue = 0;

					COTSParticleList listPartReport = pSTDPart.second;
					for (auto pParticle : listPartReport)
					{

						double dValue = GetValueAsMethod(pParticle, a_nMethod, a_dPixelSize);
						if (dValue > dMaxValue)
						{
							dMaxValue = dValue;
						}
					}


					pGridRow->SetDoubleValue(dMaxValue);
					listGridRows.push_back(pGridRow);
				}


				CGridRowPtr pGridRowUndefined = CGridRowPtr(new CGridRow());
				pGridRowUndefined->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
				auto itr = mapSameSTDItemPartList.find((int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED);
				listPartReport.clear();
				if (itr != mapSameSTDItemPartList.end())
				{
					listPartReport = itr->second;
				}

				for (auto pParticle : listPartReport)
				{

					double dValue = GetValueAsMethod(pParticle, a_nMethod, a_dPixelSize);
					if (dValue > dMaxValueUndefined)
					{

						dMaxValueUndefined = dValue;
					}
				}


				if (itr != mapSameSTDItemPartList.end())
				{
					pGridRowUndefined->SetDoubleValue(dMaxValueUndefined);
					listGridRows.push_back(pGridRowUndefined);
				}

				CGridRowPtr pGridRowSiC = CGridRowPtr(new CGridRow());
				pGridRowSiC->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
				auto itrSiC = mapSameSTDItemPartList.find((int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_SIC);
				listPartReport.clear();
				if (itrSiC != mapSameSTDItemPartList.end())
				{
					listPartReport = itrSiC->second;
				}

				for (auto pParticle : listPartReport)
				{
					double dValue = GetValueAsMethod(pParticle, a_nMethod, a_dPixelSize);
					if (dValue > dMaxValueSiC)
					{
						dMaxValueSiC = dValue;
					}
				}

				if (itrSiC != mapSameSTDItemPartList.end())
				{
					pGridRowSiC->SetDoubleValue(dMaxValueSiC);
					listGridRows.push_back(pGridRowSiC);
				}

				CGridRowPtr pGridRowFeO = CGridRowPtr(new CGridRow());
				pGridRowFeO->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
				auto itrFeO = mapSameSTDItemPartList.find((int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_FEO);
				listPartReport.clear();
				if (itrFeO != mapSameSTDItemPartList.end())
				{
					listPartReport = itrFeO->second;
				}

				for (auto pParticle : listPartReport)
				{
					double dValue = GetValueAsMethod(pParticle, a_nMethod, a_dPixelSize);
					if (dValue > dMaxValueFeO)
					{
						dMaxValueFeO = dValue;
					}
				}

				if (itrFeO != mapSameSTDItemPartList.end())
				{
					pGridRowFeO->SetDoubleValue(dMaxValueFeO);
					listGridRows.push_back(pGridRowFeO);
				}
			}
			break;
			}

			pColumn->SetGridRowsList(listGridRows);

			listGridColumn.push_back(pColumn);
		}


		a_pGridData->SetGridColumnList(listGridColumn);
		return TRUE;
	}

	// compute element component
	CGridDatasList CReportProjFileMgr::CompElementComponent()
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		CGridDatasList listGridData;
		listGridData.clear();


		std::vector<CString> listDataSource = m_CurrentPropParam->GetDataSourceList();
		int nSelectedDataSourceIndex = m_CurrentPropParam->GetDataSourceId();
		CString sDataSourceNames = listDataSource[nSelectedDataSourceIndex];
		std::vector<CString> listSelectedDataSource = COTSHelper::SplitString(sDataSourceNames, _T("+"));
		//int nIndex = 0;
		for (auto strDataSourceName : listSelectedDataSource)
		{

			CGridDataPtr pGridData = CGridDataPtr(new CGridData());

			// data source id

			pGridData->SetDataSourceList(m_CurrentPropParam->GetDataSourceList());


			pGridData->SetDataSourceId(m_CurrentPropParam->GetDataSourceId());

			COTSParticleList listParticleAll;
			listParticleAll.clear();

			CPosXraysList listXrayOut;
			listXrayOut.clear();

			CPosXraysList listXray;
			listXray.clear();


			listXrayOut = GetAnalysisXrayList(strDataSourceName);

			if (m_CurrentPropParam->GetDataSourceType() == DATA_SOURCE_TYPE::ALL)
			{

				listParticleAll = GetAnalysisParticleList(strDataSourceName);

				for (auto pXray : listXrayOut)
				{
					CPosXrayPtr pXrayNew = CPosXrayPtr(new CPosXray(*pXray.get()));
					listXray.push_back(pXrayNew);
				}
			}
			else if (m_CurrentPropParam->GetDataSourceType() == DATA_SOURCE_TYPE::SELECTION)
			{
				listParticleAll = m_CurrentPropParam->GetSelectParticle();

				for (auto pParticle : listParticleAll)
				{
					int nIndex = pParticle->GetAnalysisId();
					int nField = pParticle->GetFieldId();

					auto itr = std::find_if(listXrayOut.begin(), listXrayOut.end(), [nIndex, nField](CPosXrayPtr p) { return (p->GetIndex() == nIndex && p->GetScanFieldId() == nField); });
					if (itr == listXrayOut.end())
					{
						continue;
					}
					else
					{
						CPosXrayPtr pXray = *itr;
						CPosXrayPtr pXrayNew = CPosXrayPtr(new CPosXray(*pXray.get()));
						listXray.push_back(pXrayNew);
					}
				}
			}

			if (!GetElementComponentFromParticleList(listParticleAll, listXray, pGridData))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompParticleComponent: can't get general information."));
				return listGridData;
			}

			listGridData.push_back(pGridData);

		}

		return listGridData;
	}

	BOOL CReportProjFileMgr::GetElementComponentFromParticleList(COTSParticleList a_listParticleAll, CPosXraysList a_listXray, CGridDataPtr a_pGridData)
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		ASSERT(a_pGridData);
		if (!a_pGridData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetElementComponentFromParticleList: invalid grid data pointer."));
			return FALSE;
		}

		// std
		ASSERT(m_pReportProjFile);
		if (!m_pReportProjFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetElementComponentFromParticleList: empty project file."));
			return FALSE;
		}

		int nColumnNum = ((int)(REPORT_ELEMENT_COMPONENT_GRID_CLUMN::MAX) - (int)(REPORT_ELEMENT_COMPONENT_GRID_CLUMN::MIN) + 1);
		std::vector<CString> listColumnName;
		LoadColumnString(listColumnName, IDS_ELEMENT_COMPONENT_START, nColumnNum);

		if ((int)listColumnName.size() != nColumnNum)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetElementComponentFromParticleList: Can't get column name number."));
			return FALSE;
		}

		COTSParticleList listParticleAnalysis;
		listParticleAnalysis.clear();

		for (auto pParticle : a_listParticleAll)
		{
			int nType = pParticle->GetType();
			if (nType >= (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_SIC)
			{
				COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
				listParticleAnalysis.push_back(pParticleNew);
			}
		}

		CElementChemistriesList listElementResult = GetUndefinedElementList(listParticleAnalysis, a_listXray);

		//Draw the grid
		CGridColumnsList listGridColumn;

		for (int i = 0; i < nColumnNum; i++)
		{
			CGridColumnPtr pColumn = CGridColumnPtr(new CGridColumn());
			pColumn->SetName(listColumnName[i]);

			CGridRowsList listGridRows;
			listGridRows.clear();

			switch (i)
			{
			case (int)REPORT_ELEMENT_COMPONENT_GRID_CLUMN::NAME:
			{	// std item name
				listGridRows.clear();
				for (auto pElement : listElementResult)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					CString strElementName = pElement->GetName();
					pGridRow->SetStringValue(strElementName);
					listGridRows.push_back(pGridRow);
				}
			}
			break;
			case (int)REPORT_ELEMENT_COMPONENT_GRID_CLUMN::NUM:
			{	// std item name
				listGridRows.clear();
				for (auto pElement : listElementResult)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					CString strElementNum = _T("");
					double dPercent = pElement->GetPercentage();
					strElementNum.Format(_T("%f"), dPercent);
					strElementNum += "%";
					pGridRow->SetStringValue(strElementNum);
					listGridRows.push_back(pGridRow);
				}

			}
			break;
			}
			pColumn->SetGridRowsList(listGridRows);

			listGridColumn.push_back(pColumn);
		}

		a_pGridData->SetGridColumnList(listGridColumn);
		return TRUE;
	}

	// compute particle size distribution
	CGridDatasList CReportProjFileMgr::CompParticleSizeDistribution()
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		CGridDatasList listGridData;
		listGridData.clear();


		// depart compound source name
		std::vector<CString> listDataSource = m_CurrentPropParam->GetDataSourceList();
		int nSelectedDataSourceIndex = m_CurrentPropParam->GetDataSourceId();
		CString sDataSourceNames = listDataSource[nSelectedDataSourceIndex];
		std::vector<CString> listSelectedDataSource = COTSHelper::SplitString(sDataSourceNames, _T("+"));
		//int nIndex = 0;
		for (auto strDataSourceName : listSelectedDataSource)
		{

			CGridDataPtr pGridData = CGridDataPtr(new CGridData());

			// data source id
			std::vector<CString> listDataSource;
			listDataSource.clear();
			listDataSource = m_CurrentPropParam->GetDataSourceList();
			pGridData->SetDataSourceList(listDataSource);

			int nDataSourceId = m_CurrentPropParam->GetDataSourceId();
			pGridData->SetDataSourceId(nDataSourceId);
			COTSParticleList* pSelectidParts;
			COTSParticleList listParticleAll;
			COTSParticleList seleParticles;
			// add filter select particle
			if (m_CurrentPropParam->GetDataSourceType() == DATA_SOURCE_TYPE::SELECTION)
			{
				seleParticles = m_CurrentPropParam->GetSelectParticle();
				pSelectidParts = &seleParticles;
			}
			else
			{
				listParticleAll = GetAnalysisParticleList(strDataSourceName);
				pSelectidParts = &listParticleAll;
			}


			//get pixel size
			CSmplMsrResultFileMgrPtr pSmplMsrResultFileMgr = this->GetASmplMsrResultMgrByFileName(strDataSourceName);
			ASSERT(pSmplMsrResultFileMgr);
			if (!pSmplMsrResultFileMgr)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompParticleSizeDistribution: can't get sample result file manager."));
				return listGridData;
			}

			CSmplMsrResultFilePtr pSmplMsrResultFile = pSmplMsrResultFileMgr->GetSmplMsrResultFile();
			ASSERT(pSmplMsrResultFile);
			if (!pSmplMsrResultFile)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompParticleSizeDistribution: can't get sample result file."));
				return listGridData;
			}

			COTSSamplePtr pSample = pSmplMsrResultFile->GetSample();
			if (!pSample)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompParticleSizeDistribution: can't get sample."));
				return listGridData;
			}

			double dPixelSize = pSample->CalculatePixelSize();


			if (!GetSizeDistributionFromParticleList(*pSelectidParts, pGridData, dPixelSize))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompParticleSizeDistribution: can't get general information."));
				return listGridData;
			}

			listGridData.push_back(pGridData);
		}
		return listGridData;
	}

	BOOL CReportProjFileMgr::IsHaveMultiDataSource()
	{
		int nMultiCount = 0;
		for (auto SmplMgr : m_listSmplMgrs)
		{
			CSmplMsrResultFilePtr pSmpl = SmplMgr->GetSmplMsrResultFile();
			if (pSmpl->GetSwitch())
			{
				nMultiCount++;
			}
		}

		if (nMultiCount > 1)
		{
			return TRUE;
		}

		return FALSE;
	}
	BOOL CReportProjFileMgr::GetSizeDistributionFromParticleList(COTSParticleList a_listParticle, CGridDataPtr a_pGridData, double a_dPixelSize)
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		ASSERT(a_pGridData);
		if (!a_pGridData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSizeDistributionFromParticleList: invalid grid data pointer."));
			return FALSE;
		}


		//size
		CPartSizeFilePtr pPartSize = m_CurrentPropParam->GetWorkingSizeFile();
		ASSERT(pPartSize);
		if (!pPartSize)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSizeDistributionFromParticleList: invalid pPartSize data."));
			return FALSE;
		}

		CPartSizeItemList listPartSize = pPartSize->GetPartSizeList();

		if (listPartSize.empty())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSizeDistributionFromParticleList: empty pPartSize Item."));
			return FALSE;
		}

		//get the same type particle together
		map<int, COTSParticleList> mapSameSTDItemPartList;
		map<int, COTSParticleList>::iterator partListIter;
		this->GetSTDMapedParticleList(a_listParticle, &mapSameSTDItemPartList);
		COTSParticleList listNotIdentified;

		for (auto partListIter = mapSameSTDItemPartList.begin(); partListIter != mapSameSTDItemPartList.end(); partListIter++)
		{
			if (partListIter->first == (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED)
			{

				listNotIdentified = partListIter->second;
			}
		}

		COTSParticleList listSiC;
		for (auto partListIter = mapSameSTDItemPartList.begin(); partListIter != mapSameSTDItemPartList.end(); partListIter++)
		{
			if (partListIter->first == (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_SIC)
			{

				listSiC = partListIter->second;
			}
		}

		COTSParticleList listFeO;
		for (auto partListIter = mapSameSTDItemPartList.begin(); partListIter != mapSameSTDItemPartList.end(); partListIter++)
		{
			if (partListIter->first == (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_FEO)
			{

				listFeO = partListIter->second;
			}
		}



		int nColumnNum = ((int)(REPORT_SIZE_DISTRIBUTION_GRID_CLUMN::MAX) - (int)(REPORT_SIZE_DISTRIBUTION_GRID_CLUMN::MIN) + 1);
		std::vector<CString> listColumnName;
		LoadColumnString(listColumnName, IDS_PARTICLE_COMPONENT_START, nColumnNum);

		if ((int)listColumnName.size() != nColumnNum)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetComponentFromParticleList: Can't get column name number."));
			return FALSE;
		}

		CGridColumnsList listGridColumn;

		for (int i = 0; i < nColumnNum; i++)
		{
			CGridColumnPtr pColumn = CGridColumnPtr(new CGridColumn());
			pColumn->SetName(listColumnName[i]);

			CGridRowsList listGridRows;
			listGridRows.clear();

			switch (i)
			{
			case (int)REPORT_SIZE_DISTRIBUTION_GRID_CLUMN::NAME:
			{
				// std item name
				listGridRows.clear();

				for (auto sItemName : mapSameSTDItemPartList)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					pGridRow->SetStringValue(sItemName.second[0]->TypeName().c_str());
					listGridRows.push_back(pGridRow);
				}

				if (!listNotIdentified.empty())
				{
					CGridRowPtr pGridRowUndefined = CGridRowPtr(new CGridRow());
					pGridRowUndefined->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					CString strUndefined;
					strUndefined = MultiLang::GetInstance().GetCStringByKey(IDS_UNDEFINED_PARTICLE);//“未识别颗粒”
					pGridRowUndefined->SetStringValue(strUndefined);
					listGridRows.push_back(pGridRowUndefined);
				}

				if (!listSiC.empty())
				{
					CGridRowPtr pGridRowSiC = CGridRowPtr(new CGridRow());
					pGridRowSiC->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					CString strSIC;
					strSIC = MultiLang::GetInstance().GetCStringByKey(IDS_SIC);//“未识别颗粒SiC”
					pGridRowSiC->SetStringValue(strSIC);
					listGridRows.push_back(pGridRowSiC);
				}

				if (!listFeO.empty())
				{
					CGridRowPtr pGridRowFeO = CGridRowPtr(new CGridRow());
					pGridRowFeO->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					CString strFeO;
					strFeO = MultiLang::GetInstance().GetCStringByKey(IDS_FEO);//“未识别颗粒”
					pGridRowFeO->SetStringValue(strFeO);
					listGridRows.push_back(pGridRowFeO);
				}

				//个数
				CGridRowPtr pGridRowNum = CGridRowPtr(new CGridRow());
				pGridRowNum->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
				CString strNum;
				strNum = MultiLang::GetInstance().GetCStringByKey(IDS_NUM);
				pGridRowNum->SetStringValue(strNum);
				listGridRows.push_back(pGridRowNum);

				break;
			}
			case (int)REPORT_SIZE_DISTRIBUTION_GRID_CLUMN::COLOUR:
			{
				// std item colour
				listGridRows.clear();

				for (auto parts : mapSameSTDItemPartList)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					pGridRow->SetStringValue(parts.second[0]->TypeColor().c_str());
					listGridRows.push_back(pGridRow);
				}

				if (!listNotIdentified.empty())
				{
					CGridRowPtr pGridRowUndefined = CGridRowPtr(new CGridRow());
					pGridRowUndefined->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					CString strUndefinedColour = _T("");
					pGridRowUndefined->SetStringValue(strUndefinedColour);
					listGridRows.push_back(pGridRowUndefined);
				}

				if (!listSiC.empty())
				{
					CGridRowPtr pGridRowSiC = CGridRowPtr(new CGridRow());
					pGridRowSiC->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					CString strSiCColour = _T("");
					pGridRowSiC->SetStringValue(strSiCColour);
					listGridRows.push_back(pGridRowSiC);
				}

				if (!listFeO.empty())
				{
					CGridRowPtr pGridRowFeO = CGridRowPtr(new CGridRow());
					pGridRowFeO->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					CString strFeOColour = _T("");
					pGridRowFeO->SetStringValue(strFeOColour);
					listGridRows.push_back(pGridRowFeO);
				}

				//颜色行补齐行
				CGridRowPtr pGridRowNum = CGridRowPtr(new CGridRow());
				pGridRowNum->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
				CString strColorNumber = _T("");
				pGridRowNum->SetStringValue(strColorNumber);
				listGridRows.push_back(pGridRowNum);

				break;
			}
			}

			pColumn->SetGridRowsList(listGridRows);

			listGridColumn.push_back(pColumn);
		}


		//ParticleAmount
		double dParticleAmount = 0;
		for (unsigned int i = 0; i < a_listParticle.size(); i++)
		{
			if (a_listParticle[i]->GetAnalysisId() > -1)
				dParticleAmount++;
		}


		//add item
		for (auto partsizeItem : listPartSize)
		{
			CDoubleRangePtr level = partsizeItem->GetSizeLevel();
			double dStart = level->GetStart();
			double dEnd = level->GetEnd();
			CString ColumnName = _T("");
			//ColumnName = dStart + "-" + dEnd;
			ColumnName = partsizeItem->GetName();
			CGridColumnPtr pColumn = CGridColumnPtr(new CGridColumn());
			pColumn->SetName(ColumnName);
			double dColumnAmount = 0;
			CGridRowsList listGridRows;
			listGridRows.clear();

			int nTypeId;
			double dParticleUndefined = (double)listNotIdentified.size();
			double dParticleSiC = (double)listNotIdentified.size();
			double dParticleFeO = (double)listNotIdentified.size();
			for (auto pSTDPart : mapSameSTDItemPartList)
			{

				CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
				pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				bool bAdd = true;
				double dParticleNum = 0;

				for (auto pParticle : pSTDPart.second)
				{
					SIZE_CAL_METHOD_TYPE Method = m_CurrentPropParam->GetSizeCalMethodType();
					double  dValue = GetValueAsMethod(pParticle, Method, a_dPixelSize);

					if (dValue >= dStart && dValue < dEnd)
					{
						dParticleNum++;
					}
				}

				pGridRow->SetIntValue((int)dParticleNum);
				listGridRows.push_back(pGridRow);
				dColumnAmount += dParticleNum;
			}

			if (!listNotIdentified.empty())
			{
				CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
				pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				double dParticleNumCount = 0;
				for (auto undefinedPart : listNotIdentified)
				{
					SIZE_CAL_METHOD_TYPE Method = m_CurrentPropParam->GetSizeCalMethodType();
					double  dValue = GetValueAsMethod(undefinedPart, Method, a_dPixelSize);

					if (dValue >= dStart && dValue < dEnd)
					{
						dParticleNumCount++;
					}
				}
				pGridRow->SetIntValue((int)dParticleNumCount);
				listGridRows.push_back(pGridRow);
				dColumnAmount += dParticleNumCount;
			}
			//percent
			if (!listSiC.empty())
			{
				CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
				pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				int dParticleNumCount = 0;
				for (auto undefinedPart : listSiC)
				{
					SIZE_CAL_METHOD_TYPE Method = m_CurrentPropParam->GetSizeCalMethodType();
					double  dValue = GetValueAsMethod(undefinedPart, Method, a_dPixelSize);

					if (dValue >= dStart && dValue < dEnd)
					{
						dParticleNumCount++;
					}
				}
				pGridRow->SetIntValue((int)dParticleNumCount);
				listGridRows.push_back(pGridRow);
				dColumnAmount += dParticleNumCount;
			}

			//percent
			if (!listFeO.empty())
			{
				CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
				pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				int dParticleNumCount = 0;
				for (auto undefinedPart : listFeO)
				{
					SIZE_CAL_METHOD_TYPE Method = m_CurrentPropParam->GetSizeCalMethodType();
					double  dValue = GetValueAsMethod(undefinedPart, Method, a_dPixelSize);

					if (dValue >= dStart && dValue < dEnd)
					{
						dParticleNumCount++;
					}
				}
				pGridRow->SetIntValue((int)dParticleNumCount);
				listGridRows.push_back(pGridRow);
				dColumnAmount += dParticleNumCount;
			}

			CGridRowPtr pGridRow2 = CGridRowPtr(new CGridRow());
			pGridRow2->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
			double dAPercent = dColumnAmount / dParticleAmount;
			char cColumnAmount[256];
			sprintf(cColumnAmount, "%.0lf", dColumnAmount);
			char cRes[256];
			sprintf(cRes, "%.2lf%%\n", dAPercent * 100);
			CString strResult = cRes;
			strResult = "" + (CString)cColumnAmount + "(" + strResult + ")";
			pGridRow2->SetStringValue(strResult);
			listGridRows.push_back(pGridRow2);

			//addcolum
			pColumn->SetGridRowsList(listGridRows);

			listGridColumn.push_back(pColumn);

		}
		a_pGridData->SetGridColumnList(listGridColumn);

		return TRUE;
	}

	// compute average element component
	CGridDatasList CReportProjFileMgr::CompAveElemnetComponent()
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		CGridDatasList listGridData;
		listGridData.clear();


		// depart compound source name

		std::vector<CString> listDataSource = m_CurrentPropParam->GetDataSourceList();
		int nSelectedDataSourceIndex = m_CurrentPropParam->GetDataSourceId();
		CString sDataSourceNames = listDataSource[nSelectedDataSourceIndex];
		std::vector<CString> listSelectedDataSource = COTSHelper::SplitString(sDataSourceNames, _T("+"));
		//int nIndex = 0;
		for (auto strDataSourceName : listSelectedDataSource)
		{

			CGridDataPtr pGridData = CGridDataPtr(new CGridData());

			// data source id
			std::vector<CString> listDataSource;
			listDataSource.clear();
			listDataSource = m_CurrentPropParam->GetDataSourceList();
			pGridData->SetDataSourceList(listDataSource);

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

			COTSParticleList listParticleAll;
			listParticleAll.clear();

			CPosXraysList listXrayOut;
			listXrayOut.clear();

			CPosXraysList listXray;
			listXray.clear();


			listXrayOut = GetAnalysisXrayList(strDataSourceName);

			if (m_CurrentPropParam->GetDataSourceType() == DATA_SOURCE_TYPE::ALL)
			{

				listParticleAll = GetAnalysisParticleList(strDataSourceName);


				for (auto pXray : listXrayOut)
				{
					CPosXrayPtr pXrayNew = CPosXrayPtr(new CPosXray(*pXray.get()));
					listXray.push_back(pXrayNew);
				}
			}
			else if (m_CurrentPropParam->GetDataSourceType() == DATA_SOURCE_TYPE::SELECTION)
			{
				listParticleAll = m_CurrentPropParam->GetSelectParticle();

				for (auto pParticle : listParticleAll)
				{
					int nIndex = pParticle->GetAnalysisId();
					int nField = pParticle->GetFieldId();

					auto itr = std::find_if(listXrayOut.begin(), listXrayOut.end(), [nIndex, nField](CPosXrayPtr p) { return (p->GetIndex() == nIndex && p->GetScanFieldId() == nField); });
					if (itr == listXrayOut.end())
					{
						continue;
					}
					else
					{
						CPosXrayPtr pXray = *itr;
						CPosXrayPtr pXrayNew = CPosXrayPtr(new CPosXray(*pXray.get()));
						listXray.push_back(pXrayNew);
					}
				}
			}

			if (!GetAveElementFromParticleList(listParticleAll, listXray, pGridData))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompParticleComponent: can't get general information."));
				return listGridData;
			}

			listGridData.push_back(pGridData);
			//nIndex++;
		}

		return listGridData;
	}

	BOOL CReportProjFileMgr::GetAveElementFromParticleList(COTSParticleList a_listParticleAll, CPosXraysList a_listXray, CGridDataPtr a_pGridData)
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		ASSERT(a_pGridData);
		if (!a_pGridData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetAveElementFromParticleList: invalid grid data pointer."));
			return FALSE;
		}

		// std
		ASSERT(m_pReportProjFile);
		if (!m_pReportProjFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetAveElementFromParticleList: empty project file."));
			return FALSE;
		}



		std::set<int> allTypeIds;
		allTypeIds.clear();

		COTSParticleList listNotIdentifiedParticle;
		listNotIdentifiedParticle.clear();

		COTSParticleList listSiCParticle;
		listSiCParticle.clear();

		COTSParticleList listFeOParticle;
		listFeOParticle.clear();

		COTSParticleList listIdentifiedParticle;
		listIdentifiedParticle.clear();

		std::vector<CElementChemistriesList> listElementChemistriesList;
		listElementChemistriesList.clear();

		for (auto pParticle : a_listParticleAll)
		{
			int nType = (int)pParticle->GetType();

			// get undefined particle and analysis particle
			if (nType >= (int)OTS_PARTCLE_TYPE::NO_ANALYSIS_X_RAY)
			{
				COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
				if (nType == (int)OTS_PARTCLE_TYPE::NO_ANALYSIS_X_RAY)//不与考虑
				{
					//listNoAnalysisParticle.push_back(pParticleNew);
				}
				else if (nType == (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED)
				{
					listNotIdentifiedParticle.push_back(pParticleNew);

				}
				else if (nType == (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_SIC)
				{
					listSiCParticle.push_back(pParticleNew);

				}
				else if (nType == (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_FEO)
				{
					listFeOParticle.push_back(pParticleNew);

				}
				else if (nType >= (int)OTS_PARTCLE_TYPE::USER_DEFINED_MIN)//类型ID号至少1000以上
				{
					listIdentifiedParticle.push_back(pParticleNew);

					allTypeIds.insert(nType);

				}
			}

		}

		//CPartSTDDataPtr pPartSTDData = m_pReportProjFile->GetPartSTDData();
		//ASSERT(pPartSTDData);
		//if (!pPartSTDData)
		//{
		//	LogErrorTrace(__FILE__, __LINE__, _T("GetSizeDistributionFromParticleList: invalid STD data."));
		//	return FALSE;
		//}
		//CSTDItemsList listSTDItem = pPartSTDData->GetSTDItemsList();

		//if (listSTDItem.empty())
		//{
		//	LogErrorTrace(__FILE__, __LINE__, _T("GetSizeDistributionFromParticleList: empty STD Item."));
		//	return FALSE;
		//}
		COTSParticleList listPartReport;
		//get the same type particle together
		map<int, COTSParticleList> mapSameSTDItemPartList;
		map<int, COTSParticleList>::iterator partListIter;
		this->GetSTDMapedParticleList(a_listParticleAll, &mapSameSTDItemPartList);



		// make the first two columns: particle type and area
		CGridColumnsList listGridColumn;

		CGridRowsList listParticleGridRows;
		listParticleGridRows.clear();

		CGridRowsList listAreaGridRows;
		listAreaGridRows.clear();

		COTSParticleList listParticleType;
		COTSParticleList particlesOfThisType;
		listParticleType.clear();
		particlesOfThisType.clear();
		double dAreaTotal = 0;
		for (auto typeId : allTypeIds)
		{
			auto iterParts = mapSameSTDItemPartList.find(typeId);
			if (iterParts == mapSameSTDItemPartList.end())
			{
				continue;
			}
			else
			{
				particlesOfThisType = iterParts->second;
			}


			CGridRowPtr pParticleGridRow = CGridRowPtr(new CGridRow());
			pParticleGridRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);

			//CSTDItemPtr  STDItem = GetParticleSTDItem(typeId);
			//CSTDItemPtr  STDItem = particlesOfThisType[0]->TypeName();
			CString strPartName = particlesOfThisType[0]->TypeName().c_str();
			pParticleGridRow->SetStringValue(strPartName);
			listParticleGridRows.push_back(pParticleGridRow);

			CGridRowPtr pAreaGridRow = CGridRowPtr(new CGridRow());
			pAreaGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);


			double dArea = 0;
			for (auto pPatTp : particlesOfThisType)
			{
				double dAreaC = pPatTp->GetArea();

				dArea += dAreaC;
			}
			pAreaGridRow->SetDoubleValue(dArea);
			listAreaGridRows.push_back(pAreaGridRow);
			dAreaTotal += dArea;

			// compute Element
			COTSParticlePtr pParticle = particlesOfThisType[0];
			COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
			listParticleType.push_back(pParticleNew);

			int XrayId = pParticle->GetAnalysisId();
			if (XrayId < 0 || XrayId >(int)a_listXray.size())
			{
				continue;
			}

			int nFieldId = pParticle->GetFieldId();
			auto itr = std::find_if(a_listXray.begin(), a_listXray.end(), [XrayId, nFieldId](CPosXrayPtr p) { return ((p->GetScanFieldId() == nFieldId) && (p->GetIndex() == XrayId)); });
			if (itr == a_listXray.end())
			{
				LogErrorTrace(__FILE__, __LINE__, _T("GetAveElementFromParticleList: can't find x-ray."));
				return FALSE;
			}

			CPosXrayPtr pXray = *itr;

			CElementChemistriesList listTpElement = pXray->GetElementQuantifyData();
			listElementChemistriesList.push_back(listTpElement);

		}

		//undefined particle area
		double dAreaNotIden = 0;
		for (auto pPUn : listNotIdentifiedParticle)
		{
			double dA = pPUn->GetArea();
			dAreaNotIden += dA;
		}
		dAreaTotal += dAreaNotIden;

		double dAreaSiC = 0;
		for (auto pPUn : listSiCParticle)
		{
			double dA = pPUn->GetArea();
			dAreaSiC += dA;
		}
		dAreaTotal += dAreaSiC;

		double dAreaFeO = 0;
		for (auto pPUn : listFeOParticle)
		{
			double dA = pPUn->GetArea();
			dAreaFeO += dA;
		}
		dAreaTotal += dAreaFeO;

		// area row of undefined and total analysis 

		if (!listNotIdentifiedParticle.empty())
		{
			CGridRowPtr pAreaGridRow = CGridRowPtr(new CGridRow());
			pAreaGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
			pAreaGridRow->SetDoubleValue(dAreaNotIden);
			listAreaGridRows.push_back(pAreaGridRow);
		}

		if (!listSiCParticle.empty())
		{
			CGridRowPtr pAreaSiCGridRow = CGridRowPtr(new CGridRow());
			pAreaSiCGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
			pAreaSiCGridRow->SetDoubleValue(dAreaSiC);
			listAreaGridRows.push_back(pAreaSiCGridRow);
		}

		if (!listFeOParticle.empty())
		{
			CGridRowPtr pAreaFeOGridRow = CGridRowPtr(new CGridRow());
			pAreaFeOGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
			pAreaFeOGridRow->SetDoubleValue(dAreaFeO);
			listAreaGridRows.push_back(pAreaFeOGridRow);
		}

		CGridRowPtr pAreaToTalGridRow = CGridRowPtr(new CGridRow());
		pAreaToTalGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
		pAreaToTalGridRow->SetDoubleValue(dAreaTotal);
		listAreaGridRows.push_back(pAreaToTalGridRow);

		// particle type of undefined and analysis particle
		if (!listNotIdentifiedParticle.empty())
		{
			CGridRowPtr pParticleGridRow = CGridRowPtr(new CGridRow());
			pParticleGridRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
			CString strUndefineName = _T("");
			strUndefineName = MultiLang::GetInstance().GetCStringByKey(IDS_PARTICL_UNDEFINED);
			pParticleGridRow->SetStringValue(strUndefineName);
			listParticleGridRows.push_back(pParticleGridRow);
		}

		if (!listSiCParticle.empty())
		{
			CGridRowPtr pParticleSiCGridRow = CGridRowPtr(new CGridRow());
			pParticleSiCGridRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
			CString strSiCName = _T("");
			strSiCName = MultiLang::GetInstance().GetCStringByKey(IDS_SIC);
			pParticleSiCGridRow->SetStringValue(strSiCName);
			listParticleGridRows.push_back(pParticleSiCGridRow);
		}

		if (!listFeOParticle.empty())
		{
			CGridRowPtr pParticleFeOGridRow = CGridRowPtr(new CGridRow());
			pParticleFeOGridRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
			CString strFeOName = _T("");
			strFeOName = MultiLang::GetInstance().GetCStringByKey(IDS_FEO);
			pParticleFeOGridRow->SetStringValue(strFeOName);
			listParticleGridRows.push_back(pParticleFeOGridRow);
		}

		CGridRowPtr pParticleAGridRow = CGridRowPtr(new CGridRow());
		pParticleAGridRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
		CString strAnalysisdName = _T("");
		strAnalysisdName = MultiLang::GetInstance().GetCStringByKey(IDS_PARTICL_ANALYSIS);
		pParticleAGridRow->SetStringValue(strAnalysisdName);
		listParticleGridRows.push_back(pParticleAGridRow);

		if (!((int)listParticleGridRows.size() == (int)listAreaGridRows.size()))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetAveElementFromParticleList: particle num and area num are different."));
			return FALSE;
		}

		// column name of particle type and area
		int nColumnNum = ((int)(REPORT_AVE_ELEMENT_GRID_CLUMN::MAX) - (int)(REPORT_AVE_ELEMENT_GRID_CLUMN::MIN) + 1);
		std::vector<CString> listColumnName;
		LoadColumnString(listColumnName, IDS_AVE_ELEMENT_START, nColumnNum);

		// particle type
		CGridColumnPtr pParticleColumn = CGridColumnPtr(new CGridColumn());
		pParticleColumn->SetName(listColumnName[0]);
		pParticleColumn->SetGridRowsList(listParticleGridRows);

		// area
		CGridColumnPtr pAreaColumn = CGridColumnPtr(new CGridColumn());
		pAreaColumn->SetName(listColumnName[1]);
		pAreaColumn->SetGridRowsList(listAreaGridRows);

		listGridColumn.push_back(pParticleColumn);
		listGridColumn.push_back(pAreaColumn);

		// get element area list from particle list
		CElementChemistriesList listUndefinedElement;
		if (!listNotIdentifiedParticle.empty())
		{
			listUndefinedElement = GetUndefinedElementList(listNotIdentifiedParticle, a_listXray);
			listElementChemistriesList.push_back(listUndefinedElement);
		}
		// get element area list from particle list
		CElementChemistriesList listSiCElement;
		if (!listSiCParticle.empty())
		{
			listSiCElement = GetUndefinedElementList(listSiCParticle, a_listXray);
			listElementChemistriesList.push_back(listSiCElement);
		}

		CElementChemistriesList listFeOElement;
		if (!listFeOParticle.empty())
		{
			listFeOElement = GetUndefinedElementList(listFeOParticle, a_listXray);
			listElementChemistriesList.push_back(listFeOElement);
		}

		std::vector<CString> listElementName;
		listElementName.clear();

		for (auto listElement : listElementChemistriesList)
		{
			for (auto pElement : listElement)
			{
				CString strElementName = pElement->GetName();
				if (strElementName.Compare("Fe") == 0)
				{
					continue;
				}
				auto itr = std::find(listElementName.begin(), listElementName.end(), strElementName);
				if (itr == listElementName.end())
				{
					listElementName.push_back(strElementName);
				}
			}
		}

		for (auto strName : listElementName)
		{
			//2020-2-17修改，c元素不再包含显示在元素列表中，并将显示的其它元素重新进行归一化。
			if (strName == "C")
				continue;

			// particle type
			CGridColumnPtr pElementColumn = CGridColumnPtr(new CGridColumn());
			pElementColumn->SetName(strName);

			CGridRowsList listElementGridRows;
			listElementGridRows.clear();

			double dTotalArea = 0.0;
			int nRowNum = 0;

			// analysis particle
			for (auto pParticle : listParticleType)
			{
				CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
				pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);

				int XrayId = pParticle->GetAnalysisId();
				if (XrayId < 0 || XrayId >(int)a_listXray.size())
				{
					LogErrorTrace(__FILE__, __LINE__, _T("GetAveElementFromParticleList: can't get x ray."));
					return FALSE;
				}

				int nFieldId = pParticle->GetFieldId();
				auto itr = std::find_if(a_listXray.begin(), a_listXray.end(), [XrayId, nFieldId](CPosXrayPtr p) { return ((p->GetScanFieldId() == nFieldId) && (p->GetIndex() == XrayId)); });
				if (itr == a_listXray.end())
				{
					LogErrorTrace(__FILE__, __LINE__, _T("GetAveElementFromParticleList: can't find x-ray."));
					return FALSE;
				}

				CPosXrayPtr pXray = *itr;

				CElementChemistriesList listTpElement = pXray->GetElementQuantifyData();

				auto itrE = std::find_if(listTpElement.begin(), listTpElement.end(), [strName](CElementChemistryPtr p) { return p->GetName().CompareNoCase(strName) == 0; });
				if (itrE == listTpElement.end())
				{
					pGridRow->SetDoubleValue(0.0);
				}
				else
				{
					CElementChemistriesList listElementNoFe = CPosXray::RemoveFe(listTpElement);
					auto itr = std::find_if(listElementNoFe.begin(), listElementNoFe.end(), [strName](CElementChemistryPtr p) { return p->GetName().CompareNoCase(strName) == 0; });
					if (itr == listElementNoFe.end())
					{
						pGridRow->SetDoubleValue(0.0);
					}
					else
					{
						CElementChemistryPtr pElement = *itr;
						double dPercent = pElement->GetPercentage();
						pGridRow->SetDoubleValue(dPercent);

						if (nRowNum < 0 || nRowNum >(int) listAreaGridRows.size())
						{
							LogErrorTrace(__FILE__, __LINE__, _T("GetAveElementFromParticleList: can't get area."));
							return FALSE;
						}

						dTotalArea += listAreaGridRows[nRowNum]->GetDoubleValue() * dPercent;
					}
				}

				nRowNum++;
				listElementGridRows.push_back(pGridRow);

			}

			// undefined particle
			if (!listNotIdentifiedParticle.empty())
			{
				CGridRowPtr pUndefinedGridRow = CGridRowPtr(new CGridRow());
				pUndefinedGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
				// get element area list from particle list
				auto itr = std::find_if(listUndefinedElement.begin(), listUndefinedElement.end(), [strName](CElementChemistryPtr p) { return p->GetName().CompareNoCase(strName) == 0; });
				if (itr == listUndefinedElement.end())
				{
					pUndefinedGridRow->SetDoubleValue(0.0);
				}
				else
				{
					CElementChemistryPtr pElement = *itr;
					double dPercent = pElement->GetPercentage();
					pUndefinedGridRow->SetDoubleValue(dPercent);

					dTotalArea += listAreaGridRows[nRowNum]->GetDoubleValue() * dPercent;

				}

				nRowNum++;
				listElementGridRows.push_back(pUndefinedGridRow);
			}

			if (!listSiCParticle.empty())
			{
				CGridRowPtr pSiCGridRow = CGridRowPtr(new CGridRow());
				pSiCGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
				// get element area list from particle list
				auto itrSiC = std::find_if(listSiCElement.begin(), listSiCElement.end(), [strName](CElementChemistryPtr p) { return p->GetName().CompareNoCase(strName) == 0; });
				if (itrSiC == listSiCElement.end())
				{
					pSiCGridRow->SetDoubleValue(0.0);
				}
				else
				{
					CElementChemistryPtr pElement = *itrSiC;
					double dPercent = pElement->GetPercentage();
					pSiCGridRow->SetDoubleValue(dPercent);

					dTotalArea += listAreaGridRows[nRowNum]->GetDoubleValue() * dPercent;

				}

				nRowNum++;
				listElementGridRows.push_back(pSiCGridRow);
			}

			if (!listFeOParticle.empty())
			{
				CGridRowPtr pFeOGridRow = CGridRowPtr(new CGridRow());
				pFeOGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
				// get element area list from particle list
				auto itrFeO = std::find_if(listFeOElement.begin(), listFeOElement.end(), [strName](CElementChemistryPtr p) { return p->GetName().CompareNoCase(strName) == 0; });
				if (itrFeO == listFeOElement.end())
				{
					pFeOGridRow->SetDoubleValue(0.0);
				}
				else
				{
					CElementChemistryPtr pElement = *itrFeO;
					double dPercent = pElement->GetPercentage();
					pFeOGridRow->SetDoubleValue(dPercent);

					dTotalArea += listAreaGridRows[nRowNum]->GetDoubleValue() * dPercent;

				}

				nRowNum++;
				listElementGridRows.push_back(pFeOGridRow);
			}

			int nAreaSize = (int)listAreaGridRows.size();
			if (!((nRowNum + 1) == nAreaSize))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("GetAveElementFromParticleList: can't get area."));
				return FALSE;
			}

			dTotalArea = dTotalArea / listAreaGridRows[nAreaSize - 1]->GetDoubleValue();

			// total particle
			CGridRowPtr pTotalGridRow = CGridRowPtr(new CGridRow());
			pTotalGridRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
			pTotalGridRow->SetDoubleValue(dTotalArea);
			listElementGridRows.push_back(pTotalGridRow);

			pElementColumn->SetGridRowsList(listElementGridRows);
			listGridColumn.push_back(pElementColumn);
		}

		//2020-2-17 Modify and standardize
		double d_allelement_subtotal = 0;

		for (unsigned int i_row = 0; i_row < listGridColumn[0]->GetRowList().size(); i_row++)
		{
			//first,So let's take out all the sums
			d_allelement_subtotal = 0;
			for (unsigned int icolumn = 2; icolumn < listGridColumn.size(); icolumn++)
			{
				double ls_dd = listGridColumn[icolumn]->GetRowList()[i_row]->GetDoubleValue();
				if (ls_dd < 0)
					continue;
				d_allelement_subtotal = d_allelement_subtotal + ls_dd;
			}

			//second,Then calculate the normalized values
			for (unsigned int icolumn = 2; icolumn < listGridColumn.size(); icolumn++)
			{
				double ls_dd = listGridColumn[icolumn]->GetRowList()[i_row]->GetDoubleValue();
				if (ls_dd < 0)
					continue;
				listGridColumn[icolumn]->GetRowList()[i_row]->SetDoubleValue(ls_dd / d_allelement_subtotal * 100);
			}
		}

		a_pGridData->SetGridColumnList(listGridColumn);
		return TRUE;

	}

	// compute sort image class
	CGridDatasList CReportProjFileMgr::CompSortClass()
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		CGridDatasList listGridData;
		listGridData.clear();



		// depart compound source name

		std::vector<CString> listDataSource = m_CurrentPropParam->GetDataSourceList();
		int nSelectedDataSourceIndex = m_CurrentPropParam->GetDataSourceId();
		CString sDataSourceNames = listDataSource[nSelectedDataSourceIndex];
		std::vector<CString> listSelectedDataSource = COTSHelper::SplitString(sDataSourceNames, _T("+"));
		//int nIndex = 0;
		for (auto strDataSourceName : listSelectedDataSource)
		{
			CGridDataPtr pGridData = CGridDataPtr(new CGridData());

			// data source id
			std::vector<CString> listDataSource;
			listDataSource.clear();
			listDataSource = m_CurrentPropParam->GetDataSourceList();
			pGridData->SetDataSourceList(listDataSource);

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

			COTSParticleList listParticleAll = GetAnalysisParticleList(strDataSourceName);

			if (!GetSortClassFromParticleList(listParticleAll, pGridData))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompParticleComponent: can't get general information."));
				return listGridData;
			}

			listGridData.push_back(pGridData);

		}

		return listGridData;

	}

	// get sort class from particle list
	BOOL CReportProjFileMgr::GetSortClassFromParticleList(COTSParticleList a_listParticleAll, CGridDataPtr a_pGridData)
	{
		ASSERT(a_pGridData);
		if (!a_pGridData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSortClassFromParticleList: invalid grid data pointer."));
			return FALSE;
		}

		// std
		ASSERT(m_pReportProjFile);
		if (!m_pReportProjFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSortClassFromParticleList: empty project file."));
			return FALSE;
		}

		int nColumnNum = ((int)(REPORT_SORT_CLASS_GRID_CLUMN::MAX) - (int)(REPORT_SORT_CLASS_GRID_CLUMN::MIN) + 1);
		std::vector<CString> listColumnName;
		LoadColumnString(listColumnName, IDS_SORT_CLASS_START, nColumnNum);

		if ((int)listColumnName.size() != nColumnNum)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSortClassFromParticleList: Can't get column name number."));
			return FALSE;
		}

		CGridColumnsList listGridColumn;

		for (int i = 0; i < nColumnNum; i++)
		{
			CGridColumnPtr pColumn = CGridColumnPtr(new CGridColumn());
			pColumn->SetName(listColumnName[i]);

			CGridRowsList listGridRows;
			listGridRows.clear();

			switch (i)
			{
			case (int)REPORT_SORT_CLASS_GRID_CLUMN::TOO_SMALL:
			{
				listGridRows.clear();
				int nTypeId = (int)OTS_PARTCLE_TYPE::SMALL;

				for (auto pParticle : a_listParticleAll)
				{
					int nType = pParticle->GetType();
					if (nType == nTypeId)
					{
						COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
						CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
						pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
						pGridRow->SetParticle(pParticleNew);
						listGridRows.push_back(pGridRow);
					}
				}
			}
			break;
			case (int)REPORT_SORT_CLASS_GRID_CLUMN::OVER_SIZE:
			{
				listGridRows.clear();
				int nTypeId = (int)OTS_PARTCLE_TYPE::OVERSIZE;

				for (auto pParticle : a_listParticleAll)
				{
					int nType = pParticle->GetType();
					if (nType == nTypeId)
					{
						COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
						CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
						pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
						pGridRow->SetParticle(pParticleNew);
						listGridRows.push_back(pGridRow);
					}
				}
			}
			break;
			case (int)REPORT_SORT_CLASS_GRID_CLUMN::GRAY_NO_INTERS:
			{
				listGridRows.clear();
				int nTypeId = (int)OTS_PARTCLE_TYPE::AVE_GRAY_NOT_INRANRE;

				for (auto pParticle : a_listParticleAll)
				{
					int nType = pParticle->GetType();
					if (nType == nTypeId)
					{
						COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
						CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
						pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
						pGridRow->SetParticle(pParticleNew);
						listGridRows.push_back(pGridRow);
					}
				}
			}
			break;
			case (int)REPORT_SORT_CLASS_GRID_CLUMN::LOW_COUNT:
			{
				listGridRows.clear();
				int nTypeId = (int)OTS_PARTCLE_TYPE::LOW_COUNT;

				for (auto pParticle : a_listParticleAll)
				{
					int nType = pParticle->GetType();
					if (nType == nTypeId)
					{
						COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
						CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
						pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
						pGridRow->SetParticle(pParticleNew);
						listGridRows.push_back(pGridRow);
					}
				}
			}
			break;
			case (int)REPORT_SORT_CLASS_GRID_CLUMN::NO_INTEREST_ELEMENTS:
			{
				listGridRows.clear();
				int nTypeId = (int)OTS_PARTCLE_TYPE::NO_INTEREST_ELEMENTS;

				for (auto pParticle : a_listParticleAll)
				{
					int nType = pParticle->GetType();
					if (nType == nTypeId)
					{
						COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
						CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
						pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
						pGridRow->SetParticle(pParticleNew);
						listGridRows.push_back(pGridRow);
					}
				}
			}
			break;
			case (int)REPORT_SORT_CLASS_GRID_CLUMN::NOT_INCLUSION_SIC:
			{
				listGridRows.clear();
				int nTypeId = (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_SIC;

				for (auto pParticle : a_listParticleAll)
				{
					int nType = pParticle->GetType();
					if (nType == nTypeId)
					{
						COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
						CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
						pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
						pGridRow->SetParticle(pParticleNew);
						listGridRows.push_back(pGridRow);
					}
				}
			}
			break;
			case (int)REPORT_SORT_CLASS_GRID_CLUMN::NOT_INCLUSION_FEO:
			{
				listGridRows.clear();
				int nTypeId = (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED_FEO;

				for (auto pParticle : a_listParticleAll)
				{
					int nType = pParticle->GetType();
					if (nType == nTypeId)
					{
						COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
						CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
						pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
						pGridRow->SetParticle(pParticleNew);
						listGridRows.push_back(pGridRow);
					}
				}
			}
			break;
			case (int)REPORT_SORT_CLASS_GRID_CLUMN::NOT_IDENTIFIED:
			{
				listGridRows.clear();
				int nTypeId = (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED;

				for (auto pParticle : a_listParticleAll)
				{
					int nType = pParticle->GetType();
					if (nType == nTypeId)
					{
						COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
						CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
						pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
						pGridRow->SetParticle(pParticleNew);
						listGridRows.push_back(pGridRow);
					}
				}
			}
			break;
			case (int)REPORT_SORT_CLASS_GRID_CLUMN::IDENTIFIED:
			{
				listGridRows.clear();
				int nTypeId = (int)OTS_PARTCLE_TYPE::IDENTIFIED;

				for (auto pParticle : a_listParticleAll)
				{
					int nType = pParticle->GetType();
					if (nType >= nTypeId)
					{
						COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
						CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
						pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
						pGridRow->SetParticle(pParticleNew);
						listGridRows.push_back(pGridRow);
					}
				}
			}
			break;
			}

			pColumn->SetGridRowsList(listGridRows);

			listGridColumn.push_back(pColumn);

		}

		a_pGridData->SetGridColumnList(listGridColumn);
		return TRUE;

	}

	// compute sort image kind
	CGridDatasList CReportProjFileMgr::CompSortKind()
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		CGridDatasList listGridData;
		listGridData.clear();



		// depart compound source name

		std::vector<CString> listDataSource = m_CurrentPropParam->GetDataSourceList();
		int nSelectedDataSourceIndex = m_CurrentPropParam->GetDataSourceId();
		CString sDataSourceNames = listDataSource[nSelectedDataSourceIndex];
		std::vector<CString> listSelectedDataSource = COTSHelper::SplitString(sDataSourceNames, _T("+"));
		//int nIndex = 0;
		for (auto strDataSourceName : listSelectedDataSource)
		{
			CGridDataPtr pGridData = CGridDataPtr(new CGridData());

			// data source id
			std::vector<CString> listDataSource;
			listDataSource.clear();
			listDataSource = m_CurrentPropParam->GetDataSourceList();
			pGridData->SetDataSourceList(listDataSource);

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

			COTSParticleList listParticleAll = GetAnalysisParticleList(strDataSourceName);

			if (!GetSortKindFromParticleList(listParticleAll, pGridData))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompParticleComponent: can't get general information."));
				return listGridData;
			}

			listGridData.push_back(pGridData);

		}

		return listGridData;
	}

	// compute sort king from particle list
	BOOL CReportProjFileMgr::GetSortKindFromParticleList(COTSParticleList a_listParticleAll, CGridDataPtr a_pGridData)
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		ASSERT(a_pGridData);
		if (!a_pGridData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSortClassFromParticleList: invalid grid data pointer."));
			return FALSE;
		}



		int nColumnNum = ((int)(REPORT_SORT_KIND_GRID_CLUMN::MAX) - (int)(REPORT_SORT_KIND_GRID_CLUMN::MIN) + 1);
		std::vector<CString> listColumnName;
		LoadColumnString(listColumnName, IDS_SORT_KIND_START, nColumnNum);

		map<int, COTSParticleList> mapSameSTDItemPartList;

		this->GetSTDMapedParticleList(a_listParticleAll, &mapSameSTDItemPartList);

		CGridColumnsList listGridColumn;
		nColumnNum = mapSameSTDItemPartList.size();
		for (auto itr = mapSameSTDItemPartList.begin(); itr != mapSameSTDItemPartList.end(); itr++)
		{
			CGridColumnPtr pColumn = CGridColumnPtr(new CGridColumn());
			std::string typeName = itr->second[0]->TypeName();
			pColumn->SetName(typeName.c_str());

			CGridRowsList listGridRows;
			listGridRows.clear();
			COTSParticleList thisTypeParts = itr->second;

			for (auto pParticle : thisTypeParts)
			{
				COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
				CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
				pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
				pGridRow->SetParticle(pParticleNew);
				listGridRows.push_back(pGridRow);
			}

			pColumn->SetGridRowsList(listGridRows);

			listGridColumn.push_back(pColumn);

		}

		a_pGridData->SetGridColumnList(listGridColumn);
		return TRUE;

	}

	// compute sort image size
	CGridDatasList CReportProjFileMgr::CompSortSize()
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		CGridDatasList listGridData;
		listGridData.clear();

		// depart compound source name
		std::vector<CString> listDataSource = m_CurrentPropParam->GetDataSourceList();
		int nSelectedDataSourceIndex = m_CurrentPropParam->GetDataSourceId();
		CString sDataSourceNames = listDataSource[nSelectedDataSourceIndex];
		std::vector<CString> listSelectedDataSource = COTSHelper::SplitString(sDataSourceNames, _T("+"));
		//int nIndex = 0;
		for (auto strDataSourceName : listSelectedDataSource)
		{
			CGridDataPtr pGridData = CGridDataPtr(new CGridData());

			// data source id
			std::vector<CString> listDataSource;
			listDataSource.clear();
			listDataSource = m_CurrentPropParam->GetDataSourceList();
			pGridData->SetDataSourceList(listDataSource);

			int nDataSourceId = m_CurrentPropParam->GetDataSourceId();
			pGridData->SetDataSourceId(nDataSourceId);
			COTSParticleList listParticleAll = GetAnalysisParticleList(strDataSourceName);

			//get pixel size
			CSmplMsrResultFileMgrPtr pSmplMsrResultFileMgr = this->GetASmplMsrResultMgrByFileName(strDataSourceName);
			ASSERT(pSmplMsrResultFileMgr);
			if (!pSmplMsrResultFileMgr)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompDistribution: can't get sample result file manager."));
				return listGridData;
			}

			CSmplMsrResultFilePtr pSmplMsrResultFile = pSmplMsrResultFileMgr->GetSmplMsrResultFile();
			ASSERT(pSmplMsrResultFile);
			if (!pSmplMsrResultFile)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompDistribution: can't get sample result file."));
				return listGridData;
			}

			COTSSamplePtr pSample = pSmplMsrResultFile->GetSample();
			ASSERT(pSample);
			if (!pSample)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompDistribution: can't get sample."));
				return listGridData;
			}

			double dPixelSize = pSample->CalculatePixelSize();

			if (!GetSortSizeFromParticleList(listParticleAll, dPixelSize, pGridData))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompParticleComponent: can't get general information."));
				return listGridData;
			}

			listGridData.push_back(pGridData);
			//nIndex++;
		}


		return listGridData;
	}

	// compute sort size from particle list
	BOOL CReportProjFileMgr::GetSortSizeFromParticleList(COTSParticleList a_listParticleAll, double a_dPixelSize, CGridDataPtr a_pGridData)
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		ASSERT(a_pGridData);
		if (!a_pGridData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSortSizeFromParticleList: invalid grid data pointer."));
			return FALSE;
		}


		// particle size file
		CPartSizeFilePtr pPartSize = m_CurrentPropParam->GetWorkingSizeFile();
		ASSERT(pPartSize);
		if (!pPartSize)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSortSizeFromParticleList: invalid part size data."));
			return FALSE;
		}

		int nColumnNum = ((int)(REPORT_SORT_SIZE_GRID_CLUMN::MAX) - (int)(REPORT_SORT_SIZE_GRID_CLUMN::MIN) + 1);
		std::vector<CString> listColumnName;
		LoadColumnString(listColumnName, IDS_SORT_SIZE_START, nColumnNum);
		CPartSizeItemList& listSizes = pPartSize->GetPartSizeList();
		for (auto pSize : listSizes)
		{
			CString strSizeName = pSize->GetName();
			listColumnName.push_back(strSizeName);
			nColumnNum++;
		}

		if ((int)listColumnName.size() != nColumnNum)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSortClassFromParticleList: Can't get column name number."));
			return FALSE;
		}

		CGridColumnsList listGridColumn;

		for (int i = 0; i < nColumnNum; i++)
		{
			CGridColumnPtr pColumn = CGridColumnPtr(new CGridColumn());
			pColumn->SetName(listColumnName[i]);

			CGridRowsList listGridRows;
			listGridRows.clear();

			double dSizeMax = 0.0;
			double dSizeMin = 0.0;

			if (i == 0)
			{
				dSizeMin = m_CurrentPropParam->GetGrainSizeMin();
				dSizeMax = m_CurrentPropParam->GetGrainSizeMax();
			}
			else
			{
				dSizeMin = listSizes[i - 1]->GetSizeLevel()->GetStart();
				dSizeMax = listSizes[i - 1]->GetSizeLevel()->GetEnd();
			}

			for (auto pParticle : a_listParticleAll)
			{
				double dValue = GetValueAsMethod(pParticle, m_CurrentPropParam->GetSizeCalMethodType(), a_dPixelSize);
				if (dValue < dSizeMax && dValue > dSizeMin)
				{
					COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
					pGridRow->SetParticle(pParticleNew);
					listGridRows.push_back(pGridRow);
				}
			}

			pColumn->SetGridRowsList(listGridRows);

			listGridColumn.push_back(pColumn);
		}

		//reverse funcation for size particle sort
		reverse(listGridColumn.begin(), listGridColumn.end());

		a_pGridData->SetGridColumnList(listGridColumn);
		return TRUE;
	}

	// compute sort image size
	CGridDatasList CReportProjFileMgr::CompDistribution()//CGridInPtr a_pGridIn
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		CGridDatasList listGridData;
		listGridData.clear();

		// depart compound source name
		CPropParamPtr propParam = this->GetPropertyParamImage();
		std::vector<CString> listDataSource = this->GetPropertyParamImage()->GetDataSourceList();
		int nSelectedDataSourceIndex = propParam->GetDataSourceId();
		CString sDataSourceNames = listDataSource[nSelectedDataSourceIndex];
		std::vector<CString> listSelectedDataSource = COTSHelper::SplitString(sDataSourceNames, _T("+"));
		int nIndex = 0;
		for (auto strDataSourceName : listSelectedDataSource)
		{

			CGridDataPtr pGridData = CGridDataPtr(new CGridData());

			// data source id
			std::vector<CString> listDataSource;
			listDataSource.clear();
			listDataSource = propParam->GetDataSourceList();
			pGridData->SetDataSourceList(listDataSource);

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

			COTSParticleList listParticleAll = GetAnalysisParticleList(strDataSourceName);

			//get pixel size
			CSmplMsrResultFileMgrPtr pSmplMsrResultFileMgr = this->GetASmplMsrResultMgrByFileName(strDataSourceName);
			ASSERT(pSmplMsrResultFileMgr);
			if (!pSmplMsrResultFileMgr)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompDistribution: can't get sample result file manager."));
				return listGridData;
			}

			CSmplMsrResultFilePtr pSmplMsrResultFile = pSmplMsrResultFileMgr->GetSmplMsrResultFile();
			ASSERT(pSmplMsrResultFile);
			if (!pSmplMsrResultFile)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompDistribution: can't get sample result file."));
				return listGridData;
			}

			COTSSamplePtr pSample = pSmplMsrResultFile->GetSample();
			ASSERT(pSample);
			if (!pSample)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompDistribution: can't get sample."));
				return listGridData;
			}

			double dPixelSize = pSample->CalculatePixelSize();

			if (!GetDistributionFromParticleList(propParam, dPixelSize, listParticleAll, pGridData))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompDistribution: can't get particle list."));
				return listGridData;
			}

			listGridData.push_back(pGridData);
			nIndex++;
		}

		return listGridData;
	}

	BOOL CReportProjFileMgr::GetDistributionFromParticleList(CPropParamPtr propParam, double a_dPixelSize, COTSParticleList a_listParticleAll, CGridDataPtr a_pGridData)
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());


		ASSERT(a_pGridData);
		if (!a_pGridData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetDistributionFromParticleList: invalid grid data pointer."));
			return FALSE;
		}

		// std
		ASSERT(m_pReportProjFile);
		if (!m_pReportProjFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetDistributionFromParticleList: empty project file."));
			return FALSE;
		}

		// particle size file
		CPartSizeFilePtr pPartSize = m_CurrentPropParam->GetWorkingSizeFile();
		ASSERT(pPartSize);
		if (!pPartSize)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetDistributionFromParticleList: invalid part size data."));
			return FALSE;
		}

		CPartSizeItemList& listSizes = pPartSize->GetPartSizeList();
		std::vector<CString> listSizeClassTables;
		LoadColumnString(listSizeClassTables, (UINT)IDS_SIZE_CLASS_DEFUALT_FIRST, (int)(SIZE_CLASS_DEFUALT::MAX) - (int)(SIZE_CLASS_DEFUALT::MIN) + 1);
		if ((pPartSize.get() != nullptr))
		{
			CPartSizeItemList listSizeItem = pPartSize->GetPartSizeList();
			for (auto pItem : listSizeItem)
			{
				CString strValue = pItem->GetName();
				listSizeClassTables.push_back(strValue);
			}
		}


		CGridColumnsList listGridColumn;

		CGridColumnPtr pColumn = CGridColumnPtr(new CGridColumn());
		pColumn->SetName(_T(""));

		CGridRowsList listGridRows;
		listGridRows.clear();

		PARTICLE_TYPE nSelectType = propParam->GetPartType();
		int nSTDId = propParam->GetSTDId();
		int nSizeClassType;

		double dSizeMax = 0;
		double dSizeMin = 0;


		dSizeMin = propParam->GetGrainSizeMin();
		dSizeMax = propParam->GetGrainSizeMax();

		//因GridIn参数中没有传递具体选择什么类型的粒级分类数据，因此用SizeLevel的两个限值来区分，都为0 时就认为是选择了全部，其他的就按选择具体的档级处理。
		if (dSizeMax == 0 && dSizeMin == 0)//当DSizeMax==0 和 dSizeMin==0 时表明“粒级”栏选择的是 “全部”或“自定义”上下限填写的是0.
		{
			nSizeClassType = 0;//等于0表明选择“全部”也就是默认取全部粒级表的尺寸数据
		}
		else
		{
			nSizeClassType = 1;//等于1表明选择的是单个某个粒级的数据档 如“3~5”
		}

		for (auto pParticle : a_listParticleAll)
		{
			int nTypeParticle = pParticle->GetType();

			double dValue = GetValueAsMethod(pParticle, propParam->GetSizeCalMethodType(), a_dPixelSize);

			COTSParticlePtr pParticleNew = COTSParticlePtr(new COTSParticle(*pParticle.get()));

			switch ((int)nSelectType)
			{
			case (int)PARTICLE_TYPE::ALL:
				if (nSizeClassType == 0)
				{
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
					pGridRow->SetParticle(pParticleNew);
					listGridRows.push_back(pGridRow);
				}
				else
				{
					if (dValue > dSizeMin && dValue < dSizeMax)
					{
						CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
						pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
						pGridRow->SetParticle(pParticleNew);
						listGridRows.push_back(pGridRow);
					}
				}
				break;
			case (int)PARTICLE_TYPE::ANALYSISED:
				if (nSizeClassType == 0)
				{
					if (nSTDId == 0) //全部颗粒
					{
						if (nSizeClassType == 0)
						{
							CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
							pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
							pGridRow->SetParticle(pParticleNew);
							listGridRows.push_back(pGridRow);
						}
						else
						{
							if (dValue > dSizeMin && dValue < dSizeMax)
							{
								CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
								pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
								pGridRow->SetParticle(pParticleNew);
								listGridRows.push_back(pGridRow);
							}
						}
					}
					else if (nSTDId == 1) // 未识别颗粒
					{
						if (nTypeParticle == (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED)
						{
							CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
							pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
							pGridRow->SetParticle(pParticleNew);
							listGridRows.push_back(pGridRow);
						}
					}
					else
					{
						if (nTypeParticle == (nSTDId - 1))
						{
							CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
							pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
							pGridRow->SetParticle(pParticleNew);
							listGridRows.push_back(pGridRow);
						}
					}
				}
				else
				{
					if (dValue > dSizeMin && dValue < dSizeMax)
					{
						CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
						pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::PARTICLE);
						pGridRow->SetParticle(pParticleNew);
						listGridRows.push_back(pGridRow);
					}
				}
				break;
			default:
				break;
			}

		}

		pColumn->SetGridRowsList(listGridRows);

		listGridColumn.push_back(pColumn);

		a_pGridData->SetGridColumnList(listGridColumn);
		return TRUE;
	}

	// load column name string
	void CReportProjFileMgr::LoadColumnString(std::vector<CString>& a_listStrings, UINT a_nFirstStringID, int a_nCount)
	{
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		for (int i = 0; i < a_nCount; ++i)
		{
			CString str;
			str = MultiLang::GetInstance().GetCStringByKey(a_nFirstStringID + i);
			a_listStrings.push_back(str);
		}
	}

	// get undefined element list from particle list
	CElementChemistriesList CReportProjFileMgr::GetUndefinedElementList(COTSParticleList a_listParticle, CPosXraysList a_listXray)
	{
		CElementChemistriesList listElementChemistry;

		// safety check to get xray data and element number
		int nXraySize = (int)a_listXray.size();
		int nParticleSize = (int)a_listParticle.size();

		if (nParticleSize > nXraySize)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetUndefinedElementList: get xray number is not enough."));
			return listElementChemistry;
		}

		CElementAreaList listElementArea;

		// get element area
		double dTotalArea = 0;
		for (auto pParticle : a_listParticle)
		{
			int nXrayId = pParticle->GetAnalysisId();

			if (nXrayId < 0 || nXrayId >(int) a_listXray.size())
			{
				LogErrorTrace(__FILE__, __LINE__, _T("GetUndefinedElementList: get wrong xray id."));
				return listElementChemistry;
			}

			int nFieldId = pParticle->GetFieldId();
			auto itr = std::find_if(a_listXray.begin(), a_listXray.end(), [nXrayId, nFieldId](CPosXrayPtr p) { return ((p->GetScanFieldId() == nFieldId) && (p->GetIndex() == nXrayId)); });
			if (itr == a_listXray.end())
			{
				LogErrorTrace(__FILE__, __LINE__, _T("GetUndefinedElementList: can't find x-ray."));
				return listElementChemistry;
			}

			CPosXrayPtr pXray = *itr;

			// remove Fe
			CElementChemistriesList listElementChemistryCurrent = pXray->GetElementQuantifyData();
			CElementChemistriesList listElementChemistryNew1 = CPosXray::RemoveFe(listElementChemistryCurrent);
			CElementChemistriesList listElementChemistryNew = CPosXray::RemoveC(listElementChemistryNew1);
			double t = 0;
			CElementChemistriesList listElementChemistryG1;
			for (auto pElementChemistry : listElementChemistryNew)
			{
				t += pElementChemistry->GetPercentage();

			}
			if (t == 0)
			{
				continue;
			}
			for (auto pElementChemistry : listElementChemistryNew)
			{
				double dPecent = 100.0 *pElementChemistry->GetPercentage() / t;

				CElementChemistryPtr pElementNew = CElementChemistryPtr(new CElementChemistry(*pElementChemistry.get()));
				pElementNew->SetPercentage(dPecent);

				listElementChemistryG1.push_back(pElementNew);
			}

			CElementAreaPtr pElementArea = CElementAreaPtr(new CElementArea());
			double dArea = pParticle->GetArea();
			pElementArea->SetArea(dArea);
			pElementArea->SetElementList(listElementChemistryG1);

			listElementArea.push_back(pElementArea);
			dTotalArea += dArea;
		}

		for (auto pElementArea : listElementArea)
		{
			CElementChemistriesList listElementChemistryCurrent = pElementArea->GetElementList();

			for (auto pElement : listElementChemistryCurrent)
			{
				CString strName = pElement->GetName();
				double dPercentNorm = 1.0;
				auto itr = std::find_if(listElementChemistry.begin(), listElementChemistry.end(), [strName](CElementChemistryPtr p) { return p->GetName().CompareNoCase(strName) == 0; });
				if (itr == listElementChemistry.end())
				{
					double dArea = pElementArea->GetArea();
					double dPercent = pElement->GetPercentage();
					dPercentNorm = dArea * dPercent / dTotalArea;

				}
				else
				{

					CElementChemistryPtr pElementChemistry = *itr;

					double dAreaOld = pElementChemistry->GetPercentage() * dTotalArea * 0.01;
					double dArea = pElementArea->GetArea();
					double dPercent = pElement->GetPercentage();
					dPercentNorm = 100 * (0.01 * dArea * dPercent + dAreaOld) / dTotalArea;

					listElementChemistry.erase(itr);

				}

				CElementChemistryPtr pElement = CElementChemistryPtr(new CElementChemistry());
				pElement->SetName(strName);
				pElement->SetPercentage(dPercentNorm);
				listElementChemistry.push_back(pElement);
			}
		}

		return listElementChemistry;
	}

	CGridDatasList CReportProjFileMgr::CompChartParticleComp()
	{

		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		CGridDatasList listGridData;
		listGridData.clear();

		// depart compound source name

		std::vector<CString> listDataSource = m_CurrentPropParam->GetDataSourceList();
		int nSelectedDataSourceIndex = m_CurrentPropParam->GetDataSourceId();

		CGridDatasList pGridList = CompParticleComponent();

		for (CGridDataPtr pGrid : pGridList)
		{

			CGridDataPtr pGridData = CGridDataPtr(new CGridData());

			// data source id
			std::vector<CString> listDataSource;
			listDataSource.clear();
			listDataSource = m_CurrentPropParam->GetDataSourceList();
			pGridData->SetDataSourceList(listDataSource);

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

			ASSERT(pGrid);
			if (!pGrid)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompChartParticleComp: invalid grid in data pointer."));
				return listGridData;
			}

			CGridColumnsList listGridColumn = pGrid->GetGridColumnList();

			// particle column
			CGridColumnPtr pParticleCol = listGridColumn[(int)REPORT_PARTICLE_COMPONENT_GRID_CLUMN::NAME - (int)REPORT_PARTICLE_COMPONENT_GRID_CLUMN::MIN];
			CGridRowsList listGridParticleRows = pParticleCol->GetRowList();
			// particle num column
			CGridColumnPtr pParticleNumCol = listGridColumn[(int)REPORT_PARTICLE_COMPONENT_GRID_CLUMN::PARTICLE_NUM - (int)REPORT_PARTICLE_COMPONENT_GRID_CLUMN::MIN];
			CGridRowsList listGridParticleNumRows = pParticleNumCol->GetRowList();

			if (!((int)listGridParticleRows.size() == (int)listGridParticleNumRows.size()))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompChartParticleComp: invalid name and num are different."));
				return listGridData;
			}

			CGridColumnsList listCol;
			listCol.clear();

			int nIndex = 0;
			for (auto pNameRow : listGridParticleRows)
			{
				CGridColumnPtr pColumn = CGridColumnPtr(new CGridColumn());
				// name
				CString strName = pNameRow->GetStringValue();
				pColumn->SetName(strName);

				// list of rows
				CGridRowsList listRows;
				CGridRowPtr pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::INT);

				CGridRowPtr pGridRow = listGridParticleNumRows[nIndex];
				ASSERT(pGridRow);
				if (!pGridRow)
				{
					LogErrorTrace(__FILE__, __LINE__, _T("CompChartParticleComp: invalid name and num are different."));
					return listGridData;
				}

				int nValue = pGridRow->GetIntValue();
				pRow->SetIntValue(nValue);
				listRows.push_back(pRow);

				pColumn->SetGridRowsList(listRows);

				listCol.push_back(pColumn);

				nIndex++;
			}

			pGridData->SetGridColumnList(listCol);

			listGridData.push_back(pGridData);

		}

		return listGridData;
	}

	CGridDatasList CReportProjFileMgr::CompChartElementComp()
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		CGridDatasList listGridData;
		listGridData.clear();
		CGridDatasList listGridDataEEE = CompElementComponent();

		for (CGridDataPtr pGrid : listGridDataEEE)
		{
			CGridDataPtr pGridData = CGridDataPtr(new CGridData());
			// data source id
			std::vector<CString> listDataSource = m_CurrentPropParam->GetDataSourceList();
			pGridData->SetDataSourceList(listDataSource);

			int nDataSourceId = m_CurrentPropParam->GetDataSourceId();
			pGridData->SetDataSourceId(nDataSourceId);
			CGridColumnsList listGridColumn = pGrid->GetGridColumnList();
			//获取第一列所有元素名称
			CGridColumnPtr element = listGridColumn[0];
			//获取第二列所有占比
			CGridColumnPtr Comp = listGridColumn[1];
			CGridRowsList listGridNameRows = element->GetRowList();

			CGridColumnsList listGridValid; // first two column is particle name and area, they are invalid
			listGridValid.clear();
			//循环第一列所有行，创建新表结构列
			for (CGridRowPtr row : listGridNameRows)
			{
				CGridColumnPtr pColumn = CGridColumnPtr(new CGridColumn());
				// name
				CString strName = row->GetStringValue();
				pColumn->SetName(strName);
				listGridValid.push_back(pColumn);
			}
			//添加数据
			CGridColumnsList listCol;
			listCol.clear();
			for (int i = 0; i < listGridValid.size(); i++)
			{
				auto pGridColumn = listGridValid[i];
				CGridColumnPtr pColumn = CGridColumnPtr(new CGridColumn());
				// name
				CString strName = pGridColumn->GetName();
				pColumn->SetName(strName);

				// list of rows
				CGridRowsList listRows;
				CGridRowPtr pRow = CGridRowPtr(new CGridRow());
				pRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
				CString sValue = Comp->GetRowList()[i]->GetStringValue();
				sValue.Replace('%', '0');
				double dValue;
				dValue = atof(sValue);
				pRow->SetDoubleValue(dValue);
				listRows.push_back(pRow);

				pColumn->SetGridRowsList(listRows);

				listCol.push_back(pColumn);
			}
			pGridData->SetGridColumnList(listCol);
			listGridData.push_back(pGridData);
		}



		// use the dll resource
		//AFX_MANAGE_STATE(AfxGetStaticModuleState());
		//CGridDatasList listGridData;
		//listGridData.clear();

		//// depart compound source name
		//std::vector<int> listWorkIndex;
		//std::vector<int> listPos;
		//std::vector<CString> listDataSource = m_CurrentPropParam->GetDataSourceList();
		//int nSelectedDataSourceIndex = m_CurrentPropParam->GetDataSourceId();
		//
		//int nIndex = 0;
		//CGridDatasList pGridList = CompAveElemnetComponent();
		//
		//for (CGridDataPtr pGrid : pGridList)
		//{

		//	CGridDataPtr pGridData = CGridDataPtr(new CGridData());

		//	// data source id
		//	std::vector<CString> listDataSource = m_CurrentPropParam->GetDataSourceList();
		//	pGridData->SetDataSourceList(listDataSource);

		//	int nDataSourceId = m_CurrentPropParam->GetDataSourceId();
		//	pGridData->SetDataSourceId(nDataSourceId);

		//	
		//
		//	ASSERT(pGrid);
		//	if (!pGrid)
		//	{
		//		LogErrorTrace(__FILE__, __LINE__, _T("CompChartElementComp: invalid grid in data pointer."));
		//		return listGridData;
		//	}

		//	CGridColumnsList listGridColumn = pGrid->GetGridColumnList();
		//	int nSTDId = m_CurrentPropParam->GetSTDId();
		//	CGridColumnPtr pParticleName = listGridColumn[(int)REPORT_ELEMENT_COMPONENT_GRID_CLUMN::NAME - (int)REPORT_ELEMENT_COMPONENT_GRID_CLUMN::MIN];
		//	CGridRowsList listGridNameRows = pParticleName->GetRowList();
		//	if (nSTDId < -1 || nSTDId >(int)listGridNameRows.size())
		//	{
		//		LogErrorTrace(__FILE__, __LINE__, _T("CompChartElementComp: invalid STD id."));
		//		return listGridData;
		//	}

		//	if (nSTDId == 0)// all element
		//	{
		//		nSTDId = (int)listGridNameRows.size() - 1;
		//	}
		//	else if (nSTDId == 1) // undefined element
		//	{
		//		nSTDId = (int)listGridNameRows.size() - 2;
		//	}
		//	else
		//	{
		//		nSTDId = nSTDId - 1;
		//	}

		//	if ((int)listGridColumn.size() < 3)
		//	{
		//		LogErrorTrace(__FILE__, __LINE__, _T("CompChartElementComp: no element is checked out."));
		//		return listGridData;
		//	}

		//	CGridColumnsList listGridValid; // first two column is particle name and area, they are invalid
		//	listGridValid.clear();

		//	for (int i = 2; i < (int)listGridColumn.size(); i++)
		//	{
		//		CGridColumnPtr pNewGridColumn = listGridColumn[i];
		//		ASSERT(pNewGridColumn);
		//		if (!pNewGridColumn)
		//		{
		//			LogErrorTrace(__FILE__, __LINE__, _T("CompChartElementComp: invalid column."));
		//			return listGridData;
		//		}

		//		listGridValid.push_back(pNewGridColumn);
		//	}

		//	CGridColumnsList listCol;
		//	listCol.clear();

		//	for (auto pGridColumn : listGridValid)
		//	{
		//		CGridColumnPtr pColumn = CGridColumnPtr(new CGridColumn());

		//		// name
		//		CString strName = pGridColumn->GetName();
		//		pColumn->SetName(strName);

		//		// list of rows
		//		CGridRowsList listRows;
		//		CGridRowPtr pRow = CGridRowPtr(new CGridRow());
		//		pRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);

		//		CGridRowsList listGridRows = pGridColumn->GetRowList();
		//		if (!((int)listGridRows.size() == (int)listGridNameRows.size()))
		//		{
		//			LogErrorTrace(__FILE__, __LINE__, _T("CompChartElementComp: row lengths are different."));
		//			return listGridData;
		//		}

		//		CGridRowPtr pGridRow = listGridRows[nSTDId];
		//		ASSERT(pGridRow);
		//		if (!pGridRow)
		//		{
		//			LogErrorTrace(__FILE__, __LINE__, _T("CompChartElementComp: invalid name and num are different."));
		//			return listGridData;
		//		}

		//		double dValue = pGridRow->GetDoubleValue();
		//		pRow->SetDoubleValue(dValue);
		//		listRows.push_back(pRow);

		//		pColumn->SetGridRowsList(listRows);

		//		listCol.push_back(pColumn);
		//	}

		//	pGridData->SetGridColumnList(listCol);

		//	listGridData.push_back(pGridData);
		//}
		return listGridData;
	}

	CGridDatasList CReportProjFileMgr::CompChartParticleSize()
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		CGridDatasList listGridData;
		listGridData.clear();

		// depart compound source name
		std::vector<int> listWorkIndex;
		std::vector<int> listPos;
		std::vector<CString> listDataSource = m_CurrentPropParam->GetDataSourceList();
		int nSelectedDataSourceIndex = m_CurrentPropParam->GetDataSourceId();


		CGridDatasList pGridList = CompParticleSizeDistribution();
		for (CGridDataPtr pGrid : pGridList)
		{
			CGridDataPtr pGridData = CGridDataPtr(new CGridData());

			// data source id
			std::vector<CString> listDataSource;
			listDataSource.clear();
			listDataSource = m_CurrentPropParam->GetDataSourceList();
			pGridData->SetDataSourceList(listDataSource);

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


			//CGridDataPtr pGrid = pGridList[0];
			ASSERT(pGrid);
			if (!pGrid)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompChartParticleSize: invalid grid in data pointer."));
				return listGridData;
			}

			//amounts
			CGridColumnsList listGridColumn = pGrid->GetGridColumnList();
			int nCols = (int)listGridColumn.size();
			int nAmounts = 0;


			int nSTDId = m_CurrentPropParam->GetSTDId();
			CGridColumnPtr pParticleName = listGridColumn[(int)REPORT_SIZE_DISTRIBUTION_GRID_CLUMN::NAME - (int)REPORT_SIZE_DISTRIBUTION_GRID_CLUMN::MIN];
			CGridRowsList listGridNameRows = pParticleName->GetRowList();

			if (nSTDId < -1 || nSTDId >(int)listGridNameRows.size())
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompChartParticleSize: invalid STD id."));
				return listGridData;
			}


			CGridColumnsList listCol;
			listCol.clear();

			int nCIndex = 0;
			int nCAmount = 0;
			for (auto gridColumn : listGridColumn)
			{

				nCIndex++;

				if (nCIndex > (((int)REPORT_SIZE_DISTRIBUTION_GRID_CLUMN::MAX) + 1))
				{
					CGridColumnPtr pColumn = CGridColumnPtr(new CGridColumn());
					CString strName = gridColumn->GetName();
					pColumn->SetName(strName);

					CGridRowsList listGridRows = gridColumn->GetRowList();
					CGridRowsList listRows;
					int nRows = (int)listGridRows.size();
					CGridRowPtr pGridRow = listGridRows[nRows - 1];
					ASSERT(pGridRow);
					if (!pGridRow)
					{
						LogErrorTrace(__FILE__, __LINE__, _T("CompChartParticleSize: invalid name and num are different."));
						return listGridData;
					}
					CString strValue = pGridRow->GetStringValue();
					double dValue = atof(strValue);

					CGridRowPtr pRow = CGridRowPtr(new CGridRow());
					pRow->SetDataType(REPORT_GRID_DATA_TYPE::FLOAT);
					pRow->SetDoubleValue(dValue);
					listRows.push_back(pRow);
					pColumn->SetGridRowsList(listRows);
					listCol.push_back(pColumn);

				}
			}

			//double dValue = nCAmount / nAmounts;
			pGridData->SetGridColumnList(listCol);
			listGridData.push_back(pGridData);
		}

		return listGridData;
	}

	// compute common five classification
	CGridDatasList CReportProjFileMgr::CompChartCommonFive()
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		CGridDatasList listGridData;
		listGridData.clear();

		std::vector<CString> listDataSource = m_CurrentPropParam->GetDataSourceList();
		int nSelectedDataSourceIndex = m_CurrentPropParam->GetDataSourceId();
		CString sDataSourceNames = listDataSource[nSelectedDataSourceIndex];
		std::vector<CString> listSelectedDataSource = COTSHelper::SplitString(sDataSourceNames, _T("+"));
		//int nIndex = 0;
		for (auto strDataSourceName : listSelectedDataSource)
		{
			CGridDataPtr pGridData = CGridDataPtr(new CGridData());

			// data source id

			pGridData->SetDataSourceList(m_CurrentPropParam->GetDataSourceList());


			pGridData->SetDataSourceId(m_CurrentPropParam->GetDataSourceId());
			COTSParticleList* pSelectidParts;
			COTSParticleList listParticleAll;
			COTSParticleList seleParticles;

			// add filter select particle
			if (m_CurrentPropParam->GetDataSourceType() == DATA_SOURCE_TYPE::SELECTION)
			{
				seleParticles = m_CurrentPropParam->GetSelectParticle();
				pSelectidParts = &seleParticles;
			}
			else
			{
				listParticleAll = GetAnalysisParticleList(strDataSourceName);
				pSelectidParts = &listParticleAll;
			}

			if (!GetCommonFiveFromParticleList(*pSelectidParts, pGridData))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("CompParticleComponent: can't get general information."));
				return listGridData;
			}

			listGridData.push_back(pGridData);

		}
		return listGridData;
	}

	BOOL CReportProjFileMgr::GetCommonClass(
		COTSParticlePtr a_pPart,
		INC_COMMON_CLASSIFY_TYPE& a_nType)
	{
		// safety check
		ASSERT(a_pPart);
		if (!a_pPart)
		{
			// something wrong
			LogErrorTrace(__FILE__, __LINE__, _T("GetCommonClass: invalid CParticlePtr."));
			return FALSE;
		}

		int nType = a_pPart->GetType();
		//CString sIncName = GetSTDItemNameById(a_listSTDItems, nType);

		//只有"NOT_IDENTIFIED"以上的颗粒类型需要考虑
		if (nType >= (int)OTS_PARTCLE_TYPE::NOT_IDENTIFIED)
		{
			if ((nType >= (int)OTS_STD_ITEM_VALUE::SYS_SPIEL_OXICE_MIN && nType <= (int)OTS_STD_ITEM_VALUE::SYS_SPIEL_OXICE_MAX)
				|| (nType >= (int)OTS_STD_ITEM_VALUE::SYS_SPINEL_OXIDE_NITRIDE_MIN && nType <= (int)OTS_STD_ITEM_VALUE::SYS_SPINEL_OXIDE_NITRIDE_MAX)
				|| (nType >= (int)OTS_STD_ITEM_VALUE::SYS_SPINEL_OXIDE_SULFIDE_MIN && nType <= (int)OTS_STD_ITEM_VALUE::SYS_SIMPLE_OXIDE_SULFIDE_MAX))
			{
				a_nType = INC_COMMON_CLASSIFY_TYPE::SPINEL;
			}
			else if (nType >= (int)OTS_STD_ITEM_VALUE::SYS_OXIDE_MIN && nType <= (int)(int)OTS_STD_ITEM_VALUE::SYS_OXIDE_MAX)
			{
				a_nType = INC_COMMON_CLASSIFY_TYPE::OXIDE;
			}
			else if ((nType >= (int)OTS_STD_ITEM_VALUE::SYS_SIMPLE_OXIDE_SULFIDE_MIN && nType <= (int)(int)OTS_STD_ITEM_VALUE::SYS_SIMPLE_OXIDE_SULFIDE_MAX)
				|| (nType >= (int)OTS_STD_ITEM_VALUE::SYS_COMPLEX_OXIDE_SULFIDE_MIN && nType <= (int)(int)OTS_STD_ITEM_VALUE::SYS_COMPLEX_OXIDE_SULFIDE_MAX)
				|| (nType >= (int)OTS_STD_ITEM_VALUE::SYS_OXIDE_SULFIDE_MIN && nType <= (int)(int)OTS_STD_ITEM_VALUE::SYS_OXIDE_SULFIDE_MAX))
			{
				a_nType = INC_COMMON_CLASSIFY_TYPE::SULFIDE_OXIDE;
			}
			else if (nType > (int)OTS_STD_ITEM_VALUE::SYS_NITRIDE_MIN && nType <= (int)(int)OTS_STD_ITEM_VALUE::SYS_NITRIDE_MAX)
			{
				a_nType = INC_COMMON_CLASSIFY_TYPE::NITRIDE;
			}
			else if (nType > (int)OTS_STD_ITEM_VALUE::SYS_SUL_MIN && nType <= (int)(int)OTS_STD_ITEM_VALUE::SYS_SUL_MAX)
			{
				a_nType = INC_COMMON_CLASSIFY_TYPE::SULFIDE;
			}

		}
		else
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetCommonClass: this particle is not a common particle."));
			return FALSE;
		}

		// ok, return TRUE
		return TRUE;
	}

	BOOL CReportProjFileMgr::GetCommonFiveFromParticleList(COTSParticleList a_listParticle, CGridDataPtr a_pGridData)
	{
		// use the dll resource
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		ASSERT(a_pGridData);
		if (!a_pGridData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetCommonFiveFromParticleList: invalid grid data pointer."));
			return FALSE;
		}

		//// std
		//ASSERT(m_pReportProjFile);
		//if (!m_pReportProjFile)
		//{
		//	LogErrorTrace(__FILE__, __LINE__, _T("GetCommonFiveFromParticleList: empty project file."));
		//	return FALSE;
		//}

		//CPartSTDDataPtr pPartSTDData = m_pReportProjFile->GetPartSTDData();
		//ASSERT(pPartSTDData);
		//if (!pPartSTDData)
		//{
		//	LogErrorTrace(__FILE__, __LINE__, _T("GetComponentFromParticleList: invalid STD data."));
		//	return FALSE;
		//}

		//CSTDItemsList listSTDItem = pPartSTDData->GetSTDItemsList();

		//if (listSTDItem.empty())
		//{
		//	LogErrorTrace(__FILE__, __LINE__, _T("GetComponentFromParticleList: empty STD Item."));
		//	return FALSE;
		//}

		int nNumSulfideOxide = 0;
		int nNumOxide = 0;
		int nNumSulfide = 0;
		int nNumNitrides = 0;
		int nNumSpinel = 0;

		for (auto pPart : a_listParticle)
		{
			INC_COMMON_CLASSIFY_TYPE nCommonType = INC_COMMON_CLASSIFY_TYPE::INVALID;
			if (GetCommonClass(pPart, nCommonType))
			{
				if ((int)nCommonType == (int)INC_COMMON_CLASSIFY_TYPE::SULFIDE_OXIDE)
				{
					nNumSulfideOxide++;
				}
				else if ((int)nCommonType == (int)INC_COMMON_CLASSIFY_TYPE::OXIDE)
				{
					nNumOxide++;
				}
				else if ((int)nCommonType == (int)INC_COMMON_CLASSIFY_TYPE::SULFIDE)
				{
					nNumSulfide++;
				}
				else if ((int)nCommonType == (int)INC_COMMON_CLASSIFY_TYPE::NITRIDE)
				{
					nNumNitrides++;
				}
				else if ((int)nCommonType == (int)INC_COMMON_CLASSIFY_TYPE::SPINEL)
				{
					nNumSpinel++;
				}
			}
		}

		int nColumnNum = ((int)(REPORT_COMMON_FIVE_GRID_CLUMN::MAX) - (int)(REPORT_COMMON_FIVE_GRID_CLUMN::MIN) + 1);
		std::vector<CString> listColumnName;
		LoadColumnString(listColumnName, IDS_COMMON_FIVE_START, nColumnNum);

		if ((int)listColumnName.size() != nColumnNum)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetCommonFiveFromParticleList: Can't get column name number."));
			return FALSE;
		}

		CGridColumnsList listGridColumn;
		COTSParticleList listPartReport;
		for (int i = 0; i < nColumnNum; i++)
		{

			CGridColumnPtr pColumn = CGridColumnPtr(new CGridColumn());
			pColumn->SetName(listColumnName[i]);

			CGridRowsList listGridRows;
			listGridRows.clear();

			switch (i)
			{
			case (int)REPORT_COMMON_FIVE_GRID_CLUMN::SULFIDE_OXIDE:
			{
				listGridRows.clear();
				CGridRowPtr pGridRowNum = CGridRowPtr(new CGridRow());
				pGridRowNum->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				pGridRowNum->SetIntValue(nNumSulfideOxide);
				listGridRows.push_back(pGridRowNum);
			}
			break;
			case (int)REPORT_COMMON_FIVE_GRID_CLUMN::OXIDE:
			{
				listGridRows.clear();
				CGridRowPtr pGridRowNum = CGridRowPtr(new CGridRow());
				pGridRowNum->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				pGridRowNum->SetIntValue(nNumOxide);
				listGridRows.push_back(pGridRowNum);
			}
			break;
			case (int)REPORT_COMMON_FIVE_GRID_CLUMN::SULFIDE:
			{
				listGridRows.clear();
				CGridRowPtr pGridRowNum = CGridRowPtr(new CGridRow());
				pGridRowNum->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				pGridRowNum->SetIntValue(nNumSulfide);
				listGridRows.push_back(pGridRowNum);
			}
			break;
			case (int)REPORT_COMMON_FIVE_GRID_CLUMN::NITRIDES:
			{
				listGridRows.clear();
				CGridRowPtr pGridRowNum = CGridRowPtr(new CGridRow());
				pGridRowNum->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				pGridRowNum->SetIntValue(nNumNitrides);
				listGridRows.push_back(pGridRowNum);
			}
			break;
			case (int)REPORT_COMMON_FIVE_GRID_CLUMN::SPINEL:
			{
				listGridRows.clear();
				CGridRowPtr pGridRowNum = CGridRowPtr(new CGridRow());
				pGridRowNum->SetDataType(REPORT_GRID_DATA_TYPE::INT);
				pGridRowNum->SetIntValue(nNumSpinel);
				listGridRows.push_back(pGridRowNum);
			}
			break;
			}

			pColumn->SetGridRowsList(listGridRows);
			listGridColumn.push_back(pColumn);
		}

		a_pGridData->SetGridColumnList(listGridColumn);
		return TRUE;
	}

	double CReportProjFileMgr::GetValueAsMethod(COTSParticlePtr a_pParticle, OTSMODEL::SIZE_CAL_METHOD_TYPE a_nMethod, double a_dPixelSize)
	{
		double dValue = 0;

		double dArea = a_pParticle->GetArea();
		double dDiameter = 2 * sqrt(dArea / Pi);
		double dFltD;
		double dMinWidth;
		double dMaxLength;
		double dRatio;
		if (!OTSIMGPROC::CGBImgPropCal::GetParticleFTD(a_pParticle, a_dPixelSize, dFltD, dMinWidth, dMaxLength, dRatio))
		{
			return dValue;
		}

		switch ((int)a_nMethod)
		{
		case (int)SIZE_CAL_METHOD_TYPE::CIRCLE:
			dValue = dDiameter;
			break;
		case (int)SIZE_CAL_METHOD_TYPE::AREA:
			dValue = dArea;
			break;
		case (int)SIZE_CAL_METHOD_TYPE::FLTD:
			dValue = dFltD;
			break;
		case (int)SIZE_CAL_METHOD_TYPE::LENGTH:
			dValue = dMaxLength;
			break;
		case (int)SIZE_CAL_METHOD_TYPE::WIDTH:
			dValue = dMinWidth;
			break;
		}

		return dValue;
	}



	void CReportProjFileMgr::SetSelectedPicture(RETORT_PROP_GRID_PARAM_TYPE a_nType)
	{

		if (m_listPropParams.size() == 0)
		{
			ResetPropertyParams();
		}
		if (m_listPropParams.size() > 0)
		{
			switch (a_nType)
			{

			case RETORT_PROP_GRID_PARAM_TYPE::IMAGE:
				m_CurrentPropParam = m_listPropParams[0];
				break;
			case RETORT_PROP_GRID_PARAM_TYPE::TABLE:
				m_CurrentPropParam = m_listPropParams[1];
				break;
			case RETORT_PROP_GRID_PARAM_TYPE::CHART:
				m_CurrentPropParam = m_listPropParams[2];
				break;
			default:
				break;
			}
		}



	}

}