• English
  • 3.9.0

    • Resize

    The Resize operator is used to resize the picture by interpolating the algorithm and scaling the picture to the target size according to the user's needs.

    Operator Effect

    Input ImageParameterOutput Image
    imagexscale = 1.5
    yscale = 1.5
    interp = HB_VP_INTER_LINEAR    		image

    Principle

    The operator is formulated as follows, with different implementation details depending on the interpolation algorithm:

    {dstwidth=xscale∗srcwidthdstheight=yscale∗srcheight\begin{aligned}\begin{cases}dst_{width}=xscale*src_{width}\\dst_{height}=yscale*src_{height}\end{cases}\end{aligned}

    For the bilinear interpolation method, the pixel mapping principle is as follows:

    image

    dst(x,y)=Q∗(1−b)+R∗bdst(x,y)=Q*(1-b)+R*b

    Q=src(m,n)∗(1−a)+src(m,n+1)∗aQ=src(m,n)*(1-a)+src(m,n+1)*a

    R=src(m+1,n)∗(1−a)+src(m+1,n+1)∗aR=src(m+1,n)*(1-a)+src(m+1,n+1)*a

    Among them, srcsrc is the input image, dstdst is the output image, and m,n,x,ym,n,x,y are the pixel point coordinates.

    For the nearest neighbor interpolation method, the pixel mapping principle is as follows:

    {srcx=xscale∗dstxsrcy=yscale∗dsty\begin{aligned}\begin{cases}src_x=xscale*dst_x\\src_y=yscale*dst_y\end{cases}\end{aligned}

    Among them, x,yx,y are the coordinates of the picture.

    API Interface

    int32_t hbVPResize(hbUCPTaskHandle_t *taskHandle, 
                   hbVPImage *dstImg, 
                   hbVPImage const *srcImg,
                   hbVPInterpolationType interpolation);

    For detailed interface information, please refer to hbVPResize.

    Usage

    // Include the header
#include "hobot/hb_ucp.h"
#include "hobot/vp/hb_vp.h"
#include "hobot/vp/hb_vp_resize.h"

// init Image, allocate memory for image data
hbUCPSysMem src_mem;
hbUCPMallocCached(&src_mem, src_stride * src_height, 0);
hbVPImage src_img{HB_VP_IMAGE_FORMAT_Y,
                  HB_VP_IMAGE_TYPE_U8C1,
                  src_width,
                  src_height,
                  src_stride,
                  src_mem.virAddr,
                  src_mem.phyAddr,
                  nullptr,
                  0,
                  0};

hbUCPSysMem dst_mem;
hbUCPMallocCached(&dst_mem, dst_stride * dst_height, 0);
hbVPImage dst_img{HB_VP_IMAGE_FORMAT_Y,
                  HB_VP_IMAGE_TYPE_U8C1,
                  dst_width,
                  dst_height,
                  dst_stride,
                  dst_mem.virAddr,
                  dst_mem.phyAddr,
                  nullptr,
                  0,
                  0};

// init param
hbVPInterpolationType interp{HB_VP_INTER_LINEAR};

// init task handle and schedule param
hbUCPTaskHandle_t task_handle{nullptr};
hbUCPSchedParam sched_param;
HB_UCP_INITIALIZE_SCHED_PARAM(&sched_param);
sched_param.backend = HB_UCP_DSP_CORE_0;

// create task
hbVPResize(&task_handle, &dst_img, &src_img, interp);

// submit task
hbUCPSubmitTask(task_handle, &sched_param);

// wait for task done 
hbUCPWaitTaskDone(task_handle, 0);

// release task handle
hbUCPReleaseTask(task_handle);

// release memory
hbUCPFree(&src_mem);
hbUCPFree(&dst_mem);