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)
	{
		CSize resolu;
		resolu.cx = a_ResolutionSize.Width;
		resolu.cy = a_ResolutionSize.Height;
		m_LpFieldMgr = new CFieldMgrPtr(new CFieldMgr(scanFieldSize, resolu));
	}

	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,
		 int a_FieldStartMode
		)
	{
		

		CDomainPtr pDomain = a_pMeasureArea->GetDomainPtr();



		CFieldMgrPtr pFieldMgr = GetCFiledMgrPtr();

		ASSERT(pFieldMgr);
		if (!pFieldMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Init: invalid pointer."));
			return false;
		}
		
		bool bRet = pFieldMgr->Init(pDomain,a_FieldStartMode);

		return bRet;

	}

	int CFieldMgrClr::GetEffectiveFieldWidth()
	{
		CFieldMgrPtr pFieldMgr = GetCFiledMgrPtr();
		return pFieldMgr->GetEffectiveFieldWidth();
	}

	int CFieldMgrClr::GetEffectiveFieldHeight()
	{
		CFieldMgrPtr pFieldMgr = GetCFiledMgrPtr();
		return pFieldMgr->GetEffectiveFieldHeight();
	}

	

	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;
	}

	

	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;
	}

	bool CFieldMgrClr::IsThisPointInMeasureArea(Point^ p)
	{
		return m_LpFieldMgr->get()->IsThisPointInMeasureArea(CPoint(p->X, p->Y));
	}

	

	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;
	}

	bool CFieldMgrClr::FindNeighborField( List<Point>^ a_flds, Point centerField,Point% a_neighbor, int a_direction)
	{
		std::vector<CPoint> allfieldPos;
		CPoint curFld;
		CPoint neighbor;
		for (int i = 0; i < a_flds->Count; i++)
		{
			allfieldPos.push_back(CPoint(a_flds[i].X, a_flds[i].Y));
		}
		curFld.x = centerField.X;
		curFld.y = centerField.Y;

		if (m_LpFieldMgr->get()->FindNeighborField(allfieldPos, curFld, neighbor, (SORTING_DIRECTION)a_direction))
		{
			a_neighbor.X = neighbor.x;
			a_neighbor.Y = neighbor.y;
			return true;
		}
		else
		{
			return false;
		}
		
	}




}