OTS/OTS_GB/OTSModel/Measure/OTSSample.cpp

// OTSSample.cpp : implementation file
//

#include "stdafx.h"
#include "OTSData.h"
#include "OTSSample.h"

#include "OTSDATAresource.h"
#include "MultiLang.h"
namespace OTSMODEL {
	//using namespace std;
	using namespace OTSDATA;


	// constructor
	COTSSample::COTSSample()
	{
		// initialization
		Init();
	}

	// copy constructor
	COTSSample::COTSSample(const COTSSample& a_oSource)
	{
		// can't copy itself
		if (&a_oSource == this)
		{
			return;
		}

		// copy data over
		Duplicate(a_oSource);
	}

	// copy constructor
	COTSSample::COTSSample(COTSSample* a_poSource)
	{
		// input check
		ASSERT(a_poSource);
		if (!a_poSource)
		{
			return;
		}

		// can't copy itself
		if (a_poSource == this)
		{
			return;
		}

		// copy data over
		Duplicate(*a_poSource);
	}

	// =operator	
	COTSSample& COTSSample::operator=(const COTSSample& a_oSource)
	{
		// cleanup
		Cleanup();

		// copy the class data over
		Duplicate(a_oSource);

		// return class
		return *this;
	}

	// destructor
	COTSSample::~COTSSample()
	{
		// cleanup
		Cleanup();
	}

	// ==operator
	BOOL COTSSample::operator==(const COTSSample& a_oSource)
	{
		return m_strName.Compare(a_oSource.m_strName) == 0 &&
			m_strHoleName == a_oSource.m_strHoleName &&
			m_bParamLock == a_oSource.m_bParamLock &&
			m_bSwitch == a_oSource.m_bSwitch &&
			*(m_poMsrParams.get()) == *(a_oSource.m_poMsrParams.get()) &&
			*(m_poMsrArea.get()) == *(a_oSource.m_poMsrArea.get()) &&
			*(m_poSEMDataMsr.get()) == *(a_oSource.m_poSEMDataMsr.get()) &&
			*(m_poMsrStatus.get()) == *(a_oSource.m_poMsrStatus.get()) &&
			*(m_poMsrResults.get()) == *(a_oSource.m_poMsrResults.get());
	}

	// COTSSample member functions

	// public

	// serialization


	void COTSSample::Serialize(bool isStoring, tinyxml2::XMLDocument * classDoc, tinyxml2::XMLElement * rootNode)
	{
		xmls::xString xstrName;
		xmls::xString xstrHoleName;
		xmls::xBool xbParamlock;
		xmls::xBool xbSwitch;
		xmls::Slo slo;
		slo.Register("SampleName", &xstrName);
		slo.Register("HoleName", &xstrHoleName);
		slo.Register("ParamLock", &xbParamlock);
		slo.Register("Switch", &xbSwitch);
		slo.Register("MsrParams", m_poMsrParams.get());
		slo.Register("MsrArea", m_poMsrArea.get());
		slo.Register("SEMDataMsr", m_poSEMDataMsr.get());
		/*slo.Register("MsrStatus", m_poMsrStatus.get());
		slo.Register("MsrResults", m_poMsrResults.get());*/

		if (isStoring)
		{
			xstrName = m_strName;
			xstrHoleName = m_strHoleName;
			xbParamlock = m_bParamLock;
			xbSwitch = m_bSwitch;

			slo.Serialize(true, classDoc, rootNode);
		}
		else
		{
			slo.Serialize(false, classDoc, rootNode);

			m_strName = xstrName.value().c_str();
			m_strHoleName = xstrHoleName.value().c_str();
			m_bParamLock = xbParamlock.value();
			m_bSwitch = xbSwitch.value();
		}
	}
	 
	// measurement parameter 
	void COTSSample::SetMsrParams(CMsrParamsPtr a_poMsrParams)
	{
		// make sure that measure parameters is always valid
		if(!a_poMsrParams)
		{ 
			m_poMsrParams = CMsrParamsPtr(new CMsrParams());
		}
		else
		{
			m_poMsrParams = CMsrParamsPtr(new CMsrParams(a_poMsrParams.get()));
		}
	}

	// measurement area
	void COTSSample::SetMsrArea(CDomainPtr a_poMsrArea)
	{
		// make sure that measure area is always valid
		if (!a_poMsrArea)
		{
			m_poMsrArea = CDomainPtr(new CDomain());
		}
		else
		{
			m_poMsrArea = CDomainPtr(new CDomain(a_poMsrArea.get()));
		}
	}

	// SEM data (measurement)
	void COTSSample::SetSEMDataMsr(CSEMDataMsrPtr a_poSEMDataMsr)
	{
		// make sure that measure SEM data is always valid
		if (!a_poSEMDataMsr)
		{
			m_poSEMDataMsr = CSEMDataMsrPtr(new CSEMDataMsr());
		}
		else
		{
			m_poSEMDataMsr = CSEMDataMsrPtr(new CSEMDataMsr(a_poSEMDataMsr.get()));
		}
	}

	// measure status
	void COTSSample::SetMsrStatus(CMsrSampleStatusPtr a_poMsrStatus)
	{
		// make sure that measure status is always valid
		if (!a_poMsrStatus)
		{
			m_poMsrStatus = CMsrSampleStatusPtr(new CMsrSampleStatus());
		}
		else
		{ 
			m_poMsrStatus = CMsrSampleStatusPtr(new CMsrSampleStatus(a_poMsrStatus.get()));
		}
	}

	// measure results
	void COTSSample::SetMsrResults(CMsrResultsPtr a_poMsrResults) 
	{ 
		// make sure that measure results is always valid
		if (!a_poMsrResults)
		{
			m_poMsrResults = CMsrResultsPtr(new CMsrResults());
		}
		else
		{ 
			m_poMsrResults = CMsrResultsPtr(new CMsrResults(a_poMsrResults.get())); 
		}
	}
	// fields
	void COTSSample::SetFieldsData(COTSFieldDataList& a_listFieldData)
	{
		m_listFieldData.clear();

		for (auto pFieldData : a_listFieldData)
		{
			//COTSFieldDataPtr pFieldDataNew = COTSFieldDataPtr(new COTSFieldData(*pFieldData.get()));
			COTSFieldDataPtr pFieldDataNew = pFieldData;
			m_listFieldData.push_back(pFieldDataNew);
		}
	}
	// has measure results test
	BOOL COTSSample::HasMeasureResult()
	{
		// result items is not empty
		BOOL bHasResult = !(m_poMsrResults->GetResultItems().empty());
		return bHasResult;
	}

