Sobel

This is the Sobel accelerated function from Vitis Vision Open Source Library. More...

Collaboration diagram for Sobel:

Modules
	Sobel Testbench
	This is a subgroup of Sobel accelerated function with only testbench-related functions/classes.
	Sobel HLS
	This is a subgroup of Sobel accelerated function with only synthesizable (HLS) functions/classes.
	Sobel Host
	This is a subgroup of Sobel accelerated function with only host code software.

Files
file	config.h
	The configuration of a Sobel Example application (UDP or TCP)
file	sobel_host.cpp
	Sobel userspace application for cF (x86, ppc64).
file	xf_sobel_config.h
	The Sobel configuration header.

Macros
#define	CEIL(a, b)   (((a) + (b-1)) / (b))
#define	FRAME_HEIGHT   1024
#define	FRAME_WIDTH   1024
#define	FRAME_INTERVAL   (1000/30)
#define	PACK_SIZE   1024
#define	BUF_LEN   65540
#define	WRITE_OUTPUT_FILE
#define	INPUT_TYPE_HOST   CV_8UC1
#define	NET_TYPE   udp
#define	DEBUG_LEVEL   dbgLevelNone
#define	FRAME_TOTAL   FRAME_HEIGHT * FRAME_WIDTH
#define	TOT_TRANSFERS   CEIL(FRAME_TOTAL, PACK_SIZE)
#define	tcp   0
#define	udp   1
#define	PY_WRAP_SOBEL_NUMPI   0
#define	PY_WRAP_SOBEL_FILENAME   1
#define	NPC1   XF_NPPC1
#define	PTR_WIDTH   128
#define	TYPE   XF_8UC1
#define	CH_TYPE   XF_GRAY
#define	INPUT_PTR_WIDTH   8
#define	OUTPUT_PTR_WIDTH   64
#define	NPIX   XF_NPPC1
#define	WIDTH   FRAME_WIDTH
#define	HEIGHT   FRAME_HEIGHT
#define	IMGSIZE   FRAME_TOTAL
#define	BITS_PER_10GBITETHRNET_AXI_PACKET   64
#define	BYTES_PER_10GBITETHRNET_AXI_PACKET   (BITS_PER_10GBITETHRNET_AXI_PACKET/8)
#define	IMG_PACKETS   IMGSIZE/(BYTES_PER_10GBITETHRNET_AXI_PACKET)
#define	MIN_RX_LOOPS   IMG_PACKETS*(BITS_PER_10GBITETHRNET_AXI_PACKET/INPUT_PTR_WIDTH)
#define	MIN_TX_LOOPS   IMG_PACKETS*(BITS_PER_10GBITETHRNET_AXI_PACKET/OUTPUT_PTR_WIDTH)
#define	OUT_TYPE   TYPE

Functions
void	delay (unsigned int mseconds)
void	print_cFpZoo (void)
void	resizeCropSquare (const cv::Mat &input, const cv::Mat &output, const cv::Size &dstSize, int interpolation=INTER_LINEAR)
	Resize an image and crop if necessary in order to keep a rectangle area in the middle of the image. More...
int	main (int argc, char *argv[])
void	sobel_accel (xf::cv::Mat< XF_8UC1, 1024, 1024, XF_NPPC1 > &_src, xf::cv::Mat< XF_8UC1, 1024, 1024, XF_NPPC1 > &_dst)
void	medianBlurAccelArray (ap_uint< 256 > *img_inp, ap_uint< 256 > *img_out, int rows, int cols)
void	medianBlurAccelStream (hls::stream< ap_uint< 256 >> &img_in_axi_stream, hls::stream< ap_uint< 256 >> &img_out_axi_stream, int rows, int cols)
	Top-level accelerated function of the Sobel Application with array I/Fadd SOBEL. More...
void	fakeSobelAccelStream (hls::stream< ap_axiu< 256, 0, 0, 0 > > &img_in_axi_stream, hls::stream< ap_axiu< 256, 0, 0, 0 > > &img_out_axi_stream, unsigned int min_rx_loops, unsigned int min_tx_loops)
void	medianBlurAccelMem (membus_t *img_inp, membus_t *img_out, int rows, int cols)
	Top-level accelerated function of the MedianBlur Application with array I/F. More...

