OTS/OTS_GB/OTSModel/Report/MeasureResultInfo.cpp

#include "stdafx.h"
#include "MeasureResultInfo.h"
#include "OTSFileSys.h"
#include "OTSHelper.h"
#include "PropParam.h"
#include "ReportProjFile.h"
#include "SmplMsrResultFileMgr.h"
//#include "GridIn.h"
#include "GridData.h"
#include<math.h>
#include<list>
#include "MultiLang.h"

//测量结果信息表格
namespace OTSMODEL
{
	using namespace std;

	MeasureResultInfo::MeasureResultInfo(CReportProjFileMgr* rptMgrPtr)
	{
		m_RptMgrPtr = rptMgrPtr;
	}

	MeasureResultInfo::~MeasureResultInfo()
	{
	}
	CGridDatasList MeasureResultInfo::GetMeasureResultInfo()
	{
		// 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> listDataSourceOut = m_rptMgrPtr->GetFullDataSource(a_pGridIn, listWorkIndex, listPos);
		std::vector<CString> listDataSource = m_RptMgrPtr->GetCurrentPropParam()->GetDataSourceList();
		int nSelectedDataSourceIndex = m_RptMgrPtr->GetCurrentPropParam()->GetDataSourceId();
		CString sDataSourceNames = listDataSource[nSelectedDataSourceIndex];
		std::vector<CString> listSelectedDataSource = COTSHelper::SplitString(sDataSourceNames, _T("+"));
		
		for (auto strDataSourceName : listSelectedDataSource)
		{
			CGridDataPtr pGridData = CGridDataPtr(new CGridData());

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

			int nDataSourceId = m_RptMgrPtr->GetCurrentPropParam()->GetDataSourceId();
			pGridData->SetDataSourceId(nDataSourceId);

			int nColumnNum = 2;
			CGridColumnsList listGridColumn;

			for (int i = 0; i < nColumnNum; i++)
			{
				CGridColumnPtr pColumn = CGridColumnPtr(new CGridColumn);

				CGridRowsList listGridRows;
				listGridRows.clear();

				switch (i)
				{
				case (int)REPORT_MEASURE_RESULT_INFO_GRID_CLUMN::NAME:
				{
					pColumn->SetName("infoName");
					listGridRows.clear();
					std::list<CString> listMsrResultReport;
					for (int i = 0; i < RESULT_INFOR_STRING_NUMBER; i++)
					{
						CString str;
						str=MultiLang::GetInstance ().GetCStringByKey (IDS_RESULT_INFOR_NAME_FIRST + i);
						listMsrResultReport.push_back(str);
					}
					list<CString>::iterator it;
					for (it = listMsrResultReport.begin(); it != listMsrResultReport.end(); it++)
					{
						CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
						pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
						pGridRow->SetStringValue(*it);
						listGridRows.push_back(pGridRow);
					}
					break;
				}
				case (int)REPORT_MEASURE_RESULT_INFO_GRID_CLUMN::INFORMATIN:
				{
					pColumn->SetName("Sample");
					listGridRows.clear();
					list<CString> ListValue;

					//获得指针的值
					CSmplMsrResultFileMgrPtr rstFilePtr = m_RptMgrPtr->GetASmplMsrResultMgrByFileName(strDataSourceName);
					ASSERT(rstFilePtr);
					if (!rstFilePtr) {
						LogErrorTrace(__FILE__, __LINE__, _T("MeasureResultInfo: invalid rstFilePtr."));
						return listGridData;
					}

					CSmplMsrResultFilePtr rstFile = rstFilePtr->GetSmplMsrResultFile();
					ASSERT(rstFile);
					if (!rstFile) {
						LogErrorTrace(__FILE__, __LINE__, _T("MeasureResultInfo: invalid rstFile."));
						return listGridData;
					}

					COTSSamplePtr smpRst = rstFile->GetSample();

					ASSERT(smpRst);
					if (!smpRst) {
						LogErrorTrace(__FILE__, __LINE__, _T("MeasureResultInfo: invalid smpRst."));
						return listGridData;
					}

					double dPixelSize = smpRst->CalculatePixelSize();
					double dAFieldArea = smpRst->CalculateAFieldArea();

					//数据源名称
					ListValue.push_back(strDataSourceName);
					//运行已开始
					COleDateTime ole_startTime = smpRst->GetMsrStatus()->GetStartTime();
					ASSERT(ole_startTime);
					if (!ole_startTime) {
						LogErrorTrace(__FILE__, __LINE__, _T("MeasureResultInfo: invalid ole_startTime."));
						return listGridData;
					}

					CString strStartTime;
					strStartTime = ole_startTime.Format(MSR_RESULT_INFOR_YMD);
					CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
					pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
					ListValue.push_back(strStartTime);

					//运行已结束
					COleDateTime ole_endTime = smpRst->GetMsrStatus()->GetEndTime();
					ASSERT(ole_endTime);
					if (!ole_endTime) {
						LogErrorTrace(__FILE__, __LINE__, _T("MeasureResultInfo: invalid ole_endTime."));
						return listGridData;
					}

					CString strEndTime;
					strEndTime = ole_endTime.Format(MSR_RESULT_INFOR_YMD);
					ListValue.push_back(strEndTime);

					//运行时间
					COleDateTimeSpan ts = ole_endTime - ole_startTime;
					CString str;
					str.Format(MSR_RESULT_INFOR_FOUR, ts.m_span * 1440);
					CString Character = MSR_RESULT_INFOR_MINUTES;
					CString strRunTime = str + Character;
					ListValue.push_back(strRunTime);

					//视场总数
					int allFieldsNum = smpRst->GetMsrStatus()->GetCompletedFields();
					ASSERT(allFieldsNum);
					if (!allFieldsNum) {
						LogErrorTrace(__FILE__, __LINE__, _T("MeasureResultInfo: invalid allFieldsNum."));
						return listGridData;
					}

					CString HallFieldsNum;
					HallFieldsNum.Format(_T("%d"), allFieldsNum);
					ListValue.push_back(HallFieldsNum);

					//分类方案
					CString classifyMethod = _T("InclCleanSteel(1)");
					ListValue.push_back(classifyMethod);

					//已检测特征
					int featureNum = smpRst->GetMsrResults()->GetTotalParticleNumber();
					ASSERT(featureNum);
					if (!featureNum) {
						LogErrorTrace(__FILE__, __LINE__, _T("MeasureResultInfo: invalid featureNum."));
						return listGridData;
					}

					CString HfeatureNum;
					HfeatureNum.Format(_T("%d"), featureNum);
					ListValue.push_back(HfeatureNum);


					CSmplMsrResultFilePtr restFile = rstFilePtr->GetSmplMsrResultFile();
					COTSFieldDataList FieldData = restFile->GetFieldData();
					double dFieldArea = smpRst->CalculateAFieldArea();

					//获取有效的分析颗粒数量
					int nEffectiveParticleNum = GetEffectiveParticleNum(FieldData);
					CString strEffectiveParticleNum;
					strEffectiveParticleNum.Format(_T("%d"), nEffectiveParticleNum);
					ListValue.push_back(strEffectiveParticleNum);

					//视场面积
					int fieldArea = smpRst->GetMsrResults()->GetMeasuredArea();
					CString HfieldArea;
					HfieldArea.Format(_T("%d"), fieldArea);
					ListValue.push_back(HfieldArea);

					//已分析的特征面积
					int MsrPArea = smpRst->GetMsrResults()->GetTotalParticleArea();
					CString HMsrPArea;
					HMsrPArea.Format(_T("%d"), MsrPArea);
					ListValue.push_back(HMsrPArea);

					//已检测的特征面积
					double MsrArea;
					double dScale = m_RptMgrPtr->GetReportProjFile()->GetScale();
					if (0 == fieldArea)
					{
						MsrArea = 0;
					}
					else
					{
						MsrArea = dScale * (double)MsrPArea / (double)fieldArea;
					}

					//面积为零的情况判断
					CString HMsrArea;
					if (0 == MsrArea)
					{
						HMsrArea = _T("0");
						ListValue.push_back(HMsrArea);
					}
					else 
					{	
						HMsrArea.Format(_T("%f"), MsrArea);
						ListValue.push_back(HMsrArea);
					}

					//纳入指数
					CString sScale;
					sScale.Format(_T("%f"), dScale);
					ListValue.push_back(sScale);
					
					//参考标准
					CString refStandard = _T("GB/T30834-2014");
					ListValue.push_back(refStandard);

					//单个Field夹杂物面积占比
					int nPerMicroNum = GetNumPerMicro(FieldData, dFieldArea);
					CString strPerMicroNum;
					strPerMicroNum.Format(_T("%d"), nPerMicroNum);
					ListValue.push_back(strPerMicroNum);

					//单个Field夹杂物面积占比				
					double dPerMicroArea = GetAreaPerMicro(FieldData, dFieldArea);
					CString strPerMicroArea;
					strPerMicroArea.Format(_T("%f"), dPerMicroArea);
					ListValue.push_back(strPerMicroArea);

					//  insert value to grid list
					for (list<CString>::iterator its = ListValue.begin(); its != ListValue.end(); its++)
					{
						CGridRowPtr pGridRow = CGridRowPtr(new CGridRow());
						pGridRow->SetDataType(REPORT_GRID_DATA_TYPE::STRING);
						pGridRow->SetStringValue(*its);
						listGridRows.push_back(pGridRow);
					}
					break;	
				}
				}
				pColumn->SetGridRowsList(listGridRows);
				listGridColumn.push_back(pColumn);
			}
			pGridData->SetGridColumnList(listGridColumn);
			listGridData.push_back(pGridData);
			
		}

		return listGridData;
	}
	int MeasureResultInfo::GetNumPerMicro(COTSFieldDataList a_listFieldData, double a_dFieldArea)
	{
		int nPartNumMax = 0;
		for (auto pField : a_listFieldData)
		{
			COTSParticleList listPart =  pField->GetParticleList();

			if (nPartNumMax < (int)listPart.size())
			{
				nPartNumMax = (int)listPart.size();
			}
		}

		int nResult = 0;
		if(0!= a_dFieldArea)
		{ 
			nResult = ceil((double)nPartNumMax / a_dFieldArea);
		}
		return nResult;
	}

