FaceReco

import socket

import qi
import time
import sys
import cv2
import numpy as np

from naoqi import ALModule, ALBroker


class FaceRecognition(ALModule):
    """
    Face recognition utility class
    """

    serverip = 'localhost'
    port = 8888

    # naoqi sessions
    face_recon = None
    tts = None
    memory = None
    subscriber = None
    video_service = None

    # search options
    scanning = False
    searched_person = None
    learn = False
    face_to_learn = None
    face_learend = False

    def __init__(self, name, session):
        ALModule.__init__(self, name)

        self.tts = session.service("ALTextToSpeech")
        self.face_recon = session.service("ALFaceDetection")
        self.video_service = session.service("ALVideoDevice")

        self.memory = session.service("ALMemory")
        self.subscriber = self.memory.subscriber("FaceDetected")
        self.subscriber.signal.connect(self.faceCallback)

    def learn_face(self, name):
        """Learns Face that is in the frame atm"""

        self.face_to_learn = name
        self.learn = True
        while not self.face_learend:
            time.sleep(0)

        self.face_to_learn = None
        self.learn = False

    def known_faces(self):
        """returns list of known faces"""
        return self.face_recon.getLearnedFacesList()

    def delete_faces(self):
        """Deletes all known faces"""
        self.face_recon.clearDatabase()

    def delete_face(self, name):
        """Deletes a learned face by name"""
        self.face_recon.forgetPerson(name)

    def find_face(self, name):
        """Finds a face that was previously learned"""
        self.searched_person = name
        self.scanning = True

        # todo: tell movement class to do search movement.
        # movement.search()

    def faceCallback(self, *_args):
        """Callback method for faceDetected"""
        if self.scanning:
            if _args[2] == self.searched_person:
                self.person_found()

        if self.learn:
            while not self.face_recon.learnFace(self.face_to_learn):
                time.sleep(1)
            self.tts.say('hello ', self.face_to_learn)

    def person_found(self):
        """activity started when searched person was found"""
        # todo: do stuff when person is found.

        # movement.moveToPerson()
        # reset search variables
        self.scanning = False
        self.searched_person = None

    def grayscale_img(self):
        """Takes a picture and returns it as greyscale image"""
        t0 = time.time()

        resolution = 2  # VGA
        colorSpace = 11  # RGB
        videoClient = self.video_service.subscribe("python_client", resolution, colorSpace, 5)
        # Time the image transfer.
        images = []
        for i in range(0, 50):
            naoImage = self.video_service.getImageRemote(videoClient)
            # Get the image size and pixel array.
            imageWidth = naoImage[0]
            imageHeight = naoImage[1]
            array = naoImage[6]
            image_string = str(bytearray(array))

            nparr = np.fromstring(image_string, np.uint8).reshape(imageHeight, imageWidth, 3)

            img_grey = cv2.cvtColor(nparr, cv2.COLOR_RGB2GRAY)
            images.append(img_grey)

        t1 = time.time()
        print('time used to aquire picture: '+str(t1-t0)+'s')
        self.video_service.unsubscribe(videoClient)

        return images

    # cv2.resize(img_grey, (256, 256))

    def send_image(self):
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        server_adress = (self.serverip, self.port)
        s.connect(server_adress)

        s.send(self.grayscale_img())


if __name__ == '__main__':
    connect_ip = '192.168.1.102'
    connection_url = connect_ip+':9559'

    myBroker = ALBroker("myBroker",
                        "0.0.0.0",  # listen to anyone
                        0,  # find a free port and use it
                        connect_ip,  # parent broker IP
                        9559)  # parent broker port
    app = qi.Application(["--qi-url=" + connection_url])  # Connection to robot
    app.start()
    session = app.session
    global FaceRec

    FaceRec = FaceRecognition('FaceRecognition', session)
    # img = FaceRec.grayscale_img()
    FaceRec.learn_face('Pascal')

    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        print
        print "Interrupted by user, shutting down"
        myBroker.shutdown()
        sys.exit(0)