zhangzhuo/TowerOptoSifAndSpectral_Tooling
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

first commnit

Browse Source
This commit is contained in:
zhangzhuo
2022-08-16 09:26:36 +08:00
commit 11d5fc83c2
941 changed files with 168924 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
othersoft/calibration_console/CMakeLists.txt Normal file
View File

@ -0,0 +1,52 @@
cmake_minimum_required(VERSION 3.5)
project(ocean_optics_calibration_console)#ocean_optics_calibration_console
#编译32位的程序
#option(USE_32BITS "Compile for 32bits processors(linux only)" OFF)
#
#
#if(USE_32BITS)
# message(STATUS "using 32bits")
# set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m32")
#
# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m32")
#else()
#endif(USE_32BITS)
set(CMAKE_CXX_STANDARD 14)
SET(CMAKE_INSTALL_PREFIX < /home/pi/bin >)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_PREFIX_PATH "/home/iris-xport/Qt5.9.0/5.9/gcc_64/")#tc_add: https://blog.csdn.net/aiyun5666/article/details/101915628
set(QT Core Network SerialPort)
set(TEMPLATE app)
set(TARGET ximeaImageRecorder)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
find_package(Qt5 REQUIRED ${QT})
#include_directories(/home/iris-xport/projects/ocean/seabreeze-3.0.11/SeaBreeze/include/)
#LINK_DIRECTORIES(/home/iris-xport/projects/ocean/seabreeze-3.0.11/SeaBreeze/lib/)
include_directories(/home/pi/SeaBrease/include/)
LINK_DIRECTORIES(/home/pi/SeaBrease/lib/)
include_directories(.)#包含头文件
include_directories(/usr/include/eigen3)#包含头文件，安装eigen：sudo apt-get install libeigen3-dev
file(GLOB_RECURSE SRC_h ./Header_Files/*.h)
file(GLOB_RECURSE SRC_CPP ./Source_Files/*.cpp)
add_executable(${CMAKE_PROJECT_NAME} ${SRC_h} ${SRC_CPP})
qt5_use_modules(${CMAKE_PROJECT_NAME} ${QT})
TARGET_LINK_LIBRARIES(${CMAKE_PROJECT_NAME}
seabreeze
usb
)

102
othersoft/calibration_console/Header_Files/ATPControl_Serial_QT.h Normal file
View File

@ -0,0 +1,102 @@
//////////////////////////////////////////////////////////////////////////
//ATP<54><50><EFBFBD>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD>
//////////////////////////////////////////////////////////////////////////
#pragma once
//#include "pch.h"
#include "ZZ_Types.h"
#include "ZZ_Math.h"
#include <QSerialPort>
#include <QtEndian>
#include <QDebug>
#include "IrisFiberSpectrometerBase.h"
using namespace ZZ_MISCDEF;
using namespace ZZ_MISCDEF::ATP;
using namespace ZZ_MISCDEF::IRIS::FS;
class ZZ_ATPControl_Serial_Qt:public CIrisFSBase
{
Q_OBJECT
public:
ZZ_ATPControl_Serial_Qt(QObject* parent = nullptr);
virtual ~ZZ_ATPControl_Serial_Qt();
public:
//do not call
//int ReInit();
//<2F><><EFBFBD>ò<EFBFBD><C3B2><EFBFBD><EFBFBD><EFBFBD>
//int SetBaudRate(int iBaud);
//<2F><>ʼ<EFBFBD><CABC><EFBFBD>豸
int Initialize(bool bIsUSBMode, std::string ucPortNumber, std::string strDeviceName);
//<2F>ر<EFBFBD><D8B1>豸
void Close();
//<2F><><EFBFBD>β<EFBFBD><CEB2>Բɼ<D4B2> <20><><EFBFBD><EFBFBD>ȷ<EFBFBD><C8B7><EFBFBD>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int SingleShot(int &iPixels);
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݲɼ<DDB2>
int SingleShot(DataFrame &dfData);
//<2F><><EFBFBD>ΰ<EFBFBD><CEB0><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɼ<EFBFBD>
//int SingleShotDark(ATPDataFrame &dfData);
//int SingleShotDeducted(ATPDataFrame &dfData);
//<2F><><EFBFBD><EFBFBD><EFBFBD>ع<EFBFBD>ʱ<EFBFBD><CAB1>
int SetExposureTime(int iExposureTimeInMS);
//<2F><>ȡ<EFBFBD>ع<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int GetExposureTime(int &iExposureTimeInMS);
//int GetWaveLength(float *pfWaveLength);
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8>Ϣ
int GetDeviceInfo(DeviceInfo &Info);
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int GetDeviceAttribute(DeviceAttribute &Attr);
//int GetDeviceListInfo(); //use type name to enum
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int SetDeviceTemperature(float fTemperature);
//<2F><>ȡ<EFBFBD><EFBFBD>
int GetDeviceTemperature(float &fTemperature);
//<2F>Զ<EFBFBD><D4B6>ع<EFBFBD>
int PerformAutoExposure(float fMinScaleFactor, float fMaxScaleFactor, float &fPredictedExposureTime);
private:
int SetAvgTimes(int iTimes = 1);
#ifdef _DEBUG
public:
#else //
private:
#endif
//port
int m_iBaudRate;
QSerialPort *m_pSerialPort;
//ATP
DeviceInfo m_diDeviceInfo;
DeviceAttribute m_daDeviceAttr;
//Attr
int m_iExposureTime;
//////////////////////////////////////////////////////////////////////////shutter control stub code s
//int SetExtShutter(int iShutterUP0, int iShutterDOWN1,int iShutterDOWN2,int iShutterDOWN3); //0:close 1:open
//////////////////////////////////////////////////////////////////////////shutter control stub code e
int GetExposureTime_Init();
int SendCommand(QByteArray qbCommand);
int RecvData(QByteArray &qbData);
int RecvData_ShortLag(QByteArray &qbData);
int ParseData(QByteArray &qbData);
public slots:
int Init_Self();
signals:
void SignalInit_Self();
//private slots :
//void ReadMessage();
};

61
othersoft/calibration_console/Header_Files/FiberSpectrometerOperationBase.h Normal file
View File

@ -0,0 +1,61 @@
//
// Created by tangchao on 2022/1/11.
//
#ifndef OCEAN_OPTICS_CALIBRATION_CONSOLE_FIBERSPECTROMETEROPERATIONBASE_H
#define OCEAN_OPTICS_CALIBRATION_CONSOLE_FIBERSPECTROMETEROPERATIONBASE_H
#include "ZZ_Types.h"
using namespace ZZ_MISCDEF;
using namespace ZZ_MISCDEF::IRIS::FS;
class FiberSpectrometerOperationBase
{
public:
// FiberSpectrometerOperationBase();
// ~FiberSpectrometerOperationBase();
virtual void connectFiberSpectrometer(QString& sn, QString& pixelCount, QString& wavelengthInfo) = 0;
virtual void disconnectFiberSpectrometer() = 0;
virtual void getDeviceAttribute(DeviceAttribute& deviceAttribute) = 0;
virtual void getDeviceInfo(DeviceInfo& deviceInfo) = 0;
virtual void setExposureTime(int iExposureTimeInMS) = 0;
virtual void getExposureTime(int &iExposureTimeInMS) = 0;
virtual void getDeviceTemperature(float &fTemperature) = 0;
virtual void singleShot(DataFrame &dfData) = 0;
// typedef struct coeffs
// {
// ZZ_U32 coeffsCounter;
// double coeffs[100];
// }coeffsFrame;
virtual void getNonlinearityCoeffs(coeffsFrame &coeffs) = 0;
// ZZ_S32 GetMaxValue(ZZ_S32 * dark, int number) = 0;
DataFrame m_IntegratingSphereData;
DataFrame m_DarkData;
protected:
ZZ_U32 m_MaxValueOfFiberSpectrometer;
private:
public slots:
virtual void recordDark(QString path) = 0;
virtual void recordTarget(int recordTimes, QString path) = 0;
virtual void autoExpose() = 0;
signals:
void sendExposureTimeSignal(int exposureTime);
};
#endif //OCEAN_OPTICS_CALIBRATION_CONSOLE_FIBERSPECTROMETEROPERATIONBASE_H

43
othersoft/calibration_console/Header_Files/IrisFiberSpectrometerBase.h Normal file
View File

@ -0,0 +1,43 @@
#include "QObject"
#include <string>
#include "ZZ_Types.h"
#pragma once
using namespace ZZ_MISCDEF;
using namespace ZZ_MISCDEF::IRIS::FS;
class CIrisFSBase:public QObject
{
public:
//CIrisFSBase();
//virtual ~CIrisFSBase()= 0;
public:
//<2F><>ʼ<EFBFBD><CABC><EFBFBD>豸
//<2F>˴<EFBFBD>stringΪָ<CEAA><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ĸ<EFBFBD>ocean<61><6E><EFBFBD><EFBFBD><EFBFBD>ǵIJ<C7B5><C4B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>и<EFBFBD><D0B8><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>c/c++<2B><>׼<EFBFBD><D7BC><EFBFBD><EFBFBD>
//0Ϊ<30>޴<EFBFBD><DEB4>󣬲<EFBFBD>ͬ<EFBFBD><CDAC><EFBFBD><EFBFBD><EFBFBD>뷵<EFBFBD>ز<EFBFBD>ֵͬ
virtual int Initialize(bool bIsUSBMode,std::string ucPortNumber,std::string strDeviceName) = 0;
//<2F>ر<EFBFBD><D8B1>豸
virtual void Close() = 0;
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݲɼ<DDB2>
virtual int SingleShot(DataFrame &dfData) = 0;
//<2F><><EFBFBD><EFBFBD><EFBFBD>ع<EFBFBD>ʱ<EFBFBD><CAB1>
virtual int SetExposureTime(int iExposureTimeInMS) = 0;
//<2F><>ȡ<EFBFBD>ع<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
virtual int GetExposureTime(int &iExposureTimeInMS) = 0;
//<2F><><EFBFBD><EFBFBD>Ŀ<EFBFBD><C4BF><EFBFBD><EFBFBD>
virtual int SetDeviceTemperature(float fTemperature) = 0;
//<2F><>ȡ<EFBFBD><EFBFBD><C2B6><EFBFBD><EFBFBD><EFBFBD>
virtual int GetDeviceTemperature(float &fTemperature) = 0;
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8>Ϣ
virtual int GetDeviceInfo(DeviceInfo &Info) = 0;
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
virtual int GetDeviceAttribute(DeviceAttribute &Attr) = 0;
};

121
othersoft/calibration_console/Header_Files/ZZ_Math.h Normal file
View File

@ -0,0 +1,121 @@
#include <utility>
#include <vector>
#//#include "Dense"
#include "Eigen/Dense"
#include <unsupported/Eigen/Splines>
#pragma once
namespace ZZ_MATH
{
template<typename T>
void MinHeapify(T*arry, int size, int element)
{
int lchild = element * 2 + 1, rchild = lchild + 1;
while (rchild < size)
{
if (arry[element] <= arry[lchild] && arry[element] <= arry[rchild])
{
return;
}
if (arry[lchild] <= arry[rchild])
{
std::swap(arry[element], arry[lchild]);
element = lchild;
}
else
{
std::swap(arry[element], arry[rchild]);
element = rchild;
}
lchild = element * 2 + 1;
rchild = lchild + 1;
}
if (lchild < size&&arry[lchild] < arry[element])
{
std::swap(arry[lchild], arry[element]);
}
return;
}
template<typename T>
void MaxHeapify(T*arry, int size, int element)
{
int lchild = element * 2 + 1, rchild = lchild + 1;
while (rchild < size)
{
if (arry[element] >= arry[lchild] && arry[element] >= arry[rchild])
{
return;
}
if (arry[lchild] >= arry[rchild])
{
std::swap(arry[element], arry[lchild]);
element = lchild;
}
else
{
std::swap(arry[element], arry[rchild]);
element = rchild;
}
lchild = element * 2 + 1;
rchild = lchild + 1;
}
if (lchild<size&&arry[lchild]>arry[element])
{
std::swap(arry[lchild], arry[element]);
}
return;
}
template<typename T>
void HeapSort(T*arry, int size)
{
int i;
for (i = size - 1; i >= 0; i--)
{
MinHeapify(arry, size, i);
}
while (size > 0)
{
std::swap(arry[size - 1], arry[0]);
size--;
MinHeapify(arry, size, 0);
}
return;
}
namespace PolyFit
{
void Eigen_Polyfit(const std::vector<double> &xv, const std::vector<double> &yv, std::vector<double> &coeff, int order);
double Eigen_Polyeval(std::vector<double> coeffs, double x);
};
namespace SplineFit
{
using namespace Eigen;
VectorXd Eigen_Normalize(const VectorXd &x);
void Test(std::vector<double> const &x_vec, std::vector<double> const &y_vec);// do not call
class SplineInterpolation
{
public:
SplineInterpolation(Eigen::VectorXd const &x_vec,Eigen::VectorXd const &y_vec);
double operator()(double x) const;
private:
double x_min;
double x_max;
double scaled_value(double x) const;
Eigen::RowVectorXd scaled_values(Eigen::VectorXd const &x_vec) const;
Eigen::Spline<double, 1> spline_;
};
};
};

354
othersoft/calibration_console/Header_Files/ZZ_Types.h Normal file
View File

@ -0,0 +1,354 @@
//////////////////////////////////////////////////////////////////////////
//<2F><><EFBFBD><EFBFBD>˵<EFBFBD><CBB5><EFBFBD>ļ<EFBFBD>
//////////////////////////////////////////////////////////////////////////
#pragma once
#include <string>
#include <QTime>
#define MAX_DEVICENUMBER_FS 2
#define MAX_LINEARSHUTTER_POSITION 12
#define ZZ_Enum2String(x) #x
namespace ZZ_MISCDEF
{
typedef unsigned char ZZ_U8;
typedef unsigned short int ZZ_U16;
typedef unsigned int ZZ_U32;
typedef int ZZ_S32;
namespace IRIS
{
//Fiber Spectrometer
namespace FS
{
typedef struct tagDataFrame
{
ZZ_U32 usExposureTimeInMS;
ZZ_S32 lData[4096];
float fTemperature = 0;
double dTimes = 0;
}DataFrame;
typedef struct coeffs//tc<74><63><EFBFBD><EFBFBD>-----------------------
{
ZZ_U32 coeffsCounter;
double coeffs[100];
}coeffsFrame;
typedef struct tagDeviceInfo
{
std::string strPN;
std::string strSN;
}DeviceInfo;
typedef struct tagDeviceAttribute
{
int iPixels;
int iMaxIntegrationTimeInMS;
int iMinIntegrationTimeInMS;
float fWaveLengthInNM[4096];
}DeviceAttribute;
// inline DataFrame GetIndex(DataFrame dfDark, DataFrame dfSignal)
// {
//
// }
}
enum DeviceModel
{
OSIFAlpha=0,
OSIFBeta,
ISIF,
IS1,
IS2
};
inline std::string GetDeviceModelName(int iModel)
{
switch (iModel)
{
case DeviceModel::OSIFAlpha: return "OSIFAlpha"; break;
case DeviceModel::OSIFBeta: return "OSIFBeta"; break;
case DeviceModel::ISIF: return "ISIF"; break;
case DeviceModel::IS1: return "IS1"; break;
case DeviceModel::IS2: return "IS2"; break;
default: return "error"; break;
}
}
inline int GetIndex(std::string strDeviceModelName)
{
if (strDeviceModelName == "OSIFAlpha")
{
return DeviceModel::OSIFAlpha;
}
else if (strDeviceModelName == "OSIFBeta")
{
return DeviceModel::OSIFBeta;
}
else if (strDeviceModelName == "ISIF")
{
return DeviceModel::ISIF;
}
else if (strDeviceModelName == "IS1")
{
return DeviceModel::IS1;
}
else if (strDeviceModelName == "IS2")
{
return DeviceModel::IS2;
}
else
{
return -1;
}
}
};
//ATP????<3F><>???
namespace ATP
{
const int MAX_SPECTRUM_SIZE = 4096;
const int GET_MODULECIRCUIT_TEMP = 0x01;
const int GET_PN_NUMBER = 0x03;
const int GET_SN_NUMBER = 0x04;
const int GET_MANUFACTURE_DATA = 0x06;
const int GET_MANUFACTURE_INFO = 0x09;
const int GET_PIXEL_LENGTH = 0x0a;
const int GET_TEC_TEMP = 0x13;
const int SET_TEC_TEMP = 0x12;
const int GET_OPTICS_TEMP = 0x35;
const int GET_CIRCUITBOARD_TEMP = 0x36;
const int SET_INTEGRATION_TIME = 0x14;
const int GET_INTEGRATION_TIME = 0x41;
const int GET_MAX_INTEGRATION_TIME = 0x42;
const int GET_MIN_INTEGRATION_TIME = 0x43;
const int ASYNC_COLLECT_DARK = 0x23;
const int ASYNC_START_COLLECTION = 0x16;
const int ASYNC_READ_DATA = 0x17;
const int SET_AVERAGE_NUMBER = 0x28;
const int SYNC_GET_DATA = 0x1e;
const int SYNC_GET_DARK = 0x2f;
const int EXTERNAL_TRIGGER_ENABLE = 0x1f;
const int SET_XENON_LAMP_DELAY_TIME = 0x24;
const int GET_WAVELENGTH_CALIBRATION_COEF = 0x55;
const int GET_STAT_LAMPOUT = 0x60;
const int SET_GPIO = 0x61;
//const int SYNCHRONIZATION_GET_DARK = 0x23
//////////////////////////////////////////////////////////////////////////device
enum Model
{
ATP1010 = 0,
ATP6500
};
//???????<3F><>??
typedef struct tagATPDataFrame
{
unsigned short usExposureTime;
ZZ_U16 usData[4096];
float fTemperature;
double dTimes = 0;
}ATPDataFrame;
//?<3F><><EFBFBD><EFBFBD>??????<3F><>??
typedef struct tagATPDeviceInfo
{
std::string strPN;
std::string strSN;
}ATPDeviceInfo;
//?<3F><><EFBFBD><EFBFBD>????<3F><>?<3F><>??
typedef struct tagATPDeviceAttribute
{
int iPixels;
int iMaxIntegrationTime;
int iMinIntegrationTime;
float fWaveLength[4096];
}ATPDeviceAttribute;
//////////////////////////////////////////////////////////////////////////config file
}
//????????
namespace ZZ_RUNPARAMS
{
typedef struct tagErrorInfo
{
int iDataTransferErr = -1000;
float fTecTempErr = -1000;
int iShutterErr = -1000;
float fChassisTempErr = -1000;
}ErrInfo;
typedef struct tagFiberSpecContext
{
ZZ_U8 ucDeviceNumber;
ZZ_U8 ucDeviceModel[MAX_DEVICENUMBER_FS];
std::string strInterface[MAX_DEVICENUMBER_FS];
std::string strSN[MAX_DEVICENUMBER_FS];
long lDepth[MAX_DEVICENUMBER_FS];
float fMinFactor[MAX_DEVICENUMBER_FS];
float fMaxFactor[MAX_DEVICENUMBER_FS];
ZZ_U16 usPixels[MAX_DEVICENUMBER_FS];
float fWavelength[MAX_DEVICENUMBER_FS][4096];
}FSContext;
typedef struct tagLinearShutterContext
{
std::string strInterface;
ZZ_U8 ucProtocolType;
ZZ_U8 ucCmdID;
}LSContext;
typedef struct tagAcquisitionTimeSettings
{
QTime qtStartTime;
QTime qtStopTime;
QTime qtInterval;
}AcqTimeSettings;
typedef struct tagAcquisitionPositionSettings
{
int iTotalPosition;
int iPosition[MAX_LINEARSHUTTER_POSITION];
}AcqPosSettings;
typedef struct tagRunTimeGrabberParams
{
LSContext lscParam;
FSContext fscParams;
AcqTimeSettings atsParams;
AcqPosSettings apsParams;
}RunTimeGrabberParams;
typedef struct tagATPCalibrationSettings
{
//Up0 Down1,2,3
QString qsISIF_CalibrationFilePath[4];
QString qsIS1_CalibrationFilePath[4];
}ATPCalibrationSettings;
}
//?????????????<3F><>??
namespace ZZ_DATAFILE
{
typedef struct tagEnvironmentalContext
{
QString qstrUTCDateTime;
QString qstrLocation;
QString qstrGPS_Longtitude;
QString qstrGPS_Latitude;
QString qstrGPS_Altitude;
QString qstrGPS_North;
QString qstrCaseTemperature;
QString qstrCaseHumidity;
QString qstrDEV_SN;
}EContext;
typedef struct tagManmadeEnviromentalContext
{
QString qstrOriFileName;
QString qstrInstallationTime;
QString qstrISIFCalibrationTime;
QString qstrIS1CalibrationTime;
QString qstrNameOfMaintenanceStaff;
QString qstrPhoneNumberOfMaintenanceStaff;
QString qstrDownloadUserID;
QString qstrDownlaodAddress;
QString qstrHTTPServer;
}MEContext;
typedef struct tagIS1Information
{
QString qstrSN_ATP;
QString qstrSN_IRIS;
QString qstrCalFile_U0;
QString qstrCalFile_D1;
QString qstrCalFile_D2;
QString qstrCalFile_D3;
int iPixelCount;
int iExposureTimeInMS_U0;
int iExposureTimeInMS_D1;
int iExposureTimeInMS_D2;
int iExposureTimeInMS_D3;
float fTemperature_U0;
float fTemperature_D1;
float fTemperature_D2;
float fTemperature_D3;
}IS1Info;
typedef struct tagISIFInformation
{
QString qstrSN_ATP;
QString qstrSN_IRIS;
QString qstrCalFile_U0;
QString qstrCalFile_D1;
QString qstrCalFile_D2;
QString qstrCalFile_D3;
int iPixelCount;
int iExposureTimeInMS_U0;
int iExposureTimeInMS_D1;
int iExposureTimeInMS_D2;
int iExposureTimeInMS_D3;
float fTemperature_U0;
float fTemperature_D1;
float fTemperature_D2;
float fTemperature_D3;
}ISIFInfo;
typedef struct tagATPDataHeader
{
}ATPDataHeader;
typedef struct tagCalibrationFrame
{
ZZ_U32 uiExposureTimeInMS;
float fTemperature;
int iPixels;
float fWaveLength[4096] = { 0 };
double dCal_Gain[4096] = { 0 };
double dCal_Offset[4096] = { 0 };
}CalFrame;
typedef struct tagCalDataFrame
{
ZZ_U32 usExposureTimeInMS;
float fTemperature = 0;
int iPixels;
float fData[4096];
QString qstrGrabDate;
}CalDataFrame;
}
//misc detector
namespace MISC_DETECTOR
{
typedef struct tagHumitureDeviceInfo
{
QString qstrInterfaceName;
}HumitureDeviceInfo;
}
};

53
othersoft/calibration_console/Header_Files/atpFiberImager.h Normal file
View File

@ -0,0 +1,53 @@
#pragma once
#include <qthread.h>
//#include <QFileDialog>
#include <QDateTime>
#include <iostream>
#include <fstream>
#include "ATPControl_Serial_QT.h"
#include "FiberSpectrometerOperationBase.h"
class ATPFiberImager :public QObject,public FiberSpectrometerOperationBase
{
Q_OBJECT
public:
ATPFiberImager(bool bIsUSBMode, std::string ucPortNumber, std::string strDeviceName);
~ATPFiberImager();
ZZ_ATPControl_Serial_Qt * m_FiberSpectrometer;
void connectFiberSpectrometer(QString& sn, QString& pixelCount, QString& wavelengthInfo);
void disconnectFiberSpectrometer();
void getDeviceAttribute(DeviceAttribute& deviceAttribute);
void getDeviceInfo(DeviceInfo& deviceInfo);
void setExposureTime(int iExposureTimeInMS);
void getExposureTime(int &iExposureTimeInMS);//ok
void getDeviceTemperature(float &fTemperature);//ok
void singleShot(DataFrame &dfData);
void getNonlinearityCoeffs(coeffsFrame &coeffs);
ZZ_S32 GetMaxValue(ZZ_S32 * dark, int number);
// DataFrame m_IntegratingSphereData;
// DataFrame m_DarkData;
protected:
private:
std::string mUcPortNumber;
// ZZ_U32 m_MaxValueOfFiberSpectrometer;
public slots:
void recordDark(QString path);
void recordTarget(int recordTimes, QString path);
void autoExpose();
signals:
void sendExposureTimeSignal(int exposureTime);
};

51
othersoft/calibration_console/Header_Files/calibration.h Normal file
View File

@ -0,0 +1,51 @@
#pragma once
#include <qthread.h>
//#include <QFileDialog>
#include <QFile>
#include <QDataStream>
#include <QFileInfo>
#include <QDateTime>
#include <iostream>
#include <fstream>
#include "ZZ_Types.h"
#include "ZZ_Math.h"
//#include "Dense"
#include "Eigen/Dense"
#include "unsupported/Eigen/Splines"
using namespace ZZ_MISCDEF::IRIS::FS;
class CalibrationAlgorithm :public QObject
{
Q_OBJECT
public:
CalibrationAlgorithm();
~CalibrationAlgorithm();
void readAndResample_StandardLightFile(QString filePath, int integratingSphereDetectorValue, DeviceAttribute deviceAttribute, DeviceInfo deviceInfo);//
void produceCalfile(QString calFilePath, DeviceAttribute deviceAttribute, DataFrame integratingSphereData, DataFrame darkData);
protected:
private:
double m_dStandardLightDataBase;//<2F><>׼<EFBFBD><D7BC><EFBFBD>ļ<EFBFBD><C4BC>Ļ<EFBFBD>׼<EFBFBD><D7BC><EFBFBD><EFBFBD>
double * m_dStandardLightWavelength;
double * m_dStandardLightData;
double * m_dStandardLightWavelengthResampled;
double * m_dStandardLightDataResampled;
double * m_gain;
double * m_offset;
public slots:
signals:
};

71
othersoft/calibration_console/Header_Files/library.h Normal file
View File

@ -0,0 +1,71 @@
#ifndef OCEAN_LIB_LIBRARY_H
#define OCEAN_LIB_LIBRARY_H
#include <cstdio>
#include <cstdlib>
#include <ctime>
//#include <unistd.h>
#include <chrono>
#include "api/SeaBreezeWrapper.h"
#include "IrisFiberSpectrometerBase.h"
#include "api/seabreezeapi/SeaBreezeAPI.h"
#include "api/seabreezeapi/NonlinearityCoeffsFeatureAdapter.h"
using namespace std;
class OceanOptics_lib :public CIrisFSBase
{
public:
OceanOptics_lib();
virtual ~OceanOptics_lib();
public:
//初始化设备
//此处string为指明连接哪个ocean光谱仪的参数，可自行更换为其他c/c++标准类型
//0为无错误，不同错误请返回不同值(不能确定：当不成功时SeaBreeze返回的错误代码error不为0 → 不敢将error直接返回)
int Initialize(bool bIsUSBMode, std::string ucPortNumber, std::string strDeviceName);//ok
int Initialize();//ok
//关闭设备
void Close();//ok
//单次数据采集
int SingleShot(DataFrame &dfData);
//设置曝光时间
int SetExposureTime(int iExposureTimeInMS);//ok
//获取曝光时间设置
int GetExposureTime(int &iExposureTimeInMS);//ok
//设置目标温度
int SetDeviceTemperature(float fTemperature);//ok
//获取温度设置
int GetDeviceTemperature(float &fTemperature);//ok
//获取设备信息
int GetDeviceInfo(DeviceInfo &Info);//ok
//获取设备特征数据
int GetDeviceAttribute(DeviceAttribute &Attr);//ok
//tc
static const char* get_error_string(int error);
void test_nonlinearity_coeffs_feature();
private:
int m_iSpectralmeterHandle;
DeviceInfo m_deviceInfo;
int m_iExposureTime;
bool isSuccess(char* resultStr);
string GetDeviceType(int index);
string GetSerialNumber(int index);
};
#endif //OCEAN_LIB_LIBRARY_H

58
othersoft/calibration_console/Header_Files/oceanOpticsFiberImager.h Normal file
View File

@ -0,0 +1,58 @@
#pragma once
#include <qthread.h>
//#include <QFileDialog>
#include <QDateTime>
#include <iostream>
#include <fstream>
#include "library.h"
#include "FiberSpectrometerOperationBase.h"
class OceanOpticsFiberImager :public QObject,public FiberSpectrometerOperationBase
{
Q_OBJECT
public:
OceanOpticsFiberImager(double * nonlinearityCoeffs, int numberOfCoeffs);
~OceanOpticsFiberImager();
OceanOptics_lib * m_FiberSpectrometer;
void connectFiberSpectrometer(QString& sn, QString& pixelCount, QString& wavelengthInfo);
void disconnectFiberSpectrometer();
void getDeviceAttribute(DeviceAttribute& deviceAttribute);
void getDeviceInfo(DeviceInfo& deviceInfo);
void setExposureTime(int iExposureTimeInMS);
void getExposureTime(int &iExposureTimeInMS);//ok
void getDeviceTemperature(float &fTemperature);//ok
void singleShot(DataFrame &dfData);
void getNonlinearityCoeffs(coeffsFrame &coeffs);
ZZ_S32 GetMaxValue(ZZ_S32 * dark, int number);
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ÿ<EFBFBD>ζ<EFBFBD><CEB6><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
DeviceInfo m_deviceInfo;
DeviceAttribute m_deviceAttribute;
// DataFrame m_IntegratingSphereData;
// DataFrame m_DarkData;
protected:
private:
double * m_nonlinearityCoeffs;
int m_iNumberOfNonlinearityCoeffs;
// ZZ_U32 m_MaxValueOfFiberSpectrometer;
public slots:
void recordDark(QString path);
void recordTarget(int recordTimes, QString path);
void autoExpose();
signals:
void sendExposureTimeSignal(int exposureTime);
};

886
othersoft/calibration_console/Source_Files/ATPControl_Serial_QT.cpp Normal file
View File

@ -0,0 +1,886 @@
//#include "pch.h"
#include "Header_Files/ATPControl_Serial_QT.h"
//#include "ZZ_Math_HDRONLY.h"
ZZ_ATPControl_Serial_Qt::ZZ_ATPControl_Serial_Qt(QObject* parent /*= nullptr*/)
{
m_pSerialPort = new QSerialPort;
m_iBaudRate = 115200;
//emit SignalInit_Self();
}
ZZ_ATPControl_Serial_Qt::~ZZ_ATPControl_Serial_Qt()//
{
if (m_pSerialPort != NULL)
{
delete m_pSerialPort;
}
}
// int ZZ_ATPControl_Serial_Qt::ReInit()
// {
// m_pSerialPort->close();
// delete m_pSerialPort;
//
// m_pSerialPort = new QSerialPort;
//
// m_pSerialPort->setPortName("COM7");
// m_pSerialPort->setReadBufferSize(512);
// bool bRes = m_pSerialPort->setBaudRate(m_iBaudRate);
// bRes = m_pSerialPort->open(QIODevice::ReadWrite);
// }
// int ZZ_ATPControl_Serial_Qt::SetBaudRate(int iBaud)
// {
// m_iBaudRate = iBaud;
// return 0;
// }
int ZZ_ATPControl_Serial_Qt::Initialize(bool bIsUSBMode, std::string ucPortNumber, std::string strDeviceName)
{
//connect(this, &ZZ_ATPControl_Serial_Qt::SignalInit_Self, this, &ZZ_ATPControl_Serial_Qt::Init_Self);
//emit SignalInit_Self();
QString qstrPortName = QString::fromStdString(ucPortNumber);
m_pSerialPort->setPortName(qstrPortName);
m_pSerialPort->setReadBufferSize(512);
bool bRes = m_pSerialPort->setBaudRate(m_iBaudRate);
if (!bRes)
{
qDebug() << "Err:setBaudRate Failed.Exit Code:1";
//std::cout << "Err.setBaudRate Failed" << std::endl;
return 1;
}
bRes = m_pSerialPort->open(QIODevice::ReadWrite);
if (!bRes)
{
qDebug() << "Err:open Failed.Exit Code:2";
//std::cout << "Err.open Failed" << std::endl;
return 2;
}
// int testi;
// GetDeviceAttribute(m_daDeviceAttr);
// GetExposureTime(testi);
// SetExposureTime(10000);
// DataFrame test;
// SingleShot(test);
GetDeviceInfo(m_diDeviceInfo);
GetExposureTime_Init();
SetAvgTimes(1);
std::string::size_type szPostion = m_diDeviceInfo.strSN.find(strDeviceName);
if (szPostion == std::string::npos)
{
qDebug() << "Err:FS serial number not match.Exit Code:3";
return 3;
}
else
{
return 0;
}
return 0;
}
void ZZ_ATPControl_Serial_Qt::Close()
{
m_pSerialPort->close();
}
int ZZ_ATPControl_Serial_Qt::GetDeviceInfo(DeviceInfo &Info)
{
QByteArray qbSend, qbRecv;
qbSend.clear();
qbRecv.clear();
qbSend.append(GET_PN_NUMBER);
int iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceInfo Failed,Communication error.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceInfo Failed,Communication error.Exit Code:1";
return 1;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceInfo Failed,Communication error.Exit Code:1";
return 1;
}
m_diDeviceInfo.strPN = qbRecv.data();
qbSend.clear();
qbRecv.clear();
qbSend.append(GET_SN_NUMBER);
iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceInfo Failed,Communication error.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceInfo Failed,Communication error.Exit Code:1";
return 1;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceInfo Failed,Communication error.Exit Code:1";
return 1;
}
m_diDeviceInfo.strSN = qbRecv.data();
Info = m_diDeviceInfo;
return 0;
}
int ZZ_ATPControl_Serial_Qt::GetDeviceAttribute(DeviceAttribute &Attr)
{
QByteArray qbSend, qbRecv;
qbSend.clear();
qbRecv.clear();
qbSend.append(GET_MIN_INTEGRATION_TIME);
int iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Communication error.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Communication error.Exit Code:1";
return 1;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Communication error.Exit Code:1";
return 1;
}
m_daDeviceAttr.iMinIntegrationTimeInMS = (ZZ_U8)qbRecv[1] + (ZZ_U8)qbRecv[0] * 256;
qbSend.clear();
qbRecv.clear();
qbSend.append(GET_MAX_INTEGRATION_TIME);
iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Communication error.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Communication error.Exit Code:1";
return 1;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Communication error.Exit Code:1";
return 1;
}
m_daDeviceAttr.iMaxIntegrationTimeInMS = (ZZ_U8)qbRecv[1] + (ZZ_U8)qbRecv[0] * 256;
///
int iTempExpTime = 0;
GetExposureTime(iTempExpTime);
iRes = SetExposureTime(m_daDeviceAttr.iMinIntegrationTimeInMS);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Call SetExposureTime error.Exit Code:2";
//return 2;
}
iRes = SingleShot(m_daDeviceAttr.iPixels);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Call SingleShot error.Exit Code:3";
return 3;
}
SetExposureTime(iTempExpTime);
///
qbSend.clear();
qbRecv.clear();
qbSend.append(GET_WAVELENGTH_CALIBRATION_COEF);
qbSend.resize(3);
qbSend[1] = 0x00;
qbSend[2] = 0x01;
iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Communication error.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Communication error.Exit Code:1";
return 1;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceAttribute Failed,Communication error.Exit Code:1";
return 1;
}
float fWaveLengthCoef[4];
memcpy(fWaveLengthCoef, qbRecv.data() + 16, 4 * sizeof(float));
for (int i = 0; i < m_daDeviceAttr.iPixels; i++)
{
m_daDeviceAttr.fWaveLengthInNM[i] = fWaveLengthCoef[0] * i*i*i + fWaveLengthCoef[1] * i*i + fWaveLengthCoef[2] * i + fWaveLengthCoef[3];
}
Attr = m_daDeviceAttr;
return 0;
}
int ZZ_ATPControl_Serial_Qt::SetDeviceTemperature(float fTemperature)
{
return 0;
}
int ZZ_ATPControl_Serial_Qt::SetAvgTimes(int iTimes /*= 1*/)
{
QByteArray qbSend, qbRecv;
qbSend.clear();
qbRecv.clear();
qbSend.append(SET_AVERAGE_NUMBER);
qbSend.resize(3);
qbSend[1] = 0x00;
qbSend[2] = 0x01;
int iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:SetAvgTimes Failed.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:SetAvgTimes Failed.Exit Code:2";
return 2;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:SetAvgTimes Failed.Exit Code:3";
return 3;
}
return 0;
}
int ZZ_ATPControl_Serial_Qt::GetExposureTime_Init()
{
QByteArray qbSend, qbRecv;
qbSend.clear();
qbRecv.clear();
qbSend.append(GET_INTEGRATION_TIME);
qbSend.resize(3);
qbSend[1] = 0x00;
qbSend[2] = 0x01;
int iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:GetExposureTime Failed.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetExposureTime Failed.Exit Code:2";
return 2;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetExposureTime Failed.Exit Code:3";
return 3;
}
m_iExposureTime = (ZZ_U8)qbRecv[1] + (ZZ_U8)qbRecv[0] * 256;
return 0;
}
int ZZ_ATPControl_Serial_Qt::SendCommand(QByteArray qbCommand)
{
int iSize = qbCommand.size() + 3;
QByteArray qbSend;
qbSend.resize(4);
qbSend[0] = (ZZ_U8)0xAA;
qbSend[1] = 0x55;
qbSend[2] = iSize / 256;
qbSend[3] = iSize % 256;
qbSend.append(qbCommand);
int iSum = 0;
for (int i = 0; i < iSize - 1; i++)
{
iSum = iSum + qbSend[i + 2];
}
qbSend.append(iSum % 256);
qint64 qi64Write = m_pSerialPort->write(qbSend);
if (qi64Write != qbSend.size())
{
qDebug() << "Err:write Failed.Exit Code:1" << qi64Write;
return 1;
}
return 0;
}
int ZZ_ATPControl_Serial_Qt::RecvData(QByteArray &qbData)
{
qbData.clear();
qbData = m_pSerialPort->readAll();
int iCounter = 0;
while (qbData.size() < 4)
{
m_pSerialPort->waitForReadyRead(5000);
QByteArray qbTemp = m_pSerialPort->readAll();
qbData.append(qbTemp);
if (iCounter > 150)
{
qDebug() << "Err:RecvData Failed,Not Enough Data.Exit Code:1" << qbData.size();
return 1;
}
iCounter++;
}
if ((ZZ_U8)qbData[0] != (ZZ_U8)0xaa || (ZZ_U8)qbData[1] != (ZZ_U8)0x55)
{
qDebug() << "Err:RecvData Failed,Wrong Header.Exit Code:2" << qbData.size();
return 2;
}
iCounter = 0;
int iLength = qbData[2] * 256 + qbData[3] + 2;
while (qbData.size() < iLength)
{
m_pSerialPort->waitForReadyRead(5000);
qbData.append(m_pSerialPort->readAll());
if (iCounter > 200)
{
qDebug() << "Err:RecvData Failed,Incomplete Data.Exit Code:3" << qbData.size();
return 3;
}
iCounter++;
}
if (qbData.size() > iLength)
{
qbData.remove(iLength - 1, qbData.size() - iLength);
}
int iCheckSumLength = iLength - 3;
ZZ_U16 usCheckSum = 0;
for (int i = 0; i < iCheckSumLength; i++)
{
usCheckSum += qbData[i + 2];
}
usCheckSum = usCheckSum % 256;
ZZ_U8 ucTemp = qbData[qbData.size() - 1];
if ((ZZ_U8)usCheckSum != ucTemp)
{
qDebug() << "Err:RecvData Failed,Incorrect Check Sum.Exit Code:4" << "Total Recv:" << qbData.size() << "Check Sum:" << usCheckSum << "Not Equal To" << ucTemp;
//qbData.clear();
//return 4;
return 0;
}
return 0;
}
int ZZ_ATPControl_Serial_Qt::RecvData_ShortLag(QByteArray &qbData)
{
qbData.clear();
qbData = m_pSerialPort->readAll();
int iCounter = 0;
while (qbData.size() < 4)
{
m_pSerialPort->waitForReadyRead(100);
QByteArray qbTemp = m_pSerialPort->readAll();
qbData.append(qbTemp);
if (iCounter > 6)
{
qDebug() << "Err:RecvData_ShortLag Failed,Not Enough Data.Exit Code:1" << qbData.size();
return 1;
}
iCounter++;
}
if ((ZZ_U8)qbData[0] != (ZZ_U8)0xaa || (ZZ_U8)qbData[1] != (ZZ_U8)0x55)
{
qDebug() << "Err:RecvData_ShortLag Failed,Wrong Header.Exit Code:2" << qbData.size();
return 2;
}
iCounter = 0;
int iLength = qbData[2] * 256 + qbData[3] + 2;
while (qbData.size() < iLength)
{
m_pSerialPort->waitForReadyRead(100);
qbData.append(m_pSerialPort->readAll());
if (iCounter > 6)
{
qDebug() << "Err:RecvData_ShortLag Failed,Incomplete Data.Exit Code:3" << qbData.size();
return 3;
}
iCounter++;
}
if (qbData.size() > iLength)
{
qbData.remove(iLength - 1, qbData.size() - iLength);
}
int iCheckSumLength = iLength - 3;
ZZ_U16 usCheckSum = 0;
for (int i = 0; i < iCheckSumLength; i++)
{
usCheckSum += qbData[i + 2];
}
usCheckSum = usCheckSum % 256;
ZZ_U8 ucTemp = qbData[qbData.size() - 1];
if ((ZZ_U8)usCheckSum != ucTemp)
{
qDebug() << "Err:RecvData_ShortLag Failed,Incorrect Check Sum.Exit Code:4" << "Total Recv:" << qbData.size() << "Check Sum:" << usCheckSum << "Not Equal To" << ucTemp;
//qbData.clear();
//return 4;
return 0;
}
return 0;
}
int ZZ_ATPControl_Serial_Qt::ParseData(QByteArray &qbData)
{
if (qbData.size() < 6)
{
qDebug() << "Err:ParseData Failed,Not Enough Data.Exit Code:1" << qbData.size();
return 1;
}
qbData.remove(0, 5);
qbData.remove(qbData.size() - 1, 1);
return 0;
}
int ZZ_ATPControl_Serial_Qt::Init_Self()
{
m_pSerialPort = new QSerialPort;
return 0;
}
int ZZ_ATPControl_Serial_Qt::PerformAutoExposure(float fMinScaleFactor, float fMaxScaleFactor, float &fPredictedExposureTime)
{
using namespace ZZ_MATH;
int iDeviceDepth = 65535;
bool bFlagIsOverTrying = false;
bool bFlagIsLowerMinExposureTime = false;
bool bFlagIsOverMaxExposureTime = false;
bool bFlagIsAutoExposureOK = false;
bool bFlagIsAutoExposureFailed = false;
bool bIsValueOverflow = false;
bool bIsLastValueOverflow = false;
float fExposureTime = 0;
float fTempExposureTime = 0;
double fLastExposureTime = 0.1;
int iRepeatCount = 0;
int iRes = SetExposureTime(m_daDeviceAttr.iMinIntegrationTimeInMS);//need change to load from files
if (iRes != 0)
{
qDebug() << "Err:PerformAutoExposure Failed.Exit Code:1";
return 1;
}
while (!bFlagIsAutoExposureOK && !bFlagIsAutoExposureFailed)
{
DataFrame dfTemp;
if (iRepeatCount++ > 30)
{
bFlagIsAutoExposureFailed = true;
bFlagIsOverTrying = true;
qDebug() << "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>30<EFBFBD><EFBFBD>"<<endl;
break;
}
// fExposureTime = (float)m_daDeviceAttr.iMinIntegrationTimeInMS;
int tc_tmp;
GetExposureTime(tc_tmp);
fExposureTime=tc_tmp;
fTempExposureTime = fExposureTime;
iRes = SingleShot(dfTemp);
if (iRes != 0)
{
qDebug() << "Err:PerformAutoExposure Failed.Exit Code:2"<<endl;
return 2;
}
HeapSort(dfTemp.lData, m_daDeviceAttr.iPixels);
double dSum = 0;
int iCount = m_daDeviceAttr.iPixels / 100;
for (int i = 0; i < iCount; i++)
{
dSum += dfTemp.lData[i];
}
double dTemp = dSum / iCount;
qDebug() << "1111111111111111111111111111111" << dTemp << endl;
if (dTemp >= iDeviceDepth * 0.99)
{
bIsValueOverflow = true;
if (!bIsLastValueOverflow)
{
fExposureTime = (float)(fLastExposureTime + fExposureTime) / 2;
}
else
{
fExposureTime = fExposureTime / 2;
}
}
else if (iDeviceDepth * fMaxScaleFactor >= dTemp && dTemp >= iDeviceDepth * fMinScaleFactor)
{
bFlagIsAutoExposureOK = 1;
continue;
}
else if (dTemp > iDeviceDepth * fMaxScaleFactor)
{
bIsValueOverflow = true;
if (!bIsLastValueOverflow)
{
fExposureTime = (float)(fLastExposureTime + fExposureTime) / 2;
}
else
{
fExposureTime = fExposureTime * 3 / 4;
}
}
else if (dTemp < iDeviceDepth * fMinScaleFactor)
{
bIsValueOverflow = false;
if (bIsLastValueOverflow)
{
fExposureTime = (float)(fLastExposureTime + fExposureTime) / 2;
}
else
{
double dFactor;
dFactor = dTemp / (iDeviceDepth * fMaxScaleFactor);
fExposureTime = (float)(fExposureTime / dFactor);
}
if (fExposureTime < m_daDeviceAttr.iMinIntegrationTimeInMS)
{
bFlagIsAutoExposureOK = false;
bFlagIsAutoExposureFailed = true;
bFlagIsLowerMinExposureTime = true;
qDebug() << "lower-----------------------"<<endl;
}
}
bIsLastValueOverflow = bIsValueOverflow;
fLastExposureTime = fTempExposureTime;
if (fExposureTime > 13000)
{
bFlagIsAutoExposureOK = false;
bFlagIsAutoExposureFailed = true;
fPredictedExposureTime = 13000;
iRes = SetExposureTime(13000);
if (iRes != 0)
{
qDebug() << "Err:PerformAutoExposure Failed.Exit Code:3";
return 3;
}
bFlagIsOverMaxExposureTime = true;
break;
}
iRes = SetExposureTime((int)fExposureTime);
if (iRes != 0)
{
qDebug() << "Err:PerformAutoExposure Failed.Exit Code:4";
return 3;
}
}
fPredictedExposureTime = fExposureTime;
return 0;
}
// int ZZ_ATPControl_Serial_Qt::SetExtShutter(int iShutterUP0, int iShutterDOWN1, int iShutterDOWN2, int iShutterDOWN3)
// {
// qDebug() << "stub code not implemented";
// return -1;
// }
int ZZ_ATPControl_Serial_Qt::SetExposureTime(int iExposureTimeInMS)
{
m_iExposureTime = iExposureTimeInMS;
QByteArray qbExposureTime, qbRecv;
//qbExposureTime.append(SET_INTEGRATION_TIME);
qbExposureTime.resize(3);
qbExposureTime[0] = SET_INTEGRATION_TIME;
qbExposureTime[1] = iExposureTimeInMS >> 8;
qbExposureTime[2] = iExposureTimeInMS & 0xFF;
int iRes = SendCommand(qbExposureTime);
if (iRes != 0)
{
qDebug() << "Err:SetExposureTime Failed.Exit Code:2";
return 2;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:SetExposureTime Failed.Exit Code:3";
return 3;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:SetExposureTime Failed.Exit Code:4";
return 4;
}
if ((ZZ_U8)qbRecv[0] != 0)
{
qDebug() << "Err:SetExposureTime Failed.Exit Code:1";
//return 1;
}
return 0;
}
int ZZ_ATPControl_Serial_Qt::GetExposureTime(int &iExposureTimeInMS)
{
// QByteArray qbSend, qbRecv;
// qbSend.clear();
// qbRecv.clear();
// qbSend.append(GET_INTEGRATION_TIME);
// qbSend.resize(3);
// qbSend[1] = 0x00;
// qbSend[2] = 0x01;
// int iRes = SendCommand(qbSend);
// if (iRes != 0)
// {
// qDebug() << "Err:GetExposureTime Failed.Exit Code:1";
// return 1;
// }
// iRes = RecvData(qbRecv);
// if (iRes != 0)
// {
// qDebug() << "Err:GetExposureTime Failed.Exit Code:2";
// return 2;
// }
// iRes = ParseData(qbRecv);
// if (iRes != 0)
// {
// qDebug() << "Err:GetExposureTime Failed.Exit Code:3";
// return 3;
// }
//
// iExposureTimeInMS = (ZZ_U8)qbRecv[1] + (ZZ_U8)qbRecv[0] * 256;
iExposureTimeInMS = m_iExposureTime;
return 0;
}
int ZZ_ATPControl_Serial_Qt::SingleShot(DataFrame &dfData)
{
QByteArray qbSend, qbRecv;
qbSend.clear();
qbRecv.clear();
qbSend.append(SYNC_GET_DATA);
qbSend.resize(3);
// qbSend[1] = 0x00;
// qbSend[2] = 0x01;
qbSend[1] = m_iExposureTime >> 8;;
qbSend[2] = m_iExposureTime & 0xFF;
qDebug() << "-------------"<<m_iExposureTime<<endl;
int iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:SingleShot Failed.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:SingleShot Failed.Exit Code:2";
return 2;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:SingleShot Failed.Exit Code:3";
return 3;
}
ZZ_U16 usData[4096] = { 0 };
if ((ZZ_U8)qbRecv[0] != 0)
{
qDebug() << "Err:SingleShot Failed.Exit Code:1";
return 1;
}
else
{
//int aaa = qbRecv.size();
int iDataSizeInPixel = (qbRecv.size() - 1) / 2;
memcpy(usData, qbRecv.data() + 1, iDataSizeInPixel * 2);
for (size_t i = 0; i < iDataSizeInPixel; i++)
{
dfData.lData[i] = qToBigEndian(usData[i]);
}
// for (int i = 0; i < iDataSizeInPixel; i++)
// {
// dfData.lData[i] = usData[i];
// }
}
dfData.usExposureTimeInMS = m_iExposureTime;
return 0;
}
int ZZ_ATPControl_Serial_Qt::SingleShot(int &iPixels)
{
QByteArray qbSend, qbRecv;
qbSend.clear();
qbRecv.clear();
qbSend.append(SYNC_GET_DATA);
qbSend.resize(3);
qbSend[1] = 0x00;
qbSend[2] = 0x01;
int iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:SingleShotP Failed.Exit Code:1";
return 1;
}
iRes = RecvData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:SingleShotP Failed.Exit Code:2";
return 2;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:SingleShot Failed.Exit Code:3";
return 3;
}
if ((ZZ_U8)qbRecv[0] != 0)
{
qDebug() << "Err:SingleShotP Failed.Exit Code:4";
return 4;
}
else
{
iPixels = (qbRecv.size() - 1) / 2;
}
return 0;
}
// int ZZ_ATPControl_Serial_Qt::SingleShotDark(ATPDataFrame &dfData)
// {
// SetExtShutter(0,0,0,0);
// SingleShot(dfData);
// return 0;
// }
int ZZ_ATPControl_Serial_Qt::GetDeviceTemperature(float &fTemperature)
{
fTemperature = 0;
QByteArray qbSend, qbRecv;
qbSend.clear();
qbRecv.clear();
qbSend.append(GET_TEC_TEMP);
qbSend.resize(3);
qbSend[1] = 0x00;
qbSend[2] = 0x01;
int iRes = SendCommand(qbSend);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceTemperature Failed.Exit Code:1";
return 1;
}
iRes = RecvData_ShortLag(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceTemperature Failed.Exit Code:2";
return 2;
}
iRes = ParseData(qbRecv);
if (iRes != 0)
{
qDebug() << "Err:GetDeviceTemperature Failed.Exit Code:3";
return 3;
}
QString qstrTemp = qbRecv.data();
fTemperature = qstrTemp.toFloat();
return 0;
}
//void ZZ_ATPControl_Serial_Qt::ReadMessage()
//{
// QByteArray qbTemp, qbTemp1;
// qbTemp = m_pSerialPort->readAll();
// while (qbTemp.size()<2)
// {
// m_pSerialPort->waitForReadyRead(50);
// qbTemp1 = m_pSerialPort->readAll();
// qbTemp.append(qbTemp1);
// }
//return;
// }

