jerryzeng/camDev
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

撕裂相机算法 version1.7.1

Browse Source
This commit is contained in:
jerryzeng 2026-08-05 18:49:40 +08:00
parent df92bec83a
commit bb92d9bab5
17 changed files with 1696 additions and 303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

317
Calib/sourceCode/Calib.cpp
View File

@ -6,20 +6,24 @@ void calib(
hls::stream<RgnSubPixCalib> &outSubpixCalib
)
{
#if !(VITIS_HLS)
#pragma HLS DATA_PACK variable=inCalibData
#pragma HLS DATA_PACK variable=outSubpixCalib
#else
#pragma HLS aggregate variable=inCalibData compact=bit
#pragma HLS aggregate variable=outSubpixCalib compact=bit
#endif
#pragma HLS INTERFACE axis register both port=inCalibData
#pragma HLS INTERFACE axis register both port=outSubpixCalib
CalibData InData;
InData = inCalibData.read();
ap_uint<1> VSync = InData.Sync.range(1,1);
if(0b0 == VSync) //wait for syncFirst
if(0b10 != InData.Sync) //wait for syncFirst
return;
Byte8 dataBuff;
dataBuff.dData = InData.calibK[0];
ap_uint<12> WinNum = 0;
ap_uint<12> Lines = 0;
RgnSubPixCalib outData = {0,0,0,0,0,0,0};
//1st: frameNo
outData.Sync = InData.Sync;
@ -52,36 +56,62 @@ void calib(
tmp.unData = (unsigned int)data_32;
outData.x = tmp.fdata;
outSubpixCalib.write(outData);
//5th: frmX, WinNum
InData = inCalibData.read();
outData.Sync = InData.Sync;
dataBuff.dData = InData.calibK[0];
data_32 = dataBuff.nData[0];
tmp.unData = (unsigned int)data_32;
outData.x = tmp.fdata;
ap_uint<32> d32_tmp = data_32;
WinNum(11,0) = d32_tmp.range(23,12);
outSubpixCalib.write(outData);
ap_uint<32> d32_t5h = data_32;
Lines(11,0) = d32_t5h.range(23,12); //lines
//outSubpixCalib.write(outData);
//6th: frmY
ap_uint<12> validDataSize = 0;
RgnSubPixCalib outData_1 = {0,0,0,0,0,0,0};
InData = inCalibData.read();
outData.Sync = InData.Sync;
outData_1.Sync = InData.Sync;
dataBuff.dData = InData.calibK[0];
data_32 = dataBuff.nData[0];
ap_uint<32> d32_tmp = data_32;
validDataSize(11,0) = d32_tmp.range(23,12);
d32_tmp(31,12) = 0;
tmp.unData = (unsigned int)data_32;
outData_1.x = tmp.fdata;
//output validDataSize
d32_t5h(23,12) = validDataSize.range(11,0);
tmp.unData = (unsigned int)d32_t5h;
outData.x = tmp.fdata;
outSubpixCalib.write(outData);
outSubpixCalib.write(outData_1);
Byte8 dataConver_x, dataConver_y;
//double kx, ky;
float kx_1, kx_2, ky_1, ky_2;
//line_pt0
RgnSubPixCalib calibPnt;
double rawx,rawy;
float rawx,rawy;
double x2, x3,x4,x5,x6,x7;
double y2, y3,y4,y5,y6,y7;
double kx, ky;
double xmul0=0, xmul1=0, xmul2=0, xmul3=0, xmul4=0, xmul5=0, xmul6=0, xmul7=0;
double ymul0=0, ymul1=0, ymul2=0, ymul3=0, ymul4=0, ymul5=0, ymul6=0, ymul7=0;
for(int n = 0; n < WinNum; n ++)
float xmul0=0, xmul1=0, xmul2=0, xmul3=0, xmul4=0, xmul5=0, xmul6=0, xmul7=0;
float ymul0=0, ymul1=0, ymul2=0, ymul3=0, ymul4=0, ymul5=0, ymul6=0, ymul7=0;
//line_pt1
RgnSubPixCalib calibPnt_pt1;
float rawx_pt1,rawy_pt1;
double x2_pt1, x3_pt1,x4_pt1,x5_pt1,x6_pt1,x7_pt1;
double y2_pt1, y3_pt1,y4_pt1,y5_pt1,y6_pt1,y7_pt1;
float xmul0_pt1=0, xmul1_pt1=0, xmul2_pt1=0, xmul3_pt1=0, xmul4_pt1=0, xmul5_pt1=0, xmul6_pt1=0, xmul7_pt1=0;
float ymul0_pt1=0, ymul1_pt1=0, ymul2_pt1=0, ymul3_pt1=0, ymul4_pt1=0, ymul5_pt1=0, ymul6_pt1=0, ymul7_pt1=0;
bool vldFlag = 0;
bool vldFlag_pt1 = 0;
for(int n = 0; n < Lines; n ++)
{
#pragma HLS LOOP_TRIPCOUNT min=3072 max=3072
for(int j = 0; j <= 8; j ++)
#pragma HLS LOOP_TRIPCOUNT min=4096 max=4096
for(int j = 0; j <= 5; j ++) //6 clocks: 0-pt0, 1-pt1, 2ŁŹ3ŁŹ4ŁŹ5 - K
{
#pragma HLS PIPELINE II=1
InData = inCalibData.read();
@ -89,93 +119,238 @@ void calib(
{
calibPnt.x = (float)(xmul0 + xmul1 + xmul2 + xmul3 + xmul4 + xmul5+ xmul6 + xmul7);
calibPnt.y = (float)(ymul0 + ymul1 + ymul2 + ymul3 + ymul4 + ymul5+ ymul6 + ymul7);
if(n > 0)
if( (n > 0) && (vldFlag == 1))
outSubpixCalib.write(calibPnt);
dataBuff.dData = InData.calibK[0];
rawx = (double)dataBuff.fData[0];
rawx = (float)dataBuff.fData[0];
ap_uint<32> apData32 = (ap_uint<32>)dataBuff.nData[1];
ap_uint<12> dy_12;
dy_12(11,0)= apData32.range(11, 0);
rawy = (double)dy_12;
rawy = (float)dy_12;
calibPnt.rid = apData32.range(22, 12);
calibPnt.flag = apData32.range(26,23);
dataBuff.dData = InData.calibK[1];
apData32 = (ap_uint<32>)dataBuff.nData[0];
calibPnt.value = apData32.range(7,0);
calibPnt.Sync = 0;
calibPnt.Sync = InData.Sync;
calibPnt.rsv = 0;
if(rawx < 0)
vldFlag = 0;
else
vldFlag = 1;
double dtmp_1 = (double)rawx;
double dtmp_2 = (double)rawy;
x2 = dtmp_1 * dtmp_1;
y2 = dtmp_2 * dtmp_2;
}
else if(1 == j)//k0
else if( 1 == j)//read subpix_pt1
{
calibPnt_pt1.x = (float)(xmul0_pt1 + xmul1_pt1 + xmul2_pt1 + xmul3_pt1 + xmul4_pt1 + xmul5_pt1+ xmul6_pt1 + xmul7_pt1);
calibPnt_pt1.y = (float)(ymul0_pt1 + ymul1_pt1 + ymul2_pt1 + ymul3_pt1 + ymul4_pt1 + ymul5_pt1+ ymul6_pt1 + ymul7_pt1);
if( (n > 0) && (vldFlag_pt1 == 1))
outSubpixCalib.write(calibPnt_pt1);
dataBuff.dData = InData.calibK[0];
rawx_pt1 = (float)dataBuff.fData[0];
ap_uint<32> apData32 = (ap_uint<32>)dataBuff.nData[1];
ap_uint<12> dy_12;
dy_12(11,0)= apData32.range(11, 0);
rawy_pt1 = (float)dy_12;
calibPnt_pt1.rid = apData32.range(22, 12);
calibPnt_pt1.flag = apData32.range(26,23);
dataBuff.dData = InData.calibK[1];
apData32 = (ap_uint<32>)dataBuff.nData[0];
calibPnt_pt1.value = apData32.range(7,0);
calibPnt_pt1.Sync = InData.Sync;
calibPnt_pt1.rsv = 0;
if(rawx_pt1 < 0)
vldFlag_pt1 = 0;
else
vldFlag_pt1 = 1;
double dtmp_1 = (double)rawx_pt1;
double dtmp_2 = (double)rawy_pt1;
x2_pt1 = dtmp_1 * dtmp_1;
y2_pt1 = dtmp_2 * dtmp_2;
}
else if(2 == j)//k0, k1*x
{
//kx = InData.calibK[0];
//ky = InData.calibK[1];
dataConver_x.dData = InData.calibK[0];
kx_1 = (float)dataConver_x.fData[0];
ky_1 = (float)dataConver_x.fData[1];
dataConver_y.dData = InData.calibK[1];
kx_2 = (float)dataConver_y.fData[0];
ky_2 = (float)dataConver_y.fData[1];
xmul0 = kx_1;
ymul0 = ky_1;
xmul1 = kx_2 * rawx;
ymul1 = ky_2 * rawy;
double dtmp_1 = (double)rawx;
double dtmp_2 = (double)rawy;
x3 = x2 * dtmp_1;
y3 = y2 * dtmp_2;
xmul0_pt1 = kx_1;
ymul0_pt1 = ky_1;
xmul1_pt1 = kx_2 * rawx_pt1;
ymul1_pt1 = ky_2 * rawy_pt1;
double dtmp_3 = (double)rawx_pt1;
double dtmp_4 = (double)rawy_pt1;
x3_pt1 = x2_pt1 * dtmp_3;
y3_pt1 = y2_pt1 * dtmp_4;
}
else if(3 == j)//k2 * x^2, k3 * x^3
{
dataConver_x.dData = InData.calibK[0];
kx_1 = (float)dataConver_x.fData[0];
ky_1 = (float)dataConver_x.fData[1];
dataConver_y.dData = InData.calibK[1];
kx_2 = (float)dataConver_y.fData[0];
ky_2 = (float)dataConver_y.fData[1];
float x2_tmp = (float)x2;
float y2_tmp = (float)y2;
float x3_tmp = (float)x3;
float y3_tmp = (float)y3;
xmul2 = kx_1 * x2_tmp;
ymul2 = ky_1 * y2_tmp;
xmul3 = kx_2 * x3_tmp;
ymul3 = ky_2 * y3_tmp;
x4 = x2 * x2;
y4 = y2 * y2;
x5 = x3 * x2;
y5 = y3 * x2;
float x2_tmp_pt1 = (float)x2_pt1;
float y2_tmp_pt1 = (float)y2_pt1;
float x3_tmp_pt1 = (float)x3_pt1;
float y3_tmp_pt1 = (float)y3_pt1;
xmul2_pt1 = kx_1 * x2_tmp_pt1;
ymul2_pt1 = ky_1 * y2_tmp_pt1;
xmul3_pt1 = kx_2 * x3_tmp_pt1;
ymul3_pt1 = ky_2 * y3_tmp_pt1;
x4_pt1 = x2_pt1 * x2_pt1;
y4_pt1 = y2_pt1 * y2_pt1;
x5_pt1 = x3_pt1 * x2_pt1;
y5_pt1 = y3_pt1 * x2_pt1;
}
else if(4 == j) //k4 * x^4, k5 * x^5
{
dataConver_x.dData = InData.calibK[0];
kx_1 = (float)dataConver_x.fData[0];
ky_1 = (float)dataConver_x.fData[1];
dataConver_y.dData = InData.calibK[1];
kx_2 = (float)dataConver_y.fData[0];
ky_2 = (float)dataConver_y.fData[1];
float x4_tmp = (float)x4;
float y4_tmp = (float)y4;
float x5_tmp = (float)x5;
float y5_tmp = (float)y5;
xmul4 = kx_1 * x4_tmp;
ymul4 = ky_1 * y4_tmp;
xmul5 = kx_2 * x5_tmp;
ymul5 = ky_2 * y5_tmp;
x6 = x4 * x2;
y6 = y4 * x2;
x7 = x5 * x2;
y7 = y5 * x2;
float x4_tmp_pt1 = (float)x4_pt1;
float y4_tmp_pt1 = (float)y4_pt1;
float x5_tmp_pt1 = (float)x5_pt1;
float y5_tmp_pt1 = (float)y5_pt1;
xmul4_pt1 = kx_1 * x4_tmp_pt1;
ymul4_pt1 = ky_1 * y4_tmp_pt1;
xmul5_pt1 = kx_2 * x5_tmp_pt1;
ymul5_pt1 = ky_2 * y5_tmp_pt1;
x6_pt1 = x4_pt1 * x2_pt1;
y6_pt1 = y4_pt1 * x2_pt1;
x7_pt1 = x5_pt1 * x2_pt1;
y7_pt1 = y5_pt1 * x2_pt1;
}
else if(5 == j)//k6 * x^6, k7 * x^7
{
dataConver_x.dData = InData.calibK[0];
kx_1 = (float)dataConver_x.fData[0];
ky_1 = (float)dataConver_x.fData[1];
dataConver_y.dData = InData.calibK[1];
kx_2 = (float)dataConver_y.fData[0];
ky_2 = (float)dataConver_y.fData[1];
float x6_tmp = (float)x6;
float y6_tmp = (float)y6;
float x7_tmp = (float)x7;
float y7_tmp = (float)y7;
xmul6 = kx_1 * x6_tmp;
ymul6 = ky_1 * y6_tmp;
xmul7 = kx_2 * x7_tmp;
ymul7 = ky_2 * y7_tmp;
float x6_tmp_pt1 = (float)x6_pt1;
float y6_tmp_pt1 = (float)y6_pt1;
float x7_tmp_pt1 = (float)x7_pt1;
float y7_tmp_pt1 = (float)y7_pt1;
xmul6_pt1 = kx_1 * x6_tmp_pt1;
ymul6_pt1 = ky_1 * y6_tmp_pt1;
xmul7_pt1 = kx_2 * x7_tmp_pt1;
ymul7_pt1 = ky_2 * y7_tmp_pt1;
}
#if 0
else if(5 == j) //
{
kx = InData.calibK[0];
ky = InData.calibK[1];
xmul0 = kx;
ymul0 = ky;
}
else if(2 == j)//k1 * x
{
kx = InData.calibK[0];
ky = InData.calibK[1];
xmul1 = kx * rawx;
ymul1 = ky * rawy;
x2 = rawx * rawx;
y2 = rawy * rawy;
}
else if(3 == j) //k2 * x^2
{
kx = InData.calibK[0];
ky = InData.calibK[1];
xmul2 = kx * x2;
ymul2 = ky * y2;
x3 = x2 * rawx;
y3 = y2 * rawy;
}
else if(4 == j)//k3 * x^3
{
kx = InData.calibK[0];
ky = InData.calibK[1];
xmul3 = kx * x3;
ymul3 = ky * y3;
x4 = x3 * rawx;
y4 = y3 * rawy;
}
else if(5 == j) //k4 * x^4
{
kx = InData.calibK[0];
ky = InData.calibK[1];
xmul4 = kx * x4;
ymul4 = ky * y4;
x5 = x4 * rawx;
y5 = y4 * rawy;
}
else if(6 == j) //k5 * x^5
else if(6 == j) //
{
kx = InData.calibK[0];
ky = InData.calibK[1];
xmul5 = kx * x5;
ymul5 = ky * y5;
x6 = x5 * rawx;
y6 = y5 * rawy;
}
else if(7 == j)//k6 * x^6
else if(7 == j)//
{
kx = InData.calibK[0];
ky = InData.calibK[1];
xmul6 = kx * x6;
ymul6 = ky * y6;
x7 = x6 * rawx;
y7 = y6 * rawy;
}
else if(8 == j)//k7 * x^7
else if(8 == j)//
{
kx = InData.calibK[0];
ky = InData.calibK[1];
xmul7 = kx * x7;
ymul7 = ky * y7;
}
#endif
}
}
if(WinNum > 0)
if( (Lines > 0)&& (vldFlag == 1))
{
calibPnt.x = (float)(xmul0 + xmul1 + xmul2 + xmul3 + xmul4 + xmul5+ xmul6 + xmul7);
calibPnt.y = (float)(ymul0 + ymul1 + ymul2 + ymul3 + ymul4 + ymul5+ ymul6 + ymul7);
outSubpixCalib.write(calibPnt);
}
if( (Lines > 0)&& (vldFlag_pt1 == 1))
{
calibPnt_pt1.x = (float)(xmul0_pt1 + xmul1_pt1 + xmul2_pt1 + xmul3_pt1 + xmul4_pt1 + xmul5_pt1+ xmul6_pt1 + xmul7_pt1);
calibPnt_pt1.y = (float)(ymul0_pt1 + ymul1_pt1 + ymul2_pt1 + ymul3_pt1 + ymul4_pt1 + ymul5_pt1+ ymul6_pt1 + ymul7_pt1);
outSubpixCalib.write(calibPnt_pt1);
}
}

4
Calib/sourceCode/calib.h
View File

@ -1,8 +1,8 @@
#ifndef COMPUTE_3D_H
#define COMPUTE_3D_H
#include "..\..\globals\algoGlobals.h"
#include "../../globals/algoGlobals.h"
void calib(
hls::stream<CalibData> &inCalibData,

387
Calib/sourceCode/calib_tb.cpp
View File

@ -0,0 +1,387 @@
#include <fstream>
#include <cstring>
#include <stdio.h>
//#include "ap_utils.h"
#include <iostream>
#include "calib.h"
#include "../../globals/tbGlobals.h"
Luma_frameInfo readParaFile(const char* file)
{
std::ifstream inputFile(file);
Luma_frameInfo frameInfo;
std::string strLineTxt;
int data;
getline(inputFile, strLineTxt); //XL
sscanf(strLineTxt.c_str(), "XL:%d", &data);
frameInfo.L = (uint16_t)data;
getline(inputFile, strLineTxt); //XR
getline(inputFile, strLineTxt); //TL
sscanf(strLineTxt.c_str(), "TL:%d", &data);
frameInfo.T = (uint16_t)data;
getline(inputFile, strLineTxt); //TR
getline(inputFile, strLineTxt); //W
sscanf(strLineTxt.c_str(), "W:%d", &data);
frameInfo.W = (uint16_t)data;
getline(inputFile, strLineTxt); //H
sscanf(strLineTxt.c_str(), "H:%d", &data);
frameInfo.H = (uint16_t)data;
getline(inputFile, strLineTxt); //FrmNO
sscanf(strLineTxt.c_str(), "FrmNO:%x", &data);
frameInfo.FrmNo = (uint32_t)data;
getline(inputFile, strLineTxt); //TimStp
sscanf(strLineTxt.c_str(), "TimStp:%x", &data);
frameInfo.TimeStamp = (uint32_t)data;
getline(inputFile, strLineTxt); //EncInfo
sscanf(strLineTxt.c_str(), "EncInfo:%x", &data);
frameInfo.encInfo = (uint32_t)data;
inputFile.close();
return frameInfo;
}
std::vector<RgnSubPix> readSubpixDataFile(
const char* file,
uint16_t* validSize)
{
std::ifstream inputFile(file);
std::string strLineTxt;
int size = 0;
std::vector<RgnSubPix> testData;
RgnSubPix a_line;
uint16_t validNum = 0;
while(getline(inputFile, strLineTxt))
{
if (strLineTxt.empty())
continue;
float x;
int y, Rid, Flag, pkValue, Sync;
#if defined(__linux__)
sscanf(strLineTxt.c_str(), "%f %d %d %x %d %x", &x, &y, &Rid, &Flag, &pkValue, &Sync);
#else
sscanf_s(strLineTxt.c_str(), "%f %d %d %x %d %x", &x, &y, &Rid, &Flag, &pkValue, &Sync);
#endif
a_line.x = (float)x;
a_line.y = (ap_uint<12>)y;
a_line.rid = (ap_uint<11>)Rid;
a_line.flag = (ap_uint<4>)Flag;
a_line.value = (ap_uint<8>)pkValue;
a_line.Sync = (ap_uint<2>)Sync;
testData.push_back(a_line);
if(x >= 0)
validNum ++;
}
*validSize = validNum;
inputFile.close();
return testData;
}
void genCalibTestSream(
std::vector<RgnSubPix>& subpixData,
hls::stream<CalibData>& calibStream,
const Luma_frameInfo framwInfo,
const uint16_t validDataSize)
{
CalibData VSync;
Byte8 dataBuff;
//1st:FrmNo
dataBuff.nData[0] = framwInfo.FrmNo;
dataBuff.nData[1] = 0;
VSync.Sync = 0b10;
VSync.calibK[0] = dataBuff.dData;
VSync.calibK[1] = 0;
calibStream.write(VSync);
//2nd:FrmNo
dataBuff.nData[0] = framwInfo.TimeStamp;
VSync.Sync = 0b00;
VSync.calibK[0] = dataBuff.dData;
VSync.calibK[1] = 0;
calibStream.write(VSync);
//3rd:encInfo
dataBuff.nData[0] = framwInfo.encInfo;
VSync.Sync = 0b00;
VSync.calibK[0] = dataBuff.dData;
VSync.calibK[1] = 0;
calibStream.write(VSync);
//4th:frmW(12bit), frmH(12bit)
ap_uint<16> data16_1, data16_2;
data16_1 = framwInfo.W;
data16_2 = framwInfo.H;
ap_uint<32> tmpData;
tmpData(11,0) = data16_1.range(11,0);
tmpData(23,12) = data16_2.range(11,0);
tmpData(31,24) = 0;
dataBuff.nData[0] = (uint32_t)tmpData;
VSync.calibK[0] = dataBuff.dData;
VSync.calibK[1] = 0;
VSync.Sync = 0b00;
calibStream.write(VSync);
//5th: frmX, WinNum
int lines = (int)subpixData.size() / 2; //lines
data16_1 = framwInfo.L;
data16_2 = (uint16_t)lines;
tmpData(11,0) = data16_1.range(11,0);
tmpData(23,12) = data16_2.range(11,0);
tmpData(31,24) = 0;
dataBuff.nData[0] = (uint32_t)tmpData;
VSync.calibK[0] = dataBuff.dData;
VSync.calibK[1] = 0;
VSync.Sync = 0b00;
calibStream.write(VSync);
//6th: frmY
data16_1 = framwInfo.T;
data16_2 = validDataSize;
tmpData(11,0) = data16_1.range(11,0);
tmpData(23,12) = data16_2.range(11,0);
tmpData(31,24) = 0;
dataBuff.nData[0] = (uint32_t)tmpData;
VSync.calibK[0] = dataBuff.dData;
VSync.calibK[1] = 0;
VSync.Sync = 0b00;
calibStream.write(VSync);
//output data
for(int i = 0; i < lines; i ++)
{
if(i == lines-1)
int kkk = 1; //debug point
RgnSubPix a_line = subpixData[i*2];
CalibData conData;
dataBuff.fData[0] = a_line.x;
ap_uint<32> apData32;
apData32(11, 0) = a_line.y.range(11,0);
apData32(22, 12) = a_line.rid.range(10,0);
apData32(26,23) = a_line.flag(3,0);
apData32(31,27) = 0;
dataBuff.nData[1] = (uint32_t)apData32;
conData.calibK[0] = dataBuff.dData;
apData32(7,0) = a_line.value.range(7,0);
apData32(31,8) = 0;
dataBuff.nData[0] = (uint32_t)apData32;
dataBuff.nData[1] = 0;
conData.calibK[1] = dataBuff.dData;
conData.Sync = a_line.Sync;
calibStream.write(conData);
a_line = subpixData[i*2+1];
dataBuff.fData[0] = a_line.x;
apData32(11, 0) = a_line.y.range(11,0);
apData32(22, 12) = a_line.rid.range(10,0);
apData32(26,23) = a_line.flag(3,0);
apData32(31,27) = 0;
dataBuff.nData[1] = (uint32_t)apData32;
conData.calibK[0] = dataBuff.dData;
apData32(7,0) = a_line.value.range(7,0);
apData32(31,8) = 0;
dataBuff.nData[0] = (uint32_t)apData32;
dataBuff.nData[1] = 0;
conData.calibK[1] = dataBuff.dData;
conData.Sync = a_line.Sync;
calibStream.write(conData);
for(int m = 0; m < 4; m ++) //write k
{
conData.Sync = 0b00;
if(m == 0)
{
Byte8 dataConv_0;
dataConv_0.fData[0] = 0.0;
dataConv_0.fData[1] = 0.0;
Byte8 dataConv_1;
dataConv_1.fData[0] = 1.0;
dataConv_1.fData[1] = 1.0;
conData.calibK[0] = dataConv_0.dData;
conData.calibK[1] = dataConv_1.dData;
}
else
{
Byte8 dataConv;
dataConv.fData[0] = 0.0;
dataConv.fData[1] = 0.0;
conData.calibK[0] = dataConv.dData;
conData.calibK[1] = dataConv.dData;
}
calibStream.write(conData);
}
}
return;
}
void convertSubpixCalibStreamToArray(
hls::stream<RgnSubPixCalib>& streamData,
std::vector<Luma_rgnSubpixCalib>& 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
RgnSubPixCalib VSync = streamData.read();
UintFloat tmp;
tmp.fdata = VSync.x;
*FrmNo = (uint32_t)tmp.unData;
//2nd:timeStamp
VSync = streamData.read();
tmp.fdata = VSync.x;
*timeStamp = (uint32_t)tmp.unData;
//3rd:encInfo
VSync = streamData.read();
tmp.fdata = VSync.x;
*encInfo = (uint32_t)tmp.unData;
//4th:frmW(12bit), frmH(12bit)
VSync = streamData.read();
tmp.fdata = VSync.x;
*frameROI_w = tmp.unData & 0xfff;
*frameROI_h = (tmp.unData >> 12) & 0xfff;
//5th: frmX, WinNum
VSync = streamData.read();
tmp.fdata = VSync.x;
*frameROI_x = tmp.unData & 0xfff;
uint16_t winNum = (tmp.unData >> 12) & 0xfff;
//6th: frmY
VSync = streamData.read();
tmp.fdata = VSync.x;
*frameROI_y = tmp.unData & 0xfff;
//output data
for(int i = 0; i < winNum; i ++)
{
if(i == winNum-1)
int kkk = 1; //debug point
RgnSubPixCalib data_in = streamData.read();
Luma_rgnSubpixCalib a_pnt;
a_pnt.x = data_in.x;
a_pnt.y = data_in.y;
a_pnt.Rid = (uint16_t)data_in.rid;
a_pnt.Flag = (uint8_t)data_in.flag;
a_pnt.pkValue = (uint8_t)data_in.value;
a_pnt.sync = (uint8_t)data_in.Sync;
arrayData.push_back(a_pnt);
}
return;
}
void writeSubpixCalibData(
const char* fileName,
std::vector<Luma_rgnSubpixCalib>& outData)
{
std::ofstream sw(fileName);
int i_max = outData.size();
for (int i = 0; i < i_max; i++)
{
char data[250];
#if defined(__linux__)
sprintf(data, "%.2f %.2f %04d %01x %02d %01x",
outData[i].x, outData[i].y, outData[i].Rid, outData[i].Flag, outData[i].pkValue, outData[i].sync);
#else
sprintf_s(data, "%.2f %.2f %04d %01x %02d %01x",
outData[i].x, outData[i].y, outData[i].Rid, outData[i].Flag, outData[i].pkValue, outData[i].sync);
#endif
sw << data << std::endl;
}
sw.close();
}
#define TST_GROUP 3
int main()
{
#if defined(__linux__)
const char* SrcDataPath[TST_GROUP] = {
"/home/zengHQ/CamTestData/testSample/PickRgn_C/PickRgn_Rslt/Txt/",
"/home/zengHQ/CamTestData/Grp_0/PickRgn_C/PickRgn_Rslt/Txt/",
"/home/zengHQ/CamTestData/Grp_1/PickRgn_C/PickRgn_Rslt/Txt/"
};
const char* InDataPath[TST_GROUP] = {
"/home/zengHQ/CamTestData/testSample/Subpix/",
"/home/zengHQ/CamTestData/Grp_0/Subpix/",
"/home/zengHQ/CamTestData/Grp_1/Subpix/",
};
const char* OutDataPath[TST_GROUP] = {
"/home/zengHQ/CamTestData/testSample/Calib/",
"/home/zengHQ/CamTestData/Grp_0/Calib/",
"/home/zengHQ/CamTestData/Grp_1/Calib/",
};
#else
const char* SrcDataPath[TST_GROUP] = {
"F:/zengHQ/CamTestData/testSample/PickRgn_C/PickRgn_Rslt/Txt/",
"F:/zengHQ/CamTestData/Grp_0/PickRgn_C/PickRgn_Rslt/Txt/",
"F:/zengHQ/CamTestData/Grp_1/PickRgn_C/PickRgn_Rslt/Txt/"
};
const char* InDataPath[TST_GROUP] = {
"F:/zengHQ/CamTestData/testSample/Subpix/",
"F:/zengHQ/CamTestData/Grp_0/Subpix/",
"F:/zengHQ/CamTestData/Grp_1/Subpix/",
};
const char* OutDataPath[TST_GROUP] = {
"F:/zengHQ/CamTestData/testSample/Calib/",
"F:/zengHQ/CamTestData/Grp_0/Calib/",
"F:/zengHQ/CamTestData/Grp_1/Calib/",
};
#endif
int testFileSize[TST_GROUP] = {1, 4, 4};
for(int n = 1; n < TST_GROUP; n ++)
{
int winSize = 0;
int fileSize = testFileSize[n];
for(int fi = 0; fi < fileSize; fi++)
{
char fileName[200];
char paraFileName[200];
char outFileName[200];
#if defined(__linux__)
sprintf(fileName, "%s%d_L_subpix.txt", InDataPath[n], fi);
sprintf(paraFileName, "%s%d_para_verilog.txt", SrcDataPath[n], fi);
sprintf(outFileName, "%s%d_L_calib.txt", OutDataPath[n], fi);
#else
sprintf_s(fileName, "%s%d_L_subpix.txt", InDataPath[n], fi);
sprintf_s(paraFileName, "%s%d_para_verilog.txt", SrcDataPath[n], fi);
sprintf_s(outFileName, "%s%d_L_calib.txt", OutDataPath[n], fi);
#endif
Luma_frameInfo framwInfo = readParaFile(paraFileName);
uint16_t vldSize = 0;
std::vector<RgnSubPix> testData = readSubpixDataFile(fileName, &vldSize);
//gen test stream
hls::stream<CalibData> inStream;
genCalibTestSream(testData, inStream, framwInfo, vldSize);
hls::stream<RgnSubPixCalib> outStream;
calib(inStream,outStream);
std::vector<Luma_rgnSubpixCalib> outData;
uint32_t outFrmNo, outTimeStamp, outEncInfo;
uint16_t outROI_w,outROI_h, outROI_x,outROI_y;
convertSubpixCalibStreamToArray(
outStream,
outData,
&outFrmNo,
&outTimeStamp,
&outEncInfo,
&outROI_w,
&outROI_h,
&outROI_x,
&outROI_y);
writeSubpixCalibData(outFileName, outData);
}
}
printf("done!\n");
}

41
compute3D/sourceCode/compute3D.cpp
View File

@ -4,16 +4,21 @@
void compute3D(
hls::stream<RgnSubPixCalib> &inSubCalib,
hls::stream<Pnt3D> &outPt3D,
double u0,
double v0,
double F_inv,
double plane_a,
double plane_b,
double plane_c
float u0_f,
float v0_f,
float F_inv_f,
float plane_a_f,
float plane_b_f,
float plane_c_f
)
{
#if !(VITIS_HLS)
#pragma HLS DATA_PACK variable=inSubCalib
#pragma HLS DATA_PACK variable=outPt3D
#else
#pragma HLS aggregate variable=inSubCalib compact=bit
#pragma HLS aggregate variable=outPt3D compact=bit
#endif
#pragma HLS INTERFACE axis register both port=inSubCalib
#pragma HLS INTERFACE axis register both port=outPt3D
@ -42,9 +47,9 @@ void compute3D(
outPt3D.write(outData);
//4th: frmW, frmH
InData = inSubCalib.read();
//outData.Sync = InData.Sync;
//outData.x = InData.x;
//outPt3D.write(outData);
outData.Sync = InData.Sync;
outData.x = InData.x;
outPt3D.write(outData);
//5th: frmX, WinNum
InData = inSubCalib.read();
outData.Sync = InData.Sync;
@ -53,14 +58,20 @@ void compute3D(
ap_uint<32> d32 = (ap_uint<32>)tmp.unData;
WinNum(11,0) = d32.range(23,12);
tmp.unData = (unsigned int)WinNum;
outData.x = tmp.fdata;
outData.x = InData.x;
outPt3D.write(outData);
//6th: frmY
InData = inSubCalib.read();
//outData.Sync = InData.Sync;
//outData.x = InData.x;
//outPt3D.write(outData);
outData.Sync = InData.Sync;
outData.x = InData.x;
outPt3D.write(outData);
double u0 = u0_f;
double v0 =v0_f;
double F_inv =F_inv_f;
double plane_a = plane_a_f;
double plane_b = plane_b_f;
double plane_c = plane_c_f;
for(int n = 0; n < WinNum; n ++)
{
#pragma HLS LOOP_TRIPCOUNT min=3072 max=3072
@ -78,7 +89,9 @@ void compute3D(
outData.y = (float)y;
outData.z = (float)z;
outData.value = InData.value;
outData.Sync = 0;
outData.Sync = InData.Sync;
outPt3D.write(outData);
if(0b11 == InData.Sync)
break;
}
}

14
compute3D/sourceCode/compute3D.h
View File

@ -2,17 +2,17 @@
#ifndef COMPUTE_3D_H
#define COMPUTE_3D_H
#include "..\..\globals\algoGlobals.h"
#include "../../globals/algoGlobals.h"
void compute3D(
hls::stream<RgnSubPixCalib> &inSubCalib,
hls::stream<Pnt3D> &outPt3D,
double u0,
double v0,
double F_inv,
double plane_a,
double plane_b,
double plane_c
float u0,
float v0,
float F_inv,
float plane_a,
float plane_b,
float plane_c
);
#endif

323
compute3D/sourceCode/compute3D_tb.cpp
View File

@ -0,0 +1,323 @@
#include <fstream>
#include <cstring>
#include <stdio.h>
//#include "ap_utils.h"
#include <iostream>
#include "compute3D.h"
#include "../../globals/tbGlobals.h"
Luma_frameInfo readParaFile(const char* file)
{
std::ifstream inputFile(file);
Luma_frameInfo frameInfo;
std::string strLineTxt;
int data;
getline(inputFile, strLineTxt); //XL
sscanf(strLineTxt.c_str(), "XL:%d", &data);
frameInfo.L = (uint16_t)data;
getline(inputFile, strLineTxt); //XR
getline(inputFile, strLineTxt); //TL
sscanf(strLineTxt.c_str(), "TL:%d", &data);
frameInfo.T = (uint16_t)data;
getline(inputFile, strLineTxt); //TR
getline(inputFile, strLineTxt); //W
sscanf(strLineTxt.c_str(), "W:%d", &data);
frameInfo.W = (uint16_t)data;
getline(inputFile, strLineTxt); //H
sscanf(strLineTxt.c_str(), "H:%d", &data);
frameInfo.H = (uint16_t)data;
getline(inputFile, strLineTxt); //FrmNO
sscanf(strLineTxt.c_str(), "FrmNO:%x", &data);
frameInfo.FrmNo = (uint32_t)data;
getline(inputFile, strLineTxt); //TimStp
sscanf(strLineTxt.c_str(), "TimStp:%x", &data);
frameInfo.TimeStamp = (uint32_t)data;
getline(inputFile, strLineTxt); //EncInfo
sscanf(strLineTxt.c_str(), "EncInfo:%x", &data);
frameInfo.encInfo = (uint32_t)data;
inputFile.close();
return frameInfo;
}
std::vector<RgnSubPixCalib> readSubpixCalibDataFile(
const char* file)
{
std::ifstream inputFile(file);
std::string strLineTxt;
int size = 0;
std::vector<RgnSubPixCalib> testData;
RgnSubPixCalib a_line;
while(getline(inputFile, strLineTxt))
{
if (strLineTxt.empty())
continue;
float x,y;
int Rid, Flag, pkValue, Sync;
#if defined(__linux__)
sscanf(strLineTxt.c_str(), "%f %f %d %x %d %x", &x, &y, &Rid, &Flag, &pkValue, &Sync);
#else
sscanf_s(strLineTxt.c_str(), "%f %f %d %x %d %x", &x, &y, &Rid, &Flag, &pkValue, &Sync);
#endif
a_line.x = (float)x;
a_line.y = (float)y;
a_line.rid = (ap_uint<11>)Rid;
a_line.flag = (ap_uint<4>)Flag;
a_line.value = (ap_uint<8>)pkValue;
a_line.Sync = (ap_uint<2>)Sync;
testData.push_back(a_line);
}
inputFile.close();
return testData;
}
void genCompute3DTestSream(
std::vector<RgnSubPixCalib>& subpixCalibData,
hls::stream<RgnSubPixCalib>& conpute3DStream,
const Luma_frameInfo framwInfo)
{
RgnSubPixCalib VSync;
UintFloat dataBuff;
//1st:FrmNo
dataBuff.unData = framwInfo.FrmNo;
VSync.Sync = 0b10;
VSync.x = dataBuff.fdata;
VSync.y = 0;
VSync.rid = 0;
VSync.flag = 0;
VSync.value = 0;
VSync.rsv = 0;
conpute3DStream.write(VSync);
//2nd:FrmNo
dataBuff.unData = framwInfo.TimeStamp;
VSync.Sync = 0b00;
VSync.x = dataBuff.fdata;
conpute3DStream.write(VSync);
//3rd:encInfo
dataBuff.unData = framwInfo.encInfo;
VSync.Sync = 0b00;
VSync.x = dataBuff.fdata;
conpute3DStream.write(VSync);
//4th:frmW(12bit), frmH(12bit)
ap_uint<16> data16_1, data16_2;
data16_1 = framwInfo.W;
data16_2 = framwInfo.H;
ap_uint<32> tmpData;
tmpData(11,0) = data16_1.range(11,0);
tmpData(23,12) = data16_2.range(11,0);
tmpData(31,24) = 0;
dataBuff.unData = (uint32_t)tmpData;
VSync.x = dataBuff.fdata;
VSync.Sync = 0b00;
conpute3DStream.write(VSync);
//5th: frmX, WinNum
int winNum = (int)subpixCalibData.size();
data16_1 = framwInfo.L;
data16_2 = (uint16_t)winNum;
tmpData(11,0) = data16_1.range(11,0);
tmpData(23,12) = data16_2.range(11,0);
tmpData(31,24) = 0;
dataBuff.unData = (uint32_t)tmpData;
VSync.x = dataBuff.fdata;
VSync.Sync = 0b00;
conpute3DStream.write(VSync);
//6th: frmY
data16_1 = framwInfo.T;
data16_2 = 0;
tmpData(11,0) = data16_1.range(11,0);
tmpData(23,12) = data16_2.range(11,0);
tmpData(31,24) = 0;
dataBuff.unData = (uint32_t)tmpData;
VSync.x = dataBuff.fdata;
VSync.Sync = 0b00;
conpute3DStream.write(VSync);
//output data
for(int i = 0; i < winNum; i ++)
{
RgnSubPixCalib a_line = subpixCalibData[i];
a_line.rsv = 0;
conpute3DStream.write(a_line);
}
return;
}
void convertSubpixCalibStreamToArray(
hls::stream<Pnt3D>& streamData,
std::vector<Pnt3D>& 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
Pnt3D VSync = streamData.read();
UintFloat tmp;
tmp.fdata = VSync.x;
*FrmNo = (uint32_t)tmp.unData;
//2nd:timeStamp
VSync = streamData.read();
tmp.fdata = VSync.x;
*timeStamp = (uint32_t)tmp.unData;
//3rd:encInfo
VSync = streamData.read();
tmp.fdata = VSync.x;
*encInfo = (uint32_t)tmp.unData;
//4th:frmW(12bit), frmH(12bit)
VSync = streamData.read();
tmp.fdata = VSync.x;
*frameROI_w = tmp.unData & 0xfff;
*frameROI_h = (tmp.unData >> 12) & 0xfff;
//5th: frmX, WinNum
VSync = streamData.read();
tmp.fdata = VSync.x;
*frameROI_x = tmp.unData & 0xfff;
uint16_t winNum = (tmp.unData >> 12) & 0xfff;
//6th: frmY
VSync = streamData.read();
tmp.fdata = VSync.x;
*frameROI_y = tmp.unData & 0xfff;
//output data
for(int i = 0; i < winNum; i ++)
{
Pnt3D data_in = streamData.read();
Pnt3D a_pnt;
a_pnt.x = data_in.x;
a_pnt.y = data_in.y;
a_pnt.z = data_in.z;
a_pnt.value = (ap_uint<8>)data_in.value;
a_pnt.Sync = data_in.Sync;
arrayData.push_back(a_pnt);
}
return;
}
void writeCompute3DData(
const char* fileName,
std::vector<Pnt3D>& outData)
{
std::ofstream sw(fileName);
int i_max = outData.size();
for (int i = 0; i < i_max; i++)
{
char data[250];
uint8_t value = (uint8_t)outData[i].value;
uint8_t sync = (uint8_t)outData[i].Sync;
#if defined(__linux__)
sprintf(data, "%.3f %.3f %.3f %02d %01x",
outData[i].x, outData[i].y, outData[i].z, value, sync);
#else
sprintf_s(data, "%.3f %.3f %.3f %02d %01x",
outData[i].x, outData[i].y, outData[i].z, value, sync);
#endif
sw << data << std::endl;
}
sw.close();
}
#define TST_GROUP 3
int main()
{
#if defined(__linux__)
const char* SrcDataPath[TST_GROUP] = {
"/home/zengHQ/CamTestData/testSample/PickRgn_C/PickRgn_Rslt/Txt/",
"/home/zengHQ/CamTestData/Grp_0/PickRgn_C/PickRgn_Rslt/Txt/",
"/home/zengHQ/CamTestData/Grp_1/PickRgn_C/PickRgn_Rslt/Txt/"
};
const char* InDataPath[TST_GROUP] = {
"/home/zengHQ/CamTestData/testSample/Calib/",
"/home/zengHQ/CamTestData/Grp_0/Calib/",
"/home/zengHQ/CamTestData/Grp_1/Calib/",
};
const char* OutDataPath[TST_GROUP] = {
"/home/zengHQ/CamTestData/testSample/Compute3D/",
"/home/zengHQ/CamTestData/Grp_0/Compute3D/",
"/home/zengHQ/CamTestData/Grp_1/Compute3D/",
};
#else
const char* SrcDataPath[TST_GROUP] = {
"F:/zengHQ/CamTestData/testSample/PickRgn_C/PickRgn_Rslt/Txt/",
"F:/zengHQ/CamTestData/Grp_0/PickRgn_C/PickRgn_Rslt/Txt/",
"F:/zengHQ/CamTestData/Grp_1/PickRgn_C/PickRgn_Rslt/Txt/"
};
const char* InDataPath[TST_GROUP] = {
"F:/zengHQ/CamTestData/testSample/Calib/",
"F:/zengHQ/CamTestData/Grp_0/Calib/",
"F:/zengHQ/CamTestData/Grp_1/Calib/",
};
const char* OutDataPath[TST_GROUP] = {
"F:/zengHQ/CamTestData/testSample/Compute3D/",
"F:/zengHQ/CamTestData/Grp_0/Compute3D/",
"F/zengHQ/CamTestData/Grp_1/Compute3D/",
};
#endif
int testFileSize[TST_GROUP] = {1, 4, 4};
for(int n = 1; n < TST_GROUP; n ++)
{
int winSize = 0;
int fileSize = testFileSize[n];
for(int fi = 0; fi < fileSize; fi++)
{
char fileName[200];
char paraFileName[200];
char outFileName[200];
#if defined(__linux__)
sprintf(fileName, "%s%d_L_calib.txt", InDataPath[n], fi);
sprintf(paraFileName, "%s%d_para_verilog.txt", SrcDataPath[n], fi);
sprintf(outFileName, "%s%d_L_compute3d.txt", OutDataPath[n], fi);
#else
sprintf_s(fileName, "%s%d_L_calib.txt", InDataPath[n], fi);
sprintf_s(paraFileName, "%s%d_para_verilog.txt", SrcDataPath[n], fi);
sprintf_s(outFileName, "%s%d_L_compute3d.txt", OutDataPath[n], fi);
#endif
Luma_frameInfo framwInfo = readParaFile(paraFileName);
std::vector<RgnSubPixCalib> testData = readSubpixCalibDataFile(fileName);
//gen test stream
hls::stream<RgnSubPixCalib> inStream;
genCompute3DTestSream(testData, inStream, framwInfo);
float u0 = 630;
float v0 = 960;
float F_inv = 0.0009933051235;
float plane_a = -2.0;
float plane_b = 0.0501805;
float plane_c = 631.944;
hls::stream<Pnt3D> outStream;
compute3D(inStream, outStream, u0, v0, F_inv, plane_a, plane_b, plane_c );
//output
std::vector<Pnt3D> outData;
uint32_t outFrmNo, outTimeStamp, outEncInfo;
uint16_t outROI_w,outROI_h, outROI_x,outROI_y;
convertSubpixCalibStreamToArray(
outStream,
outData,
&outFrmNo,
&outTimeStamp,
&outEncInfo,
&outROI_w,
&outROI_h,
&outROI_x,
&outROI_y);
writeCompute3DData(outFileName, outData);
}
}
printf("done!\n");
}

21
convolve/sourceCode/convolve.cpp
View File

@ -5,8 +5,13 @@ void convolve(
hls::stream<RgnPix> &InRgnPnt,
hls::stream<RgnPixConvolve> &OutConvolvePnt)
{
#if !(VITIS_HLS)
#pragma HLS DATA_PACK variable=InRgnPnt
#pragma HLS DATA_PACK variable=OutConvolvePnt
#else
#pragma HLS aggregate variable=InRgnPnt compact=bit
#pragma HLS aggregate variable=OutConvolvePnt compact=bit
#endif
#pragma HLS INTERFACE axis register both port=OutConvolvePnt
#pragma HLS INTERFACE axis register both port=InRgnPnt
@ -17,8 +22,7 @@ void convolve(
ap_uint<12> WinNum = 0;
RgnPix InData;
InData = InRgnPnt.read();
ap_uint<1> VSync = InData.Sync.range(1,1);
if(0b0 == VSync) //wait for syncFirst
if(0b10 != InData.Sync) //wait for syncFirst
return;
RgnPixConvolve outData = {0,0,0,0,0,0, 0, 0, 0};
@ -80,14 +84,23 @@ void convolve(
int nD2 = 0;
RgnPix HSyncData_d1 = {0,0,0,0,0,0,0};
ap_uint<8> peakValue = 0;
for(int n = 0; n < WinNum; n ++)
ap_uint<1> lastData = false;
for(int n = 0; n <= WinNum; n ++)
{
#pragma HLS LOOP_TRIPCOUNT min=3072 max=3072
if(1 == lastData) //frmae done
break;
for(int i = 0; i <= 8; i ++)
{
#pragma HLS PIPELINE II=1
RgnPix InData = InRgnPnt.read();
if(0b11 == InData.Sync)
{
lastData = 1;
break;
}
if(0 == i) //HSync
{
//compute pre-line subpix; output
@ -132,7 +145,7 @@ void convolve(
if(WinNum > 0)
{
RgnPixConvolve a_pnt;
a_pnt.Sync = 0b00;
a_pnt.Sync = 0b11;
a_pnt.LazerWinX = HSyncData_d1.LazerWinX;
a_pnt.LazerWinY = HSyncData_d1.LazerWinY;
a_pnt.LazerWinRid = HSyncData_d1.LazerWinRid;

2
convolve/sourceCode/convolve.h
View File

@ -2,7 +2,7 @@
#ifndef CONVOLVE_H
#define CONVOLVE_H
#include "..\..\globals\algoGlobals.h"
#include "../../globals/algoGlobals.h"
const int mask_1st[16] =
{

202
convolve/sourceCode/convolve_tb.cpp
View File

@ -2,10 +2,53 @@
#include <fstream>
#include <cstring>
#include <stdio.h>
#include "ap_utils.h"
//#include "ap_utils.h"
#include <iostream>
#include "convolve.h"
#include "..\..\globals\tbGlobals.h"
#include "../../globals/tbGlobals.h"
Luma_frameInfo readParaFile(const char* file)
{
std::ifstream inputFile(file);
Luma_frameInfo frameInfo;
std::string strLineTxt;
int data;
getline(inputFile, strLineTxt); //XL
sscanf(strLineTxt.c_str(), "XL:%d", &data);
frameInfo.L = (uint16_t)data;
getline(inputFile, strLineTxt); //XR
getline(inputFile, strLineTxt); //TL
sscanf(strLineTxt.c_str(), "TL:%d", &data);
frameInfo.T = (uint16_t)data;
getline(inputFile, strLineTxt); //TR
getline(inputFile, strLineTxt); //W
sscanf(strLineTxt.c_str(), "W:%d", &data);
frameInfo.W = (uint16_t)data;
getline(inputFile, strLineTxt); //H
sscanf(strLineTxt.c_str(), "H:%d", &data);
frameInfo.H = (uint16_t)data;
getline(inputFile, strLineTxt); //FrmNO
sscanf(strLineTxt.c_str(), "FrmNO:%x", &data);
frameInfo.FrmNo = (uint32_t)data;
getline(inputFile, strLineTxt); //TimStp
sscanf(strLineTxt.c_str(), "TimStp:%x", &data);
frameInfo.TimeStamp = (uint32_t)data;
getline(inputFile, strLineTxt); //EncInfo
sscanf(strLineTxt.c_str(), "EncInfo:%x", &data);
frameInfo.encInfo = (uint32_t)data;
inputFile.close();
return frameInfo;
}
std::vector<Luma_rgnData> readTestFile(
const char* file,
@ -60,32 +103,26 @@ std::vector<Luma_rgnData> readTestFile(
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)
const Luma_frameInfo FrmInfo)
{
RgnPix VSync = {0,0,0,0,0,0,0};
ap_uint<32> data_32;
//1st:FrmNo
data_32 = FrmNo;
data_32 = FrmInfo.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;
data_32 = FrmInfo.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;
data_32 = FrmInfo.encInfo;
VSync.Sync = 0b00;
VSync.LazerWinX(11,0) = data_32.range(11,0);
VSync.LazerWinY(11,0) = data_32.range(23,12);
@ -93,28 +130,28 @@ void genTestSream(
inStream.write(VSync);
//4th:frmW(12bit), frmH(12bit)
ap_uint<16> data16_1, data16_2;
data16_1 = frameROI_w;
data16_2 = frameROI_h;
data16_1 = FrmInfo.W;
data16_2 = FrmInfo.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;
int winNum = (int)srcData.size() + 12;
data16_1 = FrmInfo.L;
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;
data16_1 = FrmInfo.T;
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 ++)
for(int i = 0, i_max= (int)srcData.size(); i < i_max; i ++)
{
Luma_rgnData* a_line = &srcData[i];
RgnPix Hsync;
@ -138,6 +175,16 @@ void genTestSream(
inStream.write(a_data);
}
}
//add Last sync data
VSync.LazerWinFlag = 0;
VSync.LazerWinRid = 0;
VSync.LazerWinRsv = 0;
VSync.LazerWinX = 0;
VSync.LazerWinY = 0;
VSync.RltvRdx = 0;
VSync.Sync = 0b11;
inStream.write(VSync);
return;
}
@ -201,6 +248,8 @@ void convertConvolveStreamToArray(
a_pnt.nD1 = data_in.nD1;
a_pnt.nD2 = data_in.nD2;
arrayData.push_back(a_pnt);
if(data_in.Sync == 0b11)
break;
}
return;
}
@ -214,61 +263,114 @@ void writeConvolveData(
for (int i = 0; i < i_max; i++)
{
char data[250];
#if defined(__linux__)
sprintf(data, "%04x %04x %04x %01x %02x",
outData[i].WinRdx, outData[i].y, outData[i].Rid, outData[i].Flag, outData[i].pkValue);
#else
sprintf_s(data, "%04x %04x %04x %01x %02x",
outData[i].WinRdx, outData[i].y, outData[i].Rid, outData[i].Flag, outData[i].pkValue);
#endif
sw << data << std::endl;
#if defined(__linux__)
sprintf(data, "%d",outData[i].nD1);
#else
sprintf_s(data, "%d",outData[i].nD1);
#endif
sw << data << std::endl;
#if defined(__linux__)
sprintf(data, "%d",outData[i].nD2);
#else
sprintf_s(data, "%d",outData[i].nD2);
#endif
sw << data << std::endl;
}
sw.close();
}
#define TST_GROUP 1
#define TST_GROUP 3
int main()
{
#if defined(__linux__)
const char* SrcDataPath[TST_GROUP] = {
"/home/zengHQ/CamTestData/testSample/PickRgn_C/PickRgn_Rslt/Txt/",
"/home/zengHQ/CamTestData/Grp_0/PickRgn_C/PickRgn_Rslt/Txt/",
"/home/zengHQ/CamTestData/Grp_1/PickRgn_C/PickRgn_Rslt/Txt/"
};
const char* InDataPath[TST_GROUP] = {
"E:\\CamTestData\\PkCentering\\testSample\\testData.txt"
"/home/zengHQ/CamTestData/testSample/PkCentering/",
"/home/zengHQ/CamTestData/Grp_0/PkCentering/",
"/home/zengHQ/CamTestData/Grp_1/PkCentering/",
};
const char* OutDataPath[TST_GROUP] = {
"E:\\CamTestData\\Convolve\\testSample\\testData.txt"
"/home/zengHQ/CamTestData/testSample/Convolve/",
"/home/zengHQ/CamTestData/Grp_0/Convolve/",
"/home/zengHQ/CamTestData/Grp_1/Convolve/",
};
#else
const char* SrcDataPath[TST_GROUP] = {
"F:/zengHQ/CamTestData/testSample/PickRgn_C/PickRgn_Rslt/Txt/",
"F:/zengHQ/CamTestData/Grp_0/PickRgn_C/PickRgn_Rslt/Txt/",
"F:/zengHQ/CamTestData/Grp_1/PickRgn_C/PickRgn_Rslt/Txt/"
};
const char* InDataPath[TST_GROUP] = {
"F:/zengHQ/CamTestData/testSample/PkCentering/",
"F:/zengHQ/CamTestData/Grp_0/PkCentering/",
"F:/zengHQ/CamTestData/Grp_1/PkCentering/",
};
const char* OutDataPath[TST_GROUP] = {
"F:/zengHQ/CamTestData/testSample/Convolve/",
"F:/zengHQ/CamTestData/Grp_0/Convolve/",
"F:/zengHQ/CamTestData/Grp_1/Convolve/",
};
#endif
int testFileSize[TST_GROUP] = {1, 4, 4};
for(int n = 0; n < TST_GROUP; n ++)
for(int n = 1; 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);
int fileSize = testFileSize[n];
for(int fi = 0; fi < fileSize; fi++)
{
char fileName[200];
char paraFileName[200];
char outFileName[200];
#if defined(__linux__)
sprintf(fileName, "%s%d_L_pkCenter.txt", InDataPath[n], fi);
sprintf(paraFileName, "%s%d_para_verilog.txt", SrcDataPath[n], fi);
sprintf(outFileName, "%s%d_L_convolve.txt", OutDataPath[n], fi);
#else
sprintf_s(fileName, "%s%d_L_pkCenter.txt", InDataPath[n], fi);
sprintf_s(paraFileName, "%s%d_para_verilog.txt", SrcDataPath[n], fi);
sprintf_s(outFileName, "%s%d_L_convolve.txt", OutDataPath[n], fi);
#endif
hls::stream<RgnPixConvolve> OutConvolvePnt;
convolve( inStream, OutConvolvePnt );
std::vector<Luma_rgnData> testData = readTestFile(fileName, &winSize);
Luma_frameInfo framwInfo = readParaFile(paraFileName);
std::vector<Luma_convolveData> outData;
uint32_t outFrmNo, outTimeStamp, outEncInfo;
uint16_t outROI_w,outROI_h, outROI_x,outROI_y;
convertConvolveStreamToArray(
OutConvolvePnt,
outData,
&outFrmNo,
&outTimeStamp,
&outEncInfo,
&outROI_w,
&outROI_h,
&outROI_x,
&outROI_y);
//gen test stream
hls::stream<RgnPix> inStream;
genTestSream(testData, inStream, framwInfo);
writeConvolveData(OutDataPath[n], outData);
hls::stream<RgnPixConvolve> OutConvolvePnt;
convolve( inStream, OutConvolvePnt );
std::vector<Luma_convolveData> outData;
uint32_t outFrmNo, outTimeStamp, outEncInfo;
uint16_t outROI_w,outROI_h, outROI_x,outROI_y;
convertConvolveStreamToArray(
OutConvolvePnt,
outData,
&outFrmNo,
&outTimeStamp,
&outEncInfo,
&outROI_w,
&outROI_h,
&outROI_x,
&outROI_y);
writeConvolveData(outFileName, outData);
}
}
printf("done!\n");
}

4
globals/algoGlobals.h
View File

@ -5,6 +5,8 @@
#include "ap_int.h"
#include "hls_stream.h"
#define VITIS_HLS 1
#define RGN_DATA_WIN_SIZE 16
#define RGN_DATA_PIXEL_WIDTH 2 //output 2 pixels per clock
#define MAX_PT_NUM 4096
@ -95,7 +97,7 @@ union Byte8
//SubpixInfo subpix;
unsigned int nData[2];
float fData[2];
double dData;;
double dData;
};
struct CalibData
{

25
globals/tbGlobals.h
View File

@ -2,7 +2,7 @@
#ifndef TB_GLOBALS_H
#define TB_GLOBALS_H
#include "..\globals\algoGlobals.h"
#include "../globals/algoGlobals.h"
#include <vector>
#include <cmath>
#include <algorithm>
@ -10,6 +10,17 @@
#include <iostream>
#include <fstream>
typedef struct
{
uint16_t L;
uint16_t T;
uint16_t W;
uint16_t H;
uint32_t FrmNo;
uint32_t TimeStamp;
uint32_t encInfo;
}Luma_frameInfo;
typedef struct
{
uint16_t WinRdx;//窗口在图像内的起始坐标
@ -39,8 +50,20 @@ typedef struct
uint16_t Rid; //region的ID
uint8_t Flag; //bit0是overlap标志。bit1是反光信号标
uint8_t pkValue;
uint8_t Sync;
}Luma_rgnSubpix;
typedef struct
{
float x;
float y; //y坐标
uint16_t Rid; //region的ID
uint8_t Flag; //bit0是overlap标志。bit1是反光信号标
uint8_t pkValue;
uint8_t sync;
}Luma_rgnSubpixCalib;
#pragma pack(push, 1)
typedef struct {
uint16_t file_type; // 文件类型，'BM'

165
peakCentering/sourceCode/peakCentering.cpp
View File

@ -6,8 +6,13 @@ void peakCentering(
hls::stream<RgnPix> &OutCenteringPnt
)
{
#if !(VITIS_HLS)
#pragma HLS DATA_PACK variable=OutCenteringPnt
#pragma HLS DATA_PACK variable=InRgnPnt
#else
#pragma HLS aggregate variable=OutCenteringPnt compact=bit
#pragma HLS aggregate variable=InRgnPnt compact=bit
#endif
#pragma HLS INTERFACE axis register both port=OutCenteringPnt
#pragma HLS INTERFACE axis register both port=InRgnPnt
@ -18,8 +23,7 @@ void peakCentering(
ap_uint<12> WinNum = 0;
RgnPix InData;
InData = InRgnPnt.read();
ap_uint<1> VSync = InData.Sync.range(1,1);
if(0b0 == VSync) //wait for syncFirst
if(0b10 != InData.Sync) //wait for syncFirst
return;
//1st: frameNo
@ -53,10 +57,20 @@ void peakCentering(
RgnPix zeroData = {0,0,0,0,0,0,0};
//ping-pong buffer
RgnPix HSyncData_d1 = {0,0,0,0,0,0,0};
ap_uint<12> LazerWinX_d1 = 0;
ap_uint<8> lineBuff_0[RGN_DATA_WIN_SIZE * 2];
#if VITIS_HLS
#pragma HLS BIND_STORAGE variable=lineBuff_0 type=RAM_2p
#else
//#pragma HLS RESOURCE variable=lineBuff_0 core=RAM_2P
#endif
ap_uint<8> lineBuff_1[RGN_DATA_WIN_SIZE * 2];
#if VITIS_HLS
#pragma HLS BIND_STORAGE variable=lineBuff_0 type=RAM_2p
#else
//#pragma HLS RESOURCE variable=lineBuff_1 core=RAM_2P
#endif
//initialize buffer
for(int m = 0; m < RGN_DATA_WIN_SIZE * 2; m ++)
@ -74,6 +88,8 @@ void peakCentering(
ap_uint<2> SM = 0b00;
ap_uint<1> evenFlag = 0;
ap_uint<5> pkRng_S, pkRng_E;
ap_uint<1> outFlag = 0;
ap_uint<1> lastSync = 0;
for(int n = 0; n <= WinNum; n ++)
{
#pragma HLS LOOP_TRIPCOUNT min=3072 max=3072
@ -82,25 +98,46 @@ void peakCentering(
#pragma HLS PIPELINE II=1
RgnPix InData;
if(n < WinNum)
if(0 == lastSync)
InData = InRgnPnt.read();
else
InData = zeroData;
if(InData.Sync == 0b11)
lastSync = 1;
if(InData.LazerWinY == 510)
int kkk = 1; //debug point
if(0 == i) //HSync
{
if ((n > 0) &&( linePk.len>0))
evenFlag = n%2;
if(0 == linePk.len)
{
if(linePk.value >= 240)
pkCenter = RGN_DATA_WIN_SIZE;
else
pkCenter = 0;
}
else
pkCenter = linePk.start + (linePk.len >> 1);
HSyncData_d1.LazerWinX = LazerWinX_d1 + pkCenter;
if ((n > 0) && ( pkCenter > 0))
{
OutCenteringPnt.write(HSyncData_d1);
outFlag = 1;
}
else
outFlag = 0;
HSyncData_d1 = InData;
LazerWinX_d1 = InData.LazerWinX - RGN_DATA_WIN_SIZE;
pkRng_S = InData.RltvRdx.range(3,0) + RGN_DATA_WIN_SIZE/2;
pkRng_E = InData.RltvRdx.range(7,4) + RGN_DATA_WIN_SIZE/2;
evenFlag = n%2;
if(0 == linePk.len)
pkCenter = RGN_DATA_WIN_SIZE/2;
else
pkCenter = linePk.start + (linePk.len >> 1);
linePk.start = 0;
linePk.len = 0;
linePk.value = 0;
@ -113,6 +150,7 @@ void peakCentering(
else//for(int i = 0; i < 8; i ++)
{
ap_uint<8> wrPos_0 = i * 2 - 2 + RGN_DATA_WIN_SIZE/2;
ap_uint<8> lastPos = wrPos_0 -1;
ap_uint<8> wrPos_1 = i * 2 - 1 + RGN_DATA_WIN_SIZE/2;
ap_uint<8> rdPos_0 = pkCenter - RGN_DATA_WIN_SIZE/2 + i* 2 -2;
ap_uint<8> rdPos_1 = pkCenter - RGN_DATA_WIN_SIZE/2 + i* 2 -1;
@ -147,9 +185,89 @@ void peakCentering(
currPeak.len = 1;
currPeak.value = data_1;
SM = 0b01;
linePk.value = data_1; //record initial value
}
else if(data_0 > data_1) //falling
{
SM = 0b10;
currPeak.value = data_0;
linePk.value = data_0; //record initial value
}
else
{
currPeak.start = wrPos_0;
currPeak.len = 2;
currPeak.value = data_0;
SM = 0b11;
linePk.value = data_0; //record initial value
}
break;
case 0b11: //horizontal state
if(lastData < data_0) //rising
{
if(data_0 < data_1) //rising - rising. if i==8, data_1 is invalid peak,
{
currPeak.start = wrPos_1;
currPeak.len = 1;
currPeak.value = data_1;
SM = 0b01;
}
else if(data_0 > data_1) //rising - falling, data_0 is peak
{
if( (wrPos_0 >= pkRng_S) && (wrPos_0 <= pkRng_E) )
{
linePk.start = wrPos_0;
linePk.len = 1;
linePk.value = data_0;
}
SM = 0b10;
}
else //data_0 == data_1, if i==8, data_0 and data_1 is invalid peak,
{
currPeak.start = wrPos_0;
currPeak.len = 2;
currPeak.value = data_0;
SM = 0b01;
}
}
else if(lastData > data_0) //falling
{
if((currPeak.start >= pkRng_S) && (lastPos <= pkRng_E))
linePk = currPeak;
if(data_0 < data_1) //falling - rising, peak is at lastData (pos:0,1,2...), invalid
{
currPeak.start = wrPos_1;
currPeak.len = 1;
currPeak.value = data_1;
SM = 0b01;
}
else// if(data_0 >= data_1)//falling, peak is at lastData
SM = 0b10;
}
else //lastData == data_0
{
if(data_0 < data_1) //rising
{
currPeak.start = wrPos_1;
currPeak.len = 1;
currPeak.value = data_1;
SM = 0b01;
}
else if(data_0 > data_1) //falling
{
if( (currPeak.start >= pkRng_S) && (wrPos_0 >= pkRng_S))
{
linePk.start = currPeak.start;
linePk.len = currPeak.len + 1;
linePk.value = currPeak.value;
}
SM = 0b10;
}
else
currPeak.len += 2;
}
break;
case 0b01: //rising
if(lastData < data_0)
@ -160,7 +278,7 @@ void peakCentering(
currPeak.len = 1;
currPeak.value = data_1;
}
else if(data_0 > data_1) //change to falling
else if(data_0 > data_1) //change to falling, compare with exist
{
if( (wrPos_0 >= pkRng_S) && (wrPos_0 <= pkRng_E) && (data_0 >linePk.value ))
{
@ -176,12 +294,11 @@ void peakCentering(
currPeak.len = 2;
currPeak.value = data_0;
}
}
else if(lastData > data_0)
{
//compare with exist
if( (preCenter >= pkRng_S) && (preCenter <= pkRng_E) && (currPeak.value > linePk.value))
if( (currPeak.start >= pkRng_S) && (lastPos <= pkRng_E) && (currPeak.value > linePk.value))
{
linePk = currPeak;
}
@ -204,7 +321,7 @@ void peakCentering(
}
else if(data_0 > data_1)
{
if( (preCenter_1 >= pkRng_S) && (preCenter_1 <= pkRng_E) && (currPeak.value > linePk.value))
if( (currPeak.start >= pkRng_S) && (wrPos_0 <= pkRng_E) && (currPeak.value > linePk.value))
{
linePk.start = currPeak.start;
linePk.value = currPeak.value;
@ -213,7 +330,16 @@ void peakCentering(
SM = 0b10; //change to falling
}
else //data_0 == dta_1
{
currPeak.len += 2;
if(i == 8) //last one
{
if( (currPeak.start >= pkRng_S) && (wrPos_1 <= pkRng_E) && (currPeak.value > linePk.value))
{
linePk = currPeak;
}
}
}
}
break;
case 0b10: //falling
@ -265,12 +391,21 @@ void peakCentering(
stmOut.Sync = 0b00;
stmOut.LazerWinX(7,0) = out_0;
stmOut.LazerWinY(7,0) = out_1;
if( (n > 0 ) && (pkCenter > 0) )
if( outFlag == 1)
{
OutCenteringPnt.write(stmOut);
}
}
}
}
//add Last sync data
RgnPix VSync;
VSync.LazerWinFlag = 0;
VSync.LazerWinRid = 0;
VSync.LazerWinRsv = 0;
VSync.LazerWinX = 0;
VSync.LazerWinY = 0;
VSync.RltvRdx = 0;
VSync.Sync = 0b11;
OutCenteringPnt.write(VSync);
}

2
peakCentering/sourceCode/peakCentering.h
View File

@ -2,7 +2,7 @@
#ifndef PEAK_CENTERING_H
#define PEAK_CENTERING_H
#include "..\..\globals\algoGlobals.h"
#include "../../globals/algoGlobals.h"
void peakCentering(
hls::stream<RgnPix> &InRgnPnt,

216
peakCentering/sourceCode/peakCentering_tb.cpp
View File

@ -2,29 +2,33 @@
#include <fstream>
#include <cstring>
#include <stdio.h>
#include "ap_utils.h"
//#include "ap_utils.h"
#include <iostream>
#include "peakCentering.h"
#include "..\..\globals\tbGlobals.h"
#include "../../globals/tbGlobals.h"
void save_bmp_2(
const char* filename,
std::vector<Luma_rgnData>& testSamples)
{
FILE* file;
#if defined(__linux__)
file = fopen(filename, "wb");
#else
fopen_s(&file, filename, "wb");
#endif
if (!file) {
printf("无法打开文件 %s\n", filename);
printf("閿熺潾鍑ゆ嫹閿熸枻鎷烽敓渚ョ》鎷<EFBFBD> %s\n", filename);
return;
}
// 计算每行填充字节数
int bytes_per_row = RGN_DATA_WIN_SIZE * 3; // 每个像素3字节（BGR）
// 閿熸枻鎷烽敓鏂ゆ嫹姣忛敓鏂ゆ嫹閿熸枻鎷烽敓鏂ゆ嫹绾搁敓鏂ゆ嫹閿燂拷
int bytes_per_row = RGN_DATA_WIN_SIZE * 3; // 姣忛敓鏂ゆ嫹閿熸枻鎷烽敓鏂ゆ嫹3閿熻鑺傦綇鎷稡GR閿熸枻鎷<EFBFBD>
int padding = (4 - (bytes_per_row % 4)) % 4;
int row_size = bytes_per_row + padding;
int height = testSamples.size();
// 初始化文件头
// 閿熸枻鎷峰閿熸枻鎷烽敓渚ョ》鎷峰ご
BMPFileHeader file_header = {
.file_type = 0x4D42, // 'BM'
.file_size = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader) + row_size * height,
@ -32,11 +36,11 @@ void save_bmp_2(
.reserved2 = 0,
.offset_data = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader)
};
// 初始化信息头
// 閿熸枻鎷峰閿熸枻鎷烽敓鏂ゆ嫹鎭ご
BMPInfoHeader info_header = {
.size = sizeof(BMPInfoHeader),
.width = RGN_DATA_WIN_SIZE,
.height = height, // 正数表示像素数据从下到上排列
.height = height, // 閿熸枻鎷烽敓鏂ゆ嫹閿熸枻鎷风ず閿熸枻鎷烽敓鏂ゆ嫹閿熸枻鎷烽敓鎹疯揪鎷烽敓閾扮鎷烽敓鏂ゆ嫹閿熸枻鎷烽敓鏂ゆ嫹
.planes = 1,
.bit_count = 24,
.compression = 0,
@ -47,26 +51,68 @@ void save_bmp_2(
.colors_important = 0
};
// 写入头信息
// 鍐欓敓鏂ゆ嫹澶撮敓鏂ゆ嫹鎭<EFBFBD>
fwrite(&file_header, 1, sizeof(BMPFileHeader), file);
fwrite(&info_header, 1, sizeof(BMPInfoHeader), file);
// 写入像素数据（从最后一行开始）
// 鍐欓敓鏂ゆ嫹閿熸枻鎷烽敓鏂ゆ嫹閿熸枻鎷烽敓鎹凤綇鎷烽敓鏂ゆ嫹閿熸枻鎷烽敓鎻紮鎷烽攲閿熺粸纭锋嫹閿燂拷
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];
// 将RGB转为BGR顺序
// 閿熸枻鎷稲GB杞负BGR椤洪敓鏂ゆ嫹
fputc(pixel, file); // B
fputc(pixel, file); // G
fputc(pixel, file); // R
}
fwrite(padding_bytes, 1, padding, file); // 填充
fwrite(padding_bytes, 1, padding, file); // 閿熸枻鎷烽敓锟<EFBFBD>
}
fclose(file);
}
Luma_frameInfo readParaFile(const char* file)
{
std::ifstream inputFile(file);
Luma_frameInfo frameInfo;
std::string strLineTxt;
int data;
getline(inputFile, strLineTxt); //XL
sscanf(strLineTxt.c_str(), "XL:%d", &data);
frameInfo.L = (uint16_t)data;
getline(inputFile, strLineTxt); //XR
getline(inputFile, strLineTxt); //TL
sscanf(strLineTxt.c_str(), "TL:%d", &data);
frameInfo.T = (uint16_t)data;
getline(inputFile, strLineTxt); //TR
getline(inputFile, strLineTxt); //W
sscanf(strLineTxt.c_str(), "W:%d", &data);
frameInfo.W = (uint16_t)data;
getline(inputFile, strLineTxt); //H
sscanf(strLineTxt.c_str(), "H:%d", &data);
frameInfo.H = (uint16_t)data;
getline(inputFile, strLineTxt); //FrmNO
sscanf(strLineTxt.c_str(), "FrmNO:%x", &data);
frameInfo.FrmNo = (uint32_t)data;
getline(inputFile, strLineTxt); //TimStp
sscanf(strLineTxt.c_str(), "TimStp:%x", &data);
frameInfo.TimeStamp = (uint32_t)data;
getline(inputFile, strLineTxt); //EncInfo
sscanf(strLineTxt.c_str(), "EncInfo:%x", &data);
frameInfo.encInfo = (uint32_t)data;
inputFile.close();
return frameInfo;
}
std::vector<Luma_rgnData> readTestFile(
const char* file,
@ -121,32 +167,26 @@ std::vector<Luma_rgnData> readTestFile(
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)
const Luma_frameInfo frameInfo)
{
RgnPix VSync = {0,0,0,0,0,0,0};
ap_uint<32> data_32;
//1st:FrmNo
data_32 = FrmNo;
data_32 = frameInfo.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;
data_32 = frameInfo.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;
data_32 = frameInfo.encInfo;
VSync.Sync = 0b00;
VSync.LazerWinX(11,0) = data_32.range(11,0);
VSync.LazerWinY(11,0) = data_32.range(23,12);
@ -154,22 +194,22 @@ void genTestSream(
inStream.write(VSync);
//4th:frmW(12bit), frmH(12bit)
ap_uint<16> data16_1, data16_2;
data16_1 = frameROI_w;
data16_2 = frameROI_h;
data16_1 = frameInfo.W;
data16_2 = frameInfo.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_1 = frameInfo.L;
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;
data16_1 = frameInfo.T;
VSync.Sync = 0b00;
VSync.LazerWinX(11,0) = data16_1.range(11,0);
VSync.LazerWinY(11,0) = 0;
@ -199,6 +239,15 @@ void genTestSream(
inStream.write(a_data);
}
}
//add Last sync data
VSync.LazerWinFlag = 0;
VSync.LazerWinRid = 0;
VSync.LazerWinRsv = 0;
VSync.LazerWinX = 0;
VSync.LazerWinY = 0;
VSync.RltvRdx = 0;
VSync.Sync = 0b11;
inStream.write(VSync);
return;
}
@ -250,15 +299,20 @@ void convertStreamToArray(
data16_1(11,0) = VSync.LazerWinX.range(11,0);
*frameROI_y = data16_1;
//output data
for(int i = 0; i < winNum; i ++)
for(int i = 0; i <= winNum; i ++)
{
RgnPix Hsync = streamData.read();
if(Hsync.Sync != 0b01)
if(Hsync.Sync == 0b11)
break;
else if(Hsync.Sync != 0b01)
continue;
Luma_rgnData a_line;
a_line.WinRdx = (uint16_t)Hsync.LazerWinX;
a_line.y = (uint16_t)Hsync.LazerWinY;
if(a_line.y >= 1963)
int kkk = 1; //debug point
a_line.Rid = (uint16_t)Hsync.LazerWinRid;
a_line.Flag = (uint8_t)Hsync.LazerWinFlag;
a_line.PeakRltvRdx = (uint8_t)Hsync.RltvRdx;
@ -282,68 +336,112 @@ void writepeakCenteringData(
{
std::ofstream sw(fileName);
char str[250];
#if defined(__linux__)
sprintf(str, "0x10");
#else
sprintf_s(str, "0x10");
#endif
sw << str << std::endl;
int i_max = outData.size();
for (int i = 0; i < i_max; i++)
{
char data[250];
#if defined(__linux__)
sprintf(data, "%04x %04x %04x %01x %02x",
outData[i].WinRdx, outData[i].y, outData[i].Rid, outData[i].Flag, outData[i].PeakRltvRdx);
#else
sprintf_s(data, "%04x %04x %04x %01x %02x",
outData[i].WinRdx, outData[i].y, outData[i].Rid, outData[i].Flag, outData[i].PeakRltvRdx);
#endif
sw << data << std::endl;
for (int j = 0; j < RGN_DATA_WIN_SIZE; j++)
{
#if defined(__linux__)
sprintf(data, "%02x", outData[i].data[j]);
#else
sprintf_s(data, "%02x", outData[i].data[j]);
#endif
sw << data << std::endl;
}
}
sw.close();
}
#define TST_GROUP 1
#define TST_GROUP 3
int main()
{
#if defined(__linux__)
const char* InDataPath[TST_GROUP] = {
"E:\\CamTestData\\RgnPixData\\testSample\\testData.txt"
"/home/zengHQ/CamTestData/testSample/PickRgn_C/PickRgn_Rslt/Txt/",
"/home/zengHQ/CamTestData/Grp_0/PickRgn_C/PickRgn_Rslt/Txt/",
"/home/zengHQ/CamTestData/Grp_1/PickRgn_C/PickRgn_Rslt/Txt/"
};
const char* OutDataPath[TST_GROUP] = {
"E:\\CamTestData\\PkCentering\\testSample\\testData.txt"
"/home/zengHQ/CamTestData/testSample/PkCentering/",
"/home/zengHQ/CamTestData/Grp_0/PkCentering/",
"/home/zengHQ/CamTestData/Grp_1/PkCentering/",
};
#else
const char* InDataPath[TST_GROUP] = {
"F:/zengHQ/CamTestData/testSample/PickRgn_C/PickRgn_Rslt/Txt/",
"F:/zengHQ/CamTestData/Grp_0/PickRgn_C/PickRgn_Rslt/Txt/",
"F:/zengHQ/CamTestData/Grp_1/PickRgn_C/PickRgn_Rslt/Txt/"
};
const char* OutDataPath[TST_GROUP] = {
"F:/zengHQ/CamTestData/testSample/PkCentering/",
"F:/zengHQ/CamTestData/Grp_0/PkCentering/",
"F:/zengHQ/CamTestData/Grp_1/PkCentering/",
};
#endif
int testFileSize[TST_GROUP] = {1, 4, 4};
for(int n = 0; n < TST_GROUP; n ++)
for(int n = 1; 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);
int fileSize = testFileSize[n];
for(int fi = 0; fi < fileSize; fi++)
{
char fileName[200];
char paraFileName[200];
char outFileName[200];
#if defined(__linux__)
sprintf(fileName, "%s%d_L_verilog.txt", InDataPath[n], fi);
sprintf(paraFileName, "%s%d_para_verilog.txt", InDataPath[n], fi);
sprintf(outFileName, "%s%d_L_pkCenter.txt", OutDataPath[n], fi);
#else
sprintf_s(fileName, "%s%d_L_verilog.txt", InDataPath[n], fi);
sprintf_s(paraFileName, "%s%d_para_verilog.txt", InDataPath[n], fi);
sprintf_s(outFileName, "%s%d_L_pkCenter.txt", OutDataPath[n], fi);
#endif
std::vector<Luma_rgnData> testData = readTestFile(fileName, &winSize);
Luma_frameInfo framwInfo = readParaFile(paraFileName);
//gen test stream
hls::stream<RgnPix> inStream;
genTestSream(testData, inStream, framwInfo);
hls::stream<RgnPix> outStream;
peakCentering(inStream,outStream);
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);
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);
writepeakCenteringData(outFileName, outData);
}
}
printf("done!\n");
}

82
subPix/sourceCode/subPix.cpp
View File

@ -6,19 +6,26 @@ void subpix(
hls::stream<RgnSubPix> &OutSubpixPnt
)
{
#if !(VITIS_HLS)
#pragma HLS DATA_PACK variable=InConvolvePnt
#pragma HLS DATA_PACK variable=OutSubpixPnt
#else
#pragma HLS aggregate variable=InConvolvePnt compact=bit
#pragma HLS aggregate variable=OutSubpixPnt compact=bit
#endif
#pragma HLS INTERFACE axis register both port=OutSubpixPnt
#pragma HLS INTERFACE axis register both port=InConvolvePnt
ap_uint<12> WinNum = 0;
ap_uint<12> frmH = 0;
ap_uint<12> frmY = 0;
RgnPixConvolve InData;
InData = InConvolvePnt.read();
ap_uint<1> VSync = InData.Sync.range(1,1);
if(0b0 == VSync) //wait for syncFirst
if(0b10 != InData.Sync) //wait for syncFirst
return;
RgnSubPix outData = {0,0,0,0,0,0};
RgnSubPix nullOut = {-1.0f,0,0,0,0,0};
//1st: frameNo
outData.Sync = InData.Sync;
outData.rsv = 0;
@ -54,53 +61,84 @@ void subpix(
data_32(11,0) = InData.LazerWinX.range(11,0);
data_32(23,12) = InData.LazerWinY.range(11,0);
data_32(31,24) = 0;
frmH(11,0) = InData.LazerWinY.range(11,0);
tmp.unData = (unsigned int)data_32;
outData.x = tmp.fdata;
OutSubpixPnt.write(outData);
//5th: frmX, WinNum
int nLines = (int)frmH;
int nLoops = nLines; // * 2;
//if(nLoops >= 4096)
// nLoops = 4095;
ap_uint<12> outSize = (ap_uint<12>)nLoops;
InData = InConvolvePnt.read();
outData.Sync = InData.Sync;
data_32(11,0) = InData.LazerWinX.range(11,0);
data_32(23,12) = InData.LazerWinY.range(11,0);
data_32(23,12) = outSize.range(11,0); //InData.LazerWinY.range(11,0);
data_32(31,24) = 0;
tmp.unData = (unsigned int)data_32;
outData.x = tmp.fdata;
WinNum(11,0) = InData.LazerWinY.range(11,0);
OutSubpixPnt.write(outData);
//6th: frmY
//6th: frmY, validDataSize
InData = InConvolvePnt.read();
outData.Sync = InData.Sync;
data_32(11,0) = InData.LazerWinX.range(11,0);
data_32(23,12) = InData.LazerWinY.range(11,0);
data_32(23,12) = WinNum.range(11,0); //validDataSize
data_32(31,24) = 0;
frmY(11,0) = InData.LazerWinX.range(11,0);
tmp.unData = (unsigned int)data_32;
outData.x = tmp.fdata;
OutSubpixPnt.write(outData);
for(int n = 0; n < WinNum; n ++)
int nStart = (int)frmY;
ap_uint<12> lastLine = frmY + frmH - 1;
ap_uint<1> readFlag = 1;
InData = InConvolvePnt.read();
RgnPixConvolve currData;
int loopNum = nLoops * 2;
for(int n = 0; n < loopNum; n ++)
{
#pragma HLS LOOP_TRIPCOUNT min=3072 max=3072
#pragma HLS LOOP_TRIPCOUNT min=4096 max=4096
#pragma HLS PIPELINE II=1
InData = InConvolvePnt.read();
int lineIndx = n / 2 + nStart;
float fx;
if(InData.nD2 == 0)
fx = 0;
else
fx = (float)InData.nD1/(float)InData.nD2;
ap_uint<1> vldFlag = 0;
if( InData.LazerWinY <= lineIndx)
{
if(1 == readFlag)
{
currData = InData;
vldFlag = 1;
if(currData.Sync != 0b11)
InData = InConvolvePnt.read();
else
readFlag = 0;
}
}
RgnSubPix a_pnt;
if(n == 1)
a_pnt.Sync = 0b01;
if(vldFlag == 0)
{
a_pnt = nullOut;
}
else
a_pnt.Sync = 0b00;
a_pnt.flag = InData.LazerWinFlag;
a_pnt.y = InData.LazerWinY;
a_pnt.rid = InData.LazerWinRid;
a_pnt.value = InData.value;
a_pnt.x = (float)InData.LazerWinX + 8.0f + fx;
a_pnt.rsv = 0;
{
float fx;
if(currData.nD2 == 0)
fx = 0;
else
fx = (float)currData.nD1/(float)currData.nD2;
a_pnt.flag = currData.LazerWinFlag;
a_pnt.y = currData.LazerWinY;
a_pnt.rid = currData.LazerWinRid;
a_pnt.value = currData.value;
a_pnt.x = (float)currData.LazerWinX + 8.0f + fx + 0.5; //adjust point to pixel center
a_pnt.rsv = 0;
a_pnt.Sync = currData.Sync;
}
OutSubpixPnt.write(a_pnt);
}
}

2
subPix/sourceCode/subPix.h
View File

@ -2,7 +2,7 @@
#ifndef SUBPIX_H
#define SUBPIX_H
#include "..\..\globals\algoGlobals.h"
#include "../../globals/algoGlobals.h"
void subpix(
hls::stream<RgnPixConvolve> &InConvolvePnt,

192
subPix/sourceCode/subPix_tb.cpp
View File

@ -2,14 +2,56 @@
#include <fstream>
#include <cstring>
#include <stdio.h>
#include "ap_utils.h"
//#include "ap_utils.h"
#include <iostream>
#include "subPix.h"
#include "..\..\globals\tbGlobals.h"
#include "../../globals/tbGlobals.h"
Luma_frameInfo readParaFile(const char* file)
{
std::ifstream inputFile(file);
Luma_frameInfo frameInfo;
std::string strLineTxt;
int data;
getline(inputFile, strLineTxt); //XL
sscanf(strLineTxt.c_str(), "XL:%d", &data);
frameInfo.L = (uint16_t)data;
getline(inputFile, strLineTxt); //XR
getline(inputFile, strLineTxt); //TL
sscanf(strLineTxt.c_str(), "TL:%d", &data);
frameInfo.T = (uint16_t)data;
getline(inputFile, strLineTxt); //TR
getline(inputFile, strLineTxt); //W
sscanf(strLineTxt.c_str(), "W:%d", &data);
frameInfo.W = (uint16_t)data;
getline(inputFile, strLineTxt); //H
sscanf(strLineTxt.c_str(), "H:%d", &data);
frameInfo.H = (uint16_t)data;
getline(inputFile, strLineTxt); //FrmNO
sscanf(strLineTxt.c_str(), "FrmNO:%x", &data);
frameInfo.FrmNo = (uint32_t)data;
getline(inputFile, strLineTxt); //TimStp
sscanf(strLineTxt.c_str(), "TimStp:%x", &data);
frameInfo.TimeStamp = (uint32_t)data;
getline(inputFile, strLineTxt); //EncInfo
sscanf(strLineTxt.c_str(), "EncInfo:%x", &data);
frameInfo.encInfo = (uint32_t)data;
inputFile.close();
return frameInfo;
}
std::vector<Luma_convolveData> readConvolveDataFile(
const char* file)
{
const char* file){
std::ifstream inputFile(file);
std::string strLineTxt;
@ -60,32 +102,26 @@ std::vector<Luma_convolveData> readConvolveDataFile(
void genTestSream(
std::vector<Luma_convolveData>& convolveData,
hls::stream<RgnPixConvolve>& convolveStream,
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)
const Luma_frameInfo framwInfo)
{
RgnPixConvolve VSync = {0,0,0,0,0,0,0, 0, 0};
ap_uint<32> data_32;
//1st:FrmNo
data_32 = FrmNo;
data_32 = framwInfo.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);
convolveStream.write(VSync);
//2nd:FrmNo
data_32 = timeStamp;
data_32 = framwInfo.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);
convolveStream.write(VSync);
//3rd:encInfo
data_32 = encInfo;
data_32 = framwInfo.encInfo;
VSync.Sync = 0b00;
VSync.LazerWinX(11,0) = data_32.range(11,0);
VSync.LazerWinY(11,0) = data_32.range(23,12);
@ -93,28 +129,28 @@ void genTestSream(
convolveStream.write(VSync);
//4th:frmW(12bit), frmH(12bit)
ap_uint<16> data16_1, data16_2;
data16_1 = frameROI_w;
data16_2 = frameROI_h;
data16_1 = framwInfo.W;
data16_2 = framwInfo.H;
VSync.Sync = 0b00;
VSync.LazerWinX(11,0) = data16_1.range(11,0);
VSync.LazerWinY(11,0) = data16_2.range(11,0);
convolveStream.write(VSync);
//5th: frmX, WinNum
int winNum = (int)convolveData.size();
data16_1 = frameROI_x;
int winNum = (int)convolveData.size()+12;
data16_1 = framwInfo.L;
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);
convolveStream.write(VSync);
//6th: frmY
data16_1 = frameROI_y;
data16_1 = framwInfo.T;
VSync.Sync = 0b00;
VSync.LazerWinX(11,0) = data16_1.range(11,0);
VSync.LazerWinY(11,0) = 0;
convolveStream.write(VSync);
//output data
for(int i = 0; i < winNum; i ++)
for(int i = 0, i_max=(int)convolveData.size(); i < i_max; i ++)
{
Luma_convolveData* a_line = &convolveData[i];
RgnPixConvolve conData;
@ -126,6 +162,8 @@ void genTestSream(
conData.value = (ap_uint<8>)a_line->pkValue;
if(i == 0)
conData.Sync = 0b01;
else if(i == (i_max-1))
conData.Sync = 0b11;
else
conData.Sync = 0b00;
conData.nD1 = a_line->nD1;
@ -174,7 +212,7 @@ void convertSubpixStreamToArray(
tmp.fdata = VSync.x;
*frameROI_y = tmp.unData & 0xfff;
//output data
for(int i = 0; i < winNum; i ++)
for(int i = 0; i < winNum*2; i ++)
{
RgnSubPix data_in = streamData.read();
Luma_rgnSubpix a_pnt;
@ -183,6 +221,7 @@ void convertSubpixStreamToArray(
a_pnt.Rid = (uint16_t)data_in.rid;
a_pnt.Flag = (uint8_t)data_in.flag;
a_pnt.pkValue = (uint8_t)data_in.value;
a_pnt.Sync = (uint8_t)data_in.Sync;
arrayData.push_back(a_pnt);
}
return;
@ -197,57 +236,102 @@ void writeSubpixData(
for (int i = 0; i < i_max; i++)
{
char data[250];
sprintf_s(data, "%.2f %04d %04d %01x %02d",
outData[i].x, outData[i].y, outData[i].Rid, outData[i].Flag, outData[i].pkValue);
#if defined(__linux__)
sprintf(data, "%.2f %04d %04d %01x %02d %01x",
outData[i].x, outData[i].y, outData[i].Rid, outData[i].Flag, outData[i].pkValue, outData[i].Sync);
#else
sprintf_s(data, "%.2f %04d %04d %01x %02d %01x",
outData[i].x, outData[i].y, outData[i].Rid, outData[i].Flag, outData[i].pkValue, outData[i].Sync);
#endif
sw << data << std::endl;
}
sw.close();
}
#define TST_GROUP 1
#define TST_GROUP 3
int main()
{
#if defined(__linux__)
const char* SrcDataPath[TST_GROUP] = {
"/home/zengHQ/CamTestData/testSample/PickRgn_C/PickRgn_Rslt/Txt/",
"/home/zengHQ/CamTestData/Grp_0/PickRgn_C/PickRgn_Rslt/Txt/",
"/home/zengHQ/CamTestData/Grp_1/PickRgn_C/PickRgn_Rslt/Txt/"
};
const char* InDataPath[TST_GROUP] = {
"E:\\CamTestData\\Convolve\\testSample\\testData.txt"
"/home/zengHQ/CamTestData/testSample/Convolve/",
"/home/zengHQ/CamTestData/Grp_0/Convolve/",
"/home/zengHQ/CamTestData/Grp_1/Convolve/",
};
const char* OutDataPath[TST_GROUP] = {
"E:\\CamTestData\\Subpix\\testSample\\testData.txt"
"/home/zengHQ/CamTestData/testSample/Subpix/",
"/home/zengHQ/CamTestData/Grp_0/Subpix/",
"/home/zengHQ/CamTestData/Grp_1/Subpix/",
};
#else
const char* SrcDataPath[TST_GROUP] = {
"F:/zengHQ/CamTestData/testSample/PickRgn_C/PickRgn_Rslt/Txt/",
"F:/zengHQ/CamTestData/Grp_0/PickRgn_C/PickRgn_Rslt/Txt/",
"F:/zengHQ/CamTestData/Grp_1/PickRgn_C/PickRgn_Rslt/Txt/"
};
const char* InDataPath[TST_GROUP] = {
"F:/zengHQ/CamTestData/testSample/Convolve/",
"F:/zengHQ/CamTestData/Grp_0/Convolve/",
"F:/zengHQ/CamTestData/Grp_1/Convolve/",
};
const char* OutDataPath[TST_GROUP] = {
"F:/zengHQ/CamTestData/testSample/Subpix/",
"F:/zengHQ/CamTestData/Grp_0/Subpix/",
"F:/zengHQ/CamTestData/Grp_1/Subpix/",
};
#endif
int testFileSize[TST_GROUP] = {1, 4, 4};
for(int n = 0; n < TST_GROUP; n ++)
for(int n = 1; n < TST_GROUP; n ++)
{
int winSize = 0;
std::vector<Luma_convolveData> testData = readConvolveDataFile(InDataPath[n]);
//gen test stream
hls::stream<RgnPixConvolve> 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);
int fileSize = testFileSize[n];
for(int fi = 0; fi < fileSize; fi++)
{
char fileName[200];
char paraFileName[200];
char outFileName[200];
#if defined(__linux__)
sprintf(fileName, "%s%d_L_convolve.txt", InDataPath[n], fi);
sprintf(paraFileName, "%s%d_para_verilog.txt", SrcDataPath[n], fi);
sprintf(outFileName, "%s%d_L_subpix.txt", OutDataPath[n], fi);
#else
sprintf_s(fileName, "%s%d_L_convolve.txt", InDataPath[n], fi);
sprintf_s(paraFileName, "%s%d_para_verilog.txt", SrcDataPath[n], fi);
sprintf_s(outFileName, "%s%d_L_subpix.txt", OutDataPath[n], fi);
#endif
Luma_frameInfo framwInfo = readParaFile(paraFileName);
std::vector<Luma_convolveData> testData = readConvolveDataFile(fileName);
//gen test stream
hls::stream<RgnPixConvolve> inStream;
genTestSream(testData, inStream, framwInfo);
hls::stream<RgnSubPix> outStream;
subpix(inStream,outStream);
hls::stream<RgnSubPix> outStream;
subpix(inStream,outStream);
std::vector<Luma_rgnSubpix> outData;
uint32_t outFrmNo, outTimeStamp, outEncInfo;
uint16_t outROI_w,outROI_h, outROI_x,outROI_y;
convertSubpixStreamToArray(
outStream,
outData,
&outFrmNo,
&outTimeStamp,
&outEncInfo,
&outROI_w,
&outROI_h,
&outROI_x,
&outROI_y);
std::vector<Luma_rgnSubpix> outData;
uint32_t outFrmNo, outTimeStamp, outEncInfo;
uint16_t outROI_w,outROI_h, outROI_x,outROI_y;
convertSubpixStreamToArray(
outStream,
outData,
&outFrmNo,
&outTimeStamp,
&outEncInfo,
&outROI_w,
&outROI_h,
&outROI_x,
&outROI_y);
writeSubpixData(OutDataPath[n], outData);
writeSubpixData(outFileName, outData);
}
}
printf("done!\n");
}