mirror of
https://github.com/NanjingForestryUniversity/UpmatchinePassion-tomato.git
synced 2025-11-08 06:14:03 +00:00
666 lines
17 KiB
C++
666 lines
17 KiB
C++
#include "camera.h"
|
||
#include "thread.h"
|
||
#include <vector>
|
||
// 使用std::vector存储所有帧的数据
|
||
|
||
//外部引用的标志位 save_flag 存图标志位 RGB 光谱是否需要保存图 （不能单独存一个 RGB 或 光谱 ， 只能要存全存 除非再加标志位）
|
||
//spec_flag 没用到
|
||
extern int save_flag;
|
||
extern bool spec_flag;
|
||
tomato tomato;
|
||
|
||
//RGB相机的回调函数
|
||
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);
|
||
|
||
//三个相机是否连接上的标志位 在 initcamera 里面的 opencamera 函数有返回值 负责修改 ui界面的 "是否连接" 标志位
|
||
int camStatusret;
|
||
int camStatusret1;
|
||
int camStatusret2;
|
||
|
||
//果蔬标志位
|
||
extern int fruit_flag;
|
||
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);
|
||
|
||
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
//下面是所有 initcamera 函数内调用的函数的具体内容
|
||
uint32_t CameraL::enum_device()
|
||
{
|
||
int ret = MV_CC_EnumDevices(MV_GIGE_DEVICE | MV_USB_DEVICE, &device_list);
|
||
if(ret != MV_OK)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
return device_list.nDeviceNum;
|
||
}
|
||
|
||
//这里需要注意 因为是三个相机 且有位置顺序 所以需要根据相机的第四位 ip 来确定 （所有相机都必须分配固定ip）
|
||
//比如相机 ip 为 192.168.2.10 10 则为相机的第四位 ip 如果发现顺序不对，使用MVS软件重新分配固定 ip
|
||
//200顶部相机 100右侧相机 150左侧相机
|
||
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;
|
||
}
|
||
|
||
ip4 = pstDeviceInfo->SpecialInfo.stGigEInfo.nCurrentIp & 0x000000ff;
|
||
//根据第四位 ip 来创建 camera_handle
|
||
//camera_handle 相当于 一个指向相机的指针 这个指针就代表相机
|
||
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::open_camera2()
|
||
{
|
||
/*
|
||
* 导入配置文件（相机）
|
||
**/
|
||
bool 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;
|
||
}
|
||
|
||
// 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);
|
||
}
|
||
|
||
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, onImageDataCallBackFunc1, NULL); //100 right
|
||
|
||
int ret1 = MV_CC_RegisterImageCallBackForBGR(camera_handle, onImageDataCallBackFunc2, NULL); //150 left
|
||
|
||
int ret = MV_CC_RegisterImageCallBackForBGR(camera_handle2, onImageDataCallBackFunc, NULL); //200 top
|
||
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(fruit_flag) //百香果
|
||
{
|
||
qDebug()<<"import passion camera ini";
|
||
int ret = MV_CC_FeatureLoad(camera_handle, CAMERApassion_left_config);
|
||
if(ret != MV_OK)
|
||
{
|
||
return false;
|
||
}
|
||
int ret2 = MV_CC_FeatureLoad(camera_handle2, CAMERAtoppassion_top2_config);
|
||
if(ret2 != MV_OK)
|
||
{
|
||
return false;
|
||
}
|
||
int ret1 = MV_CC_FeatureLoad(camera_handle1, CAMERApassion_right_config);
|
||
if(ret1 != MV_OK)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
else //西红柿
|
||
{
|
||
qDebug()<<"import tomato camera ini";
|
||
|
||
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;
|
||
}
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
|
||
//光谱相机的所有函数
|
||
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;
|
||
}
|
||
|
||
//这个 cal 函数 是光谱相机的回调函数内触发的一个槽函数 可以在 thread 里面的光谱相机的回调找到
|
||
bool SpecCamera::cal(unsigned char *pData)
|
||
{
|
||
test_count++;
|
||
//假设筛选后的ROI 为 30 * 100 宽 * 谱段数
|
||
//按右上角为数据初始点 900像素点 每一行第 900 个像素点 第 73 个谱段
|
||
|
||
|
||
|
||
unsigned short* spec_total_data = new unsigned short[30 * 13]; //宽 * 谱段数
|
||
|
||
unsigned short* spec_short_data = (unsigned short *)pData;
|
||
int Band[13]={8,9,10,48,49,50,77,80,103,108,115,143,145};
|
||
for(int k=0;k<13;k++)
|
||
{
|
||
memcpy(spec_total_data + k * 30, spec_short_data + 900 + (Band[k] - 1) * 2048, 30 * sizeof(unsigned short));
|
||
}
|
||
if (test_count < 26)
|
||
{
|
||
SpecData_vector.push_back(spec_total_data);
|
||
}
|
||
else
|
||
{
|
||
delete[] spec_total_data; // 释放内存以防止内存泄漏
|
||
}
|
||
|
||
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
//光谱相机内置函数 不用管
|
||
bool SpecCamera::stop_capture()
|
||
{
|
||
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::start_capture()
|
||
{
|
||
trigger_open();
|
||
bool flag = RTStartSingleCapture(false, false, "E:/QT/projects/tomato20240415/tomato04150955/image/newdata.raw");
|
||
if (!flag)
|
||
{
|
||
printf("erro to start capture");
|
||
return 1;
|
||
}
|
||
return true;
|
||
}
|