#include "Hd_25DCameraVJ_module.h"
#include <QDebug>

#include <QQueue>

#include <QTextCodec>
//data == "rest_newProductIn"时要结束run；机台报警，取图超时，复位后重新拍的情况。
bool ifBreak = false;
//ifRunning减少ifBreak的判断；"rest_newProductIn"时，Logic_camera_thread框架会结束未处理完的相相机取图
bool ifRunning = false;
int imgIndex = 0;
QString byteArrayToUnicode(const QByteArray array) {

	// state用于保存转换状态，它的成员invalidChars，可用来判断是否转换成功
	// 如果转换成功，则值为0，如果值大于0，则说明转换失败
	QTextCodec::ConverterState state;
	// 先尝试使用utf-8的方式把QByteArray转换成QString
	QString text = QTextCodec::codecForName("UTF-8")->toUnicode(array.constData(), array.size(), &state);
	// 如果转换时无效字符数量大于0，说明编码格式不对
	if (state.invalidChars > 0)
	{
		// 再尝试使用GBK的方式进行转换，一般就能转换正确(当然也可能是其它格式，但比较少见了)
		text = QTextCodec::codecForName("GBK")->toUnicode(array);
	}
	return text;
}
KglDevice* kglDevice;
KglStream* kglStream;
KglGenParameterArray* kgllFeatureNodes;
KglGenParameterArray* kgllStreamFeatureNodes;
LocalKglDeviceEventSink* ab;
KglBuffer* kglBuffer;
std::string sModelName;
// Camera type
#define CameraTypeArea 1
#define CameraTypeLine 2
#define CameraTypeXT 3
#define CameraTypeRB 4
int iCameraType;

QQueue<vector<cv::Mat>> queuePic;
QMutex* n_mutex = new QMutex();
std::vector<std::string> sImageType;
static int imgNum = 1;
//是否为标准通信流程：
//标准通信流程，run函数设置曝光/增益；非标准通信流程（简单通信流程），回调函数设置曝光/增益
bool ifStandard = false;
//相机取图超时时间
int getImageTimeOut = 1000;
bool moduleStatus = false;

#pragma region Device control
bool Connect(int index)
{
	KglSystem kglSystem;
	const KglDeviceInfo* deviceInfo;
	std::string inputkey;
	if (KGL_SUCCESS != kglSystem.find()) {
		qDebug() << "Failed to find camera device.";
		return false;
	}

	uint32_t count = kglSystem.getDeviceCount();
	if (count == 0)
	{
		qDebug() << ("No camera device can be found.\n");
		return false;
	}
	/*else
	{
		qDebug() <<("Select the camera device number.\n\n");
		for (uint32_t i = 0; i < count; ++i)
		{
			deviceInfo = kglSystem.getDeviceInfo(i);
			sModelName = deviceInfo->getModelName();
			std::string sMACAddress = (std::string)deviceInfo->getMACAddress();
			qDebug() <<("%d : %s_KEYENCE CORPORATION_%s\n", i + 1, sMACAddress.c_str(), sModelName.c_str());
		}
		std::cin >> inputkey;
		qDebug() <<("------------------------------\n");
	}*/

	//uint32_t selectNum = atoi(inputkey.c_str()) - 1;
	if ((index < 0) || (count <= index))
	{
		qDebug() << ("The entry is invalid.\n");
		return false;
	}

	kglDevice = new KglDevice();
	kglStream = new KglStream();

	deviceInfo = kglSystem.getDeviceInfo(index);
	sModelName = deviceInfo->getModelName();
	if ((sModelName == ("CA-HL02MX")) ||
		(sModelName == ("CA-HL04MX")) ||
		(sModelName == ("CA-HL08MX")))
	{
		iCameraType = CameraTypeLine;
	}
	else if ((sModelName == ("XT-024")) ||
		(sModelName == ("XT-060")))
	{
		iCameraType = CameraTypeXT;
	}
	else if ((sModelName == ("RB-500")) ||
		(sModelName == ("RB-800")) ||
		(sModelName == ("RB-1200")))
	{
		iCameraType = CameraTypeRB;
	}
	else {
		iCameraType = CameraTypeArea;
	}

	if (KGL_SUCCESS != kglDevice->connect(deviceInfo->getIPAddress())) {
		qDebug() << ("Cannot connect to the camera device.\n");
		return false;
	}

	if (KGL_SUCCESS != kglStream->open(*kglDevice)) {
		qDebug() << ("Cannot connect to the stream.\n");
		return false;
	}



	// Get FeatureNode of camera device
	kgllFeatureNodes = kglDevice->getDeviceParameters();
	kgllStreamFeatureNodes = kglStream->getStreamParameters();
	moduleStatus = true;
	return true;
}

void Disconnect()
{
	moduleStatus = false;
	if ((kglStream != NULL) && (kglStream->isOpen()))
	{
		KglResult result = kglStream->close(*kglDevice);
		if (KGL_SUCCESS != result) {
			qDebug() << ("Cannot disconnect from the stream.\n");
			return;
		}
	}

	if ((kglDevice != NULL) && (kglDevice->isConnected()))
	{
		if (KGL_SUCCESS != kglDevice->disconnect()) {
			qDebug() << ("Cannot disconnect from the camera device.\n");
			return;
		}
	}
}
#pragma endregion

#pragma region Feature access

void setFeatureNodes(const std::string sFeatureName, const int64_t value)
{
	KglResult result;
	KglString sConfigurationLastFailureCause;

	qDebug() << "(2.5Dmodel) " << "[setFeatureNodes] " << sFeatureName.c_str() << value;
	result = kgllStreamFeatureNodes->setIntegerValue(sFeatureName.c_str(), value);
	if (KGL_SUCCESS != result)
	{
		qDebug() << "(2.5Dmodel) " << ("Error : setParam\n");
		return;
	}

}

