OTS/OTS_GB/OTSInterface/FieldMgrClr.cpp

#include "stdafx.h"
#include "FieldMgrClr.h"

namespace OTSINTERFACE {
	CFieldMgrClr::CFieldMgrClr()
	{
		m_LpFieldMgr = new CFieldMgrPtr(new CFieldMgr());

	}

	CFieldMgrClr::CFieldMgrClr(CFieldMgrPtr a_pFieldMgr)
	{
		ASSERT(a_pFieldMgr);
		if (!a_pFieldMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CBSEImgClr: Generate CElementChemistryClr pointer failed."));
			return;
		}
		
			m_LpFieldMgr = new CFieldMgrPtr(a_pFieldMgr);
		
		
		

	}

	CFieldMgrClr::!CFieldMgrClr()
	{
		if (m_LpFieldMgr != nullptr)
		{
			delete m_LpFieldMgr;
			m_LpFieldMgr = NULL;
		}
	}

	CFieldMgrClr::~CFieldMgrClr()
	{
		if (m_LpFieldMgr != nullptr)
		{
			delete m_LpFieldMgr;
			m_LpFieldMgr = NULL;
		}
	}
	
	

	CFieldMgrPtr CFieldMgrClr::GetCFiledMgrPtr()
	{
		return *m_LpFieldMgr;
	}

	bool CFieldMgrClr::Init(CDomainClr^ a_pMeasureArea,
		COTSImgScanPrmClr^ a_poImageScanParam,
		CSEMDataMsrClr^ a_poSEMDataMsr,
		List<Point>^ a_listMeasuredFieldCentrePoints)
	{
		ASSERT(a_pMeasureArea);
		if (!a_pMeasureArea)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Init:invalid mesaure area pointer."));
			return false;
		}

		CDomainPtr pDomain = a_pMeasureArea->GetDomainPtr();

