This is a subgroup of Harris accelerated function with only testbench-related functions/classes/. More...

Collaboration diagram for Harris Testbench:

Files
file	harris_host_fwd_tb.cpp
	Testbench for Harris userspace application for cF (x86, ppc64).

file	xf_ocv_ref.hpp
	The Harris reference functions used in TB.

file	test_harris.cpp
	: Testbench for Harris.

Macros
#define	THIS_NAME "TB"

#define	TRACE_OFF 0x0000

#define	TRACE_URIF 1 << 1

#define	TRACE_UAF 1 << 2

#define	TRACE_MMIO 1 << 3

#define	TRACE_ALL 0xFFFF

#define	DEBUG_LEVEL (TRACE_ALL)

#define	OK true

#define	KO false

#define	VALID true

#define	UNVALID false

#define	DEBUG_TRACE true

#define	TB_TRIALS 2

#define	ENABLE_DDR_EMULATE_DELAY_IN_TB

#define	ENABLED (ap_uint<1>)1

#define	DISABLED (ap_uint<1>)0

Typedefs
typedef float	NMSTYPE

Functions
int	main (int argc, char *argv[])

bool	OCVFindMaximum2 (NMSTYPE t1, NMSTYPE t2, NMSTYPE m1, NMSTYPE b1, NMSTYPE *b2)

void	OCVMaxSuppression2 (cv::Mat &src, cv::Mat &dst)

bool	OCVFindMaximum1 (NMSTYPE t0, NMSTYPE t1, NMSTYPE t2, NMSTYPE m0, NMSTYPE m1, NMSTYPE m2, NMSTYPE b0, NMSTYPE b1, NMSTYPE b2)

void	OCVMaxSuppression1 (cv::Mat &src, cv::Mat &dst)

void	ocv_ref (cv::Mat img_gray, cv::Mat &ocv_out_img, float Th)

stream< UdpWord >	sSHL_Uaf_Data ("sSHL_Uaf_Data")

stream< UdpWord >	sUAF_Shl_Data ("sUAF_Shl_Data")

stream< UdpWord >	image_stream_from_harris ("image_stream_from_harris")

stream< NetworkMetaStream >	siUdp_meta ("siUdp_meta")

stream< NetworkMetaStream >	soUdp_meta ("soUdp_meta")

void	stepDut ()
	Run a single iteration of the DUT model. More...

int	main (int argc, char **argv)
	Main testbench of Hrris. More...

Variables
ap_uint< 1 >	piSHL_This_MmioPostPktEn

ap_uint< 1 >	piSHL_This_MmioCaptPktEn

ap_uint< 32 >	s_udp_rx_ports = 0x0

ap_uint< 32 >	node_rank

ap_uint< 32 >	cluster_size

int	simCnt

Detailed Description

This is a subgroup of Harris accelerated function with only testbench-related functions/classes/.

This is a subgroup of Harris accelerated function with only testbench-related functions/classes.

Macro Definition Documentation

◆ DEBUG_LEVEL

#define DEBUG_LEVEL (TRACE_ALL)

Definition at line 53 of file test_harris.cpp.

◆ DEBUG_TRACE

#define DEBUG_TRACE true

Definition at line 63 of file test_harris.cpp.

◆ DISABLED

#define DISABLED (ap_uint<1>)0

Definition at line 72 of file test_harris.cpp.

◆ ENABLE_DDR_EMULATE_DELAY_IN_TB

#define ENABLE_DDR_EMULATE_DELAY_IN_TB

Definition at line 69 of file test_harris.cpp.

◆ ENABLED

#define ENABLED (ap_uint<1>)1

Definition at line 71 of file test_harris.cpp.

◆ KO

#define KO false

Definition at line 60 of file test_harris.cpp.

◆ OK

#define OK true

Definition at line 59 of file test_harris.cpp.

◆ TB_TRIALS

#define TB_TRIALS 2

Definition at line 66 of file test_harris.cpp.

◆ THIS_NAME

#define THIS_NAME "TB"

Definition at line 45 of file test_harris.cpp.

◆ TRACE_ALL

#define TRACE_ALL 0xFFFF

Definition at line 51 of file test_harris.cpp.

◆ TRACE_MMIO

#define TRACE_MMIO 1 << 3

Definition at line 50 of file test_harris.cpp.

◆ TRACE_OFF

#define TRACE_OFF 0x0000

Definition at line 47 of file test_harris.cpp.

◆ TRACE_UAF

#define TRACE_UAF 1 << 2

Definition at line 49 of file test_harris.cpp.

◆ TRACE_URIF

#define TRACE_URIF 1 << 1

Definition at line 48 of file test_harris.cpp.

◆ UNVALID

#define UNVALID false

Definition at line 62 of file test_harris.cpp.

◆ VALID

#define VALID true

Definition at line 61 of file test_harris.cpp.

Typedef Documentation

◆ NMSTYPE

typedef float NMSTYPE

Definition at line 61 of file xf_ocv_ref.hpp.

Function Documentation

◆ image_stream_from_harris()

stream<UdpWord> image_stream_from_harris ( "image_stream_from_harris" )

◆ main() [1/2]

int main	(	int	argc,
		char **	argv
	)

Main testbench of Hrris.

Returns: 0 upon success, nrErr else.

hls_out_img.data = (unsigned char *)imgOutput.copyFrom();

