图像视图

概述

图像视图应用程序将输入图像分割成 4 个视图，以 2x2 网格排列，对每个图像视图进行不同的处理，可能并行处理并使用不同的后端。处理过程消耗相同的输入父图像，并生成单个输出，将结果作为图像文件保存在磁盘上。您可以定义要处理的输入图像。每个处理使用的后端，以及每个算法及其参数，都固定如下：

1. CPU 双边滤波
2. CPU 水平方向图像翻转
3. CUDA 垂直方向图像翻转
4. CUDA 双方向图像翻转

说明

命令行参数为：

<输入图像>

其中

• 输入图像：输入图像文件名；它接受 png、jpeg 以及可能的其他格式。

这是一个示例

• C++

  ./vpi_sample_15_image_view ../assets/kodim08.png

• Python

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

这使用了提供的示例图像之一。您可以尝试其他图像，但需遵守在每个图像视图上运行的每种算法施加的约束。

结果

输入图像	输出图像

源代码

为方便起见，以下是在 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('input', help='Image to be used as input')

args = parser.parse_args();

# Load input parent image 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")

# Create 4 streams for independent processing
streams = []
for _ in range(4)
 streams.append(vpi.Stream())

# Create input parent image and output as grayscale images in the CPU using numpy
np_parent = np.zeros((input.height, input.width), np.uint8)
np_output = np.zeros((input.height, input.width), np.uint8)

# Wrap the input parent and output using VPI, this is important
# because views on Tegra devices can only be created on wrapped CPU or
# CUDA buffers. If an image is created with vpi.Image, and there is a
# different backend available, the view cannot be created.
parent = vpi.asimage(np_parent)
output = vpi.asimage(np_output)

# Convert input parent image to grayscale
with vpi.Backend.CPU, streams[0]
 input.convert(out=parent)