Detailed Description

This is the Sobel accelerated function from Vitis Vision Open Source Library.

Macro Definition Documentation

BITS_PER_10GBITETHRNET_AXI_PACKET

#define BITS_PER_10GBITETHRNET_AXI_PACKET   64

Definition at line 109 of file xf_sobel_config.h.

BUF_LEN

#define BUF_LEN   65540

Larger than maximum UDP packet size

Definition at line 55 of file config.h.

BYTES_PER_10GBITETHRNET_AXI_PACKET

#define BYTES_PER_10GBITETHRNET_AXI_PACKET   (BITS_PER_10GBITETHRNET_AXI_PACKET/8)

Definition at line 110 of file xf_sobel_config.h.

CEIL

#define CEIL	(		a,
			b
	)		(((a) + (b-1)) / (b))

Ceiling function without using math.h

Definition at line 37 of file config.h.

CH_TYPE

#define CH_TYPE   XF_GRAY

Definition at line 90 of file xf_sobel_config.h.

DEBUG_LEVEL

#define DEBUG_LEVEL   dbgLevelNone

The level of debugging. 0->None, 1-> Light Debug, 2-> Medium Debug , 3-> Insane Debug

Definition at line 78 of file config.h.

FRAME_HEIGHT

#define FRAME_HEIGHT   1024

The maximum width of frame in pixels

Definition at line 43 of file config.h.

FRAME_INTERVAL

#define FRAME_INTERVAL   (1000/30)

Definition at line 48 of file config.h.

FRAME_TOTAL

#define FRAME_TOTAL   FRAME_HEIGHT * FRAME_WIDTH

Definition at line 82 of file config.h.

FRAME_WIDTH

#define FRAME_WIDTH   1024

The maximum height of frame in pixels

Definition at line 46 of file config.h.

HEIGHT

#define HEIGHT   FRAME_HEIGHT

Definition at line 105 of file xf_sobel_config.h.

IMG_PACKETS

#define IMG_PACKETS   IMGSIZE/(BYTES_PER_10GBITETHRNET_AXI_PACKET)

Definition at line 112 of file xf_sobel_config.h.

IMGSIZE

#define IMGSIZE   FRAME_TOTAL

Definition at line 107 of file xf_sobel_config.h.

INPUT_PTR_WIDTH

#define INPUT_PTR_WIDTH   8

Definition at line 91 of file xf_sobel_config.h.

INPUT_TYPE_HOST

#define INPUT_TYPE_HOST   CV_8UC1

If defined, images will be shown in pop-up windows
For HOST TB uncomment this. For normal host execution keep it commented
Keep it uncommented of you want the input to be from camera frames else, for images comment it For The OpenCV type fot th input image. TODO: We have to automatically fix it for every kernel

Definition at line 70 of file config.h.

MIN_RX_LOOPS

#define MIN_RX_LOOPS   IMG_PACKETS*(BITS_PER_10GBITETHRNET_AXI_PACKET/INPUT_PTR_WIDTH)

Definition at line 114 of file xf_sobel_config.h.

MIN_TX_LOOPS

#define MIN_TX_LOOPS   IMG_PACKETS*(BITS_PER_10GBITETHRNET_AXI_PACKET/OUTPUT_PTR_WIDTH)

Definition at line 115 of file xf_sobel_config.h.

NET_TYPE

#define NET_TYPE   udp

The network socket type: tcp or udp

Definition at line 73 of file config.h.

NPC1

#define NPC1   XF_NPPC1

Definition at line 70 of file xf_sobel_config.h.

NPIX

#define NPIX   XF_NPPC1

Definition at line 101 of file xf_sobel_config.h.

OUT_TYPE

#define OUT_TYPE   TYPE

Definition at line 118 of file xf_sobel_config.h.

OUTPUT_PTR_WIDTH

#define OUTPUT_PTR_WIDTH   64

Definition at line 92 of file xf_sobel_config.h.

PACK_SIZE

#define PACK_SIZE   1024

This is our custom MTU. We must use a multiple of 8 (Bytes per transaction)! 1450 4086 udp pack size; note that OSX limits < 8100 bytes

Definition at line 52 of file config.h.

PTR_WIDTH

#define PTR_WIDTH   128