113
othersoft/calibration_console/Source_Files/ZZ_Math.cpp Normal file
View File

@ -0,0 +1,113 @@
//#include "pch.h"
#include "Header_Files/ZZ_Math.h"
void ZZ_MATH::PolyFit::Eigen_Polyfit(const std::vector<double> &xv, const std::vector<double> &yv, std::vector<double> &coeff, int order)
{
Eigen::MatrixXd A(xv.size(), order + 1);
Eigen::VectorXd yv_mapped = Eigen::VectorXd::Map(&yv.front(), yv.size());
Eigen::VectorXd result;
assert(xv.size() == yv.size());
assert(xv.size() >= order + 1);
for (size_t i = 0; i < xv.size(); i++)
{
for (size_t j = 0; j < order + 1; j++)
{
A(i, j) = pow(xv.at(i), j);
}
}
result = A.householderQr().solve(yv_mapped);
coeff.resize(order + 1);
for (size_t i = 0; i < order + 1; i++)
{
coeff[i] = result[i];
}
}
double ZZ_MATH::PolyFit::Eigen_Polyeval(std::vector<double> coeffs, double x)
{
double result = 0.0;
for (int i = 0; i < coeffs.size(); i++)
{
result += coeffs[i] * pow(x, i);
}
return result;
}
Eigen::VectorXd ZZ_MATH::SplineFit::Eigen_Normalize(const Eigen::VectorXd &x)
{
using namespace Eigen;
VectorXd x_norm;
x_norm.resize(x.size());
const double min = x.minCoeff();
const double max = x.maxCoeff();
for (int k = 0; k < x.size(); k++)
{
x_norm(k) = (x(k) - min) / (max - min);
}
return x_norm;
}
void ZZ_MATH::SplineFit::Test(std::vector<double> const &x_vec, std::vector<double> const &y_vec)
{
typedef Spline<double, 1> Spline1D;
typedef SplineFitting<Spline1D> Spline1DFitting;
//VectorXd vx,vy;
//vx.resize(x_vec.size());
//vy.resize(y_vec.size());
//vx.Map(&x_vec.front(), x_vec.size());
//vy.Map(&y_vec.front(), y_vec.size());
Eigen::VectorXd vx = Eigen::VectorXd::Map(&x_vec.front(), 5/*x_vec.size()*/);
Eigen::VectorXd vy = Eigen::VectorXd::Map(&y_vec.front(), 5/*y_vec.size()*/);
const double scale = 1 / (vx.maxCoeff() - vx.minCoeff());
const double scale_sq = scale * scale;
//VectorXd knots = Eigen_Normalize(vx);
//Spline1D spline = Spline1DFitting::Interpolate(vy.transpose(),3, knots);
//double a;
// a = spline.derivatives(0,1)(0);
//Eigen::VectorXd xvals(5);
//Eigen::VectorXd yvals(xvals.rows());
//xvals << 0, 1, 2,3,4;
//yvals << 0, 1, 4,9,16;
SplineInterpolation s(vx, vy);
}
ZZ_MATH::SplineFit::SplineInterpolation::SplineInterpolation(Eigen::VectorXd const &x_vec, Eigen::VectorXd const &y_vec):
x_min(x_vec.minCoeff()), x_max(x_vec.maxCoeff()),
spline_(Eigen::SplineFitting<Eigen::Spline<double, 1>>::
Interpolate(y_vec.transpose(), 3, scaled_values(x_vec)))
{
}
double ZZ_MATH::SplineFit::SplineInterpolation::operator()(double x) const
{
return spline_(scaled_value(x))(0);
}
double ZZ_MATH::SplineFit::SplineInterpolation::scaled_value(double x) const
{
return (x - x_min) / (x_max - x_min);
}
Eigen::RowVectorXd ZZ_MATH::SplineFit::SplineInterpolation::scaled_values(Eigen::VectorXd const &x_vec) const
{
return x_vec.unaryExpr([this](double x) { return scaled_value(x); }).transpose();
}

