#include "EntityCamera.h"




/// 初始化相机环境
bool ICamera::initEnv()
{
	//初始化巴斯勒相机
	Pylon::PylonInitialize();
	return true;
}
/// 关闭相机环境
bool ICamera::closeEnv()
{
	Pylon::PylonTerminate();
	return true;
}


/// 获取所有相机序列号       
QVector<QString> ICamera::cameraSerial()
{
	QVector<QString> Seriallist;
	Seriallist.clear();

	CTlFactory& tlFactory = CTlFactory::GetInstance();
	// 获取所有相机设备
	DeviceInfoList_t devices;
	CDeviceInfo devinfo;

	// 没找到相机
	if (0 == tlFactory.EnumerateDevices(devices))
	{
		return Seriallist;
	}

	int g_serverCount = devices.size(); //得到采集设备的数量
	for (size_t i = 0; i < g_serverCount; i++)
	{
		devinfo = devices.at(i);
		if (true == devinfo.IsDeviceClassAvailable())
		{
			QString strSerialNumber = QString(QLatin1String((char*)devinfo.GetSerialNumber().c_str() ));
			QString strUserName = QString(QLatin1String((char*)devinfo.GetUserDefinedName().c_str() ));

			QString str = strSerialNumber;
			if (!strUserName.isEmpty())
			{
			//	str = "(" + strUserName + ")" + strSerialNumber;
			}

			Seriallist.push_back(str);
		}
		
	}
	return Seriallist;
}



EntityCamera::EntityCamera() :
	m_pCamParamConfig(nullptr),
	m_pDialogCamPasram(nullptr)
{
	m_nImageChannels = 1;

	//////////////////////////////////////////////////////////////////////////
	m_pCameraCtrl = new CInstantCamera;
	

}



EntityCamera::~EntityCamera(void)
{
	this->stopWork();

	bool bcloseCamera = this->closeCamera();

	if (m_pCameraCtrl != NULL)
	{
		delete m_pCameraCtrl;
		m_pCameraCtrl = nullptr;
	}

	if (nullptr != m_pDialogCamPasram)
	{
		delete m_pDialogCamPasram;
		m_pDialogCamPasram = NULL;
	}

	if (nullptr != m_pCamParamConfig)
	{
		delete m_pCamParamConfig;
		m_pCamParamConfig = nullptr;
	}

}



/// 创建ENTITY相机
EntityCamera* EntityCamera::createCamera(QString serial)
{
	EntityCamera* camera = nullptr;

	try
	{
		camera = new EntityCamera();
		if (camera)
		{
			/// 打开相机
			if (true == camera->openCamera(serial))
			{
				if (false == camera->initialize())
				{
					delete camera;
					camera = NULL;			
				}
			}
			else
			{
				delete camera;
				camera = NULL;
			}
		}
		
	}
	catch (...)
	{
		delete camera;
		camera = NULL;
	}
	return camera;
}


/// 打开相机        
bool EntityCamera::openCamera(QString serial)
{
	QStringList qlist = serial.split(")");

	if (qlist.size() == 2)
	{
		serial = serial.split(")")[1];
	}

	bool bret = true;
	m_strSerial = serial;


	try
	{
		CDeviceInfo di;
		di.SetSerialNumber((String_t)serial.toStdString().c_str() );
		IPylonDevice* pd = CTlFactory::GetInstance().CreateDevice(di);
		if (NULL != pd && false == pd->IsOpen())
		{
			m_pCameraCtrl->Attach(pd);
			try
			{
				m_pCameraCtrl->Open();
				bret = m_pCameraCtrl->IsOpen();
			}
			catch (...)
			{
				bret = false;
				delete m_pCameraCtrl;
				m_pCameraCtrl = nullptr;

				return false;
			}
		}
		else
		{
			bret = false;
			delete m_pCameraCtrl;
			m_pCameraCtrl = nullptr;
			return false;
		}
		if (true == bret)
		{
			m_strSerial = serial;
		}

	}
	catch (...)
	{
		//AfxMessageBox(_T("相机SDk发现不可恢复的异常! 可能的原因（相机资源未有效释放）\n请重启相机!"));
		delete m_pCameraCtrl;
		m_pCameraCtrl = nullptr;
		return false;
	}

	//m_pCameraCtrl->RegisterConfiguration(new CAutoPacketSizeConfiguration(), Pylon::RegistrationMode_Append, Pylon::Cleanup_Delete);

	// 注册配置 用于监测相机断开
	//m_pCameraCtrl->RegisterConfiguration(this, RegistrationMode_ReplaceAll, Ownership_ExternalOwnership);
	// 注册图像事件 用于获取图像
	m_pCameraCtrl->RegisterImageEventHandler(this, RegistrationMode_ReplaceAll, Ownership_ExternalOwnership);

	m_pCameraCtrl->RegisterImageEventHandler(this, Pylon::RegistrationMode_ReplaceAll, Pylon::Ownership_ExternalOwnership);
	// Regist


	imageHeight();
	imageWidth();
	imageChannels();

	return bret;
}

