#include "stdafx.h"
#include "OTSImgProcPrmClr.h"
namespace OTSINTERFACE {


	COTSImgProcPrmClr::COTSImgProcPrmClr()
	{
		m_LpImgProParam = new COTSImageProcessParamPtr(new COTSImageProcessParam());
	}

	COTSImgProcPrmClr::COTSImgProcPrmClr(COTSImageProcessParam* a_pImgProParam)			// copy constructor
	{
		ASSERT(a_pImgProParam);
		if (!a_pImgProParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CGenParamClr: Generate GenParam pointer failed."));
			return;
		}

		m_LpImgProParam = new COTSImageProcessParamPtr(new COTSImageProcessParam(a_pImgProParam));
	}
	
	COTSImgProcPrmClr::COTSImgProcPrmClr(COTSImageProcessParamPtr a_pImgProParam)					// copy constructor
	{
		ASSERT(a_pImgProParam);
		if (!a_pImgProParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CGenParamClr: invalid pointer"));
			return;
		}

			m_LpImgProParam = new COTSImageProcessParamPtr(a_pImgProParam);
	
	}

	COTSImgProcPrmClr::!COTSImgProcPrmClr()
	{
		if (m_LpImgProParam != nullptr)
		{
			delete m_LpImgProParam;
			m_LpImgProParam = nullptr;
		}
	}

	COTSImgProcPrmClr::~COTSImgProcPrmClr()
	{
		if (m_LpImgProParam != nullptr)
		{
			delete m_LpImgProParam;
			m_LpImgProParam = nullptr;
		}
	}

	COTSImageProcessParamPtr COTSImgProcPrmClr::GetImgPrcPrmPtr()
	{
		return *m_LpImgProParam;
	}

	CDoubleRangeClr^ COTSImgProcPrmClr::GetIncArea()
	{
		auto pGray = m_LpImgProParam->get()->GetIncArea();
		CDoubleRange* gray = new  CDoubleRange(pGray);
		CDoubleRangeClr^ doubleRan = gcnew CDoubleRangeClr(CDoubleRangePtr(gray));
		return doubleRan;
	}


	void COTSImgProcPrmClr::SetIncArea(CDoubleRangeClr^ a_oVal)
	{
		m_LpImgProParam->get()->SetIncArea(*(a_oVal->GetCDoubleRangePtr().get()));
	}

	bool COTSImgProcPrmClr::GetShowAreaUp()
	{
		if (m_LpImgProParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowAreaUp: invalid pointer"));
			return false;
		}
		COTSImageProcessParamPtr pImgProcParam = GetImgPrcPrmPtr();
		ASSERT(pImgProcParam);
		if (!pImgProcParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowAreaUp: invalid pointer"));
			return false;
		}
		bool ImgProcParam = pImgProcParam->GetShowAreaUp();
		return ImgProcParam;
	}
	void COTSImgProcPrmClr::SetShowAreaUp(bool a_bValue)
	{
		if (m_LpImgProParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowAreaUp: invalid pointer"));
			return;
		}
		COTSImageProcessParamPtr pImgProcParam = GetImgPrcPrmPtr();
		ASSERT(pImgProcParam);
		if (!pImgProcParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowAreaUp: invalid pointer"));
			return;
		}
		return pImgProcParam->SetShowAreaUp(a_bValue);
	}

	bool COTSImgProcPrmClr::GetShowAreaLow()
	{
		if (m_LpImgProParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowAreaLow: invalid pointer"));
			return false;
		}
		COTSImageProcessParamPtr pImgProcParam = GetImgPrcPrmPtr();
		ASSERT(pImgProcParam);
		if (!pImgProcParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowAreaLow: invalid pointer"));
			return false;
		}
		bool ImgProcParam = pImgProcParam->GetShowAreaLow();
		return ImgProcParam;
	}
	void COTSImgProcPrmClr::SetShowAreaLow(bool a_bValue)
	{
		if (m_LpImgProParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowAreaLow: invalid pointer"));
			return;
		}
		COTSImageProcessParamPtr pImgProcParam = GetImgPrcPrmPtr();
		ASSERT(pImgProcParam);
		if (!pImgProcParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowAreaLow: invalid pointer"));
			return;
		}
		return pImgProcParam->SetShowAreaLow(a_bValue);
	}

	CIntRangeClr^ COTSImgProcPrmClr::GetBGGray()
	{
		auto pGray = m_LpImgProParam->get()->GetBGGray();
		CIntRange* gray = new  CIntRange(pGray);
		CIntRangeClr^ intRan = gcnew CIntRangeClr(CIntRangePtr(gray));
		return intRan;
		}

	void COTSImgProcPrmClr::SetBGGray(CIntRangeClr^ a_oVal)
	{
		ASSERT(a_oVal);
		if (!a_oVal)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetBGGray: invalid data."));
			return;
		}

