// CCOS.Dev.FPD.DEMO.cpp : 定义 DLL 应用程序的导出函数。
//

#include "stdafx.h"
#include "CCOS.Dev.FPDDeviceMould.hpp"

using namespace CCOS::Dev;
using namespace CCOS::Dev::Detail::Detector;
namespace nsFPD = CCOS::Dev::Detail::Detector;

extern Log4CPP::Logger* gLogger;

//-----------------------------------------------------------------------------
//		AcqUnit
//-----------------------------------------------------------------------------
nsFPD::AcqUnit::AcqUnit():
m_pFullImageQueue(NULL),
m_pPrevImageData(NULL),
m_strZskkFPDState("0"),
m_strNoNeedWaitImage("0"),
m_strAutonumousMapFinish("0"),
m_strLastImage(""),
m_nFullWidth(3000),
m_nFullHeight(3000),
m_nPrevWidth(1500),
m_nPrevHeight(1500),
m_nBits(16)
{


}

nsFPD::AcqUnit:: ~AcqUnit()
{

}

void OEM_IF nsFPD::AcqUnit::SetEventCenter(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter)
{
	m_EventCenter = EventCenter;
}


RET_STATUS nsFPD::AcqUnit::JSSetAcqMode(std::string in, std::string & out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int mode = 0;
	Info ("JSSetAcqMode {$}", in.c_str ());

	if (json.GetFirstOf("P0") >= 0)
	{
		string strMode = json["P0"];
		if (strMode == "RAD")
		{
			mode = 1;
		}
		else if (strMode == "FLU")
		{
			mode = 3;
		}
		else
			mode = atoi(strMode.c_str());

		Info("StartAcquisition logicMode:{$}", mode);
	}
	SetAcqMode(mode);
	out = "test@SetAcqMode";
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::AcqUnit::JSSetGainMode(std::string in, std::string & out)
{
	Info ("SetGainMode. {$}", in.c_str ());
	ResDataObject json;
	json.decode(in.c_str());
	string strP0 = (const char*)json["P0"];
	float fGain = stof(strP0.c_str());

	RET_STATUS ret = SetGainMode(fGain);
	out = "test@SetGainMode";
	return ret;
}

RET_STATUS nsFPD::AcqUnit::JSSetBinningMode(std::string in, std::string& out)
{
	Info ("SetBinningMode. {$}", in.c_str ());
	ResDataObject json;
	json.decode(in.c_str());
	string strP0 = (const char*)json["P0"];
	string strP1 = (const char*)json["P1"];
	int nX = atoi(strP0.c_str());
	int nY = atoi(strP1.c_str());
	RET_STATUS ret = SetBinningMode(nX, nY);
	out = "test@SetBinningMode";
	return ret;
}

RET_STATUS nsFPD::AcqUnit::JSSetZoomMode(std::string in, std::string& out)
{
	Info("SetZoomMode. {$}", in.c_str());
	ResDataObject json;
	json.decode(in.c_str());
	string strP0 = (const char*)json["P0"];
	string strP1 = (const char*)json["P1"];
	string strP2 = (const char*)json["P2"];
	string strP3 = (const char*)json["P3"];
	int nX1 = atoi(strP0.c_str());
	int nY1 = atoi(strP1.c_str());
	int nX2 = atoi(strP2.c_str());
	int nY2 = atoi(strP3.c_str());
	RET_STATUS ret = SetZoomMode(nX1, nY1, nX2, nY2);
	out = "test@SetZoomMode";
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::AcqUnit::JSSetDemoImage(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	string strP0 = (const char*)json["P0"];

	Info("SetDemoImage. {$}", in.c_str());
	out = "test@SetDemoImage";
	SetDemoImage(strP0);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::AcqUnit::SetDemoImage(string strFile)
{
	Info("AcqUnit::SetDemoImage\n");
	return RET_STATUS::RET_SUCCEED;
}

bool OEM_IF nsFPD::AcqUnit::SetMaxBlockSize(const char *pQueName, DWORD BlockSize, DWORD FulBlockCount, DWORD PrevBlockCount)
{
	return true;
}

bool OEM_IF nsFPD::AcqUnit::SetFulImageInfo(DWORD Height, DWORD Width, DWORD Bits, bool FetchFlag)
{
	m_nFullWidth = Width;
	m_nFullHeight = Height;
	m_nBits = Bits;
	return true;
}

bool OEM_IF nsFPD::AcqUnit::SetPrevImageInfo(bool Support, DWORD Height, DWORD Width, bool FetchFlag)
{
	m_nPrevWidth = Width;
	m_nPrevHeight = Height;
	return true;
}

RET_STATUS nsFPD::AcqUnit::JSGetZskkFPDState(std::string & out)
{
	out = m_strZskkFPDState;
	return RET_STATUS::RET_SUCCEED;
}

bool OEM_IF nsFPD::AcqUnit::SetZskkFPDState(ZSKK_FPD_STATE state)
{
	auto szFDinfo = std::to_string(state);
	m_strZskkFPDState = szFDinfo;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, CcosZskkFPDState, m_strZskkFPDState);

	return true;
}

RET_STATUS nsFPD::AcqUnit::JSGetNoNeedWaitImage(std::string & out)
{
	out = m_strNoNeedWaitImage;
	return RET_STATUS::RET_SUCCEED;
}

void OEM_NOTIFY nsFPD::AcqUnit::SendNoNeedWaitImage(bool bflag)
{
	auto szFDinfo = std::to_string(bflag);
	m_EventCenter->OnNotify((int)ATTRACTION_SET, "NoNeedWaitImage", szFDinfo);
	Info("Send NoNeedWaitImage");
	return;
}

RET_STATUS nsFPD::AcqUnit::JSGetLastImage(std::string & out)
{
	out = m_strLastImage;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::AcqUnit::AddFrameWithRawHead(IMAGE_VIEW_TYPE eType, string ImageHead, unsigned char* pFrameBuff, DWORD FrameSize)
{
	ResDataObject json;
	if (IMAGE_FULL == eType)
	{
		json.add("ImageType", 0);//IMAGE_TYPE_2D: 0; IMAGE_TYPE_3D: 1
		json.add("Viewtype", (int)eType);
		json.add("Sharememid", "0");
		json.add("Imageid", "0");
		json.add("Width", m_nFullWidth);
		json.add("Height", m_nFullHeight);
		json.add("Bit", m_nBits);
	}

	if (IMAGE_PREVIEW == eType || IMAGE_AEC_PREVIEW == eType)
	{
		json.add("ImageType", 0);//IMAGE_TYPE_2D: 0; IMAGE_TYPE_3D: 1
		json.add("Viewtype", (int)eType);
		json.add("Sharememid", "0");
		json.add("Imageid", "0");
		json.add("Width", m_nPrevWidth);
		json.add("Height", m_nPrevHeight);
		json.add("Bit", m_nBits);
	}

	m_strLastImage = json.encode();

	m_EventCenter->OnDataNotify((int)eType, "ImgDataInfo", m_strLastImage, ImageHead, (char *)pFrameBuff, FrameSize);
	Info("AddFrameWithRawHead:{$}", m_strLastImage.c_str());
	return RET_STATUS::RET_SUCCEED;
}

DWORD nsFPD::AcqUnit::AddFrame(IMAGE_VIEW_TYPE Type, string ImageHead, WORD* pFrameBuff, DWORD FrameSize)
{
	return 0;
}


/********************************************************************/
//
//图像沿X轴做翻转，
//pData:[IN][OUT] 图像数据
//nWidth[IN] nHeight[IN]
/********************************************************************/
bool nsFPD::AcqUnit::FlipX(WORD* pData, UINT nWidth, UINT nHeight)
{
	UINT j = 0;
	UINT i = 0;
	WORD temp;

	//修改翻转的判断，之前的代码会导致中央区域多翻转一个像素
	for (i = 0; i < nWidth; i++)
	{
		for (j = 0; j < nHeight / 2; j++)
		{
			int nSrc = j * nWidth + i;
			int nDes = (nHeight - j - 1) * nWidth + i;
			temp = pData[nSrc];
			pData[nSrc] = pData[nDes];
			pData[nDes] = temp;
		}
	}

	return true;
}

/********************************************************************/
//
//图像沿Y轴做翻转，
//pData:[IN][OUT] 图像数据
//nWidth[IN] nHeight[IN]
/********************************************************************/
bool nsFPD::AcqUnit::FlipY(WORD* pData, UINT nWidth, UINT nHeight)
{
	UINT j = 0;
	UINT i = 0;
	WORD temp;

	//修改翻转的判断，之前的代码会导致中央区域多翻转一个像素
	for (i = 0; i < nHeight; i++)
	{
		for (j = 0; j < nWidth / 2; j++)
		{
			temp = pData[i * nWidth + j];
			pData[i * nWidth + j] = pData[(i + 1) * nWidth - j - 1];
			pData[(i + 1) * nWidth - j - 1] = temp;
		}
	}
	return true;
}

/***
** 说明：旋转图像
** 参数：nAngle，顺时针旋转角度,0 90 180 270
** addbyys20200810
***/
bool nsFPD::AcqUnit::RotateImage(WORD* imageBuffer, int nImageHeight, int nImageWidth, int nAngle)
{
	bool ret = true;
	if (NULL == imageBuffer || 0 == nImageHeight || 0 == nImageWidth)
	{
		return false;
	}
	int nTemp = 0;
	int i = 0, j = 0;//for loop
	WORD* ptempData;
	ptempData = new WORD[nImageHeight * nImageWidth];

	switch (nAngle)
	{
	case 90: //顺时针旋转90°
		//TPRINTA_INFO("Rotate 90 degrees clockwise");
		nTemp = nImageHeight;
		nImageHeight = nImageWidth;
		nImageWidth = nTemp;
		try
		{
			memcpy(ptempData, imageBuffer, nImageHeight * nImageWidth * sizeof(WORD));
			for (i = 0; i < nImageHeight; i++)
			{
				for (j = 0; j < nImageWidth; j++)
				{
					imageBuffer[i * nImageWidth + j] = ptempData[(nImageWidth - 1 - j) * nImageHeight + i];
				}
			}
		}
		catch (...)
		{
			//TPRINTA_INFO("Rotate image crashed");
			ret = false;
		}
		break;
	case 180: //顺时针旋转180°
		//TPRINTA_INFO("Rotate 180 degrees clockwise");
		try
		{
			memcpy(ptempData, imageBuffer, nImageHeight * nImageWidth * sizeof(WORD));
			for (i = 0; i < nImageWidth * nImageHeight; i++)
			{
				imageBuffer[i] = ptempData[nImageWidth * nImageHeight - 1 - i];
			}
		}
		catch (...)
		{
			//TPRINTA_INFO("Rotate image crashed");
			ret = false;
		}
		break;
	case 270: //顺时针旋转270°
		//TPRINTA_INFO("Rotate 270 degrees clockwise");
		nTemp = nImageHeight;
		nImageHeight = nImageWidth;
		nImageWidth = nTemp;
		try
		{
			memcpy(ptempData, imageBuffer, nImageWidth * nImageHeight * sizeof(WORD));
			for (i = 0; i < nImageHeight; i++)
			{
				for (j = 0; j < nImageWidth; j++)
				{
					imageBuffer[i * nImageWidth + j] = ptempData[j * nImageHeight + (nImageHeight - 1 - i)];
				}
			}
		}
		catch (...)
		{
			//TPRINTA_INFO("Rotate image crashed");
			ret = false;
		}
		break;
	default:
		ret = false;
		break;
	}
	delete[] ptempData;
	ptempData = NULL;
	return ret;
}

RET_STATUS nsFPD::AcqUnit::SetGainMode(float nGain)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::AcqUnit::SetBinningMode(int nBinningX, int nBinningY)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::AcqUnit::SetZoomMode(int nZOOMX1, int nZOOMY1, int nZOOMX2, int nZOOMY2)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::AcqUnit::JSAutonumousMapFinish(std::string& out)
{
	out = m_strAutonumousMapFinish;
	return RET_STATUS::RET_SUCCEED;
}

void OEM_NOTIFY nsFPD::AcqUnit::SendAutonumousMapFinish(int nFlag)
{
	string szFPDinfo = "";
	szFPDinfo = to_string(nFlag);
	m_strAutonumousMapFinish = szFPDinfo;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, "AutonumousMapFinish", szFPDinfo);
	Info("Send AutonumousMapFinish({$})", szFPDinfo);
	return;
}

//超声相关
RET_STATUS nsFPD::AcqUnit::JSSetFreeze(std::string in, std::string& out) 
{
	ResDataObject json;
	json.decode(in.c_str());
	int nFreeze = 0;//1 冻结 0 解冻
	Info("JSSetFreeze {$}", in.c_str());

	if (json.GetFirstOf("P0") >= 0)
	{
		string strFreeze = json["P0"];
		nFreeze = atoi(strFreeze.c_str());
	}
	out = "test@JSSetFreeze";
	return SetFreeze(nFreeze);
}
RET_STATUS nsFPD::AcqUnit::JSSwitchProbe(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nProbeType = 1;//1 线阵 2 凸阵
	Info("JSSwitchProbe {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (json.GetFirstOf("P0") >= 0)
	{
		string strProbeType = json["P0"];
		nProbeType = atoi(strProbeType.c_str());
		out = "test@JSSwitchProbe";
		ret = SwitchProbe(nProbeType);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			return ret;
		}
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::ProbeType, strProbeType);
	}
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSwitchProbeMode(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nProbeMode = 1;//1 B 2 C
	Info("JSSwitchProbeMode {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (json.GetFirstOf("P0") >= 0)
	{
		string strProbeMode = json["P0"];
		nProbeMode = atoi(strProbeMode.c_str());
		out = "test@JSSwitchProbeMode";
		ret = SwitchProbeMode(nProbeMode);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			return ret;
		}
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::ProbeMode, strProbeMode);
	}
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSetBGain(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nGain = 50;
	Info("JSSetBGain {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (json.GetFirstOf("P0") >= 0)
	{
		string strGain = json["P0"];
		nGain = atoi(strGain.c_str());
		out = "test@JSSetBGain";
		ret = SetBGain(nGain);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			return ret;
		}
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::BGain, strGain);
	}
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSetBDepth(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nDepth = 15; //范围 1-31
	Info("JSSetBDepth {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (json.GetFirstOf("P0") >= 0)
	{
		string strDepth = json["P0"];
		nDepth = atoi(strDepth.c_str());
		out = "test@JSSetBDepth";
		ret = SetBDepth(nDepth);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			return ret;
		}
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::BDepth, strDepth);
	}
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSetBFrequency(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	//线阵 5.00 6.67 7.50 8.00 10.00 单位(Hz)
	//凸阵 2.90 3.50 5.00 单位(Hz)
	float frequency = 5.00f;
	Info("JSSetBFrequency {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (json.GetFirstOf("P0") >= 0)
	{
		string strFrequency = json["P0"];
		frequency = stof(strFrequency);
		out = "test@JSSetBFrequency";
		ret = SetBFrequency(frequency);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			return ret;
		}
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::BFrequency, strFrequency);
	}
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSetBFocus(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nFocus = 7; //范围 0-15
	Info("JSSetBFocus {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (json.GetFirstOf("P0") >= 0)
	{
		string strFocus = json["P0"];
		nFocus = atoi(strFocus.c_str());
		out = "test@JSSetBFocus";
		ret = SetBFocus(nFocus);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			return ret;
		}
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::BFocus, strFocus);
	}
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSetBHarmonic(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nHarmonic = 0; //0 关 1 开
	Info("JSSetBHarmonic {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (json.GetFirstOf("P0") >= 0)
	{
		string strHarmonic = json["P0"];
		nHarmonic = atoi(strHarmonic.c_str());
		out = "test@JSSetBHarmonic";
		ret = SetBHarmonic(nHarmonic);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			return ret;
		}
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::BHarmonic, strHarmonic);
	}
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSetBPower(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nPower = 0; //0-3
	Info("JSSetBPower {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (json.GetFirstOf("P0") >= 0)
	{
		string strPower = json["P0"];
		nPower = atoi(strPower.c_str());
		out = "test@JSSetBPower";
		ret = SetBPower(nPower);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			return ret;
		}
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::BPower, strPower);
	}
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSetBDynamicRange(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nRange = 0; //0-15
	Info("JSSetBDynamicRange {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (json.GetFirstOf("P0") >= 0)
	{
		string strRange = json["P0"];
		nRange = atoi(strRange.c_str());
		out = "test@JSSetBDynamicRange";
		ret = SetBDynamicRange(nRange);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			return ret;
		}
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::BDynamicRange, strRange);
	}
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSGetBDepth(std::string in, std::string& out)
{
	Info("JSGetBDepth");
	int nDepth = 0;
	float fCm = 0.0f;
	RET_STATUS ret = GetBDepth(nDepth, fCm);
	if (ret != RET_STATUS::RET_SUCCEED)
	{
		return ret;
	}
	ResDataObject json;
	std::string strDepth = std::to_string(nDepth);
	std::string strDepthCm = std::to_string(fCm);
	json.add(AttrKey::BDepth, strDepth.c_str());
	json.add(AttrKey::BDepthCm, strDepthCm.c_str());
	string result = json.encode();
	out = result;
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSGetBFrequency(std::string in, std::string& out)
{
	Info("JSGetBFrequency");
	float frequency = 0.0f;
	RET_STATUS ret = GetBFrequency(frequency);
	if (ret != RET_STATUS::RET_SUCCEED)
	{
		return ret;
	}
	ResDataObject json;
	std::string strFrequency = std::to_string(frequency);
	json.add(AttrKey::BFrequency, strFrequency.c_str());
	string result = json.encode();
	out = result;
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSGetBGain(std::string in, std::string& out)
{
	Info("JSGetBGain");
	int nGain = 0;
	RET_STATUS ret = GetBGain(nGain);
	if (ret != RET_STATUS::RET_SUCCEED)
	{
		return ret;
	}
	ResDataObject json;
	std::string strGain = std::to_string(nGain);
	json.add(AttrKey::BGain, strGain.c_str());
	string result = json.encode();
	out = result;
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSGetBFocus(std::string in, std::string& out)
{
	Info("JSGetBFocus");
	int nFocus = 0;
	float fCm = 0.0f;
	RET_STATUS ret = GetBFocus(nFocus,fCm);
	if (ret != RET_STATUS::RET_SUCCEED)
	{
		return ret;
	}
	ResDataObject json;
	std::string strFocus = std::to_string(nFocus);
	std::string strFocusCm = std::to_string(fCm);
	json.add(AttrKey::BFocus, strFocus.c_str());
	json.add(AttrKey::BFocusCm, strFocusCm.c_str());
	string result = json.encode();
	out = result;
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSGetBDynamicRange(std::string in, std::string& out)
{
	Info("JSGetBDynamicRange");
	int nRange = 0;
	RET_STATUS ret = GetBDynamicRange(nRange);
	if (ret != RET_STATUS::RET_SUCCEED)
	{
		return ret;
	}
	ResDataObject json;
	std::string strRange = std::to_string(nRange);
	json.add(AttrKey::BDynamicRange, strRange.c_str());
	string result = json.encode();
	out = result;
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSetCRoi(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int x1 = 0, x2 = 0, y1 = 0, y2 = 0; //x 1-640 y 1-480
	Info("JSSetCRoi {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;
	string strNotifyX1;
	string strNotifyX2;
	string strNotifyy1;
	string strNotifyy2;
	if (json.GetFirstOf("P0") >= 0)
	{
		string strx1 = json["P0"];
		x1 = atoi(strx1.c_str());
		strNotifyX1 = strx1;
	}
	if (json.GetFirstOf("P1") >= 0)
	{
		string strx2 = json["P1"];
		x2 = atoi(strx2.c_str());
		strNotifyX2 = strx2;
	}
	if (json.GetFirstOf("P2") >= 0)
	{
		string stry1 = json["P2"];
		y1 = atoi(stry1.c_str());
		strNotifyy1 = stry1;
	}
	if (json.GetFirstOf("P3") >= 0)
	{
		string stry2 = json["P3"];
		y2 = atoi(stry2.c_str());
		strNotifyy2 = stry2;
	}
	ret = SetCRoi(x1, x2, y1, y2);
	if (ret != RET_STATUS::RET_SUCCEED)
	{
		return ret;
	}
	out = "test@JSSetCRoi";

	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::CxLeft, strNotifyX1);
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::CxRight, strNotifyX2);
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::CyTop, strNotifyy1);
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::CyBottom, strNotifyy2);
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSetCGain(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nGain = 0; //0-255
	Info("JSSetCGain {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (json.GetFirstOf("P0") >= 0)
	{
		string strGain = json["P0"];
		nGain = atoi(strGain.c_str());
		out = "test@JSSetCGain";
		ret = SetCGain(nGain);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			return ret;
		}
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::CGain, strGain);
	}
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSetPostLevel(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nLevel = 3; //0-5
	Info("JSSetPostLevel {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (json.GetFirstOf("P0") >= 0)
	{
		string strLevel = json["P0"];
		nLevel = atoi(strLevel.c_str());
		out = "test@JSSetPostLevel";
		ret = SetPostLevel(nLevel);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			return ret;
		}
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::PostLevel, strLevel);
	}
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSetMirror(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nMirror = 0; //1 镜像 0 取消镜像
	Info("JSSetMirror {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (json.GetFirstOf("P0") >= 0)
	{
		string strMirror = json["P0"];
		nMirror = atoi(strMirror.c_str());
		out = "test@JSSetMirror";
		ret = SetMirror(nMirror);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			return ret;
		}
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::Mirror, strMirror);
	}
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSetCFrequency(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	float frequency = 0.0f;
	Info("JSSetCFrequency {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (json.GetFirstOf("P0") >= 0)
	{
		string strFrequency = json["P0"];
		frequency = stof(strFrequency);
		out = "test@JSSetCFrequency";
		ret = SetCFrequency(frequency);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			return ret;
		}
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::CFrequency, strFrequency);
	}
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSetCSpeedWallFilter(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nSpeedWallFilter = 0; //0-31
	Info("JSSetCSpeedWallFilter {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (json.GetFirstOf("P0") >= 0)
	{
		string strSpeedWallFilter = json["P0"];
		nSpeedWallFilter = atoi(strSpeedWallFilter.c_str());
		out = "test@JSSetCSpeedWallFilter";
		ret = SetCSpeedWallFilter(nSpeedWallFilter);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			return ret;
		}
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::CSpeedWallFilter, strSpeedWallFilter);
	}
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSetCRangeWallFilter(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nRangeWallFilter = 0; //0-31
	Info("JSSetCRangeWallFilter {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (json.GetFirstOf("P0") >= 0)
	{
		string strRangeWallFilter = json["P0"];
		nRangeWallFilter = atoi(strRangeWallFilter.c_str());
		out = "test@JSSetCRangeWallFilter";
		ret = SetCRangeWallFilter(nRangeWallFilter);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			return ret;
		}
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::CRangeWallFilter, strRangeWallFilter);
	}
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSetCPersistence(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nPersistence = 0; //0-9
	Info("JSSetCPersistence {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (json.GetFirstOf("P0") >= 0)
	{
		string strPersistence = json["P0"];
		nPersistence = atoi(strPersistence.c_str());
		out = "test@JSSetCPersistence";
		ret = SetCPersistence(nPersistence);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			return ret;
		}
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::CPersistence, strPersistence);
	}
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSetCLinearAngle(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nAngle = 0;
	Info("JSSetCLinearAngle {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (json.GetFirstOf("P0") >= 0)
	{
		string strAngle = json["P0"];
		nAngle = atoi(strAngle.c_str());
		out = "test@JSSetCLinearAngle";
		ret = SetCLinearAngle(nAngle);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			return ret;
		}
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::CLinearAngle, strAngle);
	}
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSetCPrf(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nPrf = 0;//0-15
	Info("JSSetCPrf {$}", in.c_str());
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (json.GetFirstOf("P0") >= 0)
	{
		string strPrf = json["P0"];
		nPrf = atoi(strPrf.c_str());
		out = "test@JSSetCPrf";
		ret = SetCLinearAngle(nPrf);
		if (ret != RET_STATUS::RET_SUCCEED)
		{
			return ret;
		}
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::CPrf, strPrf);
	}
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSGetCFrequency(std::string in, std::string& out)
{
	Info("JSGetCFrequency");
	float frequency = 0.0f;
	RET_STATUS ret = GetCFrequency(frequency);
	if (ret != RET_STATUS::RET_SUCCEED)
	{
		return ret;
	}
	ResDataObject json;
	std::string strFrequency = std::to_string(frequency);
	json.add(AttrKey::CFrequency, strFrequency.c_str());
	string result = json.encode();
	out = result;
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSGetCGain(std::string in, std::string& out)
{
	Info("JSGetCGain");
	int nGain = 0;
	RET_STATUS ret = GetCGain(nGain);
	if (ret != RET_STATUS::RET_SUCCEED)
	{
		return ret;
	}
	ResDataObject json;
	std::string strGain = std::to_string(nGain);
	json.add(AttrKey::CGain, strGain.c_str());
	string result = json.encode();
	out = result;
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSGetCPrf(std::string in, std::string& out)
{
	Info("JSGetCPrf");
	int nPrf = 0;
	RET_STATUS ret = GetCPrf(nPrf);
	if (ret != RET_STATUS::RET_SUCCEED)
	{
		return ret;
	}
	ResDataObject json;
	std::string strPrf = std::to_string(nPrf);
	json.add(AttrKey::CPrf, strPrf.c_str());
	string result = json.encode();
	out = result;
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSGetCLinearAngle(std::string in, std::string& out)
{
	Info("JSGetCLinearAngle");
	int nAngle = 0;
	RET_STATUS ret = GetCLinearAngle(nAngle);
	if (ret != RET_STATUS::RET_SUCCEED)
	{
		return ret;
	}
	ResDataObject json;
	std::string strAngle = std::to_string(nAngle);
	json.add(AttrKey::CLinearAngle, strAngle.c_str());
	string result = json.encode();
	out = result;
	return ret;
}
RET_STATUS nsFPD::AcqUnit::JSSetTgc1(std::string in, std::string& out) 
{
	ResDataObject json;
	json.decode(in.c_str());
	int nTgc = 0;
	Info("JSSetTgc1 {$}", in.c_str());

	if (json.GetFirstOf("P0") >= 0)
	{
		string strTgc = json["P0"];
		nTgc = atoi(strTgc.c_str());
	}
	out = "test@JSSetTgc1";
	return SetTgc1(nTgc);
}
RET_STATUS nsFPD::AcqUnit::JSSetTgc2(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nTgc = 0;
	Info("JSSetTgc2 {$}", in.c_str());

	if (json.GetFirstOf("P0") >= 0)
	{
		string strTgc = json["P0"];
		nTgc = atoi(strTgc.c_str());
	}
	out = "test@JSSetTgc2";
	return SetTgc2(nTgc);
}
RET_STATUS nsFPD::AcqUnit::JSSetTgc3(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nTgc = 0;
	Info("JSSetTgc3 {$}", in.c_str());

	if (json.GetFirstOf("P0") >= 0)
	{
		string strTgc = json["P0"];
		nTgc = atoi(strTgc.c_str());
	}
	out = "test@JSSetTgc3";
	return SetTgc3(nTgc);
}
RET_STATUS nsFPD::AcqUnit::JSSetTgc4(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nTgc = 0;
	Info("JSSetTgc4 {$}", in.c_str());

	if (json.GetFirstOf("P0") >= 0)
	{
		string strTgc = json["P0"];
		nTgc = atoi(strTgc.c_str());
	}
	out = "test@JSSetTgc4";
	return SetTgc4(nTgc);
}
RET_STATUS nsFPD::AcqUnit::JSSetTgc5(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nTgc = 0;
	Info("JSSetTgc5 {$}", in.c_str());

	if (json.GetFirstOf("P0") >= 0)
	{
		string strTgc = json["P0"];
		nTgc = atoi(strTgc.c_str());
	}
	out = "test@JSSetTgc5";
	return SetTgc5(nTgc);
}
RET_STATUS nsFPD::AcqUnit::JSSetTgc6(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nTgc = 0;
	Info("JSSetTgc6 {$}", in.c_str());

	if (json.GetFirstOf("P0") >= 0)
	{
		string strTgc = json["P0"];
		nTgc = atoi(strTgc.c_str());
	}
	out = "test@JSSetTgc6";
	return SetTgc6(nTgc);
}
RET_STATUS nsFPD::AcqUnit::JSSetTgc7(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nTgc = 0;
	Info("JSSetTgc7 {$}", in.c_str());

	if (json.GetFirstOf("P0") >= 0)
	{
		string strTgc = json["P0"];
		nTgc = atoi(strTgc.c_str());
	}
	out = "test@JSSetTgc7";
	return SetTgc7(nTgc);
}
RET_STATUS nsFPD::AcqUnit::JSSetTgc8(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nTgc = 0;
	Info("JSSetTgc8 {$}", in.c_str());

	if (json.GetFirstOf("P0") >= 0)
	{
		string strTgc = json["P0"];
		nTgc = atoi(strTgc.c_str());
	}
	out = "test@JSSetTgc8";
	return SetTgc8(nTgc);
}


RET_STATUS nsFPD::AcqUnit::SetFreeze(int nFreeze) 
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SwitchProbe(int nProbeType)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SwitchProbeMode(int nProbeMode)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetBGain(int nGain)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetBDepth(int nDepth)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetBFrequency(float fFrequency)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetBFocus(int nFocus)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetBHarmonic(int nHarmonic)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetBPower(int nPower)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetBDynamicRange(int nRange)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::GetBDepth(int& nDepth, float& fDepthCm)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::GetBFrequency(float& fFrequency)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::GetBGain(int& nGain)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::GetBFocus(int& nFocus, float& fFocusCm)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::GetBDynamicRange(int& nRange)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetCRoi(int x1, int x2, int y1, int y2)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetCGain(int nGain)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetPostLevel(int nLevel)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetMirror(int nMirror)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetCFrequency(float fFrequency)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetCSpeedWallFilter(int nSpeedWallFilter)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetCRangeWallFilter(int nRangeWallFilter)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetCPersistence(int nPersistence)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetCLinearAngle(int nAngle)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetCPrf(int nPrf)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::GetCFrequency(float& fFrequency)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::GetCGain(int& nGain)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::GetCPrf(int& nPrf)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::GetCLinearAngle(int& nAngle)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::AcqUnit::SetTgc1(int nTgc)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetTgc2(int nTgc)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetTgc3(int nTgc)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetTgc4(int nTgc)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetTgc5(int nTgc)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetTgc6(int nTgc)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetTgc7(int nTgc)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::AcqUnit::SetTgc8(int nTgc)
{
	return RET_STATUS::RET_SUCCEED;
}

void nsFPD::AcqUnit::NotifyProbeType(int nProbeType)
{
	Info("NotifyProbeType nProbeType:{$}", nProbeType);
	string probeType = std::to_string(nProbeType);
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::ProbeType, probeType);
}