void setIntegerValue(const std::string sFeatureName, const int64_t value)
{
	KglResult result;
	KglString sConfigurationLastFailureCause;

	qDebug() << "(2.5Dmodel) " << "[setIntegerValue] " << sFeatureName.c_str() << value;
	result = kgllFeatureNodes->setIntegerValue(sFeatureName.c_str(), value);
	if (KGL_SUCCESS != result)
	{
		qDebug() << "(2.5Dmodel) " << ("Error : setParam\n");
		return;
	}

}

void setFloatValue(const std::string sFeatureName, const double value)
{
	KglResult result;
	KglString sConfigurationLastFailureCause;

	qDebug() << "(2.5Dmodel) " << "[setFloatValue] " << sFeatureName.c_str() << value;
	result = kgllFeatureNodes->setFloatValue(sFeatureName.c_str(), value);
	if (KGL_SUCCESS != result)
	{
		if (KGL_SUCCESS != result)
		{
			qDebug() << "(2.5Dmodel) " << ("Error : setParam\n");
			return;
		}
	}
}

void setBooleanValue(const std::string sFeatureName, const bool value)
{
	KglResult result;
	KglString sConfigurationLastFailureCause;

	qDebug() << "(2.5Dmodel) " << "[setBooleanValue] " << sFeatureName.c_str() << value;
	result = kgllFeatureNodes->setBooleanValue(sFeatureName.c_str(), value);
	if (KGL_SUCCESS != result)
	{
		if (KGL_SUCCESS != result)
		{
			qDebug() << "(2.5Dmodel) " << ("Error : setParam\n");
			return;
		}
	}
}

void setEnumValue(const std::string sFeatureName, std::string value)
{
	KglResult result;
	KglString sConfigurationLastFailureCause;

	qDebug() << "(2.5Dmodel) " << "[setEnumValue] " << sFeatureName.c_str() << value.c_str();
	result = kgllFeatureNodes->setEnumValue(sFeatureName.c_str(), value.c_str());
	if (KGL_SUCCESS != result)
	{
		qDebug() << "(2.5Dmodel) " << ("Error : setParam\n");
		return;
	}
}

void setStringValue(const std::string sFeatureName, const std::string value)
{
	KglResult result;
	KglString sConfigurationLastFailureCause;

	qDebug() << "(2.5Dmodel) " << "[setStringValue] " << sFeatureName.c_str() << value.c_str();
	result = kgllFeatureNodes->setStringValue(sFeatureName.c_str(), value.c_str());
	if (KGL_SUCCESS != result)
	{
		qDebug() << "(2.5Dmodel) " << ("Error : setParam\n");
		return;
	}
}

void executeCommand(const std::string sFeatureName)
{
	KglResult result;
	qDebug() << "(2.5Dmodel) " << "[executeCommand] " << sFeatureName.c_str();
	result = kgllFeatureNodes->executeCommand(sFeatureName.c_str());
	if (KGL_SUCCESS != result)
	{
		qDebug() << "(2.5Dmodel) " << ("Error : execCommand\n");
		return;
	}
}

void getIntegerValue(const std::string sFeatureName, int64_t& value)
{
	KglResult result;

	result = kgllFeatureNodes->getIntegerValue(sFeatureName.c_str(), value);
	if (KGL_SUCCESS != result)
	{
		qDebug() << ("Error : getParam\n");
		return;
	}
}

void getFloatValue(const std::string sFeatureName, double& value)
{
	KglResult result;

	result = kgllFeatureNodes->getFloatValue(sFeatureName.c_str(), value);
	if (KGL_SUCCESS != result)
	{
		qDebug() << ("Error : getParam\n");
		return;
	}
}

void getBooleanValue(const std::string sFeatureName, bool& value)
{
	KglResult result;

	result = kgllFeatureNodes->getBooleanValue(sFeatureName.c_str(), value);
	if (KGL_SUCCESS != result)
	{
		qDebug() << ("Error : getParam\n");
		return;
	}
}

void getEnumValue(const std::string sFeatureName, std::string& value)
{
	KglResult result;
	KglString featurevalue;

	result = kgllFeatureNodes->getEnumValue(sFeatureName.c_str(), featurevalue);
	value = featurevalue;

	if (KGL_SUCCESS != result)
	{
		qDebug() << ("Error : getParam\n");
		return;
	}
}

void getStringValue(const std::string sFeatureName, std::string& value)
{
	KglResult result;
	KglString featurevalue;

	result = kgllFeatureNodes->getStringValue(sFeatureName.c_str(), featurevalue);
	value = featurevalue;
	if (KGL_SUCCESS != result)
	{
		qDebug() << ("Error : getParam\n");
		return;
	}
}
//
//bool setSystemFeatureValue(const std::string sFeatureName, const int64_t value)
//{
//	KglResult result;
//	KglString sConfigurationLastFailureCause;
//
//	qDebug() << ("2.5Dmodel\t") << "[setSystemFeatureValue] " << sFeatureName.c_str() << value;
//	result = kgllFeatureNodes->setIntegerValue(sFeatureName.c_str(), value);
//	if (KGL_SUCCESS != result)
//	{
//		qDebug() << ("2.5Dmodel\t") << ("Error : setParam\n");
//		QString str = QString::fromStdString(sFeatureName) + "_" + QString::number(result, 16);
//		throw exception(str.toStdString().c_str());
//		return;
//	}
//}
#pragma endregion