Definition at line 71 of file xf_sobel_config.h.

PY_WRAP_SOBEL_FILENAME

#define PY_WRAP_SOBEL_FILENAME   1

Definition at line 91 of file config.h.

PY_WRAP_SOBEL_NUMPI

#define PY_WRAP_SOBEL_NUMPI   0

Definition at line 90 of file config.h.

tcp

#define tcp   0

Definition at line 87 of file config.h.

TOT_TRANSFERS

#define TOT_TRANSFERS   CEIL(FRAME_TOTAL, PACK_SIZE)

The total TxRx transfers for a predefined MTU=PACK_SIZE

Definition at line 85 of file config.h.

TYPE

#define TYPE   XF_8UC1

Definition at line 85 of file xf_sobel_config.h.

udp

#define udp   1

Definition at line 88 of file config.h.

WIDTH

#define WIDTH   FRAME_WIDTH

Definition at line 104 of file xf_sobel_config.h.

WRITE_OUTPUT_FILE

#define WRITE_OUTPUT_FILE

If defined, output images will be written

Definition at line 58 of file config.h.

Function Documentation

delay()

void delay

(

unsigned int

mseconds

)

Definition at line 51 of file sobel_host.cpp.

{
    clock_t goal = mseconds + clock();
    while (goal > clock());
}

Here is the call graph for this function:

fakeSobelAccelStream()

void fakeSobelAccelStream	(	hls::stream< ap_axiu< 256, 0, 0, 0 > > &	img_in_axi_stream,
		hls::stream< ap_axiu< 256, 0, 0, 0 > > &	img_out_axi_stream,
		unsigned int	min_rx_loops,
		unsigned int	min_tx_loops
	)

Here is the caller graph for this function:

main()

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

Main testbench and user-application for Sobel on host. Client

Returns

O on success, 1 on fail