/// 关闭相机        
bool EntityCamera::closeCamera()
{
	bool bret = true;
	if (NULL != m_pCameraCtrl)
	{
		//断开设备
		m_pCameraCtrl->Close();
	}
	return bret;
}

// 
// void readNodeList(NodeList_t* nodeList)
// {
// 	if (NULL == nodeList || true == nodeList->empty())
// 	{
// 		return;
// 	}
// 	gcstring nodeName;
// 	gcstring strval;
// 
// 	INode* node = NULL;
// 	NodeList_t nodes;
// 	size_t nodeCount = nodeList->size();
// 	CStringPtr str;
// 
// 	for (size_t i = 0; i < nodeCount; i++)
// 	{
// 		node = nodeList->at(i);
// 		nodeName = node->GetName();
// 		cout << i << " Node Name = " << nodeName << "\n";
// 
// 		/*		str = node;
// 				if ( str->IsValueCacheValid() )
// 				{
// 					strval = str->ToString();
// 					cout<< i << "Node Val = "<<strval<<"\n";
// 				} */
// 				//		node->GetChildren( nodes );
// 				//		readNodeList( &nodes );
// 	}
// 
// }
// 
// void readAllNode(INodeMap& map)
// {
// 	gcstring nodeName;
// 	gcstring devName = map.GetDeviceName();
// 	cout << "Device Name = " << devName << "\n";
// 	NodeList_t nodeList;
// 	map.GetNodes(nodeList);
// 	readNodeList(&nodeList);
// }
// 


/// 初始化
bool EntityCamera::initialize()
{

	if (NULL == m_pDialogCamPasram)
	{
		m_pDialogCamPasram = new DialogCamPasram(this);
	}

// 	if (imageChannels() == 3)
// 	{
// 		m_pColorconv->Enable(true, false);
// 		m_pColorconv->SetOutputFormat(SapFormatRGB888);
// 		m_pColorconv->SetAlign(SapColorConversion::AlignRGGB);
// 	}



	return true;
}


/// 加载参数
void EntityCamera::loadCamParam()
{

}



/// 保存参数
void EntityCamera::saveCamParam()
{

}


/// 设置相机工作模式
bool EntityCamera::setWorkMode(IBaseCamCommon::CamWorkMode mode, bool Running )
{
	bool bret = true;
	this->stopWork();
	
	switch (mode)
	{
	case IBaseCamCommon::eContinu:
		//连续采集模式 相机一直工作采图
		this->setToFreeRunMode();
		break;
	case IBaseCamCommon::eHardware:
		//中断采集模式 相机接收到硬件中断中断命令采集图像
		this->setToHardwareTrigerMode();  
		break;
	case IBaseCamCommon::eSoftware:
		//中断采集模式 相机接收到软件中断命令采集图像
		bret = this->setToSoftwareTrigerMode(); 
		break;
	case IBaseCamCommon::eSuspendCou:

		break;
	default:

		break;
	}
	mWorkMode = mode; //工作模式
	
	return bret;
}

/// 相机工作模式
IBaseCamCommon::CamWorkMode EntityCamera::workMode()
{
	return mWorkMode;
}


/// 相机开始工作
bool EntityCamera::startWork()
{
	bool bret = true;
	if (m_pCameraCtrl == nullptr)
	{
		return false;
	}

	bret = m_pCameraCtrl->IsOpen();
	if (true == bret)
	{
		if (false == m_pCameraCtrl->IsGrabbing())
		{
			m_pCameraCtrl->StartGrabbing(GrabStrategy_UpcomingImage, GrabLoop_ProvidedByInstantCamera);
			//		m_pCameraCtrl->StartGrabbing( GrabStrategy_OneByOne, GrabLoop_ProvidedByInstantCamera );
			//		m_pCameraCtrl->StartGrabbing( GrabStrategy_LatestImages, GrabLoop_ProvidedByInstantCamera );
			//		m_pCameraCtrl->StartGrabbing( GrabStrategy_LatestImageOnly, GrabLoop_ProvidedByInstantCamera );		
			bret = m_pCameraCtrl->IsGrabbing();
		}
	}
	return bret;
}