Definition at line 157 of file test_harris.cpp.

                                 {
  
     //------------------------------------------------------
     //-- TESTBENCH LOCAL VARIABLES
     //------------------------------------------------------
     int nrErr;
     unsigned int tb_trials = 0;
  
     printf("#####################################################\n");
     printf("## MAIN TESTBENCH STARTS HERE                      ##\n");
     printf("#####################################################\n");
  
     
     //------------------------------------------------------
     //-- TESTBENCH LOCAL VARIABLES FOR HARRIS
     //------------------------------------------------------
     cv::Mat in_img, img_gray;
     cv::Mat hls_out_img, ocv_out_img;
  
     if (argc != 2) {
         printf("Usage : %s <input image> \n", argv[0]);
         return -1;
     }
     in_img = cv::imread(argv[1], 0); // reading in the color image
  
     if (!in_img.data) {
         printf("ERROR: Failed to load the image ... %s\n!", argv[1]);
         return -1;
     }
     else {
       printf("INFO: Succesfully loaded image ... %s\n", argv[1]);
       if (in_img.total() != FRAME_WIDTH * FRAME_HEIGHT) {
         printf("WARNING: Resizing input image %s from [%u x %u] to  [%u x %u] !\n", argv[1], in_img.rows, in_img.cols, FRAME_WIDTH, FRAME_HEIGHT);
         cv::resize(in_img, in_img, cv::Size(FRAME_WIDTH, FRAME_HEIGHT), 0, 0, cv::INTER_LINEAR);
       }
       // Ensure that the selection of MTU is a multiple of 8 (Bytes per transaction)
       assert(PACK_SIZE % 8 == 0);
     }
  
     #ifdef ENABLE_DDR
     memset(lcl_mem0,  0x0, sizeof(lcl_mem0));
     memset(lcl_mem1,  0x0, sizeof(lcl_mem1));
     
     DmCmd           dmCmd_MemCmdP0;
     DmSts           dmSts_MemWrStsP0;
     DmSts           dmSts_MemRdStsP0;
     Axis<MEMDW_512> memP0;
     ap_uint<64>     currentMemPattern = 0;
   
     unsigned int ddr_addr_in = 0x0;
     unsigned int ddr_write_req_iter = 0;
     unsigned int wait_cycles_to_ack_ddr_status = 0;
     unsigned int count_cycles_to_ack_ddr_status = 0;
     bool ddr_write_sts_req = false;
     #endif
     
     uint16_t Thresh; // Threshold for HLS
     float Th;
     if (FILTER_WIDTH == 3) {
         Th = 30532960.00;
         Thresh = 442;
     } else if (FILTER_WIDTH == 5) {
         Th = 902753878016.0;
         Thresh = 3109;
     } else if (FILTER_WIDTH == 7) {
         Th = 41151168289701888.000000;
         Thresh = 566;
     }
  
  
     //------------------------------------------------------
     //-- STEP-1.1 : CREATE MEMORY FOR OUTPUT IMAGES
     //------------------------------------------------------
     //  cvtColor(in_img, img_gray, CV_BGR2GRAY);
     // Convert rgb into grayscale
     hls_out_img.create(in_img.rows, in_img.cols, CV_8U); // create memory for hls output image
     ocv_out_img.create(in_img.rows, in_img.cols, CV_8U); // create memory for opencv output image
  
     #if NO
     static xf::cv::Mat<IN_TYPE, HEIGHT, WIDTH, XF_NPPC1> imgInput(in_img.rows, in_img.cols);
     static xf::cv::Mat<IN_TYPE, HEIGHT, WIDTH, XF_NPPC1> imgOutput(in_img.rows, in_img.cols);
     static xf::cv::Mat<IN_TYPE, HEIGHT, WIDTH, XF_NPPC1> imgOutputTb(in_img.rows, in_img.cols);
     imgInput.copyTo(in_img.data);
     //  imgInput = xf::cv::imread<IN_TYPE, HEIGHT, WIDTH, XF_NPPC1>(argv[1], 0);
     ap_uint<INPUT_PTR_WIDTH>  *imgInputArray    = (ap_uint<INPUT_PTR_WIDTH>*)  malloc(in_img.rows * in_img.cols * sizeof(ap_uint<INPUT_PTR_WIDTH>));
     ap_uint<OUTPUT_PTR_WIDTH> *imgOutputArrayTb = (ap_uint<OUTPUT_PTR_WIDTH>*) malloc(in_img.rows * in_img.cols * sizeof(ap_uint<OUTPUT_PTR_WIDTH>));
     ap_uint<OUTPUT_PTR_WIDTH> *imgOutputArray   = (ap_uint<OUTPUT_PTR_WIDTH>*) malloc(in_img.rows * in_img.cols * sizeof(ap_uint<OUTPUT_PTR_WIDTH>));
     xf::cv::xfMat2Array<INPUT_PTR_WIDTH, IN_TYPE, HEIGHT, WIDTH, NPIX>(imgInput, imgInputArray);
     #endif
  
     #if RO
     static xf::cv::Mat<IN_TYPE, HEIGHT, WIDTH, XF_NPPC8> imgInput(in_img.rows, in_img.cols);
     static xf::cv::Mat<IN_TYPE, HEIGHT, WIDTH, XF_NPPC8> imgOutput(in_img.rows, in_img.cols);
     static xf::cv::Mat<IN_TYPE, HEIGHT, WIDTH, XF_NPPC1> imgOutputTb(in_img.rows, in_img.cols);
     #endif
     
     while (tb_trials++ < TB_TRIALS) {
    
  
         printf ( "##################################################### \n" );
         printf ( "## TESTBENCH #%u STARTS HERE                        ##\n", tb_trials );
         printf ( "##################################################### \n" );
  
  
         simCnt = 0;
         nrErr  = 0;
  
 #if NO
         if ( !dumpImgToFile ( imgInput, "ifsSHL_Uaf_Data.dat", simCnt ) ) {
             nrErr++;
         }
 #endif
  
 #if RO
         // imgInput.copyTo(img_gray.data);
         imgInput = xf::cv::imread<IN_TYPE, HEIGHT, WIDTH, XF_NPPC8> ( argv[1], 0 );
 #endif
  
  
  
         //------------------------------------------------------
         //-- STEP-1.2 : RUN HARRIS DETECTOR FROM OpenCV LIBRARY
         //------------------------------------------------------
         ocv_ref ( in_img, ocv_out_img, Th );
  
  
  
         //------------------------------------------------------
         //-- STEP-2.1 : CREATE TRAFFIC AS INPUT STREAMS
         //------------------------------------------------------
         if ( nrErr == 0 ) {
             if ( !setInputDataStream ( sSHL_Uaf_Data, "sSHL_Uaf_Data", "ifsSHL_Uaf_Data.dat", simCnt ) ) {
                 printf ( "### ERROR : Failed to set input data stream \"sSHL_Uaf_Data\". \n" );
                 nrErr++;
             }
  
             //there are TOT_TRANSFERS streams from the the App to the Role
             NetworkMeta tmp_meta = NetworkMeta ( 1,DEFAULT_RX_PORT,0,DEFAULT_RX_PORT,0 );
             for ( int i=0; i<TOT_TRANSFERS; i++ ) {
                 siUdp_meta.write ( NetworkMetaStream ( tmp_meta ) );
             }
             //set correct node_rank and cluster_size
             node_rank = 1;
             cluster_size = 2;
         }
  
         //------------------------------------------------------
         //-- STEP-2.2 : SET THE PASS-THROUGH MODE
         //------------------------------------------------------
         //piSHL_This_MmioEchoCtrl.write(ECHO_PATH_THRU);
         //[TODO] piSHL_This_MmioPostPktEn.write(DISABLED);
         //[TODO] piSHL_This_MmioCaptPktEn.write(DISABLED);
  
         //------------------------------------------------------
         //-- STEP-3 : MAIN TRAFFIC LOOP
         //------------------------------------------------------
         while ( !nrErr ) {
  
             // Keep enough simulation time for sequntially executing the FSMs of the main 3 functions
             // (Rx-Proc-Tx)
             if ( simCnt < MIN_RX_LOOPS + MIN_RX_LOOPS + MIN_TX_LOOPS + 10
 #ifdef ENABLE_DDR
 #ifdef ENABLE_DDR_EMULATE_DELAY_IN_TB 
                 + (TYPICAL_DDR_LATENCY + EXTRA_DDR_LATENCY_DUE_II + DDR_LATENCY) * MEMORY_LINES_512
 #endif
 #endif
                ) {
                 stepDut();
  
                 if ( simCnt > 2 ) {
                     assert ( s_udp_rx_ports == PORTS_OPENED );
                 }
  
 if (simCnt < 0)
     exit(0);
 #ifdef ENABLE_DDR
  
                 if ( !sROL_Shl_Mem_WrCmdP0.empty() ) {
                     printf ( "DEBUG tb: Read a memory write command from SHELL/Mem/Mp0 \n" );
                     //-- Read a memory write command from SHELL/Mem/Mp0
                     sROL_Shl_Mem_WrCmdP0.read ( dmCmd_MemCmdP0 );
                     //assert ( dmCmd_MemCmdP0.bbt == CHECK_CHUNK_SIZE );
                     assert ( dmCmd_MemCmdP0.type == 1 && dmCmd_MemCmdP0.dsa == 0 && dmCmd_MemCmdP0.eof == 1 && dmCmd_MemCmdP0.drr == 1 && dmCmd_MemCmdP0.tag == 0x0 );
                     ddr_addr_in = (unsigned int)dmCmd_MemCmdP0.saddr / BPERMDW_512; // Convert the byte-aligned address to local mem of stack tb.
                     printf ( "DEBUG tb: Requesting writting to address %u (max depth = %u) an amount of %u bytes (%u memory lines), ddr_write_req_iter=%u\n", ddr_addr_in,  MEMORY_LINES_512-1, (unsigned int)dmCmd_MemCmdP0.bbt, (unsigned int)(1 + (dmCmd_MemCmdP0.bbt - 1) / BPERMDW_512), ddr_write_req_iter);
                     assert (ddr_addr_in <= MEMORY_LINES_512-1);
                     //ddr_write_req_iter++;
                     //printf ( "DEBUG tb: (ddr_write_req_iter)%(MEMORY_LINES_512-1)=%u\n", (ddr_write_req_iter)%(MEMORY_LINES_512-1));
                     if ((++ddr_write_req_iter)%(MEMORY_LINES_512) == 0) {
                         ddr_write_req_iter = 0;
                     }
                     printf ( "DEBUG tb: ddr_write_req_iter=%u\n", ddr_write_req_iter);
  
 #ifdef ENABLE_DDR_EMULATE_DELAY_IN_TB
                     /*
                      * 16                   ->  emulate a response in 16 cycles
                      * 1                    ->  emulate immediate response
                      * CYCLES_UNTIL_TIMEOUT ->  on purpose timeout
                      */ 
                     if (ddr_write_req_iter == 1) {
                         wait_cycles_to_ack_ddr_status = TYPICAL_DDR_LATENCY;
                     }
                     else if (ddr_write_req_iter == 2) {
                         wait_cycles_to_ack_ddr_status = TYPICAL_DDR_LATENCY;
                     }
                     else {
                         wait_cycles_to_ack_ddr_status = TYPICAL_DDR_LATENCY;
                     }
                     if (!sSHL_Rol_Mem_WrStsP0.empty()) {
                         printf("WARNING: Emptying sSHL_Rol_Mem_WrStsP0 fifo.\n");
                         dmSts_MemWrStsP0  = sSHL_Rol_Mem_WrStsP0.read();
                     }
 #else
                     wait_cycles_to_ack_ddr_status = 0;
 #endif
                     count_cycles_to_ack_ddr_status = 0;
                     ddr_write_sts_req = false;
                 }
  
                 if ( !sROL_Shl_Mem_WriteP0.empty() ) {
                     sROL_Shl_Mem_WriteP0.read ( memP0 );
                     printf ( "DEBUG tb: Write a memory line from SHELL/Mem/Mp0 \n" );
  
                     assert ( memP0.tkeep == 0xffffffffffffffff );
  
                     /* Read from AXI stream DDR interface and write to the memory mapped interface of
                      * DDR channel P0. In the real HW, this is enabled by the AXI interconnect and AXI
                      * Datamover, being instantiated in VHDL.
                      * */
                     printf ( "DEBUG tb: Writting to address 0x%x : %u an amount of %u bytes\n", ddr_addr_in, memP0.tdata.to_long(), BPERMDW_512);
                     //lcl_mem0[ddr_addr_in++] = memP0.tdata;
                     memcpy(&lcl_mem0[ddr_addr_in++], &memP0.tdata, BPERMDW_512);
                     ddr_write_sts_req = true;
                 }
                 // When we have emulated the writting to lcl_mem0, we acknowledge with a P0 status
                 if ((ddr_write_sts_req == true) && !sSHL_Rol_Mem_WrStsP0.full() && (memP0.tlast == true)) {
                     if (count_cycles_to_ack_ddr_status++ == wait_cycles_to_ack_ddr_status) {
                         dmSts_MemWrStsP0.tag = 7;
                         dmSts_MemWrStsP0.okay = 1;
                         dmSts_MemWrStsP0.interr = 0;
                         dmSts_MemWrStsP0.slverr = 0;
                         dmSts_MemWrStsP0.decerr = 0;
                         printf ( "DEBUG tb: Write a memory status command to SHELL/Mem/Mp0 \n" );
                             sSHL_Rol_Mem_WrStsP0.write ( dmSts_MemWrStsP0 );
                             ddr_write_sts_req = false;
                     }
                     else{
                         printf ( "DEBUG tb: Waiting to write a memory status command to SHELL/Mem/Mp0 [%u out of %u] cycles\n", count_cycles_to_ack_ddr_status, wait_cycles_to_ack_ddr_status);
                     }
                 }
  
  
  
 #endif // ENABLE_DDR
  
  
                 //if( !soUdp_meta.empty())
                 //{
                 //  NetworkMetaStream tmp_meta = soUdp_meta.read();
                 //  printf("NRC received NRCmeta stream from node_rank %d.\n", (int) tmp_meta.tdata.src_rank);
                 //}
  
  
             } else {
 #ifdef ENABLE_DDR
                 if (!sSHL_Rol_Mem_WrStsP0.empty()) {
                     printf("WARNING: Emptying sSHL_Rol_Mem_WrStsP0 fifo.\n");
                     dmSts_MemWrStsP0  = sSHL_Rol_Mem_WrStsP0.read();
                 }
 #endif
                 printf ( "## End of simulation at cycle=%3d. \n", simCnt );
                 break;
             }
  
         }  // End: while()
  
         //-------------------------------------------------------
         //-- STEP-4 : DRAIN AND WRITE OUTPUT FILE STREAMS
         //-------------------------------------------------------
         //---- UAF-->SHELL Data ----
         if ( !getOutputDataStream ( sUAF_Shl_Data, "sUAF_Shl_Data", "ofsUAF_Shl_Data.dat", simCnt ) ) {
             nrErr++;
         }
         //---- UAF-->SHELL META ----
         if ( !soUdp_meta.empty() ) {
             int i = 0;
             while ( !soUdp_meta.empty() ) {
                 i++;
                 NetworkMetaStream tmp_meta = soUdp_meta.read();
                 printf ( "NRC received NRCmeta stream from rank %d to rank %d.\n", ( int ) tmp_meta.tdata.src_rank, ( int ) tmp_meta.tdata.dst_rank );
                 assert ( tmp_meta.tdata.src_rank == node_rank );
                 //ensure forwarding behavior
                 assert ( tmp_meta.tdata.dst_rank == ( ( tmp_meta.tdata.src_rank + 1 ) % cluster_size ) );
             }
             //printf("DEBUG: i=%u\tTOT_TRANSFERS=%u\n", i, TOT_TRANSFERS);
             assert ( i == TOT_TRANSFERS );
         } else {
             printf ( "Error No metadata received...\n" );
             nrErr++;
         }
  
         //-------------------------------------------------------
         //-- STEP-5 : FROM THE OUTPUT FILE CREATE AN ARRAY
         //-------------------------------------------------------
         if ( !setInputFileToArray ( "ofsUAF_Shl_Data.dat", imgOutputArray, simCnt ) ) {
             printf ( "### ERROR : Failed to set input array from file \"ofsUAF_Shl_Data.dat\". \n" );
             nrErr++;
         }
         xf::cv::Array2xfMat<OUTPUT_PTR_WIDTH, OUT_TYPE, HEIGHT, WIDTH, NPIX> ( imgOutputArray, imgOutput );
  
  
         //------------------------------------------------------
         //-- STEP-6 : COMPARE INPUT AND OUTPUT FILE STREAMS
         //------------------------------------------------------
         int rc1 = system ( "diff --brief -w -i -y ../../../../test/ofsUAF_Shl_Data.dat \
                                             ../../../../test/verify_UAF_Shl_Data.dat" );
         if ( rc1 ) {
             printf ( "## Error : File \'ofsUAF_Shl_Data.dat\' does not match \'verify_UAF_Shl_Data.dat\'.\n" );
         } else {
             printf ( "Output data in file \'ofsUAF_Shl_Data.dat\' verified.\n" );
         }
  
         nrErr += rc1;
  
         printf ( "#####################################################\n" );
         if ( nrErr ) {
             printf ( "## ERROR - TESTBENCH #%u FAILED (RC=%d) !!!        ##\n", tb_trials, nrErr );
         } else {
             printf ( "## SUCCESSFULL END OF TESTBENCH #%u (RC=0)          ##\n", tb_trials );
         }
         printf ( "#####################################################\n" );
  
  
  
  
  
     } // End tb trials while loop
  
  
  
  
  
  
  
  
     float K = 0.04;
     uint16_t k = K * (1 << 16); // Convert to Q0.16 format
  
     #if NO
  
     // L2 Vitis Harris
     cornerHarrisAccelArray(imgInputArray, imgOutputArrayTb, in_img.rows, in_img.cols, Thresh, k);
     xf::cv::Array2xfMat<OUTPUT_PTR_WIDTH, OUT_TYPE, HEIGHT, WIDTH, NPIX>(imgOutputArrayTb, imgOutputTb);
         
     // L1 Vitis Harris 
     //harris_accel(imgInput, imgOutput, Thresh, k);
     
     #endif
  
     #if RO
  
     harris_accel(imgInput, imgOutputTb, Thresh, k);
  
     #endif
  
     xf::cv::imwrite("hls_out_tb.jpg", imgOutputTb);
     xf::cv::imwrite("hls_out.jpg", imgOutput);
  
     unsigned int val;
     unsigned short int row, col;
  
     cv::Mat out_img;
     out_img = in_img.clone();
  
     std::vector<cv::Point> hls_points;
     std::vector<cv::Point> ocv_points;
     std::vector<cv::Point> common_pts;
  
     xf::cv::Mat<OUT_TYPE, HEIGHT, WIDTH, NPIX>* select_imgOutput;
  
     // Select which output you want to process for image outputs and corners comparisons:
     // &imgOutput   : The processed image by Harris IP inside the ROLE (i.e. I/O traffic is passing through SHELL)
     // &imgOutputTb : The processed image by Harris IP in this testbench (i.e. I/O traffic is done in testbench)
     select_imgOutput = &imgOutput;
  
     // Mark HLS points on the image 
     markPointsOnImage(*select_imgOutput, in_img, out_img, hls_points);
  
     // Write HLS and Opencv corners into a file 
     //nrErr += 
     writeCornersIntoFile(in_img, ocv_out_img, out_img, hls_points, ocv_points, common_pts);
  
     // Clear memory
     free(imgOutputArrayTb);
     free(imgOutputArray);
     free(imgInputArray);
     
     
     return(nrErr);
 }