		ASSERT(pDomain);
		if (!pDomain)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Init:invalid mesaure area pointer."));
			return false;
		}

		ASSERT(a_poImageScanParam);
		if (!a_poImageScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Init:invalid image scan pointer."));
			return false;
		}

		COTSImageScanParamPtr pImageScan = a_poImageScanParam->GetImgScanPrmPtr();

		ASSERT(pImageScan);
		if (!pImageScan)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Init:invalid image scan pointer."));
			return false;
		}

		ASSERT(a_poSEMDataMsr);
		if (!a_poSEMDataMsr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Init:invalid sem data pointer."));
			return false;
		}

		CSEMDataMsrPtr pSEMData = a_poSEMDataMsr->GetSEMDataMsrPtr();

		ASSERT(pSEMData);
		if (!pSEMData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Init:invalid sem data pointer."));
			return false;
		}

		ASSERT(a_listMeasuredFieldCentrePoints);
		if (!a_listMeasuredFieldCentrePoints)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Init:invalid list measure field center pointer."));
			return false;
		}

		std::vector<CPoint> pointlist;
		pointlist.clear();
		for (int i = 0; i< a_listMeasuredFieldCentrePoints->Count; i++)
		{
			Point opt = a_listMeasuredFieldCentrePoints[i];
			CPoint opoint;

			opoint.x = opt.X;
			opoint.y = opt.Y;

			pointlist.push_back(opoint);
		}


		CFieldMgrPtr pFieldMgr = GetCFiledMgrPtr();

		ASSERT(pFieldMgr);
		if (!pFieldMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Init: invalid pointer."));
			return false;
		}

		bool bRet = pFieldMgr->Init(pDomain, pImageScan, pSEMData, pointlist);

		return bRet;

	}


	// reset
	bool CFieldMgrClr::Reset(CDomainClr^ a_pMeasureArea,
		COTSImgScanPrmClr^ a_poImageScanParam,
		CSEMDataMsrClr^ a_poSEMDataMsr,
		List<Point>^ a_listMeasuredFieldCentrePoints)
	{
		
		ASSERT(a_pMeasureArea);
		if (!a_pMeasureArea)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Reset:invalid mesaure area pointer."));
			return false;
		}

		CDomainPtr pDomain = a_pMeasureArea->GetDomainPtr();

		ASSERT(pDomain);
		if (!pDomain)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Reset:invalid mesaure area pointer."));
			return false;
		}

		ASSERT(a_poImageScanParam);
		if (!a_poImageScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Reset:invalid image scan pointer."));
			return false;
		}

		COTSImageScanParamPtr pImageScan = a_poImageScanParam->GetImgScanPrmPtr();

		ASSERT(pImageScan);
		if (!pImageScan)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Reset:invalid image scan pointer."));
			return false;
		}

		ASSERT(a_poSEMDataMsr);
		if (!a_poSEMDataMsr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Reset:invalid sem data pointer."));
			return false;
		}

		CSEMDataMsrPtr pSEMData = a_poSEMDataMsr->GetSEMDataMsrPtr();

		ASSERT(pSEMData);
		if (!pSEMData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Reset:invalid sem data pointer."));
			return false;
		}

		ASSERT(a_listMeasuredFieldCentrePoints);
		if (!a_listMeasuredFieldCentrePoints)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Reset:invalid list measure field center pointer."));
			return false;
		}

		std::vector<CPoint> pointlist;
		pointlist.clear();
		for (int i = 0; i < a_listMeasuredFieldCentrePoints->Count; i++)
		{
			Point opt = a_listMeasuredFieldCentrePoints[i];
			CPoint opoint;
			opoint.x = opt.X;
			opoint.y = opt.Y;
			pointlist.push_back(opoint);
		}

		CFieldMgrPtr pFieldMgr = GetCFiledMgrPtr();

		ASSERT(pFieldMgr);
		if (!pFieldMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Reset: invalid pointer."));
			return false;
		}

		bool bRet = pFieldMgr->Reset(pDomain, pImageScan, pSEMData, pointlist);

		return bRet;

	}

	// calculate estimate total fields
	long CFieldMgrClr::CalculateTotalFields(CDomainClr^ a_poMeasureArea, double a_dScanFieldSizeX, Size^ a_sizeResolution)
	{
		if (this == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CalculateTotalFields:invalid pointer."));
			return -1;
		}

		ASSERT(a_poMeasureArea);
		if (!a_poMeasureArea)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CalculateTotalFields:invalid mesaure area pointer."));
			return -1;
		}

		CDomainPtr pDomain = a_poMeasureArea->GetDomainPtr();

		ASSERT(pDomain);
		if (!pDomain)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CalculateTotalFields:invalid mesaure area pointer."));
			return -1;
		}

		ASSERT(a_sizeResolution);
		if (a_sizeResolution)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CalculateTotalFields:invalid mesaure area pointer."));
			return -1;
		}

		CSize sz;
		sz.cx = a_sizeResolution->Width;
		sz.cy = a_sizeResolution->Height;

		CFieldMgrPtr pFieldMgr = GetCFiledMgrPtr();

		ASSERT(pFieldMgr);
		if (!pFieldMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Reset: invalid pointer."));
			return -1;
		}

		long lRet = pFieldMgr->CalculateTotalFields(pDomain, a_dScanFieldSizeX, sz);

		return lRet;

	}

	List<Point>^ CFieldMgrClr::GetFieldCentrePoints()
	{
		List<Point>^ NameClr = gcnew List<Point>();
		if (m_LpFieldMgr != nullptr)
		{
			std::vector<CPoint> sName = m_LpFieldMgr->get()->GetFieldCentrePoints();
			for each(auto p in sName)
			{
				NameClr->Add( Point(p.x, p.y));
			}
			
		}

		return NameClr;
	}

	// field centre points list
	bool CFieldMgrClr::GetFieldRectByIndex(int a_nIndex, System::Drawing::Rectangle^% a_rctField)
	{
	
		ASSERT(a_rctField);
		if (!a_rctField)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetFieldRectByIndex:invalid rectangle pointer."));
			return false;
		}

		CRect oRect;
		CFieldMgrPtr pFieldMgr = GetCFiledMgrPtr();

		ASSERT(pFieldMgr);
		if (!pFieldMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetFieldRectByIndex: invalid pointer."));
			return false;
		}

		bool bRet = pFieldMgr->GetFieldRectByIndex(a_nIndex, oRect);

		a_rctField->X = oRect.left;
		a_rctField->Y = oRect.top;
		a_rctField->Width = oRect.Width();
		a_rctField->Height = oRect.Height();

	
		return bRet;

	}

	int CFieldMgrClr::GetTotalFields()
	{
		return m_LpFieldMgr->get()->GetTotalFields ();
	}
	
	List<Point>^ CFieldMgrClr::GetUnmeasuredFieldCentrePoints()
	{
		List<Point>^ Pts = gcnew List<Point>();
		if (m_LpFieldMgr != nullptr)
		{
			std::vector<CPoint> ps = m_LpFieldMgr->get()->GetUnmeasuredFieldCentrePoints();
			for each(auto p in ps)
			{
				Pts->Add(Point(p.x, p.y));
			}

		}

		return Pts;
	}

	// unmeasured field centre points list
	bool CFieldMgrClr::CFieldMgrClr::UnmeasuredGetNextField(System::Drawing::Rectangle^ a_rctField)
	{

		ASSERT(a_rctField);
		if (!a_rctField)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("UnmeasuredGetNextField:invalid rectangle pointer."));
			return false;
		}

		CRect oRect;
		oRect.left = a_rctField->Left;
		oRect.top = a_rctField->Top;
		oRect.right = a_rctField->Right;
		oRect.bottom = a_rctField->Bottom;


		CFieldMgrPtr pFieldMgr = GetCFiledMgrPtr();

		ASSERT(pFieldMgr);
		if (!pFieldMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("UnmeasuredGetNextField: invalid pointer."));
			return false;
		}

		bool bRet = pFieldMgr->UnmeasuredGetNextField(oRect);

		return bRet;

	}

	bool CFieldMgrClr::CFieldMgrClr::GetUnmeasuredRandemField(System::Drawing::Rectangle^ a_rctField)
	{

		ASSERT(a_rctField);
		if (!a_rctField)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetUnmeasuredRandemField:invalid rectangle pointer."));
			return false;
		}

		CRect oRect;
		oRect.left = a_rctField->Left;
		oRect.top = a_rctField->Top;
		oRect.right = a_rctField->Right;
		oRect.bottom = a_rctField->Bottom;


		CFieldMgrPtr pFieldMgr = GetCFiledMgrPtr();

		ASSERT(pFieldMgr);
		if (!pFieldMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetUnmeasuredRandemField: invalid pointer."));
			return false;
		}

		bool bRet = pFieldMgr->GetUnmeasuredRandemField(oRect);

		return bRet;
	}

	List<Point>^ CFieldMgrClr::GetMeasuredFieldCentrePoints()
	{
		List<Point>^ Pts = gcnew List<Point>();
		if (m_LpFieldMgr != nullptr)
		{
			std::vector<CPoint> ps = m_LpFieldMgr->get()->GetMeasuredFieldCentrePoints();
			for each(auto p in ps)
			{
				Pts->Add(Point(p.x, p.y));
			}

		}

		return Pts;
	}

	void CFieldMgrClr::SetMeasuredFieldCentrePoints(List<Point>^ a_listMeasuredFieldCentrePoints)
	{
		List<Point>^ Pts = a_listMeasuredFieldCentrePoints;
		std::vector<CPoint> ps;
		if (m_LpFieldMgr != nullptr)
		{
			
			for each(auto p in Pts)
			{
				ps.push_back (CPoint(p.X, p.Y));
			}

		}
		 m_LpFieldMgr->get()->SetMeasuredFieldCentrePoints(ps);
		
	}

	CDomainClr ^ CFieldMgrClr::GetMeasureArea()
	{
		return gcnew CDomainClr(m_LpFieldMgr->get()->GetMeasureArea());
	}

	// measure area
	bool CFieldMgrClr::CFieldMgrClr::SetMeasureArea(CDomainClr^ a_pMeasureArea)
	{

		ASSERT(a_pMeasureArea);
		if (!a_pMeasureArea)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetMeasureArea:invalid measure area."));
			return false;
		}

		CFieldMgrPtr pFieldMgr = GetCFiledMgrPtr();

		ASSERT(pFieldMgr);
		if (!pFieldMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetMeasureArea: invalid pointer."));
			return false;
		}

		CDomainPtr pDomain = a_pMeasureArea->GetDomainPtr();

		ASSERT(pDomain);
		if (!pDomain)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetMeasureArea:invalid mesaure area pointer."));
			return false;
		}


		pFieldMgr->SetMeasureArea(pDomain);

		return true;


	}

	COTSImgScanPrmClr ^ CFieldMgrClr::GetImageScanParam()
	{
		return gcnew COTSImgScanPrmClr(m_LpFieldMgr->get()->GetImageScanParam());
		
	}

	// image scan parameter
	bool CFieldMgrClr::CFieldMgrClr::SetImageScanParam(COTSImgScanPrmClr^ a_poImageScanParam)
	{

		ASSERT(a_poImageScanParam);
		if (!a_poImageScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageScanParam:invalid image scan."));
			return false;
		}

		CFieldMgrPtr pFieldMgr = GetCFiledMgrPtr();

		ASSERT(pFieldMgr);
		if (!pFieldMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageScanParam: invalid pointer."));
			return false;
		}

		COTSImageScanParamPtr pImageScan = a_poImageScanParam->GetImgScanPrmPtr();

		ASSERT(pImageScan);
		if (!pImageScan)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageScanParam:invalid image scan pointer."));
			return false;
		}
		pFieldMgr->SetImageScanParam(pImageScan);

		return true;
	}

	CSEMDataMsrClr ^ CFieldMgrClr::GetSEMDataMsr()
	{
		return gcnew CSEMDataMsrClr(m_LpFieldMgr->get()->GetSEMDataMsr());
	}

	// SEM data (measurement)
	bool CFieldMgrClr::CFieldMgrClr::SetSEMDataMsr(CSEMDataMsrClr^ a_poSEMDataMsr)
	{
		ASSERT(a_poSEMDataMsr);
		if (!a_poSEMDataMsr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSEMDataMsr:invalid sem data msr."));
			return false;
		}

		CFieldMgrPtr pFieldMgr = GetCFiledMgrPtr();

		ASSERT(pFieldMgr);
		if (!pFieldMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSEMDataMsr: invalid pointer."));
			return false;
		}

		CSEMDataMsrPtr pSEMData = a_poSEMDataMsr->GetSEMDataMsrPtr();

		ASSERT(pSEMData);
		if (!pSEMData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSEMDataMsr:invalid sem data msr pointer."));
			return false;
		}

		pFieldMgr->SetSEMDataMsr(pSEMData);

		return true;
	}
}