566 lines
15 KiB
C++
566 lines
15 KiB
C++
#include "Header_Files/irisximeaimager.h"
|
||
using namespace Iris;
|
||
|
||
void Iris::IrisXimeaImager::setGainOffset(float gain, float offset)
|
||
{
|
||
m_fGain = gain;
|
||
m_fOffset = offset;
|
||
}
|
||
|
||
bool Iris::IrisXimeaImager::setSpectralBin(int spectralBin)
|
||
{
|
||
CE(xiSetParamInt(m_xiH, XI_PRM_BINNING_SELECTOR, XI_BIN_SELECT_HOST_CPU));//用：XI_BIN_SELECT_HOST_CPU；默认为XI_BIN_SELECT_SENSOR(会报错)，不可用：XI_BIN_SELECT_DEVICE_FPGA
|
||
CE(xiSetParamInt(m_xiH, XI_PRM_BINNING_VERTICAL_MODE, XI_BIN_MODE_AVERAGE));
|
||
CE(xiSetParamInt(m_xiH, XI_PRM_BINNING_VERTICAL, spectralBin));
|
||
printf("Iris::IrisXimeaImager::setSpectralBin----2 设置bin模式为XI_PRM_BINNING_SELECTOR XI_BIN_MODE_AVERAGE ！\n");
|
||
|
||
|
||
// CE(xiSetParamInt(m_xiH, XI_PRM_DECIMATION_SELECTOR, XI_DEC_SELECT_SENSOR));
|
||
// CE(xiSetParamInt(m_xiH, XI_PRM_DECIMATION_VERTICAL, spectralBin));
|
||
|
||
|
||
m_iSpectralBin = spectralBin;
|
||
|
||
return true;
|
||
}
|
||
|
||
bool Iris::IrisXimeaImager::setSpatialBin(int spatialBin)
|
||
{
|
||
CE(xiSetParamInt(m_xiH, XI_PRM_BINNING_SELECTOR, XI_BIN_SELECT_HOST_CPU));//用：XI_BIN_SELECT_HOST_CPU；默认为XI_BIN_SELECT_SENSOR(会报错)，不可用：XI_BIN_SELECT_DEVICE_FPGA
|
||
CE(xiSetParamInt(m_xiH, XI_PRM_BINNING_HORIZONTAL_MODE, XI_BIN_MODE_AVERAGE));
|
||
CE(xiSetParamInt(m_xiH, XI_PRM_BINNING_HORIZONTAL, spatialBin));
|
||
printf("Iris::IrisXimeaImager::setSpatialBin----2 设置bin模式为XI_PRM_BINNING_SELECTOR XI_BIN_MODE_AVERAGE ！\n");
|
||
|
||
|
||
// CE(xiSetParamInt(m_xiH, XI_PRM_DECIMATION_SELECTOR, XI_DEC_SELECT_SENSOR));
|
||
// CE(xiSetParamInt(m_xiH, XI_PRM_DECIMATION_HORIZONTAL, spatialBin));
|
||
|
||
m_iSpatialBin = spatialBin;
|
||
|
||
return true;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::getSpectralBin()
|
||
{
|
||
int spectralBin = 0;
|
||
CE(xiGetParamInt(m_xiH, XI_PRM_BINNING_VERTICAL, &spectralBin));
|
||
|
||
// CE(xiGetParamInt(m_xiH, XI_PRM_DECIMATION_VERTICAL, &spectralBin));
|
||
|
||
return spectralBin;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::getSpatialBin()
|
||
{
|
||
int spatialBin = 0;
|
||
CE(xiGetParamInt(m_xiH, XI_PRM_BINNING_HORIZONTAL, &spatialBin));
|
||
|
||
// CE(xiGetParamInt(m_xiH, XI_PRM_DECIMATION_HORIZONTAL, &spatialBin));
|
||
|
||
return spatialBin;
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::setEffectiveWindow(int OffsetX, int width, int OffsetY, int height)
|
||
{
|
||
CE(xiSetParamInt(m_xiH, XI_PRM_WIDTH, width));
|
||
CE(xiSetParamInt(m_xiH, XI_PRM_OFFSET_X, OffsetX));
|
||
|
||
CE(xiSetParamInt(m_xiH, XI_PRM_HEIGHT, height));
|
||
CE(xiSetParamInt(m_xiH, XI_PRM_OFFSET_Y, OffsetY));
|
||
|
||
m_iEffectiveWindow_OffsetX = OffsetX;
|
||
m_iEffectiveWindow_width = width;
|
||
m_iEffectiveWindow_OffsetY = OffsetY;
|
||
m_iEffectiveWindow_height = height;
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::setEffectiveWindowRoi(int OffsetX, int width)
|
||
{
|
||
m_iEffectiveWindowRoi_OffsetX = OffsetX;
|
||
m_iEffectiveWindowRoi_width = width;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::getBufferSizeOfOneFrame()
|
||
{
|
||
// if(m_xiH==NULL)
|
||
// return 0;
|
||
//
|
||
// start();
|
||
//
|
||
// //清空image缓存
|
||
// memset(&m_image, 0, sizeof(m_image));
|
||
// m_image.size = sizeof(XI_IMG);
|
||
//
|
||
// CE(xiGetImage(m_xiH, 5000, &m_image)); // getting next image from the camera opened
|
||
//
|
||
// stop();
|
||
//
|
||
// return static_cast<int>(m_image.bp_size);
|
||
|
||
// //比实际大小（m_iEffectiveWindow_height * m_iEffectiveWindow_width * 2）大，why？
|
||
// int value = 0;
|
||
// xiGetParamInt(m_xiH, XI_PRM_IMAGE_PAYLOAD_SIZE, &value);
|
||
|
||
|
||
return m_iEffectiveWindow_height * m_iEffectiveWindow_width * 2;
|
||
}
|
||
|
||
float Iris::IrisXimeaImager::getTemperature()
|
||
{
|
||
float temperature = 0.0;
|
||
CE(xiGetParamFloat(m_xiH, XI_PRM_TEMP, &temperature));
|
||
|
||
return temperature;
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::setBufferPolicy(int bufferPolicy)
|
||
{
|
||
if (bufferPolicy==0)
|
||
{
|
||
xiSetParamInt(m_xiH, XI_PRM_BUFFER_POLICY, XI_BP_UNSAFE);
|
||
printf("Iris::IrisXimeaImager::connect---- XI_PRM_BUFFER_POLICY: XI_BP_UNSAFE\n");
|
||
}
|
||
else if (bufferPolicy==1)
|
||
{
|
||
xiSetParamInt(m_xiH, XI_PRM_BUFFER_POLICY, XI_BP_SAFE);
|
||
printf("Iris::IrisXimeaImager::connect---- XI_PRM_BUFFER_POLICY: XI_BP_SAFE\n");
|
||
}
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::setAcqBufferSize(int acqBufferSize)
|
||
{
|
||
XI_RETURN stat = XI_OK;
|
||
|
||
// set unit to 1 MiB
|
||
xiSetParamInt(m_xiH, XI_PRM_ACQ_BUFFER_SIZE_UNIT, 1024*1024);
|
||
int value = 0;
|
||
xiGetParamInt(m_xiH, XI_PRM_ACQ_BUFFER_SIZE, &value);
|
||
printf("Iris::IrisXimeaImager::connect---- XI_PRM_ACQ_BUFFER_SIZE: %d MiB.\n", value);
|
||
|
||
xiSetParamInt(m_xiH, XI_PRM_ACQ_BUFFER_SIZE, acqBufferSize);
|
||
|
||
xiGetParamInt(m_xiH, XI_PRM_ACQ_BUFFER_SIZE, &value);
|
||
printf("Iris::IrisXimeaImager::connect---- XI_PRM_ACQ_BUFFER_SIZE: %d MiB.\n", value);
|
||
|
||
// set maximum number of queue
|
||
int number_of_field_buffers = 0;
|
||
xiGetParamInt(m_xiH, XI_PRM_BUFFERS_QUEUE_SIZE XI_PRM_INFO_MAX, &number_of_field_buffers);
|
||
printf("Iris::IrisXimeaImager::connect---- XI_PRM_BUFFERS_QUEUE_SIZE XI_PRM_INFO_MAX: %d.\n", number_of_field_buffers);
|
||
HandleResult(stat,"xiGetParam (number_of_field_buffers maximum)");
|
||
xiSetParamInt(m_xiH, XI_PRM_BUFFERS_QUEUE_SIZE, number_of_field_buffers);
|
||
HandleResult(stat,"xiSetParam (number_of_field_buffers)");
|
||
}
|
||
|
||
Iris::IrisXimeaImager::IrisXimeaImager()
|
||
{
|
||
m_xiH=NULL;
|
||
|
||
std::cout<<"ximeaControlDll 版本："<< "21." <<std::endl;
|
||
}
|
||
|
||
Iris::IrisXimeaImager::~IrisXimeaImager()
|
||
{
|
||
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::connect(const char *camera_serial_number)
|
||
{
|
||
printf("Iris::IrisXimeaImager::connect----1 打开相机(xiOpenDevice)\n");
|
||
CE(xiOpenDevice(0, &m_xiH));//没有插上ximea相机,这句代码都过不去
|
||
|
||
//add-----------------------------------------------------------------------------------------------------------------------
|
||
XI_RETURN stat = XI_OK;
|
||
|
||
int payload=0;
|
||
stat = xiGetParamInt(m_xiH, XI_PRM_IMAGE_PAYLOAD_SIZE, &payload);
|
||
HandleResult(stat,"xiGetParam (payload)");
|
||
|
||
int transport_buffer_size_default = 0;
|
||
int transport_buffer_size_increment = 0;
|
||
int transport_buffer_size_minimum = 0;
|
||
// get default transport buffer size - that should be OK on all controllers
|
||
stat = xiGetParamInt(m_xiH, XI_PRM_ACQ_TRANSPORT_BUFFER_SIZE, &transport_buffer_size_default);
|
||
HandleResult(stat,"xiGetParamInt (transport buffer size)");
|
||
stat = xiGetParamInt(m_xiH, XI_PRM_ACQ_TRANSPORT_BUFFER_SIZE XI_PRM_INFO_INCREMENT, &transport_buffer_size_increment);
|
||
HandleResult(stat,"xiGetParamInt (transport buffer size increment)");
|
||
stat = xiGetParamInt(m_xiH, XI_PRM_ACQ_TRANSPORT_BUFFER_SIZE XI_PRM_INFO_MIN, &transport_buffer_size_minimum);
|
||
HandleResult(stat,"xiGetParamInt (transport buffer size minimum)");
|
||
|
||
// check if payload size is less than default transport buffer size
|
||
if(payload < transport_buffer_size_default + transport_buffer_size_increment)
|
||
{
|
||
// use optimized transport buffer size, as nearest increment to payload
|
||
int transport_buffer_size = payload;
|
||
if (transport_buffer_size_increment)
|
||
{
|
||
// round up to nearest increment
|
||
int remainder = transport_buffer_size % transport_buffer_size_increment;
|
||
if (remainder)
|
||
transport_buffer_size += transport_buffer_size_increment - remainder;
|
||
}
|
||
// check the minimum
|
||
if (transport_buffer_size < transport_buffer_size_minimum)
|
||
transport_buffer_size = transport_buffer_size_minimum;
|
||
stat = xiSetParamInt(m_xiH, XI_PRM_ACQ_TRANSPORT_BUFFER_SIZE, transport_buffer_size);
|
||
HandleResult(stat,"xiSetParam (transport buffer size)");
|
||
}
|
||
//add---------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
// set unit to 1 MiB
|
||
xiSetParamInt(m_xiH, XI_PRM_ACQ_BUFFER_SIZE_UNIT, 1024*1024);
|
||
int value = 0;
|
||
xiGetParamInt(m_xiH, XI_PRM_ACQ_BUFFER_SIZE, &value);
|
||
printf("Iris::IrisXimeaImager::connect---- XI_PRM_ACQ_BUFFER_SIZE: %d MiB.\n", value);
|
||
|
||
|
||
int NUM_THREADS = 0;
|
||
xiGetParamInt(m_xiH, XI_PRM_PROC_NUM_THREADS, &NUM_THREADS);
|
||
printf("Iris::IrisXimeaImager::connect---- XI_PRM_PROC_NUM_THREADS默认值为%d\n", NUM_THREADS);
|
||
xiSetParamInt(m_xiH, XI_PRM_PROC_NUM_THREADS, 8);
|
||
|
||
//设置数据格式
|
||
printf("Iris::IrisXimeaImager::connect----2 设置数据格式(xiSetParamInt)\n");
|
||
CE(xiSetParamInt(m_xiH, XI_PRM_IMAGE_DATA_FORMAT, XI_RAW16));//Default value: XI_MONO8
|
||
// //设置packing, 使用xiGetImage接收影像时不执行unpacking
|
||
// CE(xiSetParamInt(m_xiH, XI_PRM_OUTPUT_DATA_BIT_DEPTH, 12));//set 12 bit transport data width
|
||
// CE(xiSetParamInt(m_xiH, XI_PRM_OUTPUT_DATA_PACKING, XI_ON));//enable packing
|
||
// //使用xiGetImage接收影像时不执行unpacking
|
||
// CE(xiSetParamInt(m_xiH, XI_PRM_IMAGE_DATA_FORMAT, XI_FRM_TRANSPORT_DATA));//in this case, the function xiGetImage just set pointer to transport-buffer without any processing
|
||
|
||
//判断数据格式设置是否成功
|
||
int dataFortmat;
|
||
CE(xiGetParamInt(m_xiH, XI_PRM_IMAGE_DATA_FORMAT, &dataFortmat));
|
||
if(dataFortmat==XI_RAW16)
|
||
{
|
||
printf("Iris::IrisXimeaImager::connect----当前数据格式设置成功, 设置为: XI_RAW16\n");
|
||
}
|
||
else if(dataFortmat==XI_FRM_TRANSPORT_DATA)
|
||
{
|
||
printf("Iris::IrisXimeaImager::connect----当前数据格式设置成功, 设置为: XI_FRM_TRANSPORT_DATA\n");
|
||
}
|
||
else
|
||
{
|
||
printf("Iris::IrisXimeaImager::connect----2 数据格式设置失败！\n");
|
||
printf("Iris::IrisXimeaImager::connect----当前数据格式为:%d\n",dataFortmat);
|
||
}
|
||
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::disconnect()
|
||
{
|
||
printf("Closing camera...\n");
|
||
CE(xiCloseDevice(m_xiH));
|
||
|
||
m_xiH=NULL;
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::start()
|
||
{
|
||
CE(xiStartAcquisition(m_xiH));
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::stop()
|
||
{
|
||
//printf("Stopping acquisition...\n");
|
||
CE(xiStopAcquisition(m_xiH));
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::get_imager_type(char *buffer, int buffer_size)
|
||
{
|
||
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::get_serial_number(char *buffer, int buffer_size)
|
||
{
|
||
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::get_camera_serial_number(char *buffer, int buffer_size)
|
||
{
|
||
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::generate_configuration_report(char *buffer, int buffer_size)
|
||
{
|
||
|
||
}
|
||
|
||
float Iris::IrisXimeaImager::get_coeff_a()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
float Iris::IrisXimeaImager::get_coeff_b()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
float Iris::IrisXimeaImager::get_coeff_c()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
double Iris::IrisXimeaImager::get_wavelength_at_band(const int band)
|
||
{
|
||
//sn008
|
||
float a=1.999564;
|
||
float b=-279.893;
|
||
//
|
||
float wavelength=band*m_fGain + m_fOffset;
|
||
return wavelength;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_frame_buffer_size_in_bytes()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
unsigned short *Iris::IrisXimeaImager::get_frame(unsigned short *buffer)
|
||
{
|
||
//清空image缓存
|
||
memset(&m_image, 0, sizeof(m_image));
|
||
m_image.size = sizeof(XI_IMG);
|
||
|
||
CE(xiGetImage(m_xiH, 5000, &m_image)); // getting next image from the camera opened
|
||
|
||
//方法１:memcpy
|
||
// memcpy(buffer,m_image.bp,m_image.bp_size);
|
||
// //方法2:此做法是错误的，虽然是指针，也是传值！
|
||
// buffer = (unsigned short *)m_image.bp;
|
||
|
||
// for(int i=0;i<m_iEffectiveWindow_height;i++)
|
||
// {
|
||
// memcpy(buffer+i*m_iEffectiveWindowRoi_width, (unsigned short *)m_image.bp + i*m_iEffectiveWindow_width + m_iEffectiveWindowRoi_OffsetX, m_iEffectiveWindowRoi_width*2);
|
||
// }
|
||
|
||
//强制将指针从高精度（uint64_t*）转换到低精度（unsigned short *），会有精度降低的问题???????????????????????????????????????????????????
|
||
return (unsigned short *)&m_timestampOfCamera;
|
||
}
|
||
|
||
uint64_t Iris::IrisXimeaImager::get_last_timestamp()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
uint64_t Iris::IrisXimeaImager::ticks_per_second()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::set_spectral_bin(int new_spectral_bin)
|
||
{
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_spectral_bin()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_min_spectral_bin()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_max_spectral_bin()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_band_count()
|
||
{
|
||
return m_iEffectiveWindow_height;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_start_band()
|
||
{
|
||
int WindowStartLine;
|
||
CE(xiGetParamInt(m_xiH, XI_PRM_OFFSET_Y, &WindowStartLine));
|
||
|
||
return WindowStartLine;
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::set_start_band(int band)
|
||
{
|
||
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_min_start_band()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_max_start_band()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_inc_start_band()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_end_band()
|
||
{
|
||
int height;
|
||
CE(xiGetParamInt(m_xiH, XI_PRM_HEIGHT, &height));
|
||
return get_start_band()+height;
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::set_end_band(int band)
|
||
{
|
||
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_min_end_band()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_max_end_band()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_inc_end_band()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_sample_count()
|
||
{
|
||
return m_iEffectiveWindow_width;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_start_sample()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::set_start_sample(int sample)
|
||
{
|
||
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_min_start_sample()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_max_start_sample()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_inc_start_sample()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_end_sample()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::set_end_sample(int sample)
|
||
{
|
||
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_min_end_sample()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_max_end_sample()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
int Iris::IrisXimeaImager::get_inc_end_sample()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::set_framerate(const double frames_per_second)
|
||
{
|
||
CE(xiSetParamInt(m_xiH, XI_PRM_ACQ_TIMING_MODE, XI_ACQ_TIMING_MODE_FRAME_RATE_LIMIT));
|
||
|
||
CE(xiSetParamFloat(m_xiH, XI_PRM_FRAMERATE, frames_per_second));
|
||
}
|
||
|
||
double Iris::IrisXimeaImager::get_framerate()
|
||
{
|
||
float framerate;
|
||
CE(xiGetParamFloat(m_xiH, XI_PRM_FRAMERATE, &framerate));
|
||
return framerate;
|
||
}
|
||
|
||
double Iris::IrisXimeaImager::get_min_framerate()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
double Iris::IrisXimeaImager::get_max_framerate()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
double Iris::IrisXimeaImager::get_min_integration_time()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
double Iris::IrisXimeaImager::get_max_integration_time()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::set_integration_time(const double microsecond)
|
||
{
|
||
CE(xiSetParamInt(m_xiH, XI_PRM_EXPOSURE, microsecond));//time_in_us(microseconds)
|
||
}
|
||
|
||
double Iris::IrisXimeaImager::get_integration_time()
|
||
{
|
||
float exposureTime;
|
||
CE(xiGetParamFloat(m_xiH, XI_PRM_EXPOSURE, &exposureTime));//time_in_us(microseconds)
|
||
return exposureTime;
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::set_gain(const double gain)
|
||
{
|
||
CE(xiSetParamFloat(m_xiH, XI_PRM_GAIN, gain));//gain_in_db
|
||
}
|
||
|
||
double Iris::IrisXimeaImager::get_gain()
|
||
{
|
||
float gain;
|
||
CE(xiGetParamFloat(m_xiH, XI_PRM_GAIN, &gain));
|
||
return gain;
|
||
}
|
||
|
||
double Iris::IrisXimeaImager::get_min_gain()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
double Iris::IrisXimeaImager::get_max_gain()
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::set_internal_trigger()
|
||
{
|
||
|
||
}
|
||
|
||
void Iris::IrisXimeaImager::set_external_trigger(unsigned int signal_line, bool rising_edge)
|
||
{
|
||
|
||
}
|
||
|
||
bool Iris::IrisXimeaImager::is_trigger_external()
|
||
{
|
||
return 0;
|
||
}
|