//Camera.cpp
#include "Camera.h"
#include <stdexcept>
#include <pylon/PylonIncludes.h>

using namespace Pylon;
using namespace std;
using namespace GenApi;
using namespace std;

String_t ID_t;

MyCamera::MyCamera() {
	
}
MyCamera::~MyCamera() {
	Dispose();
}
void MyCamera::OpenCamera() {
	PylonInitialize();
	//camera = new CInstantCamera();//CTlFactory::GetInstance().CreateFirstDevice()
	camera.Attach(CTlFactory::GetInstance().CreateFirstDevice());

	cout << camera.GetDeviceInfo().GetFullName() << endl;
	camera.RegisterImageEventHandler(new CImageEventPrinter, RegistrationMode_Append, Cleanup_Delete);
	// For demonstration purposes only, register another configuration event handler that handles device removal.
	camera.RegisterConfiguration(new CSampleConfigurationEventHandler, RegistrationMode_Append, Cleanup_Delete);
	camera.Open();
	CHeartbeatHelper heartbeatHelper(camera);
	heartbeatHelper.SetValue(1000);
}
void MyCamera::OpenCameraByID(String_t ID) {
	ID_t = ID;
	PylonInitialize();
	CDeviceInfo cInfo;
	cInfo.SetSerialNumber(ID);
	camera.Attach(CTlFactory::GetInstance().CreateDevice(cInfo));
	cout << camera.GetDeviceInfo().GetFullName() << endl;
	camera.RegisterImageEventHandler(new CImageEventPrinter, RegistrationMode_Append, Cleanup_Delete);
	// For demonstration purposes only, register another configuration event handler that handles device removal.
	camera.RegisterConfiguration(new CSampleConfigurationEventHandler, RegistrationMode_Append, Cleanup_Delete);
	camera.Open();
	CHeartbeatHelper heartbeatHelper(camera);
	heartbeatHelper.SetValue(1000);
}
void MyCamera::CloseCamera() {
	camera.Close();
}
void MyCamera::StartGrabing() {
	camera.StartGrabbing(GrabStrategy_OneByOne, GrabLoop_ProvidedByInstantCamera);
	camera.ExecuteSoftwareTrigger();
	std::cout << "Using device 11" << camera.GetDeviceInfo().GetModelName() << endl;
	
}
void MyCamera::StopGrabing() {
	camera.StopGrabbing();
}

void MyCamera::Dispose() {
	camera.DestroyDevice();
}

bool MyCamera::SetPixelForamt(char* PixelForamt) {
	GenApi::INodeMap& nodemap = camera.GetNodeMap();
	// Set the pixel data format.
	CEnumerationPtr(nodemap.GetNode("PixelFormat"))->FromString(PixelForamt);
	return true;
}

bool MyCamera::SetGain(double newGain) {

	INodeMap& nodemap = camera.GetNodeMap();
	CEnumerationPtr gainAuto(nodemap.GetNode("GainAuto"));
	if (IsWritable(gainAuto))
	{
		gainAuto->FromString("Off");
		// Check to see which Standard Feature Naming Convention (SFNC) is used by the camera device.
		if (camera.GetSfncVersion() >= Sfnc_2_0_0)
		{
			// Access the Gain float type node. This node is available for USB camera devices.
			// USB camera devices are compliant to SFNC version 2.0.
			CFloatPtr gain(nodemap.GetNode("Gain"));
			gain->SetValue(newGain);
			cout << "Gain (50%)       : " << gain->GetValue() << " (Min: " << gain->GetMin() << "; Max: " << gain->GetMax() << ")" << endl;
		}
		else
		{
			// Access the GainRaw integer type node. This node is available for IIDC 1394 and GigE camera devices.
			CIntegerPtr gainRaw(nodemap.GetNode("GainRaw"));
			gainRaw->SetValue(newGain);
			cout << "Gain (50%)       : " << gainRaw->GetValue() << " (Min: " << gainRaw->GetMin() << "; Max: " << gainRaw->GetMax() << "; Inc: " << gainRaw->GetInc() << ")" << endl;
		}

		return true;
	}
	return false;
}
int  MyCamera::GetGain() {
	return (int)GetCamera(Type_Basler_GainRaw);
}
bool MyCamera::SetFps(double fps) {
	SetCamera(Type_Basler_AcquisitionFrameRateAbs, fps);
	return true;
}