#pragma region  Import XML 
void ImportDeviceParameters(std::string sFilePath)
{
	setEnumValue("OperationMode", "SetupMode");

	if (!sFilePath.empty())
	{
		KglTargetDataSet target = (KglTargetDataSet)(KglTargetData::CameraParameters)
			| (KglTargetDataSet)(KglTargetData::ParameterSetOfCameraParameter)
			| (KglTargetDataSet)(KglTargetData::ModelImageOfCameraParameter)
			| (KglTargetDataSet)(KglTargetData::CameraParametersOfEnvironmentSettings)
			| (KglTargetDataSet)(KglTargetData::CommonParametersOfEnvironmentSettings)
			| (KglTargetDataSet)(KglTargetData::CommonCameraParameters)
			| (KglTargetDataSet)(KglTargetData::CalibrationOfCameraParameter);
		KglImportDeviceParamOption option = KglImportDeviceParamOption();
		option.bOverwriteModelImage = true;
		option.bOverwriteCalibration = true;
		KglString failFeature;

		KglResult ret = kglDevice->importDeviceParameters(sFilePath.c_str(), failFeature, target, option);
		if (ret != KGL_SUCCESS)
		{
			qDebug() << ("Failed to load a Feature List file.\n");
			return;
		}
	}

	setEnumValue("OperationMode", "RunMode");
}
#pragma endregion