	// property item groups list
	void COTSSample::SetPropItemGrps()
	{
		// clean the list and all items in it
		for (auto poItemGroup : m_listPropItemGrps)
		{
			poItemGroup->GetItemsList().clear();
		}
		m_listPropItemGrps.clear();

		// add item groups
		for (int i = (int)OTS_SAMPLE_PROP_GRID_ITEM_GROUPS::MIN; i <= (int)OTS_SAMPLE_PROP_GRID_ITEM_GROUPS::MAX; i++)
		{
			// create a property items group 
			CPropItemGrpPtr poItemGroup = SetPropertyItemGrp((OTS_SAMPLE_PROP_GRID_ITEM_GROUPS)i);

			// add property items group into property item groups list 
			if(poItemGroup)
			{ 
				m_listPropItemGrps.push_back(poItemGroup);
			}
		}
	}
	CPropItemGrpPtr COTSSample::GetPropItemGrpByIndex(int a_nIndex)
	{
		CPropItemGrpPtr poPropItemGrp = nullptr;

		if (0 < a_nIndex || a_nIndex < (int)m_listPropItemGrps.size())
		{
			poPropItemGrp = m_listPropItemGrps[a_nIndex];
		}

		return poPropItemGrp;
	}
	CPropItemGrpPtr COTSSample::GetPropItemGrpById(OTS_SAMPLE_PROP_GRID_ITEM_GROUPS a_nId)
	{
		CPropItemGrpPtr poPropItemGrp = nullptr;

		auto itr = std::find_if(m_listPropItemGrps.begin(), m_listPropItemGrps.end(), [a_nId](CPropItemGrpPtr& p) { return p->GetGroupId() == a_nId; });
		if (itr != m_listPropItemGrps.end())
		{
			// found the property item group
			poPropItemGrp = *itr;
		}

		return poPropItemGrp;
	}
	CPropItemGrpPtr COTSSample::UpdatePropItemGrp(OTS_SAMPLE_PROP_GRID_ITEM_GROUPS a_nId)
	{
		CPropItemGrpPtr poPropItemGrp = nullptr;

		auto itr = std::find_if(m_listPropItemGrps.begin(), m_listPropItemGrps.end(), [a_nId](CPropItemGrpPtr& p) { return p->GetGroupId() == a_nId; });
		if (itr != m_listPropItemGrps.end())
		{
			// found the property item group
			poPropItemGrp = *itr;

			// create a property items group 
			CPropItemGrpPtr poItemGroupNew = SetPropertyItemGrp(a_nId);

			// update the property item group
			if (poItemGroupNew)
			{
				*(poPropItemGrp.get()) = *(poItemGroupNew.get());
			}
		}

		return poPropItemGrp;
	}	
	CPropItemPtr COTSSample::GetPropItemById(OTS_SAMPLE_PROP_GRID_ITEMS a_nId)
	{
		CPropItemPtr pPropItem = nullptr;
		if (m_listPropItemGrps.size() > 0)
		{
			for (auto poPropItemGrp : m_listPropItemGrps)
			{
				CPropItemsList& listPropItems = poPropItemGrp->GetItemsList();
				auto itr = std::find_if(listPropItems.begin(), listPropItems.end(), [a_nId](CPropItemPtr& poPropItem) { return poPropItem->GetSmplItemId() == a_nId; });
				if (listPropItems.size() > 0)
				{
					if (itr != listPropItems.end())
					{
						// found the property item
						pPropItem = *itr;
					}
				}
			}
		}
		return pPropItem;
	}
	CString COTSSample::GetItemValueStr(OTS_SAMPLE_PROP_GRID_ITEMS ItemID)
	{
		//CString strItemID = ItemId;
		CString valStr="";
		CPropItemPtr itm = this->GetPropItemById(ItemID);
		switch ((OTS_ITEM_TYPES)itm->GetTypeId())
		{
		case OTS_ITEM_TYPES::BOOL:
		{
			BOOL bflag;
			if (GetPropBOOLData(ItemID,  bflag))
			{
				valStr.Format(_T("%d"), bflag);
				/*valStr = CString(bflag.ToString());*/
			}
			
		}
		break;
		case OTS_ITEM_TYPES::INT:
		{
			int iVal = 0;
			if (GetPropIntData(ItemID,  iVal))
			{
				valStr .Format(_T("%d"),iVal);
			}
			
		}
		break;
		case OTS_ITEM_TYPES::DOUBLE:
		{
			DOUBLE dVal = 0;
			if (GetPropDoubleData(ItemID, dVal))
			{
				
				valStr.Format (_T("%.2f"),dVal);//µãºóÃ漸¸ö0¾Í±£Áô¼¸Î»                                                                          
			}
			
		}
		break;
		case OTS_ITEM_TYPES::STRING:
		{
			CString StrVal = "";
			if (GetPropStringData(ItemID,StrVal))
			{
				valStr = StrVal;
			}
			
		}
		break;
		case OTS_ITEM_TYPES::COMBO:
		{
			std::vector <CString> StrVal ;
			if (GetPropComboStrings(ItemID,  StrVal))
			{
				int index = 0;
				GetPropComboData(ItemID, index);
				if (index > (int)StrVal.size())
				{
					valStr = StrVal[0];
					break;
				}
				valStr = StrVal[index];
			}
			
		}
		break;
		case OTS_ITEM_TYPES::TIME:
		{
			COleDateTime dt ;
			if (GetPropTimeData(ItemID,  dt))
			{
				valStr = dt.Format("%Y-%m-%d %H:%M:%S");
			}
			
		}
		break;
		case OTS_ITEM_TYPES::TIME_SPAN:
		{
			COleDateTimeSpan TimeSpanValue ;
			if (GetPropTimeSpanData(ItemID,  TimeSpanValue))
			{
				int v = (int)TimeSpanValue.GetTotalSeconds();
				valStr.Format(_T("%d"), v);
			}
			
		}
		break;
		case OTS_ITEM_TYPES::FILE_LIST:
		{
		//CMsrParams object represent a project param file. It includes PartSTD file ImgProcessParam ImgScanParam XrayParam four parts content.
			int iPos = -1;
			std::vector <CString> sFileNameList ;
			if (OTS_SAMPLE_PROP_GRID_ITEMS::MEASURE_PARAM_FILE_NAME == (OTS_SAMPLE_PROP_GRID_ITEMS)ItemID)
			{
				valStr = m_poMsrParams->GetName();
				
			}

			if (OTS_SAMPLE_PROP_GRID_ITEMS::STD_FILE_NAME == (OTS_SAMPLE_PROP_GRID_ITEMS)ItemID)
			{
				valStr = m_poMsrParams->GetPartSTDData()->GetName();
				
			}

		}
		break;
		default:
			break;
		}
		return valStr;
	}


