图像重采样

概述

Rescale 应用程序通过首先应用低通滤波器以避免混叠，然后进行降采样来重新调整输入图像的大小。生成的图像具有输入图像宽度的一半和高度的三分之一。然后将结果保存到磁盘。

说明

命令行参数为

<backend> <input image>

其中

• backend: 可以是 cpu、cuda 或 vic；它定义了执行处理的后端。
• input image: 要进行降采样的输入图像文件名，它接受 png、jpeg 以及可能的其他格式。

这是一个示例

• C++

  ./vpi_sample_04_rescale cuda ../assets/kodim08.png

• Python

  python3 main.py cuda ../assets/kodim08.png

这是使用 CUDA 后端和提供的示例图像之一。您可以尝试使用其他图像，但需遵守算法施加的约束。

结果

输入图像	输出图像，已降采样

源代码

为了方便起见，以下代码也安装在示例目录中。

语言 C++ Python

import sys
import vpi
import numpy as np
from PIL import Image
from argparse import ArgumentParser

# Parse command line arguments
parser = ArgumentParser()
parser.add_argument('backend', choices=['cpu','cuda','vic'],
 help='Backend to be used for processing')

parser.add_argument('input',
 help='Image to be used as input')

args = parser.parse_args();

if args.backend == 'cpu'
 backend = vpi.Backend.CPU
elif args.backend == 'cuda'
 backend = vpi.Backend.CUDA
else
 assert args.backend == 'vic'
 backend = vpi.Backend.VIC

# Load input into a vpi.Image
try
 input = vpi.asimage(np.asarray(Image.open(args.input)))
except IOError
 sys.exit("Input file not found")
except
 sys.exit("Error with input file")

