#include "stdafx.h"
#include "OTSScanOxford.h"
#define TRACE_HERE        /*NOP*/

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

namespace OTSController
{

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


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



    // initialisation
	BOOL COTSScanOxford::Init()
    {


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

    CSize COTSScanOxford::GetMatrixSize(int /*a_nMatrixIndex*/)
    {
        // method return value
        CSize oRet = CSize(0);



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

        long nWidth = 0, nHeight = 0;
        if (m_oxfordImpl->GetImageSize(nWidth, nHeight))
        {
            oRet.SetSize(nWidth, nHeight);
        }

        return oRet;
    }

    BOOL COTSScanOxford::MoveBeamTo(CPoint& a_beamPos)
    {


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

        bool bRet = m_oxfordImpl->SetBeamPosition(a_beamPos.x, a_beamPos.y);

		return bRet;		

    }

    // Start Scan Table
	BOOL COTSScanOxford::StartScanTable (int a_nMatrixIndex, unsigned int nP, int* px, int* py)
    {
        CSize szMatrix = GetMatrixSize(a_nMatrixIndex); 
        double stepSize = ((double)m_szScanRange.cx) /((double) szMatrix.cx); 
        for (unsigned int i = 0 ; i < nP ; i++)
        {
            px[i] = (int) (px[i] * stepSize) ; 
            py[i] = m_szScanRange.cy - (int) (py[i] * stepSize) ; 
        }

        return true;
    }

    /// set image size
    /// input long nImageSize
    /// return true if success
	BOOL COTSScanOxford::SetImageSize(long newImageSize,long nHeight)
    {
       

        // safety check
        ASSERT(m_oxfordImpl);
        if (!m_oxfordImpl)
        {
            return false;
        }

        if (!m_oxfordImpl->SetImageSize(newImageSize, nHeight))
        {
			ASSERT(m_oxfordImpl);
			if (!m_oxfordImpl)
			{
				return FALSE;
			}
        }

        return true;
    }

    /// set dwell time
    /// input long a_nDwellTime
    /// return true if success
	BOOL COTSScanOxford::SetDwellTime(long nDwellTime)
    {
       

        // safety check
        ASSERT(m_oxfordImpl);
        if (!m_oxfordImpl)
        {
            return false;
        }

        if (!m_oxfordImpl->SetScanSpeed(nDwellTime))
        {
			ASSERT(m_oxfordImpl);
			if (!m_oxfordImpl)
			{
				return FALSE;
			}
        }

        return true;
    }

	CBSEImgPtr COTSScanOxford::AcquireBSEImage(int /*a_nMatrixIndex*/, int /*nReads*/, int /*nDwell*/)
    {
       

        // safety check
        ASSERT(m_oxfordImpl);
        if (!m_oxfordImpl)
        {
            return nullptr;
        }

        long nWidth, nHeight;

        if (!m_oxfordImpl->GetImageSize(nWidth, nHeight))
        {
			LogErrorTrace(__FILE__, __LINE__, _T("Call GetImageSize failed."));
            
            return nullptr;
        }
        long nImageSize = nWidth * nHeight;
        if (nImageSize <= 0)
        {
			LogErrorTrace(__FILE__, __LINE__, _T("AcquireBSEImage failed: invalid image size (%d, %d)."), nWidth, nHeight);
            
            return nullptr;
        }

        std::vector<BYTE> vecImage(nImageSize, 0);

        if (!m_oxfordImpl->CollectImage(&vecImage[0]))
        {
			LogErrorTrace(__FILE__, __LINE__, _T("Call CollectImage failed."));
           
            return nullptr;
        }
        CRect imageRect(0, 0, nWidth, nHeight);
		CBSEImgPtr bseImage(new CBSEImg(imageRect));
      
        //bseImage->SetImageRect(imageRect);
        bseImage->InitImageData(nWidth, nHeight);
        BYTE* pImageData = bseImage->GetImageDataPointer();

        memcpy(pImageData, &vecImage[0], nWidth * nHeight);

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

		return bseImage;
    }

    long COTSScanOxford::GetDwellTimeByIndex(const long a_nIndex)
    {
        // dwell time
        if(a_nIndex < DWELLTIME_OXFORD_ID_MIN || a_nIndex > DWELLTIME_OXFORD_ID_MAX)
        {
            // error, invalid scan speed value
			LogErrorTrace(__FILE__, __LINE__, _T("Scan speed (Dwell time) index (%d) error."), a_nIndex);
            ASSERT(FALSE);

            return -1;
        }

        // convert dwell time index to dwell time value
        return DWELLTIME_OXFORD_VALUES[a_nIndex];
    }

	BOOL COTSScanOxford::SetDwellTimeByIndex(const long a_nDwellTimeIndex)
    {
        // dwell time
        if(a_nDwellTimeIndex < DWELLTIME_OXFORD_ID_MIN || a_nDwellTimeIndex > DWELLTIME_OXFORD_ID_MAX)
        {
            // error, invalid scan speed value
			LogErrorTrace(__FILE__, __LINE__, _T("Scan speed index (%d) error."), a_nDwellTimeIndex);
			ASSERT(m_oxfordImpl);
			if (!m_oxfordImpl)
			{
				return FALSE;
			}
        }

        // convert dwell time index to dwell time value
        long nDwellTimeLong = DWELLTIME_OXFORD_VALUES[a_nDwellTimeIndex];
        if (!SetDwellTime(nDwellTimeLong))
        {
            // error, failed to set dwell time
			LogErrorTrace(__FILE__, __LINE__, _T("Failed to set dwell time (%d)."), a_nDwellTimeIndex);
			ASSERT(m_oxfordImpl);
			if (!m_oxfordImpl)
			{
				return FALSE;
			}
        } 

        return true;
    }

	BOOL COTSScanOxford::SetScanFieldSize(const int a_nWidth, const int a_nHeight)
	{
		m_nScanFieldSizeX = a_nWidth;
		m_nScanFieldSizeY = a_nHeight;
		return TRUE;
	}

	// set the SEM position
	BOOL COTSScanOxford::SetEMPosition(const int a_nPosX, const int a_nPosY)
	{
		m_nCurrentBSEPositionX = a_nPosX;
		m_nCurrentBSEPositionY = a_nPosY;
		return TRUE;
	}

	


}