jerryzeng/camDev
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
camDev/peakCentering/sourceCode/peakCentering_tb.cpp

350 lines
9.4 KiB
C++
Raw Normal View History

initial check in
2025-06-08 11:37:52 +08:00
#include <fstream>
#include <cstring>
#include <stdio.h>
#include "ap_utils.h"
#include <iostream>
#include "peakCentering.h"
#include "..\..\globals\tbGlobals.h"
void save_bmp_2(
const char* filename,
std::vector<Luma_rgnData>& testSamples)
{
FILE* file;
fopen_s(&file, filename, "wb");
if (!file) {
printf("<EFBFBD>޷<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD> %s\n", filename);
return;
}
// <20><><EFBFBD><EFBFBD>ÿ<EFBFBD><C3BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>
int bytes_per_row = RGN_DATA_WIN_SIZE * 3; // ÿ<><C3BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD>3<EFBFBD>ֽڣ<D6BD>BGR<47><52>
int padding = (4 - (bytes_per_row % 4)) % 4;
int row_size = bytes_per_row + padding;
int height = testSamples.size();
// <20><>ʼ<EFBFBD><CABC><EFBFBD>ļ<EFBFBD>ͷ
BMPFileHeader file_header = {
.file_type = 0x4D42, // 'BM'
.file_size = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader) + row_size * height,
.reserved1 = 0,
.reserved2 = 0,
.offset_data = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader)
};
// <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>Ϣͷ
BMPInfoHeader info_header = {
.size = sizeof(BMPInfoHeader),
.width = RGN_DATA_WIN_SIZE,
.height = height, // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݴ<EFBFBD><DDB4>µ<EFBFBD><C2B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
.planes = 1,
.bit_count = 24,
.compression = 0,
.size_image = (uint32_t)(row_size * height),
.x_pixels_per_meter = 0,
.y_pixels_per_meter = 0,
.colors_used = 0,
.colors_important = 0
};
// д<><D0B4>ͷ<EFBFBD><CDB7>Ϣ
fwrite(&file_header, 1, sizeof(BMPFileHeader), file);
fwrite(&info_header, 1, sizeof(BMPInfoHeader), file);
// д<><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݣ<EFBFBD><DDA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD>п<EFBFBD>ʼ<EFBFBD><CABC>
uint8_t padding_bytes[3] = { 0, 0, 0 };
for (int y = height - 1; y >= 0; y--) {
for (int x = 0; x < RGN_DATA_WIN_SIZE; x++) {
uint8_t pixel = (uint8_t)testSamples[y].data[x];
// <20><>RGBתΪBGR˳<52><CBB3>
fputc(pixel, file); // B
fputc(pixel, file); // G
fputc(pixel, file); // R
}
fwrite(padding_bytes, 1, padding, file); // <20><><EFBFBD><EFBFBD>
}
fclose(file);
}
std::vector<Luma_rgnData> readTestFile(
const char* file,
int* winSize)
{
std::ifstream inputFile(file);
int winW = 0;
std::string strLineTxt;
getline(inputFile, strLineTxt);
sscanf(strLineTxt.c_str(), "%x", &winW);
int size = 0;
std::vector<Luma_rgnData> testData;
Luma_rgnData a_line;
while(getline(inputFile, strLineTxt))
{
if (strLineTxt.empty())
continue;
if(size == 0)
{
int winRdx, y, Rid, Flag, PeakRltvRdx;
sscanf(strLineTxt.c_str(), "%04x %04x %04x %01x %02x", &winRdx, &y, &Rid, &Flag, &PeakRltvRdx);
a_line.WinRdx = (uint16_t)winRdx;
a_line.y = (uint16_t)y;
a_line.Rid = (uint16_t)Rid;
a_line.Flag = (uint8_t)Flag;
a_line.PeakRltvRdx = (uint8_t)PeakRltvRdx;
for(int n = 0; n < RGN_DATA_WIN_SIZE; n ++)
a_line.data[n] = 0;
size = 1 ;
}
else //receive Data
{
int data;
sscanf(strLineTxt.c_str(), "%02x", &data);
a_line.data[size -1] = (uint8_t)data;
if(size >= 16)
{
testData.push_back(a_line);
size = 0;
}
else
size ++;
}
}
inputFile.close();
return testData;
}
void genTestSream(
std::vector<Luma_rgnData>& srcData,
hls::stream<RgnPix>& inStream,
const uint32_t FrmNo,
const uint32_t timeStamp,
const uint32_t encInfo,
const uint16_t frameROI_w,
const uint16_t frameROI_h,
const uint16_t frameROI_x,
const uint16_t frameROI_y)
{
RgnPix VSync = {0,0,0,0,0,0,0};
ap_uint<32> data_32;
//1st:FrmNo
data_32 = FrmNo;
VSync.Sync = 0b10;
VSync.LazerWinX(11,0) = data_32.range(11,0);
VSync.LazerWinY(11,0) = data_32.range(23,12);
VSync.LazerWinRid(7,0) = data_32.range(31,24);
inStream.write(VSync);
//2nd:FrmNo
data_32 = timeStamp;
VSync.Sync = 0b00;
VSync.LazerWinX(11,0) = data_32.range(11,0);
VSync.LazerWinY(11,0) = data_32.range(23,12);
VSync.LazerWinRid(7,0) = data_32.range(31,24);
inStream.write(VSync);
//3rd:encInfo
data_32 = encInfo;
VSync.Sync = 0b00;
VSync.LazerWinX(11,0) = data_32.range(11,0);
VSync.LazerWinY(11,0) = data_32.range(23,12);
VSync.LazerWinRid(7,0) = data_32.range(31,24);
inStream.write(VSync);
//4th:frmW(12bit), frmH(12bit)
ap_uint<16> data16_1, data16_2;
data16_1 = frameROI_w;
data16_2 = frameROI_h;
VSync.Sync = 0b00;
VSync.LazerWinX(11,0) = data16_1.range(11,0);
VSync.LazerWinY(11,0) = data16_2.range(11,0);
inStream.write(VSync);
//5th: frmX, WinNum
int winNum = (int)srcData.size();
data16_1 = frameROI_x;
data16_2 = (uint16_t)winNum;
VSync.Sync = 0b00;
VSync.LazerWinX(11,0) = data16_1.range(11,0);
VSync.LazerWinY(11,0) = data16_2.range(11,0);
inStream.write(VSync);
//6th: frmY
data16_1 = frameROI_y;
VSync.Sync = 0b00;
VSync.LazerWinX(11,0) = data16_1.range(11,0);
VSync.LazerWinY(11,0) = 0;
inStream.write(VSync);
//output data
for(int i = 0; i < winNum; i ++)
{
Luma_rgnData* a_line = &srcData[i];
RgnPix Hsync;
Hsync.LazerWinX = (ap_uint<12>)a_line->WinRdx;
Hsync.LazerWinY = (ap_uint<12>)a_line->y;
Hsync.LazerWinRid = (ap_uint<11>)a_line->Rid;
Hsync.LazerWinFlag = (ap_uint<4>)a_line->Flag;
Hsync.LazerWinRsv = 0;
Hsync.RltvRdx = (ap_uint<8>)a_line->PeakRltvRdx;
Hsync.Sync = 0b01;
inStream.write(Hsync);
for(int j = 0; j < RGN_DATA_WIN_SIZE/2; j ++)
{
RgnPix a_data = {0,0,0,0,0,0,0};
ap_uint<8> data8_1, data8_2;
data8_1 = (ap_uint<8>)a_line->data[j * 2];
data8_2 = (ap_uint<8>)a_line->data[j * 2 + 1];
a_data.LazerWinX(7,0) = data8_1.range(7,0);
a_data.LazerWinY(7,0) = data8_2.range(7,0);
a_data.Sync = 0b00;
inStream.write(a_data);
}
}
return;
}
void convertStreamToArray(
hls::stream<RgnPix>& streamData,
std::vector<Luma_rgnData>& arrayData,
uint32_t* FrmNo,
uint32_t* timeStamp,
uint32_t* encInfo,
uint16_t* frameROI_w,
uint16_t* frameROI_h,
uint16_t* frameROI_x,
uint16_t* frameROI_y)
{
//1st:FrmNo
RgnPix VSync = streamData.read();
ap_uint<32> data_32;
data_32(11,0) = VSync.LazerWinX.range(11,0);
data_32.range(23,12) = VSync.LazerWinY.range(11,0);
data_32.range(31,24) = VSync.LazerWinRid.range(7,0);
*FrmNo = (int)data_32;
//2nd:timeStamp
VSync = streamData.read();
data_32(11,0) = VSync.LazerWinX.range(11,0);
data_32.range(23,12) = VSync.LazerWinY.range(11,0);
data_32.range(31,24) = VSync.LazerWinRid.range(7,0);
*timeStamp = (int)data_32;
//3rd:encInfo
VSync = streamData.read();
data_32(11,0) = VSync.LazerWinX.range(11,0);
data_32.range(23,12) = VSync.LazerWinY.range(11,0);
data_32.range(31,24) = VSync.LazerWinRid.range(7,0);
*encInfo = (int)data_32;
//4th:frmW(12bit), frmH(12bit)
VSync = streamData.read();
ap_uint<16> data16_1, data16_2;
data16_1(11,0) = VSync.LazerWinX.range(11,0);
data16_2(11,0) = VSync.LazerWinY.range(11,0);
*frameROI_w = data16_1;
*frameROI_h = data16_2;
//5th: frmX, WinNum
VSync = streamData.read();
data16_1(11,0) = VSync.LazerWinX.range(11,0);
data16_2(11,0) = VSync.LazerWinY.range(11,0);
*frameROI_x = data16_1;
uint16_t winNum = (uint16_t)data16_2;
//6th: frmY
VSync = streamData.read();
data16_1(11,0) = VSync.LazerWinX.range(11,0);
*frameROI_y = data16_1;
//output data
for(int i = 0; i < winNum; i ++)
{
RgnPix Hsync = streamData.read();
if(Hsync.Sync != 0b01)
continue;
Luma_rgnData a_line;
a_line.WinRdx = (uint16_t)Hsync.LazerWinX;
a_line.y = (uint16_t)Hsync.LazerWinY;
a_line.Rid = (uint16_t)Hsync.LazerWinRid;
a_line.Flag = (uint8_t)Hsync.LazerWinFlag;
a_line.PeakRltvRdx = (uint8_t)Hsync.RltvRdx;
for(int j = 0; j < RGN_DATA_WIN_SIZE/2; j ++)
{
RgnPix a_data = streamData.read();
ap_uint<8> data8_1, data8_2;
data8_1(7,0) = a_data.LazerWinX.range(7,0);
data8_2(7,0) = a_data.LazerWinY.range(7,0);
a_line.data[j * 2] = (uint8_t)data8_1;
a_line.data[j * 2 + 1] = (uint8_t)data8_2;
}
arrayData.push_back(a_line);
}
return;
}
void writepeakCenteringData(
const char* fileName,
std::vector<Luma_rgnData>& outData)
{
std::ofstream sw(fileName);
char str[250];
sprintf_s(str, "0x10");
sw << str << std::endl;
int i_max = outData.size();
for (int i = 0; i < i_max; i++)
{
char data[250];
sprintf_s(data, "%04x %04x %04x %01x %02x",
outData[i].WinRdx, outData[i].y, outData[i].Rid, outData[i].Flag, outData[i].PeakRltvRdx);
sw << data << std::endl;
for (int j = 0; j < RGN_DATA_WIN_SIZE; j++)
{
sprintf_s(data, "%02x", outData[i].data[j]);
sw << data << std::endl;
}
}
sw.close();
}
#define TST_GROUP 1
int main()
{
const char* InDataPath[TST_GROUP] = {
"E:\\CamTestData\\RgnPixData\\testSample\\testData.txt"
};
const char* OutDataPath[TST_GROUP] = {
"E:\\CamTestData\\PkCentering\\testSample\\testData.txt"
};
for(int n = 0; n < TST_GROUP; n ++)
{
int winSize = 0;
std::vector<Luma_rgnData> testData = readTestFile(InDataPath[n], &winSize);
//gen test stream
hls::stream<RgnPix> inStream;
uint32_t FrmNo = 0x1;
uint32_t timeStamp = 0x2;
uint32_t encInfo = 0x3;
uint16_t frameROI_w = 0x100;
uint16_t frameROI_h = 2048;
uint16_t frameROI_x = 0;
uint16_t frameROI_y = 0;
genTestSream(testData, inStream, FrmNo, timeStamp, encInfo, frameROI_w, frameROI_h, frameROI_x, frameROI_y);
hls::stream<RgnPix> outStream;
peakCentering(inStream,outStream);
std::vector<Luma_rgnData> outData;
uint32_t outFrmNo, outTimeStamp, outEncInfo;
uint16_t outROI_w,outROI_h, outROI_x,outROI_y;
convertStreamToArray(
outStream,
outData,
&outFrmNo,
&outTimeStamp,
&outEncInfo,
&outROI_w,
&outROI_h,
&outROI_x,
&outROI_y);
writepeakCenteringData(OutDataPath[n], outData);
}
}
Reference in New Issue Copy Permalink