/// 相机停止工作
bool EntityCamera::stopWork()
{
	bool bret = true;
	if (m_pCameraCtrl == nullptr)
	{
		return false;
	}

	bret = m_pCameraCtrl->IsOpen();
	if (true == bret)
	{
		bret = m_pCameraCtrl->IsGrabbing();
		if (true == bret)
		{
			m_pCameraCtrl->StopGrabbing();
			bret = !m_pCameraCtrl->IsGrabbing();
		}
		else
		{
			bret = true;
		}
	}
	return bret;
}

/// 相机序列号
QString EntityCamera::serial()
{
	return m_strSerial;
}

/// 重启相机
bool EntityCamera::restartCamera()
{

	return true;
}

/// 获取一桢图像 
bool EntityCamera::captureImage(void** buf, int size)
{
	return true;
}

/// 获取图像宽
int EntityCamera::imageWidth(void)
{
	return 0;
}

/// 获取图像高
int EntityCamera::imageHeight(void)
{
	return 0;
}

/// 获取图像通道数
int EntityCamera::imageChannels(void)
{
	return m_nImageChannels;
}

/// 获取配置参数类
IBaseCamParamConfig* EntityCamera::camParamConfig()
{
	CamParamConfig* paramConfig = nullptr; //配置参数类

	if (nullptr == m_pCamParamConfig)
	{
		m_pCamParamConfig = new CamParamConfig(this);
	}
	paramConfig = m_pCamParamConfig;

	return paramConfig;
}

/// 显示设置参数窗口页面
void EntityCamera::showParamConfigWindow(int mode )
{
	if (m_pDialogCamPasram)
	{
		m_pDialogCamPasram->setModal(true);
		m_pDialogCamPasram->show();
	}
}


/// 获取相机最大分辨率
bool EntityCamera::getMaxSize(int& w, int& h)
{
	return true;
}


/// 设置相机分辨率
bool EntityCamera::setResolution(int w, int h)
{
	return true;
}

/// 获取已注册图像回调的数量
int EntityCamera::getReceCallBackSIze()
{
	return m_pImgCallBack.size();
}

///设置接收图像数据回调函数
void EntityCamera::setReceCallBack(IBaseCamCommon::receImgCallBack callBack, long long userParam, QString userID)
{
	//this->m_pReceImgFunction = callBack;
	//this->mUserParam = userParam;

	IBaseCamCommon::ImgCallBack* pImgCallBack = new IBaseCamCommon::ImgCallBack;
	pImgCallBack->pReceFunction = callBack;
	pImgCallBack->pUserParam = userParam;
	pImgCallBack->strUserID = userID;

	m_pImgCallBack.push_back(pImgCallBack);
}

///设置接收Log数据回调函数
void EntityCamera::setReceLogCallBack(IBaseCamCommon::receLogCallBack callBack, long long userParam)
{
	this->m_pReceLogFunction = callBack;
	this->mLogUserParam = userParam;
}


/// 执行回调函数
void EntityCamera::execCallFunction(IBaseCamCommon::CamImgData* img, int frameCount)
{
	for (int i = 0; i < m_pImgCallBack.size(); i++)
	{
		if (m_pImgCallBack[i]->pReceFunction != nullptr)
		{
			if (m_pImgCallBack[i]->bActivation || (m_pImgCallBack[i]->strUserID == "main"))
			{
				m_pImgCallBack[i]->pReceFunction(img, frameCount, m_strSerial,  m_pImgCallBack[i]->pUserParam);
				
				//qDebug() << "execCallFunction " << m_pImgCallBack[i]->strUserID;
			}
		}
	}
}


/// 执行Log回调函数
void EntityCamera::execLogCallFunction(QString serial, QString Massage, long long userParam)
{
	//	printf( "执行回调函数\n" );
	if (this->m_pReceLogFunction != NULL)
	{
		this->m_pReceLogFunction(serial, Massage, userParam);
	}
}


