Function StartTestVarShape

tests/cvcuda/system/TestOpCopyMakeBorder.cpp:351–480

template<typename T>
void StartTestVarShape(int srcWidthBase, int srcHeightBase, int numBatches, int topPad, int bottomPad, int leftPad,
                       int rightPad, NVCVBorderType borderType, float4 borderValue, nvcv::ImageFormat format)
{
    cudaStream_t stream;
    ASSERT_EQ(cudaSuccess, cudaStreamCreate(&stream));

    std::default_random_engine         randEng{0};
    std::uniform_int_distribution<int> rndSrcWidth(srcWidthBase * 0.8, srcWidthBase * 1.2);
    std::uniform_int_distribution<int> rndSrcHeight(srcHeightBase * 0.8, srcHeightBase * 1.2);

    std::uniform_int_distribution<int> rndTop(topPad * 0.8, topPad * 1.2);
    std::uniform_int_distribution<int> rndBottom(bottomPad * 0.8, bottomPad * 1.2);

    std::uniform_int_distribution<int> rndLeft(leftPad * 0.8, leftPad * 1.2);
    std::uniform_int_distribution<int> rndRight(rightPad * 0.8, rightPad * 1.2);

    //Prepare input and output buffer
    std::vector<nvcv::Image>    imgSrcVec, imgDstVec;
    std::vector<std::vector<T>> hImgSrcVec, hImgDstVec, batchGoldVec;
    std::vector<int>            topVec(numBatches);
    std::vector<int>            leftVec(numBatches);
    for (int i = 0; i < numBatches; ++i)
    {
        int srcWidth  = rndSrcWidth(randEng);
        int srcHeight = rndSrcHeight(randEng);
        int top       = rndTop(randEng);
        int left      = rndLeft(randEng);
        int bottom    = rndBottom(randEng);
        int right     = rndRight(randEng);

        int dstWidth  = srcWidth + left + right;
        int dstHeight = srcHeight + top + bottom;
        topVec[i]     = top;
        leftVec[i]    = left;
        //prepare input buffers
        imgSrcVec.emplace_back(nvcv::Size2D{srcWidth, srcHeight}, format);

        auto imgSrcData   = imgSrcVec.back().exportData<nvcv::ImageDataStridedCuda>();
        int  srcStride    = imgSrcData->plane(0).rowStride;
        int  srcRowStride = srcStride / sizeof(T);
        int  srcBufSize   = srcRowStride * imgSrcData->plane(0).height;

        std::vector<T>                         srcVec(srcBufSize);
        std::uniform_int_distribution<uint8_t> srcRand{0u, 255u};
        if (std::is_same<T, float>::value)
            std::generate(srcVec.begin(), srcVec.end(), [&]() { return srcRand(randEng) / 255.0f; });
        else
            std::generate(srcVec.begin(), srcVec.end(), [&]() { return srcRand(randEng); });

        // Copy each input image with random data to the GPU
        ASSERT_EQ(cudaSuccess, cudaMemcpyAsync(imgSrcData->plane(0).basePtr, srcVec.data(), srcBufSize * sizeof(T),
                                               cudaMemcpyHostToDevice, stream));
        hImgSrcVec.push_back(std::move(srcVec));

        //prepare output Buffers
        imgDstVec.emplace_back(nvcv::Size2D{dstWidth, dstHeight}, format);
        auto imgDstData   = imgDstVec.back().exportData<nvcv::ImageDataStridedCuda>();
        int  dstStride    = imgDstData->plane(0).rowStride;