diff --git a/Calib/sourceCode/Calib.cpp b/Calib/sourceCode/Calib.cpp index d90259c..6d21dea 100644 --- a/Calib/sourceCode/Calib.cpp +++ b/Calib/sourceCode/Calib.cpp @@ -6,20 +6,24 @@ void calib( hls::stream &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); + } } diff --git a/Calib/sourceCode/calib.h b/Calib/sourceCode/calib.h index 0c714f9..4d17b93 100644 --- a/Calib/sourceCode/calib.h +++ b/Calib/sourceCode/calib.h @@ -1,8 +1,8 @@ #ifndef COMPUTE_3D_H #define COMPUTE_3D_H - -#include "..\..\globals\algoGlobals.h" + +#include "../../globals/algoGlobals.h" void calib( hls::stream &inCalibData, diff --git a/Calib/sourceCode/calib_tb.cpp b/Calib/sourceCode/calib_tb.cpp index e69de29..2f4b8e2 100644 --- a/Calib/sourceCode/calib_tb.cpp +++ b/Calib/sourceCode/calib_tb.cpp @@ -0,0 +1,387 @@ + +#include +#include +#include +//#include "ap_utils.h" +#include +#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 readSubpixDataFile( + const char* file, + uint16_t* validSize) +{ + std::ifstream inputFile(file); + + std::string strLineTxt; + int size = 0; + std::vector 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& subpixData, + hls::stream& 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& streamData, + std::vector& 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& 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 testData = readSubpixDataFile(fileName, &vldSize); + //gen test stream + hls::stream inStream; + genCalibTestSream(testData, inStream, framwInfo, vldSize); + + hls::stream outStream; + calib(inStream,outStream); + + std::vector 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"); +} diff --git a/compute3D/sourceCode/compute3D.cpp b/compute3D/sourceCode/compute3D.cpp index ed932df..43faace 100644 --- a/compute3D/sourceCode/compute3D.cpp +++ b/compute3D/sourceCode/compute3D.cpp @@ -4,16 +4,21 @@ void compute3D( hls::stream &inSubCalib, hls::stream &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; } } diff --git a/compute3D/sourceCode/compute3D.h b/compute3D/sourceCode/compute3D.h index 53dad7f..014a233 100644 --- a/compute3D/sourceCode/compute3D.h +++ b/compute3D/sourceCode/compute3D.h @@ -2,17 +2,17 @@ #ifndef COMPUTE_3D_H #define COMPUTE_3D_H -#include "..\..\globals\algoGlobals.h" +#include "../../globals/algoGlobals.h" void compute3D( hls::stream &inSubCalib, hls::stream &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 diff --git a/compute3D/sourceCode/compute3D_tb.cpp b/compute3D/sourceCode/compute3D_tb.cpp index e69de29..c65b81c 100644 --- a/compute3D/sourceCode/compute3D_tb.cpp +++ b/compute3D/sourceCode/compute3D_tb.cpp @@ -0,0 +1,323 @@ + +#include +#include +#include +//#include "ap_utils.h" +#include +#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 readSubpixCalibDataFile( + const char* file) +{ + std::ifstream inputFile(file); + std::string strLineTxt; + int size = 0; + std::vector 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& subpixCalibData, + hls::stream& 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& streamData, + std::vector& 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& 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 testData = readSubpixCalibDataFile(fileName); + //gen test stream + hls::stream 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 outStream; + compute3D(inStream, outStream, u0, v0, F_inv, plane_a, plane_b, plane_c ); + + //output + std::vector 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"); +} diff --git a/convolve/sourceCode/convolve.cpp b/convolve/sourceCode/convolve.cpp index c26eb22..cf65f8d 100644 --- a/convolve/sourceCode/convolve.cpp +++ b/convolve/sourceCode/convolve.cpp @@ -5,8 +5,13 @@ void convolve( hls::stream &InRgnPnt, hls::stream &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; diff --git a/convolve/sourceCode/convolve.h b/convolve/sourceCode/convolve.h index 165831f..7672c8e 100644 --- a/convolve/sourceCode/convolve.h +++ b/convolve/sourceCode/convolve.h @@ -2,7 +2,7 @@ #ifndef CONVOLVE_H #define CONVOLVE_H -#include "..\..\globals\algoGlobals.h" +#include "../../globals/algoGlobals.h" const int mask_1st[16] = { diff --git a/convolve/sourceCode/convolve_tb.cpp b/convolve/sourceCode/convolve_tb.cpp index b17ff28..5f49b24 100644 --- a/convolve/sourceCode/convolve_tb.cpp +++ b/convolve/sourceCode/convolve_tb.cpp @@ -2,10 +2,53 @@ #include #include #include -#include "ap_utils.h" +//#include "ap_utils.h" #include #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 readTestFile( const char* file, @@ -60,32 +103,26 @@ std::vector readTestFile( void genTestSream( std::vector& srcData, hls::stream& 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 testData = readTestFile(InDataPath[n], &winSize); - //gen test stream - hls::stream 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 OutConvolvePnt; - convolve( inStream, OutConvolvePnt ); + std::vector testData = readTestFile(fileName, &winSize); + Luma_frameInfo framwInfo = readParaFile(paraFileName); - std::vector 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 inStream; + genTestSream(testData, inStream, framwInfo); - writeConvolveData(OutDataPath[n], outData); + hls::stream OutConvolvePnt; + convolve( inStream, OutConvolvePnt ); + + std::vector 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"); } diff --git a/globals/algoGlobals.h b/globals/algoGlobals.h index dce248e..ab21e72 100644 --- a/globals/algoGlobals.h +++ b/globals/algoGlobals.h @@ -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 { diff --git a/globals/tbGlobals.h b/globals/tbGlobals.h index fb0d4bc..3de4662 100644 --- a/globals/tbGlobals.h +++ b/globals/tbGlobals.h @@ -2,7 +2,7 @@ #ifndef TB_GLOBALS_H #define TB_GLOBALS_H -#include "..\globals\algoGlobals.h" +#include "../globals/algoGlobals.h" #include #include #include @@ -10,6 +10,17 @@ #include #include +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' diff --git a/peakCentering/sourceCode/peakCentering.cpp b/peakCentering/sourceCode/peakCentering.cpp index 4556bcd..a36c9fb 100644 --- a/peakCentering/sourceCode/peakCentering.cpp +++ b/peakCentering/sourceCode/peakCentering.cpp @@ -6,8 +6,13 @@ void peakCentering( hls::stream &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); } diff --git a/peakCentering/sourceCode/peakCentering.h b/peakCentering/sourceCode/peakCentering.h index 487ac9c..bd9b72a 100644 --- a/peakCentering/sourceCode/peakCentering.h +++ b/peakCentering/sourceCode/peakCentering.h @@ -2,7 +2,7 @@ #ifndef PEAK_CENTERING_H #define PEAK_CENTERING_H -#include "..\..\globals\algoGlobals.h" +#include "../../globals/algoGlobals.h" void peakCentering( hls::stream &InRgnPnt, diff --git a/peakCentering/sourceCode/peakCentering_tb.cpp b/peakCentering/sourceCode/peakCentering_tb.cpp index 49a7116..7782c58 100644 --- a/peakCentering/sourceCode/peakCentering_tb.cpp +++ b/peakCentering/sourceCode/peakCentering_tb.cpp @@ -2,29 +2,33 @@ #include #include #include -#include "ap_utils.h" +//#include "ap_utils.h" #include #include "peakCentering.h" -#include "..\..\globals\tbGlobals.h" +#include "../../globals/tbGlobals.h" void save_bmp_2( const char* filename, std::vector& testSamples) { FILE* file; +#if defined(__linux__) + file = fopen(filename, "wb"); +#else fopen_s(&file, filename, "wb"); +#endif if (!file) { - printf("无法打开文件 %s\n", filename); + printf("闁跨喓娼鹃崙銈嗗闁跨喐鏋婚幏鐑芥晸娓氥儳銆嬮幏锟 %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闁跨喐鏋婚幏锟 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 }; - // 写入头信息 + // 閸愭瑩鏁撻弬銈嗗婢舵挳鏁撻弬銈嗗閹拷 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顺序 + // 闁跨喐鏋婚幏绋睪B鏉烆兛璐烞GR妞ゆ椽鏁撻弬銈嗗 fputc(pixel, file); // B fputc(pixel, file); // G fputc(pixel, file); // R } - fwrite(padding_bytes, 1, padding, file); // 填充 + fwrite(padding_bytes, 1, padding, file); // 闁跨喐鏋婚幏鐑芥晸閿燂拷 } 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 readTestFile( const char* file, @@ -121,32 +167,26 @@ std::vector readTestFile( void genTestSream( std::vector& srcData, hls::stream& 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 testData = readTestFile(InDataPath[n], &winSize); - //gen test stream - hls::stream 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 testData = readTestFile(fileName, &winSize); + Luma_frameInfo framwInfo = readParaFile(paraFileName); + //gen test stream + hls::stream inStream; + genTestSream(testData, inStream, framwInfo); - hls::stream outStream; - peakCentering(inStream,outStream); + hls::stream outStream; + peakCentering(inStream,outStream); - std::vector 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 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"); } diff --git a/subPix/sourceCode/subPix.cpp b/subPix/sourceCode/subPix.cpp index 4a0056e..3c8cc1f 100644 --- a/subPix/sourceCode/subPix.cpp +++ b/subPix/sourceCode/subPix.cpp @@ -6,19 +6,26 @@ void subpix( hls::stream &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); } } diff --git a/subPix/sourceCode/subPix.h b/subPix/sourceCode/subPix.h index 885e940..174a0ba 100644 --- a/subPix/sourceCode/subPix.h +++ b/subPix/sourceCode/subPix.h @@ -2,7 +2,7 @@ #ifndef SUBPIX_H #define SUBPIX_H -#include "..\..\globals\algoGlobals.h" +#include "../../globals/algoGlobals.h" void subpix( hls::stream &InConvolvePnt, diff --git a/subPix/sourceCode/subPix_tb.cpp b/subPix/sourceCode/subPix_tb.cpp index 9214abd..3385701 100644 --- a/subPix/sourceCode/subPix_tb.cpp +++ b/subPix/sourceCode/subPix_tb.cpp @@ -2,14 +2,56 @@ #include #include #include -#include "ap_utils.h" +//#include "ap_utils.h" #include #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 readConvolveDataFile( - const char* file) -{ + const char* file){ std::ifstream inputFile(file); std::string strLineTxt; @@ -60,32 +102,26 @@ std::vector readConvolveDataFile( void genTestSream( std::vector& convolveData, hls::stream& 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 testData = readConvolveDataFile(InDataPath[n]); - //gen test stream - hls::stream 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 testData = readConvolveDataFile(fileName); + //gen test stream + hls::stream inStream; + genTestSream(testData, inStream, framwInfo); - hls::stream outStream; - subpix(inStream,outStream); + hls::stream outStream; + subpix(inStream,outStream); - std::vector 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 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"); }