OTS/OTSCPP/OTSClrInterface/ControlClr/OTSControlFunExport.h

#pragma once


/**
@file
@brief		OTSControl  DLL Interface  provide for C#
@author		xiaoxing.zhang，Anna Hao
@version	1.0.0.0
@date		2017/6/28

- 2017/6/28 1.0.0.0  xiaoxing.zhang  developed SEM Interface
- 2017/6/28 1.0.0.0  Anna Hao  developed Scan Interface
- 2017/6/29 1.0.0.0  Anna Hao  developed EDS Interface
- - 2017/7/3 1.0.0.0  xiaoxing.zhang  Add log for SemInterface 
*/

#include "BSEImg.h"
#include "COTSHardwareMgr.h"
#include "Bruker/OTSBrukerImpl_const.h"
#include <OTSFeatureClr.h>
#include <BSEImgClr.h>
#include <OTSParticleClr.h>






using namespace System;
using namespace System::Drawing;
using namespace System::Collections::Generic;

namespace NSOTSController 
{
	using namespace OTSController;
	using namespace OTSCOMMONCLR;
	


	public ref class COTSSimuControlClr
	{
		public:
			COTSSimuControlClr();
			~COTSSimuControlClr();
			!COTSSimuControlClr();
			
	public:
		bool Connect();
		bool Disconnect();
		bool SetWorkingDistance(double a_dWorkingDistance);
		bool GetWorkingDistance(double% a_dWorkingDistance);
		bool SetMagnification(double a_dMag);
		bool GetMagnification(double% a_dMag);
	
		 
	};