	std::vector<CString> COTSSample::GetItemComboDownList(OTS_SAMPLE_PROP_GRID_ITEMS ItemID)
	{
		//CString strItemID = ItemId;
		std::vector<CString> listStr;
			listStr.clear ();
		CPropItemPtr itm = this->GetPropItemById(ItemID);
		switch ((OTS_ITEM_TYPES)itm->GetTypeId())
		{
		case OTS_ITEM_TYPES::BOOL:
		
		break;
		case OTS_ITEM_TYPES::INT:
		
		break;
		case OTS_ITEM_TYPES::DOUBLE:
		
		break;
		case OTS_ITEM_TYPES::STRING:
		
		break;
		case OTS_ITEM_TYPES::COMBO:
		{
			
			if (GetPropComboStrings(ItemID, listStr))
			{
				
			}

		}
		break;
		case OTS_ITEM_TYPES::TIME:
		
		break;
		case OTS_ITEM_TYPES::TIME_SPAN:
		
		break;
		case OTS_ITEM_TYPES::FILE_LIST:
		{
			
		}
		break;
		default:
			break;
		}
		return listStr;
	}

	
	// BOOL data
	BOOL COTSSample::GetPropBOOLData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, BOOL& a_bValue)
	{
		switch (a_nId)
		{
		case OTS_SAMPLE_PROP_GRID_ITEMS::SWITCH:
		{
			a_bValue = m_bSwitch;
		}
		break;

		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}

		// ok, return TRUE
		return TRUE;
	}
	BOOL COTSSample::SetPropBOOLData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, BOOL a_bValue) 
	{
		switch (a_nId)
		{
		case OTS_SAMPLE_PROP_GRID_ITEMS::SWITCH:
		{
			m_bSwitch = a_bValue;
		}
		break;

		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}

		// failed, return FALSE
		return TRUE;
	}

	// int data (16)
	BOOL COTSSample::GetPropIntData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, int& a_nValue)
	{
		switch (a_nId)
		{
		case OTS_SAMPLE_PROP_GRID_ITEMS::STOP_PARAM_PARTICLE:
		{
			a_nValue = m_poMsrParams->GetImageScanParam()->GetStopParamParticles();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::STOP_PARAM_FIELD:
		{
			a_nValue = m_poMsrParams->GetImageScanParam()->GetStopParamFields();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::STOP_PARAM_TIME:
		{
			a_nValue = m_poMsrParams->GetImageScanParam()->GetStopParamMeasTime();
		}
		break;

		/*case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_AREA_MIN:
		{
			a_nValue = m_poMsrParams->GetImageProcessParam()->GetIncArea().GetStart();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_AREA_MAX:
		{
			a_nValue = m_poMsrParams->GetImageProcessParam()->GetIncArea().GetEnd();
		}
		break;*/

		case OTS_SAMPLE_PROP_GRID_ITEMS::BG_GRAY_MIN:
		{
			a_nValue = m_poMsrParams->GetImageProcessParam()->GetBGGray().GetStart();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::BG_GRAY_MAX:
		{
			a_nValue = m_poMsrParams->GetImageProcessParam()->GetBGGray().GetEnd();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_GRAY_MIN:
		{
			a_nValue = m_poMsrParams->GetImageProcessParam()->GetParticleGray().GetStart();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_GRAY_MAX:
		{
			a_nValue = m_poMsrParams->GetImageProcessParam()->GetParticleGray().GetEnd();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::LOW_COUNTS:
		{
			a_nValue = m_poMsrParams->GetXRayParam()->GetXRaySearchCount();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::ANALYSIS_COUNTS:
		{
			a_nValue = m_poMsrParams->GetXRayParam()->GetAnalyExpCount();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::ANALYSIS_RESOLUTION:
		{
			a_nValue = (int)m_poMsrParams->GetXRayParam()->GetMidAnalyAQTime();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_FIELDS:
		{
			a_nValue = m_poSEMDataMsr->GetTotalFields();
		}
		break;	

		case OTS_SAMPLE_PROP_GRID_ITEMS::COMPLETED_FIELDS:
		{
			a_nValue = m_poMsrStatus->GetCompletedFields();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_AREA:
		{
			a_nValue = m_poMsrResults->GetMeasuredArea();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_PARTICLE:
		{
			a_nValue = m_poMsrResults->GetTotalParticleNumber();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_PARTICLE_AREA:
		{
			a_nValue = m_poMsrResults->GetTotalParticleArea();
		}
		break;

		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}

		// ok, return TRUE
		return TRUE;
	}
	BOOL COTSSample::SetPropIntData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, int a_nValue)
	{
		switch (a_nId)
		{
		case OTS_SAMPLE_PROP_GRID_ITEMS::STOP_PARAM_PARTICLE:
		{
			// value validation
			if (STOP_PARAM_PARTICLE_MIN > a_nValue || a_nValue > STOP_PARAM_PARTICLE_MAX )
			{
				return FALSE;
			}

			if (m_poMsrParams->GetImageScanParam()->GetStopParamParticles() != a_nValue)
			{
				m_poMsrParams->GetImageScanParam()->SetStopParamParticles(a_nValue);
				m_poMsrStatus->SetStatus(OTS_MSR_SAMPLE_STATUS::UNMEASURED);
			}
		
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::STOP_PARAM_FIELD:
		{
			if (STOP_PARAM_FIELD_MIN > a_nValue || a_nValue > STOP_PARAM_FIELD_MAX )
			{
				return FALSE;
			}

			if (m_poMsrParams->GetImageScanParam()->GetStopParamFields() != a_nValue)
			{
				m_poMsrParams->GetImageScanParam()->SetStopParamFields(a_nValue);
				m_poMsrStatus->SetStatus(OTS_MSR_SAMPLE_STATUS::UNMEASURED);
			}
			
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::STOP_PARAM_TIME:
		{
			if (STOP_PARAM_MSR_TINE_MIN > a_nValue || a_nValue > STOP_PARAM_MSR_TINE_MAX)
			{
				return FALSE;
			}

			if (m_poMsrParams->GetImageScanParam()->GetStopParamMeasTime() != a_nValue)
			{
				m_poMsrParams->GetImageScanParam()->SetStopParamMeasTime(a_nValue);
				m_poMsrStatus->SetStatus(OTS_MSR_SAMPLE_STATUS::UNMEASURED);
			}
			
		}
		break;

		/*case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_AREA_MIN:
		{
			if (PARTICLE_AREA_MIN > a_nValue || a_nValue > PARTICLE_AREA_MAX)
			{
				return FALSE;
			}

			CIntRange oIncArea = m_poMsrParams->GetImageProcessParam()->GetIncArea();
			oIncArea.SetStart(a_nValue);
			m_poMsrParams->GetImageProcessParam()->SetIncArea(oIncArea);
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_AREA_MAX:
		{
			if (PARTICLE_AREA_MIN > a_nValue || a_nValue > PARTICLE_AREA_MAX)
			{
				return FALSE;
			}
			CIntRange oIncArea = m_poMsrParams->GetImageProcessParam()->GetIncArea();
			oIncArea.SetEnd(a_nValue);
			m_poMsrParams->GetImageProcessParam()->SetIncArea(oIncArea);
		}
		break;*/

		case OTS_SAMPLE_PROP_GRID_ITEMS::BG_GRAY_MIN:
		{
			if (GRAY_LEVEL_MIN > a_nValue || a_nValue > GRAY_LEVEL_MAX)
			{
				return FALSE;
			}
			
			if (m_poMsrParams == nullptr)
			{
				return FALSE;
			}
			
			COTSImageProcessParamPtr pImageProcessParam = m_poMsrParams->GetImageProcessParam();
			if (pImageProcessParam == nullptr)
			{
				return FALSE;
			}
			
			CIntRange oBGGray = m_poMsrParams->GetImageProcessParam()->GetBGGray();
			oBGGray.SetStart(a_nValue);
			m_poMsrParams->GetImageProcessParam()->SetBGGray(oBGGray);
			
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::BG_GRAY_MAX:
		{
			if (GRAY_LEVEL_MIN > a_nValue || a_nValue > GRAY_LEVEL_MAX)
			{
				return FALSE;
			}

			CIntRange oBGGray = m_poMsrParams->GetImageProcessParam()->GetBGGray();
			oBGGray.SetEnd(a_nValue);
			m_poMsrParams->GetImageProcessParam()->SetBGGray(oBGGray);
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_GRAY_MIN:
		{
			if (GRAY_LEVEL_MIN > a_nValue || a_nValue > GRAY_LEVEL_MAX)
			{
				return FALSE;
			}
			CIntRange oParticleGray = m_poMsrParams->GetImageProcessParam()->GetParticleGray();
			oParticleGray.SetStart(a_nValue);
			m_poMsrParams->GetImageProcessParam()->SetParticleGray(oParticleGray);
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_GRAY_MAX:
		{
			if (GRAY_LEVEL_MIN > a_nValue || a_nValue > GRAY_LEVEL_MAX)
			{
				return FALSE;
			}
			CIntRange oParticleGray = m_poMsrParams->GetImageProcessParam()->GetParticleGray();
			oParticleGray.SetEnd(a_nValue);
			m_poMsrParams->GetImageProcessParam()->SetParticleGray(oParticleGray);
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::LOW_COUNTS:
		{
			if (COUNTS_MIN > a_nValue)
			{
				return FALSE;
			}
			m_poMsrParams->GetXRayParam()->SetXRaySearchCount(a_nValue);
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::ANALYSIS_COUNTS:
		{
			if (COUNTS_MIN > a_nValue)
			{
				return FALSE;
			}
			m_poMsrParams->GetXRayParam()->SetAnalyExpCount(a_nValue);
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::ANALYSIS_RESOLUTION:
		{
			//a_nValue = (int)m_poMsrParams->GetXRayParam()->GetAnalySpeed();
			m_poMsrParams->GetXRayParam()->SetMidAnalyAQTime(a_nValue);
		}
		break;

		// read only properties, treat same as default
		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_FIELDS:
		case OTS_SAMPLE_PROP_GRID_ITEMS::COMPLETED_FIELDS:
		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_AREA:
		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_PARTICLE:
		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_PARTICLE_AREA:
		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}

		// ok, return TRUE
		return TRUE;
	}

	// double data (4)
	BOOL COTSSample::GetPropDoubleData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, double& a_dValue)
	{
		switch (a_nId)
		{
		case OTS_SAMPLE_PROP_GRID_ITEMS::MAGNIFICATION:
		{
			a_dValue = m_poSEMDataMsr->GetMagnification();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::PIXEL_SIZE:
		{
			a_dValue = CalculatePixelSize();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::WORKING_DISTANCE:
		{
			a_dValue = m_poSEMDataMsr->GetWorkingDistance();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::RADIO:
		{
			a_dValue = m_poMsrResults->GetRadio();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_AREA_MIN:
		{
			a_dValue = m_poMsrParams->GetImageProcessParam()->GetIncArea().GetStart();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_AREA_MAX:
		{
			a_dValue = m_poMsrParams->GetImageProcessParam()->GetIncArea().GetEnd();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_TO_MEASURE_AREA:
		{

			DOUBLE dFieldArea = 0; // this area should be the field area
			dFieldArea = CalculateAFieldArea();
			a_dValue = (DOUBLE)m_poSEMDataMsr->GetTotalFields() * dFieldArea;//
		}
		break;

		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}

		// ok, return TRUE
		return TRUE;
	}
	BOOL COTSSample::SetPropDoubleData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, double a_dValue) 
	{
		switch (a_nId)
		{
		case OTS_SAMPLE_PROP_GRID_ITEMS::MAGNIFICATION:
		{
			// value validation
			if (a_dValue < MAGNIFICATION_MIN || a_dValue > MAGNIFICATION_MAX)
			{
				return FALSE;
			}
			m_poSEMDataMsr->SetMagnification(a_dValue);
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::PIXEL_SIZE:
		{
			if (a_dValue < PIXELSIZE_MIN || a_dValue > PIXELSIZE_MAX)
			{
				return FALSE;
			}
			int nScanFieldSize = CalculateScanFileSize(a_dValue);
			m_poSEMDataMsr->SetScanFieldSize(nScanFieldSize);
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_AREA_MIN:
		{
			if (PARTICLE_AREA_MIN > a_dValue || a_dValue > PARTICLE_AREA_MAX)
			{
				return FALSE;
			}

			CDoubleRange oIncArea = m_poMsrParams->GetImageProcessParam()->GetIncArea();
			oIncArea.SetStart(a_dValue);
			m_poMsrParams->GetImageProcessParam()->SetIncArea(oIncArea);
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_AREA_MAX:
		{
			if (PARTICLE_AREA_MIN > a_dValue || a_dValue > PARTICLE_AREA_MAX)
			{
				return FALSE;
			}
			CDoubleRange oIncArea = m_poMsrParams->GetImageProcessParam()->GetIncArea();
			oIncArea.SetEnd(a_dValue);
			m_poMsrParams->GetImageProcessParam()->SetIncArea(oIncArea);
		}
		break;

		// read only property, tread as default. 
		case OTS_SAMPLE_PROP_GRID_ITEMS::WORKING_DISTANCE:
		case OTS_SAMPLE_PROP_GRID_ITEMS::RADIO:
		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_TO_MEASURE_AREA:
		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}

		// ok, return TRUE
		return TRUE;
	}

	// string data (7)
	BOOL COTSSample::GetPropStringData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, CString& a_strValue)
	{
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		switch (a_nId)
		{
		case OTS_SAMPLE_PROP_GRID_ITEMS::SAMPLE_NAME:
		{
			a_strValue = m_strName;
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::SAMPLE_HOLE_NAME:
		{
			a_strValue = m_strHoleName;
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::MAGNIFICATION:
		{
			a_strValue = NOT_APPLIED;
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::PIXEL_SIZE:
		{
			a_strValue = NOT_APPLIED;
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::WORKING_DISTANCE:
		{
			a_strValue = NOT_APPLIED;
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_FIELDS:
		{
			a_strValue = NOT_APPLIED;
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_TO_MEASURE_AREA:
		{
			a_strValue = NOT_APPLIED;
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::MEASURE_STATAU:
		{
			OTS_MSR_SAMPLE_STATUS nStatus = m_poMsrStatus->GetStatus();
			CString strStatus;
			strStatus= MultiLang::GetInstance().GetCStringByKey(IDS_MEASURE_STATUS_FIRST + (int)nStatus);
			a_strValue = strStatus;
		}
		break;

		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}

		// ok, return TRUE
		return TRUE;
	}
	BOOL COTSSample::SetPropStringData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, CString a_strValue)
	{
		switch (a_nId)
		{
		case OTS_SAMPLE_PROP_GRID_ITEMS::SAMPLE_NAME:
		{
			//we think the samplename as the Identification of the sample,if we change the name then reset the status.
            //so we can remeasure the sample by change the sample name.
			if (m_strName != a_strValue)		
			{
				m_strName = a_strValue;
				m_poMsrStatus = CMsrSampleStatusPtr(new CMsrSampleStatus());
			}			
		}
		break;

		// read only property, tread as default. 
		case OTS_SAMPLE_PROP_GRID_ITEMS::SAMPLE_HOLE_NAME:
		case OTS_SAMPLE_PROP_GRID_ITEMS::MAGNIFICATION:
		case OTS_SAMPLE_PROP_GRID_ITEMS::PIXEL_SIZE:
		case OTS_SAMPLE_PROP_GRID_ITEMS::WORKING_DISTANCE:
		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_FIELDS:
		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_TO_MEASURE_AREA:
		case OTS_SAMPLE_PROP_GRID_ITEMS::MEASURE_STATAU:
		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}

		// ok, return TRUE
		return TRUE;
	}

	// combo data (7)
	BOOL COTSSample::GetPropComboData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, int& a_nValue)
	{
		switch (a_nId)
		{
		case OTS_SAMPLE_PROP_GRID_ITEMS::START_MODE:
		{
			a_nValue = (int)m_poMsrParams->GetImageScanParam()->GetStartImageMode();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::STOP_MODE:
		{
			a_nValue = (int)m_poMsrParams->GetImageScanParam()->GetStopMode();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::SCAN_SPEED:
		{
			a_nValue = (int)m_poMsrParams->GetImageScanParam()->GetScanImageSpeed();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::IMAGE_RESOLUTION:
		{
			a_nValue = (int)m_poMsrParams->GetImageScanParam()->GetImagePixelSize();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::SEARCH_RESOLUTION:
		{
			a_nValue = (int)m_poMsrParams->GetXRayParam()->GetSearchSpeed();
		}
		break;

		/*case OTS_SAMPLE_PROP_GRID_ITEMS::ANALYSIS_RESOLUTION:
		{
			a_nValue = (int)m_poMsrParams->GetXRayParam()->GetAnalySpeed();
		}
		break;*/

		case OTS_SAMPLE_PROP_GRID_ITEMS::SCAN_MODE:
		{
			a_nValue = (int)m_poMsrParams->GetXRayParam()->GetScanMode();
		}
		break;
		case OTS_SAMPLE_PROP_GRID_ITEMS::STEEL_TECHNOLOGY:
		{
			a_nValue = (int)m_poMsrParams->GetSteelTechnology();
		}
		break;
		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}

		// ok, return TRUE
		return TRUE;
	}
	BOOL COTSSample::SetPropComboData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, int a_nValue)
	{
		switch (a_nId)
		{


		case OTS_SAMPLE_PROP_GRID_ITEMS::START_MODE:
		{
			if (OTS_GET_IMAGE_MODE::MIN > (OTS_GET_IMAGE_MODE)a_nValue || (OTS_GET_IMAGE_MODE)a_nValue > OTS_GET_IMAGE_MODE::MAX)
			{
				return FALSE;
			}

			m_poMsrParams->GetImageScanParam()->SetStartImageMode((OTS_GET_IMAGE_MODE)a_nValue);
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::STOP_MODE:
		{
			if (OTS_MEASURE_STOP_MODE::MIN > (OTS_MEASURE_STOP_MODE)a_nValue || (OTS_MEASURE_STOP_MODE)a_nValue > OTS_MEASURE_STOP_MODE::MAX)
			{
				return FALSE;
			}
			if (m_poMsrParams->GetImageScanParam()->GetStopMode() != (OTS_MEASURE_STOP_MODE)a_nValue)
			{
				m_poMsrParams->GetImageScanParam()->SetStopMode((OTS_MEASURE_STOP_MODE)a_nValue);
				m_poMsrStatus->SetStatus(OTS_MSR_SAMPLE_STATUS::UNMEASURED);
			}
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::SCAN_SPEED:
		{
			if (OTS_THREE_TIES_OPTIONS::MIN > (OTS_THREE_TIES_OPTIONS)a_nValue || (OTS_THREE_TIES_OPTIONS)a_nValue > OTS_THREE_TIES_OPTIONS::MAX)
			{
				return FALSE;
			}
			 m_poMsrParams->GetImageScanParam()->SetScanImageSpeed((OTS_THREE_TIES_OPTIONS)a_nValue);
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::IMAGE_RESOLUTION:
		{
			if (OTS_FIVE_TIES_OPTIONS::MIN > (OTS_FIVE_TIES_OPTIONS)a_nValue || (OTS_FIVE_TIES_OPTIONS)a_nValue > OTS_FIVE_TIES_OPTIONS::MAX)
			{
				return FALSE;
			}
			 m_poMsrParams->GetImageScanParam()->SetImagePixelSize((OTS_FIVE_TIES_OPTIONS)a_nValue);
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::SEARCH_RESOLUTION:
		{
			if (OTS_THREE_TIES_OPTIONS::MIN > (OTS_THREE_TIES_OPTIONS)a_nValue || (OTS_THREE_TIES_OPTIONS)a_nValue > OTS_THREE_TIES_OPTIONS::MAX)
			{
				return FALSE;
			}
			m_poMsrParams->GetXRayParam()->SetSearchSpeed((OTS_THREE_TIES_OPTIONS)a_nValue);
		}
		break;

		/*case OTS_SAMPLE_PROP_GRID_ITEMS::ANALYSIS_RESOLUTION:
		{
			if (OTS_THREE_TIES_OPTIONS::MIN > (OTS_THREE_TIES_OPTIONS)a_nValue || (OTS_THREE_TIES_OPTIONS)a_nValue > OTS_THREE_TIES_OPTIONS::MAX)
			{
				return FALSE;
			}
			m_poMsrParams->GetXRayParam()->SetAnalySpeed((OTS_THREE_TIES_OPTIONS)a_nValue);
		}
		break;*/

		case OTS_SAMPLE_PROP_GRID_ITEMS::SCAN_MODE:
		{
			if (OTS_X_RAY_SCAN_MODE::MIN > (OTS_X_RAY_SCAN_MODE)a_nValue || (OTS_X_RAY_SCAN_MODE)a_nValue > OTS_X_RAY_SCAN_MODE::MAX)
			{
				return FALSE;
			}
			m_poMsrParams->GetXRayParam()->SetScanMode((OTS_X_RAY_SCAN_MODE)a_nValue);
		}
		break;
		case OTS_SAMPLE_PROP_GRID_ITEMS::STEEL_TECHNOLOGY:
		{
			if (STEEL_TECHNOLOGY::MIN > (STEEL_TECHNOLOGY)a_nValue || (STEEL_TECHNOLOGY)a_nValue > STEEL_TECHNOLOGY::MAX)
			{
				return FALSE;
			}
			m_poMsrParams->SetSteelTechnology((STEEL_TECHNOLOGY)a_nValue);
		}
		break;
		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}

		// ok, return TRUE
		return TRUE;
	}
	BOOL COTSSample::GetPropComboStrings(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, std::vector<CString>& a_listComboStrings)
	{
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		// clear the strings list
		a_listComboStrings.clear();

		// set the strings list
		CString strItem;
		switch (a_nId)
		{
		case OTS_SAMPLE_PROP_GRID_ITEMS::START_MODE:
		{
			for(int i = (int)OTS_GET_IMAGE_MODE::MIN; i <= (int)OTS_GET_IMAGE_MODE::MAX; ++i)
			{
				strItem= MultiLang::GetInstance().GetCStringByKey(IDS_IMAGE_MODE_FIRST + i);
				a_listComboStrings.push_back(strItem);
			}
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::STOP_MODE:
		{
			for(int i = (int)OTS_MEASURE_STOP_MODE::MIN; i <= (int)OTS_MEASURE_STOP_MODE::MAX; ++i)
			{
				strItem= MultiLang::GetInstance().GetCStringByKey(IDS_MEASURE_STOP_MODE_FIRST + i);
				a_listComboStrings.push_back(strItem);
			}
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::SCAN_SPEED:
		case OTS_SAMPLE_PROP_GRID_ITEMS::SEARCH_RESOLUTION:
		//case OTS_SAMPLE_PROP_GRID_ITEMS::ANALYSIS_RESOLUTION:
		{
			for(int i = (int)OTS_THREE_TIES_OPTIONS::MIN; i <= (int)OTS_THREE_TIES_OPTIONS::MAX; ++i)
			{
				strItem= MultiLang::GetInstance().GetCStringByKey(IDS_THREE_TIES_OPTIONS_FIRST + i);
				a_listComboStrings.push_back(strItem);
			}
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::IMAGE_RESOLUTION:
		{
			for (int i = (int)OTS_FIVE_TIES_OPTIONS::MIN; i <= (int)OTS_FIVE_TIES_OPTIONS::MAX; ++i)
			{
				strItem = RESOLUTION_STRINGS[RESOLUTION_ID_FIRST_TIE + i];
				a_listComboStrings.push_back(strItem);
			}
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::SCAN_MODE:
		{
			for (int i = (int)OTS_X_RAY_SCAN_MODE::MIN; i <= (int)OTS_X_RAY_SCAN_MODE::MAX; ++i)
			{
				strItem= MultiLang::GetInstance().GetCStringByKey(IDS_X_RAY_SCAN_MODE_FIRST + i);
				a_listComboStrings.push_back(strItem);
			}
		}
		break;
		case OTS_SAMPLE_PROP_GRID_ITEMS::STEEL_TECHNOLOGY:
		{
			for (int i = (int)STEEL_TECHNOLOGY::MIN; i <= (int)STEEL_TECHNOLOGY::MAX; ++i)
			{
				strItem= MultiLang::GetInstance().GetCStringByKey(IDS_STEEL_TECHNOLOGY + i);
				a_listComboStrings.push_back(strItem);
			}
		}
		break;

		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}

		// ok, return TRUE
		return TRUE;
	}

	// time data
	BOOL COTSSample::GetPropTimeData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, COleDateTime& a_oValue)
	{
		switch (a_nId)
		{
		case OTS_SAMPLE_PROP_GRID_ITEMS::START_TIME:
		{
			a_oValue = m_poMsrStatus->GetStartTime();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::FINISH_TIME:
		{
			a_oValue = m_poMsrStatus->GetEndTime();
		}
		break;

		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}

		// ok, return TRUE
		return TRUE;
	}
	BOOL COTSSample::SetPropTimeData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, COleDateTime /*a_oValue*/)
	{
		switch (a_nId)
		{
		// read only property, tread as default. 
		case OTS_SAMPLE_PROP_GRID_ITEMS::START_TIME:
		case OTS_SAMPLE_PROP_GRID_ITEMS::FINISH_TIME:
		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}

		// ok, return TRUE
		return TRUE;
	}

	// time span data (1)
	BOOL COTSSample::GetPropTimeSpanData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, COleDateTimeSpan& a_oValue)
	{
		switch (a_nId)
		{
		case OTS_SAMPLE_PROP_GRID_ITEMS::USED_TIME:
		{
			a_oValue = m_poMsrStatus->GetUsedTime();
		}
		break;

		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}

		// ok, return TRUE
		return TRUE;
	}
	BOOL COTSSample::SetPropTimeSpanData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, COleDateTimeSpan /*a_oValue*/)
	{
		switch (a_nId)
		{
		// read only property, tread as default. 
		case OTS_SAMPLE_PROP_GRID_ITEMS::USED_TIME:
		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}

		// ok, return TRUE
		return TRUE;
	}

	// file list data (2)
	BOOL COTSSample::GetPropFileListData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, CString& a_strFileName)
	{
		switch (a_nId)
		{
		case OTS_SAMPLE_PROP_GRID_ITEMS::MEASURE_PARAM_FILE_NAME:
		{
			a_strFileName = m_poMsrParams->GetName();
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::STD_FILE_NAME:
		{
			a_strFileName = m_poMsrParams->GetPartSTDData()->GetName();
		}
		break;

		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}

		// ok, return TRUE
		return TRUE;
	}
	BOOL COTSSample::SetPropFileListData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, CString a_strFileName)
	{
		switch (a_nId)
		{
		case OTS_SAMPLE_PROP_GRID_ITEMS::MEASURE_PARAM_FILE_NAME:
		{
			m_poMsrParams->SetName(a_strFileName);
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::STD_FILE_NAME:
		{
			m_poMsrParams->GetPartSTDData()->SetName(a_strFileName);
		}
		break;

		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}
		// ok, return TRUE
		return TRUE;
	}

	// get related property
	BOOL COTSSample::GetRelatedPropItem(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, OTS_SAMPLE_PROP_GRID_ITEMS& a_nRelatedPropId)
	{
		switch (a_nId)
		{
		// general group
		case OTS_SAMPLE_PROP_GRID_ITEMS::SAMPLE_NAME:
		case OTS_SAMPLE_PROP_GRID_ITEMS::SAMPLE_HOLE_NAME:
		case OTS_SAMPLE_PROP_GRID_ITEMS::SWITCH:
		case OTS_SAMPLE_PROP_GRID_ITEMS::MEASURE_PARAM_FILE_NAME:
		case OTS_SAMPLE_PROP_GRID_ITEMS::STD_FILE_NAME:
		// image param group
		case OTS_SAMPLE_PROP_GRID_ITEMS::START_MODE:
		case OTS_SAMPLE_PROP_GRID_ITEMS::STOP_MODE:
		case OTS_SAMPLE_PROP_GRID_ITEMS::STOP_PARAM_PARTICLE:
		case OTS_SAMPLE_PROP_GRID_ITEMS::STOP_PARAM_FIELD:
		case OTS_SAMPLE_PROP_GRID_ITEMS::STOP_PARAM_TIME:
		case OTS_SAMPLE_PROP_GRID_ITEMS::SCAN_SPEED:
		{
			a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS::INVALID;
			return FALSE;
		}

		case OTS_SAMPLE_PROP_GRID_ITEMS::IMAGE_RESOLUTION:
		{
			a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS::PIXEL_SIZE;
		}
		break;

		// image process param
		case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_AREA_MIN:
		{
			a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_AREA_MAX;
		}
		break;
		case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_AREA_MAX:
		{
			a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_AREA_MIN;
		}
		break;
		case OTS_SAMPLE_PROP_GRID_ITEMS::BG_GRAY_MIN:
		{
			a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS::BG_GRAY_MAX;
		}
		break;
		case OTS_SAMPLE_PROP_GRID_ITEMS::BG_GRAY_MAX:
		{
			a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS::BG_GRAY_MIN;
		}
		break;
		case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_GRAY_MIN:
		{
			a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_GRAY_MAX;
		}
		break;
		case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_GRAY_MAX:
		{
			a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_GRAY_MIN;
		}
		break;
		// x-ray param
		case OTS_SAMPLE_PROP_GRID_ITEMS::SEARCH_RESOLUTION:
		case OTS_SAMPLE_PROP_GRID_ITEMS::LOW_COUNTS:
		case OTS_SAMPLE_PROP_GRID_ITEMS::ANALYSIS_RESOLUTION:
		case OTS_SAMPLE_PROP_GRID_ITEMS::SCAN_MODE:
		case OTS_SAMPLE_PROP_GRID_ITEMS::ANALYSIS_COUNTS:
		{
			a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS::INVALID;
			return FALSE;
		}
		break;

		// SEM data 
		case OTS_SAMPLE_PROP_GRID_ITEMS::MAGNIFICATION:
		{
			a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS::PIXEL_SIZE;
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::PIXEL_SIZE:
		{
			a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS::MAGNIFICATION;
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::WORKING_DISTANCE:
		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_FIELDS:
		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_TO_MEASURE_AREA:
		// measure status
		case OTS_SAMPLE_PROP_GRID_ITEMS::MEASURE_STATAU:
		case OTS_SAMPLE_PROP_GRID_ITEMS::START_TIME:
		case OTS_SAMPLE_PROP_GRID_ITEMS::USED_TIME:
		case OTS_SAMPLE_PROP_GRID_ITEMS::FINISH_TIME:
		case OTS_SAMPLE_PROP_GRID_ITEMS::COMPLETED_FIELDS:
		// measure results
		case OTS_SAMPLE_PROP_GRID_ITEMS::RADIO:
		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_AREA:
		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_PARTICLE:
		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_PARTICLE_AREA:			
		{
			a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS::INVALID;
			return FALSE;
		}
		break;

		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}

		// ok, return TRUE
		return TRUE;
	}

	// get related property item group
	BOOL COTSSample::GetRelatedPropItemGrp(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, OTS_SAMPLE_PROP_GRID_ITEM_GROUPS& a_nRelatedPropGrpId)
	{
		switch (a_nId)
		{
		// general group
		case OTS_SAMPLE_PROP_GRID_ITEMS::SAMPLE_NAME:
		case OTS_SAMPLE_PROP_GRID_ITEMS::SAMPLE_HOLE_NAME:
		case OTS_SAMPLE_PROP_GRID_ITEMS::SWITCH:
		case OTS_SAMPLE_PROP_GRID_ITEMS::MEASURE_PARAM_FILE_NAME:
		case OTS_SAMPLE_PROP_GRID_ITEMS::STD_FILE_NAME:
		// image param group
		case OTS_SAMPLE_PROP_GRID_ITEMS::START_MODE:
		{
			a_nRelatedPropGrpId = OTS_SAMPLE_PROP_GRID_ITEM_GROUPS::INVALID;
			return FALSE;
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::STOP_MODE:
		{
			a_nRelatedPropGrpId = OTS_SAMPLE_PROP_GRID_ITEM_GROUPS::IMAGE;
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEMS::STOP_PARAM_PARTICLE:
		case OTS_SAMPLE_PROP_GRID_ITEMS::STOP_PARAM_FIELD:
		case OTS_SAMPLE_PROP_GRID_ITEMS::STOP_PARAM_TIME:
		case OTS_SAMPLE_PROP_GRID_ITEMS::SCAN_SPEED:
		case OTS_SAMPLE_PROP_GRID_ITEMS::IMAGE_RESOLUTION:
			// image process param
		case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_AREA_MIN:
		case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_AREA_MAX:
		case OTS_SAMPLE_PROP_GRID_ITEMS::BG_GRAY_MIN:
		case OTS_SAMPLE_PROP_GRID_ITEMS::BG_GRAY_MAX:
		case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_GRAY_MIN:
		case OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_GRAY_MAX:
			// x-ray param
		case OTS_SAMPLE_PROP_GRID_ITEMS::SEARCH_RESOLUTION:
		case OTS_SAMPLE_PROP_GRID_ITEMS::LOW_COUNTS:
		case OTS_SAMPLE_PROP_GRID_ITEMS::ANALYSIS_RESOLUTION:
		case OTS_SAMPLE_PROP_GRID_ITEMS::SCAN_MODE:
		case OTS_SAMPLE_PROP_GRID_ITEMS::ANALYSIS_COUNTS:
		case OTS_SAMPLE_PROP_GRID_ITEMS::WORKING_DISTANCE:
		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_FIELDS:
		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_TO_MEASURE_AREA:
			// measure status
		case OTS_SAMPLE_PROP_GRID_ITEMS::MEASURE_STATAU:
		case OTS_SAMPLE_PROP_GRID_ITEMS::START_TIME:
		case OTS_SAMPLE_PROP_GRID_ITEMS::USED_TIME:
		case OTS_SAMPLE_PROP_GRID_ITEMS::FINISH_TIME:
		case OTS_SAMPLE_PROP_GRID_ITEMS::COMPLETED_FIELDS:
			// measure results
		case OTS_SAMPLE_PROP_GRID_ITEMS::RADIO:
		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_AREA:
		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_PARTICLE:
		case OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_PARTICLE_AREA:
		{
			a_nRelatedPropGrpId = OTS_SAMPLE_PROP_GRID_ITEM_GROUPS::INVALID;
			return FALSE;
		}
		break;

		default:
		{
			// something wrong, return FALSE
			return FALSE;
		}
		break;

		}

		// ok, return TRUE
		return TRUE;
	}

	// calculate pixel size 
	double COTSSample::CalculatePixelSize()
	{
		// pixel size 
		double dPixelSize = 0.0;

		// make sure SEM is valid
		if (!(*(m_poSEMDataMsr.get()) == CSEMDataMsr()))
		{
			// get scan field size
			int nScanFieldSize = m_poSEMDataMsr->GetScanFieldSize();

			// get image size
			OTS_FIVE_TIES_OPTIONS nImageSizeId = m_poMsrParams->GetImageScanParam()->GetImagePixelSize();
			long nResulotionId = RESOLUTION_ID_FIRST_TIE + (long)nImageSizeId;
			int nImageSize = RESOLUTION_VALUE[nResulotionId].cx;

			// calculate pixel size 
			dPixelSize = (double)nScanFieldSize / (double)nImageSize;
		}

		// return pixel size 
		return dPixelSize;
	}

	// calculate pixel size 
	double COTSSample::CalculateAFieldArea()
	{
		// pixel size 
		double dAFieldArea = 0.0;

		// make sure SEM is valid
		if (!(*(m_poSEMDataMsr.get()) == CSEMDataMsr()))
		{
			// get image size
			OTS_FIVE_TIES_OPTIONS nImageSizeId = m_poMsrParams->GetImageScanParam()->GetImagePixelSize();
			long nResulotionId = RESOLUTION_ID_FIRST_TIE + (long)nImageSizeId;
			int nImageSize = RESOLUTION_VALUE[nResulotionId].cx;			

			// pixel size (micros)
			double dPixelSize = 0;
			dPixelSize = CalculatePixelSize();

			// calculate pixel size 
			dAFieldArea = (double)nImageSize * (double)nImageSize * 0.75 * dPixelSize * dPixelSize * 0.000001;// mm^2
		}

		// return pixel size 
		return dAFieldArea;
	}

	BOOL COTSSample::GetBSESize(int& a_nWidth, int& a_nHeight)
	{
		// scan parameters
		CMsrParamsPtr pMsrParam = GetMsrParams();
		ASSERT(pMsrParam);
		if (!pMsrParam)
		{
			return FALSE;
		}
		COTSImageScanParamPtr pImgScanParam = pMsrParam->GetImageScanParam();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			return FALSE;
		}

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

		// get scan field size
		a_nWidth = sizePixelImage.cx;
		a_nHeight = sizePixelImage.cy;

		return TRUE;
	}

	// protected

	// cleanup 
	void COTSSample::Cleanup()
	{
		// need to do nothing at the moment
	}

	// initialization
	void COTSSample::Init()
	{
		m_strName = _T("");
		m_strHoleName = _T("");
		m_bParamLock = FALSE;
		m_bSwitch = TRUE;
		m_poMsrParams = CMsrParamsPtr(new CMsrParams());
		m_poMsrArea = CDomainPtr(new CDomain());
		m_poSEMDataMsr = CSEMDataMsrPtr(new CSEMDataMsr());
		m_poMsrStatus = CMsrSampleStatusPtr(new CMsrSampleStatus());
		m_poMsrResults = CMsrResultsPtr(new CMsrResults());
	}

	// duplication 
	void COTSSample::Duplicate(const COTSSample& a_oSource)
	{
		// initialization
		Init();

		// copy data over
		m_strName = a_oSource.m_strName;
		m_strHoleName = a_oSource.m_strHoleName;
		m_bParamLock = a_oSource.m_bParamLock;
		m_bSwitch = a_oSource.m_bSwitch;
		m_poMsrParams = CMsrParamsPtr(new CMsrParams(a_oSource.m_poMsrParams.get()));
		m_poMsrArea = CDomainPtr(new CDomain(a_oSource.m_poMsrArea.get()));
		m_poSEMDataMsr = CSEMDataMsrPtr(new CSEMDataMsr(a_oSource.m_poSEMDataMsr.get()));
		m_poMsrStatus = CMsrSampleStatusPtr(new CMsrSampleStatus(a_oSource.m_poMsrStatus.get()));
		m_poMsrResults = CMsrResultsPtr(new CMsrResults(a_oSource.m_poMsrResults.get()));
		m_listPropItemGrps = a_oSource.m_listPropItemGrps;
	}

	// create a property items group
	CPropItemGrpPtr COTSSample::SetPropertyItemGrp(OTS_SAMPLE_PROP_GRID_ITEM_GROUPS a_nGrpId)
	{
		AFX_MANAGE_STATE(AfxGetStaticModuleState());
		// property items group name
		CString strGrpName;
		strGrpName = MultiLang::GetInstance().GetCStringByKey(IDS_SAMPLE_ITEM_GROUP_NAME_FIRST + (int)a_nGrpId);
		
		// property items group
		CPropItemGrpPtr poPropItemGrp(new CPropItemGrp());
		// group name and id
		poPropItemGrp->SetName(strGrpName);
		poPropItemGrp->SetGroupId(a_nGrpId);
		// items list
		CPropItemsList a_listPropItems;
		// set group items list
		OTS_SAMPLE_PROP_GRID_ITEMS nItemId;
		CPropItemPtr poPropItem;
		BOOL bShow = TRUE;
		switch (a_nGrpId)
		{
		case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS::GENERAL:
		{
			// name
			poPropItem = CPropItemPtr(new CPropItem());
			nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::SAMPLE_NAME;
			poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::STRING, FALSE,TRUE);
			a_listPropItems.push_back(poPropItem);

			// hole
			poPropItem = CPropItemPtr(new CPropItem());
			nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::SAMPLE_HOLE_NAME;
			poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::STRING, TRUE, TRUE);
			a_listPropItems.push_back(poPropItem);

			// switch
			poPropItem = CPropItemPtr(new CPropItem());
			nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::SWITCH;
			poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::BOOL, FALSE, TRUE);
			a_listPropItems.push_back(poPropItem);

			// parameter file name
		/*	poPropItem = CPropItemPtr(new CPropItem());
			nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::MEASURE_PARAM_FILE_NAME;
			poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::FILE_LIST, FALSE, TRUE);
			a_listPropItems.push_back(poPropItem);*/

			// STD file name
			poPropItem = CPropItemPtr(new CPropItem());
			nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::STD_FILE_NAME;
			poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::FILE_LIST, FALSE, TRUE);
			a_listPropItems.push_back(poPropItem);
			// Steel technology
			poPropItem = CPropItemPtr(new CPropItem());
			nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::STEEL_TECHNOLOGY;
			poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::COMBO, FALSE, TRUE);
			a_listPropItems.push_back(poPropItem);
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS::IMAGE:
		{
			// start mode
			COTSImageScanParamPtr pScanParam = m_poMsrParams->GetImageScanParam();
			bShow = pScanParam->GetShowStartImageMode();
			if (bShow)
			{
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::START_MODE;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::COMBO, FALSE, bShow);
				a_listPropItems.push_back(poPropItem);
			}
			// stop mode
			bShow = pScanParam->GetShowStopMode();
			if (bShow)
			{
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::STOP_MODE;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::COMBO, FALSE, bShow);
				a_listPropItems.push_back(poPropItem);
			}
			// stop parameter
			switch (m_poMsrParams->GetImageScanParam()->GetStopMode())
			{
			case OTS_MEASURE_STOP_MODE::ParticleMode:
			{
				// particle
				bShow = pScanParam->GetShowParticles();
				if (bShow)
				{
					poPropItem = CPropItemPtr(new CPropItem());
					nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::STOP_PARAM_PARTICLE;
					poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::INT, FALSE, bShow);
					a_listPropItems.push_back(poPropItem);
				}
			}
			break;

			case OTS_MEASURE_STOP_MODE::FieldMode:
			{
				// field
				bShow = pScanParam->GetShowParamFields();
				if (bShow)
				{
					poPropItem = CPropItemPtr(new CPropItem());
					nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::STOP_PARAM_FIELD;
					poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::INT, FALSE, bShow);
					a_listPropItems.push_back(poPropItem);
				}
			}
			break;

			case OTS_MEASURE_STOP_MODE::TimeMode:
			{
				// used time
				bShow = pScanParam->GetShowMeasTime();
				if (bShow)
				{
					poPropItem = CPropItemPtr(new CPropItem());
					nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::STOP_PARAM_TIME;
					poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::INT, FALSE, bShow);
					a_listPropItems.push_back(poPropItem);
				}
			}
			break;

			case OTS_MEASURE_STOP_MODE::CoverMode:
			default:
			{
				// no stop parameter item
			}
			break;
			}

			// scan speed
			bShow = pScanParam->GetShowImageSpeed();
			if (bShow)
			{
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::SCAN_SPEED;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::COMBO, FALSE, bShow);
				a_listPropItems.push_back(poPropItem);
			}
			// image resolution
			bShow = pScanParam->GetShowPixelSize();
			if (bShow)
			{
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::IMAGE_RESOLUTION;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::COMBO, FALSE, bShow);
				a_listPropItems.push_back(poPropItem);
			}			
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS::IMAGE_PROCESS:
		{
			COTSImageProcessParamPtr pProcParam = m_poMsrParams->GetImageProcessParam();
			// particle area min
			bShow = pProcParam->GetShowAreaLow();
			if (bShow)
			{
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_AREA_MIN;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::DOUBLE, FALSE, bShow);
				a_listPropItems.push_back(poPropItem);
			}
			// particle area max
			bShow = pProcParam->GetShowAreaUp();
			if (bShow)
			{
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_AREA_MAX;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::DOUBLE, FALSE, bShow);
				a_listPropItems.push_back(poPropItem);
			}
			// BG gray level min
			bShow = pProcParam->GetShowBGLow();
			if (bShow)
			{
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::BG_GRAY_MIN;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::INT, FALSE, bShow);
				a_listPropItems.push_back(poPropItem);
			}
			// BG gray level max
			bShow = pProcParam->GetShowBGUp();
			if (bShow)
			{
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::BG_GRAY_MAX;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::INT, FALSE, bShow);
				a_listPropItems.push_back(poPropItem);
			}
			// particle gray level min
			bShow = pProcParam->GetShowPGLow();
			if (bShow)
			{
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_GRAY_MIN;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::INT, FALSE, bShow);
				a_listPropItems.push_back(poPropItem);
			}
			// particle gray level max
			bShow = pProcParam->GetShowPGUp();
			if (bShow)
			{
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::PARTICLE_GRAY_MAX;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::INT, FALSE, bShow);
				a_listPropItems.push_back(poPropItem);
			}
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS::XRAY:
		{/*  search xray function is not work in this release*/
			// search x-ray resolution
			//poPropItem = CPropItemPtr(new CPropItem());
			//nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::SEARCH_RESOLUTION;
			//poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::COMBO, FALSE);
			//a_listPropItems.push_back(poPropItem);

			//// low counts
			//poPropItem = CPropItemPtr(new CPropItem());
			//nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::LOW_COUNTS;
			//poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::INT, FALSE);
			//a_listPropItems.push_back(poPropItem);

			COTSXRayParamPtr pXrayParam = m_poMsrParams->GetXRayParam();
			// analysis 
			bShow = pXrayParam->GetShowSpeed();
			if (bShow)
			{
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::ANALYSIS_RESOLUTION;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::INT, FALSE, bShow);
				a_listPropItems.push_back(poPropItem);
			}
			// scan mode 
			bShow = pXrayParam->GetShowScanMode();
			if (bShow)
			{
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::SCAN_MODE;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::COMBO, FALSE, bShow);
				a_listPropItems.push_back(poPropItem);
			}
			// analysis counts 
			bShow = pXrayParam->GetShowExpCount();
			if (bShow)
			{
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::ANALYSIS_COUNTS;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::INT, FALSE, bShow);
				a_listPropItems.push_back(poPropItem);
			}
		}
		break;		
		case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS::SEM:
		{
			// does SEM data (measure) set?
			if (*(m_poSEMDataMsr.get()) == CSEMDataMsr())
			{
				// not set

				// magnification
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::MAGNIFICATION;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::STRING, TRUE, TRUE);
				a_listPropItems.push_back(poPropItem);

				// pixel size
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::PIXEL_SIZE;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::STRING, TRUE, TRUE);
				a_listPropItems.push_back(poPropItem);

				// working distance
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::WORKING_DISTANCE;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::STRING, TRUE, TRUE);
				a_listPropItems.push_back(poPropItem);

				// total field
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_FIELDS;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::INT, TRUE, TRUE);
				a_listPropItems.push_back(poPropItem);

				// total area
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_TO_MEASURE_AREA;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::DOUBLE, TRUE, TRUE);
				a_listPropItems.push_back(poPropItem);
			}
			else
			{
				// set

				// magnification
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::MAGNIFICATION;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::DOUBLE, FALSE, TRUE);
				a_listPropItems.push_back(poPropItem);

				// pixel size
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::PIXEL_SIZE;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::DOUBLE, FALSE, TRUE);
				a_listPropItems.push_back(poPropItem);

				// working distance
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::WORKING_DISTANCE;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::DOUBLE, TRUE, TRUE);
				a_listPropItems.push_back(poPropItem);

				// total field
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_FIELDS;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::INT, TRUE, TRUE);
				a_listPropItems.push_back(poPropItem);

				// total area
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_TO_MEASURE_AREA;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::DOUBLE, TRUE, TRUE);
				a_listPropItems.push_back(poPropItem);
			}
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS::MEASURE_STATUS:
		{
			// measure status 
			poPropItem = CPropItemPtr(new CPropItem());
			nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::MEASURE_STATAU;
			poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::STRING, TRUE, TRUE);
			a_listPropItems.push_back(poPropItem);

			// has measure result?
			if (HasMeasureResult())
			{
				// start time 
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::START_TIME;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::TIME, TRUE, TRUE);
				a_listPropItems.push_back(poPropItem);

				// used time 
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::USED_TIME;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::TIME_SPAN, TRUE, TRUE);
				a_listPropItems.push_back(poPropItem);

				// finish time 
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::FINISH_TIME;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::TIME, TRUE, TRUE);
				a_listPropItems.push_back(poPropItem);

				// completed fields 
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::COMPLETED_FIELDS;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::INT, TRUE, TRUE);
				a_listPropItems.push_back(poPropItem);
			}
		}
		break;

		case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS::MEASURE_RESULTS:
		{
			// has measure result?
			if (HasMeasureResult())
			{
			
				// radio 
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::RADIO;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::DOUBLE, TRUE, TRUE);
				a_listPropItems.push_back(poPropItem);

				// total measured area 
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_AREA;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::INT, TRUE, TRUE);
				a_listPropItems.push_back(poPropItem);

				// total particles 
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_PARTICLE;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::INT, TRUE, TRUE);
				a_listPropItems.push_back(poPropItem);

				// total particle area
				poPropItem = CPropItemPtr(new CPropItem());
				nItemId = OTS_SAMPLE_PROP_GRID_ITEMS::TOTAL_PARTICLE_AREA;
				poPropItem->SetSmplParameter(nItemId, OTS_ITEM_TYPES::INT, TRUE, TRUE);
				a_listPropItems.push_back(poPropItem);
			}
		}
		break;

		default:
		{
			// something wrong here, return nullptr
			return nullptr;
		}

		}
		poPropItemGrp->SetItemsList(a_listPropItems);

		// return property items group
		return poPropItemGrp;
	}
	
	// calculate scan field size
	int COTSSample::CalculateScanFileSize(double a_dPixelSize)
	{
		// scan field size
		int nScanFiledSize = 0;

		// make sure SEM is valid
		if (!(*(m_poSEMDataMsr.get()) == CSEMDataMsr()))
		{
			// get image size
			OTS_FIVE_TIES_OPTIONS nImageSizeId = m_poMsrParams->GetImageScanParam()->GetImagePixelSize();
			long nResulotionId = RESOLUTION_ID_FIRST_TIE + (long)nImageSizeId;
			int nImageSize = RESOLUTION_VALUE[nResulotionId].cx;

			// calculate scan field size
			nScanFiledSize = (int)((a_dPixelSize * (double)nImageSize) + 0.5);
		}

		// return scan field size
		return nScanFiledSize;
	}

}