Функциональная задача такая - на вход поступает изображение, матрицы RGB. Пусть пока это одна матрица I (требуемый порядок - 640x480). Из этой матрицы получается две градиентные матрицы - по x (Ix) и по y (Iy). После этого из этих градиентных матриц строится матрица Харриса по формуле выше.

Собственно, всё. Условно я вижу это в железе как проводки идущие от двух ячеек исходной матрицы через сумматор к одной ячейке градиентных матриц. И также от нескольких ячеек градиентных матриц - к одной ячейке матрицы Харриса (свёртка). Всё это должно выполняться параллельно и потому быстро :).

// ASSIGNES //
assign end_load_w = ( int_bytes_loaded == P_IMAGE_ROWS * P_IMAGE_COLS - 1 );
assign end_grad_w = ( int_grad == P_IMAGE_ROWS * P_IMAGE_COLS  );
assign end_harris_w = ( int_harris == P_HARRIS_SIZE );
<...>;
// END ASSIGNES //

/ ALWAYS-BLOCKS //
// ** RESET & LOAD & DBOUTPUT ** //
always @( posedge CLK or posedge RESET ) begin
    if( RESET ) <начальная иницализация>;
    else if( IN_1_BTN_CLICK && !end_load_w ) begin
        mem_image[ int_bytes_loaded ] <= IN_8_IMAGE;
        int_bytes_loaded <= int_bytes_loaded + 1;
        DB_OUT_7_LED_r <= int_bytes_loaded;
    end
    else <после окончания преобразования вывод результата>;
end
// ** GRADIENT & HARRIS ROUTINE ** //
always @( posedge CLK or posedge RESET ) begin
    if( RESET ) <начальная инициализация>
    else if( end_load_w && !end_grad_w && !end_harris_w  )
        for( int_xi = 0; int_xi < P_IMAGE_COLS; int_xi = int_xi + 1 )
            for( int_yi = 0; int_yi < P_IMAGE_ROWS; int_yi = int_yi + 1 )
                if( int_grad != P_IMAGE_ROWS * P_IMAGE_COLS ) begin
                    mem_image_x[ int_xi + P_IMAGE_COLS*int_yi ] = <разность по x>;
                    mem_image_y[ int_xi + P_IMAGE_COLS*int_yi ] = <разность по y>;
                    int_grad = int_grad + 1;
                end
                else;
    else if( end_load_w && end_grad_w && end_db_output_w && !end_harris_w )
        for( int_xi_2 = P_RADIUS; int_xi_2 < ( P_IMAGE_COLS - P_RADIUS ); int_xi_2 = int_xi_2 + 1 )
            for( int_yi_2 = P_RADIUS; int_yi_2 < ( P_IMAGE_ROWS - P_RADIUS ); int_yi_2 = int_yi_2 + 1 )
                if( int_harris != P_HARRIS_SIZE ) begin
                    mem_harris[ <адрес блока памяти> ] = f_harris_block( int_xi_2, int_yi_2 );
                    int_harris = int_harris + 1;
                end
                else;
    else;
end
<...>;
// END ALWAYS-BLOCKS //

// FUNCTIONS //
// ** TABLE SQRT ** //
function integer f_my_sqrt;
    input integer f_int_x;
    
    case( f_int_x )
        0: f_my_sqrt = 0;
        3: f_my_sqrt = 1;
        4: f_my_sqrt = 2;
        default: f_my_sqrt = 255;
    endcase
endfunction
// ** HARRIS BLOCK ** //
function integer f_harris_block;
    // FARGUMENTS //
    input integer f_int_x;
    input integer f_int_y;
    // FVARIABLES //
    integer f_int_ki;
    integer f_int_ri;
    integer f_int_xx;
    integer f_int_xy;
    integer f_int_yy;
    
    begin
        f_int_xx = 0;
        f_int_xy = 0;
        f_int_yy = 0;
        for( f_int_ki = -P_RADIUS; f_int_ki <= P_RADIUS; f_int_ki = f_int_ki + 1)
            for( f_int_ri = -P_RADIUS; f_int_ri <= P_RADIUS; f_int_ri = f_int_ri + 1 )
            begin
                if( `_ABS( f_int_ri ) <= f_my_sqrt( `_SQR( P_RADIUS ) - `_SQR( f_int_ki ) ) ) begin
                    f_int_xx = f_int_xx + <mem_image_x * mem_image_x>;
                    f_int_xy = f_int_xy + <mem_image_x * mem_image_y>;
                    f_int_yy = f_int_yy + <mem_image_y * mem_image_y>;
                end
                else;
            end
        f_harris_block = f_int_xx + f_int_xy + f_int_yy;
    end
endfunction
// END FUNCTIONS //

Timing Summary:
---------------
Speed Grade: -4

   Minimum period: 206.584ns (Maximum Frequency: 4.841MHz)
   Minimum input arrival time before clock: 2.793ns
   Maximum output required time after clock: 4.310ns
   Maximum combinational path delay: No path found