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,
		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 ();
	}
	
	List<Point>^ CFieldMgrClr::GetUnmeasuredFieldCentrePoints(List<Point>^ a_listMeasuredFieldCentrePoints)
	{
		List<Point>^ Pts = gcnew List<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 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;


	}






}