1006 lines
32 KiB
C++
1006 lines
32 KiB
C++
#include "Header_Files/ximeaimager.h"
|
||
|
||
XimeaImager::XimeaImager()
|
||
{
|
||
m_buffer=nullptr;
|
||
m_bRecordControl=false;
|
||
m_iFrameCounter=0;
|
||
m_iImagerState=100;
|
||
|
||
QString ximeaCfgFile = "/media/nvme/300TC/config/ximea.cfg";
|
||
m_configfile.setConfigfilePath(ximeaCfgFile.toStdString());
|
||
if(!m_configfile.isConfigfileExist())
|
||
m_configfile.createConfigFile();
|
||
m_configfile.parseConfigfile();
|
||
m_configfile.getWindowOffsety_HeightOfSpectral(m_iOffsetyOfSpectralBin1, m_iHeightOfSpectralBin1, "bin1");
|
||
m_configfile.getWindowOffsety_HeightOfSpectral(m_iOffsetyOfSpectralBin2, m_iHeightOfSpectralBin2, "bin2");
|
||
//检查 ximea.cfg 是否满足要求
|
||
if(m_iOffsetyOfSpectralBin2 != m_iOffsetyOfSpectralBin1 / 2)
|
||
{
|
||
std::cout<<"ximea.cfg 错误：m_iOffsetyOfSpectralBin2 != m_iOffsetyOfSpectralBin1 / 2!"<<std::endl;
|
||
}
|
||
if(m_iOffsetyOfSpectralBin2 % 2 != 0)
|
||
{
|
||
std::cout<<"ximea.cfg 错误：m_iOffsetyOfSpectralBin2 不是 2 的倍数，ximea相机不接受!"<<std::endl;
|
||
}
|
||
if(m_iHeightOfSpectralBin1 < m_iHeightOfSpectralBin2 * 2)
|
||
{
|
||
std::cout<<"ximea.cfg 错误：bin1 波段数小于 bin2 波段数的 2 倍!"<<std::endl;
|
||
}
|
||
|
||
|
||
m_recordTempThread=new QThread();
|
||
m_ximeaTemperature = new RecordXimeaTemperature(&m_imager);
|
||
m_ximeaTemperature->moveToThread(m_recordTempThread);
|
||
m_recordTempThread->start();
|
||
|
||
connect(this, SIGNAL(recordXimeaTemperatureSignal(QString)),m_ximeaTemperature, SLOT(recordTemperature(QString)));
|
||
|
||
writeData2DiskThread = new QThread();
|
||
writeData2Disk = new WriteData2Disk();
|
||
writeData2Disk->moveToThread(writeData2DiskThread);
|
||
writeData2DiskThread->start(QThread::HighestPriority);
|
||
connect(this, SIGNAL(startWriteDiskSignal()), writeData2Disk, SLOT(write2Disk()));
|
||
|
||
m_pool = new MemoryPool<DataBuffer>;
|
||
q = new queue<DataBuffer *>;
|
||
m_qFrameCounter = new queue<int>;
|
||
|
||
m_rgbImage = new rgbImage();
|
||
}
|
||
|
||
XimeaImager::~XimeaImager()
|
||
{
|
||
|
||
}
|
||
|
||
void XimeaImager::openImger()
|
||
{
|
||
if(m_iImagerState != 100)//如果相机已经打开或者已经出错，就直接返回
|
||
{
|
||
emit ximeaImageStatus(m_iImagerState);
|
||
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
//std::cout<<"XimeaImager::openImger111111111111111111111:正在打开相机!"<<std::endl;
|
||
m_imager.connect();
|
||
|
||
bool ret, ret1, ret2;
|
||
|
||
int spatialBin;
|
||
int spectralBin;
|
||
ret1 = m_configfile.getspatialBin(spatialBin);
|
||
ret2 = m_configfile.getSpectralBin(spectralBin);
|
||
if (ret1 & ret2)
|
||
{
|
||
bool haha = m_imager.setSpectralBin(spectralBin);
|
||
bool haha2 = m_imager.setSpatialBin(spatialBin);
|
||
|
||
emit binSignal(spatialBin, spectralBin);
|
||
std::cout<<"spectralBin："<< spectralBin <<std::endl;
|
||
std::cout<<"spatialBin："<< spatialBin <<std::endl;
|
||
}
|
||
|
||
float gain, offset;//用于生成头文件中的波长信息
|
||
ret = m_configfile.getGainOffsetOfSpectralBin1(gain, offset);
|
||
if (ret)
|
||
{
|
||
m_imager.setGainOffset(gain, offset);
|
||
}
|
||
|
||
int width = 0, offsetx = 0, height = 0, offsety = 0;
|
||
ret = m_configfile.getEffectiveWindow(width, offsetx, height, offsety);
|
||
if (ret)
|
||
{
|
||
m_imager.setEffectiveWindow(offsetx, width, offsety, height);
|
||
m_rgbImage->SetRgbImageWidthAndHeight(height, width, 20);
|
||
std::cout<<"height："<< height <<std::endl;
|
||
std::cout<<"width："<< width <<std::endl;
|
||
std::cout<<"每帧字节数："<< width * height * 2 <<std::endl;
|
||
}
|
||
|
||
// int width_roi = 0, offsetx_roi = 0;
|
||
// ret = m_configfile.getEffectiveWindowRoi(width_roi, offsetx_roi);
|
||
// if (ret)
|
||
// {
|
||
// m_imager.setEffectiveWindowRoi(offsetx_roi, width_roi);
|
||
// }
|
||
|
||
int bufferPolicy, acqBufferSize;
|
||
ret1 = m_configfile.getBufferPolicy(bufferPolicy);
|
||
if (ret1)
|
||
{
|
||
m_imager.setBufferPolicy(bufferPolicy);
|
||
}
|
||
ret1 = m_configfile.getAcqBufferSize(acqBufferSize);
|
||
if (ret1)
|
||
{
|
||
m_imager.setAcqBufferSize(acqBufferSize);
|
||
}
|
||
|
||
setFramerate(100);
|
||
|
||
//经验证：frameSizeManual和frameSizeAuto相等
|
||
int frameSizeManual = m_imager.get_band_count()*m_imager.get_sample_count()*2;
|
||
int frameSizeAuto = m_imager.getBufferSizeOfOneFrame();
|
||
|
||
m_iFrameSizeInByte = frameSizeAuto;
|
||
std::cout<<"每一帧的字节数：-------------------------------"<< m_iFrameSizeInByte <<std::endl;
|
||
|
||
m_buffer = new unsigned short[m_iFrameSizeInByte];
|
||
|
||
m_iImagerState = 101;
|
||
emit ximeaImageStatus(m_iImagerState);
|
||
|
||
QDateTime curDateTime = QDateTime::currentDateTime();
|
||
QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
|
||
m_ximeaTemperatureCSVPath = QDir::cleanPath(QString::fromStdString("/home/programRunLog/hyperspectralLog") + QDir::separator() + "ximeaTemperature_" + currentTime + ".csv");
|
||
// m_ximeaTemperatureCSVPath = "/home/ximeaTemperature.csv";
|
||
emit recordXimeaTemperatureSignal(m_ximeaTemperatureCSVPath);
|
||
}
|
||
catch(int xiApiErrorCodes)
|
||
{
|
||
std::cout<<"XimeaImager::openImger----------------:ERROR!"<<std::endl;
|
||
|
||
processXiApiErrorCodes(xiApiErrorCodes);
|
||
}
|
||
catch(char const* e1)
|
||
{
|
||
std::cout<<"char *e---------!"<<std::endl;
|
||
}
|
||
}
|
||
|
||
void XimeaImager::closeImger()
|
||
{
|
||
m_ximeaTemperature->stopRecordTemperature();
|
||
|
||
if(m_iImagerState==100)
|
||
{
|
||
emit ximeaImageStatus(m_iImagerState);
|
||
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
m_imager.disconnect();
|
||
|
||
m_iImagerState=100;
|
||
emit ximeaImageStatus(m_iImagerState);
|
||
}
|
||
catch(int xiApiErrorCodes)
|
||
{
|
||
std::cout<<"XimeaImager::closeImger-------------------!"<<std::endl;
|
||
processXiApiErrorCodes(xiApiErrorCodes);
|
||
}
|
||
|
||
|
||
}
|
||
|
||
void XimeaImager::setFramerate(double framerate)
|
||
{
|
||
try
|
||
{
|
||
m_imager.set_framerate(framerate);
|
||
|
||
int maxExposureTimeInUs=1/framerate*1000000*0.01;
|
||
setExposureTime(maxExposureTimeInUs);
|
||
// setExposureTime(1000);
|
||
|
||
m_iImagerState=102;
|
||
emit ximeaImageStatus(m_iImagerState);
|
||
|
||
emit frameRateSignal(framerate);
|
||
}
|
||
catch(int xiApiErrorCodes)
|
||
{
|
||
processXiApiErrorCodes(xiApiErrorCodes);
|
||
}
|
||
}
|
||
|
||
double XimeaImager::getExposureTime()
|
||
{
|
||
double exposureTime;
|
||
try
|
||
{
|
||
exposureTime=m_imager.get_integration_time();
|
||
return exposureTime;
|
||
}
|
||
catch(int xiApiErrorCodes)
|
||
{
|
||
processXiApiErrorCodes(xiApiErrorCodes);
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
double XimeaImager::setExposureTime(float exposureTime_in_us)
|
||
{
|
||
double integrationTime2Return;
|
||
|
||
try
|
||
{
|
||
//计算最大积分时间
|
||
float currentFramerate=getFramerate();
|
||
float maxExposureTime_in_us=1/currentFramerate*1000000;
|
||
|
||
//确保设置的积分时间比最大积分时间小
|
||
if(exposureTime_in_us<maxExposureTime_in_us)
|
||
{
|
||
|
||
m_imager.set_integration_time(exposureTime_in_us);
|
||
|
||
}
|
||
else
|
||
{
|
||
m_imager.set_integration_time(maxExposureTime_in_us);
|
||
}
|
||
|
||
//返回设置的积分时间
|
||
integrationTime2Return=m_imager.get_integration_time();
|
||
|
||
return integrationTime2Return;
|
||
}
|
||
catch(int xiApiErrorCodes)
|
||
{
|
||
processXiApiErrorCodes(xiApiErrorCodes);
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
int XimeaImager::wrapSetExposureTime(float exposureTime_in_us)
|
||
{
|
||
double exposureTime = setExposureTime(exposureTime_in_us);
|
||
|
||
m_imager.start();
|
||
m_imager.get_frame(m_buffer);
|
||
m_imager.stop();
|
||
|
||
int maxValueOfOneFrame = getMaxValueOfOneFrame((short unsigned int*)m_imager.m_image.bp,m_imager.get_band_count()*m_imager.get_sample_count());
|
||
|
||
m_iImagerState=103;
|
||
emit ximeaImageStatus(m_iImagerState);
|
||
|
||
emit autoExposeMaxValueOfOneFrame(maxValueOfOneFrame, exposureTime/1000);
|
||
|
||
return maxValueOfOneFrame;
|
||
}
|
||
|
||
double XimeaImager::autoExposure()
|
||
{
|
||
double exposureTime;
|
||
try
|
||
{
|
||
//方式１：在曝光时的帧率前提下，从最大曝光时间开始循环采集
|
||
int maxValueOfOneFrame;
|
||
float suitableMaxValue=4095 * 0.8;
|
||
|
||
double framerate = m_imager.get_framerate();
|
||
double maxExposureTime = 1/framerate*1000000*0.95;//0.95目的：避免曝光时间超过最大，而造成帧率降低
|
||
exposureTime=setExposureTime(maxExposureTime);
|
||
|
||
bool bIsAutoExposureOk=false;
|
||
while(!bIsAutoExposureOk)
|
||
{
|
||
std::cout<<"自动曝光本次时间为："<< exposureTime <<std::endl;
|
||
|
||
m_imager.start();
|
||
m_imager.get_frame(m_buffer);
|
||
m_imager.stop();
|
||
|
||
maxValueOfOneFrame=getMaxValueOfOneFrame((short unsigned int*)m_imager.m_image.bp,m_imager.get_band_count()*m_imager.get_sample_count());
|
||
printf("本帧最大值为: %d.\n",maxValueOfOneFrame);
|
||
|
||
if(maxValueOfOneFrame <= suitableMaxValue)
|
||
{
|
||
bIsAutoExposureOk=true;
|
||
}
|
||
else
|
||
{
|
||
exposureTime = exposureTime*0.95;
|
||
exposureTime=setExposureTime(exposureTime);
|
||
}
|
||
}
|
||
|
||
|
||
// //方式2：
|
||
// int baseExposureTime_in_us=5000;
|
||
// float suitableMaxValue=4095 * 0.8;
|
||
// int maxValueOfOneFrame;
|
||
|
||
// setExposureTime(baseExposureTime_in_us);
|
||
|
||
// m_imager.start();
|
||
// m_imager.get_frame(m_buffer);
|
||
// m_imager.stop();
|
||
|
||
// std::cout<<"1111111111111111111111111111111111!"<<std::endl;
|
||
// maxValueOfOneFrame=getMaxValueOfOneFrame(m_buffer,m_imager.get_band_count()*m_imager.get_sample_count());
|
||
// std::cout<<"2222222222222222222222222222222222!"<<std::endl;
|
||
|
||
// float scale=suitableMaxValue/maxValueOfOneFrame;
|
||
// float suitableExposureTime=baseExposureTime_in_us * scale;
|
||
// exposureTime=setExposureTime(suitableExposureTime);
|
||
|
||
m_iImagerState=103;
|
||
emit ximeaImageStatus(m_iImagerState);
|
||
emit autoExposeMaxValueOfOneFrame(maxValueOfOneFrame, exposureTime/1000);
|
||
|
||
std::cout<<"自动曝光完成!"<<std::endl;
|
||
return exposureTime;
|
||
}
|
||
catch(int xiApiErrorCodes)
|
||
{
|
||
processXiApiErrorCodes(xiApiErrorCodes);
|
||
|
||
std::cout<<"自动曝光失败!"<<std::endl;
|
||
return -1;
|
||
}
|
||
|
||
|
||
}
|
||
|
||
double XimeaImager::getFramerate()
|
||
{
|
||
double framerate;
|
||
|
||
try
|
||
{
|
||
framerate=m_imager.get_framerate();
|
||
|
||
return framerate;
|
||
}
|
||
catch(int xiApiErrorCodes)
|
||
{
|
||
processXiApiErrorCodes(xiApiErrorCodes);
|
||
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
void XimeaImager::setGain(double gain)
|
||
{
|
||
try
|
||
{
|
||
m_imager.set_gain(gain);
|
||
}
|
||
catch(int xiApiErrorCodes)
|
||
{
|
||
processXiApiErrorCodes(xiApiErrorCodes);
|
||
}
|
||
}
|
||
|
||
double XimeaImager::getGain()
|
||
{
|
||
try
|
||
{
|
||
return m_imager.get_gain();
|
||
}
|
||
catch(int xiApiErrorCodes)
|
||
{
|
||
processXiApiErrorCodes(xiApiErrorCodes);
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
int XimeaImager::getSampleCount()
|
||
{
|
||
try
|
||
{
|
||
int sampleCount=m_imager.get_sample_count();
|
||
return sampleCount;
|
||
}
|
||
catch(int xiApiErrorCodes)
|
||
{
|
||
processXiApiErrorCodes(xiApiErrorCodes);
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
int XimeaImager::getBandCount()
|
||
{
|
||
int bandCount;
|
||
|
||
try
|
||
{
|
||
bandCount=m_imager.get_band_count();
|
||
return bandCount;
|
||
}
|
||
catch(int xiApiErrorCodes)
|
||
{
|
||
processXiApiErrorCodes(xiApiErrorCodes);
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
int XimeaImager::getWindowStartBand()
|
||
{
|
||
int windowStartBand;
|
||
|
||
try
|
||
{
|
||
windowStartBand=m_imager.get_start_band();
|
||
return windowStartBand;
|
||
}
|
||
catch(int xiApiErrorCodes)
|
||
{
|
||
processXiApiErrorCodes(xiApiErrorCodes);
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
int XimeaImager::getWindowEndBand()
|
||
{
|
||
int windowEndBand;
|
||
|
||
try
|
||
{
|
||
windowEndBand=m_imager.get_end_band();
|
||
return windowEndBand;
|
||
}
|
||
catch(int xiApiErrorCodes)
|
||
{
|
||
processXiApiErrorCodes(xiApiErrorCodes);
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
double XimeaImager::geWavelengthAtBand(int x)
|
||
{
|
||
double wavelengthAtBand;
|
||
|
||
try
|
||
{
|
||
wavelengthAtBand=m_imager.get_wavelength_at_band(x);
|
||
return wavelengthAtBand;
|
||
}
|
||
catch(int xiApiErrorCodes)
|
||
{
|
||
processXiApiErrorCodes(xiApiErrorCodes);
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
int XimeaImager::getMaxValueOfOneFrame(unsigned short * data, int numberOfPixel)
|
||
{
|
||
//排序
|
||
//bubbleSort(data,1000);
|
||
|
||
|
||
//计算出最大的10%值的平均值
|
||
unsigned short maxValue=0;
|
||
for(int i=0;i<numberOfPixel;i++)
|
||
{
|
||
// std::cout<<"像素值为："<< *(data + i) <<std::endl;
|
||
if (*(data + i)>maxValue)
|
||
{
|
||
//std::cout<<"像素值为："<< *(data + i) <<std::endl;
|
||
maxValue=*(data + i);
|
||
}
|
||
if (*(data + i)==65535)
|
||
{
|
||
int a=0;
|
||
}
|
||
}
|
||
|
||
return maxValue;
|
||
}
|
||
|
||
int XimeaImager::getImagerState() const
|
||
{
|
||
return m_iImagerState;
|
||
}
|
||
|
||
double XimeaImager::calculateTimeDifferenceBetweenSbgAndximea(XI_IMG * image, double timeDifferenceBetweenSbgAndOS)
|
||
{
|
||
printf("XimeaImager::calculateTimeDifferenceBetweenSystemAndximea--timeDifferenceBetweenSbgAndOS: %f s\n", timeDifferenceBetweenSbgAndOS);
|
||
|
||
double ximeaTime=image->tsSec + image->tsUSec/1000000;
|
||
|
||
printf("XimeaImager::calculateTimeDifferenceBetweenSystemAndximea--ximeaTime: %f s\n", ximeaTime);
|
||
|
||
//获取系统时间（纳秒）
|
||
struct timespec systemTime;
|
||
clock_gettime(CLOCK_REALTIME,&systemTime);
|
||
tm systemTime_rili;
|
||
localtime_r(&systemTime.tv_sec, &systemTime_rili);
|
||
|
||
double secondSystem=(systemTime_rili.tm_mday-1)*24*60*60+systemTime_rili.tm_hour*60*60+systemTime_rili.tm_min*60+systemTime_rili.tm_sec;
|
||
double timeOS=secondSystem+static_cast<double>(systemTime.tv_nsec)/1000000000;
|
||
|
||
printf("XimeaImager::calculateTimeDifferenceBetweenSystemAndximea--osTime: %f s\n", timeOS);
|
||
|
||
|
||
//计算系统时间和gps时间之间的差距
|
||
double timeDifferenceBetweenSbgAndximea = timeOS - timeDifferenceBetweenSbgAndOS - ximeaTime;
|
||
|
||
printf("XimeaImager::calculateTimeDifferenceBetweenSystemAndximea--timeDifferenceBetweenSbgAndximea: %f s\n", timeDifferenceBetweenSbgAndximea);
|
||
|
||
return timeDifferenceBetweenSbgAndximea;
|
||
}
|
||
|
||
void XimeaImager::startRecord(double TimeDifferenceBetweensOSAndSbg,QString baseFileName)
|
||
{
|
||
m_ximeaTemperature->stopRecordTemperature();//开始采集影像前，停止获取相机的温度，以免降低帧率；
|
||
try
|
||
{
|
||
if(m_iImagerState <= 99 || m_iImagerState==100 || m_iImagerState==104)
|
||
{
|
||
emit ximeaImageStatus(m_iImagerState);
|
||
|
||
return;
|
||
}
|
||
|
||
m_iImagerStateTemp=m_iImagerState;
|
||
|
||
m_iImagerState=104;
|
||
emit ximeaImageStatus(m_iImagerState);
|
||
|
||
char * timeFormat="%Y%m%d_%H%M%S";
|
||
QString timeStr = formatTimeStr(timeFormat);
|
||
printf("开始采集：%s!\n", timeStr.toStdString().c_str());
|
||
|
||
m_iFrameCounter=0;
|
||
m_bRecordControl=true;
|
||
|
||
m_baseFileName=baseFileName;
|
||
|
||
std::cout << "曝光时间为：" << getExposureTime()/1000 << "ms" <<std::endl;
|
||
|
||
using namespace std;
|
||
// ofstream timesFileHandle(timesFileName.toStdString()+"_ofstream");
|
||
|
||
int number_WriteDisk = 100;
|
||
writeData2Disk->setParm(q, m_qFrameCounter,m_baseFileName,m_iFrameSizeInByte, number_WriteDisk, m_pool, m_rgbImage);
|
||
emit startWriteDiskSignal();
|
||
|
||
int indexofbuff;
|
||
DataBuffer * buffer;
|
||
|
||
QString timesFileName=m_baseFileName+".times";
|
||
FILE *hHimesFile=fopen(timesFileName.toStdString().c_str(),"w+");
|
||
// ofstream timesFile(timesFileName.toStdString());
|
||
double timeDifferenceBetweenSbgAndXimea;
|
||
double * sbgTimeBuffer = new double[number_WriteDisk];
|
||
|
||
m_imager.start();
|
||
struct timeval timeStart, timeEnd;
|
||
double runTime=0;
|
||
gettimeofday(&timeStart, NULL);
|
||
while (m_bRecordControl)
|
||
{
|
||
unsigned short *x=m_imager.get_frame(m_buffer);
|
||
m_iFrameCounter+=1;
|
||
|
||
if (m_iFrameCounter == 1)
|
||
{
|
||
timeDifferenceBetweenSbgAndXimea = calculateTimeDifferenceBetweenSbgAndximea(&m_imager.m_image, TimeDifferenceBetweensOSAndSbg);
|
||
}
|
||
|
||
indexofbuff = m_iFrameCounter % number_WriteDisk;
|
||
|
||
if (indexofbuff == 1)
|
||
{
|
||
r_qtx.lock();
|
||
buffer = m_pool->newElement();
|
||
r_qtx.unlock();
|
||
}
|
||
|
||
if (indexofbuff == 0)
|
||
{
|
||
memcpy((void *)buffer->data + (number_WriteDisk - 1) * m_iFrameSizeInByte,m_imager.m_image.bp,m_iFrameSizeInByte);
|
||
sbgTimeBuffer[number_WriteDisk - 1] = getSbgTime(&m_imager.m_image, timeDifferenceBetweenSbgAndXimea);
|
||
}
|
||
else
|
||
{
|
||
memcpy((void *)buffer->data + (indexofbuff - 1) * m_iFrameSizeInByte,m_imager.m_image.bp,m_iFrameSizeInByte);
|
||
sbgTimeBuffer[indexofbuff - 1] = getSbgTime(&m_imager.m_image, timeDifferenceBetweenSbgAndXimea);
|
||
}
|
||
|
||
if (indexofbuff == 0)
|
||
{
|
||
r_qtx.lock();
|
||
q->push(buffer);
|
||
m_qFrameCounter->push(number_WriteDisk);
|
||
r_qtx.unlock();
|
||
|
||
for (int i = 0; i < number_WriteDisk; ++i)
|
||
{
|
||
fprintf(hHimesFile,"%f\n",sbgTimeBuffer[i]);
|
||
}
|
||
}
|
||
}
|
||
if (indexofbuff != 0)
|
||
{
|
||
r_qtx.lock();
|
||
q->push(buffer);
|
||
m_qFrameCounter->push(indexofbuff);
|
||
r_qtx.unlock();
|
||
|
||
for (int i = 0; i < indexofbuff; ++i)
|
||
{
|
||
fprintf(hHimesFile,"%f\n",sbgTimeBuffer[i]);
|
||
}
|
||
|
||
std::cout << "没凑满: " << indexofbuff <<std::endl;
|
||
}
|
||
gettimeofday(&timeEnd, NULL);
|
||
runTime = (timeEnd.tv_sec - timeStart.tv_sec ) + (double)(timeEnd.tv_usec -timeStart.tv_usec)/1000000;
|
||
m_imager.stop();
|
||
writeData2Disk->exitWriteData2Disk();
|
||
writeHdr();
|
||
|
||
delete[] sbgTimeBuffer;
|
||
|
||
double frameInTheory=runTime * getFramerate();
|
||
|
||
double frameLossed = m_imager.m_image.acq_nframe - m_iFrameCounter;
|
||
double frameLossRate = frameLossed / m_imager.m_image.acq_nframe;
|
||
|
||
std::cout<<"当前采集文件为: "<<baseFileName.toStdString()<< ".bil" <<std::endl;
|
||
std::cout<<"采集时间为: "<<runTime<< "s" <<std::endl;
|
||
std::cout<<"当前帧率为: "<<getFramerate() << "hz" <<std::endl;
|
||
std::cout<<"每秒数据量为: "<<getFramerate()*m_iFrameSizeInByte/(1024*1024)<<"MB"<<std::endl;
|
||
std::cout<<"理论采集帧数为: "<<m_imager.m_image.acq_nframe<<std::endl;
|
||
std::cout<<"实际采集帧数为："<<m_iFrameCounter<<std::endl;
|
||
std::cout<<"丢失帧数为: "<<frameLossed<<std::endl;
|
||
std::cout<<"丢帧率为: "<<frameLossRate * 100<< "%" <<std::endl;
|
||
|
||
fclose(hHimesFile);
|
||
// timesFileHandle.close();
|
||
// timesFile.close();
|
||
|
||
timeStr = formatTimeStr(timeFormat);
|
||
printf("停止采集：%s!\n", timeStr.toStdString().c_str());
|
||
|
||
m_iImagerState=m_iImagerStateTemp;
|
||
emit ximeaImageStatus(m_iImagerState);
|
||
|
||
emit recordFinished();
|
||
|
||
emit recordXimeaTemperatureSignal(m_ximeaTemperatureCSVPath);//停止采集影像后，继续获取传感器温度；
|
||
}
|
||
catch(int xiApiErrorCodes)
|
||
{
|
||
processXiApiErrorCodes(xiApiErrorCodes);
|
||
}
|
||
}
|
||
|
||
void XimeaImager::writeHdr()
|
||
{
|
||
using namespace std;
|
||
|
||
QString hdrPath=m_baseFileName+".hdr";
|
||
|
||
ofstream hdrFileHandle(hdrPath.toStdString());
|
||
hdrFileHandle << "ENVI\n";
|
||
|
||
QString SN;
|
||
m_configfile.getSN(SN);
|
||
hdrFileHandle << "SN = " << SN.toStdString() << "\n";
|
||
|
||
hdrFileHandle << "interleave = bil\n";
|
||
hdrFileHandle << "byte order = 0\n";
|
||
hdrFileHandle << "data type = 2\n";
|
||
//hdrFileHandle << "bit depth = 12\n";
|
||
|
||
hdrFileHandle << "samples = " << getSampleCount() << "\n";
|
||
hdrFileHandle << "bands = " << getBandCount() << "\n";
|
||
hdrFileHandle << "lines = " << m_iFrameCounter << "\n";
|
||
hdrFileHandle << "sample binning = " << m_imager.getSpatialBin() << "\n";
|
||
hdrFileHandle << "spectral binning = " << m_imager.getSpectralBin() << "\n";
|
||
|
||
hdrFileHandle << "framerate = " << getFramerate() << "\n";
|
||
hdrFileHandle << "shutter = " << getExposureTime()/1000 << "\n";
|
||
hdrFileHandle << "shutter units = milliseconds\n";
|
||
hdrFileHandle << "gain = " << getGain() << "\n";
|
||
|
||
hdrFileHandle << "wavelength units = nanometers\n";
|
||
hdrFileHandle << "wavelength = {";
|
||
//hdrFileHandle << std::setprecision(5);
|
||
|
||
if (m_imager.getSpectralBin() == 1)
|
||
{
|
||
for (int i = getWindowStartBand(); i < getWindowEndBand(); i++)
|
||
{
|
||
hdrFileHandle << geWavelengthAtBand(i);
|
||
if (i < getWindowEndBand() - 1)
|
||
hdrFileHandle << ", ";
|
||
else
|
||
{
|
||
printf("头文件中写入了多少个波段:%d\n",i-getWindowStartBand()+1);//???????????????
|
||
}
|
||
}
|
||
}
|
||
else if (m_imager.getSpectralBin() == 2)
|
||
{
|
||
int counter = 0;
|
||
for (int i = m_iOffsetyOfSpectralBin2; i < m_iOffsetyOfSpectralBin2 + m_iHeightOfSpectralBin2; i++)
|
||
{
|
||
if (i*2 + 1 > m_iOffsetyOfSpectralBin1 + m_iHeightOfSpectralBin1)
|
||
{
|
||
printf("XimeaImager::writeHdr 出现错误：窗口中，光谱 bin1 波段数小于 bin2 的 2 倍。\n");
|
||
break;
|
||
}
|
||
|
||
hdrFileHandle << (geWavelengthAtBand(i*2) + geWavelengthAtBand(i*2 + 1)) / 2;
|
||
counter++;
|
||
if (i < m_iOffsetyOfSpectralBin2 + m_iHeightOfSpectralBin2 - 1)
|
||
hdrFileHandle << ", ";
|
||
else
|
||
{
|
||
printf("头文件中写入了多少个波段:%d\n", counter);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
hdrFileHandle << "}\n";
|
||
hdrFileHandle.close();
|
||
}
|
||
|
||
/*
|
||
#define MM40_OK 0 //!< Function call succeeded
|
||
#define MM40_INVALID_HANDLE 1 //!< Invalid handle
|
||
#define MM40_READREG 2 //!< Register read error
|
||
#define MM40_WRITEREG 3 //!< Register write error
|
||
#define MM40_FREE_RESOURCES 4 //!< Freeing resources error
|
||
#define MM40_FREE_CHANNEL 5 //!< Freeing channel error
|
||
#define MM40_FREE_BANDWIDTH 6 //!< Freeing bandwith error
|
||
#define MM40_READBLK 7 //!< Read block error
|
||
#define MM40_WRITEBLK 8 //!< Write block error
|
||
#define MM40_NO_IMAGE 9 //!< No image
|
||
#define MM40_TIMEOUT 10 //!< Timeout
|
||
#define MM40_INVALID_ARG 11 //!< Invalid arguments supplied
|
||
#define MM40_NOT_SUPPORTED 12 //!< Not supported
|
||
#define MM40_ISOCH_ATTACH_BUFFERS 13 //!< Attach buffers error
|
||
#define MM40_GET_OVERLAPPED_RESULT 14 //!< Overlapped result
|
||
#define MM40_MEMORY_ALLOCATION 15 //!< Memory allocation error
|
||
#define MM40_DLLCONTEXTISNULL 16 //!< DLL context is NULL
|
||
#define MM40_DLLCONTEXTISNONZERO 17 //!< DLL context is non zero
|
||
#define MM40_DLLCONTEXTEXIST 18 //!< DLL context exists
|
||
#define MM40_TOOMANYDEVICES 19 //!< Too many devices connected
|
||
#define MM40_ERRORCAMCONTEXT 20 //!< Camera context error
|
||
#define MM40_UNKNOWN_HARDWARE 21 //!< Unknown hardware
|
||
#define MM40_INVALID_TM_FILE 22 //!< Invalid TM file
|
||
#define MM40_INVALID_TM_TAG 23 //!< Invalid TM tag
|
||
#define MM40_INCOMPLETE_TM 24 //!< Incomplete TM
|
||
#define MM40_BUS_RESET_FAILED 25 //!< Bus reset error
|
||
#define MM40_NOT_IMPLEMENTED 26 //!< Not implemented
|
||
#define MM40_SHADING_TOOBRIGHT 27 //!< Shading is too bright
|
||
#define MM40_SHADING_TOODARK 28 //!< Shading is too dark
|
||
#define MM40_TOO_LOW_GAIN 29 //!< Gain is too low
|
||
#define MM40_INVALID_BPL 30 //!< Invalid sensor defect correction list
|
||
#define MM40_BPL_REALLOC 31 //!< Error while sensor defect correction list reallocation
|
||
#define MM40_INVALID_PIXEL_LIST 32 //!< Invalid pixel list
|
||
#define MM40_INVALID_FFS 33 //!< Invalid Flash File System
|
||
#define MM40_INVALID_PROFILE 34 //!< Invalid profile
|
||
#define MM40_INVALID_CALIBRATION 35 //!< Invalid calibration
|
||
#define MM40_INVALID_BUFFER 36 //!< Invalid buffer
|
||
#define MM40_INVALID_DATA 38 //!< Invalid data
|
||
#define MM40_TGBUSY 39 //!< Timing generator is busy
|
||
#define MM40_IO_WRONG 40 //!< Wrong operation open/write/read/close
|
||
#define MM40_ACQUISITION_ALREADY_UP 41 //!< Acquisition already started
|
||
#define MM40_OLD_DRIVER_VERSION 42 //!< Old version of device driver installed to the system.
|
||
#define MM40_GET_LAST_ERROR 43 //!< To get error code please call GetLastError function.
|
||
#define MM40_CANT_PROCESS 44 //!< Data cannot be processed
|
||
#define MM40_ACQUISITION_STOPED 45 //!< Acquisition is stopped. It needs to be started to perform operation.
|
||
#define MM40_ACQUISITION_STOPED_WERR 46 //!< Acquisition has been stopped with an error.
|
||
#define MM40_INVALID_INPUT_ICC_PROFILE 47 //!< Input ICC profile missing or corrupted
|
||
#define MM40_INVALID_OUTPUT_ICC_PROFILE 48 //!< Output ICC profile missing or corrupted
|
||
#define MM40_DEVICE_NOT_READY 49 //!< Device not ready to operate
|
||
#define MM40_SHADING_TOOCONTRAST 50 //!< Shading is too contrast
|
||
#define MM40_ALREADY_INITIALIZED 51 //!< Module already initialized
|
||
#define MM40_NOT_ENOUGH_PRIVILEGES 52 //!< Application does not have enough privileges (one or more app)
|
||
#define MM40_NOT_COMPATIBLE_DRIVER 53 //!< Installed driver is not compatible with current software
|
||
#define MM40_TM_INVALID_RESOURCE 54 //!< TM file was not loaded successfully from resources
|
||
#define MM40_DEVICE_HAS_BEEN_RESETED 55 //!< Device has been reset, abnormal initial state
|
||
#define MM40_NO_DEVICES_FOUND 56 //!< No Devices Found
|
||
#define MM40_RESOURCE_OR_FUNCTION_LOCKED 57 //!< Resource (device) or function locked by mutex
|
||
#define MM40_BUFFER_SIZE_TOO_SMALL 58 //!< Buffer provided by user is too small
|
||
#define MM40_COULDNT_INIT_PROCESSOR 59 //!< Could not initialize processor.
|
||
#define MM40_NOT_INITIALIZED 60 //!< The object/module/procedure/process being referred to has not been started.
|
||
#define MM40_RESOURCE_NOT_FOUND 61 //!< Resource not found(could be processor, file, item...).
|
||
*/
|
||
|
||
void XimeaImager::processXiApiErrorCodes(int xiApiErrorCodes)
|
||
{
|
||
using namespace std;
|
||
switch (xiApiErrorCodes)
|
||
{
|
||
case 1:
|
||
std::cout<<"XimeaImager::processXiApiErrorCodes-----------:Invalid handle!"<<std::endl;
|
||
m_iImagerState=xiApiErrorCodes;
|
||
emit ximeaImageStatus(m_iImagerState);
|
||
|
||
break;
|
||
case 10:
|
||
std::cout<<"XimeaImager::processXiApiErrorCodes-----------:Timeout!"<<std::endl;
|
||
m_iImagerState=xiApiErrorCodes;
|
||
emit ximeaImageStatus(m_iImagerState);
|
||
|
||
break;
|
||
case 11:
|
||
std::cout<<"XimeaImager::processXiApiErrorCodes-----------:Invalid arguments supplied!"<<std::endl;
|
||
m_iImagerState=xiApiErrorCodes;
|
||
emit ximeaImageStatus(m_iImagerState);
|
||
|
||
break;
|
||
case 12:
|
||
std::cout<<"XimeaImager::processXiApiErrorCodes-----------:Not supported!"<<std::endl;
|
||
m_iImagerState=xiApiErrorCodes;
|
||
emit ximeaImageStatus(m_iImagerState);
|
||
|
||
break;
|
||
case 15:
|
||
std::cout<<"XimeaImager::processXiApiErrorCodes-----------:Memory allocation error!"<<std::endl;
|
||
m_iImagerState=xiApiErrorCodes;
|
||
emit ximeaImageStatus(m_iImagerState);
|
||
|
||
break;
|
||
case 56:
|
||
std::cout<<"XimeaImager::processXiApiErrorCodes-----------:NO_DEVICES_FOUND!"<<std::endl;
|
||
m_iImagerState=xiApiErrorCodes;
|
||
emit ximeaImageStatus(m_iImagerState);
|
||
|
||
break;
|
||
case 57:
|
||
std::cout<<"XimeaImager::processXiApiErrorCodes-----------:RESOURCE_OR_FUNCTION_LOCKED!"<<std::endl;
|
||
m_iImagerState=xiApiErrorCodes;
|
||
emit ximeaImageStatus(m_iImagerState);
|
||
|
||
break;
|
||
default:
|
||
m_iImagerState=99;
|
||
emit ximeaImageStatus(m_iImagerState);
|
||
break;
|
||
}
|
||
|
||
writeXiApiErrorCodes("/media/nvme/300TC/ximeaError.txt", xiApiErrorCodes);
|
||
}
|
||
|
||
void XimeaImager::writeXiApiErrorCodes(QString filePath, int xiApiErrorCodes)
|
||
{
|
||
ofstream ximeaErrorFile(filePath.toStdString().c_str(),ios::app);
|
||
|
||
char * timeFormat="%Y%m%d_%H%M%S";
|
||
QString timeStr = formatTimeStr(timeFormat);
|
||
|
||
ximeaErrorFile<< timeStr.toStdString().c_str() << ": " << xiApiErrorCodes << "\n";
|
||
|
||
std::cout<<"XimeaImager::writeXiApiErrorCodes-----------:xiApiErrorCodes: "<<timeStr.toStdString().c_str()<< ": " << xiApiErrorCodes<<std::endl;
|
||
|
||
ximeaErrorFile.close();
|
||
}
|
||
|
||
void XimeaImager::stopRecord()
|
||
{
|
||
//printf("Stop record!\n");
|
||
m_bRecordControl=false;
|
||
}
|
||
|
||
int XimeaImager::getFrameCounter()
|
||
{
|
||
return m_iFrameCounter;
|
||
}
|
||
|
||
DataBuffer::DataBuffer()
|
||
{
|
||
}
|
||
|
||
DataBuffer::~DataBuffer()
|
||
{
|
||
}
|
||
|
||
RecordXimeaTemperature::RecordXimeaTemperature(Iris::IrisXimeaImager * imager)
|
||
{
|
||
m_imager = imager;
|
||
m_bIsRecord = true;
|
||
}
|
||
|
||
void RecordXimeaTemperature::stopRecordTemperature()
|
||
{
|
||
m_bIsRecord = false;
|
||
}
|
||
|
||
void RecordXimeaTemperature::recordTemperature(QString filePath= nullptr)
|
||
{
|
||
if(filePath== nullptr)
|
||
filePath="ximeaTemperature.csv";
|
||
ofstream ximeaTemperatureFile(filePath.toStdString().c_str(),ios::app);
|
||
|
||
while(m_bIsRecord)
|
||
{
|
||
float temp = m_imager->getTemperature();
|
||
|
||
QDateTime curDateTime = QDateTime::currentDateTime();
|
||
QString currentTime = curDateTime.toString("yyyy/MM/dd hh:mm:ss");
|
||
|
||
ximeaTemperatureFile << currentTime.toStdString() << "," << temp << "\n";
|
||
|
||
// std::cout<<"RecordXimeaTemperature::recordTemperature----------------:ximea Temperature is "<< temp <<std::endl;
|
||
|
||
sleep(1);
|
||
}
|
||
|
||
m_bIsRecord = true;
|
||
|
||
ximeaTemperatureFile.close();
|
||
}
|
||
|
||
WriteData2Disk::WriteData2Disk()
|
||
{
|
||
isExitWriteData2Disk = false;
|
||
}
|
||
|
||
void WriteData2Disk::write2Disk()
|
||
{
|
||
QString imageFileName=m_QbaseFileName+".bil";
|
||
FILE *hFile=fopen(imageFileName.toStdString().c_str(),"w+b");
|
||
|
||
int frameCounter = 0;
|
||
int frameNumber;
|
||
unsigned short * dataBuffer = new unsigned short[m_iFrameSizeInByte/2*m_iNumber_WriteDisk];
|
||
isExitWriteData2Disk = false;
|
||
while(true)
|
||
{
|
||
r_qtx.lock();
|
||
bool bempty=m_q->empty();
|
||
r_qtx.unlock();
|
||
if(bempty && isExitWriteData2Disk)
|
||
{
|
||
std::cout<<"WriteData2Disk::write2Disk-----------------------队列为空，采集线程已经退出！"<<std::endl;
|
||
break;
|
||
}
|
||
else if(bempty && !isExitWriteData2Disk)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
|
||
r_qtx.lock();
|
||
DataBuffer * buffer = m_q->front();
|
||
int frameNumber = m_qFrameCounter->front();
|
||
memcpy(dataBuffer,buffer->data,m_iFrameSizeInByte*frameNumber);
|
||
// m_pool->destroy(m_q->front());
|
||
m_pool->deleteElement(buffer);
|
||
m_q->pop();
|
||
m_qFrameCounter->pop();
|
||
r_qtx.unlock();
|
||
|
||
//构造rgb图像，用于推流到m300遥控器
|
||
// m_rgbImage->FillRgbImage(dataBuffer);
|
||
|
||
|
||
// std::cout<<"WriteData2Disk::write2Disk-----------------------正在写磁盘!" << m_pool->max_size() <<std::endl;//
|
||
fwrite(dataBuffer,1,m_iFrameSizeInByte*frameNumber, hFile);
|
||
frameCounter++;
|
||
}
|
||
m_rgbImage->m_VideoWriter.release();
|
||
fclose(hFile);
|
||
delete[] dataBuffer;
|
||
|
||
std::cout<<"WriteData2Disk::write2Disk-----------------------写磁盘线程将退出，内存池可达到的最多元素数：" << m_pool->max_size() <<std::endl;
|
||
std::cout<<"WriteData2Disk::write2Disk-----------------------写磁盘线程将退出，fwrite 调用次数：" << frameCounter <<std::endl;
|
||
}
|
||
|
||
void WriteData2Disk::exitWriteData2Disk()
|
||
{
|
||
isExitWriteData2Disk = true;
|
||
}
|
||
|
||
void WriteData2Disk::setParm(queue<DataBuffer *> * q, queue<int> * qFrameCounter, QString baseFileName, int frameSizeInByte, int number_WriteDisk, MemoryPool<DataBuffer> * pool, rgbImage * rgbImage)
|
||
{
|
||
m_q = q;
|
||
m_qFrameCounter = qFrameCounter;
|
||
m_QbaseFileName = baseFileName;
|
||
m_iFrameSizeInByte = frameSizeInByte;
|
||
m_iNumber_WriteDisk = number_WriteDisk;
|
||
|
||
m_pool = pool;
|
||
|
||
m_rgbImage = rgbImage;
|
||
}
|