OTS/OTSCPP/OTSControl/Oxford/OxfordWrapper/OxfordControllerWrapper.h

#pragma once

#include "../OTSControl/Oxford/OxfordImplConst.h"


using namespace System::Collections::Generic;

using namespace System::Threading;

using namespace OINA::Extender;
using namespace OINA::Extender::Data;
using namespace OINA::Extender::Data::Ed;
using namespace OINA::Extender::Data::Image;
using namespace OINA::Extender::MicroscopeControl;
using namespace OINA::Extender::Acquisition;
using namespace OINA::Extender::Acquisition::Ed;
using namespace OINA::Extender::Acquisition::Image;

using namespace OINA::Extender::Acquisition::Quant;


using namespace OINA::Extender::Controls;
using namespace OINA::Extender::Controls::Common;
using namespace OINA::Extender::Controls::Image;
using namespace OINA::Extender::Controls::Spectrum;
using namespace OINA::Extender::Processing;
using namespace OINA::Extender::Processing::Ed;
using namespace OINA::Extender::Processing::Quant;


using namespace OTSController;
ref class OxfordControllerWrapper
{
	enum class OxfordControllerCommand
	{
		WAITING = 0,
		GET_WORKINGDISTANCE = 1,
		SET_WORKINGDISTANCE = 2,
		GET_POSITIONXY = 3,
		SET_POSITIONXY = 4,
		GET_MAGNIFICATION = 5,
		SET_MAGNIFICATION = 6,
		GET_HIGHVOTAGE = 7,
		SET_HIGHVOTAGE = 8,
		GET_BEAMON = 9,
		SET_BEAMON = 10,
		GET_BEAMBLANK = 11,
		SET_BEAMBLANK = 12,
		GET_EXTERNAL = 13,
		SET_EXTERNAL = 14,
		COLLECT_IMAGE = 15,
		COLLECT_XRAYPOINT = 16,
		COLLECT_CURRENTXRAYPOINT = 17,
		COLLECT_XRAYPOINTS = 18,
		COLLECT_QUANTIFYSPECTRUM = 19,
		COLLECT_XRAYCHOILDLIST = 20,
		STOP_ACQUISITION=21,
		END_MULTIPLEACQUISITION = 22,
		EXIT = 100,
	};

	enum class OxfordControllerState
	{
		READY = 0,
		WORKING = 1,
		SUCCEEDED = 2,
		FAILED = 3,
		ABORT = 4
	};

	ref struct Element 
	{
		int m_nAotomaticNo;
		double m_dWeight;
	};

	//interface input/output
	ref struct OxfordControllerData
	{
		OxfordControllerData()
			: m_nState(OxfordControllerState::READY)
			, m_nCommand(OxfordControllerCommand::WAITING)
			, m_pImageBits(nullptr)
			, m_pXrayDataList(nullptr)
			, m_pSpectrumData(nullptr)
		{
			//m_dataLock = gcnew Object();	
			m_nCollectedPixelCounts = 0;
			m_nCollectedChordsCount = 0;
		}
		
		OxfordControllerState m_nState;
		OxfordControllerCommand m_nCommand;

		double m_dPositionX;
		double m_dPositionY;
		double m_dWorkingDistance;
		double m_dMagnification;

		double m_dHighVotage;

		bool m_bBeamOn;
		bool m_bBeamBlank;
		bool m_bExternal;

		long m_nImageWidth;
		long m_nImageHeight;
		double m_dPixelSize;
		BYTE* m_pImageBits;

		double m_dBeamPositionX;
		double m_dBeamPositionY;
		long* m_pSpectrumData;

		OxfordXrayData* m_pXrayDataList; //multi points
		long m_nAcTime; // xray collect time
		DWORD m_nBufferSize;
		
		// feature计数控制
		long m_nXrayDataCount;
		long m_nCollectedXrayCounts;

		// 当前feature的chords数控制
		long m_nChordsNum;
		long m_nCollectedChordsCount;

		// 当前feature的pixel数控制 
		long m_nCollectedPixelCounts;
		long m_nPixelNum;
		
		List<Element^ >^ m_listElementResult;		

		System::String^ m_sElementResult; //one point

		// should lock data every time read / write
		//Object^ m_dataLock;
	};

public:
	OxfordControllerWrapper(void);
	~OxfordControllerWrapper();	
	!OxfordControllerWrapper();

	void CloseClient();

	bool Init();

	bool IsConnected();

	bool GetPositionXY(double& a_dPosX, double& a_dPosY);
	bool SetPositionXY(const double a_dPosX, const double a_dPosY);

	bool GetWorkingDistance(double& a_dWorkingDistance);
	bool SetWorkingDistance(double a_dWorkingDistance);

	bool GetMagnification(double& a_dMagnification);
	bool SetMagnification(double a_dMagnification);

	bool GetHighVoltage(double& a_dHighVoltage);
	bool SetHighVoltage(double a_dHighVoltage);

	bool GetBeamOn(bool& a_bBeamOn);
	bool SetBeamOn(bool a_bBeamOn);

	bool GetBeamBlank(bool& a_bBeamBlank);
	bool SetBeamBlank(bool a_bBeamBlank);

	bool GetExternalScan(bool& a_bExternal);
	bool SetExternalScan(bool a_bExternal);

	bool SetBeamPosition(const double a_dPosX, const double a_dPosY);
	bool CollectXrayPoint(const double a_dPosX, const double a_dPosY, const long a_nAcTime, long* a_pSpectrumData, DWORD a_nBufferSize);
	bool CollectXrayPoint(const long a_nAcTime, long* a_pSpectrumData, DWORD a_nBufferSize);

	bool CollectXrayPoints(const long a_nAcTime, OxfordXrayData* a_pXrayDataList, const long a_nXrayDataCount, DWORD a_nBufferSize);
	bool CollectXrayArea(const long a_nAcTimeMilliseconds, OxfordXrayData* a_pXrayDataList, const long a_nXrayDataCount, DWORD a_nBufferSize);
	bool SetScanSpeed(const long a_nMilliseconds);
	bool GetImageSize(long& a_nWidth, long& a_nHeight);
	bool SetImageSize(const long a_nWidth, const long a_nHeight);

	bool CollectImage(BYTE* a_pImageBits);
	bool CollectImage(int a);

	bool QuantifySpectrum(unsigned char* cResult);
	bool IsStageUpdate()
	{
		return m_bIsStageUpdated;
	}
	bool StopXrayCollecting();

protected:

	bool GetPositionXYFromController(double& a_dPosX, double& a_dPosY);
	bool SetPositionXYToController(const double a_dPosX, const double a_dPosY);

	bool GetWorkingDistanceFromController(double& a_dWorkingDistance);
	bool SetWorkingDistanceToController(double a_dWorkingDistance);

	bool GetMagnificationFromController(double& a_dMagnification);
	bool SetMagnificationToController(double a_dMagnification);

	bool GetHighVoltageFromController(double& a_dHighVoltage);
	bool SetHighVoltageToController(double a_dHighVoltage);

	bool GetBeamOnFromController(bool& a_bBeamOn);
	bool SetBeamOnToController(bool a_bBeamOn);

	bool GetBeamBlankFromController(bool& a_bBeamBlank);
	bool SetBeamBlankToController(bool a_bBeamBlank);

	bool GetExternalScanFromController(bool& a_bExternal);
	bool SetExternalScanToController(bool a_bExternal);

	bool SetCurrentBeamPosition();

	bool IsXrayCollecting();
	bool IsImageCollecting();

	bool IsQuantifySpectrumCollecting();

	IStageConditions^ GetStageConditions();

	void OnMicroscopeColumnUpdated(Object^ sender, OINA::Extender::MicroscopeControl::ColumnEventArgs^ e)
	{
		m_bIsColumnUpdated = true;
	}
	void OnMicroscopeStageUpdated(Object^ sender, OINA::Extender::MicroscopeControl::StageEventArgs^ e)
	{
		
		m_bIsStageUpdated = true;
		//LogTrace(__FILE__, __LINE__, _T("StageUpdated!"));
	}
	void OnMicroscopeCompleted(Object^ sender, OINA::Extender::MicroscopeControl::CompletedEventArgs^ e)
	{
		if ((int)e->Control == (int)MicroscopeControl::MicroscopeControlType::Stage)
		{
			if (e->Success)
			{
				LogTrace(__FILE__, __LINE__, _T("StageUpdated!"));
				m_bIsStageUpdated = true;

			}
			
		}
	
		
	}
	bool m_bIsStageUpdated;
	bool m_bIsColumnUpdated;
	bool IsMicroscopeColumnConnected();
	bool IsMicroscopeStageConnected();

	bool StartXrayCollecting(const long a_nAcTime);
	
	void OnXrayAcquisitionFinished(Object^ sender, OINA::Extender::Acquisition::AcquisitionFinishedEventArgs<OINA::Extender::Data::Ed::IEdSpectrum^>^ e);
	void OnXrayChordlistFinished(Object^ sender, OINA::Extender::Acquisition::AcquisitionFinishedEventArgs<OINA::Extender::Data::Ed::IEdMap^>^ e);
	bool ConvertSpectrumData(IEdSpectrum^ a_spectrum, long* a_pSpectrumData, int a_nBufferSize);

	bool StartImageCollecting();
	bool StopImageCollecting();
	void OnImageAcquisitionFinished(Object^ /*sender*/, OINA::Extender::Acquisition::AcquisitionFinishedEventArgs<array<OINA::Extender::Data::Image::IElectronImage^ >^ >^ e);
	void OnController_PixelProcessed(Object^ /*sender*/, OINA::Extender::EventArgs<OINA::Extender::Processing::Quant::IPixelSEMQuantStatus^ >^ e);
	void OnController_ExperimentFinished(Object^ /*sender*/, OINA::Extender::Acquisition::AcquisitionFinishedEventArgs^ e);
	bool ReadImageData(IElectronImage^ a_electronImage, BYTE* a_pImageBits);
	void XraySpectrumProcess(OINA::Extender::Data::Ed::IEdSpectrum^ spectrum);
	void LogMessage(CString a_sMessage);

	IMicroscopeController^ CreateMicroscopeController();

	IEdSpectrumAcquisitionController^ CreateEdsSpectrumController();
	IEdSpectrumSettings^ GetEdsSpectrumSettings();

	IImageAcquisitionController^ CreateImageAcqusitionController();
	IImageAcquisitionSettings^ GetImageAcqusitionSettings();

//	IQuantCalibrationController^ CreateQuantCalibrationController();
//	IQuantCalibrationSettings^ GetQuantCalibrationSettings();

	IEdChordListAcquisitionController^ CreateChordlistController();
	IEdChordListSettings^ GetChordlistSettings();
																																																																	
	IMicroscopeController^ _microscopeController;
	IEdSpectrumAcquisitionController^ _edSpectrumController;
	IEdSpectrumSettings^ _edsSpectrumSettings;

	IEdChordListSettings^ _edsChordListSetting;
	IEdChordListAcquisitionController^ _edsChordListController;
	IEdChordListScanCapabilities^ _edsChordListScanCapablities;

	IImageAcquisitionController^ _imageAcqusitionController;
	IImageAcquisitionSettings^ _imageAcqusitionSettings;

	IQuantCalibrationController^ _SEMQuantController;
	IQuantCalibrationSettings^ _SEMQuantSettings;

	ISEMQuantCapabilities^ _SEMQuantCapabilities;

	static Object^ GetSpectrumLockObject()
	{
		if (spectrumSyncLock == nullptr)
		{
			spectrumSyncLock = gcnew Object();
		}

		return spectrumSyncLock;
	}
	static Object^ spectrumSyncLock;

	void ControllerThreadFunction();
	Thread^ _controllerThread;

	AutoResetEvent^ m_startControllerEvent;
	AutoResetEvent^ m_endControllerEvent;

	OxfordControllerData _oxfordControllerData;

	bool m_bBeamPositionSet;

	
};

ref class ManagedGlobals
{
public:
	static OxfordControllerWrapper^ oxfordController = nullptr;
};