int MyCamera::GetFps() {
	return (int)GetCamera(Type_Basler_AcquisitionFrameRateAbs);
}
bool MyCamera::SetExposure(double time) {

	SetCamera(Type_Basler_ExposureTimeAbs, time);
	return true;
}
int MyCamera::getExposureTime()
{
	return (int)GetCamera(Type_Basler_ExposureTimeAbs);
}
int MyCamera::getExposureTimeMin()
{
	return DOUBLE_MIN;
}
int MyCamera::getExposureTimeMax()
{
	return DOUBLE_MAX;
}

bool MyCamera::SetROI(int W, int H, int X, int Y) {
	GenApi::INodeMap& nodemap = camera.GetNodeMap();
	//获取相机成像宽度和高度
	const CIntegerPtr width = nodemap.GetNode("Width");
	const CIntegerPtr height = nodemap.GetNode("Height");
	const CIntegerPtr offsetX = nodemap.GetNode("OffsetX");
	const CIntegerPtr offsetY = nodemap.GetNode("OffsetY");
	width->SetValue(W);
	height->SetValue(H);
	offsetX->SetValue(X);
	offsetY->SetValue(Y);
	cout << W << H << X << Y << endl;
	return true;
}
int MyCamera::GetOffsetX() {
	INodeMap& control = camera.GetNodeMap();
	const CIntegerPtr offsetX = control.GetNode("OffsetX");
	return offsetX->GetValue();
}
int MyCamera::GetOffsetY() {
	INodeMap& control = camera.GetNodeMap();
	const CIntegerPtr offsetY = control.GetNode("OffsetY");
	return offsetY->GetValue();
}
int MyCamera::GetWidth() {
	INodeMap& control = camera.GetNodeMap();

	const CIntegerPtr width = control.GetNode("Width");
	return width->GetValue();
}
int MyCamera::GetHeight() {
	INodeMap& control = camera.GetNodeMap();

	const CIntegerPtr height = control.GetNode("Height");
	return height->GetValue();
}


double MyCamera::GetCamera(MyCamera::MyCamera_Type index)
{
	INodeMap& cameraNodeMap = camera.GetNodeMap();
	switch (index) {
	case Type_Basler_ExposureTimeAbs: {
		const CFloatPtr exposureTime = cameraNodeMap.GetNode("ExposureTimeAbs");
		return exposureTime->GetValue();
	} break;
	case Type_Basler_GainRaw: {
		const CIntegerPtr cameraGen = cameraNodeMap.GetNode("GainRaw");
		return cameraGen->GetValue();
	} break;
	case Type_Basler_AcquisitionFrameRateAbs: {
		const CBooleanPtr frameRate = cameraNodeMap.GetNode("AcquisitionFrameRateEnable");
		frameRate->SetValue(TRUE);
		const CFloatPtr frameRateABS = cameraNodeMap.GetNode("AcquisitionFrameRateAbs");
		return frameRateABS->GetValue();
	} break;
	case Type_Basler_Width: {
		const CIntegerPtr widthPic = cameraNodeMap.GetNode("Width");
		return widthPic->GetValue();
	} break;
	case Type_Basler_Height: {
		const CIntegerPtr heightPic = cameraNodeMap.GetNode("Height");
		return heightPic->GetValue();
	} break;
	default:
		return -1;
		break;
	}
}
void MyCamera::SetCamera(MyCamera::MyCamera_Type index, double tmpValue)
{
	INodeMap& cameraNodeMap = camera.GetNodeMap();
	switch (index) {
	case Type_Basler_Freerun: {
		CEnumerationPtr  ptrTriggerSel = cameraNodeMap.GetNode("TriggerSelector");
		ptrTriggerSel->FromString("FrameStart");
		CEnumerationPtr  ptrTrigger = cameraNodeMap.GetNode("TriggerMode");
#ifdef Real_Freerun
		ptrTrigger->SetIntValue(0);
#else //Software
		ptrTrigger->SetIntValue(1);
		CEnumerationPtr  ptrTriggerSource = cameraNodeMap.GetNode("TriggerSource");
		ptrTriggerSource->FromString("Software");
#endif
	} break;
	case Type_Basler_Line1: {
		CEnumerationPtr  ptrTriggerSel = cameraNodeMap.GetNode("TriggerSelector");
		ptrTriggerSel->FromString("FrameStart");
		CEnumerationPtr  ptrTrigger = cameraNodeMap.GetNode("TriggerMode");
		ptrTrigger->SetIntValue(1);
		CEnumerationPtr  ptrTriggerSource = cameraNodeMap.GetNode("TriggerSource");
		ptrTriggerSource->FromString("Line1");
	} break;
	case Type_Basler_ExposureTimeAbs: {
		const CFloatPtr exposureTime = cameraNodeMap.GetNode("ExposureTimeAbs");
		exposureTime->SetValue(tmpValue);
	} break;
	case Type_Basler_GainRaw: {
		const CIntegerPtr cameraGen = cameraNodeMap.GetNode("GainRaw");
		cameraGen->SetValue(tmpValue);
	} break;
	case Type_Basler_AcquisitionFrameRateAbs: {
		const CBooleanPtr frameRate = cameraNodeMap.GetNode("AcquisitionFrameRateEnable");
		frameRate->SetValue(TRUE);
		const CFloatPtr frameRateABS = cameraNodeMap.GetNode("AcquisitionFrameRateAbs");
		frameRateABS->SetValue(tmpValue);
	} break;
	case Type_Basler_Width: {
		const CIntegerPtr widthPic = cameraNodeMap.GetNode("Width");
		widthPic->SetValue(tmpValue);
	} break;
	case Type_Basler_Height: {
		const CIntegerPtr heightPic = cameraNodeMap.GetNode("Height");
		heightPic->SetValue(tmpValue);
	} break;
	case Type_Basler_LineSource: {
		CEnumerationPtr  ptrLineSource = cameraNodeMap.GetNode("LineSource");
		ptrLineSource->SetIntValue(2);
	} break;
	default:
		break;
	}
}

