1

我正在尝试在 Vivado HLS 中实现连接组件标记算法。这是我正在使用的算法的链接：两遍连接组件标记算法。

我在Vivado HLS中使用3x3 窗口并将该窗口发送到我的连接对象算法函数。此函数根据算法返回单个像素并将其存储到目标图像并在连续像素到来时附加它们。但是，在处理下一个窗口时，它忽略了前一个操作的结果，而算法要求它与前一个输出像素进行比较。

我需要找到一种方法来考虑该像素或更改目标图像本身。

这是我的代码：

连接.cpp

#include "CONN.h"
int label=50;
int min;

MY_PIXEL find_conn(MY_WINDOW *window)
{


      unsigned char west, north, northWest, northEast, south, east, southEast, southWest=0;


    MY_PIXEL pixel;

      char i=0;
      char j=0;





//            pixel.val[0]=window->getval(i,j);     //to make copy of original image.

               west=window->getval(i+1,j);
               northWest=window->getval(i,j);
               north=window->getval(i,j+1);
               northEast=window->getval(i,j+2);

               if(window->getval(i+1,j+1)!=0){

                   min=9600;

                   if(west!=0||north!=0||northWest!=0||northEast!=0){

                       if(west<min && west!=0)          min=west;
                       if(northWest<min && north!=0)    min=northWest;
                       if(north<min && north!=0)        min=north;
                       if(northEast!=0 && northEast!=0) min=northEast;

                       window->insert(min,i+1,j+1);
                   }
                   else
                   {
                       label= label+10;
                       window->insert(label,i+1,j+1);
                   }


                   }



          pixel.val[0]=window->getval(i+1,j+1);


      return pixel;
}






void created_window(MY_IMAGE& src, MY_IMAGE& dst, int rows, int cols)
{
  MY_BUFFER buff_A;
  MY_WINDOW WINDOW_3x3;

  for(int row = 0; row < rows+1; row++){
    for(int col = 0; col < cols+1; col++){
#pragma HLS loop_flatten off
#pragma HLS dependence variable=&buff_A false
#pragma HLS PIPELINE II = 1

      // Temp values are used to reduce the number of memory reads
      unsigned char temp;
      MY_PIXEL tempx;

      //Line Buffer fill
      if(col < cols){
          buff_A.shift_down(col);
          temp = buff_A.getval(0,col);
      }

      //There is an offset to accommodate the active pixel region
      //There are only MAX_WIDTH and MAX_HEIGHT valid pixels in the image
      if(col < cols && row < rows){
          MY_PIXEL new_pix;
          src >> new_pix;
          tempx = new_pix;
          buff_A.insert_bottom(tempx.val[0],col);
      }

      //Shift the processing window to make room for the new column
      WINDOW_3x3.shift_right();

      //The processing window only needs to store luminance values
      //rgb2y function computes the luminance from the color pixel
      if(col < cols){
          WINDOW_3x3.insert(buff_A.getval(2,col),2,0);
          WINDOW_3x3.insert(temp,1,0);
          WINDOW_3x3.insert(tempx.val[0],0,0);
      }
      MY_PIXEL conn_obj;


      //The operator only works on the inner part of the image
      //This design assumes there are no connected objects on the boundary of the image


          conn_obj = find_conn(&WINDOW_3x3);


      //The output image is offset from the input to account for the line buffer
      if(row > 0 && col > 0) {
          dst << conn_obj;
      }
    }
  }
}






void create_window(AXI_STREAM& video_in, AXI_STREAM& video_out, int rows, int cols)
{
    //Create AXI streaming interfaces for the core
#pragma HLS INTERFACE axis port=video_in bundle=INPUT_STREAM
#pragma HLS INTERFACE axis port=video_out bundle=OUTPUT_STREAM

#pragma HLS INTERFACE s_axilite port=rows bundle=CONTROL_BUS offset=0x14
#pragma HLS INTERFACE s_axilite port=cols bundle=CONTROL_BUS offset=0x1C
#pragma HLS INTERFACE s_axilite port=return bundle=CONTROL_BUS

#pragma HLS INTERFACE ap_stable port=rows
#pragma HLS INTERFACE ap_stable port=cols


    MY_IMAGE img_0(rows, cols);
    MY_IMAGE img_1(rows, cols);

#pragma HLS dataflow
    hls::AXIvideo2Mat(video_in, img_0);
    created_window(img_0, img_1, rows, cols);
    hls::Mat2AXIvideo(img_0, video_out);
}

连接器

#ifndef _TOP_H_
#define _TOP_H_

#include "hls_video.h"


#define MAX_WIDTH  320
#define MAX_HEIGHT 240

typedef hls::stream<ap_axiu<8,1,1,1> >               AXI_STREAM;
typedef hls::Scalar<1, unsigned char>                 MY_PIXEL;
typedef hls::Mat<MAX_HEIGHT, MAX_WIDTH, HLS_8UC1>     MY_IMAGE;

typedef hls::Window<3, 3, unsigned char>              MY_WINDOW;
typedef hls::LineBuffer<3, MAX_WIDTH, unsigned char>  MY_BUFFER;

void create_window(AXI_STREAM& INPUT_STREAM, AXI_STREAM& OUTPUT_STREAM, int rows, int cols);

#endif

按照这里的要求是我的main.c

#include "CONN.h"
#include <hls_video.h>
#include <hls_opencv.h>

#define INPUT_FILE "D:/TRACKING PRADNAYA/test_image/test_conn.jpg"
#define OUTPUT_FILE "D:/TRACKING PRADNAYA/test_image/test_conn_out.jpg"

int main(){
    cv::Mat inputMat(MAX_HEIGHT, MAX_WIDTH, CV_8UC1);
    cv::Mat outputMat(MAX_HEIGHT, MAX_WIDTH, CV_8UC1);

    inputMat = cv::imread(INPUT_FILE, CV_LOAD_IMAGE_GRAYSCALE);


    AXI_STREAM inStream_1;

    AXI_STREAM outStream_conn;


        cvMat2AXIvideo(inputMat, inStream_1);


        create_window(inStream_1, outStream_conn, inputMat.rows, inputMat.cols);

        AXIvideo2cvMat(outStream_conn, outputMat);


    cv::imwrite(OUTPUT_FILE, outputMat );


    return 0;
}
4

0 回答 0