This section contains examples showing how to get images from NAO’s cameras, and how to visualize them with PIL or PyQt.
This example gets an image on the robot.
# -*- encoding: 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
import time
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.kQQVGA
colorSpace = vision_definitions.kYUVColorSpace
fps = 20
nameId = camProxy.subscribe("python_GVM", resolution, colorSpace, fps)
print 'getting images in remote'
for i in range(0, 20):
print "getting image " + str(i)
camProxy.getImageRemote(nameId)
time.sleep(0.05)
camProxy.unsubscribe(nameId)
Get one image from NAO, then display it using PIL.
# -*- encoding: UTF-8 -*-
# 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
camProxy.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]
# Create a PIL Image from our pixel array.
im = Image.fromstring("RGB", (imageWidth, imageHeight), array)
# Save the image.
im.save("camImage.png", "PNG")
im.show()
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.
# -*- encoding: UTF-8 -*-
#
# 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):
"""
Initialization.
"""
QWidget.__init__(self, parent)
self._image = QImage()
self.setWindowTitle('Nao')
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.
self.startTimer(100)
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.
self._videoProxy.setParam(vision_definitions.kCameraSelectID,
self._cameraID)
def _unregisterImageClient(self):
"""
Unregister our naoqi video module.
"""
if self._imgClient != "":
self._videoProxy.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._videoProxy.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__':
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)
myWidget.show()
sys.exit(app.exec_())