void MyCamera::setConvertImageHandler(ConvertImageHandler handler) {
	m_hanlder = handler;
}

void MyCamera::DetectCamera() {

	if (camera.IsCameraDeviceRemoved()) {
		CTlFactory& tlFactory = CTlFactory::GetInstance();
		CDeviceInfo info;
		// Remember the camera properties that allow detecting the same camera again.
		info.SetDeviceClass(camera.GetDeviceInfo().GetDeviceClass());
		info.SetSerialNumber(camera.GetDeviceInfo().GetSerialNumber());

		// Create a filter containing the CDeviceInfo object info which describes the properties of the device we are looking for.
		DeviceInfoList_t filter;
		filter.push_back(info);
		DeviceInfoList_t devices;
		cout << "<<<<<<<<<<<<<<<<<<<<<<<<<<" << endl;
		if (tlFactory.EnumerateDevices(devices, filter) > 0)
		{
			cout << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>" << endl;
			// Destroy the Pylon Device representing the detached camera device.
			// It cannot be used anymore.
			camera.DestroyDevice();
			// The camera has been found. Create and attach it to the Instant Camera object.
			camera.Attach(tlFactory.CreateDevice(devices[0]));
			camera.Open();
			CHeartbeatHelper heartbeatHelper(camera);
			//Reset heartbeat 1000
			heartbeatHelper.SetValue(1000);
			StartGrabing();
		}
	}

}

//Camera.h
#pragma once
#include <stdexcept>
#include <pylon/PylonIncludes.h>

using namespace Pylon;
using namespace std;
using namespace GenApi;
#define DOUBLE_MAX 100000
#define DOUBLE_MIN 0