194
othersoft/calibration_console/Source_Files/atpFiberImager.cpp Normal file
View File

@ -0,0 +1,194 @@
#include "Header_Files/atpFiberImager.h"
ATPFiberImager::ATPFiberImager(bool bIsUSBMode, std::string ucPortNumber, std::string strDeviceName)
{
m_FiberSpectrometer = NULL;
mUcPortNumber=ucPortNumber;
}
ATPFiberImager::~ATPFiberImager()
{
}
void ATPFiberImager::connectFiberSpectrometer(QString& SN, QString& pixelCount, QString& wavelengthInfo)
{
using namespace std;
m_FiberSpectrometer = new ZZ_ATPControl_Serial_Qt();
m_FiberSpectrometer->Initialize(false, mUcPortNumber, "OPTOSKY");
DeviceInfo deviceInfo;//
DeviceAttribute deviceAttribute;
m_FiberSpectrometer->GetDeviceInfo(deviceInfo);
m_FiberSpectrometer->GetDeviceAttribute(deviceAttribute);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SN = QString::fromStdString(deviceInfo.strSN);
pixelCount = QString::number(deviceAttribute.iPixels);
wavelengthInfo = QString::number(deviceAttribute.fWaveLengthInNM[0]) + "--" + QString::number(deviceAttribute.fWaveLengthInNM[deviceAttribute.iPixels - 1]);
m_FiberSpectrometer->SetDeviceTemperature(-10);
//<2F><><EFBFBD><EFBFBD>dnֵ<6E><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD>أ<EFBFBD>
string qepro = "QEP";//?????????????????????????????????????????????????????????????????????????????????????????
string flame = "FLMS";//?????????????????????????????????????????????????????????????????????????????????????????
if (deviceInfo.strSN.find(qepro) != string::npos)
{
m_MaxValueOfFiberSpectrometer = 200000;
}
else if (deviceInfo.strSN.find(flame) != string::npos)
{
m_MaxValueOfFiberSpectrometer = 65535;
}
else//û<><C3BB><EFBFBD>ҵ<EFBFBD>ƥ<EFBFBD><C6A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> dnֵ<6E><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ
{
}
}
void ATPFiberImager::disconnectFiberSpectrometer()
{
m_FiberSpectrometer->Close();
}
void ATPFiberImager::getDeviceAttribute(DeviceAttribute& deviceAttribute)
{
m_FiberSpectrometer->GetDeviceAttribute(deviceAttribute);
}
void ATPFiberImager::getDeviceInfo(DeviceInfo& deviceInfo)
{
m_FiberSpectrometer->GetDeviceInfo(deviceInfo);
}
void ATPFiberImager::setExposureTime(int iExposureTimeInMS)
{
m_FiberSpectrometer->SetExposureTime(iExposureTimeInMS);
}
void ATPFiberImager::getExposureTime(int &iExposureTimeInMS)
{
m_FiberSpectrometer->GetExposureTime(iExposureTimeInMS);
}
void ATPFiberImager::getDeviceTemperature(float &fTemperature)
{
m_FiberSpectrometer->GetDeviceTemperature(fTemperature);
}
void ATPFiberImager::singleShot(DataFrame &dfData)
{
m_FiberSpectrometer->SingleShot(dfData);
}
void ATPFiberImager::getNonlinearityCoeffs(coeffsFrame &coeffs)
{
printf("This is ATPFiberImager.\n");
}
void ATPFiberImager::recordDark(QString path)
{
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8>Ϣ
DeviceAttribute attribute;
DeviceInfo deviceInfo;
getDeviceAttribute(attribute);
getDeviceInfo(deviceInfo);
//<2F>ɼ<EFBFBD><C9BC><EFBFBD>֡
singleShot(m_DarkData);
// //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>csv
// QDateTime curDateTime = QDateTime::currentDateTime();
// QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
// QString fileName = path + "/" + currentTime + "_" + QString::fromStdString(deviceInfo.strSN) + "_darkSpectral.csv";
// std::ofstream outfile(fileName.toStdString().c_str());
//
// for (int i = 0; i < attribute.iPixels; i++)
// {
// if (i==0)
// {
// outfile << m_DarkData.usExposureTimeInMS << std::endl;
// }
// outfile << attribute.fWaveLengthInNM[i] << "," << m_DarkData.lData[i] << std::endl;
// }
//
// outfile.close();
}
void ATPFiberImager::recordTarget(int recordTimes, QString path)
{
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8>Ϣ
DeviceAttribute attribute;
DeviceInfo deviceInfo;
getDeviceAttribute(attribute);
getDeviceInfo(deviceInfo);
DataFrame integratingSphereData_tmp;
for (int i = 0; i < recordTimes; i++)
{
singleShot(integratingSphereData_tmp);
if (i == 0)//<2F><>integratingSphereData_tmp<6D>е<EFBFBD><D0B5>ع<EFBFBD>ʱ<EFBFBD>䡢<EFBFBD>¶ȵ<C2B6><C8B5><EFBFBD>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD>m_IntegratingSphereData
{
m_IntegratingSphereData = integratingSphereData_tmp;
}
else
{
for (int i = 0; i < attribute.iPixels; i++)
{
m_IntegratingSphereData.lData[i] += integratingSphereData_tmp.lData[i];
}
}
}
for (int i = 0; i < attribute.iPixels; i++)
{
m_IntegratingSphereData.lData[i] = m_IntegratingSphereData.lData[i] / recordTimes;
}
// //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>csv
// QDateTime curDateTime = QDateTime::currentDateTime();
// QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
// QString fileName = path + "/" + currentTime + "_" + QString::fromStdString(deviceInfo.strSN) + "_integratingSphereSpectral.csv";
// std::ofstream outfile(fileName.toStdString().c_str());
//
// for (int i = 0; i < attribute.iPixels; i++)
// {
// if (i==0)
// {
// outfile << m_IntegratingSphereData.usExposureTimeInMS << std::endl;
// }
// outfile << attribute.fWaveLengthInNM[i] << "," << m_IntegratingSphereData.lData[i] << std::endl;
// }
//
// outfile.close();
}
void ATPFiberImager::autoExpose()
{
float fPredictedExposureTime;
m_FiberSpectrometer->PerformAutoExposure(0.6,0.9,fPredictedExposureTime);
}
ZZ_S32 ATPFiberImager::GetMaxValue(ZZ_S32 * dark, int number)
{
ZZ_S32 max = 0;
for (size_t i = 0; i < number; i++)
{
if (dark[i] > max)
{
max = dark[i];
}
}
//std::cout << "<22><>֡<EFBFBD><D6A1><EFBFBD><EFBFBD>ֵΪ" << max << std::endl;
return max;
}