Here is the call graph for this function:

◆ main() [2/2]

int main	(	int	argc,
		char *	argv[]
	)

Main testbench for the user-application for Harris on host. Server

Returns: O on success, 1 on fail

Definition at line 45 of file harris_host_fwd_tb.cpp.

                                   {
  
     if ((argc < 2) || (argc > 3)) { // Test for correct number of parameters
         cerr << "Usage: " << argv[0] << " <Server Port> <optional simulation mode>" << endl;
         exit(1);
     }
  
     unsigned short servPort = atoi(argv[1]); // First arg:  local port
     unsigned int num_frame = 0;
     string clean_cmd;
  
 #ifdef SHOW_WINDOWS
     namedWindow("tb_recv", WINDOW_AUTOSIZE);
 #endif // SHOW_WINDOWS
  
     try {
         #if NET_TYPE == udp
         UDPSocket sock(servPort);
     #else
     TCPServerSocket servSock(servPort);     // Server Socket object
     TCPSocket *servsock = servSock.accept();     // Wait for a client to connect
     #endif
         char buffer[BUF_LEN]; // Buffer for echo string
         int recvMsgSize; // Size of received message
         string sourceAddress; // Address of datagram source
         
     #if NET_TYPE == tcp
     // TCP client handling
     cout << "Handling client ";
     try {
       cout << servsock->getForeignAddress() << ":";
     } catch (SocketException e) {
         cerr << "Unable to get foreign address" << endl;
       }
     try {
       cout << servsock->getForeignPort();
     } catch (SocketException e) {
         cerr << "Unable to get foreign port" << endl;
       }
     cout << endl;
     #endif
         
  
         // RX Step
         clock_t last_cycle_rx = clock();
         while (1) {
             // Block until receive message from a client
     
         int total_pack = 1 + (FRAME_TOTAL - 1) / PACK_SIZE;
             int bytes_in_last_pack = (FRAME_TOTAL) - (total_pack - 1) * PACK_SIZE;      
         int receiving_now = PACK_SIZE;
             cout << " ___________________________________________________________________ " << endl;
             cout << "/                                                                   \\" << endl;
         cout << "INFO: Proxy tb Frame # " << ++num_frame << endl;       
             cout << "INFO: Expecting length of packs:" << total_pack << endl;
             char * longbuf = new char[PACK_SIZE * total_pack];
         
         // RX Loop
             for (int i = 0; i < total_pack; i++) {
             if ( i == total_pack - 1 ) {
                     receiving_now = bytes_in_last_pack;
                 }
         #if NET_TYPE == udp
                 recvMsgSize = sock.recvFrom(buffer, BUF_LEN, sourceAddress, servPort);
         #else
         recvMsgSize = servsock->recv(buffer, receiving_now);
         #endif
                 if (recvMsgSize != receiving_now) {
                     cerr << "ERROR: Received unexpected size pack:" << recvMsgSize << endl;
                     continue;
                 }
                 memcpy( & longbuf[i * PACK_SIZE], buffer, receiving_now);
             }
  
             cout << "INFO: Received packet from " << sourceAddress << ":" << servPort << endl;
  
             cv::Mat frame = cv::Mat(FRAME_HEIGHT, FRAME_WIDTH, INPUT_TYPE_HOST, longbuf); // OR vec.data() instead of ptr
         if (frame.size().width == 0) {
                 cerr << "ERROR: receive failure!" << endl;
                 continue;
             }
 #ifdef SHOW_WINDOWS
             imshow("tb_recv", frame);
 #endif // SHOW_WINDOWS
  
         // We save the image received from network in order to process it with the harris HLS TB
         imwrite("../../../../../../ROLE/vision/hls/harris/test/input_from_udp_to_fpga.png", frame);
         
         // Select simulation mode, default fcsim
         string synth_cmd = " ";
         string exec_cmd = "make fcsim -j 4";
         string ouf_file = "../../../../../../ROLE/vision/hls/harris/harris_prj/solution1/fcsim/build/hls_out.jpg";
         if (argc == 3) {
           if (atoi(argv[2]) == 2) {
         exec_cmd = "make csim";
         ouf_file = "../../../../../../ROLE/vision/hls/harris/harris_prj/solution1/csim/build/hls_out.jpg";
           }
           else if (atoi(argv[2]) == 3) {
         synth_cmd = "make csynth && ";
         exec_cmd = "make cosim";
         ouf_file = "../../../../../../ROLE/vision/hls/harris/harris_prj/solution1/sim/wrapc_pc/hls_out.jpg";
           }
           else if (atoi(argv[2]) == 4) {
         exec_cmd = "make kcachegrind";
         ouf_file = "../../../../../../ROLE/vision/hls/harris/harris_prj/solution1/fcsim/build/hls_out.jpg";
           }
         }
         // Calling the actual TB over its typical makefile procedure, but passing the save file
         // Skip the rebuilding phase on the 2nd run. However ensure that it's a clean recompile
         // the first time.
         clean_cmd = " ";
         if (num_frame == 1) {
           clean_cmd = "make clean && ";
         }
         string str_command = "cd ../../../../../../ROLE/vision/hls/harris/ && " + clean_cmd + synth_cmd + "\
                   INPUT_IMAGE=./test/input_from_udp_to_fpga.png " + exec_cmd + " && \
                   cd ../../../../HOST/vision/harris/languages/cplusplus/build/ "; 
         const char *command = str_command.c_str(); 
         cout << "Calling TB with command:" << command << endl; 
         system(command); 
  
             free(longbuf);
  
         clock_t next_cycle_rx = clock();
             double duration_rx = (next_cycle_rx - last_cycle_rx) / (double) CLOCKS_PER_SEC;
             cout << "INFO: Effective FPS RX:" << (1 / duration_rx) << " \tkbps:" << (PACK_SIZE * 
                     total_pack / duration_rx / 1024 * 8) << endl;
             last_cycle_rx = next_cycle_rx;
     
  
         // TX step
         frame = cv::imread(ouf_file, cv::IMREAD_GRAYSCALE); // reading in the image in grey scale
         if (!frame.data) {
           cerr << "ERROR: Failed to load the image " << ouf_file << endl; 
           return -1;
         }
         else {
           cout << "INFO: Succesfully loaded image " << ouf_file << endl; 
         }
             
         assert(frame.total() == FRAME_WIDTH * FRAME_HEIGHT);
         
             imshow("tb_send", frame);
         
         // Ensure that the send Mat is in continuous memory space. Typically, imread or resize 
         // will return such a continuous Mat, but we should check it.
         assert(frame.isContinuous());
         
         // TX Loop
         unsigned int sending_now = PACK_SIZE;
         clock_t last_cycle_tx = clock();
             for (int i = 0; i < total_pack; i++) {
                 if ( i == total_pack - 1 ) {
                     sending_now = bytes_in_last_pack;
         }
         #if NET_TYPE == udp
         sock.sendTo( & frame.data[i * PACK_SIZE], sending_now, sourceAddress, servPort);
         #else
         //sock.send( & frame.data[i * PACK_SIZE], sending_now);
         servsock->send( & frame.data[i * PACK_SIZE], sending_now);
         #endif
         }
             
             clock_t next_cycle_tx = clock();
             double duration_tx = (next_cycle_tx - last_cycle_tx) / (double) CLOCKS_PER_SEC;
             cout << "INFO: Effective FPS TX:" << (1 / duration_tx) << " \tkbps:" << (PACK_SIZE * 
                     total_pack / duration_tx / 1024 * 8) << endl;
             last_cycle_tx = next_cycle_tx; 
             cout << "\\___________________________________________________________________/" << endl;
         break;} // while loop
         #if NET_TYPE == tcp
         delete servsock;
     #endif
     } catch (SocketException & e) {
         cerr << e.what() << endl;
         exit(1);
     }
     return 0;
 }

