1.最近开发海康工业相机，做取图demo
2.在MVS运行目录下找到Development文件夹，找到下图两个文件夹一个是头文件一个是库文件
3.引用到qt项目中
4.下面是头文件跟源文件
头文件
#ifndef MVSCAMERA_H
#define MVSCAMERA_H
#include <QObject>
#include "MvCameraControl.h"
#ifndef MV_NULL
#define MV_NULL 0
#endif
/***海康威视相机基类***/
class MVSCamera : public QObject
{
Q_OBJECT
public:
explicit MVSCamera(QObject* parent = nullptr);
/***初始化***/
void Init();
/***打开相机抓拍***/
bool OpenCameraGrapping();
/***关闭相机抓拍***/
bool CloseCameraGrapping();
/***设置相机取图模式0实时视频1硬触发2软触发***/
bool SetCameraTakeImageModel(int model_);
/***软触发取图一次***/
bool SoftTriggerCameraTakeImage();
/***设置相机曝光***/
bool SetCameraExpource(double expource_);
/***设置相机增益***/
bool SetCameraGain(double gain_);
/***释放资源***/
void RelseadResource();
/***发送给下位机一个信号***/
bool GiveDownMachineSingle();
/***相机驱动本身函数,定义为私有函数***/
private:
/***获取sdk版本号***/
int GetSDKVersion();
/*** ch:枚举设备 | en:Enumerate Device***/
int EnumDevices(unsigned int nTLayerType, MV_CC_DEVICE_INFO_LIST* pstDevList);
/*** ch:判断设备是否可达 | en:Is the device accessible***/
bool IsDeviceAccessible(MV_CC_DEVICE_INFO* pstDevInfo, unsigned int nAccessMode);
/****ch:打开设备 | en:Open Device****/
int Open(MV_CC_DEVICE_INFO* pstDeviceInfo);
/**** ch:关闭设备 | en:Close Device****/
int Close();
/***ch:判断相机是否处于连接状态 | en:Is The Device Connected***/
bool IsDeviceConnected();
/****ch:注册图像数据回调 | en:Register Image Data CallBack****/
int RegisterImageCallBack(void(__stdcall* cbOutput)(unsigned char* pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser), void* pUser);
/***ch:开启抓图 | en:Start Grabbing***/
int StartGrabbing();
/**** ch:停止抓图 | en:Stop Grabbing***/
int StopGrabbing();
/****ch:主动获取一帧图像数据 | en:Get one frame initiatively****/
int GetImageBuffer(MV_FRAME_OUT* pFrame, int nMsec);
/*** ch:释放图像缓存 | en:Free image buffer***/
int FreeImageBuffer(MV_FRAME_OUT* pFrame);
/***ch:显示一帧图像 | en:Display one frame image***/
int DisplayOneFrame(MV_DISPLAY_FRAME_INFO* pDisplayInfo);
/***ch:设置SDK内部图像缓存节点个数 | en:Set the number of the internal image cache nodes in SDK***/
int SetImageNodeNum(unsigned int nNum);
// ch:获取设备信息 | en:Get device information
int GetDeviceInfo(MV_CC_DEVICE_INFO* pstDevInfo);
/***ch:获取GEV相机的统计信息 | en:Get detect info of GEV camera***/
int GetGevAllMatchInfo(MV_MATCH_INFO_NET_DETECT* pMatchInfoNetDetect);
/*** ch:获取U3V相机的统计信息 | en:Get detect info of U3V camera***/
int GetU3VAllMatchInfo(MV_MATCH_INFO_USB_DETECT* pMatchInfoUSBDetect);
/*** ch:获取和设置Int型参数，如 Width和Height***/
int GetIntValue(IN const char* strKey, OUT MVCC_INTVALUE_EX* pIntValue);
/*** ch:获取和设置Int型参数，如 Width和Height***/
int SetIntValue(IN const char* strKey, IN int64_t nValue);
/***ch:获取和设置Enum型参数，如 PixelFormat***/
int GetEnumValue(IN const char* strKey, OUT MVCC_ENUMVALUE* pEnumValue);
/***ch:获取和设置Enum型参数，如 PixelFormat***/
int SetEnumValue(IN const char* strKey, IN unsigned int nValue);
/***ch:获取和设置Enum型参数，如 PixelFormat***/
int SetEnumValueByString(IN const char* strKey, IN const char* sValue);
/*** ch:获取和设置Float型参数，如 ExposureTime和Gain***/
int GetFloatValue(IN const char* strKey, OUT MVCC_FLOATVALUE* pFloatValue);
/*** ch:获取和设置Float型参数，如 ExposureTime和Gain***/
int SetFloatValue(IN const char* strKey, IN float fValue);
/*** ch:获取和设置Bool型参数，如 ReverseX***/
int GetBoolValue(IN const char* strKey, OUT bool* pbValue);
/*** ch:获取和设置Bool型参数，如 ReverseX***/
int SetBoolValue(IN const char* strKey, IN bool bValue);
/***ch:获取和设置String型参数，如 DeviceUserID***/
int GetStringValue(IN const char* strKey, MVCC_STRINGVALUE* pStringValue);
/***ch:获取和设置String型参数，如 DeviceUserID***/
int SetStringValue(IN const char* strKey, IN const char* strValue);
/*** ch:执行一次Command型命令，如 UserSetSave***/
// en:Execute Command once, such as UserSetSave
int CommandExecute(IN const char* strKey);
/*** ch:探测网络最佳包大小(只对GigE相机有效) | en:Detection network optimal package size(It only works for the GigE camera)***/
int GetOptimalPacketSize(unsigned int* pOptimalPacketSize);
/*** ch:注册消息异常回调 | en:Register Message Exception CallBack****/
int RegisterExceptionCallBack(void(__stdcall* cbException)(unsigned int nMsgType, void* pUser), void* pUser);
/*** ch:注册单个事件回调 | en:Register Event CallBack***/
int RegisterEventCallBack(const char* pEventName, void(__stdcall* cbEvent)(MV_EVENT_OUT_INFO* pEventInfo, void* pUser), void* pUser);
/***ch:强制IP | en:Force IP***/
int ForceIp(unsigned int nIP, unsigned int nSubNetMask, unsigned int nDefaultGateWay);
/***ch:配置IP方式 | en:IP configuration method***/
int SetIpConfig(unsigned int nType);
/***ch:设置网络传输模式 | en:Set Net Transfer Mode***/
int SetNetTransMode(unsigned int nType);
/***ch:像素格式转换 | en:Pixel format conversion***/
int ConvertPixelType(MV_CC_PIXEL_CONVERT_PARAM* pstCvtParam);
/*** ch:保存图片 | en:save image***/
int SaveImage(MV_SAVE_IMAGE_PARAM_EX* pstParam);
/*** ch:保存图片为文件 | en:Save the image as a file***/
int SaveImageToFile(MV_SAVE_IMG_TO_FILE_PARAM* pstParam);
signals:
public:
/***相机名称***/
QString _camera_name = "";
/***相机曝光***/
double _camera_expource = 1000;
/***相机增益***/
double _camera_gain = 1;
/***相机句柄***/
void* _camera_handle;
/***设备信息列表结构体变量，用来存储设备列表 ***/
MV_CC_DEVICE_INFO_LIST _camera_list;
/***相机列表的引索***/
int _camera_list_index=-1;
/***相机取图模式0实时视频1硬触发2软触发***/
int _camera_take_image_model=1;
/***相机状态0关闭1取图***/
int _camera_status=0;
};
/***第一个相机***/
class MVSCameraOne: public MVSCamera
{
public:
/***取图回调函数***/
void static __stdcall ImageCallBackEx(unsigned char* pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser);
/***注册相机回调函数***/
void RegisterImageCallBack();
public:
/***静态相机变量***/
static MVSCameraOne _mvscamera_static;
};
/***第二个相机***/
class MVSCameraTwo:public MVSCamera
{
public:
/***取图回调函数***/
void static __stdcall ImageCallBackEx(unsigned char* pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser);
/***注册相机回调函数***/
void RegisterImageCallBack();
public:
/***静态相机变量***/
static MVSCameraTwo _mvscamera_static;
};
/***第三个相机***/
class MVSCameraThird:public MVSCamera
{
public:
/***取图回调函数***/
void static __stdcall ImageCallBackEx(unsigned char* pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser);
/***注册相机回调函数***/
void RegisterImageCallBack();
public:
/***静态相机变量***/
static MVSCameraThird _mvscamera_static;
};
/***四个相机***/
class MVSCameraFour:public MVSCamera
{
public:
/***取图回调函数***/
void static __stdcall ImageCallBackEx(unsigned char* pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser);
/***注册相机回调函数***/
void RegisterImageCallBack();
public:
/***静态相机变量***/
static MVSCameraFour _mvscamera_static;
};
/***相机管理***/
class MVSCameraCtr
{
public:
/****读取相机配置***/
void ReadCameraConfig();
/***写相机配置***/
bool WriteCameraConfig();
/***初始化***/
void Init();
public:
static MVSCameraCtr _mvscameractr_static;
};
#endif // MVSCAMERA_H
源文件
#include "mvscamera.h"
#include "QXlsxDll/header/xlsxdocument.h"
#include "qcoreapplication.h"
#include "qfile.h"
#include "DeeplearnInspection/deeplearninspection.h"
MVSCamera::MVSCamera(QObject* parent)
: QObject{ parent }
{}
void MVSCamera::Init()
{
_camera_list_index = -1;
/****查找多小个相机****/
memset(&_camera_list, 0, sizeof(MV_CC_DEVICE_INFO_LIST));
// ch:3. 枚举子网内所有设备 || en: 3. enumerate all of devices in the subnetwork
int nRet = EnumDevices(MV_GIGE_DEVICE | MV_USB_DEVICE, &_camera_list);
if (MV_OK != nRet)
{
return;
}
for (int i = 0; i < _camera_list.nDeviceNum; i++)
{
//QString name_ = QString::fromUtf8(reinterpret_cast<char*>(_camera_list.pDeviceInfo[i]->SpecialInfo.stGigEInfo.chUserDefinedName));
QString name_ = QString::fromUtf8(reinterpret_cast<char*>(_camera_list.pDeviceInfo[i]->SpecialInfo.stGigEInfo.chSerialNumber));
/***判断相机名称是否程序查找的***/
//if (name_ == "DA5350954")
if (name_ == _camera_name)
{
/***打开相机***/
nRet = this->Open(_camera_list.pDeviceInfo[i]);
if (MV_OK == nRet)
{
/***设置网络包大小***/
if (_camera_list.pDeviceInfo[i]->nTLayerType == MV_GIGE_DEVICE)
{
unsigned int nPacketSize = 0;
nRet = GetOptimalPacketSize(&nPacketSize);
if (nRet == MV_OK)
{
SetIntValue("GevSCPSPacketSize", nPacketSize);
}
}
_camera_take_image_model = 2;
/***设置相机触发取图***/
nRet = SetEnumValue("TriggerMode", MV_TRIGGER_MODE_ON);
if (nRet != MV_OK)
{
qDebug() << "设置触发模式失败";
}
/***设置相机软触发***/
nRet = SetEnumValue("TriggerSource", MV_TRIGGER_SOURCE_SOFTWARE);
if (nRet != MV_OK)
{
qDebug() << "设置出发失败";
}
/***设置相机曝光***/
nRet = SetFloatValue("ExposureTime", _camera_expource);
if (nRet != MV_OK)
{
qDebug() << "设置曝光失败";
}
/***设置相机***/
nRet = SetFloatValue("Gain", _camera_gain);
if (nRet != MV_OK)
{
qDebug() << "设置增益失败";
}
nRet=SetEnumValue("LineSelector",1);
if (nRet != MV_OK)
{
qDebug() << "设置io输出为line1";
}
// /***注册相机回调函数***/
// /*nRet = RegisterImageCallBack(ImageCallBackEx, _camera_handle);*/
// nRet = MV_CC_RegisterImageCallBackEx(_camera_handle, ImageCallBackEx, _camera_handle);
/***获取相机引索***/
_camera_list_index = i;
}
}
}
}
bool MVSCamera::OpenCameraGrapping()
{
bool ok_ = false;
int nRet = this->StartGrabbing();
if (nRet == MV_OK)
{
ok_ = true;
_camera_status = 1;
}
return ok_;
}
bool MVSCamera::CloseCameraGrapping()
{
bool ok_ = false;
int nRet = this->StopGrabbing();
if (nRet == MV_OK)
{
ok_ = true;
_camera_status = 0;
}
return ok_;
}
bool MVSCamera::SetCameraTakeImageModel(int model_)
{
bool ok_ = false;
int nRet = -1;
switch (model_)
{
/***设置实时视频***/
case 0:
_camera_take_image_model = 0;
/***设置相机触发取图***/
nRet = SetEnumValue("TriggerMode", MV_TRIGGER_MODE_OFF);
if (nRet != MV_OK)
{
qDebug() << "it fail to set camera mode";
}
/***设置相机软触发***/
nRet = SetEnumValue("TriggerSource", MV_TRIGGER_SOURCE_COUNTER0);
if (nRet != MV_OK)
{
qDebug() << "it fail to set camera counter0";
}
break;
/***1硬触发模式***/
case 1:
_camera_take_image_model = 1;
/***设置相机触发取图***/
nRet = SetEnumValue("TriggerMode", MV_TRIGGER_MODE_ON);
if (nRet != MV_OK)
{
qDebug() << "it fail to set camera mode";
}
/***设置相机硬触发***/
nRet = SetEnumValue("TriggerSource", MV_TRIGGER_SOURCE_LINE0);
if (nRet != MV_OK)
{
qDebug() << "it fail to set camera trigger source of line0";
}
break;
/***软触发模式***/
case 2:
_camera_take_image_model = 2;
/***设置相机触发取图***/
nRet = SetEnumValue("TriggerMode", MV_TRIGGER_MODE_ON);
if (nRet != MV_OK)
{
qDebug() << "it fail to set camera mode";
}
/***设置相机软触发***/
nRet = SetEnumValue("TriggerSource", MV_TRIGGER_SOURCE_SOFTWARE);
if (nRet != MV_OK)
{
qDebug() << "it fail to set camera software trigger";
}
break;
}
if (nRet == MV_OK)
{
ok_ = true;
}
return ok_;
}
bool MVSCamera::SoftTriggerCameraTakeImage()
{
bool ok_ = false;
int nRet = CommandExecute("TriggerSoftware");
if (MV_OK == nRet)
{
ok_ = true;
}
return ok_;
}
bool MVSCamera::SetCameraExpource(double expource_)
{
bool ok_ = false;
/***设置相机曝光***/
int nRet = SetFloatValue("ExposureTime", expource_);
if (nRet == MV_OK)
{
_camera_expource = expource_;
ok_ = true;
}
return ok_;
}
bool MVSCamera::SetCameraGain(double gain_)
{
bool ok_ = false;
/***设置相机***/
int nRet = SetFloatValue("Gain", gain_);
if (nRet == MV_OK)
{
_camera_gain = gain_;
ok_ = true;
}
return ok_;
}
void MVSCamera::RelseadResource()
{
if (_camera_list_index > -1)
{
this->Close();
}
}
bool MVSCamera::GiveDownMachineSingle()
{
bool ok_ = false;
int nRet = CommandExecute("LineTriggerSoftware");
if (MV_OK == nRet)
{
ok_ = true;
}
return ok_;
}
/*************相机本身函数，定义为私有函数******************/
int MVSCamera::GetSDKVersion()
{
return MV_CC_GetSDKVersion();
}
int MVSCamera::EnumDevices(unsigned int nTLayerType, MV_CC_DEVICE_INFO_LIST* pstDevList)
{
return MV_CC_EnumDevices(nTLayerType, pstDevList);
}
bool MVSCamera::IsDeviceAccessible(MV_CC_DEVICE_INFO* pstDevInfo, unsigned int nAccessMode)
{
return MV_CC_IsDeviceAccessible(pstDevInfo, nAccessMode);
}
int MVSCamera::Open(MV_CC_DEVICE_INFO* pstDeviceInfo)
{
if (MV_NULL == pstDeviceInfo)
{
return MV_E_PARAMETER;
}
if (_camera_handle)
{
return MV_E_CALLORDER;
}
int nRet = MV_CC_CreateHandle(&_camera_handle, pstDeviceInfo);
if (MV_OK != nRet)
{
return nRet;
}
nRet = MV_CC_OpenDevice(_camera_handle);
if (MV_OK != nRet)
{
MV_CC_DestroyHandle(_camera_handle);
_camera_handle = MV_NULL;
}
return nRet;
}
int MVSCamera::Close()
{
if (MV_NULL == _camera_handle)
{
return MV_E_HANDLE;
}
MV_CC_CloseDevice(_camera_handle);
int nRet = MV_CC_DestroyHandle(_camera_handle);
_camera_handle = MV_NULL;
return nRet;
}
bool MVSCamera::IsDeviceConnected()
{
return MV_CC_IsDeviceConnected(_camera_handle);
}
int MVSCamera::RegisterImageCallBack(void(__stdcall* cbOutput)(unsigned char* pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser), void* pUser)
{
return MV_CC_RegisterImageCallBackEx(_camera_handle, cbOutput, pUser);
}
int MVSCamera::StartGrabbing()
{
return MV_CC_StartGrabbing(_camera_handle);
}
int MVSCamera::StopGrabbing()
{
return MV_CC_StopGrabbing(_camera_handle);
}
int MVSCamera::GetImageBuffer(MV_FRAME_OUT* pFrame, int nMsec)
{
return MV_CC_GetImageBuffer(_camera_handle, pFrame, nMsec);
}
int MVSCamera::FreeImageBuffer(MV_FRAME_OUT* pFrame)
{
return MV_CC_FreeImageBuffer(_camera_handle, pFrame);
}
int MVSCamera::DisplayOneFrame(MV_DISPLAY_FRAME_INFO* pDisplayInfo)
{
return MV_CC_DisplayOneFrame(_camera_handle, pDisplayInfo);
}
int MVSCamera::SetImageNodeNum(unsigned int nNum)
{
return MV_CC_SetImageNodeNum(_camera_handle, nNum);
}
int MVSCamera::GetDeviceInfo(MV_CC_DEVICE_INFO* pstDevInfo)
{
return MV_CC_GetDeviceInfo(_camera_handle, pstDevInfo);
}
int MVSCamera::GetGevAllMatchInfo(MV_MATCH_INFO_NET_DETECT* pMatchInfoNetDetect)
{
if (MV_NULL == pMatchInfoNetDetect)
{
return MV_E_PARAMETER;
}
MV_CC_DEVICE_INFO stDevInfo = { 0 };
GetDeviceInfo(&stDevInfo);
if (stDevInfo.nTLayerType != MV_GIGE_DEVICE)
{
return MV_E_SUPPORT;
}
MV_ALL_MATCH_INFO struMatchInfo = { 0 };
struMatchInfo.nType = MV_MATCH_TYPE_NET_DETECT;
struMatchInfo.pInfo = pMatchInfoNetDetect;
struMatchInfo.nInfoSize = sizeof(MV_MATCH_INFO_NET_DETECT);
memset(struMatchInfo.pInfo, 0, sizeof(MV_MATCH_INFO_NET_DETECT));
return MV_CC_GetAllMatchInfo(_camera_handle, &struMatchInfo);
}
int MVSCamera::GetU3VAllMatchInfo(MV_MATCH_INFO_USB_DETECT* pMatchInfoUSBDetect)
{
if (MV_NULL == pMatchInfoUSBDetect)
{
return MV_E_PARAMETER;
}
MV_CC_DEVICE_INFO stDevInfo = { 0 };
GetDeviceInfo(&stDevInfo);
if (stDevInfo.nTLayerType != MV_USB_DEVICE)
{
return MV_E_SUPPORT;
}
MV_ALL_MATCH_INFO struMatchInfo = { 0 };
struMatchInfo.nType = MV_MATCH_TYPE_USB_DETECT;
struMatchInfo.pInfo = pMatchInfoUSBDetect;
struMatchInfo.nInfoSize = sizeof(MV_MATCH_INFO_USB_DETECT);
memset(struMatchInfo.pInfo, 0, sizeof(MV_MATCH_INFO_USB_DETECT));
return MV_CC_GetAllMatchInfo(_camera_handle, &struMatchInfo);
}
int MVSCamera::GetIntValue(IN const char* strKey, OUT MVCC_INTVALUE_EX* pIntValue)
{
return MV_CC_GetIntValueEx(_camera_handle, strKey, pIntValue);
}
int MVSCamera::SetIntValue(IN const char* strKey, IN int64_t nValue)
{
return MV_CC_SetIntValueEx(_camera_handle, strKey, nValue);
}
int MVSCamera::GetEnumValue(IN const char* strKey, OUT MVCC_ENUMVALUE* pEnumValue)
{
return MV_CC_GetEnumValue(_camera_handle, strKey, pEnumValue);
}
int MVSCamera::SetEnumValue(IN const char* strKey, IN unsigned int nValue)
{
return MV_CC_SetEnumValue(_camera_handle, strKey, nValue);
}
int MVSCamera::SetEnumValueByString(IN const char* strKey, IN const char* sValue)
{
return MV_CC_SetEnumValueByString(_camera_handle, strKey, sValue);
}
int MVSCamera::GetFloatValue(IN const char* strKey, OUT MVCC_FLOATVALUE* pFloatValue)
{
return MV_CC_GetFloatValue(_camera_handle, strKey, pFloatValue);
}
int MVSCamera::SetFloatValue(IN const char* strKey, IN float fValue)
{
return MV_CC_SetFloatValue(_camera_handle, strKey, fValue);
}
int MVSCamera::GetBoolValue(IN const char* strKey, OUT bool* pbValue)
{
return MV_CC_GetBoolValue(_camera_handle, strKey, pbValue);
}
int MVSCamera::SetBoolValue(IN const char* strKey, IN bool bValue)
{
return MV_CC_SetBoolValue(_camera_handle, strKey, bValue);
}
int MVSCamera::GetStringValue(IN const char* strKey, MVCC_STRINGVALUE* pStringValue)
{
return MV_CC_GetStringValue(_camera_handle, strKey, pStringValue);
}
int MVSCamera::SetStringValue(IN const char* strKey, IN const char* strValue)
{
return MV_CC_SetStringValue(_camera_handle, strKey, strValue);
}
int MVSCamera::CommandExecute(IN const char* strKey)
{
return MV_CC_SetCommandValue(_camera_handle, strKey);
}
int MVSCamera::GetOptimalPacketSize(unsigned int* pOptimalPacketSize)
{
if (MV_NULL == pOptimalPacketSize)
{
return MV_E_PARAMETER;
}
int nRet = MV_CC_GetOptimalPacketSize(_camera_handle);
if (nRet < MV_OK)
{
return nRet;
}
*pOptimalPacketSize = (unsigned int)nRet;
return MV_OK;
}
int MVSCamera::RegisterExceptionCallBack(void(__stdcall* cbException)(unsigned int nMsgType, void* pUser), void* pUser)
{
return MV_CC_RegisterExceptionCallBack(_camera_handle, cbException, pUser);
}
int MVSCamera::RegisterEventCallBack(const char* pEventName, void(__stdcall* cbEvent)(MV_EVENT_OUT_INFO* pEventInfo, void* pUser), void* pUser)
{
return MV_CC_RegisterEventCallBackEx(_camera_handle, pEventName, cbEvent, pUser);
}
int MVSCamera::ForceIp(unsigned int nIP, unsigned int nSubNetMask, unsigned int nDefaultGateWay)
{
return MV_GIGE_ForceIpEx(_camera_handle, nIP, nSubNetMask, nDefaultGateWay);
}
int MVSCamera::SetIpConfig(unsigned int nType)
{
return MV_GIGE_SetIpConfig(_camera_handle, nType);
}
int MVSCamera::SetNetTransMode(unsigned int nType)
{
return MV_GIGE_SetNetTransMode(_camera_handle, nType);
}
int MVSCamera::ConvertPixelType(MV_CC_PIXEL_CONVERT_PARAM* pstCvtParam)
{
return MV_CC_ConvertPixelType(_camera_handle, pstCvtParam);
}
int MVSCamera::SaveImage(MV_SAVE_IMAGE_PARAM_EX* pstParam)
{
return MV_CC_SaveImageEx2(_camera_handle, pstParam);
}
int MVSCamera::SaveImageToFile(MV_SAVE_IMG_TO_FILE_PARAM* pstSaveFileParam)
{
return MV_CC_SaveImageToFile(_camera_handle, pstSaveFileParam);
}
/***********第一个相机******************/
MVSCameraOne MVSCameraOne::_mvscamera_static;
/***取图回调函数***/
void __stdcall MVSCameraOne::ImageCallBackEx(unsigned char* pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser)
{
int width_ = pFrameInfo->nWidth;
int height_ = pFrameInfo->nHeight;
//MvGvspPixelType pt_ = pFrameInfo->enPixelType;
TongueCoatingInspection::_tongue_coating_inspection._image.Clear();
TongueCoatingInspection::_tongue_coating_inspection._image_exist = false;
switch (pFrameInfo->enPixelType)
{
case MvGvspPixelType::PixelType_Gvsp_RGB8_Packed:
{
HalconCpp::HTuple hptr_ = (Hlong)pData;
HalconCpp::GenImageInterleaved(&TongueCoatingInspection::_tongue_coating_inspection._image,
hptr_,
HalconCpp::HTuple("rgb"),
width_,
height_,
-1,
HalconCpp::HTuple("byte"),
0,
0,
0,
0,
-1,
0);
hptr_.Clear();
TongueCoatingInspection::_tongue_coating_inspection._image_exist = true;
TongueCoatingInspection::_tongue_coating_inspection.TriggerCameraImageWriteFinally();
}
break;
case MvGvspPixelType::PixelType_Gvsp_BayerRG8:
{
HalconCpp::HTuple hptr_ = (Hlong)pData;
HalconCpp::HObject image_;
HalconCpp::GenEmptyObj(&image_);
HalconCpp::GenImage1Extern(&image_,"byte",width_,height_,hptr_,0);
HalconCpp::CfaToRgb(image_,
&TongueCoatingInspection::_tongue_coating_inspection._image,
"byte_rg",
"bilinear");
image_.Clear();
hptr_.Clear();
TongueCoatingInspection::_tongue_coating_inspection._image_exist = true;
TongueCoatingInspection::_tongue_coating_inspection.TriggerCameraImageWriteFinally();
}
break;
default:
break;
}
}
void MVSCameraOne::RegisterImageCallBack()
{
int nRet =0;
/***注册相机回调函数***/
nRet = MV_CC_RegisterImageCallBackEx(_camera_handle, ImageCallBackEx, _camera_handle);
}
/************第二个相机*****************/
MVSCameraTwo MVSCameraTwo::_mvscamera_static;
/***取图回调函数***/
void __stdcall MVSCameraTwo::ImageCallBackEx(unsigned char* pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser)
{
int width_ = pFrameInfo->nWidth;
int height_ = pFrameInfo->nHeight;
qDebug() << QString::number(width_);
qDebug() << QString::number(height_);
MainFrontInspection::_main_front_inspection._image_exist=false;
MainFrontInspection::_main_front_inspection._image.Clear();
switch (pFrameInfo->enPixelType)
{
case MvGvspPixelType::PixelType_Gvsp_RGB8_Packed:
{
HalconCpp::HTuple hptr_ = (Hlong)pData;
HalconCpp::GenImageInterleaved(&MainFrontInspection::_main_front_inspection._image,
hptr_,
HalconCpp::HTuple("rgb"),
width_,
height_,
-1,
HalconCpp::HTuple("byte"),
0,
0,
0,
0,
-1,
0);
hptr_.Clear();
MainFrontInspection::_main_front_inspection._image_exist = true;
MainFrontInspection::_main_front_inspection.TriggerCameraImageWriteFinally();
}
break;
case MvGvspPixelType::PixelType_Gvsp_BayerRG8:
{
HalconCpp::HTuple hptr_ = (Hlong)pData;
HalconCpp::HObject image_;
HalconCpp::GenEmptyObj(&image_);
HalconCpp::GenImage1(&image_, "byte", width_, height_, (Hlong)hptr_);
HalconCpp::CfaToRgb(image_,
&MainFrontInspection::_main_front_inspection._image,
"bayer_rg",
"bilinear");
image_.Clear();
hptr_.Clear();
MainFrontInspection::_main_front_inspection._image_exist = true;
MainFrontInspection::_main_front_inspection.TriggerCameraImageWriteFinally();
}
break;
default:
break;
}
}
void MVSCameraTwo::RegisterImageCallBack()
{
int nRet =0;
/***注册相机回调函数***/
nRet = MV_CC_RegisterImageCallBackEx(_camera_handle, ImageCallBackEx, _camera_handle);
}
/*************第三个相机***************/
MVSCameraThird MVSCameraThird::_mvscamera_static;
/***取图回调函数***/
void __stdcall MVSCameraThird::ImageCallBackEx(unsigned char* pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser)
{
int width_ = pFrameInfo->nWidth;
int height_ = pFrameInfo->nHeight;
MainBackInspection::_main_back_inspection._image_exist=false;
MainBackInspection::_main_back_inspection._image.Clear();
switch (pFrameInfo->enPixelType)
{
case MvGvspPixelType::PixelType_Gvsp_RGB8_Packed:
{
HalconCpp::HTuple hptr_ = (Hlong)pData;
HalconCpp::GenImageInterleaved(&MainBackInspection::_main_back_inspection._image,
hptr_,
HalconCpp::HTuple("rgb"),
width_,
height_,
-1,
HalconCpp::HTuple("byte"),
0,
0,
0,
0,
-1,
0);
hptr_.Clear();
MainBackInspection::_main_back_inspection._image_exist = true;
MainBackInspection::_main_back_inspection.TriggerCameraImageWriteFinally();
}
break;
case MvGvspPixelType::PixelType_Gvsp_BayerRG8:
{
HalconCpp::HTuple hptr_ = (Hlong)pData;
HalconCpp::HObject image_;
HalconCpp::GenEmptyObj(&image_);
HalconCpp::GenImage1Extern(&image_,"byte",width_,height_,hptr_,0);
HalconCpp::CfaToRgb(image_,
&MainBackInspection::_main_back_inspection._image,
"bayer_rg",
"bilinear");
image_.Clear();
hptr_.Clear();
MainBackInspection::_main_back_inspection._image_exist = true;
MainBackInspection::_main_back_inspection.TriggerCameraImageWriteFinally();
}
break;
default:
break;
}
}
void MVSCameraThird::RegisterImageCallBack()
{
int nRet =0;
/***注册相机回调函数***/
nRet = MV_CC_RegisterImageCallBackEx(_camera_handle, ImageCallBackEx, _camera_handle);
}
/*************第四个相机***************/
MVSCameraFour MVSCameraFour::_mvscamera_static;
/***取图回调函数***/
void __stdcall MVSCameraFour::ImageCallBackEx(unsigned char* pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser)
{
int width_ = pFrameInfo->nWidth;
int height_ = pFrameInfo->nHeight;
WeldingPointInspection::_welding_point_inspection._image_exist=false;
WeldingPointInspection::_welding_point_inspection._image.Clear();
switch (pFrameInfo->enPixelType)
{
case MvGvspPixelType::PixelType_Gvsp_RGB8_Packed:
{
HalconCpp::HTuple hptr_ = (Hlong)pData;
HalconCpp::GenImageInterleaved(&WeldingPointInspection::_welding_point_inspection._image,
hptr_,
HalconCpp::HTuple("rgb"),
width_,
height_,
-1,
HalconCpp::HTuple("byte"),
0,
0,
0,
0,
-1,
0);
hptr_.Clear();
WeldingPointInspection::_welding_point_inspection._image_exist = true;
WeldingPointInspection::_welding_point_inspection.TriggerCameraImageWriteFinally();
}
break;
case MvGvspPixelType::PixelType_Gvsp_BayerRG8:
{
HalconCpp::HTuple hptr_ = (Hlong)pData;
HalconCpp::HObject image_;
HalconCpp::GenEmptyObj(&image_);
HalconCpp::GenImage1Extern(&image_,"byte",width_,height_,hptr_,0);
HalconCpp::CfaToRgb(image_,
&WeldingPointInspection::_welding_point_inspection._image,
"bayer_rg",
"bilinear");
image_.Clear();
hptr_.Clear();
WeldingPointInspection::_welding_point_inspection._image_exist = true;
WeldingPointInspection::_welding_point_inspection.TriggerCameraImageWriteFinally();
}
break;
default:
break;
}
}
void MVSCameraFour::RegisterImageCallBack()
{
int nRet =0;
/***注册相机回调函数***/
nRet = MV_CC_RegisterImageCallBackEx(_camera_handle, ImageCallBackEx, _camera_handle);
}
/**********相机管理***************/
MVSCameraCtr MVSCameraCtr::_mvscameractr_static;
void MVSCameraCtr::ReadCameraConfig()
{
QString config_path_ = QCoreApplication::applicationDirPath() + "/CameraConfig/CameraConfig.xlsx";
QFile file_(config_path_);
if (file_.exists())
{
QXlsx::Document xlsx_(config_path_);
if (xlsx_.load())
{
if(xlsx_.selectSheet("cam1"))
{
int row_count_ = xlsx_.dimension().rowCount();
int column_count_ = xlsx_.dimension().columnCount();
if ((row_count_ > 3)
&& (column_count_ > 1))
{
MVSCameraOne::_mvscamera_static._camera_name = xlsx_.cellAt(2, 2)->value().toString();
MVSCameraOne::_mvscamera_static._camera_expource = xlsx_.cellAt(3, 2)->value().toDouble();
MVSCameraOne::_mvscamera_static._camera_gain = xlsx_.cellAt(4, 2)->value().toDouble();
}
}
if(xlsx_.selectSheet("cam2"))
{
int row_count_ = xlsx_.dimension().rowCount();
int column_count_ = xlsx_.dimension().columnCount();
if ((row_count_ > 3)
&& (column_count_ > 1))
{
MVSCameraTwo::_mvscamera_static._camera_name = xlsx_.cellAt(2, 2)->value().toString();
MVSCameraTwo::_mvscamera_static._camera_expource = xlsx_.cellAt(3, 2)->value().toDouble();
MVSCameraTwo::_mvscamera_static._camera_gain = xlsx_.cellAt(4, 2)->value().toDouble();
}
}
if(xlsx_.selectSheet("cam3"))
{
int row_count_ = xlsx_.dimension().rowCount();
int column_count_ = xlsx_.dimension().columnCount();
if ((row_count_ > 3)
&& (column_count_ > 1))
{
MVSCameraThird::_mvscamera_static._camera_name = xlsx_.cellAt(2, 2)->value().toString();
MVSCameraThird::_mvscamera_static._camera_expource = xlsx_.cellAt(3, 2)->value().toDouble();
MVSCameraThird::_mvscamera_static._camera_gain = xlsx_.cellAt(4, 2)->value().toDouble();
}
}
if(xlsx_.selectSheet("cam4"))
{
int row_count_ = xlsx_.dimension().rowCount();
int column_count_ = xlsx_.dimension().columnCount();
if ((row_count_ > 3)
&& (column_count_ > 1))
{
MVSCameraFour::_mvscamera_static._camera_name = xlsx_.cellAt(2, 2)->value().toString();
MVSCameraFour::_mvscamera_static._camera_expource = xlsx_.cellAt(3, 2)->value().toDouble();
MVSCameraFour::_mvscamera_static._camera_gain = xlsx_.cellAt(4, 2)->value().toDouble();
}
}
}
}
}
bool MVSCameraCtr::WriteCameraConfig()
{
bool ok_ = false;
QString config_path_ = QCoreApplication::applicationDirPath() + "/CameraConfig/CameraConfig.xlsx";
QXlsx::Document xlsx_;
/***写入第一个相机数***/
xlsx_.addSheet("cam1");
if(xlsx_.selectSheet("cam1"))
{
/***写入抬头***/
xlsx_.write(1, 1, "Name");
xlsx_.write(1, 2, "Value");
xlsx_.write(1, 3, "Mean");
xlsx_.write(2, 1, "CameraNameOne");
xlsx_.write(2, 2,MVSCameraOne::_mvscamera_static._camera_name);
xlsx_.write(2, 3, "CameraName");
xlsx_.write(3, 1, "ExpourceOne");
xlsx_.write(3, 2, QString::number(MVSCameraOne::_mvscamera_static._camera_expource));
xlsx_.write(3, 3, "CameraExpource");
xlsx_.write(4, 1, "GainOne");
xlsx_.write(4, 2, QString::number(MVSCameraOne::_mvscamera_static._camera_gain));
xlsx_.write(4, 3, "CameraGain");
if (!xlsx_.saveAs(config_path_))
{
qDebug() << "save the DataCache.xlsx failed";
}
else
{
ok_ = true;
}
}
xlsx_.addSheet("cam2");
if(xlsx_.selectSheet("cam2"))
{
/***写入抬头***/
xlsx_.write(1, 1, "Name");
xlsx_.write(1, 2, "Value");
xlsx_.write(1, 3, "Mean");
xlsx_.write(2, 1, "CameraNameTwo");
xlsx_.write(2, 2,MVSCameraTwo::_mvscamera_static._camera_name);
xlsx_.write(2, 3, "CameraName");
xlsx_.write(3, 1, "ExpourceTwo");
xlsx_.write(3, 2, QString::number(MVSCameraTwo::_mvscamera_static._camera_expource));
xlsx_.write(3, 3, "CameraExpource");
xlsx_.write(4, 1, "GainTwo");
xlsx_.write(4, 2, QString::number(MVSCameraTwo::_mvscamera_static._camera_gain));
xlsx_.write(4, 3, "CameraGain");
if (!xlsx_.saveAs(config_path_))
{
qDebug() << "save the DataCache.xlsx failed";
}
else
{
ok_ = true;
}
}
xlsx_.addSheet("cam3");
if(xlsx_.selectSheet("cam3"))
{
/***写入抬头***/
xlsx_.write(1, 1, "Name");
xlsx_.write(1, 2, "Value");
xlsx_.write(1, 3, "Mean");
xlsx_.write(2, 1, "CameraNameThird");
xlsx_.write(2, 2,MVSCameraThird::_mvscamera_static._camera_name);
xlsx_.write(2, 3, "CameraName");
xlsx_.write(3, 1, "ExpourceThird");
xlsx_.write(3, 2, QString::number(MVSCameraThird::_mvscamera_static._camera_expource));
xlsx_.write(3, 3, "CameraExpource");
xlsx_.write(4, 1, "GainThird");
xlsx_.write(4, 2, QString::number(MVSCameraThird::_mvscamera_static._camera_gain));
xlsx_.write(4, 3, "CameraGain");
if (!xlsx_.saveAs(config_path_))
{
qDebug() << "save the DataCache.xlsx failed";
}
else
{
ok_ = true;
}
}
xlsx_.addSheet("cam4");
if(xlsx_.selectSheet("cam4"))
{
/***写入抬头***/
xlsx_.write(1, 1, "Name");
xlsx_.write(1, 2, "Value");
xlsx_.write(1, 3, "Mean");
xlsx_.write(2, 1, "CameraNameFour");
xlsx_.write(2, 2,MVSCameraFour::_mvscamera_static._camera_name);
xlsx_.write(2, 3, "CameraName");
xlsx_.write(3, 1, "ExpourceFour");
xlsx_.write(3, 2, QString::number(MVSCameraFour::_mvscamera_static._camera_expource));
xlsx_.write(3, 3, "CameraExpource");
xlsx_.write(4, 1, "GainFour");
xlsx_.write(4, 2, QString::number(MVSCameraFour::_mvscamera_static._camera_gain));
xlsx_.write(4, 3, "CameraGain");
if (!xlsx_.saveAs(config_path_))
{
qDebug() << "save the DataCache.xlsx failed";
}
else
{
ok_ = true;
}
}
return ok_;
}
void MVSCameraCtr::Init()
{
MVSCameraOne::_mvscamera_static.Init();
MVSCameraOne::_mvscamera_static.RegisterImageCallBack();
MVSCameraTwo::_mvscamera_static.Init();
MVSCameraTwo::_mvscamera_static.RegisterImageCallBack();
MVSCameraThird::_mvscamera_static.Init();
MVSCameraThird::_mvscamera_static.RegisterImageCallBack();
MVSCameraFour::_mvscamera_static.Init();
MVSCameraFour::_mvscamera_static.RegisterImageCallBack();
}