246
othersoft/calibration_console/Source_Files/calibration.cpp Normal file
View File

@ -0,0 +1,246 @@
#include "Header_Files/calibration.h"
CalibrationAlgorithm::CalibrationAlgorithm()
{
}
CalibrationAlgorithm::~CalibrationAlgorithm()
{
}
void CalibrationAlgorithm::readAndResample_StandardLightFile(QString filePath, int integratingSphereDetectorValue, DeviceAttribute deviceAttribute, DeviceInfo deviceInfo)
{
QFile file(filePath);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
{
std::cout << "<EFBFBD>ļ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڣ<EFBFBD>" << std::endl;
return;
}
//<2F><>ȡ<EFBFBD><C8A1>׼<EFBFBD><D7BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int lineCount = 0;
while (!file.atEnd())
{
QByteArray tmp = file.readLine();
lineCount++;
}
double * StandardLightWavelength_tmp = new double[lineCount - 1];
double * StandardLightData_tmp = new double[lineCount - 1];
file.seek(0);
for (size_t i = 0; i < lineCount; i++)
{
QByteArray line = file.readLine();
QString str(line);
//cout << str.section('\t', 1).trimmed().toStdString() << endl;
if (i == 0)
{
QString first = str.section('\t', 0, 0);
m_dStandardLightDataBase = first.toDouble();
}
else
{
QString first = str.section('\t', 0, 0);
QString second = str.section('\t', 1, 1);
StandardLightWavelength_tmp[i - 1] = first.toDouble();
StandardLightData_tmp[i - 1] = second.toDouble();
//if (i== lineCount-1)//<2F>鿴<EFBFBD><E9BFB4><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD><C7B7><EFBFBD>ȷ
//{
// double xx = first.toDouble();
// double yy = second.toDouble();
// std::cout << "xx<78><78>" << xx <<std::endl;
// std::cout << "yy<79><79>" << yy << std::endl;
//}
}
}
//<2F><>ȡ<EFBFBD><C8A1>׼<EFBFBD><D7BC><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD><DDB5><EFBFBD>Ч<EFBFBD><D0A7>
int startPos, endPos;
int buffer = 3;//<2F><>Ҫ<EFBFBD><D2AA><EFBFBD>DZ<EFBFBD>׼<EFBFBD><D7BC>ԭʼ<D4AD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//QString biaozhundengfanwei = QString::number(StandardLightWavelength_tmp[0]) + "--" + QString::number(StandardLightWavelength_tmp[lineCount - 2]);
if (deviceAttribute.fWaveLengthInNM[0] < StandardLightWavelength_tmp[0])//<2F><>׼<EFBFBD><D7BC><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>Χδ<CEA7><CEB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С<EFBFBD><D0A1><EFBFBD><EFBFBD>
{
startPos = 0;
}
else
{
for (size_t i = 0; i < lineCount - 1; i++)
{
if (deviceAttribute.fWaveLengthInNM[0] < StandardLightWavelength_tmp[i])
{
startPos = i - buffer;
break;
}
}
}
if (deviceAttribute.fWaveLengthInNM[deviceAttribute.iPixels - 1] > StandardLightWavelength_tmp[lineCount - 2])//<2F><>׼<EFBFBD><D7BC><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>Χδ<CEA7><CEB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>󲨳<EFBFBD>
{
endPos = lineCount - 2;
}
else
{
for (size_t i = 0; i < lineCount - 1; i++)
{
if (deviceAttribute.fWaveLengthInNM[deviceAttribute.iPixels - 1] < StandardLightWavelength_tmp[i])
{
endPos = i + buffer;//??
break;
}
}
}
m_dStandardLightWavelength = new double[endPos - startPos];
m_dStandardLightData = new double[endPos - startPos];
for (size_t i = 0; i < endPos - startPos; i++)
{
m_dStandardLightWavelength[i] = StandardLightWavelength_tmp[i + startPos];
m_dStandardLightData[i] = StandardLightData_tmp[i + startPos];
}
// //<2F><><EFBFBD>ضϱ<D8B6>׼<EFBFBD><D7BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>csv
// QFileInfo fileInfo(filePath);
// QString standardLightFileFolder = fileInfo.path();
// QString standardLightFileName = fileInfo.fileName();
//
// QDateTime curDateTime = QDateTime::currentDateTime();
// QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
//
// QString tmp = standardLightFileFolder + "/" + currentTime + "_" + QString::fromStdString(deviceInfo.strSN) +"_"+ standardLightFileName + "_truncation.csv";
//
// std::ofstream outfile1(tmp.toStdString().c_str());
//
// for (size_t i = 0; i < endPos - startPos; i++)
// {
// if (i == 0)
// {
// outfile1 << m_dStandardLightDataBase << std::endl;
// }
//
// outfile1 << m_dStandardLightWavelength[i] << "," << m_dStandardLightData[i] << std::endl;
// }
// outfile1.close();
//<2F>ز<EFBFBD><D8B2><EFBFBD><EFBFBD><EFBFBD>׼<EFBFBD><D7BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
Eigen::VectorXd vx = Eigen::VectorXd::Map(m_dStandardLightWavelength, endPos - startPos/*x_vec.size()*/);
Eigen::VectorXd vy = Eigen::VectorXd::Map(m_dStandardLightData, endPos - startPos/*y_vec.size()*/);
using namespace ZZ_MATH::SplineFit;
SplineInterpolation m_sfLine(vx, vy);
m_dStandardLightWavelengthResampled = new double[deviceAttribute.iPixels];
m_dStandardLightDataResampled = new double[deviceAttribute.iPixels];
double dTemp,scaleFactor;
if(integratingSphereDetectorValue <= 0)
scaleFactor=1;
else
scaleFactor=integratingSphereDetectorValue/m_dStandardLightDataBase;
for (size_t i = 0; i < deviceAttribute.iPixels; i++)
{
if (deviceAttribute.fWaveLengthInNM[i] < StandardLightWavelength_tmp[0])//<2F>˲<EFBFBD><CBB2><EFBFBD> < <20><>׼<EFBFBD><D7BC><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>С<EFBFBD><D0A1><EFBFBD><EFBFBD>
{
dTemp = m_sfLine(StandardLightWavelength_tmp[0]);//???????????????
}
else if (StandardLightWavelength_tmp[lineCount - 2] < deviceAttribute.fWaveLengthInNM[i])//<2F><>׼<EFBFBD><D7BC><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD>󲨳<EFBFBD> < <20>˲<EFBFBD><CBB2><EFBFBD>
{
dTemp = m_sfLine(StandardLightWavelength_tmp[lineCount - 2]);//???????????????
}
else
{
dTemp = m_sfLine(deviceAttribute.fWaveLengthInNM[i]);//?????
}
//double dTemp2 = m_sfLine(deviceAttribute.fWaveLengthInNM[i]);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>û<EFBFBD><C3BB>ʹ<EFBFBD><CAB9>
m_dStandardLightWavelengthResampled[i] = deviceAttribute.fWaveLengthInNM[i];
m_dStandardLightDataResampled[i] = dTemp * scaleFactor;
}
// //<2F><><EFBFBD>ز<EFBFBD><D8B2><EFBFBD><EFBFBD>ı<EFBFBD>׼<EFBFBD><D7BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>csv
// QString outputName = standardLightFileFolder + "/" + currentTime + "_" + QString::fromStdString(deviceInfo.strSN) + "_" + standardLightFileName + "_resample.csv";
// std::ofstream outfile2(outputName.toStdString().c_str());
// for (size_t i = 0; i < deviceAttribute.iPixels; i++)
// {
// if (i == 0)
// {
// outfile2 << m_dStandardLightDataBase << std::endl;
// }
//
// outfile2 << deviceAttribute.fWaveLengthInNM[i] << "," << m_dStandardLightDataResampled[i] << std::endl;
// }
// outfile2.close();
}
void CalibrationAlgorithm::produceCalfile(QString calFilePath, DeviceAttribute deviceAttribute, DataFrame integratingSphereData, DataFrame darkData)
{
using namespace ZZ_MISCDEF;//ZZ_U32
int errorCode;
size_t writeCounter;
double* m_gain = new double[deviceAttribute.iPixels];//double*
double* m_offset = new double[deviceAttribute.iPixels];//double*
for (size_t i = 0; i < deviceAttribute.iPixels; i++)
{
if (integratingSphereData.lData[i] - darkData.lData[i] == 0)//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ĸΪ<C4B8><CEAA>
{
m_gain[i] = 0;
}
else
{
m_gain[i] = m_dStandardLightDataResampled[i] / (integratingSphereData.lData[i] - darkData.lData[i]);
}
m_offset[i] = 0;
}
//д<>뵽<EFBFBD><EBB5BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
FILE * calFileHandle = fopen(calFilePath.toStdString().c_str(), "wb");
writeCounter = fwrite(&integratingSphereData.usExposureTimeInMS,sizeof(ZZ_U32), 1, calFileHandle);//<2F>ع<EFBFBD>ʱ<EFBFBD><CAB1>
writeCounter = fwrite(&integratingSphereData.fTemperature, sizeof(float), 1, calFileHandle);//<2F><EFBFBD>
writeCounter = fwrite(&deviceAttribute.iPixels, sizeof(int), 1, calFileHandle);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
writeCounter = fwrite(&deviceAttribute.fWaveLengthInNM, sizeof(float), deviceAttribute.iPixels, calFileHandle);//<2F><><EFBFBD><EFBFBD>
writeCounter = fwrite(m_gain, sizeof(double), deviceAttribute.iPixels, calFileHandle);//gain
writeCounter = fwrite(m_offset, sizeof(double), deviceAttribute.iPixels, calFileHandle);//offset
fclose(calFileHandle);
//д<>뵽CSV<53>ļ<EFBFBD>
QString calFile_csv = calFilePath.split(".")[0] + ".csv";
std::ofstream outfile(calFile_csv.toStdString().c_str());
for (int i = 0; i < deviceAttribute.iPixels; i++)
{
if (i==0)
{
outfile << integratingSphereData.usExposureTimeInMS << std::endl;
}
outfile << deviceAttribute.fWaveLengthInNM[i] << "," << m_gain[i] << std::endl;
}
outfile.close();
delete[] m_gain;
}