# Calculate views size: width x height
viewSize = (input.width // 2, input.height // 2)

# Define clip bounds for each view
clipBounds = vpi.RectangleI(0, 0, viewSize[0], viewSize[1])

# Create 4 input and output child image views
parViews = []
outViews = []
for i in range(4)
 clipBounds.x = (i % 2) * viewSize[0]
 clipBounds.y = (i // 2) * viewSize[1]
 parViews.append(parent.view(clipBounds))
 outViews.append(output.view(clipBounds))

# Run one algorithm on each view:
# Each algorithm runs on a different stream, potentially in parallel, all streams working together
# consuming the same input to produce a single output, using CPU and CUDA backends

with vpi.Backend.CPU
 parViews[0].bilateral_filter(3, 45, 35, out=outViews[0], border=vpi.Border.ZERO, stream=streams[0])
 parViews[1].image_flip(vpi.Flip.HORIZ, out=outViews[1], stream=streams[1])

with vpi.Backend.CUDA
 parViews[2].image_flip(vpi.Flip.VERT, out=outViews[2], stream=streams[2])
 parViews[3].image_flip(vpi.Flip.BOTH, out=outViews[3], stream=streams[3])

# Sync all streams to guarantee they finish before reading the output image
for i in range(4)
 streams[i].sync()

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

#include <opencv2/core/version.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <vpi/OpenCVInterop.hpp>

#include <vpi/Event.h>
#include <vpi/Image.h>
#include <vpi/Status.h>
#include <vpi/Stream.h>
#include <vpi/algo/BilateralFilter.h>
#include <vpi/algo/ConvertImageFormat.h>
#include <vpi/algo/ImageFlip.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 imageBGR = NULL;
 VPIImage inParent = NULL;
 VPIImage outParent = NULL;
 VPIEvent parentEvent = NULL;
 VPIImage inViews[4] = {};
 VPIImage outViews[4] = {};
 VPIStream streams[4] = {};

 int retval = 0;

 // Views on Tegra devices need parent images to have only CPU or CUDA backends enabled.
 int imgFlags = VPI_BACKEND_CPU | VPI_BACKEND_CUDA;

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

 std::string strInputFileName = argv[1];

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

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

 // Retrieve the width and height of the loaded parent image
 const int parentWidth = cvImage.cols, parentHeight = cvImage.rows;

 // Calculate the width and height of the child image views
 const int viewWidth = parentWidth / 2, viewHeight = parentHeight / 2;

 if ((viewWidth == 0) || (viewHeight == 0))
 {
 throw std::runtime_error(std::string("Input image too small, it must be at least 2x2"));
 }

 // Create the input parent image as a single unsigned 8-bit channel
 CHECK_STATUS(vpiImageCreate(parentWidth, parentHeight, VPI_IMAGE_FORMAT_U8, imgFlags, &inParent));

 // Create the output parent image, single unsigned 8-bit channel
 CHECK_STATUS(vpiImageCreate(parentWidth, parentHeight, VPI_IMAGE_FORMAT_U8, imgFlags, &outParent));

 // Create 1 event for the parent image
 CHECK_STATUS(vpiEventCreate(0, &parentEvent));

 for (int i = 0; i < 4; ++i)
 {
 // Create 4 streams to execute algorithms on
 CHECK_STATUS(vpiStreamCreate(0, &streams[i]));

 // Define the clip bounds to be the rectangular region of each view inside the parent image
 VPIRectangleI clipBounds;

 clipBounds.x = static_cast<int>(i % 2) * viewWidth;
 clipBounds.y = static_cast<int>(i / 2) * viewHeight;
 clipBounds.width = viewWidth;
 clipBounds.height = viewHeight;

 // Create each input child image view
 CHECK_STATUS(vpiImageCreateView(inParent, &clipBounds, imgFlags, &inViews[i]));

 // Create each output child image view
 CHECK_STATUS(vpiImageCreateView(outParent, &clipBounds, imgFlags, &outViews[i]));
 }

 // Run one algorithm on each view:
 // Each algorithm runs on a different stream, potentially in parallel, all streams working together
 // consuming the same input to produce a single output, using CPU and CUDA backends

 // Convert the loaded parent image to grayscale
 CHECK_STATUS(vpiSubmitConvertImageFormat(streams[0], VPI_BACKEND_CPU, imageBGR, inParent, NULL));

 // Record the parent event announcing the conversion above has finished
 CHECK_STATUS(vpiEventRecord(parentEvent, streams[0]));

 // Wait the conversion above to finish, then release all streams for view processing
 CHECK_STATUS(vpiStreamWaitEvent(streams[1], parentEvent));
 CHECK_STATUS(vpiStreamWaitEvent(streams[2], parentEvent));
 CHECK_STATUS(vpiStreamWaitEvent(streams[3], parentEvent));

 // Submit an algorithm on 1st view
 CHECK_STATUS(
 vpiSubmitBilateralFilter(streams[0], VPI_BACKEND_CPU, inViews[0], outViews[0], 3, 45, 35, VPI_BORDER_ZERO));

 // Submit an algorithm on 2nd view
 CHECK_STATUS(vpiSubmitImageFlip(streams[1], VPI_BACKEND_CPU, inViews[1], outViews[1], VPI_FLIP_HORIZ));

 // Submit an algorithm on 3rd view
 CHECK_STATUS(vpiSubmitImageFlip(streams[2], VPI_BACKEND_CUDA, inViews[2], outViews[2], VPI_FLIP_VERT));

 // Submit an algorithm on 4th view
 CHECK_STATUS(vpiSubmitImageFlip(streams[3], VPI_BACKEND_CUDA, inViews[3], outViews[3], VPI_FLIP_BOTH));

 // Synchronize all streams to make sure all views finished processing
 CHECK_STATUS(vpiStreamSync(streams[0]));
 CHECK_STATUS(vpiStreamSync(streams[1]));
 CHECK_STATUS(vpiStreamSync(streams[2]));
 CHECK_STATUS(vpiStreamSync(streams[3]));

 // Retrieve the output parent image contents and write it to disk

 // Lock output parent image to retrieve its data, checking it consists of
 // host-accessible memory buffers in pitch-linear layout
 VPIImageData outData;
 CHECK_STATUS(vpiImageLockData(outParent, VPI_LOCK_READ, VPI_IMAGE_BUFFER_HOST_PITCH_LINEAR, &outData));
 assert(outData.bufferType == VPI_IMAGE_BUFFER_HOST_PITCH_LINEAR);

 cv::Mat cvOut;
 vpiImageDataExportOpenCVMat(outData, &cvOut);
 imwrite("output_views.png", cvOut);

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

 // Clean up

 // Make sure all streams are synchronized before destroying the objects possibly in use
 for (int i = 0; i < 4; ++i)
 {
 if (streams[i] != NULL)
 {
 vpiStreamSync(streams[i]);
 }
 }

 // Make sure to destroy all views before destroying their parents
 for (int i = 0; i < 4; ++i)
 {
 vpiStreamDestroy(streams[i]);

 vpiImageDestroy(inViews[i]);
 vpiImageDestroy(outViews[i]);
 }

 vpiEventDestroy(parentEvent);

 vpiImageDestroy(imageBGR);
 vpiImageDestroy(inParent);
 vpiImageDestroy(outParent);

 return retval;
}