[openvx] VX for basic use of objects_ convolution

1. Program source code

#include <iostream>
#include <VX/vx.h>

void print_convolution(vx_convolution convolution, const char *message)
{
    
    std::cout << "===============================" << std::endl;
    std::cout << message << std::endl;

    vx_size rows;
    vxQueryConvolution(convolution, (vx_enum)VX_CONVOLUTION_ROWS, &rows, sizeof(rows));

    vx_size cols;
    vxQueryConvolution(convolution, (vx_enum)VX_CONVOLUTION_COLUMNS, &cols, sizeof(cols));

    vx_uint32 scale;
    vxQueryConvolution(convolution, (vx_enum)VX_CONVOLUTION_SCALE, &scale, sizeof(scale));

    vx_size size;
    vxQueryConvolution(convolution, (vx_enum)VX_CONVOLUTION_SIZE, &size, sizeof(size));

    std::cout << "rows : " << rows << std::endl;
    std::cout << "cols : " << cols << std::endl;
    std::cout << "scale : " << scale << std::endl;
    std::cout << "size : " << size << std::endl;
    std::cout << "item size : " << size / (rows * cols) << std::endl;

    void* buffer = malloc(size);
    //  In user memory , Convolution coefficients are stored in the form of row spindles 
    vxCopyConvolutionCoefficients(convolution, buffer, VX_READ_ONLY, VX_MEMORY_TYPE_HOST);
    std::cout << "convolution coefficients" << std::endl;
    for (int row = 0; row < rows; ++row) {
    
        std::cout << "\t";
        for (int col = 0; col < cols; ++col) {
    
            std::cout << ((vx_int16*)buffer)[row * cols + col] << "\t";
        }
        std::cout << std::endl;
    }
    free(buffer);
}

int main(int argc, char *argv[])
{
    
    (void) argc;
    (void) argv;

    vx_status status;
    vx_context context = vxCreateContext();

    //  Parameters  columns  And  rows  Must be base , And within the scope  [3, VX_CONTEXT_CONVOLUTION_MAX_DIMENSION)
    vx_size cols = 7U;
    vx_size rows = 5U;
    vx_convolution convolution = vxCreateConvolution(context, cols, rows);
    print_convolution(convolution, "create");

    //  Update elements 
    vx_int16 *coefficients = (vx_int16*)malloc(rows * cols * sizeof (vx_int16));
    for (int i = 0; i < rows * cols; ++i) {
    
        coefficients[i] = i;
    }
    vxCopyConvolutionCoefficients(convolution, coefficients, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST);
    print_convolution(convolution, "update items");

    //  Set properties 
    vx_uint32 scale = 2;
    vxSetConvolutionAttribute(convolution, (vx_enum)VX_CONVOLUTION_SCALE, &scale, sizeof (scale));
    print_convolution(convolution, "update scale");

    free(coefficients);
    vxReleaseConvolution(&convolution);

    vxReleaseContext(&context);
    return EXIT_SUCCESS;
}

2. Running results

===============================
create
rows : 5
cols : 7
scale : 1
size : 70
item size : 2
convolution coefficients
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0

===============================
update items
rows : 5
cols : 7
scale : 1
size : 70
item size : 2
convolution coefficients
0 1 2 3 4 5 6
7 8 9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30 31 32 33 34

===============================
update scale
rows : 5
cols : 7
scale : 2
size : 70
item size : 2
convolution coefficients
0 1 2 3 4 5 6
7 8 9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30 31 32 33 34