Function ResizeCropConvert

tests/cvcuda/system/TestOpResizeCropConvertReformat.cpp:77–172

template<typename DstT, typename SrcT>
void ResizeCropConvert(      DstT *dst, NVCVSize2D dstSize, nvcv::ImageFormat dstFrmt,
                       const SrcT *src, NVCVSize2D srcSize, nvcv::ImageFormat srcFrmt,
                       int numImages, NVCVSize2D newSize, int2 crop, NVCVInterpolationType interp,
                       const NVCVChannelManip manip, float scale, float offset, bool srcCast = true)
{
    int channels  = dstFrmt.numChannels();
    int srcPlanes = srcFrmt.numPlanes();
    int dstPlanes = dstFrmt.numPlanes();

    size_t srcIncrX = channels / srcPlanes; // 1 if planar; channels if not.
    size_t dstIncrX = channels / dstPlanes; // 1 if planar; channels if not.
    size_t srcIncrY = srcIncrX * srcSize.w;
    size_t dstIncrY = dstIncrX * dstSize.w;
    size_t srcIncrC = (srcPlanes > 1 ? srcSize.w * srcSize.h : 1);
    size_t dstIncrC = (dstPlanes > 1 ? dstSize.w * dstSize.h : 1);
    size_t srcIncrN = srcSize.w * srcSize.h * channels;
    size_t dstIncrN = dstSize.w * dstSize.h * channels;

    int mapC[4] = {0, 1, 2, 3};

    if (manip == NVCV_CHANNEL_REVERSE)
    {
        for (int c = 0; c < channels; ++c) mapC[c] = channels - c - 1;
    }

    float scaleW = static_cast<float>(srcSize.w) / newSize.w;
    float scaleH = static_cast<float>(srcSize.h) / newSize.h;

    for (int i = 0; i < numImages; i++)
    {
        const SrcT *srcBase = src + i * srcIncrN;
        DstT       *dstBase = dst + i * dstIncrN;

        for (int dy = 0; dy < dstSize.h; dy++)
        {
            DstT *dstRow = dstBase + dy * dstIncrY;

            for (int dx = 0; dx < dstSize.w; dx++)
            {
                DstT *dstPtr = dstRow + dx * dstIncrX;

                if (interp == NVCV_INTERP_NEAREST)
                {
                    int sx = std::floor(scaleW * (dx + crop.x + 0.5f));
                    int sy = std::floor(scaleH * (dy + crop.y + 0.5f));

                    const SrcT *src0 = srcBase + sy * srcIncrY + sx * srcIncrX;

                    for (int c = 0; c < channels; c++)
                    {
                        dstPtr[mapC[c] * dstIncrC] = cuda::SaturateCast<DstT>(scale * src0[c * srcIncrC] + offset);
                    }
                }
                else if (interp == NVCV_INTERP_LINEAR)
                {
                    float fx = scaleW * (dx + crop.x + 0.5f) - 0.5f;
                    float fy = scaleH * (dy + crop.y + 0.5f) - 0.5f;