2D 图像卷积

概述

2D 图像卷积应用程序输出一个包含输入图像边缘的图像，并将结果保存为磁盘上的图像文件。您可以定义将用于处理的后端。

注意

输出将为灰度图像，因为卷积目前仅支持单通道图像。

说明

命令行参数为

<backend> <input image>

其中

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

这是一个示例

• C++

  ./vpi_sample_01_convolve_2d cpu ../assets/kodim08.png

• Python

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

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

结果

输入图像	输出图像，边缘

源代码

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

语言 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','pva'],
 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 == 'pva'
 backend = vpi.Backend.PVA

# 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")

# Convert it to grayscale
input = input.convert(vpi.Format.U8, backend=vpi.Backend.CUDA)

# Define a simple edge detection kernel
kernel = [[ 1, 0, -1],
 [ 0, 0, 0],
 [-1, 0, 1]]

# Using the chosen backend,
with backend
 # Run input through the convolution filter
 output = input.convolution(kernel, border=vpi.Border.ZERO)

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

#include <opencv2/core/version.hpp>
#include <opencv2/imgproc/imgproc.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/Convolution.h>

#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 imageBGR = NULL;
 VPIImage gradient = NULL;
 VPIStream stream = NULL;

 int retval = 0;

 try
 {
 if (argc != 3)
 {
 throw std::runtime_error(std::string("Usage: ") + argv[0] + " <cpu|pva|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 + "'");
 }

 // We can't use cv::IMREAD_GRAYSCALE when opening the input file because the
 // color to grayscale conversion used differs between OpenCV-2.4 and OpenCV>=3.0,
 // yielding different image content.

 // Now parse the backend
 VPIBackend backend;

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

 // Create the stream for any backend.
 CHECK_STATUS(vpiStreamCreate(0, &stream));

 // We now wrap the loaded image into a VPIImage object to be used by VPI.
 CHECK_STATUS(vpiImageCreateWrapperOpenCVMat(cvImage, 0, &imageBGR));

 // Now create the input image as a single unsigned 8-bit channel
 CHECK_STATUS(vpiImageCreate(cvImage.cols, cvImage.rows, VPI_IMAGE_FORMAT_U8, 0, &image));

 // Convert the loaded image to grayscale
 CHECK_STATUS(vpiSubmitConvertImageFormat(stream, VPI_BACKEND_CUDA, imageBGR, image, NULL));

 // Now create the output image, single unsigned 8-bit channel.
 CHECK_STATUS(vpiImageCreate(cvImage.cols, cvImage.rows, VPI_IMAGE_FORMAT_U8, 0, &gradient));

 // Define the convolution filter, a simple edge detector.
 float kernel[3 * 3] = {1, 0, -1, 0, 0, 0, -1, 0, 1};

 // Submit it for processing passing the input image the result image that will store the gradient.
 CHECK_STATUS(vpiSubmitConvolution(stream, backend, image, gradient, kernel, 3, 3, VPI_BORDER_ZERO));

 // 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.
 VPIImageData outData;
 CHECK_STATUS(vpiImageLockData(gradient, 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);

 const VPIImageBufferPitchLinear &outPitch = outData.buffer.pitch;

 cv::Mat cvOut(outPitch.planes[0].height, outPitch.planes[0].width, CV_8UC1, outPitch.planes[0].data,
 outPitch.planes[0].pitchBytes);
 imwrite("edges_" + strBackend + ".png", cvOut);

 // Done handling output image, don't forget to unlock it.
 CHECK_STATUS(vpiImageUnlock(gradient));
 }
 }
 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.
 if (stream != NULL)
 {
 vpiStreamSync(stream);
 }

 vpiImageDestroy(image);
 vpiImageDestroy(imageBGR);
 vpiImageDestroy(gradient);

 vpiStreamDestroy(stream);

 return retval;
}