eUi/src/core/service/cameraManager.h

#include <QString>
#include <unordered_map>
#include <qlibrary.h>
#include <opencv.hpp>
#include <qqueue.h>
#include <qthread.h>
#include <qdebug.h>
#include <global.h>
#include <qdatetime.h>
#include <serviceModule.h>
#include <future>
#include <interface.h>
#include <detData.h>
typedef dsModuleBase* (*CreateFunction)();
typedef void (*ReleaseFunction)(dsModuleBase* animal);

struct cameraStruct {
	int index;
	std::string key;
	std::string connectionName;//per Sec
	std::string serialNum;
	std::string dllPath;
	std::vector <std::string> oriSaveFormat;
	std::vector<std::pair<QString, QString>>imageShowList;

	QByteArray  m_initByte;           // 传递初始化参数
	dsModuleBase* module_ptr = nullptr;       // 存储模块指针
	ReleaseFunction destory_ptr;      // 释放
	bool init = false;
};

//硬触发要求在触发相机前给出触发信号
class backEndManager;
class camera : public QThread{
	Q_OBJECT
public:
	QTime lastUpdateTime;
	QString cameraName;
	int imgShowCnt = 0;
	cameraStruct config;
	camera(cameraStruct configIn, int indexIn, bSignalHub* bridgeIn);
	~camera(){
		runFlag = false;
		this->terminate();
		while (this->isRunning() == true);
	}
	void run();
	void stop(){
		runFlag = false;
		while (this->isRunning() == true);
	}
	void captureImage(std::shared_ptr <detData> dataIn){
		QMutexLocker locker(&mutex);
		requestQueue.enqueue(dataIn);
		//std::thread([this]() {trigger();}).detach(); 
	}

	//相机操作
	bool trigger(){
		if (!config.module_ptr->run()){
			qCritical() << "[Error] " << " m_name:" << cameraName << " run  failed!";
			return false;
		}
		return true;
	}
	double getCameraValue(){//点激光相机专用
		double value = 0;
		std::vector<cv::Mat>  camera_mat;
		QByteArray task_name;

		int cnt = 0;
		while (!config.module_ptr->readData(camera_mat, task_name)){
			QThread::msleep(10);
			cnt++;
			if (cnt > 500)
				return 0;
		}
		value = task_name.toDouble();
		return value;
	}
	void getCameraImg(std::vector<cv::Mat>& mats,int imgAmountMin){
		QByteArray task_name;
		if (!config.module_ptr->readData(mats, task_name)) {
			if (mats.size() == 0) {
				qDebug() << "camera_mat size 0,insert blank image";
				mats = std::vector<cv::Mat>(imgAmountMin, cv::Mat::zeros(100, 100, CV_8UC3));
			}
		}
		qDebug() << __FUNCTION__ << " line:" << __LINE__ << "camera_mat size:" << mats.size();
	}
	inline void setDigitalShift(float value){
		writeData("DigitalShift_" + std::to_string(value));
	}
	inline void setExposureTime(float value){
		writeData("exposure_" + std::to_string(value));
	}
	inline void clearCache() {
		writeData("clearCache");
	}
private:
	bSignalHub* bridge;
	QByteArray readData(const std::string& str){
		QByteArray byteArray(QByteArray::fromStdString(str));
		std::vector<cv::Mat>  camera_mat;
		if (!config.module_ptr->readData(camera_mat, byteArray))
			qCritical() << "[Error] " << "module readdata error!cameraname"<<cameraName;
		return byteArray;
	}
	QByteArray writeData(const std::string& str) {
		QByteArray byteArray(QByteArray::fromStdString(str));
		std::vector<cv::Mat>  camera_mat;
		if (!config.module_ptr->writeData(camera_mat, byteArray))
			qCritical() << "[Error] " << "module readdata error!cameraname" << cameraName;
		return byteArray;
	}
	int index = 0;
	int timeout = 5000;
	QMutex mutex;
	QQueue<cv::Mat>imgQueue;
	QQueue<std::shared_ptr <detData>>requestQueue;
	bool runFlag = true;
};
class cameraManager : public serviceModule{
	Q_OBJECT
public:
	cameraManager(nlohmann::ordered_json& json, bSignalHub* bridgeIn) {
		bridge = bridgeIn;
		auto cameraJson = json["CameraSetting"];
		for (auto data : cameraJson){
			cameraStruct _cameraStruct;
			_cameraStruct.key = data["key"];
			_cameraStruct.connectionName = data["connectionName"];
			_cameraStruct.dllPath = data["dllPath"];
			_cameraStruct.oriSaveFormat = data["oriSaveFormat"];
			for (auto& imageShow : data["imageShow"]){
				QString str = QString::fromStdString(imageShow);
				QStringList l = str.split("#");
				if (l.size() < 2){
					qDebug() << "Imagehsow 格式错误，例：窗口名#类型名";
					std::cout << "Imagehsow 格式错误，例：窗口名#类型名" <<std::endl;
					continue;
				}
				_cameraStruct.imageShowList.push_back(std::make_pair(l[0], l[1]));
			}
			_cameraStructs.push_back(_cameraStruct);
		}
	}
	~cameraManager();
	void run();
	std::unordered_map<std::string, camera*>cameras;//key 相机名
	camera* getCamera(std::string cameraName){
		auto camera = cameras.find(cameraName);
		if (camera != cameras.end())
			return camera->second;
		return nullptr;
	}
	void stop(){
		for (auto camera : cameras)
			camera.second->stop();
	}
private:
	bool initFlag = false;
	std::vector<cameraStruct> _cameraStructs;//相机配置结构体
	bSignalHub* bridge;

	bool loadModule(cameraStruct& _cameraStruct);
	std::vector<cv::Mat> vec_mat;//没啥用，一直保持为空就好
	QList<QLibrary*> lib_list;
	std::map<QString,bool> m_usedDllPath;
public slots:
	void cameraTrigger(std::string Name){
		auto camera=cameras.find(Name);
		if (camera != cameras.end()){
			camera->second->trigger();
		}
	}
	cv::Mat triggerAndGetImage(std::string cameraName) {
		auto camera = cameras.find(cameraName);
		std::shared_ptr <detData> data(new detData());//创建数据包
		data->imgAmountMin = 1;
		camera->second->captureImage(data);
		while (data->getOriImgSize() == 0) {
			QThread::msleep(10);
		}
		return data->getOriImgVec()[0];
	}
};

#pragma once