Python API

VPI exposes a Python API that offers a simplified way to use the library, leading to faster development cycle. Resource management is done automatically under the hood, allowing the developer to focus on the definition of the image processing pipeline.

Requirements

• Ubuntu 16.04 or 18.04
• python 2.7 or 3.6
• numpy >= 1.11.0
• pillow >= 3.1.2

Install the Python 2.7 packages using:

apt-get install python python-pil python-numpy

If using Python 3.6, install the following packages:

apt-get install python3 python3-pil python3-numpy

Writing an Image Blurring Application

Copy the code below to a file named main.py. The comments explain how it works.

import vpi
 
import numpy as np
from PIL import Image
from argparse import ArgumentParser
 
# 2. Parse command line parameters
# -----------------------------------------------------------------------------
parser = ArgumentParser()
parser.add_argument('input',
                    help='Image to be used as input')
args = parser.parse_args();
 
# 3. Load input and wrap it into a VPI image.
# -----------------------------------------------------------------------------
 
# `Image.open` returns a Pillow image that is then interpreted as
# a numpy array. This array is finally wrapped in a VPI image suitable
# for use by VPI algorithms.
input = vpi.asimage(np.asarray(Image.open(args.input)))
 
# 4. Convert it to grayscale and blur it with a 5x5 box filter
#    with ZERO border condition.
# -----------------------------------------------------------------------------
 
# Enabling the CUDA backend in a python context like done below makes
# VPI algorithms use CUDA for execution by default. This can be overriden
# if needed by specifying the parameter `backend=` when calling the algorithm.
with vpi.Backend.CUDA:
    # `image.convert` will return a new VPI image with the desired format, in
    # this case U8 (grayscale, 8-bit unsigned pixels).
    # Algorithms returning a new VPI image allows for chaining operations like
    # done below, as the result of the conversion is then filtered.
    # The end result is finally stored in a new `output` VPI image.
    output = input.convert(vpi.Format.U8) \
                  .box_filter(5, border=vpi.Border.ZERO)
 
# 5. Save result to disk
# -----------------------------------------------------------------------------
 
# The read-lock context enabled below makes sure all processing is finished and
# results are stored in `output`.
with output.rlock():
    # `output.cpu()` returns a numpy array view (not a copy) of `output`
    # contents, accessible by host (cpu). 
    # The numpy array is then converted into a Pillo image and saved
    # to the disk
    Image.fromarray(output.cpu()).save('tutorial_blurred_python.png')
 
# vim: ts=8:sw=4:sts=4:et:ai

Testing the Application

With everything set in place, if you're using python 2.7, execute the script as follows:

python main.py <image file name>

substituting <image file name> by some image on disk.

To use python 3.6, substitute python with python3:

python3 main.py <image file name>