/// 软件触发采图
void EntityCamera::softTriggerCap(QString userID)
{
	if (true == m_pCameraCtrl->IsOpen() && true == m_pCameraCtrl->IsGrabbing())
	{
		// 设置触发源来自软件触发
		CEnumerationPtr(m_pCameraCtrl->GetNodeMap().GetNode("TriggerSource"))->FromString("Software");
		int timeoutMS = 500; // 等待超时时间
		if (true == m_pCameraCtrl->WaitForFrameTriggerReady(timeoutMS, TimeoutHandling_ThrowException))
		{
			// 软触发命令
			m_pCameraCtrl->ExecuteSoftwareTrigger();
		}
		// 设置触发源来自硬件触发
		//CEnumerationPtr( m_pCameraCtrl->GetNodeMap().GetNode("TriggerSource") )->FromString("Line1");	
	}

}



//////////////////////////////////////////////////////////////////////////


void EntityCamera::OnCameraDeviceRemoved(CInstantCamera& camera)
{
	//CString str;
	//str.Format(_T("相机（序列号%s）与主机断开！请检查相机与主机连接线！并重启程序！"), this->mSerial);

}


/// 图像数据读取 继承CImageEventHandler类函数
void EntityCamera::OnImageGrabbed(CInstantCamera& camera, const CGrabResultPtr& ptrGrabResult)
{
	EntityCamera* pDlg = (EntityCamera*)this;

	if (true == ptrGrabResult->GrabSucceeded())
	{
		mImgCapBuffer.channels = 1;

		mImgCapBuffer.imgData = ptrGrabResult->GetBuffer();
		mImgCapBuffer.width = ptrGrabResult->GetWidth();
		mImgCapBuffer.height = ptrGrabResult->GetHeight();

		pDlg->mImgCapBuffer.nTriggerIndex = ptrGrabResult->GetTimeStamp();
		pDlg->mImgCapBuffer.nLostPacket = ptrGrabResult->GetBlockID();
		pDlg->mImgCapBuffer.nFrameNum = ptrGrabResult->GetImageSize();

		pDlg->mImgCapBuffer.channels = 3;

		pDlg->execCallFunction(&pDlg->mImgCapBuffer, pDlg->mImgCapBuffer.count);
	}
}




/// 设置连续采集模式
bool EntityCamera::setToFreeRunMode()
{
	bool btn = true;
	if (m_pCameraCtrl == nullptr)
	{
		return false;
	}

	CEnumerationPtr triggerSelector(m_pCameraCtrl->GetNodeMap().GetNode("TriggerSelector"));
	CEnumerationPtr triggerMode(m_pCameraCtrl->GetNodeMap().GetNode("TriggerMode"));
	GenApi::IEnumEntry* acquisitionStart = triggerSelector->GetEntryByName("AcquisitionStart");
	bool m_bacquisitionStartAvailable = acquisitionStart && IsAvailable(acquisitionStart);
	if (true == m_bacquisitionStartAvailable)
	{
		triggerSelector->FromString("AcquisitionStart");
		triggerMode->FromString("Off");
	}
	GenApi::IEnumEntry* frameStart = triggerSelector->GetEntryByName("FrameStart");
	bool m_bframeStartAvailable = frameStart && IsAvailable(frameStart);
	if (true == m_bframeStartAvailable)
	{
		triggerSelector->FromString("FrameStart");
		triggerMode->FromString("Off");
	}


	CEnumerationPtr lineSource = CEnumerationPtr(m_pCameraCtrl->GetNodeMap().GetNode("LineSource"));//设置触发输出
	if (::IsAvailable(lineSource))
	{
		if (lineSource->GetEntryByName("UserOutput"))
		{
			lineSource->FromString("UserOutput");// 设置曝光期间输出
		}
	}

	return true;
}
/// 设置软件触发模式
bool EntityCamera::setToSoftwareTrigerMode()
{
	bool btn = true;
	if (m_pCameraCtrl == nullptr)
	{
		return false;
	}

	CEnumerationPtr triggerSelector(m_pCameraCtrl->GetNodeMap().GetNode("TriggerSelector"));
	GenApi::IEnumEntry* frameStart = triggerSelector->GetEntryByName("FrameStart");
	bool m_bframeStartAvailable = frameStart && IsAvailable(frameStart);
	GenApi::IEnumEntry* acquisitionStart = triggerSelector->GetEntryByName("AcquisitionStart");
	bool m_bacquisitionStartAvailable = acquisitionStart && IsAvailable(acquisitionStart);
	GENICAM_NAMESPACE::gcstring triggerSelectorValue = "FrameStart";
	INodeMap& Control = this->m_pCameraCtrl->GetNodeMap();
	CEnumerationPtr triggerMode(Control.GetNode("TriggerMode"));
	if (true == m_bacquisitionStartAvailable && false == m_bframeStartAvailable)
	{
		triggerSelector->FromString("AcquisitionStart");
		triggerMode->FromString("On");
		triggerSelectorValue = "AcquisitionStart";
	}
	else
	{
		if (true == m_bacquisitionStartAvailable)
		{
			triggerSelector->FromString("AcquisitionStart");
			triggerMode->FromString("Off");
		}
		assert(m_bframeStartAvailable); //Frame start trigger mode must be available here.
		triggerSelector->FromString("FrameStart");
		triggerMode->FromString("On");
	}
	triggerSelector->FromString(triggerSelectorValue);
	CEnumerationPtr(Control.GetNode("TriggerSource"))->FromString("Software");
	CEnumerationPtr lineSource = CEnumerationPtr(m_pCameraCtrl->GetNodeMap().GetNode("LineSource"));//设置触发输出
	if (::IsAvailable(lineSource))
	{
		if (lineSource->GetEntryByName("ExposureActive"))
		{
			lineSource->FromString("ExposureActive");// 设置曝光期间输出
		}
	}

	return true;
}