#pragma region Optional Functions
std::vector<std::string> GetEnableImageType(std::string sImageType)
{
	std::vector<std::string> EnableImageType;

	std::string StdImageTypeTable[1][2] =
	{
		{ "StdNormalImageEnable",       "StdNormalImage" }
	};

	std::string LtrxNmlImageTypeTable[15][2] =
	{
		{ "LtrxNormalImageEnable",      "LtrxNormalImage" },
	{ "LtrxUpperImageEnable",       "LtrxUpperImage" },
	{ "LtrxUpperRightImageEnable",  "LtrxUpperRightImage" },
	{ "LtrxRightImageEnable",       "LtrxRightImage" },
	{ "LtrxLowerRightImageEnable",  "LtrxLowerRightImage" },
	{ "LtrxLowerImageEnable",       "LtrxLowerImage" },
	{ "LtrxLowerLeftImageEnable",   "LtrxLowerLeftImage" },
	{ "LtrxLeftImageEnable",        "LtrxLeftImage" },
	{ "LtrxUpperLeftImageEnable",   "LtrxUpperLeftImage" },
	{ "LtrxShapeImage1Enable",      "LtrxShapeImage1" },
	{ "LtrxShapeImage2Enable",      "LtrxShapeImage2" },
	{ "LtrxShapeImage3Enable",      "LtrxShapeImage3" },
	{ "LtrxTextureImageEnable",     "LtrxTextureImage" },
	{ "LtrxGradientXImageEnable",   "LtrxGradientXImage" },
	{ "LtrxGradientYImageEnable",   "LtrxGradientYImage" },
	};

	std::string MlspImageTypeTable[11][2] =
	{
		{ "MlspUVImageEnable",          "MlspUVImage" },
	{ "MlspBlueImageEnable",        "MlspBlueImage" },
	{ "MlspGreenImageEnable",       "MlspGreenImage" },
	{ "MlspAmberImageEnable",       "MlspAmberImage" },
	{ "MlspRedImageEnable",         "MlspRedImage" },
	{ "MlspFarRedImageEnable",      "MlspFarRedImage" },
	{ "MlspIRImageEnable",          "MlspIRImage" },
	{ "MlspWhiteImageEnable",       "MlspWhiteImage" },
	{ "MlspAverageGrayscaleImageEnable",    "MlspAverageGrayscaleImage" },
	{ "MlspColorImageEnable",       "MlspColorImage" },
	{ "MlspColorDifferenceImageEnable",     "MlspColorDifferenceImage" }
	};

	std::string SprfImageTypeTable[16][2] =
	{
		{ "SprfX1ImageEnable",          "SprfX1Image" },
	{ "SprfX2ImageEnable",          "SprfX2Image" },
	{ "SprfX3ImageEnable",          "SprfX3Image" },
	{ "SprfX4ImageEnable",          "SprfX4Image" },
	{ "SprfY1ImageEnable",          "SprfY1Image" },
	{ "SprfY2ImageEnable",          "SprfY2Image" },
	{ "SprfY3ImageEnable",          "SprfY3Image" },
	{ "SprfY4ImageEnable",          "SprfY4Image" },
	{ "SprfSpecularReflectionImageEnable",  "SprfSpecularReflectionImage" },
	{ "SprfDiffuseReflectionImageEnable",   "SprfDiffuseReflectionImage" },
	{ "SprfShapeImage1Enable",      "SprfShapeImage1" },
	{ "SprfShapeImage2Enable",      "SprfShapeImage2" },
	{ "SprfPhaseXImageEnable",      "SprfPhaseXImage" },
	{ "SprfPhaseYImageEnable",      "SprfPhaseYImage" },
	{ "SprfGlossRatioImageEnable",  "SprfGlossRatioImage" },
	{ "SprfNormalImageEnable",      "SprfNormalImage" }
	};

	std::string Cap3DImageTypeTable[2][2] =
	{
		{ "Cap3DAreascan3DImageEnable", "Areascan3DImage" },
	{ "Cap3DAreascan2DImageEnable", "Areascan2DImage" },
	};

	std::string RBImageTypeTable[2][2] =
	{
		{ "Areascan3DImageEnable", "Areascan3DImage" },
	{ "Areascan2DGrayscaleImageEnable", "Areascan2DGrayscaleImage" },
	};

	std::string XTImageTypeTable[3][2] =
	{
		{ "Areascan3DImageEnable", "Areascan3DImage" },
	{ "Areascan2DColorImageEnable", "Areascan2DColorImage" },
	{ "Areascan2DGrayscaleImageEnable", "Areascan2DGrayscaleImage" }
	};

	std::string FilteredImageTable[8][2] =
	{
		{ "FilteredImageEnable",       "FilteredImage1" },
	{ "FilteredImageEnable",       "FilteredImage2" },
	{ "FilteredImageEnable",       "FilteredImage3" },
	{ "FilteredImageEnable",       "FilteredImage4" },
	{ "FilteredImageEnable",       "FilteredImage5" },
	{ "FilteredImageEnable",       "FilteredImage6" },
	{ "FilteredImageEnable",       "FilteredImage7" },
	{ "FilteredImageEnable",       "FilteredImage8" }
	};

	int64_t sTargetParameterSet;
	getIntegerValue("TargetParameterSet", sTargetParameterSet);
	setIntegerValue("ParameterSetSelector", sTargetParameterSet);

	if (iCameraType == CameraTypeLine)
	{
		std::string sCaptureMode;
		getEnumValue("CaptureMode", sCaptureMode);
		if (sCaptureMode == "Fixed_MultipleImages")
		{
			bool sEnable;
			getBooleanValue("IndividualFilterPerFixedCaptureNoEnable", sEnable);
			if (sEnable)
			{
				int64_t sTargetCaptureCount;
				getIntegerValue("TargetFixedCaptureNo", sTargetCaptureCount);
				setIntegerValue("FixedCaptureNoSelector", sTargetCaptureCount);
			}
		}
	}

	bool sEnable;
	if (iCameraType == CameraTypeRB)
	{
		for (UINT i = 0; i < 2; i++)
		{
			std::string sFeatureName = RBImageTypeTable[i][0];
			std::string sImageName = RBImageTypeTable[i][1];
			getBooleanValue(sFeatureName, sEnable);
			if (sEnable)
			{
				EnableImageType.push_back(sImageName);
			}
		}
	}
	else if (iCameraType == CameraTypeXT)
	{
		for (UINT i = 0; i < 3; i++)
		{
			std::string sFeatureName = XTImageTypeTable[i][0];
			std::string sImageName = XTImageTypeTable[i][1];
			getBooleanValue(sFeatureName, sEnable);
			if (sEnable)
			{
				EnableImageType.push_back(sImageName);
			}
		}
	}
	else
	{
		std::string sLightingMode = "";
		getEnumValue("ImagingMode", sLightingMode);

		if (sLightingMode == "StandardLighting")
		{
			for (UINT i = 0; i < 1; i++)
			{
				std::string sFeatureName = StdImageTypeTable[i][0];
				std::string sImageName = StdImageTypeTable[i][1];
				getBooleanValue(sFeatureName, sEnable);
				if (sEnable)
				{
					EnableImageType.push_back(sImageName);
				}
			}
		}
		else if (sLightingMode == "LumiTrax")
		{
			for (UINT i = 0; i < 15; i++)
			{
				std::string sFeatureName = LtrxNmlImageTypeTable[i][0];
				std::string sImageName = LtrxNmlImageTypeTable[i][1];
				getBooleanValue(sFeatureName, sEnable);
				if (sEnable)
				{
					EnableImageType.push_back(sImageName);
				}
			}
		}
		else if (sLightingMode == "MultiSpectrum")
		{
			for (UINT i = 0; i < 11; i++)
			{
				std::string sFeatureName = MlspImageTypeTable[i][0];
				std::string sImageName = MlspImageTypeTable[i][1];
				getBooleanValue(sFeatureName, sEnable);
				if (sEnable)
				{
					EnableImageType.push_back(sImageName);
				}
			}
		}
		else if (sLightingMode == "LumiTraxSpecularReflection")
		{
			for (UINT i = 0; i < 16; i++)
			{
				std::string sFeatureName = SprfImageTypeTable[i][0];
				std::string sImageName = SprfImageTypeTable[i][1];
				getBooleanValue(sFeatureName, sEnable);
				if (sEnable)
				{
					EnableImageType.push_back(sImageName);
				}
			}
		}
		else if (sLightingMode == "Capture3D")
		{
			for (UINT i = 0; i < 2; i++)
			{
				std::string sFeatureName = Cap3DImageTypeTable[i][0];
				std::string sImageName = Cap3DImageTypeTable[i][1];
				getBooleanValue(sFeatureName, sEnable);
				if (sEnable)
				{
					EnableImageType.push_back(sImageName);
				}
			}
		}
	}

	for (UINT i = 0; i < 8; i++)
	{
		setIntegerValue("FilteredImageSelector", (i + 1));

		std::string sFeatureName = FilteredImageTable[i][0];
		std::string sImageName = FilteredImageTable[i][1];
		getBooleanValue(sFeatureName, sEnable);
		if (sEnable)
		{
			EnableImageType.push_back(sImageName);
		}
	}

	UINT ImageTypeSize = (UINT)EnableImageType.size();
	if (ImageTypeSize < 5)
	{
		for (int i = ImageTypeSize; i < 5; i++)
		{
			EnableImageType.push_back("");
		}
	}

	qDebug() << ("Select an image type.\n\n");

	for (UINT i = 0; i < ImageTypeSize; ++i)
	{
		qDebug() << ((std::to_string(i + 1) + " :" + EnableImageType[i] + "\n").c_str());
	}

	uint32_t iSelected = atoi(sImageType.c_str());
	if ((iSelected == 0) || (iSelected > ImageTypeSize))
	{
		qDebug() << ("The entry is invalid.\n");
		return EnableImageType;
	}
	return EnableImageType;
}

void ConvertRGBA8toBGRA8(void* buffer, int pixelSize)
{
	byte dataR;
	byte dataB;

	for (int i = 0; i < pixelSize; i++)
	{
		dataR = *((byte*)(buffer)+(i * 4));
		dataB = *((byte*)(buffer)+(i * 4) + 2);

		*((byte*)(buffer)+(i * 4)) = dataB;
		*((byte*)(buffer)+(i * 4) + 2) = dataR;
	}
}
#pragma endregion

