camDev/peakCentering/sourceCode/peakCentering_tb.cpp

#include <fstream>
#include <cstring>
#include <stdio.h>
#include "ap_utils.h"
#include <iostream>
#include "peakCentering.h"
#include "../../globals/tbGlobals.h"

void save_bmp_2(
		const char* filename,
		std::vector<Luma_rgnData>& testSamples)
{
    FILE* file;
#if defined(__linux__)
    file = fopen(filename, "wb");
#else
    fopen_s(&file, filename, "wb");
#endif
    if (!file) {
        printf("閿熺潾鍑ゆ嫹閿熸枻鎷烽敓渚ョ》鎷<EFBFBD> %s\n", filename);
        return;
    }

    // 閿熸枻鎷烽敓鏂ゆ嫹姣忛敓鏂ゆ嫹閿熸枻鎷烽敓鏂ゆ嫹绾搁敓鏂ゆ嫹閿燂拷
    int bytes_per_row = RGN_DATA_WIN_SIZE * 3; // 姣忛敓鏂ゆ嫹閿熸枻鎷烽敓鏂ゆ嫹3閿熻鑺傦綇鎷稡GR閿熸枻鎷<E69EBB>
    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,
        .reserved1 = 0,
        .reserved2 = 0,
        .offset_data = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader)
    };
    // 閿熸枻鎷峰閿熸枻鎷烽敓鏂ゆ嫹鎭ご
    BMPInfoHeader info_header = {
        .size = sizeof(BMPInfoHeader),
        .width = RGN_DATA_WIN_SIZE,
        .height = height, // 閿熸枻鎷烽敓鏂ゆ嫹閿熸枻鎷风ず閿熸枻鎷烽敓鏂ゆ嫹閿熸枻鎷烽敓鎹疯揪鎷烽敓閾扮鎷烽敓鏂ゆ嫹閿熸枻鎷烽敓鏂ゆ嫹
        .planes = 1,
        .bit_count = 24,
        .compression = 0,
        .size_image = (uint32_t)(row_size * height),
        .x_pixels_per_meter = 0,
        .y_pixels_per_meter = 0,
        .colors_used = 0,
        .colors_important = 0
    };

    // 鍐欓敓鏂ゆ嫹澶撮敓鏂ゆ嫹鎭<E5ABB9>
    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];
            // 閿熸枻鎷稲GB杞负BGR椤洪敓鏂ゆ嫹
            fputc(pixel, file); // B
            fputc(pixel, file); // G
            fputc(pixel, file); // R
        }
        fwrite(padding_bytes, 1, padding, file); // 閿熸枻鎷烽敓锟<E69593>
    }

    fclose(file);
}

Luma_frameInfo readParaFile(const char* file)
{
	std::ifstream inputFile(file);
	Luma_frameInfo frameInfo;
	std::string strLineTxt;

	int data;
	getline(inputFile, strLineTxt);  //XL
	sscanf(strLineTxt.c_str(), "XL:%d", &data);
	frameInfo.L = (uint16_t)data;

	getline(inputFile, strLineTxt);  //XR

	getline(inputFile, strLineTxt);  //TL
	sscanf(strLineTxt.c_str(), "TL:%d", &data);
	frameInfo.T = (uint16_t)data;

	getline(inputFile, strLineTxt);  //TR

	getline(inputFile, strLineTxt);  //W
	sscanf(strLineTxt.c_str(), "W:%d", &data);
	frameInfo.W = (uint16_t)data;

	getline(inputFile, strLineTxt);  //H
	sscanf(strLineTxt.c_str(), "H:%d", &data);
	frameInfo.H = (uint16_t)data;

	getline(inputFile, strLineTxt);  //FrmNO
	sscanf(strLineTxt.c_str(), "FrmNO:%x", &data);
	frameInfo.FrmNo = (uint32_t)data;

	getline(inputFile, strLineTxt);  //TimStp
	sscanf(strLineTxt.c_str(), "TimStp:%x", &data);
	frameInfo.TimeStamp = (uint32_t)data;

	getline(inputFile, strLineTxt);  //EncInfo
	sscanf(strLineTxt.c_str(), "EncInfo:%x", &data);
	frameInfo.encInfo = (uint32_t)data;

	inputFile.close();
	return frameInfo;
}

std::vector<Luma_rgnData> readTestFile(
		const char* file,
		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 Luma_frameInfo frameInfo)
{
	RgnPix VSync = {0,0,0,0,0,0,0};
	ap_uint<32> data_32;
	//1st: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 = 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 = frameInfo.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 = 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 = 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 = frameInfo.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 ++)
	{
		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);
		}
	}
	//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;
}

