275 lines
7.2 KiB
C++
275 lines
7.2 KiB
C++
|
|
#include <fstream>
|
|
#include <cstring>
|
|
#include <stdio.h>
|
|
#include "ap_utils.h"
|
|
#include <iostream>
|
|
#include "convolve.h"
|
|
#include "..\..\globals\tbGlobals.h"
|
|
|
|
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 convertConvolveStreamToArray(
|
|
hls::stream<RgnPixConvolve>& streamData,
|
|
std::vector<Luma_convolveData>& 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
|
|
RgnPixConvolve 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 = VSync.LazerWinX;
|
|
data16_2 = VSync.LazerWinY;
|
|
*frameROI_w = data16_1;
|
|
*frameROI_h = data16_2;
|
|
//5th: frmX, WinNum
|
|
VSync = streamData.read();
|
|
data16_1 = VSync.LazerWinX;
|
|
data16_2 = VSync.LazerWinY;
|
|
*frameROI_x = data16_1;
|
|
uint16_t winNum = (uint16_t)data16_2;
|
|
//6th: frmY
|
|
VSync = streamData.read();
|
|
data16_1 = VSync.LazerWinX;
|
|
*frameROI_y = data16_1;
|
|
//output data
|
|
for(int i = 0; i < winNum; i ++)
|
|
{
|
|
RgnPixConvolve data_in = streamData.read();
|
|
Luma_convolveData a_pnt;
|
|
a_pnt.WinRdx = (uint16_t)data_in.LazerWinX;
|
|
a_pnt.y = (uint16_t)data_in.LazerWinY;
|
|
a_pnt.Rid = (uint16_t)data_in.LazerWinRid;
|
|
a_pnt.Flag = (uint8_t)data_in.LazerWinFlag;
|
|
a_pnt.pkValue = (uint8_t)data_in.value;
|
|
a_pnt.nD1 = data_in.nD1;
|
|
a_pnt.nD2 = data_in.nD2;
|
|
arrayData.push_back(a_pnt);
|
|
}
|
|
return;
|
|
}
|
|
|
|
void writeConvolveData(
|
|
const char* fileName,
|
|
std::vector<Luma_convolveData>& outData)
|
|
{
|
|
std::ofstream sw(fileName);
|
|
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].pkValue);
|
|
sw << data << std::endl;
|
|
sprintf_s(data, "%d",outData[i].nD1);
|
|
sw << data << std::endl;
|
|
sprintf_s(data, "%d",outData[i].nD2);
|
|
sw << data << std::endl;
|
|
}
|
|
sw.close();
|
|
}
|
|
|
|
#define TST_GROUP 1
|
|
|
|
int main()
|
|
{
|
|
const char* InDataPath[TST_GROUP] = {
|
|
"E:\\CamTestData\\PkCentering\\testSample\\testData.txt"
|
|
};
|
|
const char* OutDataPath[TST_GROUP] = {
|
|
"E:\\CamTestData\\Convolve\\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<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(OutDataPath[n], outData);
|
|
}
|
|
|
|
}
|