#pragma region Acquisition control

bool AcquisitionStart()
{
	KglResult result;

	result = kglStream->startAcquisition(*kglDevice);
	if (KGL_SUCCESS != result) {
		qDebug() << ("Error : acquisitionStart\n");
		return false;
	}

	qDebug() << "[AcquisitionStart] " << result;
	return true;
}

void AcquisitionStop()
{
	KglResult result;

	result = kglStream->stopAcquisition(*kglDevice);
	if (KGL_SUCCESS != result) {
		qDebug() << ("Error : acquisitionStop\n");
		return;
	}
}

bool QueueBuffer()
{
	KglResult result;
	KglResult operationResult;

	uint32_t payloadsize = kglDevice->getPayloadSize();
	if (payloadsize == 0)
	{
		qDebug() << ("Error : getPayloadSize\n");
		return false;
	}

	kglBuffer = new KglBuffer();
	result = kglBuffer->allocate(payloadsize);
	if (KGL_SUCCESS != result)
	{
		qDebug() << ("Error : allocate\n");
		return false;
	}

	result = kglStream->queueBuffer(kglBuffer);
	if ((KGL_SUCCESS != result) && (KGL_PENDING != result))
	{
		qDebug() << ("Error : queueBuffer\n");
		return false;
	}
}

cv::Mat RetrieveBuffer()
{
	KglResult result;
	KglResult operationResult;

	result = kglStream->retrieveBuffer(&kglBuffer, operationResult);
	if ((KGL_SUCCESS != result) || (KGL_SUCCESS != operationResult))
	{
		qDebug() << "[retrieveBuffer] " << "result:" << result;
		qDebug() << "[retrieveBuffer] " << "operationResult:" << operationResult;
		if (kglBuffer != NULL)
		{
			kglBuffer->free();//设置成只执行一次
			delete(kglBuffer);
			kglBuffer = NULL;
		}
		qDebug() << ("Error : retrieveBuffer\n");
		return Mat();
	}

	UINT bmpSize = kglBuffer->getAcquiredSize();
	char* data = (char*)malloc(bmpSize);

	CopyMemory((void*)data, kglBuffer->getDataPointer(), bmpSize);

	cv::Mat mat;
	int64_t width;
	int64_t height;
	std::string sPixelFormat;
	getIntegerValue("Width", width);
	getIntegerValue("Height", height);
	getEnumValue("PixelFormat", sPixelFormat);

	if (sPixelFormat == "Mono8")
	{
		mat = cv::Mat(height, width, CV_8UC1, data);
	}

	else if (sPixelFormat == "Mono16")
	{
		mat = cv::Mat(height, width, CV_16UC1, data);
	}

	else if (sPixelFormat == "BGR8Packed")
	{
		mat = cv::Mat(height, width, CV_8UC3, data);
	}

	else if (sPixelFormat == "RGB8Packed")
	{
		mat = cv::Mat(height, width, CV_8UC3, data);
		cv::cvtColor(mat, mat, COLOR_BGR2RGB);

	}
	else if (sPixelFormat == "BGRA8Packed")
	{
		mat = cv::Mat(height, width, CV_8UC4, data);
	}

	else if (sPixelFormat == "RGBA8Packed")
	{
		mat = cv::Mat(height, width, CV_8UC3, data);
		cv::cvtColor(mat, mat, COLOR_BGRA2RGBA);
	}
	//kglBuffer->free();
	if (kglBuffer != NULL)
	{
		kglBuffer->free();
		delete(kglBuffer);
		kglBuffer = NULL;
	}

	cv::Mat bmpMat;
	mat.copyTo(bmpMat);
	if (data)
	{
		free(data);
	}
	//imwrite("C:\\pic\\Img" + to_string(imgNum) + ".bmp", bmpMat);
	//imgNum++;
	return bmpMat;
}

void SaveBMP(cv::Mat bmp)
{
	std::string inputkey;
	std::string sFilePath;

	qDebug() << ("Do you want to save the image as a BMP file?\n\n");
	qDebug() << ("1 :Yes\n");
	qDebug() << ("2 : No\n");
	std::cin >> inputkey;
	qDebug() << ("------------------------------\n");
	switch (atoi(inputkey.c_str()))
	{
	case 1:
		qDebug() << ("Enter the full path of the BMP file.\n\n");
		std::cin >> sFilePath;
		qDebug() << ("------------------------------\n");
		break;
	case 2:
		return;
		break;
	default:
		qDebug() << ("The entry is invalid.\n");
		return;
		break;
	}
	try
	{
		/*System::String^ FilePath = gcnew System::String(sFilePath.c_str());
		FileStream^ stream = gcnew FileStream(FilePath, FileMode::Create, FileAccess::Write);
		TiffBitmapEncoder^ encoder = gcnew TiffBitmapEncoder();
		encoder->Compression = TiffCompressOption::None;
		encoder->Frames->Add(BitmapFrame::Create(bmp));
		encoder->Save(stream);*/
		//cv::imwrite(sFilePath, bmp);
	}
	catch (char)
	{
		qDebug() << ("Failed to save the BMP file.\n");
		qDebug() << ("------------------------------");
	}
}

void TriggerSoftware()
{
	Sleep(5000);
	kgllFeatureNodes->executeCommand("TriggerSoftware");
}