Definition at line 108 of file sobel_host.cpp.

                                  {
    if ((argc < 3) || (argc > 4)) { // Test for correct number of arguments
        cerr << "Usage: " << argv[0] << " <Server> <Server Port> <optional input image>\n";
        exit(1);
    }
#endif // PY_WRAP
 
    //------------------------------------------------------
    //-- STEP-1 : Socket and variables definition
    //------------------------------------------------------
    
    #ifndef PY_WRAP
    assert ((argc == 3) || (argc == 4));
    string s_servAddress = argv[1]; // First arg: server address
    char *s_servPort = argv[2];
    #endif
 
    string servAddress = s_servAddress;
    unsigned short servPort;
    bool net_type = NET_TYPE;
    if (net_type == udp) {
    servPort = Socket::resolveService(s_servPort, "udp");
    }
    else if (net_type == tcp) {
    servPort = atoi(s_servPort);
    }
    else {
    cout << "ERROR: Invalid type of socket type provided: " << net_type  << " Choosed one of (tcp=0 or udp=1)" << endl;
    }    
    
    unsigned char buffer[BUF_LEN]; // Buffer for echo string
    unsigned int recvMsgSize; // Size of received message
    string input_string;
#ifdef INPUT_FROM_CAMERA
    int input_num;
#ifdef PY_WRAP
#if PY_WRAP == PY_WRAP_SOBEL_FILENAME
    input_num = atoi(input_str);
    input_string = "./cam"+to_string(input_num);
#endif // PY_WRAP == PY_WRAP_SOBEL_FILENAME
#else // !PY_WRAP
    if (argc == 3) {
        input_num = 0;
    }
    else if (argc == 4) {
        input_num = atoi(argv[3]);
    }
    input_string = "./cam"+to_string(input_num);
#endif // PY_WRAP    
#else // !INPUT_FROM_CAMERA
#ifdef PY_WRAP
#if PY_WRAP == PY_WRAP_SOBEL_FILENAME
    input_string.assign(input_str);
#endif // PY_WRAP == PY_WRAP_SOBEL_FILENAME    
#else // !PY_WRAP
    if (argc == 3) {
        // Give a default image
        input_string.assign("../../../../../../ROLE/vision/hls/sobel/test/8x8.png");
    }
    else if (argc == 4) {
        input_string.assign(argv[3]);
    }
#endif // PY_WRAP
#endif // INPUT_FROM_CAMERA
    
   
#if !defined(PY_WRAP) || (PY_WRAP == PY_WRAP_SOBEL_FILENAME)
   
    // ksize: aperture linear size; it must be odd and greater than 1, for example: 3, 5, 7 ...
    int ksize = WINDOW_SIZE ;
    string out_img_file;
    string out_video_file;
    // Define the codec and create VideoWriter object.The output is stored in 'outcpp.avi' file. 
    //#ifdef PY_WRAP
    //out_video_file.assign(output_str);
    //#else // !PY_WRAP
    out_video_file.assign(input_string);
    out_video_file += "_fpga_video_out.avi";
    //#endif // PY_WRAP
#if CV_MAJOR_VERSION < 4
    VideoWriter video(out_video_file,CV_FOURCC('M','J','P','G'),10, Size(FRAME_WIDTH,FRAME_HEIGHT));
#else
    VideoWriter video(out_video_file,cv::VideoWriter::fourcc('M','J','P','G'),10, Size(FRAME_WIDTH,FRAME_HEIGHT));
#endif
 
#endif // #if !defined(PY_WRAP) || (PY_WRAP == PY_WRAP_SOBEL_FILENAME) 
 
    print_cFpZoo();
    
    try {
          
        //------------------------------------------------------
        //-- STEP-2 : Initialize socket connection
        //------------------------------------------------------      
#if NET_TYPE == udp
#ifndef TB_SIM_CFP_VITIS
            UDPSocket sock(servPort); // NOTE: It is very important to set port here in order to call 
                                      // bind() in the UDPSocket constructor
#else // TB_SIM_CFP_VITIS
            UDPSocket sock; // NOTE: In HOST TB the port is already binded by sobel_host_fwd_tb.cpp
#endif // TB_SIM_CFP_VITIS
#else // tcp
            TCPSocket sock(servAddress, servPort);
#endif // udp/tcp
 
 
#if !defined(PY_WRAP) || (PY_WRAP == PY_WRAP_SOBEL_FILENAME)
 
 
            //------------------------------------------------------------------------------------
            //-- STEP-3 : Initialize a Greyscale OpenCV Mat either from image or from video/camera
            //------------------------------------------------------------------------------------
            Mat frame, send(FRAME_WIDTH, FRAME_HEIGHT, INPUT_TYPE_HOST, Scalar(0)), ocv_out_img;
            vector < uchar > encoded;
 
#ifdef INPUT_FROM_CAMERA
 
        VideoCapture cap(input_num); // Grab the camera
        if (!cap.isOpened()) {
            cerr << "OpenCV Failed to open camera " + input_num << endl;
            exit(1);
        }
        
#else // INPUT_FROM_CAMERA
 
        VideoCapture cap(input_string); // Grab the image
        if (!cap.isOpened()) {
            cerr << "OpenCV Failed to open file " + input_string << endl;
            exit(1);
        }
        
#endif // INPUT_FROM_CAMERA
        
        //frame = cv::imread(argv[3], cv::IMREAD_GRAYSCALE); // reading in the image in grey scale
        unsigned int num_frame = 0;
 
        while (1) {
            clock_t start_cycle_main = clock();
            cap >> frame;
            if (frame.empty()) break; // if input is an image, the loop will be executed once
            if(frame.size().width==0) continue; //simple integrity check; skip erroneous data...
            cout << " ___________________________________________________________________ " << endl;
            cout << "/                                                                   \\" << endl;
            cout << "INFO: Frame # " << ++num_frame << endl;
#if CV_MAJOR_VERSION < 4
            cv::cvtColor(frame,frame,CV_BGR2GRAY);
#else
            cv::cvtColor(frame,frame,cv::COLOR_BGR2GRAY);
#endif
            resizeCropSquare(frame, send, Size(FRAME_WIDTH, FRAME_HEIGHT), INTER_LINEAR);
            if ((frame.cols != FRAME_WIDTH) || (frame.rows != FRAME_HEIGHT)) {
                cout << "WARNING: Input frame was resized from " << frame.cols << "x" 
                        << frame.rows << " to " << send.cols << "x" << send.rows << endl;
            }
            assert(send.total() == FRAME_WIDTH * FRAME_HEIGHT);
            // Ensure that the selection of MTU is a multiple of 8 (Bytes per transaction)
            assert(PACK_SIZE % 8 == 0);
 
#ifdef SHOW_WINDOWS     
            namedWindow("host_send", CV_WINDOW_NORMAL);
            imshow("host_send", send);
 
#endif // SHOW_WINDOWS
    
            // 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(send.isContinuous());
 
            unsigned int send_total = send.total();
            unsigned int send_channels = send.channels();
 
#else // PY_WRAP == PY_WRAP_SOBEL_NUMPI
    
            unsigned int send_total = (unsigned int)total_size;
            unsigned int send_channels = 1; // FIXME: It is ok only for 1-d array, i.e. CV_8UC1
            unsigned char * sendarr = input_img;
#endif // #if !defined(PY_WRAP) || (PY_WRAP == PY_WRAP_SOBEL_FILENAME)
 
            unsigned int total_pack  = 1 + (send_total * send_channels - 1) / PACK_SIZE;
            unsigned int total_bytes = total_pack * PACK_SIZE;
            unsigned int bytes_in_last_pack = send_total * send_channels - (total_pack - 1) * PACK_SIZE;
            assert(total_pack == TOT_TRANSFERS);
 
            //unsigned char * longbuf = new unsigned char[PACK_SIZE * total_pack];
        unsigned char * longbuf = (unsigned char *) malloc (PACK_SIZE * total_pack * sizeof (unsigned char));
 
//            cout << "INFO: FPGA destination : " << servAddress << ":" << servPort << endl;
//            cout << "INFO: Network socket   : " << ((NET_TYPE == tcp) ? "TCP" : "UDP") << endl;
//            cout << "INFO: Total packets to send/receive = " << total_pack << endl;
//            cout << "INFO: Total bytes to send/receive   = " << send_total * send_channels << endl;
//            cout << "INFO: Total bytes in " << total_pack << " packets = "  << total_bytes << endl;
//            cout << "INFO: Bytes in last packet          = " << bytes_in_last_pack << endl;
//            cout << "INFO: Packet size (custom MTU)      = " << PACK_SIZE << endl;
 
#if !defined(PY_WRAP) || (PY_WRAP == PY_WRAP_SOBEL_FILENAME)
        
            //--------------------------------------------------------
            //-- STEP-4 : RUN SOBEL DETECTOR FROM OpenCV LIBRARY (SW)
            //--------------------------------------------------------
            clock_t start_cycle_sobel_sw = clock();
            ocv_out_img.create(send.rows, send.cols, INPUT_TYPE_HOST); // create memory for opencv output image
            ocv_ref(send, ocv_out_img, ksize);
            clock_t end_cycle_sobel_sw = clock();
            double duration_sobel_sw = (end_cycle_sobel_sw - start_cycle_sobel_sw) / 
                                            (double) CLOCKS_PER_SEC;
//            cout << "INFO: SW exec. time:" << duration_sobel_sw << " seconds" << endl;
//            cout << "INFO: Effective FPS SW:" << (1 / duration_sobel_sw) << " \tkbps:" << 
//                    (PACK_SIZE * total_pack / duration_sobel_sw / 1024 * 8) << endl;
 
            //------------------------------------------------------
            //-- STEP-5 : RUN SOBEL DETECTOR FROM cF (HW)
            //------------------------------------------------------
    
            //------------------------------------------------------
            //-- STEP-5.1 : Preparation
            //------------------------------------------------------
 
            // Anchor a pointer on cvMat raw data
            unsigned char * sendarr = send.isContinuous()? send.data: send.clone().data;
 
 
#endif // !defined(PY_WRAP) || (PY_WRAP == PY_WRAP_SOBEL_FILENAME)
    
            clock_t start_cycle_sobel_hw = clock();
 
            //------------------------------------------------------
            //-- STEP-5.2 : TX Loop
            //------------------------------------------------------
            clock_t last_cycle_tx = clock();
            unsigned int sending_now = PACK_SIZE;
            for (unsigned int i = 0; i < total_pack; i++) {
                if ( i == total_pack - 1 ) {
                    sending_now = bytes_in_last_pack;
                }
                #if NET_TYPE == udp
                sock.sendTo( & sendarr[i * PACK_SIZE], sending_now, servAddress, servPort);
                #else
                sock.send( & sendarr[i * PACK_SIZE], sending_now);
                #endif
                //delay(200);  
            }
            
            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;
        
        
            //------------------------------------------------------
            //-- STEP-5.3 : RX Loop
            //------------------------------------------------------    
            clock_t last_cycle_rx = clock();
            unsigned int receiving_now = PACK_SIZE;
//            cout << "INFO: Expecting length of packs:" << total_pack << " from " <<  servAddress << ":" << servPort << endl;
            //unsigned char * longbuf = new unsigned char[PACK_SIZE * total_pack];
            unsigned int loopi=0;
            for (unsigned int i = 0; i < send_total; ) {
                //cout << "DEBUG: i=" << i << ", loopi=" << loopi++ << endl;
                //if ( i == total_pack - 1 ) {
                //    receiving_now = bytes_in_last_pack;
                //}
                #if NET_TYPE == udp                
                recvMsgSize = sock.recvFrom(buffer, BUF_LEN, servAddress, servPort);
                #else
                recvMsgSize = sock.recv(buffer, BUF_LEN);
                #endif
                if (recvMsgSize != receiving_now) {
                    cerr << "WARNING: at i=" << i << " received unexpected size pack:" << recvMsgSize << ". Expected: " << 
                            receiving_now << endl;
                    //continue;
                }
                memcpy( & longbuf[i], buffer, recvMsgSize);
                //cout << "DEBUG: i=" << i << " recvMsgSize=" << recvMsgSize << endl;
                i += recvMsgSize;
                //delay(200);
            }
//            cout << "INFO: Received packet from " << servAddress << ":" << servPort << endl;
 
            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;
 
            clock_t end_cycle_sobel_hw = next_cycle_rx;
 
            double duration_sobel_hw = (end_cycle_sobel_hw - start_cycle_sobel_hw) / 
                                                (double) CLOCKS_PER_SEC;
//            cout << "INFO: HW exec. time:" << duration_sobel_hw << " seconds" << endl;
//            cout << "INFO: Effective FPS HW:" << (1 / duration_sobel_hw) << " \tkbps:" << 
//                    (PACK_SIZE * total_pack / duration_sobel_hw / 1024 * 8) << endl;
                    
#if !defined(PY_WRAP) || (PY_WRAP == PY_WRAP_SOBEL_FILENAME)
 
            frame = cv::Mat(FRAME_HEIGHT, FRAME_WIDTH, INPUT_TYPE_HOST, longbuf); // OR vec.data() instead of ptr
            if (frame.size().width == 0) {
                cerr << "receive failure!" << endl;
                continue;
            }
#ifdef SHOW_WINDOWS            
            namedWindow("host_recv", CV_WINDOW_NORMAL);
            imshow("host_recv", frame);
#endif
 
            //------------------------------------------------------
            //-- STEP-6 : Write output files and show in windows
            //------------------------------------------------------
 
            ostringstream oss;
//            oss << "cFp_Vitis E2E:" << "INFO: Effective FPS HW:" << (1 / duration_sobel_hw) << 
//                   " \tkbps:" << (PACK_SIZE * total_pack / duration_sobel_hw / 1024 * 8);
            string windowName = "cFp_Vitis End2End"; //oss.str();
 
            //moveWindow(windowName, 0, 0);
#ifdef WRITE_OUTPUT_FILE
            if (num_frame == 1) {
                out_img_file.assign(input_string);
                out_img_file += "_fpga_image_out_frame_" + to_string(num_frame) + ".png";
#if defined(PY_WRAP) && (PY_WRAP == PY_WRAP_SOBEL_FILENAME)
 
                if (!strcpy(output_img_str, &out_img_file[0])) {
                    cerr << "ERROR: Cannot write to output image string." << endl;
                }
#endif // defined(PY_WRAP) && (PY_WRAP == PY_WRAP_SOBEL_FILENAME)
                cout << "INFO: The output image file is stored at : " << out_img_file << endl; 
                // We save the image received from network after being processed by Sobel HW or HOST TB
                imwrite(out_img_file, frame);
            }
            else if (num_frame > 1) {
                // If the frame is empty, break immediately
                if (frame.empty()) {
                    break;
                }
                cout << "INFO: The output video file is stored at  : " << out_video_file << endl;
                Mat tovideo;
                if (frame.channels() != 1) {
                    tovideo = frame;
                }
                else {
                    cvtColor(frame, tovideo, COLOR_GRAY2BGR);        
                }
                video.write(tovideo);
            }
#endif // WRITE_OUTPUT_FILE
            waitKey(FRAME_INTERVAL);
            double duration_main = (clock() - start_cycle_main) / (double) CLOCKS_PER_SEC;
//            cout << "INFO: Effective FPS E2E:" << (1 / duration_main) << endl;
//            cout << "\\___________________________________________________________________/" << endl
//            << endl;
            //delete(longbuf);
        free (longbuf);
        } // while loop
    
        // When everything done, release the video capture and write object
        cap.release();
        video.release();
 
        // Closes all the windows
        destroyAllWindows();
 
#else  // !defined(PY_WRAP) || (PY_WRAP == PY_WRAP_SOBEL_FILENAME)
        //output_img = longbuf;
        memcpy( output_img, longbuf, total_size);
    free(longbuf);
#endif // !defined(PY_WRAP) || (PY_WRAP == PY_WRAP_SOBEL_FILENAME)
 
        // Destructor closes the socket
    } catch (SocketException & e) {
        cerr << e.what() << endl;
        exit(1);
    }
    
#ifndef PY_WRAP
    return 0;
#endif
}

