iris/iris_format
1
0
Fork 0
Code Issues Pull Requests Packages Projects 1 Releases Wiki Activity

第一次提交

Browse Source
This commit is contained in:
xin
2025-06-12 09:35:09 +08:00
commit 1aba741f67
16 changed files with 27886 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

141
source/iris_format/forwin.cpp Normal file
View File

@ -0,0 +1,141 @@
#include"iris_deffine.h"
#include"json/json.hpp"
#include<string>
#include<vector>
using json = nlohmann::json;
uint64_t get_Sepctral_Info_to_Byte(Sepctral_Info_Section_Data_Struct *sepctralinfo,uint8_t **retbuffer)
{
uint8_t *buffer = *retbuffer; // 使用提供的缓冲区指针
if(buffer != nullptr)
{
delete[] buffer; // 释放之前的内存
buffer = nullptr; // 将指针置为nullptr
}
std::vector<uint8_t> buffer_vector; // 使用vector来管理内存
int number_of_spectral_info = sepctralinfo->SepctralInfoNumber;
if (number_of_spectral_info <= 0)
{
buffer = nullptr; // 如果没有光谱信息，设置buffer为nullptr
return 0; // 返回0表示没有光谱信息
}
for (size_t i = 0; i < number_of_spectral_info; i++)
{
json j;
std::string SensorId=sepctralinfo->SepctralInfoAddressList[i].SensorId;
j["SensorId"] =SensorId;
j["WaveCoeff"]["a1"] = sepctralinfo->SepctralInfoAddressList[i].WaveCoeff[0];
j["WaveCoeff"]["a2"] =sepctralinfo->SepctralInfoAddressList[i].WaveCoeff[1];
j["WaveCoeff"]["a3"] = sepctralinfo->SepctralInfoAddressList[i].WaveCoeff[2];
j["WaveCoeff"]["a4"] = sepctralinfo->SepctralInfoAddressList[i].WaveCoeff[3];
std::string json_str = j.dump();
uint16_t json_length = strlen(json_str.c_str())+1;
if (json_length > 0xFFFF)
{
return 0;
}
uint8_t *tempbuff= new uint8_t[json_length + 3];
tempbuff[1] = (json_length >> 8) & 0xFF; // 高字节
tempbuff[0] = json_length & 0xFF; // 低字节
tempbuff[2] = 0x00; //表示为json
// 将json字符串复制到tempbuff中
strcpy((char*)tempbuff + 3, json_str.c_str()); // +1 for the type byte
// 将tempbuff中的数据添加到buffer_vector中
buffer_vector.insert(buffer_vector.end(), tempbuff, tempbuff + json_length + 3);
delete[] tempbuff; // 释放临时缓冲区
/* code */
}
// 将vector中的数据复制到buffer中
uint16_t total_length = buffer_vector.size()+2;
buffer = new uint8_t[total_length];
if (buffer == nullptr)
{
return 0; // 返回0表示内存分配失败
}
int16_t spectralnumber =sepctralinfo->SepctralInfoNumber;
buffer[1] = (spectralnumber >> 8) & 0xFF; // 高字节
buffer[0] = spectralnumber & 0xFF; // 低字节
memcpy(buffer + 2, buffer_vector.data(), buffer_vector.size()); // 将vector中的数据复制到buffer中
*retbuffer = buffer; // 设置输出缓冲区指针为新分配的缓冲区
return total_length; // 返回总长度
}
uint64_t get_Other_Info_to_Byte(Other_Info_Section_Data_Struct *otherdata,uint8_t **retbuffer)
{
uint8_t *buffer = *retbuffer; // 使用提供的缓冲区指针
if(buffer != nullptr)
{
delete[] buffer; // 释放之前的内存
buffer = nullptr; // 将指针置为nullptr
}
std::vector<uint8_t> buffer_vector; // 使用vector来管理内存
int number_of_spectral_info = otherdata->OtherInfoNumber;
if (number_of_spectral_info <= 0)
{
buffer = nullptr; // 如果没有光谱信息，设置buffer为nullptr
return 0; // 返回0表示没有光谱信息
}
for (size_t i = 0; i < number_of_spectral_info; i++)
{
json j;
uint8_t Type=otherdata->OtherInfoAddressList[i].Type;
j["Type"] =Type;
// j["WaveCoeff"]["a1"] = otherdata->SepctralInfoAddressList[i].WaveCoeff[0];
// j["WaveCoeff"]["a2"] =otherdata->SepctralInfoAddressList[i].WaveCoeff[1];
// j["WaveCoeff"]["a3"] = otherdata->SepctralInfoAddressList[i].WaveCoeff[2];
// j["WaveCoeff"]["a4"] = otherdata->SepctralInfoAddressList[i].WaveCoeff[3];
std::string json_str = j.dump();
uint16_t json_length = json_str.length()+1;
if (json_length > 0xFFFF)
{
return 0;
}
uint8_t *tempbuff= new uint8_t[json_length + 3];
tempbuff[1] = (json_length >> 8) & 0xFF; // 高字节
tempbuff[0] = json_length & 0xFF; // 低字节
tempbuff[2] = 0x00; //表示为json
// 将json字符串复制到tempbuff中
strcpy((char*)tempbuff + 3, json_str.c_str()); // +1 for the type byte
// 将tempbuff中的数据添加到buffer_vector中
buffer_vector.insert(buffer_vector.end(), tempbuff, tempbuff + json_length + 3);
delete[] tempbuff; // 释放临时缓冲区
/* code */
}
// 将vector中的数据复制到buffer中
uint16_t total_length = buffer_vector.size()+2;
buffer = new uint8_t[total_length];
if (buffer == nullptr)
{
return 0; // 返回0表示内存分配失败
}
int16_t spectralnumber =otherdata->OtherInfoNumber;
buffer[1] = (spectralnumber >> 8) & 0xFF; // 高字节
buffer[0] = spectralnumber & 0xFF; // 低字节
memcpy(buffer + 2, buffer_vector.data(), buffer_vector.size()); // 将vector中的数据复制到buffer中
*retbuffer = buffer; // 设置输出缓冲区指针为新分配的缓冲区
return total_length; // 返回总长度
}
One_Spectral_Info_Struct Get_spectral_info_from_byte(uint8_t *buffer, size_t length) {
One_Spectral_Info_Struct retstruct;
std::string json_str(reinterpret_cast<char*>(buffer), length-1);
json j = json::parse(json_str, nullptr, false);
std::string sensor_id = j["SensorId"].get<std::string>();
strcpy(retstruct.SensorId,sensor_id.c_str() );
retstruct.WaveCoeff[0] = j["WaveCoeff"]["a1"].get<double>();
retstruct.WaveCoeff[1] = j["WaveCoeff"]["a2"].get<double>();
retstruct.WaveCoeff[2] = j["WaveCoeff"]["a3"].get<double>();
retstruct.WaveCoeff[3] = j["WaveCoeff"]["a4"].get<double>();
return retstruct;
}

