OTS/OTSCPP/OTSControl/Bruker/OTSEDSBrucker.cpp

#include "stdafx.h"
#include "OTSEDSBrucker.h"

namespace OTSController {

	// constructor
	COTSEDSBrucker::COTSEDSBrucker(void)
	{
	}

	// destructor
	COTSEDSBrucker::~COTSEDSBrucker(void)
	{
	}



	/// Finished the instance.
	void COTSEDSBrucker::FinishedInstance()
	{
		m_pBrukerImpl.reset();
	}

	// initialization
	BOOL COTSEDSBrucker::Init()
	{
		// create bruker controller if necessary
		if (!m_pBrukerImpl)
		{
			// create bruker controller
			m_pBrukerImpl = COTSBrukerImpl::GetInstance();
		}

		// check if bruker controller is alright
		ASSERT(m_pBrukerImpl);
		if (!m_pBrukerImpl)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::Init: failed to create bruker controller."));
			return FALSE;
		}

		// initialize bruker controller (as xray controller)
		if (!m_pBrukerImpl->Init(CONTROL_TYPE::BRUKER_XRAY))
		{
			// failed to initialize bruker controller 
			LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::Init: failed to initialize bruker controller."));
			return FALSE;
		}

		// ok, return TRUE
		return TRUE;
	}

	

	// collect spectrum at the given position (to controller buffer)
	BOOL COTSEDSBrucker::CollectSpectrum(DWORD a_nMilliseconds, const CPoint& a_oPoint)
	{
		

		// check bruker controller
		ASSERT(m_pBrukerImpl);
		if (!m_pBrukerImpl)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::CollectSpectrum: invalid m_pBrukerImpl."));
			return FALSE;
		}

		// collect spectrum data
		if (!m_pBrukerImpl->CollectOneXRayPoint(a_oPoint, a_nMilliseconds, (long*)m_nRayData, (DWORD)EDSConst::XANA_CHANNELS))
		{
			// failed to call bruker controller CollectOneXRayPoint method
			LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::CollectSpectrum: failed to call bruker controller CollectOneXRayPoint method."));
			return FALSE;
		}

		// ok, return TRUE
		return TRUE;
	}

	// collects spectrum (to controller buffer)
	BOOL COTSEDSBrucker::CollectSpectrum(DWORD a_nMilliseconds)
	{
		

		// check bruker controller
		ASSERT(m_pBrukerImpl);
		if (!m_pBrukerImpl)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::CollectSpectrum: invalid m_pBrukerImpl."));
			return FALSE;
		}

		// collect spectrum data
		if (!m_pBrukerImpl->CollectSpectrum(a_nMilliseconds, (long*)m_nRayData, (DWORD)EDSConst::XANA_CHANNELS))
		{
			// failed to call bruker controller CollectSpectrum method
			LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::CollectSpectrum: failed to call bruker controller CollectSpectrum method."));
			return FALSE;
		}

		// ok, return TRUE
		return TRUE;
	}

	// collects spectrum (to given buffer)
	BOOL COTSEDSBrucker::CollectSpectrum(DWORD a_nMilliseconds, long* a_pCounts, DWORD a_nBufferSize)
	{
		// input check
		ASSERT(a_pCounts);
		if (!a_pCounts)
		{
			// invalid input data buffer
			LogTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::CollectSpectrum: invalid input data buffer."));
			return FALSE;
		}

		

		// check bruker controller
		ASSERT(m_pBrukerImpl);
		if (!m_pBrukerImpl)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::CollectSpectrum: invalid m_pBrukerImpl."));
			return FALSE;
		}

		// collect spectrum data
		if (!m_pBrukerImpl->CollectSpectrum(a_nMilliseconds, a_pCounts, a_nBufferSize))
		{
			// failed to call bruker controller CollectSpectrum method
			LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::CollectSpectrum: failed to call bruker controller CollectSpectrum method."));
			return FALSE;
		}

		// ok, return TRUE
		return TRUE;
	}

	// get live time
	float COTSEDSBrucker::GetLiveTime()
	{
		

		// check bruker controller
		ASSERT(m_pBrukerImpl);
		if (!m_pBrukerImpl)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::CollectSpectrum: invalid m_pBrukerImpl."));
			return 0.0;
		}

		// get time value from the controller
		float fRet;
		fRet = m_pBrukerImpl->GetLiveTime();

		return fRet;
	}

	BOOL COTSEDSBrucker::IsSupportQuantification()
	{
		

		return TRUE;
	}

	BOOL COTSEDSBrucker::GetQuantificationMethods(std::vector<CString>& a_vMethods)
	{
		
		// check bruker controller
		ASSERT(m_pBrukerImpl);
		if (!m_pBrukerImpl)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::GetQuantificationMethods: invalid m_pBrukerImpl."));
			return FALSE;
		}

		return m_pBrukerImpl->GetQuantificationMethods(a_vMethods);
	}

	BOOL COTSEDSBrucker::QuantifyXrayPoint(CPosXray* a_pXRayPoint, LPCTSTR a_sMethodName)
	{
		
		// check bruker controller
		ASSERT(m_pBrukerImpl);
		if (!m_pBrukerImpl)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::QuantifyXrayPoint: invalid m_pBrukerImpl."));
			return FALSE;
		}

		return m_pBrukerImpl->QuantifyXrayPoint(a_pXRayPoint, a_sMethodName);
	}

	BOOL COTSEDSBrucker::QuantifySpectrumFile(LPCTSTR a_sFilePathName, LPCTSTR a_sMethodName, CElementChemistriesList& a_listElementChemistry)
	{
		
		// check bruker controller
		ASSERT(m_pBrukerImpl);
		if (!m_pBrukerImpl)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::QuantifySpectrumFile: invalid m_pBrukerImpl."));
			return FALSE;
		}

		return m_pBrukerImpl->QuantifySpectrumFile(a_sFilePathName, a_sMethodName, a_listElementChemistry);
	}

	BOOL COTSEDSBrucker::QuantifySpectrumOut(DWORD a_nMilliseconds, long* a_pCounts, DWORD a_nBufferSize, CElementChemistriesList& a_listElementChemistry)
	{
	
		// check bruker controller
		ASSERT(m_pBrukerImpl);
		if (!m_pBrukerImpl)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::QuantifySpectrumOut: invalid m_pBrukerImpl."));
			return FALSE;
		}

		return m_pBrukerImpl->QuantifySpectrumOut(a_nMilliseconds, a_pCounts, a_nBufferSize, a_listElementChemistry);
	}

	BOOL COTSEDSBrucker::GetXRayByPoints(std::vector<CPosXrayPtr>& a_vXRayPoints, const DWORD a_nXRayAQTime)
	{
		


		// check Bruker controller
		ASSERT(m_pBrukerImpl);
		if (!m_pBrukerImpl)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::GetXRayByPoints: invalid m_pBrukerImpl."));
			return FALSE;
		}
		std::vector<CPosXrayPtr> listXRayPointsTemp;




		for (int i = 0; i < (int)a_vXRayPoints.size(); i++)
		{
			listXRayPointsTemp.push_back( a_vXRayPoints[i]);


			if (!m_pBrukerImpl->GetXRayByPoints(listXRayPointsTemp, a_nXRayAQTime))// one point per time,or we cann't get the full element data. gsp 2020-11-30
			{
				LogErrorTrace(__FILE__, __LINE__, _T("GetXRayByPoints: failed to get element."));
			}
			listXRayPointsTemp.clear();
		}
		

		return TRUE;
	}
	BOOL COTSEDSBrucker::GetXRayByFeatures(std::vector<CPosXrayPtr>& a_listXRayPoints,
		std::vector<std::vector<BrukerSegment>>& a_listFeatures,
		const DWORD a_nXRayAQTime)
	{
		

		// check bruker controller
		ASSERT(m_pBrukerImpl);
		if (!m_pBrukerImpl)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::GetXRayByFeatures: invalid m_pBrukerImpl."));
			return FALSE;
		}

		// collect x-Ray points (area scan)
		if (!m_pBrukerImpl->GetXRayByFeatures(a_listXRayPoints, a_listFeatures, a_nXRayAQTime))
		{
			// failed to call bruker controller CollectXRayPointsByFeatures method.
			LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::CollectXRayPointsByFeatures: failed to call bruker controller CollectXRayPointsByFeatures method."));
			return FALSE;
		}

		// ok, return TRUE
		return TRUE;
	}
	// Quatification
	void COTSEDSBrucker::SetQuantification(BOOL a_bQuantification)
	{
		

		// check bruker controller
		ASSERT(m_pBrukerImpl);
		if (!m_pBrukerImpl)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::SetQuantification: invalid m_pBrukerImpl."));
			return;
		}

		// collect x-Ray points (area scan)
		m_pBrukerImpl->SetQuantificationFlag(a_bQuantification);		
	}
	BOOL COTSEDSBrucker::GetQuantification()
	{
		

		// check bruker controller
		ASSERT(m_pBrukerImpl);
		if (!m_pBrukerImpl)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSBrucker::GetQuantification: invalid m_pBrukerImpl."));
			return FALSE;
		}

		// collect x-Ray points (area scan)
		return m_pBrukerImpl->GetQuantificationFlag();
	}


	// Get number of channels
	DWORD COTSEDSBrucker::GetNumberOfChannels(void)
	{
		return (DWORD)2000;
	}

	// Get the x-Ray data
	DWORD* COTSEDSBrucker::GetXRayData()
	{
		return m_nRayData;
	}



}