medianBlurAccelArray()

void medianBlurAccelArray	(	ap_uint< 256 > *	img_inp,
		ap_uint< 256 > *	img_out,
		int	rows,
		int	cols
	)

medianBlurAccelMem()

void medianBlurAccelMem	(	membus_t *	img_inp,
		membus_t *	img_out,
		int	rows,
		int	cols
	)

Top-level accelerated function of the MedianBlur Application with array I/F.

Returns

Nothing.

Definition at line 222 of file xf_median_blur_accel.cpp.

                                                {
    // clang-format on
    #pragma  HLS INLINE off
 
    xf::cv::Mat<TYPE, HEIGHT, WIDTH, NPIX> imgInput(rows, cols);
    // clang-format off
    #pragma HLS stream variable=imgInput.data depth=2
    // clang-format on
 
    #ifndef FAKE_MedianBlur
    xf::cv::Mat<TYPE, HEIGHT, WIDTH, NPIX> imgOutput(rows, cols);
    // clang-format off
    #pragma HLS stream variable=imgOutput.data depth=2
    // clang-format on
    #endif
    
    // clang-format off
    #pragma HLS DATAFLOW
    // clang-format on
 
    // Feed a cv matrix from ddr memory
    xf::cv::Array2xfMat<MEMDW_512, XF_8UC1, HEIGHT, WIDTH, NPIX>(img_inp, imgInput);
    
    #ifdef FAKE_MedianBlur
    
    // Feed ddr memory from a cv matrix
    xf::cv::xfMat2Array<MEMDW_512, XF_8UC1, HEIGHT, WIDTH, NPIX>(imgInput, img_out);
    #else
    
    xf::cv::medianBlur<WINDOW_SIZE, XF_BORDER_REPLICATE, TYPE, HEIGHT, WIDTH, NPC1>(imgInput, imgOutput);    
 
    // Feed ddr memory from a cv matrix
    xf::cv::xfMat2Array<MEMDW_512, XF_8UC1, HEIGHT, WIDTH, NPIX>(imgOutput, img_out);
    
    #endif
    
    
}