Here is the call graph for this function:

◆ ocv_ref()

void ocv_ref	(	cv::Mat	img_gray,
		cv::Mat &	ocv_out_img,
		float	Th
	)

Definition at line 577 of file xf_ocv_ref.hpp.

                                                            {
     cv::Mat gradx, grady;
     cv::Mat gradx2, grady2, gradxy;
     cv::Mat gradx2g, grady2g, gradxyg;
     cv::Mat x2y2, xy, mtrace;
     cv::Mat dst, ocvthresh_img;
  
  
     // Step one: Apply gradient
     cv::Sobel(img_gray, gradx, CV_32FC1, 1, 0, FILTER_WIDTH, 1, 0, cv::BORDER_CONSTANT);
     cv::Sobel(img_gray, grady, CV_32FC1, 0, 1, FILTER_WIDTH, 1, 0, cv::BORDER_CONSTANT);
     // Step Two: Calculate gx^2, gy^2, gx*gy
     pow(gradx, 2.0, gradx2);
     pow(grady, 2.0, grady2);
     multiply(gradx, grady, gradxy);
     // Step Three: Apply boxfilter
     cv::boxFilter(gradx2, gradx2g, -1, cv::Size(BLOCK_WIDTH, BLOCK_WIDTH));
     cv::boxFilter(grady2, grady2g, -1, cv::Size(BLOCK_WIDTH, BLOCK_WIDTH));
     cv::boxFilter(gradxy, gradxyg, -1, cv::Size(BLOCK_WIDTH, BLOCK_WIDTH));
  
     multiply(gradx2g, grady2g, x2y2);
     multiply(gradxyg, gradxyg, xy);
     pow((gradx2g + grady2g), 2.0, mtrace);
  
     // Step Four: Compute score
     dst.create(img_gray.rows, img_gray.cols, CV_32FC1);
     ocvthresh_img.create(img_gray.rows, img_gray.cols, dst.depth());
  
     float sum = 0;
     for (int j = 0; j < img_gray.rows; j++) {
         for (int i = 0; i < img_gray.cols; i++) {
             float v1 = x2y2.at<float>(j, i);
             float v2 = xy.at<float>(j, i);
             float v3 = mtrace.at<float>(j, i);
             float temp1 = (v1 - v2) - (0.04 * v3);
             dst.at<float>(j, i) = temp1;
  
             if (temp1 > 0.0) sum += temp1;
         }
     }
     //float meanval = sum / (img_gray.rows * img_gray.cols);
  
     // Step five: Apply Threshold
     for (int i = 0; i < img_gray.rows; i++) {
         for (int j = 0; j < img_gray.cols; j++) {
             float pix = dst.at<NMSTYPE>(i, j);
             if (pix > Th) {
                 ocvthresh_img.at<NMSTYPE>(i, j) = pix;
             } else {
                 ocvthresh_img.at<NMSTYPE>(i, j) = 0;
             }
         }
     }
  
     // Step six: Find Non maxima supppression
     if (NMS_RADIUS == 1) {
         OCVMaxSuppression1(ocvthresh_img, ocv_out_img);
     } else if (NMS_RADIUS == 2) {
         OCVMaxSuppression2(ocvthresh_img, ocv_out_img);
     }
  
     gradx.~Mat();
     grady.~Mat();
     gradx2.~Mat();
     grady2.~Mat();
     gradxy.~Mat();
     gradx2g.~Mat();
     grady2g.~Mat();
     gradxyg.~Mat();
     x2y2.~Mat();
     xy.~Mat();
     mtrace.~Mat();
     dst.~Mat();
     ocvthresh_img.~Mat();
  
 }