//定义抓取的图像数
static const uint32_t c_countOfImagesToGrab = 10;
using namespace std;
typedef void (*ConvertImageHandler)(uint8_t* cameraData);
static ConvertImageHandler m_hanlder;
class CImageEventPrinter : public CImageEventHandler
{
public:
	virtual void OnImageGrabbed(CInstantCamera& camera, const CGrabResultPtr& ptrGrabResult)
	{
		if (ptrGrabResult->GrabSucceeded())
		{
			uint8_t* pImageBuffer = (uint8_t*)ptrGrabResult->GetBuffer();
			m_hanlder(pImageBuffer);
			//std::cout << "SizeX: " << ptrGrabResult->GetWidth() << std::endl;
			//std::cout << "SizeY: " << ptrGrabResult->GetHeight() << std::endl;
			//const uint8_t* pImageBuffer = (uint8_t*)ptrGrabResult->GetBuffer();
			//std::cout << "Gray value of first pixel: " << (uint32_t)pImageBuffer[0] << std::endl;
			//std::cout << std::endl;
		}
		else
		{
			std::cout << "Error: " << ptrGrabResult->GetErrorCode() << " " << ptrGrabResult->GetErrorDescription() << std::endl;
		}
	}
};
// Simple helper class to set the HeartbeatTimeout safely.
class CHeartbeatHelper
{
public:
	explicit CHeartbeatHelper(CInstantCamera& camera)
		: m_pHeartbeatTimeout(NULL)
	{
		// m_pHeartbeatTimeout may be NULL
		m_pHeartbeatTimeout = camera.GetTLNodeMap().GetNode("HeartbeatTimeout");
	}

	bool SetValue(int64_t NewValue)
	{
		// Do nothing if no heartbeat feature is available.
		if (!m_pHeartbeatTimeout.IsValid())
			return false;

		// Apply the increment and cut off invalid values if neccessary.
		int64_t correctedValue = NewValue - (NewValue % m_pHeartbeatTimeout->GetInc());
		m_pHeartbeatTimeout->SetValue(correctedValue);
		cout << "设置相机心跳成功--CHeartbeat："<< NewValue << std::endl;
		return true;
	}

	bool SetMax()
	{
		// Do nothing if no heartbeat feature is available.
		if (!m_pHeartbeatTimeout.IsValid())
			return false;

		int64_t maxVal = m_pHeartbeatTimeout->GetMax();
		return SetValue(maxVal);
	}

protected:
	GenApi::CIntegerPtr m_pHeartbeatTimeout; 
};

class CSampleConfigurationEventHandler : public Pylon::CConfigurationEventHandler
{
public:
	void OnCameraDeviceRemoved(CInstantCamera& /*camera*/)
	{
		cout << "相机已掉线。" << std::endl;
	}
};
class MyCamera
{
public:
	MyCamera();
	~MyCamera();
	enum MyCamera_Type {
		Type_Basler_Freerun,
		Type_Basler_Line1, 
		Type_Basler_ExposureTimeAbs, 
		Type_Basler_GainRaw, 
		Type_Basler_AcquisitionFrameRateAbs, 
		Type_Basler_Width, 
		Type_Basler_Height, 
		Type_Basler_LineSource, 
	};
	void OpenCamera();
	void OpenCameraByID(String_t ID); 
	void CloseCamera();
	void StartGrabing();
	void StopGrabing();
	void Dispose();
	void DetectCamera();
	bool SetPixelForamt(char* PixelForamt);
	bool SetROI(int W, int H, int X, int Y);
	bool SetExposure(double exposure);
	bool SetGain(double newGain);
	bool SetFps(double fps);
	double GetCamera(MyCamera::MyCamera_Type index);
	int getExposureTime(); 
	int getExposureTimeMin(); 
	int getExposureTimeMax();
	int GetWidth();
	int GetHeight();
	int GetOffsetX();
	int GetOffsetY();
	int GetFps();
	int GetGain();
	void SetCamera(MyCamera::MyCamera_Type index, double tmpValue);
	void setConvertImageHandler(ConvertImageHandler handler);
private:
	CInstantCamera camera;
	
};

// UseCamera.h

#pragma once

#include "Camera.h"

MyCamera*  InitCamera();

void  OpenCamera(MyCamera* PCamera);

void  OpenCameraByID(MyCamera* PCamera,char* ID);

void  CloseCamera(MyCamera* PCamera);

void  StartGrabing(MyCamera* PCamera);

void  StopGrabing(MyCamera* PCamera);

void  Dispose(MyCamera* PCamera);

bool  SetPixelForamt(MyCamera* PCamera,char* PixelForamt);

bool  SetROI(MyCamera* PCamera,int W, int H, int X, int Y);

void  setConvertImageHandler(MyCamera* PCamera,ConvertImageHandler handler);

bool  SetExposure(MyCamera* PCamera, double exposure);

bool  SetGain(MyCamera* PCamera, double newGain);

