Retrieving images¶
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.
#! /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.
#! /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.
#! /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)