void convertStreamToArray(
		hls::stream<RgnPix>& streamData,
		std::vector<Luma_rgnData>& arrayData,
		uint32_t* FrmNo,
		uint32_t* timeStamp,
		uint32_t* encInfo,
		uint16_t* frameROI_w,
		uint16_t* frameROI_h,
		uint16_t* frameROI_x,
		uint16_t* frameROI_y)
{
	//1st:FrmNo
	RgnPix VSync = streamData.read();
	ap_uint<32> data_32;
	data_32(11,0) = VSync.LazerWinX.range(11,0);
	data_32.range(23,12) = VSync.LazerWinY.range(11,0);
	data_32.range(31,24) = VSync.LazerWinRid.range(7,0);
	*FrmNo = (int)data_32;
	//2nd:timeStamp
	VSync = streamData.read();
	data_32(11,0) = VSync.LazerWinX.range(11,0);
	data_32.range(23,12) = VSync.LazerWinY.range(11,0);
	data_32.range(31,24) = VSync.LazerWinRid.range(7,0);
	*timeStamp = (int)data_32;
	//3rd:encInfo
	VSync = streamData.read();
	data_32(11,0) = VSync.LazerWinX.range(11,0);
	data_32.range(23,12) = VSync.LazerWinY.range(11,0);
	data_32.range(31,24) = VSync.LazerWinRid.range(7,0);
	*encInfo = (int)data_32;
	//4th:frmW(12bit), frmH(12bit)
	VSync = streamData.read();
	ap_uint<16> data16_1, data16_2;
	data16_1(11,0) = VSync.LazerWinX.range(11,0);
	data16_2(11,0) = VSync.LazerWinY.range(11,0);
	*frameROI_w = data16_1;
	*frameROI_h = data16_2;
	//5th: frmX, WinNum
	VSync = streamData.read();
	data16_1(11,0) = VSync.LazerWinX.range(11,0);
	data16_2(11,0) = VSync.LazerWinY.range(11,0);
	*frameROI_x = data16_1;
	uint16_t winNum = (uint16_t)data16_2;
	//6th: frmY
	VSync = streamData.read();
	data16_1(11,0) = VSync.LazerWinX.range(11,0);
	*frameROI_y = data16_1;
	//output data
	for(int i = 0; i <= winNum; i ++)
	{
		RgnPix Hsync = streamData.read();
		if(Hsync.Sync == 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;
		for(int j = 0; j < RGN_DATA_WIN_SIZE/2; j ++)
		{
			RgnPix a_data = streamData.read();
			ap_uint<8> data8_1, data8_2;
			data8_1(7,0) = a_data.LazerWinX.range(7,0);
			data8_2(7,0) = a_data.LazerWinY.range(7,0);
			a_line.data[j * 2] = (uint8_t)data8_1;
			a_line.data[j * 2 + 1] = (uint8_t)data8_2;
		}
		arrayData.push_back(a_line);
	}
	return;
}

void writepeakCenteringData(
		const char* fileName,
		std::vector<Luma_rgnData>& outData)
{
    std::ofstream sw(fileName);
    char str[250];
#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	3

int main()
{
#if defined(__linux__)
	const char* InDataPath[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* OutDataPath[TST_GROUP] = {
			"/home/zengHQ/CamTestData/testSample/PkCentering/",
			"/home/zengHQ/CamTestData/Grp_0/PkCentering/",
			"/home/zengHQ/CamTestData/Grp_1/PkCentering/",
	};
#else
	const char* InDataPath[TST_GROUP] = {
			"E:/CamTestData/testSample/PickRgn_C/PickRgn_Rslt/Txt/",
			"E:/CamTestData/Grp_0/PickRgn_C/PickRgn_Rslt/Txt/",
			"E:/CamTestData/Grp_1/PickRgn_C/PickRgn_Rslt/Txt/"
	};
	const char* OutDataPath[TST_GROUP] = {
			"E:/CamTestData/testSample/PkCentering/",
			"E:/CamTestData/Grp_0/PkCentering/",
			"E:/CamTestData/Grp_1/PkCentering/",
	};
#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_verilog.txt", InDataPath[n], fi);
			sprintf(paraFileName, "%s%d_para_verilog.txt", InDataPath[n], fi);
			sprintf(outFileName, "%s%d_L_pkCenter.txt", OutDataPath[n], fi);
#else
			sprintf_s(fileName, "%s%d_L_verilog.txt", InDataPath[n], fi);
			sprintf_s(paraFileName, "%s%d_para_verilog.txt", InDataPath[n], fi);
			sprintf_s(outFileName, "%s%d_L_pkCenter.txt", OutDataPath[n], fi);
#endif
			std::vector<Luma_rgnData> testData = readTestFile(fileName, &winSize);
			Luma_frameInfo framwInfo = readParaFile(paraFileName);
			//gen test stream
			hls::stream<RgnPix> inStream;
			genTestSream(testData, inStream, framwInfo);

			hls::stream<RgnPix> outStream;
			peakCentering(inStream,outStream);

			std::vector<Luma_rgnData> outData;
			uint32_t outFrmNo, outTimeStamp, outEncInfo;
			uint16_t outROI_w,outROI_h, outROI_x,outROI_y;
			convertStreamToArray(
					outStream,
					outData,
					&outFrmNo,
					&outTimeStamp,
					&outEncInfo,
					&outROI_w,
					&outROI_h,
					&outROI_x,
					&outROI_y);

			writepeakCenteringData(outFileName, outData);
		}
	}
	printf("done!\n");

}