Here is the call graph for this function:

◆ OCVFindMaximum1()

bool OCVFindMaximum1	(	NMSTYPE	t0,
		NMSTYPE	t1,
		NMSTYPE	t2,
		NMSTYPE	m0,
		NMSTYPE	m1,
		NMSTYPE	m2,
		NMSTYPE	b0,
		NMSTYPE	b1,
		NMSTYPE	b2
	)

Definition at line 471 of file xf_ocv_ref.hpp.

                                                                                                                 {
     bool Max = false;
     if (m1 > t1 && m1 > m0 && m1 > m2 && m1 > b1) Max = true;
     return Max;
 }

◆ OCVFindMaximum2()

bool OCVFindMaximum2	(	NMSTYPE *	t1,
		NMSTYPE *	t2,
		NMSTYPE *	m1,
		NMSTYPE *	b1,
		NMSTYPE *	b2
	)

Definition at line 63 of file xf_ocv_ref.hpp.

                                                                                       {
     bool Max = false;
     NMSTYPE maxval = m1[2];
     if ((maxval > t1[2]) && (maxval > t2[1]) && (maxval > t2[2]) && (maxval > t2[3]) && (maxval > m1[0]) &&
         (maxval > m1[1]) && (maxval > m1[3]) && (maxval > m1[4]) && (maxval > b1[1]) && (maxval > b1[2]) &&
         (maxval > b1[3]) && (maxval > b2[2]))
         Max = true;
     return Max;
 }

