mirror of
https://github.com/NanjingForestryUniversity/UpmatchinePassion-tomato.git
synced 2025-11-08 14:24:06 +00:00
726 lines
18 KiB
C++
726 lines
18 KiB
C++
#include "camera.h"
|
||
#include "thread.h"
|
||
#include <vector>
|
||
|
||
#include <QTime>
|
||
// 使用std::vector存储所有帧的数据
|
||
|
||
|
||
extern int save_flag;
|
||
extern bool spec_flag;
|
||
tomato tomato;
|
||
void __stdcall onImageDataCallBackFunc(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser);
|
||
void __stdcall onOfflineCallBackFunc(unsigned int nMsgType, void* pUser);
|
||
void __stdcall onImageDataCallBackFunc1(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser);
|
||
void __stdcall onOfflineCallBackFunc1(unsigned int nMsgType, void* pUser);
|
||
void __stdcall onImageDataCallBackFunc2(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser);
|
||
void __stdcall onOfflineCallBackFunc2(unsigned int nMsgType, void* pUser);
|
||
|
||
extern void __stdcall RTRGBViewCallback(void* pContext, unsigned char* pRData, unsigned char* pGData, unsigned char* pBData, unsigned long dataLength);
|
||
extern void __stdcall RTSpecStreamingCallback(void *pContext, unsigned char *pData, unsigned long dataLength);
|
||
|
||
int camStatusret;
|
||
int camStatusret1;
|
||
int camStatusret2;
|
||
extern bool change_passionFlag;
|
||
extern bool change_tomatoFlag;
|
||
CameraL::CameraL(QObject *parent) : QObject(parent)
|
||
{
|
||
|
||
}
|
||
|
||
bool CameraL::initCameraL()
|
||
{
|
||
/*
|
||
* 枚举设备
|
||
* */
|
||
int device_num = enum_device();
|
||
qDebug()<<"找到相机: "<<device_num;
|
||
if(device_num == -1)
|
||
{
|
||
qDebug()<<"enum device failed";
|
||
if(camera_handle != NULL)
|
||
{
|
||
destroy_handle();
|
||
}
|
||
return false;
|
||
}
|
||
if(device_num == 0)
|
||
{
|
||
qDebug()<<"no camera found";
|
||
if(camera_handle != NULL)
|
||
{
|
||
destroy_handle();
|
||
}
|
||
return false;
|
||
}
|
||
|
||
//print_device_info();
|
||
bool isOk = select_device();
|
||
if(!isOk)
|
||
{
|
||
qDebug()<<"create handle failed";
|
||
if(camera_handle != NULL)
|
||
{
|
||
destroy_handle();
|
||
}
|
||
if(camera_handle1 != NULL)
|
||
{
|
||
destroy_handle1();
|
||
}
|
||
if(camera_handle2 != NULL)
|
||
{
|
||
destroy_handle2();
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/*
|
||
* 开启相机
|
||
* */
|
||
isOk = open_camera();
|
||
|
||
if(!isOk)
|
||
{
|
||
qDebug()<<"open camera failed";
|
||
if(camera_handle != NULL)
|
||
{
|
||
destroy_handle();
|
||
}
|
||
return false;
|
||
}else{
|
||
qDebug()<<"打开相机: "<<"isOk: "<<isOk;
|
||
}
|
||
|
||
// set_ROI(0, 0, 2448, 2048);
|
||
|
||
/*
|
||
* 导入配置文件（相机）
|
||
**/
|
||
isOk = import_config_file();
|
||
// set_ROI(0, 668, 1000, 2448);
|
||
if(!isOk)
|
||
{
|
||
qDebug()<<"import config file failed";
|
||
if(camera_handle != NULL)
|
||
{
|
||
destroy_handle();
|
||
}
|
||
if(camera_handle1 != NULL)
|
||
{
|
||
destroy_handle1();
|
||
}
|
||
if(camera_handle2 != NULL)
|
||
{
|
||
destroy_handle2();
|
||
}
|
||
return false;;
|
||
}
|
||
|
||
isOk = register_image_callback(onImageDataCallBackFunc,onImageDataCallBackFunc1,onImageDataCallBackFunc2);
|
||
qDebug()<<"注册回调成功: "<<"isOk: "<<isOk;
|
||
if(!isOk)
|
||
{
|
||
qDebug()<<"register image callback function failed";
|
||
if(camera_handle != NULL)
|
||
{
|
||
destroy_handle();
|
||
}
|
||
if(camera_handle1 != NULL)
|
||
{
|
||
destroy_handle1();
|
||
}
|
||
if(camera_handle2 != NULL)
|
||
{
|
||
destroy_handle2();
|
||
}
|
||
return false;
|
||
}
|
||
|
||
isOk = register_offline_callback(onOfflineCallBackFunc,onOfflineCallBackFunc1,onOfflineCallBackFunc2);
|
||
qDebug()<<"取消注册回调成功: "<<"isOk: "<<isOk;
|
||
if(!isOk)
|
||
{
|
||
qDebug()<<"register offline callback function failed";
|
||
if(camera_handle != NULL)
|
||
{
|
||
destroy_handle();
|
||
}
|
||
if(camera_handle1 != NULL)
|
||
{
|
||
destroy_handle1();
|
||
}
|
||
if(camera_handle2 != NULL)
|
||
{
|
||
destroy_handle2();
|
||
}
|
||
return false;
|
||
}
|
||
isOk = set_acquisition_mode();
|
||
qDebug()<<"设置触发成功: "<<"isOk: "<<isOk;
|
||
if(!isOk)
|
||
{
|
||
qDebug()<<"set acquistion mode failed";
|
||
if(camera_handle != NULL)
|
||
{
|
||
destroy_handle();
|
||
}
|
||
if(camera_handle1 != NULL)
|
||
{
|
||
destroy_handle1();
|
||
}
|
||
if(camera_handle2 != NULL)
|
||
{
|
||
destroy_handle2();
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// isOk = set_ROI(0, 668, 2448, 1000);
|
||
// if(!isOk)
|
||
// {
|
||
// qDebug()<<"SET ROI FAILED";
|
||
// if(camera_handle != NULL)
|
||
// {
|
||
// destroy_handle();
|
||
// }
|
||
// return false;
|
||
// }
|
||
|
||
|
||
MV_CC_SetBalanceWhiteAuto(camera_handle, 0);
|
||
MV_CC_SetBalanceWhiteAuto(camera_handle1, 0);
|
||
MV_CC_SetBalanceWhiteAuto(camera_handle2, 0);
|
||
MV_CC_SetIntValue(camera_handle, "LineDebouncerTime", 100);
|
||
MV_CC_SetIntValue(camera_handle1, "LineDebouncerTime", 100);
|
||
MV_CC_SetIntValue(camera_handle2, "LineDebouncerTime", 100);
|
||
|
||
return true;
|
||
|
||
|
||
}
|
||
|
||
uint32_t CameraL::enum_device()
|
||
{
|
||
int ret = MV_CC_EnumDevices(MV_GIGE_DEVICE | MV_USB_DEVICE, &device_list);
|
||
if(ret != MV_OK)
|
||
{
|
||
return -1;
|
||
}
|
||
//qDebug()<<"device_list[0]: "<<device_list.pDeviceInfo[0];
|
||
|
||
//qDebug()<<"device_list[1]: "<<device_list.pDeviceInfo[1];
|
||
|
||
return device_list.nDeviceNum;
|
||
}
|
||
|
||
|
||
bool CameraL::select_device()
|
||
{
|
||
MV_CC_DEVICE_INFO* pstDeviceInfo;
|
||
|
||
|
||
for(i=0;i<=2;i++)
|
||
{
|
||
|
||
pstDeviceInfo = device_list.pDeviceInfo[i];
|
||
if (NULL == pstDeviceInfo)
|
||
{
|
||
printf("The Pointer of pstMVDevInfo is NULL!\n");
|
||
return false;
|
||
}
|
||
// qDebug()<<"nip1； "<<((pstDeviceInfo->SpecialInfo.stGigEInfo.nCurrentIp & 0xff000000)>>24);
|
||
// qDebug()<<"nip2； "<<((pstDeviceInfo->SpecialInfo.stGigEInfo.nCurrentIp & 0x00ff0000)>>16);
|
||
// qDebug()<<"nip3； "<<((pstDeviceInfo->SpecialInfo.stGigEInfo.nCurrentIp & 0x0000ff00)>>8);
|
||
// qDebug()<<"nip4； "<<((pstDeviceInfo->SpecialInfo.stGigEInfo.nCurrentIp & 0x000000ff));
|
||
ip4 = pstDeviceInfo->SpecialInfo.stGigEInfo.nCurrentIp & 0x000000ff;
|
||
switch (ip4) {
|
||
case 100:
|
||
MV_CC_CreateHandle(&camera_handle1, device_list.pDeviceInfo[i]);
|
||
|
||
break;
|
||
case 150:
|
||
MV_CC_CreateHandle(&camera_handle, device_list.pDeviceInfo[i]);
|
||
break;
|
||
case 200:
|
||
MV_CC_CreateHandle(&camera_handle2, device_list.pDeviceInfo[i]);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
pstDeviceInfo++;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool CameraL::open_camera()
|
||
{
|
||
int ret = MV_CC_OpenDevice(camera_handle);
|
||
int ret1 = MV_CC_OpenDevice(camera_handle1);
|
||
int ret2 = MV_CC_OpenDevice(camera_handle2);
|
||
camStatusret2=0;
|
||
camStatusret1=0;
|
||
camStatusret=0;
|
||
if(ret != MV_OK||ret1 != MV_OK||ret2 != MV_OK)
|
||
{
|
||
return false;
|
||
camStatusret2=0;
|
||
camStatusret1=0;
|
||
camStatusret=0;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CameraL::start_capture()
|
||
{
|
||
int ret2 = MV_CC_StartGrabbing(camera_handle2);
|
||
|
||
int ret1 = MV_CC_StartGrabbing(camera_handle1);
|
||
|
||
int ret = MV_CC_StartGrabbing(camera_handle);
|
||
if (ret != MV_OK||ret1 != MV_OK||ret2 != MV_OK)
|
||
{
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool CameraL::register_image_callback(imageCallbackFunc onImageDataCallBackFunc,imageCallbackFunc onImageDataCallBackFunc1,imageCallbackFunc onImageDataCallBackFunc2)
|
||
{
|
||
int ret2 = MV_CC_RegisterImageCallBackForBGR(camera_handle1, onImageDataCallBackFunc, NULL);
|
||
|
||
int ret1 = MV_CC_RegisterImageCallBackForBGR(camera_handle, onImageDataCallBackFunc2, NULL);
|
||
|
||
int ret = MV_CC_RegisterImageCallBackForBGR(camera_handle2, onImageDataCallBackFunc1, NULL);
|
||
if (ret != MV_OK||ret1 != MV_OK||ret2 != MV_OK)
|
||
{
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool CameraL::register_offline_callback(exceptionCallbackFunc onOfflineCallBackFunc, exceptionCallbackFunc onOfflineCallBackFunc1, exceptionCallbackFunc onOfflineCallBackFunc2)
|
||
{
|
||
int nRet1 = MV_CC_RegisterExceptionCallBack(camera_handle, onOfflineCallBackFunc2, NULL);
|
||
|
||
int nRet = MV_CC_RegisterExceptionCallBack(camera_handle2, onOfflineCallBackFunc1, NULL);
|
||
int nRet2 = MV_CC_RegisterExceptionCallBack(camera_handle1, onOfflineCallBackFunc, NULL);
|
||
if (nRet != MV_OK||nRet1 != MV_OK||nRet2 != MV_OK)
|
||
{
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
|
||
|
||
bool CameraL::destroy_handle()
|
||
{
|
||
int ret = MV_CC_DestroyHandle(camera_handle);
|
||
if (MV_OK != ret)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
bool CameraL::destroy_handle1()
|
||
{
|
||
int ret = MV_CC_DestroyHandle(camera_handle1);
|
||
if (MV_OK != ret)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}bool CameraL::destroy_handle2()
|
||
{
|
||
int ret = MV_CC_DestroyHandle(camera_handle2);
|
||
if (MV_OK != ret)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
bool CameraL::import_config_file()
|
||
{
|
||
if(change_passionFlag&&(!change_tomatoFlag))
|
||
{
|
||
int ret = MV_CC_FeatureLoad(camera_handle, CAMERA_CONFIG_PATH);
|
||
if(ret != MV_OK)
|
||
{
|
||
return false;
|
||
}
|
||
int ret2 = MV_CC_FeatureLoad(camera_handle2, CAMERA2_CONFIG_PATH);
|
||
if(ret2 != MV_OK)
|
||
{
|
||
return false;
|
||
}
|
||
int ret1 = MV_CC_FeatureLoad(camera_handle1, CAMERAtop_CONFIG_PATH);
|
||
if(ret1 != MV_OK)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
if((!change_passionFlag)&&change_tomatoFlag)
|
||
{
|
||
int ret = MV_CC_FeatureLoad(camera_handle, CAMERApassion_left_config);
|
||
if(ret != MV_OK)
|
||
{
|
||
return false;
|
||
}
|
||
int ret2 = MV_CC_FeatureLoad(camera_handle2, CAMERApassion_right_config);
|
||
if(ret2 != MV_OK)
|
||
{
|
||
return false;
|
||
}
|
||
int ret1 = MV_CC_FeatureLoad(camera_handle1, CAMERAtoppassion_top2_config);
|
||
if(ret1 != MV_OK)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
|
||
}
|
||
|
||
bool CameraL::save_config_file()
|
||
{
|
||
int ret = MV_CC_FeatureSave(camera_handle, CAMERA_CONFIG_PATH);
|
||
if(ret != MV_OK)
|
||
{
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool CameraL::set_param(Camera_param param_struct)
|
||
{
|
||
camera_param = param_struct;
|
||
int ret = MV_CC_SetIntValue(camera_handle, "BalanceRatio", camera_param.white_balance_ratio);
|
||
if (ret != MV_OK)
|
||
{
|
||
qDebug()<<"white balance ration set failed";
|
||
return false;
|
||
}
|
||
|
||
ret = MV_CC_SetFloatValue(camera_handle, "ExposureTime", camera_param.exposure_time);
|
||
if(ret != MV_OK)
|
||
{
|
||
qDebug()<<"exposure time set failed";
|
||
return false;
|
||
}
|
||
|
||
ret = MV_CC_SetFloatValue(camera_handle, "Gain", camera_param.gain);
|
||
if(ret != MV_OK)
|
||
{
|
||
qDebug()<<"gain set failed";
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
Camera_param CameraL::get_param()
|
||
{
|
||
MVCC_INTVALUE BalanceRatio = {0};
|
||
int ret = MV_CC_GetIntValue(camera_handle, "BalanceRatio", &BalanceRatio);
|
||
if (ret == MV_OK)
|
||
{
|
||
camera_param.white_balance_ratio = BalanceRatio.nCurValue;
|
||
}
|
||
else
|
||
{
|
||
qDebug()<<"get white balance ratio failed";
|
||
}
|
||
|
||
|
||
MVCC_FLOATVALUE ExposureTime = {0};
|
||
ret = MV_CC_GetFloatValue(camera_handle, "ExposureTime", &ExposureTime);
|
||
if(ret == MV_OK)
|
||
{
|
||
camera_param.exposure_time = ExposureTime.fCurValue;
|
||
}
|
||
else
|
||
{
|
||
qDebug()<<"get exposure time failed";
|
||
}
|
||
|
||
MVCC_FLOATVALUE Gain = {0};
|
||
ret = MV_CC_GetFloatValue(camera_handle, "Gain", &Gain);
|
||
if(ret == MV_OK)
|
||
{
|
||
camera_param.gain = Gain.fCurValue;
|
||
}
|
||
else
|
||
{
|
||
qDebug()<<"get gain failed";
|
||
}
|
||
|
||
#if 1
|
||
qDebug()<< camera_param.white_balance_ratio;
|
||
qDebug()<<camera_param.exposure_time;
|
||
qDebug()<<camera_param.gain;
|
||
|
||
#endif
|
||
|
||
return camera_param;
|
||
}
|
||
/*
|
||
* TriggerMode 0 OFF
|
||
* 1 ON
|
||
*
|
||
* TriggerSource Line0 0
|
||
* Line1 1
|
||
* Line2 2
|
||
* Line3 3
|
||
* Counter0 4
|
||
* Software 7
|
||
* FrequencyConverter 8
|
||
*TriggerActivation 0:RisingEdge
|
||
1:FallingEdge
|
||
2:LevelHigh
|
||
3:LevelLow
|
||
AcquisitionMode 0:SingleFrame
|
||
1:MultiFrame
|
||
2:Continuous
|
||
* */
|
||
bool CameraL::set_acquisition_mode()
|
||
{
|
||
int ret = MV_CC_SetEnumValue(camera_handle, "TriggerMode", 1);
|
||
int ret1 = MV_CC_SetEnumValue(camera_handle1, "TriggerMode",1);
|
||
int ret2 = MV_CC_SetEnumValue(camera_handle2, "TriggerMode", 1);
|
||
if(MV_OK != ret || MV_OK != ret1 ||MV_OK != ret2)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
int ret3 = MV_CC_SetEnumValue(camera_handle, "TriggerSource",0);
|
||
int ret4 = MV_CC_SetEnumValue(camera_handle1, "TriggerSource", 0);
|
||
int ret5 = MV_CC_SetEnumValue(camera_handle2, "TriggerSource", 0);
|
||
if(MV_OK != ret3 || MV_OK != ret4 ||MV_OK != ret5)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
int ret6 = MV_CC_SetEnumValue(camera_handle, "TriggerActivation", 0);
|
||
int ret7 = MV_CC_SetEnumValue(camera_handle1, "TriggerActivation", 0);
|
||
int ret8 = MV_CC_SetEnumValue(camera_handle2, "TriggerActivation", 0);
|
||
if(MV_OK != ret6 || MV_OK != ret7 ||MV_OK != ret8)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
int ret9 = MV_CC_SetEnumValue(camera_handle, "AcquisitionMode", 2); //采集模式连续
|
||
int ret10 = MV_CC_SetEnumValue(camera_handle1, "AcquisitionMode", 2);
|
||
int ret11 = MV_CC_SetEnumValue(camera_handle2, "AcquisitionMode", 2);
|
||
if(MV_OK != ret9 || MV_OK != ret10 ||MV_OK != ret11)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CameraL::stop_capture()
|
||
{
|
||
|
||
int ret = MV_CC_StopGrabbing(camera_handle);
|
||
int ret1 = MV_CC_StopGrabbing(camera_handle1);
|
||
int ret2 = MV_CC_StopGrabbing(camera_handle2);
|
||
if(MV_OK!=ret){
|
||
destroy_handle();
|
||
}
|
||
if(MV_OK!=ret1){
|
||
destroy_handle1();
|
||
}
|
||
if(MV_OK!=ret2){
|
||
destroy_handle2();
|
||
}
|
||
return true;
|
||
}
|
||
|
||
|
||
//spec camera
|
||
SpecCamera::SpecCamera(QObject *parent)
|
||
{
|
||
|
||
}
|
||
|
||
bool SpecCamera::init_SpecCamera()
|
||
{
|
||
//打开相机
|
||
int ires = RTOpenCamera();
|
||
qDebug()<<"ires: "<<ires;
|
||
if (ires != 1)
|
||
{
|
||
printf("Open Camera failed!");
|
||
return false;
|
||
}
|
||
//获取当前系统相机参数
|
||
m_uiDepth = RTGetCameraDepth(); //获取相机图像最大值（256/4096/65536）
|
||
RTGetImageProperty(m_iWidth, m_iHeight); //获取图像宽、高
|
||
m_pusSaveBuffer = new unsigned short[m_iHeight*((m_iWidth * 3 + 3) / 4 * 4)];
|
||
m_pRefreshBuffer = new unsigned char[m_iHeight*((m_iWidth * 3 + 3) / 4 * 4)];
|
||
|
||
|
||
RTGetCameraGain(m_fGain);
|
||
RTGetExposure(m_fExpTime);
|
||
RTGetCameraFrameRate(m_iFrameRate);
|
||
RTGetMinAndMaxWavelength(m_fWaveLengthMin, m_fWaveLengthMax);
|
||
|
||
RTGetRGBselect(m_cslRed, m_cslGreen, m_cslBlue);
|
||
|
||
|
||
RTSetExposure(m_fExpTime);
|
||
RTSetCameraGain(m_fGain);
|
||
RTSetCameraFrameRate(m_iFrameRate);
|
||
RTApplyCameraParam();
|
||
if (m_cslRed > m_iHeight || m_cslGreen > m_iHeight || m_cslBlue > m_iHeight
|
||
|| m_cslRed <= 0 || m_cslGreen <= 0 || m_cslBlue <= 0)
|
||
{
|
||
m_cslRed = m_iHeight * 3 / 4;
|
||
m_cslGreen = m_iHeight / 2;
|
||
m_cslBlue = m_iHeight / 4;
|
||
}
|
||
RTSetRGBselect(m_cslRed, m_cslGreen, m_cslBlue);
|
||
// RTAddRGBCallback(RTRGBViewCallback, nullptr);
|
||
RTAddStreamingCallback(RTSpecStreamingCallback,nullptr);
|
||
return true;
|
||
}
|
||
|
||
bool SpecCamera::cal(unsigned char *pData)
|
||
{
|
||
// QTime currenttime = QTime::currentTime();
|
||
// qDebug()<<"触发时间："<<currenttime;
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
// unsigned short* spec_data = new unsigned short[1024*40]; //2048*224*1
|
||
// unsigned short* spec_data_short = (unsigned short *)pData;
|
||
// memcpy(spec_data, spec_data_short + 1024 * 40 , 1024 * 40 * sizeof(unsigned short));
|
||
// //将处理后的帧数据存储到vector中
|
||
// frameData.push_back(spec_data);
|
||
// // 检查是否已收集到足够的帧
|
||
// if (frameData.size() == totalFrames)
|
||
// {
|
||
|
||
// // 处理这些帧，例如拼接成一张大图
|
||
// specfullImage = new unsigned short[1024 * 40 * totalFrames];
|
||
|
||
// for (int i = 0; i < totalFrames ; i++)
|
||
// {
|
||
// memcpy(specfullImage + i * 1024 * 40, frameData[i] , 1024 * 40 * sizeof(unsigned short));
|
||
// }
|
||
// frameData.clear();
|
||
// if(save_flag)
|
||
// {
|
||
// static int file_index = 1;
|
||
// std::string spec_filename = "E:/qt_tomato_passion/new/20240422/image/specImg/spec" + std::to_string(file_index);
|
||
// FILE *fp = fopen(spec_filename.c_str(), "wb");
|
||
// int ret = fwrite(specfullImage, 1, totalFrames * 1024 * 40 * sizeof(unsigned short), fp);
|
||
// // qDebug()<<"光谱队列长度: "<<frameData.size()<<" ret : "<<ret;
|
||
|
||
// std::fflush(fp);
|
||
// fclose(fp);
|
||
// file_index++;
|
||
// std::cout<<"save img success"<<std::endl;
|
||
// // qDebug()<<"test_count: "<<test_count;
|
||
// }
|
||
|
||
|
||
// }
|
||
|
||
|
||
// memcpy(specfullImage + test_count * m_iWidth * 224, spec_data + 500 * 224, 1024 * 224 * sizeof(unsigned short));
|
||
// test_count++;
|
||
// if(test_count == totalFrames)
|
||
// {
|
||
// QTime starttime = QTime::currentTime();
|
||
// //specImgQueue.push(specfullImage);
|
||
|
||
// test_count = 0;
|
||
// QTime stoptime = QTime::currentTime();
|
||
// int functime = starttime.msecsTo(stoptime);
|
||
// qDebug() << "Time elapsed for image" <<functime;
|
||
// }
|
||
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
|
||
bool SpecCamera::stop_capture()
|
||
{
|
||
bool ret = trigger_close();
|
||
if(ret == false)
|
||
{
|
||
qDebug()<<"trigger is not close:"<<ret;
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
qDebug()<<"trigger is close:"<<ret;
|
||
}
|
||
qDebug()<<"ret: "<<ret;
|
||
if (RTIsCameraWorking())
|
||
{
|
||
RTStopSingleCapture();
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool SpecCamera::trigger_open()
|
||
{
|
||
bool ret = RT_SetBool(L"Camera.TriggerIn", true); //设置相机外触发
|
||
|
||
if(ret==false)
|
||
{
|
||
qDebug()<<"trigger is not open:"<<ret;
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
qDebug()<<"trigger is open:"<<ret;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool SpecCamera::trigger_close()
|
||
{
|
||
bool ret = RT_SetBool(L"Camera.TriggerIn", false);
|
||
|
||
if(ret==false)
|
||
{
|
||
qDebug()<<"trigger is not close:"<<ret;
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
qDebug()<<"trigger is close:"<<ret;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool SpecCamera::start_capture()
|
||
{
|
||
trigger_open();
|
||
bool flag = RTStartSingleCapture(false, false, "E:/qt_tomato_passion/new/20240422/image/specImg/newdata.raw");
|
||
if (!flag)
|
||
{
|
||
printf("erro to start capture");
|
||
return 1;
|
||
}
|
||
return true;
|
||
}
|