bool AcquisitionStartEx_SingleFrame(bool bMultiCaptureUpdateImage, std::string sMultiCaptureImageType, std::vector<cv::Mat>& matVec)
{
	std::string sPixelFormat;

	setBooleanValue("MultiCaptureUpdateImage", bMultiCaptureUpdateImage);
	setEnumValue("MultiCaptureImageType", sMultiCaptureImageType);

	//cv::Mat bmp;

	//bmp = QueueBuffer();
	cv::Mat bmp;

	if (!QueueBuffer())
		return false;

	AcquisitionStart();
	bmp = RetrieveBuffer();
	if (!bmp.empty())
	{
		matVec.push_back(bmp);
		return true;
	}
	else
	{
		return false;
	}
	//if (sPixelFormat == "RGBA8Packed")
	//{
	//	ConvertRGBA8toBGRA8(BitmapImage->BackBuffer.ToPointer(), (BitmapImage->PixelWidth * BitmapImage->PixelHeight));
	//}

	//SaveBMP(bmp);
	AcquisitionStop();
	bmp.release();
}

#pragma endregion


void MyThread::run()
{
	clock_t start, stop;
	start = clock();
	while (m_flag)
	{

		std::vector<cv::Mat> matVecs;
		std::string sImageType1 = "2";
		std::vector<std::string> sImageType = GetEnableImageType(sImageType1); //获取图像类别 6张
		//qDebug() << __FUNCTION__ << __LINE__ << "sImageType:" << QString::fromStdString(sImageType[0]) << ";" << QString::fromStdString(sImageType[1]);
		if (AcquisitionStartEx_SingleFrame(TRUE, sImageType[0], matVecs) == true)
		{
			for (int i = 1; i < sImageType.size(); ++i)
			{
				if (sImageType[i] != "" && sImageType[i] != sImageType[i - 1])
				{
					AcquisitionStartEx_SingleFrame(FALSE, sImageType[i], matVecs);
				}
			}
		}//为true的话就是重新获取一组图片中的一张sImageType类型的图片   false就是在同一组图片获取sImageType类型的图片
		//AcquisitionStartEx_SingleFrame(FALSE, sImageType[1], matVecs);//为true的话就是重新获取一组图片中的一张sImageType类型的图片   false就是在同一组图片获取sImageType类型的图片

		if (matVecs.size() > 0)
		{
			n_mutex->lock();
			stop = clock();
			qCritical() << " [info] " << __FUNCTION__ << " line:" << __LINE__ << " checkImg getImg time"<<stop-start << " 2.5D getImg, index"<<imgIndex++ ;
			queuePic.append(matVecs);
			n_mutex->unlock();
			break;
		}
		if (ifBreak)
			break;
		//qDebug() << "[2.5D run] ";
		QThread::msleep(5);
	}
}

Hd_25DCameraVJ_module* create()
{
	qDebug() << "[info]" << __FUNCTION__ << "line:" << __LINE__ << "Hd_MvCamera_module create success!";
	return new Hd_25DCameraVJ_module;
}

void destory(Hd_25DCameraVJ_module* ptr)
{
	if (ptr)
	{
		delete  ptr;
		ptr = nullptr;
	}
	qDebug() << "[info] " << __FUNCTION__ << " line:" << __LINE__ << "Hd_MvCamera_module  destory success!";
}

Hd_25DCameraVJ_module::Hd_25DCameraVJ_module()
{
	//m_thread = new MyThread;
	//m_mutex = new QMutex();
	workThread = new MyThread();
}

Hd_25DCameraVJ_module::~Hd_25DCameraVJ_module()
{
	if (workThread)
	{
		workThread->setFlag(false);
		workThread->wait();
		workThread->quit();
		workThread->deleteLater();
		workThread = nullptr;
	}

	Disconnect();

	if (n_mutex)
	{
		delete n_mutex;
		n_mutex = nullptr;
	}

	qDebug() << "[info]" << __FUNCTION__ << "line:" << __LINE__ << " delete success!";
}

bool Hd_25DCameraVJ_module::readData(std::vector<cv::Mat>& mat, QByteArray& data)
{
	Q_UNUSED(data);

	if (queuePic.empty())
	{
		qCritical() << " [ error] " << __FUNCTION__ << " line:" << __LINE__ << " srcImage is null";
		return false;
	}
	n_mutex->lock();
	vector<cv::Mat> dstMat = queuePic.dequeue();
	for (int i = 0; i < dstMat.size(); i++)
	{
		cv::Mat img = cv::Mat();
		dstMat[i].copyTo(img);
		mat.push_back(img.clone());
	}
	n_mutex->unlock();
	//mat.assign(dstMat.begin(), dstMat.end());
	qCritical() << " [info] " << __FUNCTION__ << " line:" << __LINE__ <<" checkImg readData,2.5D ,imgIndex"<< imgIndex;

	return true;
}

bool Hd_25DCameraVJ_module::writeData(std::vector<cv::Mat>& mat, QByteArray& data)
{
	Q_UNUSED(mat);
	//2024.02.18更新，相机对应的读SN信号时，表示新产品进入，设置初始值
	if (data == "rest_newProductIn")
	{
		//根据实际项目，设置初始值：曝光、增益，ROI区域等
		/*{
			if (expourseTimeList.size() > 0)
				SetExposureTime(expourseTimeList[0]);
			if (gainList.size() > 0)
				SetGain(gainList[0]);
		}
		getImageNum = 0;*/
		if (queuePic.size() > 0)
		{
			n_mutex->lock();
			queuePic.clear();
			n_mutex->unlock();
			std::cout << "rest_newProductIn , queuePic.size() > 0 ,signal maybe too fast " << xmlPath << std::endl;
			qWarning() << __FUNCTION__ << "  line: " << __LINE__ << "rest_newProductIn , queuePic.size() > 0 ,signal maybe too fast " << QString::fromStdString(xmlPath);
		}
		if (ifRunning == true)
		{
			ifBreak = true;
			Sleep(10);
		}
		imgIndex = 0;
		return true;
	}
	//else
	//{
	//	m_flag = false;
	//	expourseTimeList.clear();
	//	gainList.clear();
	//}

	//	xmlPath = data.toStdString();
	return true;
}