635
othersoft/calibration_console/Source_Files/library.cpp Normal file
View File

@ -0,0 +1,635 @@
#include "Header_Files/library.h"
#include <iostream>
#include <cstring>
OceanOptics_lib::OceanOptics_lib()
{
m_iSpectralmeterHandle = -100;
}
OceanOptics_lib::~OceanOptics_lib()
{
}
//ʹ<><CAB9>ͷ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>#include "api/SeaBreezeWrapper.h"
int OceanOptics_lib::Initialize(bool bIsUSBMode, std::string ucPortNumber, std::string strDeviceName)
{
int flag;
int error;
char type[16];
int device_count = 0;
int i;
for (i = 0; i < SEABREEZE_MAX_DEVICES; i++)
{
// printf("\nOpening spectrometer %d.\n", i);
flag = seabreeze_open_spectrometer(i, &error);
// printf("Open spectrometer result is (%d) [%s]\n", flag, get_error_string(error));
if (0 == flag)
{
device_count++;
}
else
{
continue;
}
string sn = GetSerialNumber(i);
if (strcmp(sn.c_str(), strDeviceName.c_str()) == 0)
{
m_iSpectralmeterHandle = i;
// printf("\nfind!!!!!!!!!!!!\n");
break;
}
else
{
// printf("\nClosing spectrometer %d.\n", i);
flag = seabreeze_close_spectrometer(i, &error);
// printf("Close spectrometer result is (%d) [%s]\n", flag, get_error_string(error));
}
}
if (m_iSpectralmeterHandle == -100)
{
// printf("\nNo!!!!!!!!!!!!\n");
return 1;
}
seabreeze_set_trigger_mode(m_iSpectralmeterHandle, &error, 0);
long test = seabreeze_get_buffer_capacity_minimum(m_iSpectralmeterHandle, &error);
seabreeze_set_buffer_capacity(m_iSpectralmeterHandle, &error, test);
// printf("seabreeze_set_trigger_mode: Result is [%s]\n", get_error_string(error));
//<2F><><EFBFBD>ó<EFBFBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>
long minimum_time;
minimum_time = seabreeze_get_min_integration_time_microsec(m_iSpectralmeterHandle, &error);
//printf("...Minimum is %ld microseconds, result is [%s]\n", minimum_time, get_error_string(error));
bool ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
// printf("\n-------------------û<>ɹ<EFBFBD><C9B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>\n");
return 1;
}
if (minimum_time < 0) {
/* If there was an error, reset to a time that is supported widely. */
minimum_time = 15000;
return 1;
}
SetExposureTime(minimum_time / 1000);
return 0;
}
//ʹ<><CAB9>ͷ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>#include "api/SeaBreezeWrapper.h"
int OceanOptics_lib::Initialize()
{
int flag;
int error;
char type[16];
int device_count = 0;
int i;
for (i = 0; i < SEABREEZE_MAX_DEVICES; i++)
{
printf("\nOpening spectrometer %d.\n", i);
flag = seabreeze_open_spectrometer(i, &error);
//printf("Open spectrometer result is (%d) [%s]\n", flag, get_error_string(error));
if (0 == flag)
{
m_iSpectralmeterHandle = i;
break;
}
else
{
continue;
}
}
if (m_iSpectralmeterHandle == -100)
{
printf("\nNo!!!!!!!!!!!!\n");
return 1;
}
seabreeze_set_trigger_mode(m_iSpectralmeterHandle, &error, 0);
seabreeze_set_trigger_mode(m_iSpectralmeterHandle, &error, 0);
seabreeze_set_trigger_mode(m_iSpectralmeterHandle, &error, 0);
long test = seabreeze_get_buffer_capacity_minimum(m_iSpectralmeterHandle, &error);
printf("seabreeze_get_buffer_capacity_minimum: Result is [%s]\n", get_error_string(error));
seabreeze_set_buffer_capacity(m_iSpectralmeterHandle, &error, test);
printf("seabreeze_set_buffer_capacity: Result is [%s]\n", get_error_string(error));
// printf("seabreeze_set_trigger_mode: Result is [%s]\n", get_error_string(error));
//<2F><><EFBFBD>ó<EFBFBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>
long minimum_time;
minimum_time = seabreeze_get_min_integration_time_microsec(m_iSpectralmeterHandle, &error);
//printf("...Minimum is %ld microseconds, result is [%s]\n", minimum_time, get_error_string(error));
bool ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
// printf("\n-------------------û<>ɹ<EFBFBD><C9B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>\n");
return 1;
}
if (minimum_time < 0) {
/* If there was an error, reset to a time that is supported widely. */
minimum_time = 15000;
return 1;
}
SetExposureTime(minimum_time / 1000);
return 0;
}
//ʹ<><CAB9>ͷ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>#include "api/seabreezeapi/SeaBreezeAPI.h"
//int OceanOptics_lib::Initialize(bool bIsUSBMode,ZZ_U8 ucPortNumber,std::string strDeviceName)
//{
// int number_of_devices;
// long *device_ids;
// int i;
// int flag;
// int error = 0;
// char nameBuffer[80];
// char *serialNumber;
//
//
//// /* Give the driver a chance to initialize itself */
//// sbapi_initialize();
//
// printf("Probing for devices...\n"); fflush(stdout);
// sbapi_probe_devices();
//
// printf("Getting device count...\n"); fflush(stdout);
// number_of_devices = sbapi_get_number_of_device_ids();
// std::cout<<"Device count is "<< number_of_devices <<std::endl;
// if(0 == number_of_devices) {
// return 0;
// }
//
// printf("Getting device IDs...\n");
// device_ids = (long *)calloc(number_of_devices, sizeof(long));
// number_of_devices = sbapi_get_device_ids(device_ids, number_of_devices);
// printf("Got %d device ID%s.\n", number_of_devices, number_of_devices == 1 ? "" : "s"); fflush(stdout);
//
//
// for(i = 0; i < number_of_devices; i++)
// {
// printf("%d: Device 0x%02lX:\n", i, device_ids[i]);
//// printf("\tGetting device type...\n");
// flag = sbapi_get_device_type(device_ids[i], &error, nameBuffer, 79);
//// printf("\t\tResult is (%d) [%s]\n", flag, sbapi_get_error_string(error));
// if(flag > 0) {
// printf("\tDevice type: [%s]\n", nameBuffer);
// }
//
// serialNumber = GetSerialNumber(device_ids[i]);
// serialNumber = GetSerialNumber(device_ids[i]);
//
// printf("\tSerial number tc: [%s]\n", serialNumber);
//
//// /* Open the device */
//// printf("\tAttempting to open:\n");
//// flag = sbapi_open_device(device_ids[i], &error);
//// printf("\t\tResult is (%d) [%s]\n", flag, sbapi_get_error_string(error));
////
//// // jump to the next iteration if there was a problem
//// if(flag != 0) {
//// continue;
//// }
////
//// // log deviations
//// unsupportedFeatureCount=0;
//// testFailureCount=0;
////
//// /* Test the device */
//// for(test_index = 0; test_index < __test_function_count; test_index++) {
//// /* Invoke each of the test functions against this device */
//// __test_functions[test_index](device_ids[i], &unsupportedFeatureCount, &testFailureCount);
//// }
////
//// /* Close the device */
//// printf("\tAttempting to close:\n");
//// sbapi_close_device(device_ids[i], &error);
//// printf("\t\tResult is (%d) [%s]\n", flag, sbapi_get_error_string(error));
//// printf("%d: Device 0x%02lX: \n\tNumber of unsupported features = %d\n\tNumber of test failures = %d\n", i, device_ids[i], unsupportedFeatureCount, testFailureCount);
// }
//
// flag = sbapi_get_device_type(device_ids[i], &error, nameBuffer, 79);
//
// return 1;
//}
//<2F>ر<EFBFBD><D8B1>豸
void OceanOptics_lib::Close()
{
int flag;
int error;
flag = seabreeze_close_spectrometer(m_iSpectralmeterHandle, &error);
// printf("Close spectrometer result is (%d) [%s]\n", flag, get_error_string(error));
}
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݲɼ<DDB2>
int OceanOptics_lib::SingleShot(DataFrame &dfData)
{
if (m_iSpectralmeterHandle == -100)
{
printf("\nNo!!!!!!!!!!!!\n");
return 1;
}
int error;
int flag;
int spec_length;
double *spectrum = 0;
bool ret;
// printf("\n\nGetting formatted spectrum length.\n");
spec_length = seabreeze_get_formatted_spectrum_length(m_iSpectralmeterHandle, &error);
//printf("Get formatted spectrum_length result is (%d) [%s]\n", spec_length, get_error_string(error));
ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return 1;
}
if (spec_length > 0)
{
spectrum = (double *)calloc((size_t)spec_length, sizeof(double));
seabreeze_clear_buffer(m_iSpectralmeterHandle, &error);
auto startTime = std::chrono::high_resolution_clock::now();
flag = seabreeze_get_formatted_spectrum(m_iSpectralmeterHandle, &error, spectrum, spec_length);
auto endTime = std::chrono::high_resolution_clock::now();
std::chrono::duration<double, std::milli> fp_ms = endTime - startTime;
std::cout << "<EFBFBD>ɼ<EFBFBD><EFBFBD><EFBFBD>ʱΪ<EFBFBD><EFBFBD>" << fp_ms.count() / 1000 << "s." << std::endl;
// printf("Get formatted spectrum result is (%d) [%s]\n", flag, get_error_string(error));
// printf("\tPixel value 20 is %1.2f\n", spectrum[20]);
ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return 1;
}
for (int tmp = 0; tmp < spec_length; tmp++)
{
dfData.lData[tmp] = spectrum[tmp];
}
int exposureTimeInMS;
GetExposureTime(exposureTimeInMS);
dfData.usExposureTimeInMS = exposureTimeInMS;
float temperature;
GetDeviceTemperature(temperature);
dfData.fTemperature = temperature;
free(spectrum);
}
return 0;
}
//<2F><><EFBFBD><EFBFBD><EFBFBD>ع<EFBFBD>ʱ<EFBFBD><CAB1>
int OceanOptics_lib::SetExposureTime(int iExposureTimeInMS)
{
if (m_iSpectralmeterHandle == -100)
{
// printf("\nNo!!!!!!!!!!!!\n");
return 1;
}
int error;
seabreeze_set_trigger_mode(m_iSpectralmeterHandle, &error, 0); // trigger to normal
seabreeze_set_integration_time_microsec(m_iSpectralmeterHandle, &error, iExposureTimeInMS * 1000);
printf("Set integration time result is [%s]\n", get_error_string(error));
bool ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return 1;
}
m_iExposureTime = iExposureTimeInMS;
// //----------------------------------------------------------------------------------------------------------------
// int error;
// long *spectrometer_ids;
// int number_of_spectrometers;
//
// number_of_spectrometers = sbapi_get_number_of_spectrometer_features(m_iSpectralmeterHandle, &error);
// printf("\t\t\tResult is %d [%s]\n", number_of_spectrometers, sbapi_get_error_string(error));
// spectrometer_ids = (long *)calloc(number_of_spectrometers, sizeof(long));
// number_of_spectrometers = sbapi_get_spectrometer_features(m_iSpectralmeterHandle, &error, spectrometer_ids, number_of_spectrometers);
// printf("\t\t\tResult is %d [%s]\n", number_of_spectrometers, sbapi_get_error_string(error));
//
// sbapi_spectrometer_set_integration_time_micros(m_iSpectralmeterHandle, spectrometer_ids[0], &error, iExposureTimeInMS*1000);
// printf("\t\t\t\tResult is [%s]\n", sbapi_get_error_string(error));
return 0;
}
//<2F><>ȡ<EFBFBD>ع<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int OceanOptics_lib::GetExposureTime(int &iExposureTimeInMS)
{
if (m_iSpectralmeterHandle == -100)
{
printf("\nNo!!!!!!!!!!!!\n");
return 1;
}
iExposureTimeInMS = m_iExposureTime;
return 0;
}
//<2F><><EFBFBD><EFBFBD>Ŀ<EFBFBD><C4BF><EFBFBD><EFBFBD>
int OceanOptics_lib::SetDeviceTemperature(float fTemperature)
{
bool ret;
if (m_iSpectralmeterHandle == -100)
{
printf("\nNo!!!!!!!!!!!!\n");
return 1;
}
int error;
// printf("\nSetting TEC temperature to -5C\n");
seabreeze_set_tec_temperature(m_iSpectralmeterHandle, &error, fTemperature);
// printf("Set tec temperature result is [%s]\n", get_error_string(error));
ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return 1;
}
// printf("\nSetting TEC enable to true\n");
seabreeze_set_tec_enable(m_iSpectralmeterHandle, &error, 1);
// printf("Set tec enable result is [%s]\n", get_error_string(error));
ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return 1;
}
return 0;
}
//<2F><>ȡ<EFBFBD><EFBFBD><C2B6><EFBFBD><EFBFBD><EFBFBD>
int OceanOptics_lib::GetDeviceTemperature(float &fTemperature)
{
if (m_iSpectralmeterHandle == -100)
{
printf("\nNo!!!!!!!!!!!!\n");
return 1;
}
double temp;
int error;
// usleep(1000000);
// printf("\nGetting TEC temperature\n");
temp = seabreeze_read_tec_temperature(m_iSpectralmeterHandle, &error);
// printf("Read tec temperature result is %1.2f C [%s]\n", temp, get_error_string(error));
bool ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return 1;
}
fTemperature = temp;
return 0;
}
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8>Ϣ
int OceanOptics_lib::GetDeviceInfo(DeviceInfo &Info)
{
if (m_iSpectralmeterHandle == -100)
{
printf("\nNo!!!!!!!!!!!!\n");
return 1;
}
string deviceType = GetDeviceType(m_iSpectralmeterHandle);
string SN = GetSerialNumber(m_iSpectralmeterHandle);
Info.strPN = deviceType;
Info.strSN = SN;
return 0;
}
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int OceanOptics_lib::GetDeviceAttribute(DeviceAttribute &Attr)
{
if (m_iSpectralmeterHandle == -100)
{
printf("\nNo!!!!!!!!!!!!\n");
return 1;
}
int error;
int flag;
int spec_length;
double *wls = 0;
// printf("\n\nGetting formatted spectrum length.\n");
spec_length = seabreeze_get_formatted_spectrum_length(m_iSpectralmeterHandle, &error);
// printf("Get formatted spectrum length result is (%d) [%s]\n", spec_length, get_error_string(error));
bool ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return 1;
}
Attr.iPixels = spec_length;
long minimum_time;
minimum_time = seabreeze_get_min_integration_time_microsec(m_iSpectralmeterHandle, &error);
Attr.iMinIntegrationTimeInMS = minimum_time/1000;
Attr.iMaxIntegrationTimeInMS = 60000;
if (spec_length > 0) {
wls = (double *)calloc((size_t)spec_length, sizeof(double));
// printf("\nGetting wavelengths.\n");
flag = seabreeze_get_wavelengths(m_iSpectralmeterHandle, &error, wls, spec_length);
// printf("Get wavelengths result is (%d) [%s]\n", flag, get_error_string(error));
// printf("\tPixel 20 is wavelength %1.2f nm\n", wls[20]);
bool ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return 1;
}
for (int tmp = 0; tmp < spec_length; tmp++)
{
Attr.fWaveLengthInNM[tmp] = wls[tmp];
}
free(wls);
}
return 0;
}
bool OceanOptics_lib::isSuccess(char* resultStr)
{
if (strstr(resultStr, "Success") == NULL)//<2F><>a<EFBFBD>в<EFBFBD><D0B2><EFBFBD>b<EFBFBD><62><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڣ<EFBFBD>
{
//cout << "not found\n";//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
return false;
}
else//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڡ<EFBFBD>
{
//cout <<"found\n"; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
return true;
}
}
const char* OceanOptics_lib::get_error_string(int error)
{
static char buffer[32];
seabreeze_get_error_string(error, buffer, sizeof(buffer));
return buffer;
}
void OceanOptics_lib::test_nonlinearity_coeffs_feature()
{
using namespace seabreeze;
using namespace seabreeze::api;
using namespace std;
NonlinearityCoeffsFeatureAdapter tmp();
// int error = 0;
// int number_of_nonlinearity_coeff_features;
// long *nonlinearity_coeff_feature_ids = 0;
// double buffer[10];
// int i;
// int length;
//
// printf("\n\tTesting nonlinearity coefficient features:\n");
//
// printf("\t\tGetting number of nonlinearity coefficient features:\n");
// number_of_nonlinearity_coeff_features =
// sbapi_get_number_of_nonlinearity_coeffs_features(m_iSpectralmeterHandle, &error);
// printf("\t\t\tResult is %d [%s]\n", number_of_nonlinearity_coeff_features,
// sbapi_get_error_string(error));
//
// if(0 == number_of_nonlinearity_coeff_features) {
// printf("\tNo nonlinearity coefficient capabilities found.\n");
//// tallyUnsupportedFeatures(unsupportedFeatureCount);
//
// return;
// }
//
// nonlinearity_coeff_feature_ids =
// (long *)calloc(number_of_nonlinearity_coeff_features, sizeof(long));
// printf("\t\tGetting nonlinearity coefficient feature IDs...\n");
// number_of_nonlinearity_coeff_features = sbapi_get_nonlinearity_coeffs_features(
// m_iSpectralmeterHandle, &error, nonlinearity_coeff_feature_ids,
// number_of_nonlinearity_coeff_features);
// printf("\t\t\tResult is %d [%s]\n", number_of_nonlinearity_coeff_features,
// sbapi_get_error_string(error));
//
// for(i = 0; i < number_of_nonlinearity_coeff_features; i++) {
// printf("\t\t%d: Testing device 0x%02lX, nonlinearity coeffs 0x%02lX\n",
// i, m_iSpectralmeterHandle, nonlinearity_coeff_feature_ids[i]);
//
// printf("\t\t\tAttempting to get nonlinearity coefficients...\n");
// memset(buffer, (int)0, sizeof(buffer));
// length = sbapi_nonlinearity_coeffs_get(m_iSpectralmeterHandle,
// nonlinearity_coeff_feature_ids[i], &error, buffer, 10);
// printf("\t\t\t\tResult is %d [%s]\n", length, sbapi_get_error_string(error));
//
// if(0 == error && length > 0) {
// printf("\t\t\t\tFirst calibration term: %1.2e\n", buffer[0]);
// }
//
// printf("\t\t%d: Finished testing device 0x%02lX, nonlinearity coeffs 0x%02lX\n",
// i, m_iSpectralmeterHandle, nonlinearity_coeff_feature_ids[i]);
// }
// free(nonlinearity_coeff_feature_ids);
//
// printf("\tFinished testing nonlinearity coefficient capabilities.\n");
}
string OceanOptics_lib::GetDeviceType(int index)
{
char type[16];
int error;
seabreeze_get_model(index, &error, type, sizeof(type));
// printf("...Result is (%s) [%s]\n", type, get_error_string(error));
bool ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return "";
}
type[15] = '\0';
string deviceType = type;
return deviceType;
}
string OceanOptics_lib::GetSerialNumber(int index)
{
static char serial_number[32];//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>static<69><63><EFBFBD>˱<EFBFBD><CBB1><EFBFBD><EFBFBD>ᶨ<EFBFBD><E1B6A8><EFBFBD><EFBFBD>stack<63><6B><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>غ󣬾<D8BA><F3A3ACBE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int flag;
int error;
// printf("\n\nGetting serial number.\n");
flag = seabreeze_get_serial_number(index, &error, serial_number, 32);
// printf("Get serial number result is (%d) [%s]\n", flag, get_error_string(error));
bool ret = isSuccess((char*)get_error_string(error));
if (!ret)
{
return "";
}
serial_number[31] = '\0';
if (flag > 0) {
printf("\tSerial number: [%s]\n", serial_number);
}
string sn = serial_number;
return sn;
}

