tangchao0503/IRIS_FODIS
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

1.修改了海阳光学光谱仪派生类，以支持暗像素信息的获取。

Browse Source 
2.针对FLAME设备添加了新的实时暗背景扣除函数。
3.修改了部分系统执行逻辑，以支持FLAME的正确运行。
This commit is contained in:
zhangzhuo
2023-07-17 11:26:56 +08:00
parent 16d745ed5f
commit 3ce267dccf
19 changed files with 371 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
Source/Capture/AbsFSController.cpp
View File

@ -35,6 +35,7 @@ int CAbsFSController::Initialize()
printf("Flame Not Opened");
return 1;
}
GetDarkPixelIndices();
break;
case DeviceModel::OSIFAlpha:
m_pFSCtrl = new OceanOptics_lib;
@ -400,6 +401,27 @@ int CAbsFSController::CheckAndAdjust_Fast()
return 0;
}
int CAbsFSController::GetDarkPixelIndices()
{
m_vecDarkPixleIndices.clear();
if (m_struFSParam.ucDeviceModel == DeviceModel::FLAME)
{
m_vecDarkPixleIndices = ((OceanOptics_lib*)m_pFSCtrl)->m_vecDarkPixels;
}
//////////////////////////////////////////////////////////////////////////debug only
/*qDebug() << m_vecDarkPixleIndices.size();
qDebug() << ((OceanOptics_lib*)m_pFSCtrl)->m_vecDarkPixels.size();
for (int i=0;i< m_vecDarkPixleIndices.size();i++)
{
qDebug() << m_vecDarkPixleIndices[i];
}*/
//////////////////////////////////////////////////////////////////////////debug only
return 0;
}
void CAbsFSController::GetDeviceAttr(DeviceAttribute& struDeviceAttr)
{
struDeviceAttr = m_struDeviceAttr;

14
Source/Capture/AbsFSController.h
View File

@ -29,15 +29,19 @@ public:
int PerformAutoExposure();
int CheckAndAdjust_Fast();
int GetDarkPixelIndices();
void GetDeviceAttr(DeviceAttribute &struDeviceAttr);
public:
std::atomic_int m_iFlagInit;
std::vector<int> m_vecDarkPixleIndices;
DeviceAttribute m_struDeviceAttr;
private:
DeviceAttribute m_struDeviceAttr;
CIrisFSBase* m_pFSCtrl;
OneFSContext m_struFSParam;
DataFrame m_struSingleFrame;
QString m_qstrWaveLengthPath;
CIrisFSBase* m_pFSCtrl;
OneFSContext m_struFSParam;
DataFrame m_struSingleFrame;
QString m_qstrWaveLengthPath;
private:
//int CreateWavelengthFile();
public slots:

94
Source/Capture/MainGrabber.cpp
View File

@ -81,12 +81,18 @@ int CMainGrabber::Initialize_Self()
{
InitializeWorkers();
SetupMsgPipelines();
LoadDCT();
if (m_struFSRunParams.ucDeviceModel== DeviceModel::FLAME)
{
//do nothing
}
else
{
LoadDCT();
}
emit Signal_InitFinished();
return 0;
}
}
void CMainGrabber::Delay_MSec(ZZ_U16 usMS)
{
@ -114,6 +120,12 @@ int CMainGrabber::InitializeWorkers()
}
m_pctrlFS->GetDeviceAttr(m_struDeviceAttr);
m_dfpDataSaver->WriteWavelengthInfo(m_struDeviceAttr.fWaveLengthInNM, m_struDeviceAttr.iPixels);
//////////////////////////////////////////////////////////////////////////20230713
if (m_struFSRunParams.dMinSamplingInterval < m_pctrlFS->m_struDeviceAttr.iMaxIntegrationTimeInMS)
{
m_pctrlFS->m_struDeviceAttr.iMaxIntegrationTimeInMS = m_struFSRunParams.dMinSamplingInterval * 2;
}
return 0;
}
@ -202,45 +214,65 @@ int CMainGrabber::CheckExposureTime(DataFrame dfTemp)
int CMainGrabber::RemoveBackground(DataFrame& dfTemp)
{
int iA = dfTemp.usExposureTimeInMS / 10;
int iB = dfTemp.usExposureTimeInMS % 10;
qDebug() << "iA" << iA;
qDebug() << "iB" << iB;
if (iA == 0)
if (m_struFSRunParams.ucDeviceModel==DeviceModel::FLAME)
{
m_dfBackground = m_vecDataFrame[iB];
double dBackground = 0;
for (int i=0;i< m_pctrlFS->m_vecDarkPixleIndices.size();i++)
{
dBackground += dfTemp.lData[m_pctrlFS->m_vecDarkPixleIndices[i]];
}
dBackground = dBackground / m_pctrlFS->m_vecDarkPixleIndices.size();
for (int i = 0; i < m_struDeviceAttr.iPixels; i++)
{
dfTemp.lData[i] = dfTemp.lData[i] - dBackground;
}
qDebug() << "FLAME Real Time Background" << dBackground;
}
else
{
if (iA>100)
int iA = dfTemp.usExposureTimeInMS / 10;
int iB = dfTemp.usExposureTimeInMS % 10;
qDebug() << "iA" << iA;
qDebug() << "iB" << iB;
if (iA == 0)
{
m_dfBackground = m_vecDataFrame[m_vecDataFrame.size()-1];
}
else if(iA<=9&&iA>=1)
{
m_dfBackground = m_vecDataFrame[8 + iA];
m_dfBackground = m_vecDataFrame[iB-1];
}
else
{
int iAA= dfTemp.usExposureTimeInMS / 100;
int iBB= dfTemp.usExposureTimeInMS % 100;
DataFrame dfTempX1, dfTempX2;
dfTempX1 = m_vecDataFrame[17 + iAA];
dfTempX2 = m_vecDataFrame[18 + iAA];
for (int i=0;i< m_struDeviceAttr.iPixels;i++)
if (iA > 100)
{
m_dfBackground.lData[i] = dfTempX1.lData[i] + (dfTempX2.lData[i] - dfTempX1.lData[i]) * (double)iBB / (double)100;
m_dfBackground = m_vecDataFrame[m_vecDataFrame.size() - 1];
}
else if (iA <= 9 && iA >= 1)
{
m_dfBackground = m_vecDataFrame[8 + iA];
}
else
{
int iAA = dfTemp.usExposureTimeInMS / 100;
int iBB = dfTemp.usExposureTimeInMS % 100;
DataFrame dfTempX1, dfTempX2;
dfTempX1 = m_vecDataFrame[17 + iAA];
dfTempX2 = m_vecDataFrame[18 + iAA];
for (int i = 0; i < m_struDeviceAttr.iPixels; i++)
{
m_dfBackground.lData[i] = dfTempX1.lData[i] + (dfTempX2.lData[i] - dfTempX1.lData[i]) * (double)iBB / (double)100;
}
}
}
}
for (int i = 0; i < m_struDeviceAttr.iPixels; i++)
{
dfTemp.lData[i] = dfTemp.lData[i] - m_dfBackground.lData[i];
for (int i = 0; i < m_struDeviceAttr.iPixels; i++)
{
dfTemp.lData[i] = dfTemp.lData[i] - m_dfBackground.lData[i];
}
return 0;
}
return 0;
}