//传入initParas函数，格式为：相机key+参数名1#参数值1#参数值2+参数名2#参数值1...
bool Hd_25DCameraVJ_module::initParas(QByteArray& initData)
{
	QByteArrayList valueList = initData.split('+');
	xmlPath = valueList[0].toStdString();

	if (valueList.size() > 1)
		for (int i = 1; i < valueList.size(); i++)
		{
			QString valuei = byteArrayToUnicode(valueList[i]);
			if (valuei.contains("是否为标准通信流程"))
			{
				if (valuei.contains("true"))
					ifStandard = true;
			}
			if (valuei.contains("取图超时"))
			{
				QStringList gainL = valuei.split('#');
				if (gainL.size() > 1)
					getImageTimeOut = gainL[1].toInt();
				if (getImageTimeOut < 50)
					getImageTimeOut = 1000;
			}
		}

	KglSystem::initialize();
	bool connectSuccess = Connect(0);
	if (connectSuccess == false)
		return false;
	ab = new LocalKglDeviceEventSink();
	kglDevice->registerEventSink(ab);
	setBooleanValue("GevGVCPPendingAck", TRUE);
	//不同相机修改为对应路径
	ImportDeviceParameters("C:\\Users\\DS0904\\Desktop\\CA-HL04MX_8E2200761008_Features.xml");

	//C#使用SetFeatureValue
	setEnumValue("AcquisitionMode", "SingleFrame");

	setFeatureNodes("MaximumPendingResends", 0);
	setFeatureNodes("MaximumResendGroupSize", 0);//解决缺图问题26
	setFeatureNodes("ResetOnIdle", 0);
	setFeatureNodes("RequestTimeout", 0);
	setFeatureNodes("MaximumResendRequestRetryByPacket", 0);
	//setSystemFeatureValue("MaximumPendingResends", 0);
	//setSystemFeatureValue("MaximumResendGroupSize", 0);//解决缺图问题26
	//setSystemFeatureValue("ResetOnIdle", 0);
	//setSystemFeatureValue("RequestTimeout", 0);
	//setSystemFeatureValue("MaximumResendRequestRetryByPacket", 0);
	//setIntegerValue("GevSCPSPacketsize", 7716);//解决图像横纹问题,减小cpu使用率
	//setIntegerValue("GevSCPD", 344);//减小延迟

	bool bBGEnable;
	getBooleanValue("ImageCaptureBufferEnable", bBGEnable);
	if (bBGEnable)
	{
		executeCommand("ImageCaptureBufferClear");
		executeCommand("BufferCaptureAcquisitionStart");
	}
	std::string sImageType1 = "1";
	sImageType = GetEnableImageType(sImageType1); //获取图像类别 6张

	std::string sTriggerMode;
	getEnumValue("TriggerMode", sTriggerMode);
	std::string sTriggerSource = "";
	if (sTriggerMode == "On")
	{
		getEnumValue("TriggerSource", sTriggerSource);
		qDebug() << __FUNCTION__ << __LINE__ << "sTriggerSource:" << QString::fromStdString(sTriggerSource);
	}
	else
		qDebug() << __FUNCTION__ << __LINE__ << "hardTrigger";

	return true;
}

//注意，实际为软触发，应当每张图要有通信信号
bool Hd_25DCameraVJ_module::run()
{
	ifRunning = true;
	ifBreak = false;
	bool result = false;
	//qDebug() << "[info]" << __FUNCTION__ << " line:" <<  __LINE__ << " run start" <<QString::fromStdString(Username);
	try
	{
		workThread->setFlag(true);
		workThread->run(); //start()线程运行，频率高时有低概率无响应；
		int mytime = 0;
		while (true)
		{
			if (moduleStatus == false || mytime++ > getImageTimeOut || ifBreak == true)
			{
				result = false;
				break;
			}
			n_mutex->lock();
			if (queuePic.size() > 0)
				result = true;
			n_mutex->unlock();
			if (result == true)
				break;
			Sleep(1);
		}

		workThread->setFlag(false);

	}
	catch (QString ev)
	{
		qDebug() << "[info] FUNCTION:" << __FUNCTION__ << " line:" << __LINE__ << " ev:" << ev;
	}
	//qDebug() << "[info]"<< __FUNCTION__ << " line:" <<  __LINE__ << " run end" ;
	return result;
}

LocalKglDeviceEventSink::LocalKglDeviceEventSink()
{

}

LocalKglDeviceEventSink::~LocalKglDeviceEventSink()
{
}

void LocalKglDeviceEventSink::onLinkDisconnected(const KglDevice* pDevice)
{
	//it is required to write action when event received.
	int a = 3;
	a = a + 3;
	return;
}