	public ref class COTSControlFunExport
	{
	public:
		COTSControlFunExport()
		{

			//m_LpHardWareMgr = NULL;
			/*m_LpSemBase = NULL;
			m_LpScanBase = NULL;
			m_LpEDSBase = NULL;*/
			m_LpHardWareMgr = new COTSHardwareMgr();
			m_LpSemBase = (m_LpHardWareMgr->GetSemControllerMgrPtr()).get();
			m_LpScanBase = (m_LpHardWareMgr->GetScanControllerPtr()).get();
			m_LpEDSBase = (m_LpHardWareMgr->GetEDSControllerPtr()).get();
		}

		~COTSControlFunExport()
		{
			if (nullptr != m_LpHardWareMgr)
			{
				delete m_LpHardWareMgr;
				m_LpHardWareMgr = nullptr;
			}


			
		}
		!COTSControlFunExport()
		{
			if (nullptr != m_LpHardWareMgr)
			{
				delete m_LpHardWareMgr;
				m_LpHardWareMgr = nullptr;
			}



		}
	public:

		//void  InitDevPoint();

		//获取当前电镜的ID号
		int GetSemType()
		{
			int ID = 0;
			ID = (int)m_LpSemBase->GetType();

			return ID;
		}

		bool IsConnected()
		{

			BOOL bRev = m_LpSemBase->IsConnected();
			return bRev;
		}

		//和电镜建立通讯连接
		bool ConncetSem()
		{
			
			BOOL bRev = m_LpSemBase->Connect();
			return bRev;
		}

		//断开电镜连接
		bool DisConnectSem()
		{
			BOOL bRev = m_LpSemBase->Disconnect();
			return bRev;
		}


		//获得扫描区域大小
		Size GetSemScanField100()
		{
			Size sz;
			CSize size = m_LpSemBase->GetScanField100();
			sz.Width = size.cx;
			sz.Height = size.cy;

			return sz;

		}
		//设置扫描区域大小
		void SetSemScanField100(Size sz)
		{
			CSize size;
			size.cx = sz.Width;
			size.cy = sz.Height;

			m_LpSemBase->SetScanField100(size);

		}


		bool GetSemBeamBlank(long% a_nBeamBlank)
		{
			long lBBlank = 0;
			BOOL bRev = m_LpSemBase->GetBeamBlank(lBBlank);
			a_nBeamBlank = lBBlank;

			return bRev;
		}

		bool SetSemBeamBlank(long a_nBeamBlank)
		{
			BOOL bRev = m_LpSemBase->SetBeamBlank(a_nBeamBlank);
			return bRev;
		}


		//获得亮度
		bool GetSemBrightness(double% a_dBrightness)
		{
			double dBriness = 0;
			BOOL bRev = m_LpSemBase->GetBrightness(dBriness);
			a_dBrightness = dBriness;
			
			return bRev;
		}

		//设置亮度
		bool SetSemBrightness(double a_dBrightness)
		{
			BOOL bRev = m_LpSemBase->SetBrightness(a_dBrightness);
			return bRev;
		}

		//获得对比度
		bool GetSemContrast(double%  a_dContrast)
		{
			double dContrast = 0;
			BOOL bRev = m_LpSemBase->GetContrast(dContrast);
			a_dContrast = dContrast;
			return bRev;
		}

		//设置对比度
		bool SetSemContrast(double a_dContrast)
		{
			BOOL bRev = m_LpSemBase->SetContrast(a_dContrast);
			return bRev;
		}

		//获得Z轴的工作距离
		bool GetSemWorkingDistance(double% a_dWorkingDistance)
		{
			double dWDistance = 0;
			BOOL bRev = m_LpSemBase->GetWorkingDistance(dWDistance);
			a_dWorkingDistance = dWDistance;
			return bRev;
		}

		// 设置Z轴工作距离
		bool SetSemWorkingDistance(double a_dWorkingDistance)
		{
			BOOL bRev = m_LpSemBase->SetWorkingDistance(a_dWorkingDistance);
			return bRev;
		}

		// 获得电压值
		bool GetSemHighTension(double% a_dKV)
		{
			double dDKV = 0;
			BOOL bRev = m_LpSemBase->GetHighTension(dDKV);
			a_dKV = dDKV;
			return bRev;
		}

		// 设置电压值
		bool SetSemHighTension(double a_dKV)
		{
			BOOL bRev = m_LpSemBase->SetHighTension(a_dKV);
			return bRev;
		}

		//获得放大倍数
		bool GetSemMagnification(double% a_dMagnification)
		{
			double dMagni = 0;
			BOOL bRev = m_LpSemBase->GetMagnification(dMagni);
			a_dMagnification = dMagni;
			return bRev;
		}

		//设置放大倍数
		bool SetSemMagnification(double a_dMagnification)
		{
			BOOL bRev = m_LpSemBase->SetMagnification(a_dMagnification);
			return bRev;
		}

		//获得扫描区域尺寸
		bool GetSemScanFieldSize(double% a_dScanFieldSizeX, double% a_dScanFieldSizeY)
		{

			double dFSizeX = 0;
			double dFSizeY = 0;
			BOOL bRev = m_LpSemBase->GetScanFieldSize(dFSizeX, dFSizeY);
			a_dScanFieldSizeX = dFSizeX;
			a_dScanFieldSizeY = dFSizeY;
			return bRev;
		}

		//设置扫描区域尺寸
		bool SetSemScanFieldSizeX(double a_dScanFieldSizeX)
		{
			BOOL bRev = m_LpSemBase->SetScanFieldSizeX(a_dScanFieldSizeX);
			return bRev;
		}


		bool GetSemHTOnOff(BOOL% a_bHTValue)
		{

			BOOL bHTV = FALSE;
			BOOL bRev = m_LpSemBase->GetHTOnOff(bHTV);
			a_bHTValue = bHTV;
			return bRev;
		}


		bool SetSemHTOnOff(BOOL a_bHTValue)
		{
			BOOL bRev = m_LpSemBase->SetHTOnOff(a_bHTValue);
			return bRev;
		}


		//获得电镜位置
		bool GetSemPositionXY(double% a_dPositionX, double% a_dPositionY, double% a_dPositionR)
		{
			double dPosX = 0;
			double dPosY = 0;
			double dPosR = 0;
			BOOL bRev = m_LpSemBase->GetPositionXY(dPosX, dPosY, dPosR);
			a_dPositionX = dPosX;
			a_dPositionY = dPosY;
			a_dPositionR = dPosR;
			return bRev;
		}

		//设置电镜位置
		bool SetSemPositionXY(double a_dPositionX, double a_dPositionY, double a_dPositionR)
		{
			BOOL bRev = m_LpSemBase->SetPositionXY(a_dPositionX, a_dPositionY, a_dPositionR);
			return bRev;
		}


		//获得焦点尺寸
		bool GetSemSpotSize(double% a_dSpotSize)
		{

			double dPSize = 0;
			BOOL bRev = m_LpSemBase->GetSpotSize(dPSize);
			a_dSpotSize = dPSize;
			return bRev;
		}

		//设置焦点尺寸
		bool SetSemSpotSize(double a_dSpotSize)
		{
			BOOL bRev = m_LpSemBase->SetSpotSize(a_dSpotSize);
			return bRev;
		}


		// 获得扫描方式
		bool GetSemScanMode(long% a_nScanMode)
		{

			long lSMode = 0;
			BOOL bRev = m_LpSemBase->GetScanMode(lSMode);
			a_nScanMode = lSMode;
			return bRev;

		}

		//设置扫描方式
		bool SetSemScanMode(long a_nScanMode)
		{
			BOOL bRev = m_LpSemBase->SetScanMode(a_nScanMode);

			return bRev;
		}

		bool SetSemScanExternal(bool external)
		{
			bool bRev = false;
			try
			{
				bRev = m_LpSemBase->SetScanExternal(external);
			}
			catch (const std::exception&)
			{
				bRev = false;
			}
			return bRev;
		}

		int GetSemExternalMode()
		{
			BOOL bRev = m_LpSemBase->GetExternalMode();
			return bRev;
		}

		//移动电镜到指定的位置
		bool MoveSEMToPoint(double dPosX, double dPosY, double dRotation)
		{

			double dRota = dRotation;
			CPoint cPos;
			cPos.x = (LONG)dPosX;
			cPos.y = (LONG)dPosY;
			bool bRev = m_LpSemBase->MoveSEMToPoint(cPos, dRotation);
			return bRev;
		}


		// 释放
		void FreeHardware()
		{
			if (NULL != m_LpHardWareMgr)
			{
				if (m_LpSemBase != NULL)
				{
					if (m_LpSemBase->IsConnected())
					{
						m_LpSemBase->Disconnect();
					}
					delete m_LpSemBase;
				}
				if (m_LpScanBase != NULL)
				{
					m_LpScanBase->FinishedInstance();
					delete m_LpScanBase;
				}
				if (m_LpEDSBase!= NULL)
				{
					m_LpEDSBase->FinishedInstance();
					delete m_LpEDSBase;
				}
				//delete m_LpHardWareMgr;
				m_LpHardWareMgr = NULL;
			}
		}




		//EDS Interface
		//获取EDS名称
		//函数名称：GetEDSName()
		//输入参数：无
		//输出参数：类型：int，设备ID标识
		String^ GetEDSName()
		{
			CString a_str = (m_LpEDSBase->GetName());
			String^ strOut = gcnew String(a_str);
			return strOut;
		}
		//获取EDS类型，Bruker是3.
		//函数名称：int EDSGetType()
		//输入参数：无
		//输出参数：类型：int，设备ID标识
		int EDSGetType() 
		{ 
			
			int a_type = (int)EDSController::EDS_ID::BRUKER;
			return a_type;
		}

		//EDS进程终止
		//函数名称：void EDSFinishedInstance()
		//输入参数：无
		//输出参数：无
		void EDSFinishedInstance()
		{
			m_LpEDSBase->FinishedInstance();
		}

		//EDS初始化
		//函数名称：bool EDSInit()
		//输入参数：无
		//输出参数：类型：bool，true，设备申请成功
		//						false，设备申请失败
		bool EDSInit()
		{

			bool bRet = m_LpEDSBase->Init();
			return bRet;
		}


		//是否支持Xray采集
		//函数名称：bool IsSupportSetCollection()
		//输入参数：无
		//输出参数：类型：bool，true，支持采集
		//						false，不支持采集
		bool IsSupportSetCollection()
		{
			bool bRet = m_LpEDSBase->IsSupportSetCollection();
			return bRet;
		}

		bool CollectSpectrum(unsigned long a_nMilliseconds, Point a_oPoint, array<unsigned long>^% a_XrayData);

		bool CollectSpectrum(unsigned long a_nMilliseconds, array<unsigned long>^% a_XrayData, unsigned long a_nBufferSize);
			

		bool CollectSpectrum(unsigned long a_nMilliseconds, array<unsigned long>^% a_XrayData);


		bool GetXRayByPoints(unsigned long a_nMilliseconds, array<Point>^ points,  array<array<unsigned long>^>^% a_XrayData, array<String^>^% a_strEleResult, bool bQuant);
		
		bool GetXRayByPoints(unsigned long a_nMilliseconds, array<Point>^ points, array<COTSParticleClr^>^ parts,  bool bQuant);

		bool GetXRayBySinglePoint(unsigned long a_nMilliseconds, Point point, array<unsigned long>^% a_XrayData, String^% a_strEleResult, bool bQuant);
		
		

		bool GetXRayByFeatures(unsigned long a_nMilliseconds, array<COTSFeatureClr^>^ feas,array<array<unsigned long>^>^% a_XrayData, array<String^>^% a_strEleResult, bool bQuant);

		bool GetXRayByFeatures(unsigned long a_nMilliseconds, array<COTSParticleClr^>^ parts, bool bQuant);


		bool GetXRayBySingleFeature(unsigned long a_nMilliseconds, COTSFeatureClr^ feature, array<unsigned long>^% a_XrayData, String^% a_strEleResult, bool bQuant);


		// analysis elements
		bool GetXRayElements(unsigned long a_nMilliseconds, array<unsigned long>^% a_XrayData, int^% a_nElementNum, String^% a_strResult);
		

		// analysis elements
		bool GetXRayAndElements(unsigned long a_nMilliseconds, int a_BSEX, int a_BSEY, array<unsigned long>^% a_XrayData, int^% a_nElementNum, String^% a_strResult);
		

		/// Set Amp Time Index for all detectors
		bool SetAmpTimeIndex(long a_lvalue)
		{
			bool bRet = m_LpEDSBase->SetAmpTimeIndex(a_lvalue);
			return bRet;		
		}
		/// get live time
		float GetLiveTime(void)
		{
			float fRet = m_LpEDSBase->GetLiveTime();
			return fRet;
		}

		/// get x-ray point collection limit
		long GetMaxPointLimit(void)
		{
			long lRet = m_LpEDSBase->GetMaxPointLimit();
			return lRet;
		}
		
		DWORD GetNumberOfChannels(void)
		{
			DWORD nRet = m_LpEDSBase->GetNumberOfChannels();
			return nRet;
		}


		//获取图像数据14741238434
		int  AcquireBSEImage(int a_nMatrixIndex, int nReads, int nDwell, array<System::Byte>^% a_ImgData);
		
		//获取图像数据14741238434
		bool  AcquireBSEImage(int a_nMatrixIndex, int nReads, int nDwell, CBSEImgClr^% a_ImgData)
		{
			/*int bRet = 0;

			CSize sz;*/
			//int height, width;

			CBSEImgPtr pbseImg = nullptr;

			pbseImg = m_LpScanBase->AcquireBSEImage(a_nMatrixIndex, nReads, nDwell);

			a_ImgData = gcnew CBSEImgClr(pbseImg);
			return true;
			

		}



		// 初始化
		bool ScanInit()
		{
			bool bRet = m_LpScanBase->Init();
			return bRet;
		}

		/// instance termination
		void ScanFinishedInstance()
		{
			m_LpScanBase->FinishedInstance();
			
		}

		int GetScanType()
		{
			int nRet = (int)ScanController::SCANNER_ID::BRUKER;
			return nRet;
		}

		Size GetMatrixSize(int a_nMatrixIndex)
		{

			CSize cs;
			cs = m_LpScanBase->GetMatrixSize(a_nMatrixIndex);
			Size aa;
			aa.Height = (int)cs.cy;
			aa.Width = (int)cs.cx;
			return aa;
		}

		// Start Scan Table
		bool StartScanTable(int a_nMatrixIndex, unsigned int nP, array<System::Int16>^ pnxx, array<System::Int16>^ pnyy)
		{
			int*pnx = new int[nP];
			int*pny = new int[nP];

			memset(pnx, 0, sizeof(int)*nP);
			memset(pny, 0, sizeof(int)*nP);


			bool bRet = false;

			if (m_LpScanBase->StartScanTable(a_nMatrixIndex, nP, pnx, pny))
			{
				for (int i = 0; i <(int) nP; i++)
				{
					pnxx[i] = pnx[i];
					pnyy[i] = pny[i];
				}

				bRet = true;
			}
			else
			{				
				bRet = false;
			}
			
			delete[] pny;
			delete[] pnx;
			return  bRet;
		}
		// set Image Size
		bool SetImageSize(long nWidth,long nHeight)
		{
			bool bRet = m_LpScanBase->SetImageSize(nWidth,nHeight);
			return bRet;
			
		}
		/// set dwell time
		bool SetDwellTime(long nDwellTime)
		{
			bool bRet = m_LpScanBase->SetDwellTime(nDwellTime);
			return bRet;
		}

		/*Size GetFrameResolutionByIndex(const long a_nIndex)
		{

			CSize cs;
			cs = m_LpScanBase->GetFrameResolutionByIndex(a_nIndex);
			Size aa;
			aa.Height = (int)cs.cx;
			aa.Width = (int)cs.cy;
			return aa;
		}
		bool SetFrameResolutionByIndex(const long a_nIndex)
		{
			bool bRet = m_LpScanBase->SetFrameResolutionByIndex(a_nIndex);
			return bRet;
		}*/
		long GetDwellTimeByIndex(const long a_nIndex)
		{
			long lRet = m_LpScanBase->GetDwellTimeByIndex(a_nIndex);
			
			return lRet;
			
		}
		bool SetDwellTimeByIndex(const long a_nIndex)
		{
			bool bRet = m_LpScanBase->SetDwellTimeByIndex(a_nIndex);
			return bRet;
		}

		bool SetScanFieldSize(const int a_nWidth, const int a_nHeight)
		{
			bool bRet =(bool)m_LpScanBase->SetScanFieldSize(a_nWidth, a_nHeight);
			
			return bRet;
		}
		bool SetEMPosition(const int a_nPosX, const int a_nPosY)
		{
			bool bRet = (bool)m_LpScanBase->SetScanFieldSize(a_nPosX, a_nPosY);
			
			return bRet;
		}
		Size GetScanRange() 
		{
			
			CSize cs = m_LpScanBase->GetScanRange();

			Size aa;
			aa.Height = (int)cs.cx;
			aa.Width = (int)cs.cy;

			return aa;
		}
		int GetScanStepSize()
		{

			int nRet = m_LpScanBase->GetScanStepSize();
			return nRet;
		}
		int GetInterPixelDwell() 
		{

			int nRet = m_LpScanBase->GetInterPixelDwell();

			return nRet;
		}
		int GetNumberOfReads()
		{ 

			int nRet = m_LpScanBase->GetNumberOfReads();
			return nRet;
		}
		double GetMagnification() 
		{

			double nRet = m_LpScanBase->GetMagnification();
			return nRet;
		}

		void SetScanRange(Size cs)
		{

			CSize sz;
			sz.cx = (LONG)cs.Height;
			sz.cy = (LONG)cs.Width;
			m_LpScanBase->SetScanRange(sz);
		}
		void SetScanStepSize(int size)
		{
			m_LpScanBase->SetScanStepSize(size);


		}
		void SetInterPixelDwell(int i)
		{
			m_LpScanBase->SetInterPixelDwell(i);

			

		}
		void SetNumberOfReads(int i)
		{
			
			m_LpScanBase->SetNumberOfReads(i);
			
		}
		void SetMagnification(double mag) 
		{
			
			m_LpScanBase->SetMagnification(mag);
			
		 }
		bool ScanIsBruker()
		{
			bool bRet = (bool)m_LpScanBase->IsBruker();
			return bRet;
		}

		bool SetAndStartScan(void)
		{
			bool bRet = (bool)m_LpScanBase->SetAndStartScan();

			
			
			
			return bRet;
		}
		bool MoveBeamTo(Point a_beamPos)
		{
			CPoint pt;
			pt.x = a_beamPos.X;
			pt.y = a_beamPos.Y;

			bool bRet = (bool)m_LpScanBase->MoveBeamTo(pt);

			
			
			
			return bRet;
		}
		bool SetPointScan(int a_nMatrixIndex)
		{
			bool bRet = (bool)m_LpScanBase->SetPointScan(a_nMatrixIndex);

			
			
			
			return bRet;
		}
	private:
		// COTSSEMBruker* m_LpSemBruker;
		 COTSSemBase* m_LpSemBase;
		 //Scan
		 COTSScanBase* m_LpScanBase;
		 //EDS
		 COTSEDSBase* m_LpEDSBase;

		 //COTSHardwareMgr
		 COTSHardwareMgr* m_LpHardWareMgr;

	};

}