bool  SetFps(MyCamera* PCamera, double fps);

int  getExposureTime(MyCamera* PCamera);

int  getExposureTimeMin(MyCamera* PCamera);

int  getExposureTimeMax(MyCamera* PCamera);

int  GetWidth(MyCamera* PCamera);

int  GetHeight(MyCamera* PCamera);

int  GetOffsetX(MyCamera* PCamera);

int  GetOffsetY(MyCamera* PCamera);

int  GetFps(MyCamera* PCamera);

int  GetGain(MyCamera* PCamera);

// UseCamera.cpp

#include "UseCamera.h"
#include<thread>
using namespace std;
bool Csignal = true;

void CameraLostDector(MyCamera* PCamera) {
	while (Csignal) {
		Sleep(500);
		//cout << "dect XXXXX,,," << endl;
		if (Csignal)
			PCamera->DetectCamera();
	}
}

 MyCamera* InitCamera()
{
	 MyCamera* PCamera = new MyCamera();
	return PCamera;
}

 void  OpenCamera(MyCamera* PCamera)
{
	if (PCamera != NULL)
	{
		PCamera->OpenCamera();
		Csignal = true;
		thread T1(CameraLostDector, PCamera);
		T1.detach();
	}
}

 void  OpenCameraByID(MyCamera* PCamera, char* ID)
 {
	 if (PCamera != NULL)
	 {
		 PCamera->OpenCameraByID(ID);
		 Csignal = true;
		 thread T1(CameraLostDector, PCamera);
		 T1.detach();
	 }
 }

 void  CloseCamera(MyCamera* PCamera)
{
	 if (PCamera != NULL)
	 {
		 PCamera->CloseCamera();
		 Csignal = false;
	 }
}

 void  StartGrabing(MyCamera* PCamera)
{
	 if (PCamera != NULL)
	 {
		 PCamera->StartGrabing();
	 }
}

 void  StopGrabing(MyCamera* PCamera)
{
	 if (PCamera != NULL)
	 {
		 PCamera->StopGrabing();
		 Csignal = false;
	 }
}

 void  Dispose(MyCamera* PCamera)
{
	 if (PCamera != NULL)
	 {
		 PCamera->Dispose();
	 }
}

bool  SetPixelForamt(MyCamera* PCamera, char* PixelForamt)
{
	if (PCamera != NULL)
	{
		PCamera->SetPixelForamt(PixelForamt);
	}
	return true;
}

bool  SetROI(MyCamera* PCamera, int W, int H, int X, int Y)
{
	if (PCamera != NULL)
	{
		PCamera->SetROI( W,  H,  X,  Y);
	}
	return true;
}

void  setConvertImageHandler(MyCamera* PCamera, ConvertImageHandler handler)
{
	if (PCamera != NULL)
	{
		PCamera->setConvertImageHandler(handler);
	}
}

bool SetExposure(MyCamera* PCamera, double exposure)
{
	if (PCamera != NULL)
	{
		return PCamera->SetExposure(exposure);
	}
	return false;
}

bool SetGain(MyCamera* PCamera, double newGain)
{
	if (PCamera != NULL)
	{
		return PCamera->SetGain(newGain);
	}
	return false;
}

bool SetFps(MyCamera* PCamera, double fps)
{
	if (PCamera != NULL)
	{
		return PCamera->SetFps(fps);
	}
	return false;
}

int getExposureTime(MyCamera* PCamera)
{
	return PCamera->getExposureTime();
}

int getExposureTimeMin(MyCamera* PCamera)
{
	return PCamera->getExposureTimeMin();
}

int getExposureTimeMax(MyCamera* PCamera)
{
	return PCamera->getExposureTimeMax();
}

int GetWidth(MyCamera* PCamera)
{
	return PCamera->GetWidth();
}

int GetHeight(MyCamera* PCamera)
{
	return PCamera->GetHeight();
}

int GetOffsetX(MyCamera* PCamera)
{
	return PCamera->GetOffsetX();
}

int GetOffsetY(MyCamera* PCamera)
{
	return PCamera->GetOffsetY();
}

int GetFps(MyCamera* PCamera)
{
	return PCamera->GetFps();
}

int GetGain(MyCamera* PCamera)
{
	return PCamera->GetGain();
}