Retrieving images

<< return to examples index

This section contains examples showing how to get images from NAO’s cameras, and how to visualize them with PIL or PyQt.

Get an image

This example gets an image on the robot.

# -*- coding: utf-8 -*-

# This is just an example script that shows how images can be accessed
# through ALVideoDevice in python.
# Nothing interesting is done with the images in this example.

from naoqi import ALProxy
import vision_definitions

IP = "nao.local"  # Replace here with your NAOqi's IP address.
PORT = 9559

# Create proxy on ALVideoDevice

print "Creating ALVideoDevice proxy to ", IP

camProxy = ALProxy("ALVideoDevice", IP, PORT)

# Register a Generic Video Module

resolution = vision_definitions.kQVGA
colorSpace = vision_definitions.kYUVColorSpace
fps = 30

nameId = camProxy.subscribe("python_GVM", resolution, colorSpace, fps)
print nameId

print 'getting images in local'
for i in range(0, 20):

resolution = vision_definitions.kQQVGA
camProxy.setResolution(nameId, resolution)

print 'getting images in remote'
for i in range(0, 20):


print 'end of gvm_getImageLocal python script'

Visualize an image using PIL

Get one image from NAO, then display it using PIL.

# Get an image from NAO. Display it and save it using PIL.

import sys
import time

# Python Image Library
import Image

from naoqi import ALProxy

def showNaoImage(IP, PORT):
  First get an image from Nao, then show it on the screen with PIL.

  camProxy = ALProxy("ALVideoDevice", IP, PORT)
  resolution = 2    # VGA
  colorSpace = 11   # RGB

  videoClient = camProxy.subscribe("python_client", resolution, colorSpace, 5)

  t0 = time.time()

  # Get a camera image.
  # image[6] contains the image data passed as an array of ASCII chars.
  naoImage = camProxy.getImageRemote(videoClient)

  t1 = time.time()

  # Time the image transfer.
  print "acquisition delay ", t1 - t0


  # Now we work with the image returned and save it as a PNG  using ImageDraw
  # package.

  # Get the image size and pixel array.
  imageWidth = naoImage[0]
  imageHeight = naoImage[1]
  array = naoImage[6]

  # Create a PIL Image from our pixel array.
  im = Image.fromstring("RGB", (imageWidth, imageHeight), array)

  # Save the image."camImage.png", "PNG")

if __name__ == '__main__':
  IP = "nao.local"  # Replace here with your NaoQi's IP address.
  PORT = 9559

  # Read IP address from first argument if any.
  if len(sys.argv) > 1:
    IP = sys.argv[1]

  naoImage = showNaoImage(IP, PORT)

Visualize live NAO images using PyQt

Visualize live NAO images using PyQt.

# This is a tiny example that shows how to show live images from Nao using PyQt.
# You must have python-qt4 installed on your system.

import sys

from PyQt4.QtGui import QWidget, QImage, QApplication, QPainter
from naoqi import ALProxy

# To get the constants relative to the video.
import vision_definitions

class ImageWidget(QWidget):
    Tiny widget to display camera images from Naoqi.
    def __init__(self, IP, PORT, CameraID, parent=None):
        QWidget.__init__(self, parent)
        self._image = QImage()

        self._imgWidth = 320
        self._imgHeight = 240
        self._cameraID = CameraID
        self.resize(self._imgWidth, self._imgHeight)

        # Proxy to ALVideoDevice.
        self._videoProxy = None

        # Our video module name.
        self._imgClient = ""

        # This will contain this alImage we get from Nao.
        self._alImage = None

        self._registerImageClient(IP, PORT)

        # Trigget 'timerEvent' every 100 ms.

    def _registerImageClient(self, IP, PORT):
        Register our video module to the robot.
        self._videoProxy = ALProxy("ALVideoDevice", IP, PORT)
        resolution = vision_definitions.kQVGA  # 320 * 240
        colorSpace = vision_definitions.kRGBColorSpace
        self._imgClient = self._videoProxy.subscribe("_client", resolution, colorSpace, 5)

        # Select camera.

    def _unregisterImageClient(self):
        Unregister our naoqi video module.
        if self._imgClient != "":

    def paintEvent(self, event):
        Draw the QImage on screen.
        painter = QPainter(self)
        painter.drawImage(painter.viewport(), self._image)

    def _updateImage(self):
        Retrieve a new image from Nao.
        self._alImage = self._videoProxy.getImageRemote(self._imgClient)
        self._image = QImage(self._alImage[6],           # Pixel array.
                             self._alImage[0],           # Width.
                             self._alImage[1],           # Height.

    def timerEvent(self, event):
        Called periodically. Retrieve a nao image, and update the widget.

    def __del__(self):
        When the widget is deleted, we unregister our naoqi video module.

if __name__ == '__main__':
    IP = "nao.local"  # Replace here with your NaoQi's IP address.
    PORT = 9559
    CameraID = 0

    # Read IP address from first argument if any.
    if len(sys.argv) > 1:
        IP = sys.argv[1]

    # Read CameraID from second argument if any.
    if len(sys.argv) > 2:
        CameraID = int(sys.argv[2])

    app = QApplication(sys.argv)
    myWidget = ImageWidget(IP, PORT, CameraID)