# Using the chosen backend,
with backend
 # First convert input to NV12_ER.
 # We're overriding the default backend with CUDA.
 temp = input.convert(vpi.Format.NV12_ER, backend=vpi.Backend.CUDA)

 # Rescale the image using the chosen backend
 temp = temp.rescale((input.width//2, input.height//3))

 # Convert result back to input's format
 output = temp.convert(input.format, backend=vpi.Backend.CUDA)

# Save result to disk
Image.fromarray(output.cpu()).save('scaled_python'+str(sys.version_info[0])+'_'+args.backend+'.png')

#include <opencv2/core/version.hpp>
#if CV_MAJOR_VERSION >= 3
# include <opencv2/imgcodecs.hpp>
#else
# include <opencv2/highgui/highgui.hpp>
#endif

#include <vpi/OpenCVInterop.hpp>

#include <vpi/Image.h>
#include <vpi/Status.h>
#include <vpi/Stream.h>
#include <vpi/algo/ConvertImageFormat.h>
#include <vpi/algo/Rescale.h>

#include <cassert>
#include <cstring> // for memset
#include <iostream>
#include <sstream>

#define CHECK_STATUS(STMT) \
 do \
 { \
 VPIStatus status = (STMT); \
 if (status != VPI_SUCCESS) \
 { \
 char buffer[VPI_MAX_STATUS_MESSAGE_LENGTH]; \
 vpiGetLastStatusMessage(buffer, sizeof(buffer)); \
 std::ostringstream ss; \
 ss << vpiStatusGetName(status) << ": " << buffer; \
 throw std::runtime_error(ss.str()); \
 } \
 } while (0);

int main(int argc, char *argv[])
{
 // OpenCV image that will be wrapped by a VPIImage.
 // Define it here so that it's destroyed *after* wrapper is destroyed
 cv::Mat cvImage;

 // VPI objects that will be used
 VPIImage image = NULL;
 VPIImage imageNV12 = NULL;
 VPIImage outputNV12 = NULL;
 VPIImage output = NULL;
 VPIStream stream = NULL;

 int retval = 0;

 try
 {
 if (argc != 3)
 {
 throw std::runtime_error(std::string("Usage: ") + argv[0] + " <cpu|vic|cuda> <input image>");
 }

 std::string strBackend = argv[1];
 std::string strInputFileName = argv[2];

 // Load the input image
 cvImage = cv::imread(strInputFileName);
 if (cvImage.empty())
 {
 throw std::runtime_error("Can't open '" + strInputFileName + "'");
 }

 assert(cvImage.type() == CV_8UC3);

 // Now parse the backend
 VPIBackend backend;

 if (strBackend == "cpu")
 {
 backend = VPI_BACKEND_CPU;
 }
 else if (strBackend == "cuda")
 {
 backend = VPI_BACKEND_CUDA;
 }
 else if (strBackend == "vic")
 {
 backend = VPI_BACKEND_VIC;
 }
 else
 {
 throw std::runtime_error("Backend '" + strBackend + "' not recognized, it must be either cpu, cuda or vic");
 }

 // 1. Initialization phase ---------------------------------------

 // Create the stream for the given backend. We'll also enable CUDA for gaussian filter.
 CHECK_STATUS(vpiStreamCreate(backend | VPI_BACKEND_CUDA, &stream));

 // We now wrap the loaded image into a VPIImage object to be used by VPI.
 // VPI won't make a copy of it, so the original
 // image must be in scope at all times.
 CHECK_STATUS(vpiImageCreateWrapperOpenCVMat(cvImage, 0, &image));

 // Create a temporary image to hold the input converted to NV12.
 CHECK_STATUS(vpiImageCreate(cvImage.cols, cvImage.rows, VPI_IMAGE_FORMAT_NV12_ER, 0, &imageNV12));

 // Now create the output image.
 CHECK_STATUS(vpiImageCreate(cvImage.cols / 2, cvImage.rows / 3, VPI_IMAGE_FORMAT_NV12_ER, 0, &outputNV12));

 // And the output image converted back to BGR8
 CHECK_STATUS(vpiImageCreate(cvImage.cols / 2, cvImage.rows / 3, VPI_IMAGE_FORMAT_BGR8, 0, &output));

 // 2. Computation phase ---------------------------------------

 // Convert input from BGR8 to NV12
 CHECK_STATUS(vpiSubmitConvertImageFormat(stream, VPI_BACKEND_CUDA, image, imageNV12, NULL));

 // Now we downsample
 CHECK_STATUS(vpiSubmitRescale(stream, backend, imageNV12, outputNV12, VPI_INTERP_LINEAR, VPI_BORDER_CLAMP, 0));

 // Finally, convert the result back to BGR8
 CHECK_STATUS(vpiSubmitConvertImageFormat(stream, VPI_BACKEND_CUDA, outputNV12, output, NULL));

 // Wait until the algorithm finishes processing
 CHECK_STATUS(vpiStreamSync(stream));

 // Now let's retrieve the output image contents and output it to disk
 {
 // Lock output image to retrieve its data on cpu memory
 VPIImageData outData;
 CHECK_STATUS(vpiImageLockData(output, VPI_LOCK_READ, VPI_IMAGE_BUFFER_HOST_PITCH_LINEAR, &outData));

 // Returned data consists of host-accessible memory buffers in pitch-linear layout.
 assert(outData.bufferType == VPI_IMAGE_BUFFER_HOST_PITCH_LINEAR);

 VPIImageBufferPitchLinear &outDataPitch = outData.buffer.pitch;

 cv::Mat cvOut(outDataPitch.planes[0].height, outDataPitch.planes[0].width, CV_8UC3,
 outDataPitch.planes[0].data, outDataPitch.planes[0].pitchBytes);
 imwrite("scaled_" + strBackend + ".png", cvOut);

 // Done handling output image, don't forget to unlock it.
 CHECK_STATUS(vpiImageUnlock(output));
 }
 }
 catch (std::exception &e)
 {
 std::cerr << e.what() << std::endl;
 retval = 1;
 }

 // Clean up

 // Make sure stream is synchronized before destroying the objects
 // that might still be in use.
 vpiStreamSync(stream);

 vpiImageDestroy(image);
 vpiImageDestroy(imageNV12);
 vpiImageDestroy(output);
 vpiStreamDestroy(stream);

 return retval;
}