		if (m_LpImgProParam != nullptr)
		{
			CIntRangePtr pSetBGGray = a_oVal->GetCIntRangePtr();
			ASSERT(pSetBGGray);
			if (!pSetBGGray)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("SetBGGray: invalid pointer."));
				return;
			}
			m_LpImgProParam->get()->SetBGGray(*pSetBGGray.get());
		}
	}

	bool COTSImgProcPrmClr::GetShowBGUp()
	{
		if (m_LpImgProParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowBGUp: invalid pointer"));
			return false;
		}
		COTSImageProcessParamPtr pImgProcParam = GetImgPrcPrmPtr();
		ASSERT(pImgProcParam);
		if (!pImgProcParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowBGUp: invalid pointer"));
			return false;
		}
		bool ImgProcParam = pImgProcParam->GetShowBGUp();
		return ImgProcParam;
	}
	void COTSImgProcPrmClr::SetShowBGUp(bool a_bValue)
	{
		if (m_LpImgProParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowBGUp: invalid pointer"));
			return;
		}
		COTSImageProcessParamPtr pImgProcParam = GetImgPrcPrmPtr();
		ASSERT(pImgProcParam);
		if (!pImgProcParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowBGUp: invalid pointer"));
			return;
		}
		return pImgProcParam->SetShowBGUp(a_bValue);
	}

	bool COTSImgProcPrmClr::GetShowBGLow()
	{
		if (m_LpImgProParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowBGLow: invalid pointer"));
			return false;
		}
		COTSImageProcessParamPtr pImgProcParam = GetImgPrcPrmPtr();
		ASSERT(pImgProcParam);
		if (!pImgProcParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowBGLow: invalid pointer"));
			return false;
		}
		bool ImgProcParam = pImgProcParam->GetShowBGLow();
		return ImgProcParam;
	}
	void COTSImgProcPrmClr::SetShowBGLow(bool a_bValue)
	{
		if (m_LpImgProParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowBGLow: invalid pointer"));
			return;
		}
		COTSImageProcessParamPtr pImgProcParam = GetImgPrcPrmPtr();
		ASSERT(pImgProcParam);
		if (!pImgProcParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowBGLow: invalid pointer"));
			return;
		}
		return pImgProcParam->SetShowBGLow(a_bValue);
	}

	CIntRangeClr^ COTSImgProcPrmClr::GetParticleGray()
	{
		auto pGray= m_LpImgProParam->get()->GetParticleGray();
		CIntRange* gray =new  CIntRange(pGray);
		CIntRangeClr^ intRan = gcnew CIntRangeClr(CIntRangePtr(gray));
		return intRan;
	}

	void COTSImgProcPrmClr::SetParticleGray(CIntRangeClr^ a_oVal)
	{
		m_LpImgProParam->get()->SetParticleGray(*(a_oVal->GetCIntRangePtr().get()));
	}

	bool COTSImgProcPrmClr::GetShowPGUp()
	{
		if (m_LpImgProParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowPGUp: invalid pointer"));
			return false;
		}
		COTSImageProcessParamPtr pImgProcParam = GetImgPrcPrmPtr();
		ASSERT(pImgProcParam);
		if (!pImgProcParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowPGUp: invalid pointer"));
			return false;
		}
		bool ImgProcParam = pImgProcParam->GetShowPGUp();
		return ImgProcParam;
	}
	void COTSImgProcPrmClr::SetShowPGUp(bool a_bValue)
	{
		if (m_LpImgProParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowPGUp: invalid pointer"));
			return;
		}
		COTSImageProcessParamPtr pImgProcParam = GetImgPrcPrmPtr();
		ASSERT(pImgProcParam);
		if (!pImgProcParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowPGUp: invalid pointer"));
			return;
		}
		return pImgProcParam->SetShowPGUp(a_bValue);
	}

	bool COTSImgProcPrmClr::GetShowPGLow()
	{
		if (m_LpImgProParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowPGLow: invalid pointer"));
			return false;
		}
		COTSImageProcessParamPtr pImgProcParam = GetImgPrcPrmPtr();
		ASSERT(pImgProcParam);
		if (!pImgProcParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowPGLow: invalid pointer"));
			return false;
		}
		bool ImgProcParam = pImgProcParam->GetShowPGLow();
		return ImgProcParam;
	}
	void COTSImgProcPrmClr::SetShowPGLow(bool a_bValue)
	{
		if (m_LpImgProParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowPGLow: invalid pointer"));
			return;
		}
		COTSImageProcessParamPtr pImgProcParam = GetImgPrcPrmPtr();
		ASSERT(pImgProcParam);
		if (!pImgProcParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowPGLow: invalid pointer"));
			return;
		}
		return pImgProcParam->SetShowPGLow(a_bValue);
	}
}