# Einführung
---

## Beschreibung des Projektes

Dieses Projekt beschäftigt sich mit Verfahren der Objektverfolgung bzw. Mustererkennung (oder Merkmalsextraktion) in Videodaten. Unter Verwendung der OpenCV Bibliothek eine Gesichtserkennung im Videostream umzusetzen und die Person mittels Mustererkennung (Training auf ausgewählte Profilbilder) zu identifizieren. Dokumentierte Beispiel-Code für die Teilbereiche ist vorhanden. Schließlich soll erhoben werden, inwiefern das umgesetzte Verfahren auf einem Roboter (NAO) eingespielt werden kann.

[[_TOC_]]

# Projektumfeld (Technologien)
---
Programmiersprache: Python (Anaconda Environment)
Libraries: OpenCV, sklearn, dlib


# Projektsetup

Um das Projekt auf einer lokalen Maschine laufen zu lassen, braucht man cmake und einen c-compiler da eine der verwendeten Libraries aus nativem C Code besteht.

Anaconda und Python 3.7 werden ebenfalls benötigt.

Um die Requierements zu installieren:

pip install -r requirements.txt (Im Projektverzeichnis)

# Genereler Aufbau des Programms

Das Projekt besteht aus folgenden Files:

- FaceTools.py
- FaceLearner.py
- SmoothFaceClassifier.py

# Benutzung des Programms:

## Im Projektverzeichnis einen Ordner "pictures" anlegen, und darin in Unterordnern, die die Namen einer jeweiligen Person haben,
Trainingsbilder der Person hinzufügen. Der Name der Bilder selbst ist egal, es ist nur wichtig, dass jeweils nur ein Gesicht auf den
Bildern zu erkennen ist (Da Sonst verschiedene Gesichter dem selben Namen zugeordnet werden)

## Danach FaceLearner.py ausführen, welcher alle Bilder scannt und das Modell trainiert. Das fertige Modell wird danach unter dem
Namen "model.txt" im Projektverzeichnis gespeichert.

## Zum klassifizieren muss nun einfach SmoothFaceClassifier.py gestartet werden, welches auf die Webcam zugreift und Gesichter
in Echtzeit klassifiziert. Das Skript ladet beim Start automatisch das vorher erstellte Modell.

# Funktionsweise der Klassifizierung

## Step 1 - Gesichter in Bildern finden

Im ersten Schritt werden Gesichter in Bildern gefunden und einem Namen zugeordnet.
Dazu wird das Bild/Video zuerst in Grautöne abgestuft. Diese Methode analysiert einzelne Pixel. Zuerst wird verglichen wie dunkel der momentane Pixel im Vergleich zu seinen Nachbarn ist, woraus ein Vektor generiert wird der die Richtung abbildet in welche das Bild dunkler wird. Aus diesen Informationen wird ein sogenanntes "HOG Face" erstellt. Dieses wird mit anderen HOG Pattern verglichen, woraus die Position und eine grobe Boundry Box resultieren.
Dafür wurde eine bereits fertige Methode der Klasse "dlib" verwendet.

## Step 2 - Markante Punkte filtern und Perspektive Berücksichtigen

Im zweiten Schritt werden markante Punkte im gefundenen Gesicht gesucht. Diese Punkte werden auch "Landmarks" genannt und sind zum Beispiel: Die Augen, die Nase, der Munde und die Outlines des Gesichts.
Sind diese markanten punkte gefunden, wird das Bild so transformiert, dass sich die Augen immer in der Mitte von einem Ausschnitt (auch "FaceChip" genannt) befinden. Dies erleichtert es dem Netzwerk im nächsten Schritt, die Features korrekt zuzuordnen (Normalisierung).


[Code Step 1 und 2]

def getFaceChips(image, showShape):

    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    rects = detector(gray, 2) #detects face locations
    chips = []
    boxes = []
    shapes = []
    for rect in rects:
        boxes.append(rect_to_bb(rect))
        shape = facepred(image, rect) #generates face landmarks

        shapenp = face_utils.shape_to_np(shape)
        shapes.append(shapenp)
        chips.append(dlib.get_face_chip(image, shape)) #rotates and scales image based on eye position
        if(showShape):
            for (x, y) in shapenp:
                cv2.circle(image, (x, y), 1, (0, 255, 0), -1)

    if(showShape):
        cv2.imshow("annotated",image)
        cv2.waitKey(1)

    return chips,boxes


