OTS/OTSCPP/OTSClrInterface/ImageProClr/FieldMgrClr.cpp

#include "stdafx.h"
#include "FieldMgrClr.h"
#include "../OTSLog/COTSUtilityDllFunExport.h"

namespace OTSCLRINTERFACE {
	CFieldMgrClr::CFieldMgrClr(int scanFieldSize, Size a_ResolutionSize, int overlap)
	{
		CSize resolu;
		resolu.cx = a_ResolutionSize.Width;
		resolu.cy = a_ResolutionSize.Height;
		m_LpFieldMgr = new CFieldMgrPtr(new CFieldMgr(scanFieldSize, resolu, overlap));
	}

	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,
		Size^ a_ResolutionSize,int a_scanfieldsize, int a_FieldStartMode
		)
	{
		

		CDomainPtr pDomain = a_pMeasureArea->GetDomainPtr();



		CFieldMgrPtr pFieldMgr = GetCFiledMgrPtr();

		ASSERT(pFieldMgr);
		if (!pFieldMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Init: invalid pointer."));
			return false;
		}
		CSize resolu;
		resolu.cx = a_ResolutionSize->Width;
		resolu.cy = a_ResolutionSize->Height;
		bool bRet = pFieldMgr->Init(pDomain, resolu,a_scanfieldsize,a_FieldStartMode);

		return bRet;

	}


	// reset
	bool CFieldMgrClr::Reset(CDomainClr^ a_pMeasureArea,
		Size^ a_ResolutionSize, int a_FieldStartMode,
		int a_scanFieldSize,
		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_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;
		}
		CSize resolu;
		resolu.cx = a_ResolutionSize->Width;
		resolu.cy = a_ResolutionSize->Height;
		bool bRet = pFieldMgr->Reset(pDomain, resolu,a_FieldStartMode,a_scanFieldSize, 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 ();
	}
	
	SortedList<int,Point>^ CFieldMgrClr::GetUnmeasuredFieldCentrePoints(List<Point>^ a_listMeasuredFieldCentrePoints)
	{
		SortedList<int,Point>^ Pts = gcnew SortedList<int,Point>();
		std::vector<CPoint> measuredPoint;
		for (int i = 0; i < a_listMeasuredFieldCentrePoints->Count; i++)
		{
			measuredPoint.push_back(CPoint(a_listMeasuredFieldCentrePoints[i].X, a_listMeasuredFieldCentrePoints[i].Y));
		}
		if (m_LpFieldMgr != nullptr)
		{
			std::vector<CPoint> ps = m_LpFieldMgr->get()->GetUnmeasuredFieldCentrePoints(measuredPoint);
			for (int i=0;i<ps.size();i++)
			{
				auto p = ps[i];
				Pts->Add(i,Point(p.x, p.y));
			}

		}

		return Pts;
	}

	

	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;


	}

	int CFieldMgrClr::GetOverlap()
	{
		return m_LpFieldMgr->get()->GetOverlap();
	}

	// measure area
	bool CFieldMgrClr::CFieldMgrClr::SetOverlap(int a_overlap)
	{
		m_LpFieldMgr->get()->SetOverlap(a_overlap);

		return true;
	}




}