medianBlurAccelStream()

void medianBlurAccelStream	(	hls::stream< ap_uint< 256 >> &	img_in_axi_stream,
		hls::stream< ap_uint< 256 >> &	img_out_axi_stream,
		int	rows,
		int	cols
	)

Top-level accelerated function of the Sobel Application with array I/Fadd SOBEL.

Returns

Nothing.

Definition at line 71 of file xf_sobel_accel.cpp.

                        {
    // clang-format on
    #pragma  HLS INLINE off
 
    xf::cv::Mat<TYPE, HEIGHT, WIDTH, NPIX> imgInput(rows, cols);
    // clang-format off
    #pragma HLS stream variable=imgInput.data depth=2
    // clang-format on
 
    xf::cv::Mat<TYPE, HEIGHT, WIDTH, NPIX> imgOutput(rows, cols);
    // clang-format off
    #pragma HLS stream variable=imgOutput.data depth=2
    // clang-format on
 
    // clang-format off
    #pragma HLS DATAFLOW
    // clang-format on
 
    accel_utils accel_utils_obj;
    
    int dstMat_cols_align_npc = ((imgInput.cols + (NPIX - 1)) >> XF_BITSHIFT(NPIX)) << XF_BITSHIFT(NPIX);
 
    accel_utils_obj.hlsStrm2xfMat<INPUT_PTR_WIDTH, TYPE, HEIGHT, WIDTH, NPIX, (HEIGHT * WIDTH) / NPIX>(img_in_axi_stream, imgInput, dstMat_cols_align_npc);
    
    xf::cv::medianBlur<WINDOW_SIZE, XF_BORDER_REPLICATE, TYPE, HEIGHT, WIDTH, NPC1>(imgInput, imgOutput);    
    
    int srcMat_cols_align_npc = ((imgOutput.cols + (NPIX - 1)) >> XF_BITSHIFT(NPIX)) << XF_BITSHIFT(NPIX);
    
    accel_utils_obj.xfMat2hlsStrm<OUTPUT_PTR_WIDTH, TYPE, HEIGHT, WIDTH, NPIX, HEIGHT*((WIDTH + NPIX - 1) / NPIX)>(imgOutput, img_out_axi_stream,
                                                                                        srcMat_cols_align_npc);    
}