◆ OCVMaxSuppression1()

void OCVMaxSuppression1	(	cv::Mat &	src,
		cv::Mat &	dst
	)

Definition at line 479 of file xf_ocv_ref.hpp.

                                                 {
     int i, j;
     NMSTYPE t0, t1, t2;
     NMSTYPE m0, m1, m2;
     NMSTYPE b0, b1, b2;
     bool result;
  
     /*          First row           */
     i = 0;
     for (j = 0; j < src.cols; j++) {
         if (j == 0) {
             t0 = 0;
             t1 = 0;
             t2 = 0;
             m0 = 0;
             m1 = src.at<NMSTYPE>(i, j);
             m2 = src.at<NMSTYPE>(i, j + 1);
             b0 = 0;
             b1 = src.at<NMSTYPE>(i + 1, j);
             b2 = src.at<NMSTYPE>(i + 1, j + 1);
         } else if ((j > 0) && (j < src.cols - 1)) {
             t0 = 0;
             t1 = 0;
             t2 = 0;
             m0 = src.at<NMSTYPE>(i, j - 1);
             m1 = src.at<NMSTYPE>(i, j);
             m2 = src.at<NMSTYPE>(i, j + 1);
             b0 = src.at<NMSTYPE>(i + 1, j - 1);
             b1 = src.at<NMSTYPE>(i + 1, j);
             b2 = src.at<NMSTYPE>(i + 1, j + 1);
         } else if (j == src.cols - 1) {
             t0 = 0;
             t1 = 0;
             t2 = 0;
             m0 = src.at<NMSTYPE>(i, j - 1);
             m1 = src.at<NMSTYPE>(i, j);
             m2 = 0;
             b0 = src.at<NMSTYPE>(i + 1, j - 1);
             b1 = src.at<NMSTYPE>(i + 1, j);
             b2 = 0;
         }
         result = OCVFindMaximum1(t0, t1, t2, m0, m1, m2, b0, b1, b2);
         dst.at<uchar>(i, j) = result ? 255 : 0;
     }
     for (i = 1; i < src.rows - 1; i++) {
         for (j = 0; j < src.cols; j++) {
             if (j == 0) {
                 t0 = 0;
                 t1 = src.at<NMSTYPE>(i - 1, j);
                 t2 = src.at<NMSTYPE>(i - 1, j + 1);
                 m0 = 0;
                 m1 = src.at<NMSTYPE>(i, j);
                 m2 = src.at<NMSTYPE>(i, j + 1);
                 b0 = 0;
                 b1 = src.at<NMSTYPE>(i + 1, j);
                 b2 = src.at<NMSTYPE>(i + 1, j + 1);
             } else if ((j > 0) && (j < src.cols - 1)) {
                 t0 = src.at<NMSTYPE>(i - 1, j - 1);
                 t1 = src.at<NMSTYPE>(i - 1, j);
                 t2 = src.at<NMSTYPE>(i - 1, j + 1);
                 m0 = src.at<NMSTYPE>(i, j - 1);
                 m1 = src.at<NMSTYPE>(i, j);
                 m2 = src.at<NMSTYPE>(i, j + 1);
                 b0 = src.at<NMSTYPE>(i + 1, j - 1);
                 b1 = src.at<NMSTYPE>(i + 1, j);
                 b2 = src.at<NMSTYPE>(i + 1, j + 1);
             } else if (j == src.cols - 1) {
                 t0 = src.at<NMSTYPE>(i - 1, j - 1);
                 t1 = src.at<NMSTYPE>(i - 1, j);
                 t2 = 0;
                 m0 = src.at<NMSTYPE>(i, j - 1);
                 m1 = src.at<NMSTYPE>(i, j);
                 m2 = 0;
                 b0 = src.at<NMSTYPE>(i + 1, j - 1);
                 b1 = src.at<NMSTYPE>(i + 1, j);
                 b2 = 0;
             }
             result = OCVFindMaximum1(t0, t1, t2, m0, m1, m2, b0, b1, b2);
             dst.at<uchar>(i, j) = result ? 255 : 0;
         }
     }
     /*          Last row            */
     i = src.rows - 1;
     for (j = 1; j < src.cols - 1; j++) {
         t0 = src.at<NMSTYPE>(i - 1, j - 1);
         t1 = src.at<NMSTYPE>(i - 1, j);
         t2 = src.at<NMSTYPE>(i - 1, j + 1);
         m0 = src.at<NMSTYPE>(i, j - 1);
         m1 = src.at<NMSTYPE>(i, j);
         m2 = src.at<NMSTYPE>(i, j + 1);
         b0 = 0;
         b1 = 0;
         b2 = 0;
         result = OCVFindMaximum1(t0, t1, t2, m0, m1, m2, b0, b1, b2);
         dst.at<uchar>(i, j) = result ? 255 : 0;
     }
 }