/// 设置硬件触发模式
bool  EntityCamera::setToHardwareTrigerMode()
{
	if (m_pCameraCtrl == nullptr)
	{
		return false;
	}

	CEnumerationPtr triggerSelector(m_pCameraCtrl->GetNodeMap().GetNode("TriggerSelector"));
	GenApi::IEnumEntry* frameStart = triggerSelector->GetEntryByName("FrameStart");
	bool m_bframeStartAvailable = frameStart && IsAvailable(frameStart);
	GenApi::IEnumEntry* acquisitionStart = triggerSelector->GetEntryByName("AcquisitionStart");
	bool m_bacquisitionStartAvailable = acquisitionStart && IsAvailable(acquisitionStart);
	GENICAM_NAMESPACE::gcstring triggerSelectorValue = "FrameStart";

	INodeMap& Control = this->m_pCameraCtrl->GetNodeMap();
	CEnumerationPtr triggerMode(Control.GetNode("TriggerMode"));
	if (true == m_bacquisitionStartAvailable && false == m_bframeStartAvailable)
	{
		triggerSelector->FromString("AcquisitionStart");
		triggerMode->FromString("On");
		triggerSelectorValue = "AcquisitionStart";
	}
	else
	{
		if (true == m_bacquisitionStartAvailable)
		{
			triggerSelector->FromString("AcquisitionStart");
			triggerMode->FromString("Off");
		}
		assert(m_bframeStartAvailable); //Frame start trigger mode must be available here.
		triggerSelector->FromString("FrameStart");
		triggerMode->FromString("On");
	}
	triggerSelector->FromString(triggerSelectorValue);
	CEnumerationPtr(Control.GetNode("TriggerSource"))->FromString("Line1");

	// 设置外部触发参数
	CEnumerationPtr trgActPtr = CEnumerationPtr(Control.GetNode("TriggerActivation"));
	if (::IsAvailable(trgActPtr))
	{
		if (trgActPtr->GetEntryByName("RisingEdge"))
		{
			trgActPtr->FromString("RisingEdge"); // 上升沿触发
		}
	}
	CFloatPtr trgDelayPtr = CFloatPtr(Control.GetNode("TriggerDelayAbs"));
	if (::IsAvailable(trgDelayPtr))
	{
		trgDelayPtr->SetValue(5);	 // 触发延时波长时间
	}

	CEnumerationPtr lineSelPtr = CEnumerationPtr(Control.GetNode("LineSelector"));
	if (::IsAvailable(lineSelPtr))
	{
		if (lineSelPtr->GetEntryByName("Line1"))
		{
			lineSelPtr->FromString("Line1");// 外部触发信号线
		}
	}

	CEnumerationPtr lineSelPtrout = CEnumerationPtr(Control.GetNode("LineSelector"));//设置触发输出
	if (::IsAvailable(lineSelPtrout))
	{
		if (lineSelPtrout->GetEntryByName("Out1"))
		{
			lineSelPtrout->FromString("Out1");// 设置触发输出
		}

	}

	CEnumerationPtr lineSource = CEnumerationPtr(m_pCameraCtrl->GetNodeMap().GetNode("LineSource"));//设置触发输出
	if (::IsAvailable(lineSource))
	{
		if (lineSource->GetEntryByName("ExposureActive"))
		{
			lineSource->FromString("ExposureActive");// 设置曝光期间输出
		}
	}
	return true;
}