604
source/iris_format/iris_deffine.cpp Normal file
View File

@ -0,0 +1,604 @@
#include "iris_deffine.h"
#include<string>
#ifndef nullptr
#define nullptr NULL
#endif
MyfileControl_Struct *File_control_ptr = nullptr;
void IRIS_DATA_example() {
One_IRIS_DATA_Struct mydata = Create_IRIS_DATA_Struct();
//
// double plot1[2000]={0.0}; // HH3_IRIS 产生的数据
// float plot2[500]={0.0}; // IS3_IRIS 产生的数据
// uint16_t plot3[1000]={0};// HH3_IRIS 产生的数据
// float plot4[500]={0.0}; // IS2_IRIS 产生的数据
//最好不要让指针指向数组 影响destroy函数
double *plot1= new double[2000]; // HH3_IRIS 产生的数据
float *plot2= new float[500]; // IS3_IRIS 产生的数据
uint16_t *plot3= new uint16_t[1000]; // HH3_IRIS 产生的数据
float *plot4= new float[500]; // IS2_IRIS 产生的数据
//随机产生plot1数据
for (int i = 0; i < 2000; i++) {
plot1[i] = static_cast<double>(rand() % 1000) / 10.0; // 生成0.0到100.0之间的随机数
}
//随机产生plot2数据
for (int i = 0; i < 500; i++) {
plot2[i] = static_cast<float>(rand() % 1000) / 10.0; // 生成0.0到100.0之间的随机数
}
//随机产生plot3数据
for (int i = 0; i < 1000; i++) {
plot3[i] = static_cast<uint16_t>(rand() % 1000); // 生成0到999之间的随机数
}
//随机产生plot4数据
for (int i = 0; i < 500; i++) {
plot4[i] = static_cast<float>(rand() % 1000) / 10.0; // 生成0.0到100.0之间的随机数
}
//时间结构体构建
IRIS_Time_Struct time;
time.Year = 2023;
time.Month = 10;
time.Day = 1;
time.Hour = 12;
time.Minute = 30;
time.Second = 0;
//光谱数据区域构建
mydata.SepctralDataSection.SectionContent.SepctralDataNumber=4;
mydata.SepctralDataSection.SectionContent.SepctralDataAddressList = new One_Spectral_Data_Struct[4];
///赋值第一个光谱数据
One_Spectral_Data_Struct &tempspectradata= mydata.SepctralDataSection.SectionContent.SepctralDataAddressList[0];
tempspectradata.CollectionTime= time; // 采集时间
tempspectradata.DataType = DATA_TYPE_FLOAT64; // 假设数据类型为0
tempspectradata.PixelSize = sizeof(double);
tempspectradata.Bands = 2000;
tempspectradata.FiberID=1;
tempspectradata.SpectralDataAddress = (uint8_t *)plot1;
std::string temp="HH3_IRIS";
strcpy(tempspectradata.SensorId, temp.c_str());
///赋值第二个光谱数据
One_Spectral_Data_Struct &tempspectradata1= mydata.SepctralDataSection.SectionContent.SepctralDataAddressList[1];
tempspectradata1.CollectionTime= time; // 采集时间
tempspectradata1.DataType = DATA_TYPE_FLOAT32; // 假设数据类型为0
tempspectradata1.PixelSize = sizeof(float); // 假设像素大小为1000
tempspectradata1.Bands = 500; // 假设波段数为1000
tempspectradata1.FiberID=1;
tempspectradata1.SpectralDataAddress = (uint8_t *)plot2;
std::string temp1="IS3_IRIS";
strcpy(tempspectradata1.SensorId, temp1.c_str());
///赋值第三个光谱数据
One_Spectral_Data_Struct &tempspectradata2= mydata.SepctralDataSection.SectionContent.SepctralDataAddressList[2];
tempspectradata2.CollectionTime= time; // 采集时间
tempspectradata2.DataType = DATA_TYPE_INT16; // 假设数据类型为0
tempspectradata2.PixelSize = sizeof(uint16_t); // 假设像素大小为1000
tempspectradata2.Bands = 500; // 假设波段数为1000
tempspectradata2.FiberID=2;
tempspectradata2.SpectralDataAddress = (uint8_t *)plot3;
std::string temp2="IS2_IRIS";
strcpy(tempspectradata2.SensorId, temp2.c_str());
///赋值第二个光谱数据
One_Spectral_Data_Struct &tempspectradata3= mydata.SepctralDataSection.SectionContent.SepctralDataAddressList[3];
tempspectradata3.CollectionTime= time; // 采集时间
tempspectradata3.DataType = DATA_TYPE_FLOAT32; // 假设数据类型为0
tempspectradata3.PixelSize = sizeof(float); // 假设像素大小为1000
tempspectradata3.Bands = 500; // 假设波段数为1000
tempspectradata3.FiberID=3;
tempspectradata3.SpectralDataAddress = (uint8_t *)plot4;
strcpy(tempspectradata3.SensorId, temp1.c_str());
///光谱信息区域构造
mydata.SepctralInfoSection.SectionContent.SepctralInfoNumber = 3;
mydata.SepctralInfoSection.SectionContent.SepctralInfoAddressList = new One_Spectral_Info_Struct[3];
//第一个光谱仪的信息
One_Spectral_Info_Struct &tempspectralinfo=mydata.SepctralInfoSection.SectionContent.SepctralInfoAddressList[0];
strcpy(tempspectralinfo.SensorId, "HH3_IRIS");
tempspectralinfo.WaveCoeff[0] = 0.1;
tempspectralinfo.WaveCoeff[1] = 0.2;
tempspectralinfo.WaveCoeff[2] = 0.3;
tempspectralinfo.WaveCoeff[3] = 0.4;
//第二个光谱仪的信息
One_Spectral_Info_Struct &tempspectralinfo1=mydata.SepctralInfoSection.SectionContent.SepctralInfoAddressList[1];
strcpy(tempspectralinfo1.SensorId, "IS3_IRIS");
tempspectralinfo1.WaveCoeff[0] = 0.5;
tempspectralinfo1.WaveCoeff[1] = 0.6;
tempspectralinfo1.WaveCoeff[2] = 0.7;
tempspectralinfo1.WaveCoeff[3] = 0.8;
//第三个光谱仪的信息
One_Spectral_Info_Struct &tempspectralinfo2=mydata.SepctralInfoSection.SectionContent.SepctralInfoAddressList[2];
strcpy(tempspectralinfo2.SensorId, "IS2_IRIS");
tempspectralinfo2.WaveCoeff[0] = 0.9;
tempspectralinfo2.WaveCoeff[1] = 1.0;
tempspectralinfo2.WaveCoeff[2] = 1.1;
tempspectralinfo2.WaveCoeff[3] = 1.2;
///其他信息区域构造
mydata.OtherInfoSection.SectionContent.OtherInfoNumber = 0;
mydata.OtherInfoSection.SectionContent.OtherInfoAddressList = nullptr; // 假设没有其他信息
///图像信息区域构造
mydata.ImageInfoSection.SectionContent.ImageInfoNumber = 1;
// int8_t image[10000]; 用数组会影响destroy 最好动态分配
int8_t *image = new int8_t[10000]; // 假设图像数据为10000字节
mydata.ImageInfoSection.SectionContent.ImageInfoAddressList = new One_Image_Info_Struct[1];
One_Image_Info_Struct &tempimageinfo=mydata.ImageInfoSection.SectionContent.ImageInfoAddressList[0];
tempimageinfo.DataLength = 10000+100+sizeof(IRIS_Time_Struct)+1; // 假设图像数据长度为10000
strcpy(tempimageinfo.Name, "SampleImage");
tempimageinfo.CollectionTime = time;
tempimageinfo.Type = 3; // 假设图像类型为1
tempimageinfo.ImageDataAddress = (uint8_t *)image; // 假设图像数据地址为image
if (File_control_ptr!= nullptr) {
// 调用写入函数
write_IRIS_DATA_Struct_EMB(&mydata, "iris_data_example.iris", *File_control_ptr);
One_IRIS_DATA_Struct mydata2= Get_One_IRIS_DATA_From_File("iris_data_example.iris", *File_control_ptr);
Destroy_IRIS_DATA_Struct(mydata2);
Destroy_IRIS_DATA_Struct(mydata);
//mydata2.ImageInfoSection.SectionContent.ImageInfoNumber=1;
} else {
}
}
void Set_File_Functions( MyfileControl_Struct *File_control)
{
File_control_ptr = File_control;
}
void Write_IRIS_DATA_Struct_EMB_NoFUNC( One_IRIS_DATA_Struct *iris_data,std::string Filepath)
{
if (File_control_ptr == nullptr) {
return; // Ensure File_control_ptr is set before proceeding
}
write_IRIS_DATA_Struct_EMB(iris_data,Filepath,*File_control_ptr);
}
One_IRIS_DATA_Struct Create_IRIS_DATA_Struct()
{
One_IRIS_DATA_Struct iris_data;
iris_data.SepctralDataSection.SectionFlag = SPECTRAL_DATA_SECTION;
iris_data.SepctralDataSection.SectionLength = 0;
iris_data.SepctralInfoSection.SectionFlag = SPECTRAL_INFO_SECTION;
iris_data.SepctralInfoSection.SectionLength = 0;
iris_data.OtherInfoSection.SectionFlag = OTHER_SECTION;
iris_data.OtherInfoSection.SectionLength = 0;
iris_data.ImageInfoSection.SectionFlag = IMAGE_SECTION;
iris_data.ImageInfoSection.SectionLength = 0;
iris_data.SepctralDataSection.SectionContent.SepctralDataAddressList = nullptr;
iris_data.SepctralInfoSection.SectionContent.SepctralInfoAddressList = nullptr;
iris_data.OtherInfoSection.SectionContent.OtherInfoAddressList = nullptr;
iris_data.ImageInfoSection.SectionContent.ImageInfoAddressList = nullptr;
return iris_data;
}
// Helper function to write a section
void write_section_emb(SECTIONFLAG flag, uint64_t length, const uint8_t *data, WriteDataFunc write_callback) {
write_callback((uint8_t *)(&flag), sizeof(SECTIONFLAG));
write_callback((uint8_t *)(&length), sizeof(uint64_t));
if (length > 0 && data != nullptr) {
write_callback(data, length);
}
}
uint64_t get_Sepctral_Data_to_Byte(Sepctral_Data_Section_Data_Struct *data_section, uint8_t **retbuff) {
uint8_t *buff = *retbuff; // Use the provided buffer pointer
if(buff!= nullptr) {
delete[] buff; // Free the buffer if it was allocated
buff = nullptr;
}
if (data_section == nullptr || data_section->SepctralDataAddressList == nullptr) {
return 0;
}
uint64_t total_length = sizeof(uint16_t); // For SepctralDataNumber
for (uint16_t i = 0; i < data_section->SepctralDataNumber; ++i) {
const One_Spectral_Data_Struct *item = &data_section->SepctralDataAddressList[i];
total_length += 100; // Name
total_length += 50; // SensorId
total_length +=1; // FiberID
total_length += sizeof(IRIS_Time_Struct); // CollectionTime
total_length += sizeof(double); // Exposure
total_length += sizeof(float); // Gain
total_length += sizeof(uint8_t); // DataType
total_length += sizeof(uint8_t); // PixelSize
total_length += sizeof(uint8_t); // GroundType
total_length += sizeof(uint16_t); // Bands
total_length += sizeof(uint8_t); // ValidFlag
total_length += (uint64_t)item->PixelSize * item->Bands; // SpectralData
}
buff = new uint8_t[total_length];
uint16_t spectral_data_number = data_section->SepctralDataNumber;
memcpy(buff, &spectral_data_number, sizeof(uint16_t)); // Copy SepctralDataNumber to the buffer
uint64_t now_offset = sizeof(uint16_t); // Start after SepctralDataNumber
for (uint16_t i = 0; i < data_section->SepctralDataNumber; ++i) {
const One_Spectral_Data_Struct *item = &data_section->SepctralDataAddressList[i];
memcpy(buff + now_offset, item->Name, 100); // Copy Name
now_offset += 100;
memcpy(buff + now_offset, item->SensorId, 50); // Copy SensorId
now_offset += 50;
memcpy(buff + now_offset, &item->FiberID, sizeof(uint8_t)); // Copy FiberID
now_offset += sizeof(uint8_t);
memcpy(buff + now_offset, &item->CollectionTime, sizeof(IRIS_Time_Struct)); // Copy CollectionTime
now_offset += sizeof(IRIS_Time_Struct);
memcpy(buff + now_offset, &item->Exposure, sizeof(double)); // Copy Exposure
now_offset += sizeof(double);
memcpy(buff + now_offset, &item->Gain, sizeof(float)); // Copy Gain
now_offset += sizeof(float);
memcpy(buff + now_offset, &item->DataType, sizeof(uint8_t)); // Copy DataType
now_offset += sizeof(uint8_t);
memcpy(buff + now_offset, &item->PixelSize, sizeof(uint8_t)); // Copy PixelSize
now_offset += sizeof(uint8_t);
memcpy(buff + now_offset, &item->GroundType, sizeof(uint8_t)); // Copy GroundType
now_offset += sizeof(uint8_t);
memcpy(buff + now_offset, &item->Bands, sizeof(uint16_t)); // Copy Bands
now_offset += sizeof(uint16_t);
memcpy(buff + now_offset, &item->ValidFlag, sizeof(uint8_t)); // Copy ValidFlag
now_offset += sizeof(uint8_t);
memcpy(buff + now_offset, item->SpectralDataAddress, (uint64_t)item->PixelSize * item->Bands); // Copy SpectralData
now_offset += (uint64_t)item->PixelSize * item->Bands;
}
if (now_offset != total_length) {
// Handle error: not all data was copied
delete[] buff; // Free the buffer if it was allocated
buff = nullptr;
return -2; // Error: Data length mismatch
}
*retbuff = buff; // Set the output buffer pointer to the allocated buffer
return total_length; // Return the total length of the data written to the buffer
}
uint64_t Get_Image_Data_to_Byte(const Image_Info_Section_Data_Struct *image_section, uint8_t **retbuff) {
if (image_section == nullptr || image_section->ImageInfoAddressList == nullptr,image_section->ImageInfoNumber == 0) {
return 0;
}
uint64_t total_length = sizeof(uint16_t); // For ImageInfoNumber
for (uint16_t i = 0; i < image_section->ImageInfoNumber; ++i) {
const One_Image_Info_Struct *item = &image_section->ImageInfoAddressList[i];
total_length += sizeof(uint64_t); // DataLength
total_length += 100; // Name
total_length += sizeof(IRIS_Time_Struct); // CollectionTime
total_length += sizeof(uint8_t); // Type
total_length += item->DataLength - (100 + sizeof(IRIS_Time_Struct) + sizeof(uint8_t)); // ImageData (DataLength includes Name, Time, Type)
}
uint8_t *buff = new uint8_t[total_length];
uint16_t image_info_number = image_section->ImageInfoNumber;
memcpy(buff, &image_info_number, sizeof(uint16_t)); // Copy ImageInfoNumber to the buffer
uint64_t now_offset = sizeof(uint16_t); // Start after ImageInfoNumber
for (uint16_t i = 0; i < image_section->ImageInfoNumber; ++i) {
const One_Image_Info_Struct *item = &image_section->ImageInfoAddressList[i];
memcpy(buff + now_offset, &item->DataLength, sizeof(uint64_t)); // Copy DataLength
now_offset += sizeof(uint64_t);
memcpy(buff + now_offset, item->Name, 100); // Copy Name
now_offset += 100;
memcpy(buff + now_offset, &item->CollectionTime, sizeof(IRIS_Time_Struct)); // Copy CollectionTime
now_offset += sizeof(IRIS_Time_Struct);
memcpy(buff + now_offset, &item->Type, sizeof(uint8_t)); // Copy Type
now_offset += sizeof(uint8_t);
memcpy(buff + now_offset, item->ImageDataAddress, item->DataLength - (100 + sizeof(IRIS_Time_Struct) + sizeof(uint8_t))); // Copy ImageData
now_offset += item->DataLength - (100 + sizeof(IRIS_Time_Struct) + sizeof(uint8_t));
}
*retbuff= buff; // Set the output buffer pointer to the allocated buffer
return total_length; // Return the total length of the data written to the buffer
}
void write_IRIS_DATA_Struct_EMB(One_IRIS_DATA_Struct *iris_data,std::string Filepath, MyfileControl_Struct File_control) {
if (iris_data == nullptr || File_control.Write_data == nullptr||File_control.open_file == nullptr||File_control.close_file == nullptr) {
return; // Handle error: invalid input
}
File_control.open_file(Filepath, "wb"); // Open the file for writing in binary mode
// Write SpectralData section
uint8_t *tempbuff= nullptr;
iris_data->SepctralDataSection.SectionLength = get_Sepctral_Data_to_Byte(&iris_data->SepctralDataSection.SectionContent, &tempbuff);
write_section_emb(
iris_data->SepctralDataSection.SectionFlag,
iris_data->SepctralDataSection.SectionLength, // Using SectionLength from the struct
tempbuff, // Assuming AddressList points to raw data
File_control.Write_data
);
if (tempbuff != nullptr) {
delete[] tempbuff; // Free the temporary buffer if it was allocated
tempbuff = nullptr;
}
// Write SpectralInfo section
// Based on the ambiguity, assuming SectionLength in the struct is the correct length of the raw data.
iris_data->SepctralInfoSection.SectionLength= get_Sepctral_Info_to_Byte(&iris_data->SepctralInfoSection.SectionContent,&tempbuff);
write_section_emb(
iris_data->SepctralInfoSection.SectionFlag,
iris_data->SepctralInfoSection.SectionLength, // Using SectionLength from the struct
// Assuming AddressList points to raw data
tempbuff,
File_control.Write_data
);
if (tempbuff != nullptr) {
delete[] tempbuff; // Free the temporary buffer if it was allocated
tempbuff = nullptr;
}
// Write Other section
// Based on the ambiguity, assuming SectionLength in the struct is the correct length of the raw data.
iris_data->OtherInfoSection.SectionLength = get_Other_Info_to_Byte(&iris_data->OtherInfoSection.SectionContent, &tempbuff);
write_section_emb(
iris_data->OtherInfoSection.SectionFlag,
iris_data->OtherInfoSection.SectionLength, // Using SectionLength from the struct
tempbuff, // Assuming AddressList points to raw data
File_control.Write_data
);
if (tempbuff != nullptr) {
delete[] tempbuff; // Free the temporary buffer if it was allocated
tempbuff = nullptr;
}
iris_data->ImageInfoSection.SectionLength =Get_Image_Data_to_Byte(&iris_data->ImageInfoSection.SectionContent, &tempbuff);
write_section_emb(
iris_data->ImageInfoSection.SectionFlag,
iris_data->ImageInfoSection.SectionLength, // Using SectionLength from the struct
tempbuff, // Assuming AddressList points to raw data
File_control.Write_data
);
if (tempbuff != nullptr) {
delete[] tempbuff; // Free the temporary buffer if it was allocated
tempbuff = nullptr;
}
File_control.close_file(); // Close the file after writing all sections
}
One_IRIS_DATA_Struct Get_One_IRIS_DATA_From_File(std::string Filepath, MyfileControl_Struct File_control) {
// if (File_control== nullptr) {
// return Create_IRIS_DATA_Struct(); // Return an empty struct if File_control_ptr is not set
// }
One_IRIS_DATA_Struct Retrun_Data;
File_control.open_file(Filepath, "rb"); // Open the file for reading in binary mode
uint64_t ReadLength = 0;
uint8_t *readbuffer = nullptr;
while (1) {
ReadLength= File_control.Read_data(&readbuffer, 12); // Get the file size
if (ReadLength != 12) {
break; // Break if no more data to read
}
uint32_t SecTionFlag = 0;
uint64_t SectionLength = 0;
memcpy(&SecTionFlag, readbuffer, 4); // Read the section flag
memcpy(&SectionLength, readbuffer + 4, 8); // Read the section length
delete [] readbuffer; // Free the read buffer
readbuffer = nullptr; // Reset the pointer to nullptr
switch (SecTionFlag) {
case SPECTRAL_DATA_SECTION: {
Sepctral_Data_Section_Struct &spectral_data_section = Retrun_Data.SepctralDataSection;
spectral_data_section.SectionLength= SectionLength; // 区域长度
Sepctral_Data_Section_Data_Struct &spectral_data_content = spectral_data_section.SectionContent;
uint64_t lenthinsection=0;
lenthinsection+= File_control.Read_data(&readbuffer, 2); // Read the spectral data section
uint16_t number_of_spectral_data = 0;
memcpy(&number_of_spectral_data, readbuffer, 2); // 读取光谱数据数量
spectral_data_content.SepctralDataNumber= number_of_spectral_data; // 设置光谱数据数量
spectral_data_content.SepctralDataAddressList= new One_Spectral_Data_Struct[number_of_spectral_data]; // 创建光谱数据数组
for (int32_t j=0;j<number_of_spectral_data;j++) {
One_Spectral_Data_Struct &one_spectral_data = spectral_data_content.SepctralDataAddressList[j];
lenthinsection+= File_control.Read_data( &readbuffer, sizeof(One_Spectral_Data_Struct)-sizeof(uint8_t *)); // Read the Name
memcpy(&one_spectral_data,readbuffer,sizeof(One_Spectral_Data_Struct)-sizeof(uint8_t *));
int32_t spectral_data_length = one_spectral_data.PixelSize* one_spectral_data.Bands; // 计算光谱数据长度
one_spectral_data.SpectralDataAddress=nullptr;
// one_spectral_data.SpectralDataAddress = new uint8_t[spectral_data_length]; // 分配光谱数据地址
lenthinsection+= File_control.Read_data(&one_spectral_data.SpectralDataAddress, spectral_data_length); // 读取光谱数据
delete [] readbuffer; // 释放之前的读取缓冲区
readbuffer = nullptr; // 释放后将指针设置为nullptr
}
if (lenthinsection!= SectionLength) {
// Handle error: not all data was read
delete[] spectral_data_content.SepctralDataAddressList; // Free the allocated array
spectral_data_content.SepctralDataAddressList = nullptr; // Reset the pointer to nullptr
return Create_IRIS_DATA_Struct(); // Return an empty struct
}
// ReadLength= File_control.Read_data(&readbuffer, SectionLength); // Read the spectral data section
break;
}
case SPECTRAL_INFO_SECTION: {
//ReadLength= File_control.Read_data(&readbuffer, SectionLength); // Read the spectral info section
uint16_t lenth_in_section=0;
Sepctral_Info_Section_Struct &spectral_info_section = Retrun_Data.SepctralInfoSection;
spectral_info_section.SectionLength= SectionLength; // 区域长度
Sepctral_Info_Section_Data_Struct &spectral_info_content = spectral_info_section.SectionContent;
lenth_in_section+= File_control.Read_data(&readbuffer, 2); // Read the spectral info section
uint16_t number_of_spectral_info = 0;
memcpy(&number_of_spectral_info, readbuffer, 2); // 读取光谱信息数量
spectral_info_content.SepctralInfoNumber= number_of_spectral_info; // 设置光谱信息数量
spectral_info_content.SepctralInfoAddressList= new One_Spectral_Info_Struct[number_of_spectral_info]; // 创建光谱信息数组
for (int32_t j=0;j<number_of_spectral_info;j++) {
One_Spectral_Info_Struct &one_spectral_info = spectral_info_content.SepctralInfoAddressList[j];
uint16_t lenth_of_this_spectral_info=0;
uint8_t type_of_spectral_info=0;
lenth_in_section+= File_control.Read_data(&readbuffer, 3); // Read the spectral info section
memcpy(&lenth_of_this_spectral_info, readbuffer, 2); // 读取光谱信息长度
type_of_spectral_info = readbuffer[2]; // 读取光谱信息类型
lenth_in_section+=File_control.Read_data(&readbuffer, lenth_of_this_spectral_info); // Read the spectral info section
if (type_of_spectral_info == 0x00) {
one_spectral_info= Get_spectral_info_from_byte(readbuffer,lenth_of_this_spectral_info);
}
delete [] readbuffer; // 释放之前的读取缓冲区
readbuffer = nullptr; // 释放后将指针设置为nullptr
}
if (lenth_in_section!= SectionLength) {
// Handle error: not all data was read
delete[] spectral_info_content.SepctralInfoAddressList; // Free the allocated array
spectral_info_content.SepctralInfoAddressList = nullptr; // Reset the pointer to nullptr
return Create_IRIS_DATA_Struct(); // Return an empty struct
}
break;
}
case OTHER_SECTION: {
if (SectionLength==0) {
Retrun_Data.OtherInfoSection.SectionLength=0;
Retrun_Data.OtherInfoSection.SectionContent.OtherInfoNumber=0;
break;
}
//ReadLength= File_control.Read_data(&readbuffer, SectionLength); // Read the other section
uint16_t lenth_in_section=0;
Other_Info_Section_Struct &other_info_section = Retrun_Data.OtherInfoSection;
other_info_section.SectionLength= SectionLength; // 区域长度
Other_Info_Section_Data_Struct &other_info_content = other_info_section.SectionContent;
lenth_in_section+= File_control.Read_data(&readbuffer, 2); // Read the other info section
uint16_t number_of_other_info = 0;
memcpy(&number_of_other_info, readbuffer, 2); // 读取其他信息数量
other_info_content.OtherInfoNumber= number_of_other_info; // 设置其他信息数量
other_info_content.OtherInfoAddressList= new One_Other_Info_Struct[number_of_other_info]; // 创建其他信息数组
break;
}
case IMAGE_SECTION: {
if (SectionLength==0) {
Retrun_Data.ImageInfoSection.SectionLength=0;
Retrun_Data.ImageInfoSection.SectionContent.ImageInfoNumber=0;
break;
}
//ReadLength= File_control.Read_data(&readbuffer, SectionLength); // Read the image section
uint16_t lenth_in_section=0;
Image_Info_Section_Struct &image_info_section = Retrun_Data.ImageInfoSection;
image_info_section.SectionLength= SectionLength; // 区域长度
Image_Info_Section_Data_Struct &image_info_content = image_info_section.SectionContent;
lenth_in_section+= File_control.Read_data(&readbuffer, 2); // Read the image info section
uint16_t number_of_image_info = 0;
memcpy(&number_of_image_info, readbuffer, 2); // 读取图像信息数量
image_info_content.ImageInfoNumber= number_of_image_info; // 设置图像信息数量
image_info_content.ImageInfoAddressList= new One_Image_Info_Struct[number_of_image_info]; // 创建图像信息数组
for (int32_t j=0;j<number_of_image_info;j++) {
One_Image_Info_Struct &one_image_info = image_info_content.ImageInfoAddressList[j];
uint64_t image_data_length = 0;
lenth_in_section+= File_control.Read_data(&readbuffer, 8); // Read the image data length
memcpy(&image_data_length, readbuffer, 8); // 读取图像数据长度
one_image_info.DataLength = image_data_length; // 设置图像数据长度
lenth_in_section+= File_control.Read_data(&readbuffer, 100); // Read the image name
memcpy(one_image_info.Name, readbuffer, 100); // 读取图像名称
lenth_in_section+= File_control.Read_data(&readbuffer, sizeof(IRIS_Time_Struct)); // Read the image collection time
memcpy(&one_image_info.CollectionTime, readbuffer, sizeof(IRIS_Time_Struct)); // 读取图像采集时间
lenth_in_section+= File_control.Read_data(&readbuffer, 1); // Read the image type
memcpy(&one_image_info.Type, readbuffer, 1); // 读取图像类型
one_image_info.ImageDataAddress = nullptr; // 初始化图像数据地址为nullptr
int64_t image_total_data_length = image_data_length - (100 + sizeof(IRIS_Time_Struct) + sizeof(uint8_t)); // 计算图像数据长度
lenth_in_section+= File_control.Read_data(&one_image_info.ImageDataAddress, image_total_data_length); // 读取图像数据
delete [] readbuffer; // 释放之前的读取缓冲区
readbuffer = nullptr; // 释放后将指针设置为nullptr
}
if (lenth_in_section!= SectionLength) {
// Handle error: not all data was read
delete[] image_info_content.ImageInfoAddressList; // Free the allocated array
image_info_content.ImageInfoAddressList = nullptr; // Reset the pointer to nullptr
return Create_IRIS_DATA_Struct(); // Return an empty struct
}
break;
}
}
if (readbuffer!=nullptr) {
delete [] readbuffer; // Free the read buffer after processing
readbuffer = nullptr; // Reset the pointer to nullptr
}
}
File_control.close_file(); // Close the file after reading all sections
return Retrun_Data; // Return the populated One_IRIS_DATA_Struct
}
void Destroy_IRIS_DATA_Struct(One_IRIS_DATA_Struct &iris_data) {
//清除光谱区域
if (iris_data.SepctralDataSection.SectionContent.SepctralDataNumber !=0) {
int16_t numberforclear = iris_data.SepctralDataSection.SectionContent.SepctralDataNumber;
for (int16_t i=0;i<numberforclear;i++) {
if (iris_data.SepctralDataSection.SectionContent.SepctralDataAddressList[i].SpectralDataAddress!= nullptr) {
delete[] iris_data.SepctralDataSection.SectionContent.SepctralDataAddressList[i].SpectralDataAddress; // Free the spectral data address
iris_data.SepctralDataSection.SectionContent.SepctralDataAddressList[i].SpectralDataAddress = nullptr; // Reset the pointer to nullptr
}
}
if (iris_data.SepctralDataSection.SectionContent.SepctralDataAddressList!=nullptr)
delete[] iris_data.SepctralDataSection.SectionContent.SepctralDataAddressList; // Free the spectral data address list
iris_data.SepctralDataSection.SectionContent.SepctralDataAddressList = nullptr; // Reset the pointer to nullptr
iris_data.SepctralDataSection.SectionContent.SepctralDataNumber=0;
iris_data.SepctralDataSection.SectionLength=0;
}
//清除光谱信息区域
if (iris_data.SepctralInfoSection.SectionContent.SepctralInfoNumber !=0) {
int16_t numberforclear = iris_data.SepctralInfoSection.SectionContent.SepctralInfoNumber;
for (int16_t i=0;i<numberforclear;i++) {
// No dynamic memory allocation in One_Spectral_Info_Struct, so no need to free anything
}
if (iris_data.SepctralInfoSection.SectionContent.SepctralInfoAddressList!=nullptr)
delete[] iris_data.SepctralInfoSection.SectionContent.SepctralInfoAddressList; // Free the spectral info address list
iris_data.SepctralInfoSection.SectionContent.SepctralInfoAddressList = nullptr; // Reset the pointer to nullptr
iris_data.SepctralInfoSection.SectionContent.SepctralInfoNumber=0;
iris_data.SepctralInfoSection.SectionLength=0;
}
//清除其他信息区域
if (iris_data.OtherInfoSection.SectionContent.OtherInfoNumber !=0) {
int16_t numberforclear = iris_data.OtherInfoSection.SectionContent.OtherInfoNumber;
for (int16_t i=0;i<numberforclear;i++) {
// No dynamic memory allocation in One_Other_Info_Struct, so no need to free anything
}
if (iris_data.OtherInfoSection.SectionContent.OtherInfoAddressList!=nullptr)
delete[] iris_data.OtherInfoSection.SectionContent.OtherInfoAddressList; // Free the other info address list
iris_data.OtherInfoSection.SectionContent.OtherInfoAddressList = nullptr; // Reset the pointer to nullptr
iris_data.OtherInfoSection.SectionContent.OtherInfoNumber=0;
iris_data.OtherInfoSection.SectionLength=0;
}
//清除图像信息区域
if (iris_data.ImageInfoSection.SectionContent.ImageInfoNumber !=0) {
int16_t numberforclear = iris_data.ImageInfoSection.SectionContent.ImageInfoNumber;
for (int16_t i=0;i<numberforclear;i++) {
if (iris_data.ImageInfoSection.SectionContent.ImageInfoAddressList[i].ImageDataAddress!= nullptr) {
delete[] iris_data.ImageInfoSection.SectionContent.ImageInfoAddressList[i].ImageDataAddress; // Free the image data address
iris_data.ImageInfoSection.SectionContent.ImageInfoAddressList[i].ImageDataAddress = nullptr; // Reset the pointer to nullptr
}
}
if (iris_data.ImageInfoSection.SectionContent.ImageInfoAddressList!=nullptr)
delete[] iris_data.ImageInfoSection.SectionContent.ImageInfoAddressList; // Free the image info address list
iris_data.ImageInfoSection.SectionContent.ImageInfoAddressList = nullptr; // Reset the pointer to nullptr
iris_data.ImageInfoSection.SectionContent.ImageInfoNumber=0;
iris_data.ImageInfoSection.SectionLength=0;
}
//清除整个结构体
iris_data.SepctralDataSection.SectionFlag = SPECTRAL_DATA_SECTION;
iris_data.SepctralDataSection.SectionLength = 0;
iris_data.SepctralInfoSection.SectionFlag = SPECTRAL_INFO_SECTION;
iris_data.SepctralInfoSection.SectionLength = 0;
iris_data.OtherInfoSection.SectionFlag = OTHER_SECTION;
iris_data.OtherInfoSection.SectionLength = 0;
iris_data.ImageInfoSection.SectionFlag = IMAGE_SECTION;
iris_data.ImageInfoSection.SectionLength = 0;
}