Here is the call graph for this function:

◆ OCVMaxSuppression2()

void OCVMaxSuppression2	(	cv::Mat &	src,
		cv::Mat &	dst
	)

Definition at line 73 of file xf_ocv_ref.hpp.

                                                 {
     int i, j, k;
     int ii, jj;
     NMSTYPE t1[5], t2[5];
     NMSTYPE m1[5];
     NMSTYPE b1[5], b2[5];
     bool result;
  
     /*          Process zeroth row          */
     i = 0;
     for (j = 0; j < src.cols; j++) {
         if (j < 2) {
             for (k = 0; k < 5; k++) {
                 t1[k] = 0;
             }
             for (k = 0; k < 5; k++) {
                 t2[k] = 0;
             }
             for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
                 if (jj >= 0)
                     m1[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     m1[k] = 0;
             }
             for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
                 if (jj >= 0)
                     b1[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     b1[k] = 0;
             }
             for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
                 if (jj >= 0)
                     b2[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     b2[k] = 0;
             }
         } else if ((j >= 2) && (j < src.cols - 2)) {
             for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
                 t1[k] = 0;
             }
             for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
                 t2[k] = 0;
             }
             for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
                 m1[k] = src.at<NMSTYPE>(ii, jj);
             }
             for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
                 b1[k] = src.at<NMSTYPE>(ii, jj);
             }
             for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
                 b2[k] = src.at<NMSTYPE>(ii, jj);
             }
         } else if (j >= src.cols - 2) {
             for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
                 t1[k] = 0;
             }
             for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
                 t2[k] = 0;
             }
             for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
                 if (jj < src.cols)
                     m1[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     m1[k] = 0;
             }
             for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
                 if (jj < src.cols)
                     b1[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     b1[k] = 0;
             }
             for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
                 if (jj < src.cols)
                     b2[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     b2[k] = 0;
             }
         }
         result = OCVFindMaximum2(t1, t2, m1, b1, b2);
         dst.at<uchar>(i, j) = result ? 255 : 0;
     }
     /*          Process second row          */
     i = 1;
     for (j = 0; j < src.cols; j++) {
         if (j < 2) {
             for (k = 0; k < 5; k++) {
                 t1[k] = 0;
             }
             for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
                 if (jj >= 0)
                     t2[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     t2[k] = 0;
             }
             for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
                 if (jj >= 0)
                     m1[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     m1[k] = 0;
             }
             for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
                 if (jj >= 0)
                     b1[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     b1[k] = 0;
             }
             for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
                 if (jj >= 0)
                     b2[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     b2[k] = 0;
             }
         } else if ((j >= 2) && (j < src.cols - 2)) {
             for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
                 t1[k] = 0;
             }
             for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
                 t2[k] = src.at<NMSTYPE>(ii, jj);
             }
             for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
                 m1[k] = src.at<NMSTYPE>(ii, jj);
             }
             for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
                 b1[k] = src.at<NMSTYPE>(ii, jj);
             }
             for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
                 b2[k] = src.at<NMSTYPE>(ii, jj);
             }
         } else if (j >= src.cols - 2) {
             for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
                 t1[k] = 0;
             }
             for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
                 t2[k] = 0;
             }
             for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
                 if (jj < src.cols)
                     m1[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     m1[k] = 0;
             }
             for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
                 if (jj < src.cols)
                     b1[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     b1[k] = 0;
             }
             for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
                 if (jj < src.cols)
                     b2[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     b2[k] = 0;
             }
         }
         result = OCVFindMaximum2(t1, t2, m1, b1, b2);
         dst.at<uchar>(i, j) = result ? 255 : 0;
     }
  
     for (i = 2; i < src.rows - 2; i++) {
         for (j = 0; j < src.cols; j++) {
             if (j < 2) {
                 for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
                     if (jj >= 0)
                         t1[k] = src.at<NMSTYPE>(ii, jj);
                     else
                         t1[k] = 0;
                 }
                 for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
                     if (jj >= 0)
                         t2[k] = src.at<NMSTYPE>(ii, jj);
                     else
                         t2[k] = 0;
                 }
                 for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
                     if (jj >= 0)
                         m1[k] = src.at<NMSTYPE>(ii, jj);
                     else
                         m1[k] = 0;
                 }
                 for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
                     if (jj >= 0)
                         b1[k] = src.at<NMSTYPE>(ii, jj);
                     else
                         b1[k] = 0;
                 }
                 for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
                     if (jj >= 0)
                         b2[k] = src.at<NMSTYPE>(ii, jj);
                     else
                         b2[k] = 0;
                 }
             } else if ((j >= 2) && (j < src.cols - 2)) {
                 for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
                     t1[k] = src.at<NMSTYPE>(ii, jj);
                 }
                 for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
                     t2[k] = src.at<NMSTYPE>(ii, jj);
                 }
                 for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
                     m1[k] = src.at<NMSTYPE>(ii, jj);
                 }
                 for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
                     b1[k] = src.at<NMSTYPE>(ii, jj);
                 }
                 for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
                     b2[k] = src.at<NMSTYPE>(ii, jj);
                 }
             } else if (j >= src.cols - 2) {
                 for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
                     if (jj < src.cols)
                         t1[k] = src.at<NMSTYPE>(ii, jj);
                     else
                         t1[k] = 0;
                 }
                 for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
                     if (jj < src.cols)
                         t2[k] = src.at<NMSTYPE>(ii, jj);
                     else
                         t2[k] = 0;
                 }
                 for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
                     if (jj < src.cols)
                         m1[k] = src.at<NMSTYPE>(ii, jj);
                     else
                         m1[k] = 0;
                 }
                 for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
                     if (jj < src.cols)
                         b1[k] = src.at<NMSTYPE>(ii, jj);
                     else
                         b1[k] = 0;
                 }
                 for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
                     if (jj < src.cols)
                         b2[k] = src.at<NMSTYPE>(ii, jj);
                     else
                         b2[k] = 0;
                 }
             }
  
             result = OCVFindMaximum2(t1, t2, m1, b1, b2);
             dst.at<uchar>(i, j) = result ? 255 : 0;
         }
     }
     /*          Process zeroth row          */
     i = src.rows - 2;
     for (j = 0; j < src.cols; j++) {
         if (j < 2) {
             for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
                 if (jj >= 0)
                     t1[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     t1[k] = 0;
             }
             for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
                 if (jj >= 0)
                     t2[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     t2[k] = 0;
             }
             for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
                 if (jj >= 0)
                     m1[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     m1[k] = 0;
             }
             for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
                 if (jj >= 0)
                     b1[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     b1[k] = 0;
             }
             for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
                 b2[k] = 0;
             }
         } else if ((j >= 2) && (j < src.cols - 2)) {
             for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
                 t1[k] = src.at<NMSTYPE>(ii, jj);
             }
             for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
                 t2[k] = src.at<NMSTYPE>(ii, jj);
             }
             for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
                 m1[k] = src.at<NMSTYPE>(ii, jj);
             }
             for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
                 b1[k] = src.at<NMSTYPE>(ii, jj);
             }
             for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
                 b2[k] = 0;
             }
         } else if (j >= src.cols - 2) {
             for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
                 if (jj < src.cols)
                     t1[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     t1[k] = 0;
             }
             for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
                 if (jj < src.cols)
                     t2[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     t2[k] = 0;
             }
             for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
                 if (jj < src.cols)
                     m1[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     m1[k] = 0;
             }
             for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
                 if (jj < src.cols)
                     b1[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     b1[k] = 0;
             }
             for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
                 b2[k] = 0;
             }
         }
         result = OCVFindMaximum2(t1, t2, m1, b1, b2);
         dst.at<uchar>(i, j) = result ? 255 : 0;
     }
     /*          Process second row          */
     i = src.rows - 1;
     for (j = 0; j < src.cols; j++) {
         if (j < 2) {
             for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
                 if (jj >= 0)
                     t1[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     t1[k] = 0;
             }
             for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
                 if (jj >= 0)
                     t2[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     t2[k] = 0;
             }
             for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
                 if (jj >= 0)
                     m1[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     m1[k] = 0;
             }
             for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
                 b1[k] = 0;
             }
             for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
                 b2[k] = 0;
             }
         } else if ((j >= 2) && (j < src.cols - 2)) {
             for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
                 t1[k] = src.at<NMSTYPE>(ii, jj);
             }
             for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
                 t2[k] = src.at<NMSTYPE>(ii, jj);
             }
             for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
                 m1[k] = src.at<NMSTYPE>(ii, jj);
             }
             for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
                 b1[k] = 0;
             }
             for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
                 b2[k] = 0;
             }
         } else if (j >= src.cols - 2) {
             for (k = 0, ii = i - 2, jj = j - 2; k < 5; k++, jj++) {
                 if (jj < src.cols)
                     t1[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     t1[k] = 0;
             }
             for (k = 0, ii = i - 1, jj = j - 2; k < 5; k++, jj++) {
                 if (jj < src.cols)
                     t2[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     t2[k] = 0;
             }
             for (k = 0, ii = i, jj = j - 2; k < 5; k++, jj++) {
                 if (jj < src.cols)
                     m1[k] = src.at<NMSTYPE>(ii, jj);
                 else
                     m1[k] = 0;
             }
             for (k = 0, ii = i + 1, jj = j - 2; k < 5; k++, jj++) {
                 b1[k] = 0;
             }
             for (k = 0, ii = i + 2, jj = j - 2; k < 5; k++, jj++) {
                 b2[k] = 0;
             }
         }
         result = OCVFindMaximum2(t1, t2, m1, b1, b2);
         dst.at<uchar>(i, j) = result ? 255 : 0;
     }
 }

