# SoftBank Robotics documentation What's new in NAOqi 2.8?

# Retrieving images

<< return to Python examples

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.

`videoInput_getImage.py`

    #! /usr/bin/env python
    # -*- encoding: UTF-8 -*-

    """Example: Shows how images can be accessed through ALVideoDevice"""

    import qi
    import argparse
    import sys
    import time
    import vision_definitions

    def main(session):
        """
        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.
        """
        # Get the service ALVideoDevice.

        video_service = session.service("ALVideoDevice")

        # Register a Generic Video Module
        resolution = vision_definitions.kQQVGA
        colorSpace = vision_definitions.kYUVColorSpace
        fps = 20

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

        print 'getting images in remote'
        for i in range(0, 20):
            print "getting image " + str(i)
            video_service.getImageRemote(nameId)
            time.sleep(0.05)

        video_service.unsubscribe(nameId)

    if __name__ == "__main__":
        parser = argparse.ArgumentParser()
        parser.add_argument("--ip", type=str, default="127.0.0.1",
                            help="Robot IP address. On robot or Local Naoqi: use '127.0.0.1'.")
        parser.add_argument("--port", type=int, default=9559,
                            help="Naoqi port number")

        args = parser.parse_args()
        session = qi.Session()
        try:
            session.connect("tcp://" + args.ip + ":" + str(args.port))
        except RuntimeError:
            print ("Can't connect to Naoqi at ip \"" + args.ip + "\" on port " + str(args.port) +".\n"
                   "Please check your script arguments. Run with -h option for help.")
            sys.exit(1)
        main(session)

## Visualize an image using PIL

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

`vision_getandsaveimage.py`

    #! /usr/bin/env python
    # -*- encoding: UTF-8 -*-

    """Example: Get an image. Display it and save it using PIL."""

    import qi
    import argparse
    import sys
    import time
    import Image

    def main(session):
        """
        First get an image, then show it on the screen with PIL.
        """
        # Get the service ALVideoDevice.

        video_service = session.service("ALVideoDevice")
        resolution = 2    # VGA
        colorSpace = 11   # RGB

        videoClient = video_service.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 = video_service.getImageRemote(videoClient)

        t1 = time.time()

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

        video_service.unsubscribe(videoClient)

        # 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]
        image_string = str(bytearray(array))

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

        # Save the image.
        im.save("camImage.png", "PNG")

        im.show()

    if __name__ == "__main__":
        parser = argparse.ArgumentParser()
        parser.add_argument("--ip", type=str, default="127.0.0.1",
                            help="Robot IP address. On robot or Local Naoqi: use '127.0.0.1'.")
        parser.add_argument("--port", type=int, default=9559,
                            help="Naoqi port number")

        args = parser.parse_args()
        session = qi.Session()
        try:
            session.connect("tcp://" + args.ip + ":" + str(args.port))
        except RuntimeError:
            print ("Can't connect to Naoqi at ip \"" + args.ip + "\" on port " + str(args.port) +".\n"
                   "Please check your script arguments. Run with -h option for help.")
            sys.exit(1)
        main(session)

## Visualize live NAO images using PyQt

Visualize live NAO images using PyQt.

`vision_showimages.py`

    #! /usr/bin/env python
    # -*- encoding: UTF-8 -*-

    """Example: Shows how to show live images from Nao using PyQt"""

    import qi
    import argparse
    import sys
    from PyQt4.QtGui import QWidget, QImage, QApplication, QPainter
    import vision_definitions

    def main(session, robot_ip, port):
        """
        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.
        """
        CameraID = 0

        # Get the service ALVideoDevice.

        video_service = session.service("ALVideoDevice")
        app = QApplication([robot_ip, port])
        myWidget = ImageWidget(video_service, CameraID)
        myWidget.show()
        sys.exit(app.exec_())

    class ImageWidget(QWidget):
        """
        Tiny widget to display camera images from Naoqi.
        """
        def __init__(self, video_service, CameraID, parent=None):
            """
            Initialization.
            """
            QWidget.__init__(self, parent)
            self.video_service = video_service
            self._image = QImage()
            self.setWindowTitle('Robot')

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

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

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

            self._registerImageClient()

            # Trigget 'timerEvent' every 100 ms.
            self.startTimer(100)

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

            # Select camera.
            self.video_service.setParam(vision_definitions.kCameraSelectID,
                                      self._cameraID)

        def _unregisterImageClient(self):
            """
            Unregister our naoqi video module.
            """
            if self._imgClient != "":
                self.video_service.unsubscribe(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.video_service.getImageRemote(self._imgClient)
            self._image = QImage(self._alImage[6],           # Pixel array.
                                 self._alImage[0],           # Width.
                                 self._alImage[1],           # Height.
                                 QImage.Format_RGB888)

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

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

    if __name__ == "__main__":
        parser = argparse.ArgumentParser()
        parser.add_argument("--ip", type=str, default="127.0.0.1",
                            help="Robot IP address. On robot or Local Naoqi: use '127.0.0.1'.")
        parser.add_argument("--port", type=int, default=9559,
                            help="Naoqi port number")

        args = parser.parse_args()
        session = qi.Session()
        try:
            session.connect("tcp://" + args.ip + ":" + str(args.port))
        except RuntimeError:
            print ("Can't connect to Naoqi at ip \"" + args.ip + "\" on port " + str(args.port) +".\n"
                   "Please check your script arguments. Run with -h option for help.")
            sys.exit(1)
        main(session, args.ip, args.port)

Glossary Site map Index Support Contact Legal Notices