220
source/iris_format/iris_deffine.h Normal file
View File

@ -0,0 +1,220 @@
#ifndef IRIS_DEFFINE_H
#define IRIS_DEFFINE_H
#include <cstdint> // For uint8_t, uint16_t, uint32_t, uint64_t, int8_t
#include <stddef.h> // For size_t
#include <string> // For std::string
//结构体内存1字节对齐
#pragma pack(1)
#define SPECTRAL_DATA_SECTION 0x00ff00ff
#define SPECTRAL_INFO_SECTION 0xff00ff00
#define OTHER_SECTION 0xf0f0f0f0
#define IMAGE_SECTION 0x0f0f0f0f
/*| 编码值 | 数据类型 | 描述 |
| ------ | -------- | ------------------------------- |
| 0x10 | uint8 | 无符号8位整型 (0-255) |
| 0x11 | int16 | 有符号16位整型 (-32,768~32,767) |
| 0x12 | uint16 | 无符号16位整型 (0-65,535) |
| 0x13 | int32 | 有符号32位整型 |
| 0x14 | uint32 | 无符号32位整型 |
| 0x20 | float32 | IEEE 754单精度浮点 |
| 0x21 | float64 | IEEE 754双精度浮点 |
*/
#define DATA_TYPE_UINT8 0x10
#define DATA_TYPE_INT16 0x11
#define DATA_TYPE_UINT16 0x12
#define DATA_TYPE_INT32 0x13
#define DATA_TYPE_UINT32 0x14
#define DATA_TYPE_FLOAT32 0x20
#define DATA_TYPE_FLOAT64 0x21
typedef uint32_t SECTIONFLAG;
// Function pointer type for saving data (C compatible)
typedef void (*WriteDataFunc)(const uint8_t *data, size_t size);
typedef void (*OpenFileFunc)(std::string Filepath,const char *mode);
typedef void (*CloseFileFunc)(void);
typedef int64_t (*ReadFileFunc)(uint8_t **buffer, size_t size);
// Forward declarations of structs for C compatibility
// This is good practice if structs reference each other
typedef struct IRIS_Time_Struct IRIS_Time_Struct;
typedef struct Section_Data_Struct Section_Data_Struct;
typedef struct One_Spectral_Data_Struct One_Spectral_Data_Struct;
typedef struct Sepctral_Data_Section_Data_Struct Sepctral_Data_Section_Data_Struct;
typedef struct Sepctral_Data_Section_Struct Sepctral_Data_Section_Struct;
typedef struct One_Spectral_Info_Struct One_Spectral_Info_Struct;
typedef struct Sepctral_Info_Section_Data_Struct Sepctral_Info_Section_Data_Struct;
typedef struct Sepctral_Info_Section_Struct Sepctral_Info_Section_Struct;
typedef struct One_Other_Info_Struct One_Other_Info_Struct;
typedef struct Other_Info_Section_Data_Struct Other_Info_Section_Data_Struct;
typedef struct Other_Info_Section_Struct Other_Info_Section_Struct;
typedef struct One_Image_Info_Struct One_Image_Info_Struct;
typedef struct Image_Info_Section_Data_Struct Image_Info_Section_Data_Struct;
typedef struct Image_Info_Section_Struct Image_Info_Section_Struct;
typedef struct One_IRIS_DATA_Struct One_IRIS_DATA_Struct;
typedef struct MyfileControl_Struct MyfileControl_Struct;
typedef struct MyfileControl_Struct
{
OpenFileFunc open_file; // 打开文件函数
CloseFileFunc close_file; // 关闭文件函数
WriteDataFunc Write_data; // 保存数据函数
ReadFileFunc Read_data; // 读取数据函数
} MyfileControl_Struct;
// Define structs with typedef for C compatibility
typedef struct IRIS_Time_Struct
{
int8_t TimeZone; // 时区
uint16_t Year; // 年
uint8_t Month; // 月
uint8_t Day; // 日
uint8_t Hour; // 时
uint8_t Minute; // 分
uint8_t Second; // 秒
uint16_t Millisecond; // 毫秒
} IRIS_Time_Struct;
typedef struct Section_Data_Struct
{
SECTIONFLAG SectionFlag; // 区域标志
uint64_t SectionLength; // 区域长度
uint8_t *SectionDataAddress; // 区域类型 (pointer to data)
} Section_Data_Struct;
///////////////////////////////// 光谱数据结构体 /////////////////////////////////
typedef struct One_Spectral_Data_Struct{
char Name[100]; // 光谱数据名称
char SensorId[50]; // 传感器ID
uint8_t FiberID; // 光纤ID
IRIS_Time_Struct CollectionTime; // 采集时间
double Exposure; // 曝光时间
float Gain; // 增益
uint8_t DataType; // 数据类型
uint8_t PixelSize; // 像素大小
uint8_t GroundType; // 地面类型
uint16_t Bands; // 波段数
uint8_t ValidFlag; // 有效标志
uint8_t *SpectralDataAddress; // 光谱数据地址 (pointer to data)
} One_Spectral_Data_Struct;
typedef struct Sepctral_Data_Section_Data_Struct
{
uint16_t SepctralDataNumber;
One_Spectral_Data_Struct *SepctralDataAddressList; // 光谱数据地址 (pointer to array of structs)
} Sepctral_Data_Section_Data_Struct;
typedef struct Sepctral_Data_Section_Struct
{
SECTIONFLAG SectionFlag; // 区域标志
uint64_t SectionLength; // 区域长度
Sepctral_Data_Section_Data_Struct SectionContent; // 光谱数据区域
} Sepctral_Data_Section_Struct;
///////////////////////////////// 光谱信息结构相关定义 /////////////////////////////////
// 下面结构体应通过转换成json在进行存储 读取时亦然
typedef struct One_Spectral_Info_Struct{
char SensorId[50]; // 传感器ID
double WaveCoeff[4]; // 波长系数
} One_Spectral_Info_Struct;
typedef struct Sepctral_Info_Section_Data_Struct
{
uint16_t SepctralInfoNumber; // 光谱信息数量
One_Spectral_Info_Struct *SepctralInfoAddressList; // 光谱信息地址 (pointer to array of structs)
} Sepctral_Info_Section_Data_Struct;
typedef struct Sepctral_Info_Section_Struct
{
SECTIONFLAG SectionFlag; // 区域标志
uint64_t SectionLength; // 区域长度
Sepctral_Info_Section_Data_Struct SectionContent; // 光谱信息区域
} Sepctral_Info_Section_Struct;
///////////////////////////////// 其他信息结构相关定义 /////////////////////////////////
typedef struct One_Other_Info_Struct{
uint8_t Type; // 信息类型; // 数据地址 (pointer to data)
} One_Other_Info_Struct;
typedef struct Other_Info_Section_Data_Struct
{
uint16_t OtherInfoNumber; // 其他信息数量
One_Other_Info_Struct *OtherInfoAddressList; // 其他信息地址 (pointer to array of structs)
} Other_Info_Section_Data_Struct;
typedef struct Other_Info_Section_Struct
{
SECTIONFLAG SectionFlag; // 区域标志
uint64_t SectionLength; // 区域长度
Other_Info_Section_Data_Struct SectionContent; // 其他信息区域
} Other_Info_Section_Struct;
///////////////////////////////// 图像信息结构相关定义 /////////////////////////////////
typedef struct One_Image_Info_Struct{
uint64_t DataLength; // 图像数据长度
char Name[100]; // 图像名称
IRIS_Time_Struct CollectionTime; // 采集时间
uint8_t Type; // 图像类型
uint8_t *ImageDataAddress; // 图像数据地址 (pointer to data)
} One_Image_Info_Struct;
typedef struct Image_Info_Section_Data_Struct
{
uint16_t ImageInfoNumber; // 图像信息数量
One_Image_Info_Struct *ImageInfoAddressList; // 图像信息地址 (pointer to array of structs)
} Image_Info_Section_Data_Struct;
typedef struct Image_Info_Section_Struct
{
SECTIONFLAG SectionFlag; // 区域标志
uint64_t SectionLength; // 区域长度
Image_Info_Section_Data_Struct SectionContent; // 图像信息区域
} Image_Info_Section_Struct;
typedef struct One_IRIS_DATA_Struct
{
Sepctral_Data_Section_Struct SepctralDataSection; // 光谱数据区域
Sepctral_Info_Section_Struct SepctralInfoSection; // 光谱信息区域
Other_Info_Section_Struct OtherInfoSection; // 其他信息区域
Image_Info_Section_Struct ImageInfoSection; // 图像信息区域
} One_IRIS_DATA_Struct;
//恢复默认字节对齐
#pragma pack()
#ifdef WIN32
#define VSDLL_EXPORTS __declspec(dllexport)
#else
#define VSDLL_EXPORTS
#endif
// Function prototypes (C style)
VSDLL_EXPORTS One_IRIS_DATA_Struct Create_IRIS_DATA_Struct(void);
// 通过全局设置读写函数 在写入时就不用传递函数指针了
VSDLL_EXPORTS void Set_File_Functions( MyfileControl_Struct *File_control);
VSDLL_EXPORTS void Write_IRIS_DATA_Struct_EMB_NoFUNC( One_IRIS_DATA_Struct *iris_data,std::string Filepath);
//改变为指定读写函数的写入
VSDLL_EXPORTS void write_IRIS_DATA_Struct_EMB( One_IRIS_DATA_Struct *iris_data,std::string Filepath, MyfileControl_Struct File_control);
//下面函数需要根据平台自行实现
uint64_t get_Sepctral_Info_to_Byte(Sepctral_Info_Section_Data_Struct *sepctralinfo,uint8_t **retbuffer);
uint64_t get_Other_Info_to_Byte(Other_Info_Section_Data_Struct *otherdata,uint8_t **retbuffer);
One_IRIS_DATA_Struct Get_One_IRIS_DATA_From_File(std::string Filepath, MyfileControl_Struct File_control);
VSDLL_EXPORTS void IRIS_DATA_example();
One_Spectral_Info_Struct Get_spectral_info_from_byte(uint8_t *buffer, size_t length);
void Destroy_IRIS_DATA_Struct(One_IRIS_DATA_Struct &iris_data);
#endif // IRIS_DEFFINE_H

25526
source/json/json.hpp Normal file
View File

File diff suppressed because it is too large Load Diff