void LocalKglDeviceEventSink::onEventGenICam(const KglDevice* pDevice, const uint16_t eventID, const uint16_t channel, const uint64_t blockID, const uint64_t timestamp, const uint32_t nodenum, const KglGenParameter** pNode)
{
	//string sEventMessage = "";
	//string sDevicePAddress = pDevice.getiPAdaress()
	//	sEventMessage += "eventID: Ox" + eventID.ToString("X2");

	switch (eventID)
	{
	case 0x9000:
		/*for (int i = 0; i < pNode.size(); i++)
		{
			KglGenParameter node = pNode->ElementAt(i);
		}
		Log.LogFileAndUI("IP:" + sDevicePAddress + " " + sEventMessagee + " 触发已输入", Color.Black);*/
		qDebug() << "(2.5Dmodel) " << "0x9000" << "(Trigger entered,触发已输入 )";//触发已输入
		break;
	case 0x9001:
		/*for (int i = 0; i < pNode.size(); i++)
		{
			KglGenParameter node = pNode->ElementAt(i);
		}
		Log.LogFileAndUI("IP:" + sDevicePAddress + " " + sEventMessage + " 未接收到触发信号", Color.Black);*/
		qDebug() << "(2.5Dmodel) " << "0x9001" << "(No trigger signal received,未接收到触发信号 )";//未接收到触发信号
		break;
	case 0x9002:
		/*for (int i = 0; i < pNode.size(); i++)
		{
			KglGenParameter node = pNode->ElementAt(i);
		}
		Log.LogFileAndUI("IP:" + sDevicePAddress + " " + sEventMessagee + " 允许触发开始", Color.Black);*/
		qDebug() << "(2.5Dmodel) " << "0x9002" << "(Allow the trigger to start,允许触发开始 )";//允许触发开始
		break;
	case 0x9003:
		/*for (int i = 0; i < pNode.size(); i++)
		{
			KglGenParameter node = pNode->ElementAt(i);
		}
		Log.LogFileAndUI("IP:" + sDevicePAddress + " " + sEventMessagee + " 允许触发结束", Color.Black);*/
		qDebug() << "(2.5Dmodel) " << "0x9003" << "(Allow the trigger to end,允许触发结束 )";//允许触发结束
		break;
	case 0x9004:
		/*for (int i = 0; i < pNode.size(); i++)
		{
			KglGenParameter node = pNode->ElementAt(i);
		}
		Log.LogFileAndUI("IP:" + sDevicePAddress + " " + sEventMessagee + " 相机曝光", Color.Black);*/
		qDebug() << "(2.5Dmodel) " << "0x9004" << "(Camera exposure,相机曝光 )";//相机曝光
		break;
	case 0x9005:
		/*for (int i = 0; i < pNode.size(); i++)
		{
			KglGenParameter node = pNode->ElementAt(i);
		}
		Log.LogFileAndUI("IP:" + sDevicePAddress + " " + sEventMessagee + " 相机未曝光", Color.Black);*/
		qDebug() << "(2.5Dmodel) " << "0x9005" << "(Camera not exposure,相机未曝光 )";//相机未曝光
		break;
	case 0x9006:
		/*for (int i = 0; i < pNode.size(); i++)
		{
			KglGenParameter node = pNode->ElementAt(i);
		}
		Log.LogFileAndUI("IP:" + sDevicePAddress + " " + sEventMessagee + " 开始图像传输", Color.Black);*/
		qDebug() << "(2.5Dmodel) " << "0x9006" << "(Start the image transfer,开始图像传输 )";//开始图像传输
		break;
	case 0x9007:
		/*for (int i = 0; i < pNode.size(); i++)
		{
			KglGenParameter node = pNode->ElementAt(i);
		}
		Log.LogFileAndUI("IP:" + sDevicePAddress + " " + sEventMessagee + " 结束图像传输", Color.Black);*/
		qDebug() << "(2.5Dmodel) " << "0x9007" << "(End the image transfer,结束图像传输 )";//结束图像传输
		break;
	case 0x9008:
		/*for (int i = 0; i < pNode.size(); i++)
		{
			KglGenParameter node = pNode->ElementAt(i);
		}
		Log.LogFileAndUI("IP:" + sDevicePAddress + " " + sEventMessagee + " 图像输出完成", Color.Black);*/
		qDebug() << "(2.5Dmodel) " << "0x9008" << "(Image output complete,图像输出完成 )";//图像输出完成
		break;
	case 0x900A:
		/*for (int i = 0; i < pNode.size(); i++)
		{
			KglGenParameter node = pNode->ElementAt(i);
		}
		Log.LogFileAndUI("IP:" + sDevicePAddress + " " + sEventMessagee + " 后台缓存已满", Color.Black);*/
		qDebug() << "(2.5Dmodel) " << "0x900A" << "(The background cache is full,后台缓存已满 )";//后台缓存已满
		break;
	case 0x900B:
		/*for (int i = 0; i < pNode.size(); i++)
		{
			KglGenParameter node = pNode->ElementAt(i);
		}
		Log.LogFileAndUI("IP:" + sDevicePAddress + " " + sEventMessagee + " 后台缓存溢出", Color.Black);*/
		qDebug() << "(2.5Dmodel) " << "0x900B" << "(Background cache overflow,后台缓存溢出 )";//后台缓存溢出
		break;
	case 0x900C:
		/*for (int i = 0; i < pNode.size(); i++)
		{
			KglGenParameter node = pNode->ElementAt(i);
		}
		Log.LogFileAndUI("IP:" + sDevicePAddress + " " + sEventMessagee + " 历史图像缓存=1后台缓存=0", Color.Black);*/
		qDebug() << "(2.5Dmodel) " << "0x900C" << "(Historical image cache = 1 background cache = 0)";//历史图像缓存=1后台缓存=0
		break;
	case 0x900D:
		/*for (int i = 0; i < pNode.size(); i++)
		{
			KglGenParameter node = pNode->ElementAt(i);
		}
		Log.LogFileAndUI("IP:" + sDevicePAddress + " " + sEventMessagee + " 线扫相机触发通过", Color.Black);*/
		qDebug() << "(2.5Dmodel) " << "0x900D" << "(The line scan camera triggers pass,线扫相机触发通过 )";//线扫相机触发通过
		break;
	default:
		/*Log.LogFileAndUl("IP:" + sDevicePAddress + "" + sEventMessage, Color.Black);
			gonDeviceEventGenICam(sDevicePAddress, sEventMessage);*/
		qDebug() << "(2.5Dmodel) " << "(Other events,其他事件 )";//其他事件
		break;
	}
}