683
othersoft/calibration_console/Source_Files/main.cpp Normal file
View File

@ -0,0 +1,683 @@
#include <QtCore/QCoreApplication>
#include <QTextStream>
#include <QCommandLineParser>
#include <QDir>
#include <iostream>
#include "Header_Files/oceanOpticsFiberImager.h"
#include "Header_Files/atpFiberImager.h"
#include "Header_Files/calibration.h"
enum CommandLineParseResult
{
CommandLineOk,
CommandLineError,
CommandLineVersionRequested,
CommandLineHelpRequested
};
enum DeviceType
{
OPTOSKY,
OceanOptics,
UnknownDevice
};
struct TcQuery
{
DeviceType deviceType;
QString serialPort;
int sleepTimeinSecond;//<2F><>Ĭ<EFBFBD><C4AC>ֵ
int averageTimes;
int position;
int integratingSphereDetectorValue;
QString calFileOutputDirectory;//<2F><>Ĭ<EFBFBD><C4AC>ֵ
QString calFileOutputName;
QString standardLightFilePath;
bool justRecord;
};
CommandLineParseResult parseCommandLine2(QCommandLineParser &parser, TcQuery *query, QString *errorMessage);
bool copyFileToPath(QString sourceDir ,QString toDir, bool coverFileIfExist);
void logout(QString str);
void createDirectory(QString fullPath);
bool isFileExist(QString fullFileName);
int getNonlinearityCoeffs2(long deviceID, double * nonlinearityCoeffs);
int getNonlinearityCoeffs1(double * nonlinearityCoeffs);
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
QCoreApplication::setApplicationName("Ocean optics radiance calibration software");
QCoreApplication::setApplicationVersion("1.0");
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>в<EFBFBD><D0B2><EFBFBD>
QCommandLineParser parser;
parser.setApplicationDescription("This software is used for doing radiance calibration for ocean optics fiber imager.");
TcQuery query;
QString errorMessage;
switch (parseCommandLine2(parser, &query, &errorMessage))
{
case CommandLineOk:
break;
case CommandLineError:
errorMessage = "<br><b style=\"color:red\">" + errorMessage + "s!</b>";
logout(errorMessage);
// fputs(qPrintable(errorMessage), stderr);
fputs("\n\n", stderr);
fputs(qPrintable(parser.helpText()), stderr);
return 1;
case CommandLineVersionRequested:
printf("%s %s\n", qPrintable(QCoreApplication::applicationName()),
qPrintable(QCoreApplication::applicationVersion()));
return 0;
case CommandLineHelpRequested:
parser.showHelp();
Q_UNREACHABLE();
}
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƕ<EFBFBD><C7B6><EFBFBD>
FiberSpectrometerOperationBase * m_FiberSpectrometer;
bool isOcean = false;
double * nonlinearityCoeffs;
int numberOfNonlinearityCoeffs;
switch (query.deviceType)
{
case OPTOSKY:
m_FiberSpectrometer = new ATPFiberImager(false,query.serialPort.toStdString(),"OPTOSKY");
break;
case OceanOptics:
{
//ʹ<><CAB9>sbapi<70><69>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ѧ<EFBFBD><D1A7><EFBFBD><EFBFBD><EFBFBD>ķ<EFBFBD><C4B7><EFBFBD><EFBFBD>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
nonlinearityCoeffs = new double[100];
numberOfNonlinearityCoeffs = getNonlinearityCoeffs1(nonlinearityCoeffs);
m_FiberSpectrometer = new OceanOpticsFiberImager(nonlinearityCoeffs, numberOfNonlinearityCoeffs);
isOcean = true;
break;
}
case UnknownDevice:
parser.showHelp();
Q_UNREACHABLE();
}
//<2F><><EFBFBD>ӹ<EFBFBD><D3B9><EFBFBD><EFBFBD><EFBFBD>
QString message;
QString SN;
QString pixelCount;
QString wavelengthInfo;
logout("<br><b style=\"color:red\">Connectting the fiber spectrometer!</b>");
m_FiberSpectrometer->connectFiberSpectrometer(SN, pixelCount, wavelengthInfo);
//<2F>Զ<EFBFBD><D4B6>ع<EFBFBD>
logout("<br><b style=\"color:red\">AutoExpose!</b>");
m_FiberSpectrometer->autoExpose();//
int iExposureTime;
m_FiberSpectrometer->getExposureTime(iExposureTime);
message="<br><b style=\"color:red\">ExposureTime: " + QString::number(iExposureTime) + "</b>";
logout(message);
//<2F><><EFBFBD><EFBFBD>sleep<65><70><EFBFBD>ȴ<EFBFBD><C8B4>رտ<D8B1><D5BF><EFBFBD>
message="<br><b style=\"color:red\">Please close the lamp in " + QString::number(query.sleepTimeinSecond) + "s!</b>";
logout(message);
QThread::sleep(query.sleepTimeinSecond);
//<2F>ɼ<EFBFBD><C9BC><EFBFBD>֡
logout("<br><b style=\"color:red\">Record dark frame!</b>");
m_FiberSpectrometer->recordDark(query.calFileOutputDirectory);
//<2F><><EFBFBD><EFBFBD>sleep<65><70><EFBFBD>ȴ<EFBFBD><C8B4>򿪿<EFBFBD><F2BFAABF><EFBFBD>
message="<br><b style=\"color:red\">Please open the lamp in " + QString::number(query.sleepTimeinSecond) + "s!</b>";
logout(message);
QThread::sleep(query.sleepTimeinSecond);
//<2F>ɼ<EFBFBD><C9BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
logout("<br><b style=\"color:red\">Record integrating sphere frame!</b>");
m_FiberSpectrometer->recordTarget(query.averageTimes, query.calFileOutputDirectory);
//׼<><D7BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
logout("<br><b style=\"color:red\">readAndResample_StandardLightFile!</b>");
DeviceAttribute deviceAttribute;
DeviceInfo deviceInfo;
m_FiberSpectrometer->getDeviceAttribute(deviceAttribute);
m_FiberSpectrometer->getDeviceInfo(deviceInfo);
CalibrationAlgorithm * m_CalibrationAlgorithm = new CalibrationAlgorithm();
m_CalibrationAlgorithm->readAndResample_StandardLightFile(query.standardLightFilePath,query.integratingSphereDetectorValue, deviceAttribute, deviceInfo);
//<2F><><EFBFBD>ɷ<EFBFBD><C9B7>䶨<EFBFBD><E4B6A8><EFBFBD>ļ<EFBFBD>
if (query.calFileOutputName.isEmpty())//query->calFileOutputName==""
{
QDateTime curDateTime = QDateTime::currentDateTime();
QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
QString calFileName = QDir::cleanPath(query.calFileOutputDirectory + QDir::separator() + currentTime + "_" + QString::fromStdString(deviceInfo.strSN) + ".dat");
query.calFileOutputName=calFileName;
}
logout("<br><b style=\"color:red\">Produce calibration file!</b>");
m_CalibrationAlgorithm->produceCalfile(query.calFileOutputName, deviceAttribute, m_FiberSpectrometer->m_IntegratingSphereData, m_FiberSpectrometer->m_DarkData);
//<2F><><EFBFBD>Ʒ<EFBFBD><C6B7>䶨<EFBFBD><E4B6A8><EFBFBD>ļ<EFBFBD>
QDateTime curDateTime = QDateTime::currentDateTime();
QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
QString destName = QDir::cleanPath(query.calFileOutputDirectory + QDir::separator() + currentTime + "_" + QString::fromStdString(deviceInfo.strSN) + "_" +QString::number(query.position) + ".cal");
copyFileToPath(query.calFileOutputName,destName,true);
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ѧ<EFBFBD><D1A7><EFBFBD><EFBFBD><EFBFBD>ķ<EFBFBD><C4B7><EFBFBD><EFBFBD>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>
if (isOcean)
{
QDateTime curDateTime = QDateTime::currentDateTime();
QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
QString nonlinearityCoeffsName = QDir::cleanPath(query.calFileOutputDirectory + QDir::separator() + currentTime + "_" + QString::fromStdString(deviceInfo.strSN) + ".nonLinear");
// for (int i = 0; i < numberOfNonlinearityCoeffs; ++i)
// {
// printf("\n");
//
// printf("nonlinearityCoeffs(<28><>%d<><64>): %1.2e\n",i , nonlinearityCoeffs[i]);
//
// printf("\n");
// }
std::ofstream outfile(nonlinearityCoeffsName.toStdString().c_str());
for (int i = 0; i < numberOfNonlinearityCoeffs; i++)
{
outfile << nonlinearityCoeffs[i] << std::endl;
}
outfile.close();
free(nonlinearityCoeffs);
}
//<2F>Ͽ<EFBFBD><CFBF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
m_FiberSpectrometer->disconnectFiberSpectrometer();//Ҫ<><D2AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>֮<EFBFBD><D6AE><EFBFBD><EFBFBD>free(nonlinearityCoeffs);
//return a.exec();
}
CommandLineParseResult parseCommandLine2(QCommandLineParser &parser, TcQuery *query, QString *errorMessage)
{
parser.setSingleDashWordOptionMode(QCommandLineParser::ParseAsLongOptions);
QCommandLineOption deviceType("deviceType", "Device type. Options are OPTOSKY and OceanOptics", "deviceType");
parser.addOption(deviceType);
QCommandLineOption serialPort("serialPort", "Serial port.", "serialPort");
parser.addOption(serialPort);
QCommandLineOption sleepTimeinSecond("t", "The time app sleep.", "sleepTimeinSecond");
sleepTimeinSecond.setDefaultValue("30");//<2F><><EFBFBD><EFBFBD>Ĭ<EFBFBD>ϲ<EFBFBD><CFB2><EFBFBD>
parser.addOption(sleepTimeinSecond);
QCommandLineOption averageTimes("a", "Average times.", "average_times");
averageTimes.setDefaultValue("5");//<2F><><EFBFBD><EFBFBD>Ĭ<EFBFBD>ϲ<EFBFBD><CFB2><EFBFBD>
parser.addOption(averageTimes);//
QCommandLineOption position("position", "Position.", "position");
parser.addOption(position);
QCommandLineOption integratingSphereDetectorValue("integratingSphereDetectorValue", "integratingSphereDetectorValue.", "integratingSphereDetectorValue");
parser.addOption(integratingSphereDetectorValue);
// parser.addPositionalArgument("name", "The name to look up.");//????????????????????????????????????????????????????????????????????????????
QCommandLineOption helpOption = parser.addHelpOption();//Adds the help option (-h, --help and -? on Windows) This option is handled automatically by QCommandLineParser.
QCommandLineOption versionOption = parser.addVersionOption();//This option is handled automatically by QCommandLineParser.
//// A boolean option with a single name (-p)
//QCommandLineOption showProgressOption("p", QCoreApplication::translate("main", "Show progress during copy"));
//parser.addOption(showProgressOption);
// A boolean option with multiple names (-r, --record)
QCommandLineOption recordOption(QStringList() << "f" << "record",
QCoreApplication::translate("main", "Just record one spectral."));
parser.addOption(recordOption);
//<2F><>׼<EFBFBD><D7BC><EFBFBD>ļ<EFBFBD>
QCommandLineOption standardLightFilePath(QStringList() << "slfp" << "standard-light-file-path",
QCoreApplication::translate("main", "set standard light file."),
QCoreApplication::translate("main", "file"));
parser.addOption(standardLightFilePath);
QCommandLineOption standardLightFileSelector(QStringList() << "slfs" << "standard-light-file-selector",
QCoreApplication::translate("main", "select standard light file."),
QCoreApplication::translate("main", "file"));
parser.addOption(standardLightFileSelector);
//<2F><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>·<EFBFBD><C2B7>
// An option with a value
QCommandLineOption calFileOutputDirectory(QStringList() << "cfod" << "calibration-file-output-directory",
QCoreApplication::translate("main", "Save cal file into <directory>."),
QCoreApplication::translate("main", "directory"));
// QString tmpPath1 = QDir::cleanPath(QDir::rootPath() + QDir::separator()+"calFile");
QString tmpPath1 = "/home/data/Cal/";
calFileOutputDirectory.setDefaultValue(tmpPath1);//<2F><><EFBFBD><EFBFBD>Ĭ<EFBFBD>ϲ<EFBFBD><CFB2><EFBFBD><EFBFBD><EFBFBD>QCoreApplication::applicationDirPath()<29><>standardLightFile
parser.addOption(calFileOutputDirectory);
//<2F><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>
// An option with a value
QCommandLineOption calFileOutputName(QStringList() << "cfon" << "calibration-file-output-name",
QCoreApplication::translate("main", "Cal file name."),
QCoreApplication::translate("main", "fileName"));
parser.addOption(calFileOutputName);
if (!parser.parse(QCoreApplication::arguments()))//Process the actual command line arguments given by the user
{
*errorMessage = parser.errorText();
return CommandLineError;
}
if (parser.isSet(versionOption))
return CommandLineVersionRequested;
if (parser.isSet(helpOption))
return CommandLineHelpRequested;
if (parser.isSet(deviceType))
{
const QString deviceTypeTmp = parser.value(deviceType);
if (deviceTypeTmp=="OPTOSKY")
{
query->deviceType = OPTOSKY;
}
else if(deviceTypeTmp=="OceanOptics")
{
query->deviceType = OceanOptics;
}
else
{
*errorMessage = "DeviceType set error.";
return CommandLineError;
}
}
else//Ĭ<>ϲ<EFBFBD><CFB2><EFBFBD>
{
*errorMessage = "No deviceType set.";
return CommandLineError;
}
if (parser.isSet(serialPort))
{
const QString serialPortTmp = parser.value(serialPort);
query->serialPort = serialPortTmp;
}
else//Ĭ<>ϲ<EFBFBD><CFB2><EFBFBD>
{
if (query->deviceType == OceanOptics)
{
;
} else if (query->deviceType == OPTOSKY)
{
*errorMessage = "No serialPort set.";
return CommandLineError;
}
}
if (parser.isSet(sleepTimeinSecond))
{
const QString timeTmp = parser.value(sleepTimeinSecond);
query->sleepTimeinSecond = timeTmp.toInt();
}
else//Ĭ<>ϲ<EFBFBD><CFB2><EFBFBD>
{
QStringList tmp = sleepTimeinSecond.defaultValues();
query->sleepTimeinSecond = tmp[0].toInt();
}
if (parser.isSet(averageTimes))
{
const QString averageTimesTmp = parser.value(averageTimes);
string tttt=averageTimesTmp.toStdString();
query->averageTimes = averageTimesTmp.toInt();
}
else//Ĭ<>ϲ<EFBFBD><CFB2><EFBFBD>
{
QStringList tmp = averageTimes.defaultValues();
query->averageTimes = tmp[0].toInt();
}
if (parser.isSet(position))
{
const QString positionTmp = parser.value(position);
query->position = positionTmp.toInt();
}
else
{
*errorMessage = "No position set.";
return CommandLineError;
}
query->justRecord = parser.isSet(recordOption);
if (!parser.isSet(standardLightFilePath) && !parser.isSet(standardLightFileSelector))//û<><C3BB><EFBFBD><EFBFBD><EFBFBD>ö<EFBFBD><C3B6>걣<EFBFBD><EAB1A3><EFBFBD>ļ<EFBFBD>·<EFBFBD><C2B7>
{
*errorMessage = "No standard light file set.";
return CommandLineError;
}
if (parser.isSet(standardLightFileSelector))//
{
QString selector = parser.value(standardLightFileSelector);
// QString standardLightFilePath_tmp = QDir::cleanPath(QDir::rootPath() + QDir::separator() + "standardLightFile" + QDir::separator() + selector);
QString tmp = "/home/data/Setting/StandardLightFile";
QString standardLightFilePath_tmp = tmp + QDir::separator() + selector;
string xx=standardLightFilePath_tmp.toStdString();
//<2F>ж϶<D0B6><CFB6><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD>
if (!isFileExist(standardLightFilePath_tmp))
{
*errorMessage = "Standard light file '" + selector + "' does not exist!";
return CommandLineError;
}
query->standardLightFilePath = standardLightFilePath_tmp;
}
if (parser.isSet(standardLightFilePath))//
{
query->standardLightFilePath = parser.value(standardLightFilePath);
}
if (parser.isSet(integratingSphereDetectorValue))
{
if(query->standardLightFilePath.contains("ocean_optics.lmp",Qt::CaseSensitive))
{
query->integratingSphereDetectorValue = -1;
}
else
{
const QString integratingSphereDetectorValueTmp = parser.value(integratingSphereDetectorValue);
query->integratingSphereDetectorValue = integratingSphereDetectorValueTmp.toInt();
}
}
else
{
*errorMessage = "No integratingSphereDetectorValue set.";
return CommandLineError;
}
if (parser.isSet(calFileOutputDirectory))//<2F><><EFBFBD>걣<EFBFBD><EAB1A3><EFBFBD>ļ<EFBFBD>·<EFBFBD><C2B7>
{
query->calFileOutputDirectory = parser.value(calFileOutputDirectory);
createDirectory(query->calFileOutputDirectory);//<2F><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC>в<EFBFBD><D0B2><EFBFBD><EFBFBD><EFBFBD> <20>򴴽<EFBFBD>
}
else//Ĭ<>ϲ<EFBFBD><CFB2><EFBFBD>
{
QStringList tmp = calFileOutputDirectory.defaultValues();
QString directory = tmp[0];
createDirectory(directory);//<2F><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC>в<EFBFBD><D0B2><EFBFBD><EFBFBD><EFBFBD> <20>򴴽<EFBFBD>
query->calFileOutputDirectory = directory;
}
if (parser.isSet(calFileOutputName))//-------
{
QString calFileOutputNameTmp = QDir::cleanPath(query->calFileOutputDirectory + QDir::separator() + parser.value(calFileOutputName));
query->calFileOutputName = calFileOutputNameTmp;
}
else//Ĭ<>ϲ<EFBFBD><CFB2><EFBFBD>
{
query->calFileOutputName = "";//ʹ<>ô˲<C3B4><CBB2><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>query->calFileOutputNameΪ<65><CEAA> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>˱<EFBFBD><CBB1><EFBFBD><EFBFBD><EFBFBD>ֵ
}
// const QStringList positionalArguments = parser.positionalArguments();
// if (positionalArguments.isEmpty())
// {
// *errorMessage = "Argument 'name' missing.";
// return CommandLineError;
// }
// if (positionalArguments.size() > 1)
// {
// *errorMessage = "Several 'name' arguments specified.";
// return CommandLineError;
// }
return CommandLineOk;
}
bool copyFileToPath(QString sourceDir ,QString toDir, bool coverFileIfExist)
{
toDir.replace("\\","/");
if (sourceDir == toDir){
return true;
}
if (!QFile::exists(sourceDir)){
return false;
}
QDir *createfile = new QDir;
bool exist = createfile->exists(toDir);
if (exist){
if(coverFileIfExist){
createfile->remove(toDir);
}
}//end if
if(!QFile::copy(sourceDir, toDir))
{
return false;
}
return true;
}
void logout(QString str)
{
std::cout << str.toStdString() << "<br>";
std::fflush(stdout);
}
void createDirectory(QString fullPath)//
{
QDir dir(fullPath);
if (dir.exists())
{
return;
}
else
{
bool ok = dir.mkdir(fullPath);//ֻ<><D6BB><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD>Ŀ¼<C4BF><C2BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>뱣֤<EBB1A3>ϼ<EFBFBD>Ŀ¼<C4BF><C2BC><EFBFBD><EFBFBD>
return;
}
}
bool isFileExist(QString fullFileName)
{
QFileInfo fileInfo(fullFileName);
if (fileInfo.isFile())
{
return true;
}
return false;
}
int getNonlinearityCoeffs1(double * nonlinearityCoeffs)
{
int number_of_devices;
long *device_ids;
int i;
int test_index;
int flag;
int error = 0;
char nameBuffer[80];
/* Give the driver a chance to initialize itself */
sbapi_initialize();
// printf("Probing for devices...\n"); fflush(stdout);
sbapi_probe_devices();
//#define RS232_TEST
#ifdef RS232_TEST
printf("Adding an STS at 9600 baud...\n");
/* Uncomment for Linux */
//sbapi_add_RS232_device_location("STS", "/dev/ttyS0", 9600);
//sbapi_add_RS232_device_location("STS", "/dev/ttyUSB0", 9600);
/* Uncomment for Windows */
//sbapi_add_RS232_device_location("STS", "COM1", 9600);
/* Uncomment for e.g. USB-RS232 adapter under OSX */
//sbapi_add_RS232_device_location("STS", "/dev/tty.KeySerial1", 9600);
//sbapi_add_RS232_device_location("STS", "/dev/tty.usbserial", 9600);
#endif
/* This shows how to add network devices (note that most use TCP/IP) */
//sbapi_add_TCPIPv4_device_location("Jaz", "192.168.1.150", 7654);
//sbapi_add_TCPIPv4_device_location("Blaze", "192.168.1.151", 57357);
// printf("Getting device count...\n"); fflush(stdout);
number_of_devices = sbapi_get_number_of_device_ids();
// printf("Device count is %d\n", number_of_devices);
if(0 == number_of_devices) {
return 0;
}
// printf("Getting device IDs...\n");
device_ids = (long *)calloc(number_of_devices, sizeof(long));
number_of_devices = sbapi_get_device_ids(device_ids, number_of_devices);
// printf("Got %d device ID%s.\n", number_of_devices, number_of_devices == 1 ? "" : "s");
int number;
for(i = 0; i < number_of_devices; i++) {
// printf("%d: Device 0x%02lX:\n", i, device_ids[i]);
// printf("\tGetting device type...\n");
flag = sbapi_get_device_type(device_ids[i], &error, nameBuffer, 79);
// printf("\t\tResult is (%d) [%s]\n", flag, sbapi_get_error_string(error));
if(flag > 0) {
// printf("\tDevice type: [%s]\n", nameBuffer);
}
/* Open the device */
// printf("\tAttempting to open:\n");
flag = sbapi_open_device(device_ids[i], &error);
// printf("\t\tResult is (%d) [%s]\n", flag, sbapi_get_error_string(error));
// jump to the next iteration if there was a problem
if(flag != 0) {
continue;
}
number = getNonlinearityCoeffs2(device_ids[i],nonlinearityCoeffs);
/* Close the device */
// printf("\tAttempting to close:\n");
sbapi_close_device(device_ids[i], &error);
// printf("\t\tResult is (%d) [%s]\n", flag, sbapi_get_error_string(error));
}
free(device_ids);
// printf("Finished testing.\n");
/* Clean up memory allocated by the driver */
sbapi_shutdown();
return number;
}//
//<2F><><EFBFBD><EFBFBD>ֵ<EFBFBD>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD>У<EFBFBD><D0A3>ϵ<EFBFBD><CFB5><EFBFBD>ĸ<EFBFBD><C4B8><EFBFBD>
int getNonlinearityCoeffs2(long deviceID, double * nonlinearityCoeffs)
{
int error = 0;
int number_of_nonlinearity_coeff_features;
long *nonlinearity_coeff_feature_ids = 0;
double buffer[10];
int i;
int length = 0;
// printf("\n\tTesting nonlinearity coefficient features:\n");
// printf("\t\tGetting number of nonlinearity coefficient features:\n");
number_of_nonlinearity_coeff_features =
sbapi_get_number_of_nonlinearity_coeffs_features(deviceID, &error);
// printf("\t\t\tResult is %d [%s]\n", number_of_nonlinearity_coeff_features,
// sbapi_get_error_string(error));
if(0 == number_of_nonlinearity_coeff_features) {
printf("\tNo nonlinearity coefficient capabilities found.\n");
return 0;
}
nonlinearity_coeff_feature_ids =
(long *)calloc(number_of_nonlinearity_coeff_features, sizeof(long));
// printf("\t\tGetting nonlinearity coefficient feature IDs...\n");
number_of_nonlinearity_coeff_features = sbapi_get_nonlinearity_coeffs_features(
deviceID, &error, nonlinearity_coeff_feature_ids,
number_of_nonlinearity_coeff_features);
// printf("\t\t\tResult is %d [%s]\n", number_of_nonlinearity_coeff_features,
// sbapi_get_error_string(error));
for(i = 0; i < number_of_nonlinearity_coeff_features; i++)
{
// printf("\t\t%d: Testing device 0x%02lX, nonlinearity coeffs 0x%02lX\n",
// i, deviceID, nonlinearity_coeff_feature_ids[i]);
// printf("\t\t\tAttempting to get nonlinearity coefficients...\n");
memset(nonlinearityCoeffs, (int)0, 20);//----------------------------------------------------------------------------
length = sbapi_nonlinearity_coeffs_get(deviceID,
nonlinearity_coeff_feature_ids[i], &error, nonlinearityCoeffs, 20);
// printf("\t\t\t\tResult is %d [%s]\n", length, sbapi_get_error_string(error));
if(0 == error && length > 0) {
// printf("\t\t\t\tFirst calibration term: %1.2e\n", nonlinearityCoeffs[0]);
// printf("\t\t\t\tFirst calibration term: %1.2e\n", nonlinearityCoeffs[1]);
// printf("\t\t\t\tFirst calibration term: %1.2e\n", nonlinearityCoeffs[2]);
// printf("\t\t\t\tFirst calibration term: %1.2e\n", nonlinearityCoeffs[3]);
// printf("\t\t\t\tFirst calibration term: %1.2e\n", nonlinearityCoeffs[4]);
// printf("\t\t\t\tFirst calibration term: %1.2e\n", nonlinearityCoeffs[5]);
// printf("\t\t\t\tFirst calibration term: %1.2e\n", nonlinearityCoeffs[6]);
}
// printf("\t\t%d: Finished testing device 0x%02lX, nonlinearity coeffs 0x%02lX\n",
// i, deviceID, nonlinearity_coeff_feature_ids[i]);
}
free(nonlinearity_coeff_feature_ids);
// printf("\tFinished testing nonlinearity coefficient capabilities.\n");
return length;
}