107
Source/FS/DataFileProcessor.cpp
View File

@ -110,16 +110,121 @@ void DataFileProcessor::LoadSingleDataFile(QString qstrFileName)
printf("LoadWaveLengthFile open Failed.");
return;
}
int iExpoTime=0;
std::vector<int> vecExpotime;
std::vector<double> vecDTime;
long long int llCount = (qfDataFile.size()) / (sizeof(DataFrame));
for (int i=0;i<llCount;i++)
{
QByteArray qbDataFrame = qfDataFile.read(sizeof(DataFrame));
memcpy(&dfTemp, qbDataFrame, sizeof(DataFrame));
vecExpotime.push_back(dfTemp.usExposureTimeInMS);
vecDTime.push_back(dfTemp.dTimes);
}
return;
}
void DataFileProcessor::RecoverBackground(QString qstrDataFileName, QString qstrBackgroundFileName)
{
int iExpoTime = 0;
std::vector<int> vecExpotime;
std::vector<double> vecDTime;
DataFrame dfDataTemp;
DataFrame m_dfBackground;
QString qstrFullFileName(qstrDataFileName+"recv");
QFile qfDataRec(qstrFullFileName);
bool bRes = qfDataRec.open(QFile::WriteOnly | QIODevice::Append);
if (!bRes)
{
printf("WriteData QFile open Failed");
return;
}
QFile qfDataFile(qstrDataFileName);
bRes = qfDataFile.open(QFile::ReadOnly);
if (!bRes)
{
printf("qstrDataFileName open Failed.");
return;
}
///
std::vector<DataFrame> m_vecDataFrame;
m_vecDataFrame.clear();
DataFrame dfDarkTemp;
QFile qfData(qstrBackgroundFileName);
bRes = qfData.open(QFile::ReadOnly);
if (!bRes)
{
//qDebug() << "LoadTable open Failed.";
printf("LoadTable open Failed.");
return;
}
QString qstrTemp;
QStringList qsList;
while (!qfData.atEnd())
{
QString data;
data = qfData.readLine();
qsList = data.split(',');
dfDarkTemp.usExposureTimeInMS = qsList[0].toInt();
for (int i = 0; i < qsList.size() - 1; i++)
{
dfDarkTemp.lData[i] = qsList[i + 1].toInt();
qDebug() << qsList[i] << ";";
}
m_vecDataFrame.push_back(dfDarkTemp);
qDebug() << qsList.size() << endl;
}
///
long long int llCount = (qfDataFile.size()) / (sizeof(DataFrame));
for (int i = 0; i < llCount; i++)
{
QByteArray qbDataFrame = qfDataFile.read(sizeof(DataFrame));
memcpy(&dfDataTemp, qbDataFrame, sizeof(DataFrame));
vecExpotime.push_back(dfDataTemp.usExposureTimeInMS);
vecDTime.push_back(dfDataTemp.dTimes);
int iB = dfDataTemp.usExposureTimeInMS % 10;
m_dfBackground = m_vecDataFrame[iB];
for (int i = 0; i < 2048 ; i++)
{
dfDataTemp.lData[i] = dfDataTemp.lData[i] + m_dfBackground.lData[i];
}
double dBackground = 0;
int iCountBg = 0;
for (int i=6;i<21;i++)
{
dBackground = dBackground +dfDataTemp.lData[i];
iCountBg++;
}
dBackground = dBackground / iCountBg;
for (int i = 0; i < 2048; i++)
{
dfDataTemp.lData[i] = dfDataTemp.lData[i] - dBackground;
}
qfDataRec.write((char*)&dfDataTemp, sizeof(DataFrame));
qfDataRec.flush();
}
return;
}
void DataFileProcessor::GenerateFilePath()
{
m_qdtTime = QDateTime::currentDateTime();

1
Source/FS/DataFileProcessor.h
View File

@ -18,6 +18,7 @@ public:
void LoadWaveLengthFile(QString qstrFileName);
void LoadSingleDataFile(QString qstrFileName);
void RecoverBackground(QString qstrDataFileName, QString qstrBackgroundFileName);
//void SetEnvironmentContex(EContext struEC);
//void SetManmadeEnviromentalContext(MEContext struMEC);
//void SetDeviceInfo(FSContext struDeviceContext);

21
Source/FS/IS11_Ctrl_Qt.cpp
View File

@ -69,6 +69,9 @@ int IS11_Ctrl_Qt::SingleShot(DataFrame& dfData)
{
SendData_CMD03((char*)GET_ALL_DN, sizeof(GET_ALL_DN));
RecvData_CMD03(dfData);
GetExposureTime(m_iExposureTime);
dfData.usExposureTimeInMS = (unsigned short)m_iExposureTime;
return 0;
}
@ -93,7 +96,7 @@ int IS11_Ctrl_Qt::GetExposureTime(int & iExposureTimeInMS)
SendData_CMD03((char *)GET_INTEGRAL_TIME, sizeof(GET_INTEGRAL_TIME));
int iRes = RecvData_CMD03(qbaRecv);
iExposureTimeInMS = qbaRecv[0]*256+ qbaRecv[1];
iExposureTimeInMS = ((unsigned char)(qbaRecv[0]))*256+ (unsigned char)(qbaRecv[1]);
return iRes;
}
@ -262,11 +265,11 @@ int IS11_Ctrl_Qt::RecvData_CMD03(QByteArray &qbaRecv)
iRetryCount = 0;
while (qbaOriRecv.size()< qbaOriRecv[2]+5)
{
m_pSerialPort->waitForReadyRead(100);
m_pSerialPort->waitForReadyRead(1000);
Read_IS11(qbaTemp);
qbaOriRecv.append(qbaTemp);
iRetryCount++;
if (iRetryCount > 20)
if (iRetryCount > 66)
{
qDebug() << "Recv Data Err.out of retry time";
return 2;
@ -318,11 +321,11 @@ int IS11_Ctrl_Qt::RecvData_CMD03(DataFrame& dfData)
qbaOriRecv.append(qbaTemp);
while (qbaOriRecv.size() < 4 || ParseHdr(qbaOriRecv, 3) == 1)
{
m_pSerialPort->waitForReadyRead(100);
m_pSerialPort->waitForReadyRead(1000);
Read_IS11(qbaTemp);
qbaOriRecv.append(qbaTemp);
iRetryCount++;
if (iRetryCount > 20)
if (iRetryCount > 66)
{
qDebug() << "Recv Hdr Err.out of retry time";
return 1;
@ -333,11 +336,11 @@ int IS11_Ctrl_Qt::RecvData_CMD03(DataFrame& dfData)
iRetryCount = 0;
while (qbaOriRecv.size() < length + 4)
{
m_pSerialPort->waitForReadyRead(100);
m_pSerialPort->waitForReadyRead(1000);
Read_IS11(qbaTemp);
qbaOriRecv.append(qbaTemp);
iRetryCount++;
if (iRetryCount > 20)
if (iRetryCount > 66)
{
qDebug() << "Recv Data Err.out of retry time";
return 2;
@ -500,11 +503,11 @@ int IS11_Ctrl_Qt::RecvData_CMD06(QByteArray &qbaRecv)
iRetryCount = 0;
while (qbaOriRecv.size() < 8)
{
m_pSerialPort->waitForReadyRead(100);
m_pSerialPort->waitForReadyRead(1000);
Read_IS11(qbaTemp);
qbaOriRecv.append(qbaTemp);
iRetryCount++;
if (iRetryCount > 20)
if (iRetryCount > 66)
{
qDebug() << "Recv Data Err.out of retry time";
return 2;

49
Source/FS/OControl_USB.cpp
View File

@ -1,3 +1,4 @@
#include "pch.h"
#include "OControl_USB.h"
#include <iostream>
#include <cstring>
@ -86,6 +87,27 @@ int OceanOptics_lib::Initialize(bool bIsUSBMode, std::string ucPortNumber, std::
SetExposureTime(minimum_time / 1000);
m_vecDarkPixels.clear();
int* piIndex = new int[64];
int iCount = seabreeze_get_electric_dark_pixel_indices(m_iSpectralmeterHandle, &error, piIndex, 64);
for (int i = 0; i < iCount; i++)
{
m_vecDarkPixels.push_back(piIndex[i]);
}
delete[] piIndex;
qDebug() << "from lib" << iCount;
//////////////////////////////////////////////////////////////////////////
/*CString cstrTemp, cstrTemp1;
for (int i=0;i< m_vecDarkPixels.size();i++)
{
cstrTemp1.Format(_T("%d"), m_vecDarkPixels[i]);
cstrTemp = cstrTemp+L"-"+cstrTemp1;
}
AfxMessageBox(cstrTemp);*/
//////////////////////////////////////////////////////////////////////////
return 0;
}
@ -146,6 +168,27 @@ int OceanOptics_lib::Initialize()
SetExposureTime(minimum_time / 1000);
m_vecDarkPixels.clear();
int *piIndex=new int[64];
int iCount = seabreeze_get_electric_dark_pixel_indices(m_iSpectralmeterHandle,&error, piIndex,64);
for (int i=0;i< iCount;i++)
{
m_vecDarkPixels.push_back(piIndex[i]);
}
delete[] piIndex;
qDebug() << "from lib" << iCount;
//////////////////////////////////////////////////////////////////////////
/*CString cstrTemp, cstrTemp1;
for (int i=0;i< m_vecDarkPixels.size();i++)
{
cstrTemp1.Format(_T("%d"), m_vecDarkPixels[i]);
cstrTemp = cstrTemp+L"-"+cstrTemp1;
}
AfxMessageBox(cstrTemp);*/
//////////////////////////////////////////////////////////////////////////
return 0;
}
@ -286,7 +329,7 @@ int OceanOptics_lib::SingleShot(DataFrame &dfData)
for (int tmp = 0; tmp < spec_length; tmp++)
{
dfData.lData[tmp] = spectrum[tmp];
dfData.lData[tmp] = (unsigned int)spectrum[tmp];
}
int exposureTimeInMS;
@ -416,7 +459,7 @@ int OceanOptics_lib::GetDeviceTemperature(float &fTemperature)
return 1;
}
fTemperature = temp;
fTemperature = (float)temp;
return 0;
}
@ -484,7 +527,7 @@ int OceanOptics_lib::GetDeviceAttribute(DeviceAttribute &Attr)
for (int tmp = 0; tmp < spec_length; tmp++)
{
Attr.fWaveLengthInNM[tmp] = wls[tmp];
Attr.fWaveLengthInNM[tmp] = (float)wls[tmp];
}
free(wls);

4
Source/FS/OControl_USB.h
View File

@ -2,6 +2,7 @@
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <vector>
#include "api/SeaBreezeWrapper.h"
#include "IrisFiberSpectrometerBase.h"
@ -51,7 +52,8 @@ private:
int m_iExposureTime;
bool isSuccess(char* resultStr);
string GetDeviceType(int index);
string GetSerialNumber(int index);
public:
std::vector<int> m_vecDarkPixels;
};

4
Source/GPS/BD357Ctrl.cpp
View File

@ -41,6 +41,7 @@ int BD357Controller::SyncDateOnce()
{
using namespace ZZ_MISCDEF;
//bool bFlagFinish = 1;
bool bFlagFinish = false;
size_t uiCount = 0;
//ZZ_U8 u8Rx,u8Tx;
@ -54,6 +55,7 @@ int BD357Controller::SyncDateOnce()
{
m_pSerialPort->waitForReadyRead(1000);
m_qbReadData.append(m_pSerialPort->readAll());
qDebug() << "waiting for gps data..." << m_qbReadData.size();
}
qDebug() << m_qbReadData.size() << endl;
@ -103,6 +105,7 @@ int BD357Controller::SyncDateOnce()
}
//bFlagFinish = 1;
}
qDebug() << "Signal_StartCapture emitted.";
emit Signal_StartCapture();
return 0;
@ -240,6 +243,7 @@ int BD357Controller::Slot_InitSelf()
int BD357Controller::Slot_SyncDateOnce()
{
//emit Signal_StartCapture();
SyncDateOnce();
return 0;
}