jerryzeng
dec5589bdb
-compatible to VITIS_HLS -compatible to ubuntu24.04 -change test data directory
315 lines
7.8 KiB
C++
315 lines
7.8 KiB
C++
|
|
#include <fstream>
|
|
#include <cstring>
|
|
#include <stdio.h>
|
|
#include "ap_utils.h"
|
|
#include <iostream>
|
|
#include "calib.h"
|
|
#include "../../globals/tbGlobals.h"
|
|
|
|
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;
|
|
#if defined(__linux__)
|
|
sscanf(strLineTxt.c_str(), "%f %d %d %x %d", &x, &y, &Rid, &Flag, &pkValue);
|
|
#else
|
|
sscanf_s(strLineTxt.c_str(), "%f %d %d %x %d", &x, &y, &Rid, &Flag, &pkValue);
|
|
#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;
|
|
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 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 uint16_t validDataSize)
|
|
{
|
|
CalibData VSync;
|
|
Byte8 dataBuff;
|
|
//1st:FrmNo
|
|
dataBuff.nData[0] = 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] = timeStamp;
|
|
VSync.Sync = 0b00;
|
|
VSync.calibK[0] = dataBuff.dData;
|
|
VSync.calibK[1] = 0;
|
|
calibStream.write(VSync);
|
|
//3rd:encInfo
|
|
dataBuff.nData[0] = 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 = frameROI_w;
|
|
data16_2 = frameROI_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 = frameROI_x;
|
|
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 = frameROI_y;
|
|
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 ++)
|
|
{
|
|
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 = 0b01;
|
|
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 = 0b00;
|
|
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 ++)
|
|
{
|
|
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;
|
|
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",
|
|
outData[i].x, outData[i].y, outData[i].Rid, outData[i].Flag, outData[i].pkValue);
|
|
#else
|
|
sprintf_s(data, "%.2f %.2f %04d %01x %02d",
|
|
outData[i].x, outData[i].y, outData[i].Rid, outData[i].Flag, outData[i].pkValue);
|
|
#endif
|
|
sw << data << std::endl;
|
|
}
|
|
sw.close();
|
|
}
|
|
|
|
#define TST_GROUP 1
|
|
|
|
int main()
|
|
{
|
|
#if defined(__linux__)
|
|
const char* InDataPath[TST_GROUP] = {
|
|
"/home/zengHQ/CamTestData/testSample/Subpix/testData.txt"
|
|
};
|
|
const char* OutDataPath[TST_GROUP] = {
|
|
"/home/zengHQ/CamTestData/testSample/Calib/testData.txt"
|
|
};
|
|
#else
|
|
const char* InDataPath[TST_GROUP] = {
|
|
"E:/CamTestData/testSample/Subpix/testData.txt"
|
|
};
|
|
const char* OutDataPath[TST_GROUP] = {
|
|
"E:/CamTestData/testSample/Calib/testData.txt"
|
|
};
|
|
#endif
|
|
|
|
for(int n = 0; n < TST_GROUP; n ++)
|
|
{
|
|
int winSize = 0;
|
|
uint16_t vldSize = 0;
|
|
std::vector<RgnSubPix> testData = readSubpixDataFile(InDataPath[n], &vldSize);
|
|
//gen test stream
|
|
hls::stream<CalibData> 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;
|
|
genCalibTestSream(testData, inStream, FrmNo, timeStamp, encInfo, frameROI_w, frameROI_h, frameROI_x, frameROI_y, 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(OutDataPath[n], outData);
|
|
}
|
|
printf("done!\n");
|
|
}
|