print_cFpZoo()

void print_cFpZoo

(

void

)

Definition at line 57 of file sobel_host.cpp.

{
        cout <<  "                                                          " << endl;
    cout <<  "...build with:                                            " << endl;
    cout <<  " ██████╗███████╗██████╗    ███████╗ ██████╗  ██████╗      " << endl;
    cout <<  "██╔════╝██╔════╝██╔══██╗   ╚══███╔╝██╔═══██╗██╔═══██╗     " << endl;
    cout <<  "██║     █████╗  ██████╔╝     ███╔╝ ██║   ██║██║   ██║     " << endl;
    cout <<  "██║     ██╔══╝  ██╔═══╝     ███╔╝  ██║   ██║██║   ██║     " << endl;
    cout <<  "╚██████╗██║     ██║███████╗███████╗╚██████╔╝╚██████╔╝     " << endl;
    cout <<  " ╚═════╝╚═╝     ╚═╝╚══════╝╚══════╝ ╚═════╝  ╚═════╝      " << endl;
    cout <<  "A cloudFPGA project from IBM ZRL                    v1.0  " << endl;
    cout <<  "Quantitative Finance Monte-Carlo European Pricing Engine  " << endl;
}

resizeCropSquare()

void resizeCropSquare	(	const cv::Mat &	input,
		const cv::Mat &	output,
		const cv::Size &	dstSize,
		int	interpolation = INTER_LINEAR
	)

Resize an image and crop if necessary in order to keep a rectangle area in the middle of the image.

Parameters

[in]	input	A pointer to the cv::Mat input image
[out]	output	A pointer to the cv::Mat output image
[in]	Size	A pointer to the cv::Size of the output image (width, height)
[in]	interpolation	Enumerator for interpolation algorithm (imgproc.hpp)

Returns

Nothing.

Definition at line 82 of file sobel_host.cpp.

{
    int h = input.rows;
    int w = input.cols;
    int min_size = min(h, w);
    int x = w/2-min_size/2;
    int y = h/2-min_size/2;
    // printf("w=%d, h=%d, min_size=%d, x=%d, y=%d, width=%d, height=%d\n", w, h, min_size, x, y, width, height);
    cv::Mat crop_img = input(Rect(x, y, min_size, min_size));
    resize(crop_img, output, Size(dstSize.width, dstSize.height), 0, 0, interpolation);
}

sobel_accel()

void sobel_accel	(	xf::cv::Mat< XF_8UC1, 1024, 1024, XF_NPPC1 > &	_src,
		xf::cv::Mat< XF_8UC1, 1024, 1024, XF_NPPC1 > &	_dst
	)

Here is the caller graph for this function: