OTS/OTSCPP/OTSControl/Oxford/OTSEDSOxford.cpp

#include "stdafx.h"
#include "OTSEDSOxford.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

	namespace OTSController
	{

		COTSEDSOxford::COTSEDSOxford(void)
		{
			//LogTrace(__FILE__, __LINE__, _T("%s controller created"), (LPCTSTR)GetName());
			Init();
		}


		COTSEDSOxford::~COTSEDSOxford(void)
		{
			//LogTrace(__FILE__, __LINE__, _T("%s controller finished"), (LPCTSTR)GetName());
		}


		// initialisation
		BOOL COTSEDSOxford::Init()
		{


			// get bruker initialize controller
			if (!m_oxfordImpl)
			{
				// get Oxford controller
				m_oxfordImpl = OxfordImpl::GetInstance();
			}
			BOOL ifconnect=true;
			if (!m_oxfordImpl->IsConnected())
			{
				ifconnect=m_oxfordImpl->Connect();
			}
			return ifconnect;
		}







		BOOL COTSEDSOxford::CollectSpectrum(DWORD a_nMilliseconds)
		{


			if (!m_oxfordImpl)
			{
				ASSERT(m_oxfordImpl);
				if (!m_oxfordImpl)
				{
					return FALSE;
				}
			}

			if (!m_oxfordImpl->CollectXrayData(a_nMilliseconds, (long* )m_nRayData, (DWORD)EDSConst::XANA_CHANNELS))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("Collect spectrum at %d milliseconds failed."), a_nMilliseconds);
				ASSERT(m_oxfordImpl);
				if (!m_oxfordImpl)
				{
					return FALSE;
				}
			}

			// return method return flag
			return true;
		}

		BOOL COTSEDSOxford::CollectSpectrum(DWORD a_nMilliseconds, const CPoint& a_oPoint)
		{


			if (!m_oxfordImpl)
			{
				ASSERT(m_oxfordImpl);
				if (!m_oxfordImpl)
				{
					return FALSE;
				}
			}

			if (!m_oxfordImpl->CollectXrayDataAtPos(a_oPoint.x, a_oPoint.y, a_nMilliseconds, (long*)m_nRayData, (DWORD)EDSConst::XANA_CHANNELS))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("Collect spectrum at %d milliseconds failed."), a_nMilliseconds);
				ASSERT(m_oxfordImpl);
				if (!m_oxfordImpl)
				{
					return FALSE;
				}
			}


			return true;
		}

		BOOL COTSEDSOxford::CollectSpectrum(DWORD a_nMilliseconds, long* a_pCounts, DWORD a_nBufferSize)
		{


			if (!m_oxfordImpl)
			{
				ASSERT(m_oxfordImpl);
				if (!m_oxfordImpl)
				{
					return FALSE;
				}
			}

			if (!m_oxfordImpl->CollectXrayData(a_nMilliseconds, a_pCounts, a_nBufferSize))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("Collect spectrum at %d milliseconds failed."), a_nMilliseconds);
				ASSERT(m_oxfordImpl);
				if (!m_oxfordImpl)
				{
					return FALSE;
				}
			}

			// return method return flag
			return true;
		}

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


			// check Oxford controller
			ASSERT(m_oxfordImpl);
			if (!m_oxfordImpl)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSOxford::GetXRayByPoints: invalid m_poxfordImpl."));
				return FALSE;
			}

			// collect x-ray points (point scan)
			if (!m_oxfordImpl->GetXRayByPoints(a_vXRayPoints, a_nXRayAQTime))
			{
				// failed to call Oxford controller CollectXRayPoints method.
				LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSOxford::CollectXRayPoints: failed to call Oxford controller CollectXRayPoints method."));
				//return FALSE;
			}

			// ok, return TRUE
			return TRUE;
		}
		BOOL COTSEDSOxford::GetXRayByFeatures(std::vector<CPosXrayPtr>& a_listXRayPoints,
			std::vector<BrukerFeature>& a_listFeatures,
			const DWORD a_nXRayAQTime)
		{


			// check Oxford controller
			ASSERT(m_oxfordImpl);
			if (!m_oxfordImpl)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSOxford::GetXRayByFeatures: invalid m_oxfordImpl."));
				return FALSE;
			}

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

			// ok, return TRUE
			return TRUE;
		}

		// Quatification
		void COTSEDSOxford::SetQuantification(BOOL a_bQuantification)
		{


			// check oxford controller
			ASSERT(m_oxfordImpl);
			if (!m_oxfordImpl)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSOxford::SetQuantification: invalid m_oxfordImpl."));
				return;
			}

			m_oxfordImpl->SetQuantificationFlag(a_bQuantification);
		}
		BOOL COTSEDSOxford::GetQuantification()
		{


			// check oxford controller
			ASSERT(m_oxfordImpl);
			if (!m_oxfordImpl)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSOxford::GetQuantification: invalid m_oxfordImpl."));
				return FALSE;
			}

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


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

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


		BOOL COTSEDSOxford::IsSupportQuantification()
		{

			return TRUE;
		}

		BOOL COTSEDSOxford::GetQuantificationMethods(std::vector<CString>& a_vMethods)
		{

			// check Oxford controller
			ASSERT(m_oxfordImpl);
			if (!m_oxfordImpl)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSOxford::GetQuantificationMethods: invalid m_pOxfordImpl."));
				return FALSE;
			}

			//return m_oxfordImpl->GetQuantificationMethods(a_vMethods);
			return FALSE;
		}

		BOOL COTSEDSOxford::QuantifyXrayPoint(CPosXray* a_pXRayPoint, LPCTSTR a_sMethodName)
		{


			// check Oxford controller
			ASSERT(m_oxfordImpl);
			if (!m_oxfordImpl)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSOxford::QuantifyXrayPoint: invalid m_pOxfordImpl."));
				return FALSE;
			}

			//return m_oxfordImpl->QuantifyXrayPoint(a_pXRayPoint, a_sMethodName);
			return FALSE;
		}

		BOOL COTSEDSOxford::QuantifySpectrumFile(LPCTSTR a_sFilePathName, LPCTSTR a_sMethodName, CElementChemistriesList& a_listElementChemistry)
		{

			// check Oxford controller
			ASSERT(m_oxfordImpl);
			if (!m_oxfordImpl)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSOxford::QuantifySpectrumFile: invalid m_pOxfordImpl."));
				return FALSE;
			}

			return FALSE;
			//return m_oxfordImpl->QuantifySpectrumFile(a_sFilePathName, a_sMethodName, a_listElementChemistry);
		}

		BOOL COTSEDSOxford::QuantifySpectrumOut(DWORD a_nMilliseconds, long* a_pCounts, DWORD a_nBufferSize, CElementChemistriesList& a_listElementChemistry)
		{

			// check Oxford controller
			ASSERT(m_oxfordImpl);
			if (!m_oxfordImpl)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("COTSEDSOxford::QuantifySpectrumOut: invalid m_pOxfordImpl."));
				return FALSE;
			}

			return FALSE;
			//return m_oxfordImpl->QuantifySpectrumOut(a_nMilliseconds, a_pCounts, a_nBufferSize, a_listElementChemistry);
		}

	}
// namespace Controller