276
othersoft/calibration_console/Source_Files/oceanOpticsFiberImager.cpp Normal file
View File

@ -0,0 +1,276 @@
#include "Header_Files/oceanOpticsFiberImager.h"
OceanOpticsFiberImager::OceanOpticsFiberImager(double * nonlinearityCoeffs, int numberOfCoeffs)
{
m_FiberSpectrometer = NULL;
m_nonlinearityCoeffs = nonlinearityCoeffs;
m_iNumberOfNonlinearityCoeffs = numberOfCoeffs;
}
OceanOpticsFiberImager::~OceanOpticsFiberImager()
{
}
void OceanOpticsFiberImager::connectFiberSpectrometer(QString& SN, QString& pixelCount, QString& wavelengthInfo)
{
using namespace std;
m_FiberSpectrometer = new OceanOptics_lib();
m_FiberSpectrometer->Initialize();
getDeviceInfo(m_deviceInfo);
// m_FiberSpectrometer->GetDeviceInfo(m_deviceInfo);
getDeviceAttribute(m_deviceAttribute);
// m_FiberSpectrometer->GetDeviceAttribute(m_deviceAttribute);
SN = QString::fromStdString(m_deviceInfo.strSN);
pixelCount = QString::number(m_deviceAttribute.iPixels);
wavelengthInfo = QString::number(m_deviceAttribute.fWaveLengthInNM[0]) + "--" + QString::number(m_deviceAttribute.fWaveLengthInNM[m_deviceAttribute.iPixels - 1]);
m_FiberSpectrometer->SetDeviceTemperature(-10);
//<2F><><EFBFBD><EFBFBD>dnֵ<6E><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD>أ<EFBFBD>
string qepro = "QEP";
string flame = "FLMS";
if (m_deviceInfo.strSN.find(qepro) != string::npos)
{
m_MaxValueOfFiberSpectrometer = 200000;
}
else if (m_deviceInfo.strSN.find(flame) != string::npos)
{
m_MaxValueOfFiberSpectrometer = 65535;
}
else//û<><C3BB><EFBFBD>ҵ<EFBFBD>ƥ<EFBFBD><C6A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> dnֵ<6E><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ
{
}
}
void OceanOpticsFiberImager::disconnectFiberSpectrometer()
{
m_FiberSpectrometer->Close();
}
void OceanOpticsFiberImager::getDeviceAttribute(DeviceAttribute& deviceAttribute)
{
m_FiberSpectrometer->GetDeviceAttribute(deviceAttribute);
}
void OceanOpticsFiberImager::getDeviceInfo(DeviceInfo& deviceInfo)
{
m_FiberSpectrometer->GetDeviceInfo(deviceInfo);
}
void OceanOpticsFiberImager::setExposureTime(int iExposureTimeInMS)
{
m_FiberSpectrometer->SetExposureTime(iExposureTimeInMS);
}
void OceanOpticsFiberImager::getExposureTime(int &iExposureTimeInMS)
{
m_FiberSpectrometer->GetExposureTime(iExposureTimeInMS);
}
void OceanOpticsFiberImager::getDeviceTemperature(float &fTemperature)
{
m_FiberSpectrometer->GetDeviceTemperature(fTemperature);
}
void OceanOpticsFiberImager::singleShot(DataFrame &dfData)
{
m_FiberSpectrometer->SingleShot(dfData);
if(m_iNumberOfNonlinearityCoeffs==0)//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ0<CEAA><30><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ô<EFBFBD>Ͳ<EFBFBD><CDB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>У<EFBFBD><D0A3>
{
return;
}
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>У<EFBFBD><D0A3>
for (int i = 0; i < m_deviceAttribute.iPixels; i++)
{
dfData.lData[i] = dfData.lData[i] / (m_nonlinearityCoeffs[0]
+ m_nonlinearityCoeffs[1] * dfData.lData[i]
+ m_nonlinearityCoeffs[2] * pow(dfData.lData[i], 2)
+ m_nonlinearityCoeffs[3] * pow(dfData.lData[i], 3)
+ m_nonlinearityCoeffs[4] * pow(dfData.lData[i], 4)
+ m_nonlinearityCoeffs[5] * pow(dfData.lData[i], 5)
+ m_nonlinearityCoeffs[6] * pow(dfData.lData[i], 6)
+ m_nonlinearityCoeffs[7] * pow(dfData.lData[i], 7)
);
}
}
void OceanOpticsFiberImager::getNonlinearityCoeffs(coeffsFrame &coeffs)
{
printf("This is OceanOpticsFiberImager.\n");
m_FiberSpectrometer->test_nonlinearity_coeffs_feature();
}
void OceanOpticsFiberImager::recordDark(QString path)
{
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8>Ϣ
DeviceAttribute attribute;
DeviceInfo deviceInfo;
getDeviceAttribute(attribute);
getDeviceInfo(deviceInfo);
//<2F>ɼ<EFBFBD><C9BC><EFBFBD>֡
singleShot(m_DarkData);
// //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>csv
// QDateTime curDateTime = QDateTime::currentDateTime();
// QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
//
// QString fileName = path + "/" + currentTime + "_" + QString::fromStdString(deviceInfo.strSN) + "_darkSpectral.csv";
// std::ofstream outfile(fileName.toStdString().c_str());
//
// for (int i = 0; i < attribute.iPixels; i++)
// {
// if (i==0)
// {
// outfile << m_DarkData.usExposureTimeInMS << std::endl;//
// }
// outfile << attribute.fWaveLengthInNM[i] << "," << m_DarkData.lData[i] << std::endl;
// }
//
// outfile.close();
}
void OceanOpticsFiberImager::recordTarget(int recordTimes, QString path)
{
//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8>Ϣ
DeviceAttribute attribute;
DeviceInfo deviceInfo;
getDeviceAttribute(attribute);
getDeviceInfo(deviceInfo);
DataFrame integratingSphereData_tmp;
for (int i = 0; i < recordTimes; i++)
{
singleShot(integratingSphereData_tmp);
if (i == 0)//<2F><>integratingSphereData_tmp<6D>е<EFBFBD><D0B5>ع<EFBFBD>ʱ<EFBFBD>䡢<EFBFBD>¶ȵ<C2B6><C8B5><EFBFBD>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD>m_IntegratingSphereData
{
m_IntegratingSphereData = integratingSphereData_tmp;
}
else
{
for (int i = 0; i < attribute.iPixels; i++)
{
m_IntegratingSphereData.lData[i] += integratingSphereData_tmp.lData[i];
}
}
}
for (int i = 0; i < attribute.iPixels; i++)
{
m_IntegratingSphereData.lData[i] = m_IntegratingSphereData.lData[i] / recordTimes;
}
// //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>csv
// QDateTime curDateTime = QDateTime::currentDateTime();
// QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
//
// QString fileName = path + "/" + currentTime + "_" + QString::fromStdString(deviceInfo.strSN) + "_integratingSphereSpectral.csv";
// std::ofstream outfile(fileName.toStdString().c_str());
//
// for (int i = 0; i < attribute.iPixels; i++)//
// {
// if (i==0)
// {
// outfile << m_IntegratingSphereData.usExposureTimeInMS << std::endl;
// }
// outfile << attribute.fWaveLengthInNM[i] << "," << m_IntegratingSphereData.lData[i] << std::endl;
// }
//
// outfile.close();
}
void OceanOpticsFiberImager::autoExpose()
{
DeviceAttribute attribute;
getDeviceAttribute(attribute);
int iterations = 0;//<2F><>¼<EFBFBD>Զ<EFBFBD><D4B6>ع<EFBFBD><D8B9>Ѿ<EFBFBD><D1BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>
int maxIterations = 10;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ĵ<EFBFBD><C4B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
ZZ_U32 thresholdValue = m_MaxValueOfFiberSpectrometer * 0.8;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ80%
ZZ_U16 range = 10000;
//<2F><><EFBFBD>ó<EFBFBD>ʼ<EFBFBD>ع<EFBFBD>ʱ<EFBFBD><CAB1>
int exposureTimeInMS = 200;
setExposureTime(exposureTimeInMS);
emit sendExposureTimeSignal(exposureTimeInMS);
DataFrame integratingSphereData_tmp;
while (true)
{
if (iterations > maxIterations)//<2F>Ƿ񳬹<C7B7><F1B3ACB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
break;
}
singleShot(integratingSphereData_tmp);
ZZ_S32 maxValue = GetMaxValue(integratingSphereData_tmp.lData, attribute.iPixels);
if (maxValue < thresholdValue && maxValue < (thresholdValue - range))//<2F>ع<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>С
{
double scale = 1 + ((double)(thresholdValue - maxValue) / (double)thresholdValue);
int exposureTime;
m_FiberSpectrometer->GetExposureTime(exposureTime);
m_FiberSpectrometer->SetExposureTime(exposureTime * scale);
emit sendExposureTimeSignal(exposureTime);
ZZ_S32 m = GetMaxValue(integratingSphereData_tmp.lData, attribute.iPixels);
std::cout << "<EFBFBD>Զ<EFBFBD><EFBFBD>ع<EFBFBD>-----------" << "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵΪ" << m << std::endl;
}
else if (maxValue > thresholdValue && maxValue > (thresholdValue + range))//<2F>ع<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
double scale = 1 - ((double)(maxValue - thresholdValue) / (double)thresholdValue);
int exposureTime;
m_FiberSpectrometer->GetExposureTime(exposureTime);
m_FiberSpectrometer->SetExposureTime(exposureTime * scale);
emit sendExposureTimeSignal(exposureTime);
ZZ_S32 m = GetMaxValue(integratingSphereData_tmp.lData, attribute.iPixels);
std::cout << "<EFBFBD>Զ<EFBFBD><EFBFBD>ع<EFBFBD>-----------" << "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵΪ" << m << std::endl;
}
else//<2F>ҵ<EFBFBD><D2B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ع<EFBFBD>ʱ<EFBFBD>䣬<EFBFBD><E4A3AC><EFBFBD><EFBFBD>whileѭ<65><D1AD>
{
break;
}
iterations++;
}
}
ZZ_S32 OceanOpticsFiberImager::GetMaxValue(ZZ_S32 * dark, int number)
{
ZZ_S32 max = 0;
for (size_t i = 0; i < number; i++)
{
if (dark[i] > max)
{
max = dark[i];
}
}
//std::cout << "<22><>֡<EFBFBD><D6A1><EFBFBD><EFBFBD>ֵΪ" << max << std::endl;
return max;
}