Here is the call graph for this function:

◆ siUdp_meta()

stream<NetworkMetaStream> siUdp_meta ( "siUdp_meta" )

Here is the caller graph for this function:

◆ soUdp_meta()

stream<NetworkMetaStream> soUdp_meta ( "soUdp_meta" )

Here is the caller graph for this function:

◆ sSHL_Uaf_Data()

stream<UdpWord> sSHL_Uaf_Data ( "sSHL_Uaf_Data" )

Here is the caller graph for this function:

◆ stepDut()

void stepDut ( )

Run a single iteration of the DUT model.

Returns: Nothing.

Definition at line 127 of file test_harris.cpp.

                {
     harris(
         &node_rank, &cluster_size,
         sSHL_Uaf_Data, sUAF_Shl_Data,
         siUdp_meta, soUdp_meta,
         &s_udp_rx_ports
         #ifdef ENABLE_DDR
                         ,
         // sROL_Shl_Mem_RdCmdP0,
         // sSHL_Rol_Mem_RdStsP0,
         // sSHL_Rol_Mem_ReadP0,
         sROL_Shl_Mem_WrCmdP0,
         sSHL_Rol_Mem_WrStsP0,
         sROL_Shl_Mem_WriteP0,
         lcl_mem0,
         lcl_mem1
       #endif
       );
     simCnt++;
     printf("[%4.4d] STEP DUT \n", simCnt);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sUAF_Shl_Data()

stream<UdpWord> sUAF_Shl_Data ( "sUAF_Shl_Data" )

Here is the caller graph for this function:

Variable Documentation

◆ cluster_size

ap_uint<32> cluster_size

Definition at line 93 of file test_harris.cpp.

◆ node_rank

ap_uint<32> node_rank

Definition at line 92 of file test_harris.cpp.

◆ piSHL_This_MmioCaptPktEn

ap_uint<1> piSHL_This_MmioCaptPktEn

Definition at line 82 of file test_harris.cpp.

◆ piSHL_This_MmioPostPktEn

ap_uint<1> piSHL_This_MmioPostPktEn

Definition at line 81 of file test_harris.cpp.

◆ s_udp_rx_ports

ap_uint<32> s_udp_rx_ports = 0x0

Definition at line 89 of file test_harris.cpp.

◆ simCnt

int simCnt

Definition at line 120 of file test_harris.cpp.

Files

Macros

Typedefs

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ DEBUG_LEVEL

◆ DEBUG_TRACE

◆ DISABLED

◆ ENABLE_DDR_EMULATE_DELAY_IN_TB

◆ ENABLED

◆ KO

◆ OK

◆ TB_TRIALS

◆ THIS_NAME

◆ TRACE_ALL

◆ TRACE_MMIO

◆ TRACE_OFF

◆ TRACE_UAF

◆ TRACE_URIF

◆ UNVALID

◆ VALID

Typedef Documentation

◆ NMSTYPE

Function Documentation

◆ image_stream_from_harris()

◆ main() [1/2]

◆ main() [2/2]

◆ ocv_ref()

◆ OCVFindMaximum1()

◆ OCVFindMaximum2()

◆ OCVMaxSuppression1()

◆ OCVMaxSuppression2()

◆ siUdp_meta()

◆ soUdp_meta()

◆ sSHL_Uaf_Data()

◆ stepDut()

◆ sUAF_Shl_Data()

Variable Documentation

◆ cluster_size

◆ node_rank

◆ piSHL_This_MmioCaptPktEn

◆ piSHL_This_MmioPostPktEn

◆ s_udp_rx_ports

◆ simCnt