	//获取有效的分析颗粒数量
	int MeasureResultInfo::GetEffectiveParticleNum(COTSFieldDataList a_listFieldData)
	{
		int retEffectiveParticleNum = 0;
		for (auto pField : a_listFieldData)
		{
			COTSParticleList listPart = pField->GetParticleList();
			for (auto pPart : listPart)
			{
				//大于识别颗粒的分类都是有效颗粒
				if (pPart->GetType() > (int)OTS_PARTCLE_TYPE::IDENTIFIED)
				{
					retEffectiveParticleNum++;
				}
			}
		}

		return retEffectiveParticleNum;
	}

	double MeasureResultInfo::GetAreaPerMicro(COTSFieldDataList a_listFieldData, double a_dFieldArea)
	{
		double dPartArea = 0;
		double dPartSumArea = 0; 
		double dPartAreaMax = 0;

		for (auto pField : a_listFieldData)
		{
			COTSParticleList listPart = pField->GetParticleList();
			for (auto pParticle : listPart)
			{
				dPartArea = (double)pParticle->GetArea();
				dPartSumArea += dPartArea;

				if (dPartSumArea > dPartAreaMax)
				{
					dPartAreaMax = dPartSumArea;
				}
			}
		}
		double dResult = 0;
		if(0!= a_dFieldArea)
		{ 
			dResult = dPartAreaMax / (1000000 * a_dFieldArea);
		}
		
		return dResult;
	}
}