## Step 3 - Erstellung des Feature-Vektors
Hierbei wird aus einem FaceChip ein 128 - dimensionaler Vektor generiert, welcher Merkmale des Gesichtes widerspiegelt.
Dieser Vektor wird mittels eines vortrainierten Netzes, welches durch eine unsupervised Learning Methode erstellt wurde, generiert.
Diese Methode wurde zum ersten Mal im Jahr 2015 in einem Paper namens "FaceNet" vorgestellt. Unser Programm bietet mit Hilfe der Library "Hypertools" die Möglichkeit, diese 128 dimensionalen Vektoren auf 3 Dimensionen "herunter zu rechnen" und zu visualisieren, wodurch eventuelle Ähnlichkeiten zwischen Personen erkannt werden können.

[Code Step 3]

def getFaceDescriptor(facechip):
    face_descriptor = facerec.compute_face_descriptor(facechip)
    return [np.array(face_descriptor)]

descriptions,tags = getImagesDescriptions("pictures")
hyp.plot(descriptions, '.', hue=tags, legend=list(set(tags)))


## Step 4 - kNN trainieren (in unserem Fall)

Mit den genereierten 128d Vektoren wird ein k-Nearest-Neighbour Algorithmus trainiert. Dies ist der einzige Schritt bei dem sich die Klassifizierung und das Training unterscheiden.
Wir haben als Machine Learning verfahren kNN gewählt, da neue Einträge in O(1) gelernt werden können und so die Zeit zum Trainieren drastisch reduziert wird, was die flexibilität des Programmes erhöht.
Um beim klassifizieren durch die Berechnungen das Kamerabild nicht zu verzögern, wurde eine Multiprocessing - Lösung implementiert, bei welcher in zwei Prozessen unabhängig voneinander das Kamerabild angezeigt und die Gesichter erkannt und klassifiziert werden.

[Code Step 4]

def camStreamer(imageQueue,boxesQueue):
    try:
        camera = Camera()
        camera.start_capture()
        boxes = None
        chips = None
        tags = None
        while True:
            frame = camera.current_frame.read()
            frame = imutils.resize(frame, width=300)

            writeNormQueue(frame.copy(),imageQueue)

            if(boxesQueue.full()):
                boxes,chips,tags = boxesQueue.get()

            if(boxes is not None):
                for  box,tag,chip in zip(boxes, tags,chips):
                    (x, y, w, h) = box
                    cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255))
                    cv2.putText(frame, str(tag), (x , y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255))

            cv2.imshow("frame",frame)
            cv2.waitKey(10)
    except:
        print ("FATAL: camStreamer exited while multiprocessing")
        traceback.print_exc()

def faceLabeler(imageQueue,boxesQueue):
    try:
        print("faceLabeler started!")
        model = load("model.txt")
        while True:
            #if (imageQueue.full()):
                image = imageQueue.get()
                chips, boxes = ft.getFaceChips(image, False)
                tags = []
                for chip, box in zip(chips, boxes):
                    tag = ft.classifyChip(model, chip)
                    tags.append(tag)
                    #cv2.imshow("chip",image)
                writeNormQueue([boxes,chips,tags],boxesQueue)
                cv2.waitKey(1)


    except:
        print ("FATAL: faceLabeler exited while multiprocessing")
        traceback.print_exc()


def writeNormQueue(var,queue):
    if (queue.full()):
        try:
            queue.get_nowait()
        except:
            print("anormaly with emptying queue!")

    queue.put(var)

if __name__ == '__main__':
    imageQueue = mp.Queue(1)
    boxesQueue = mp.Queue(1)

    streamP = mp.Process(target=camStreamer, args=(imageQueue,boxesQueue,))
    labelP = mp.Process(target=faceLabeler,args=(imageQueue,boxesQueue,))

    streamP.start()
    labelP.start()