Projektlabor Robotik MINTgrün

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
======= Gestensteuerung =======
\\

===== Themenbeschreibung/Einleitung =====
Unsere Idee ist es ein Programm zu schreiben mit dem Ziel Echtzeit-Bilder aus einen Computer Webcam aufzunehmen, die Gesten zu erkennen und daraufhin bestimmte Programme bzw. Applikationen auf den Rechner auszuführen.  
Dabei ist besonders zu achten, dass unser Programm 3~5 von uns bestimmten Gesten erkennt, diese richtig auf ihren Aufgaben zuordnen und die vorbestimmten Aufgaben ausführen können.Wir haben unser Projekt in drei großen Themenbereichen eingeteilt und zwar in die Bildverarbeitung, die Bilderkennung und die Aufgabenausführung.\\ 


===== Umsetzung/Funktionalität =====
===Überblick===
Ich habe mich hauptsächlich mit der Bildverarbeitung beschäftigt und versucht Bilder aus der Webcam für die Bilderkennung in den späteren Phasen vorzubereiten. Dabei habe ich hauptsächlich die OpenCV library(eine Programmbibliothek mit Algorithmen für die Bildverarbeitung und Computer Vision) benutzt, um Bildrauschen und andere Störfaktoren im Bild zu eliminieren. {{ref>Ablauf}} \\

<figure Ablauf>
{{ :projektesose20:gestensteuerung1:ablauf.png |}}
<caption>Ablauf</caption>
</figure>

----

===Arbeitsabschnitte===
Die Vorbereitung auf die Bildverarbeitung wird in sechs verschiedene Schritten aufgeteilt.
  - Das Video wird vom Webcam eingelesen
  - Das Video wird in Greyscale konvertiert
  - Anwendung der Gauß-Filter 
  - Schwellenwertverfahren (Thresholding)
  - Dilation und Erosion
  - Konturen erkennen
Das Video wird zuerst vom Webcam eingelesen (Abb.2 links) und in [[https://en.wikipedia.org/wiki/Grayscale|Greyscale]] konvertiert, denn mit Grauwerten kann man Bildelemente w.z.B. die Kanten und Lichtverhältnisse von bestimmten Objekten erfassen, ohne die Farben einzubeziehen, was sonst den Prozess verkompliziert.{{ref>Abb01}}  
<figure Abb01>
{{:projektesose20:gestensteuerung1:hand01.jpg?300|}}
{{:projektesose20:gestensteuerung1:hand02.jpg?300|}}
<caption>Links: Normales Bild aus der Webcam, Rechts: Bild nach greyscale konvertiert</caption>
</figure>
\\
Mit einem [[https://de.wikipedia.org/wiki/Gau%C3%9F-Filter|Gauß-Filter]] wird Bildrauschen reduziert, indem kleinere Strukturen verloren gehen und gröbere Strukturen erhalten bleiben. {{ref>Abb02}}  
<figure Abb02>
{{:projektesose20:gestensteuerung1:hand03.jpg?300|}}\\
<caption>Nach Anwendung von Gauß-Filter</caption>
</figure>
\\
Hier haben wir ein [[https://de.wikipedia.org/wiki/Schwellenwertverfahren|Schwellenwert]] festgelegt (hier im Beispiel 0.3). Alle Pixeln über den Schwellenwert nehmen die Farbwerte von Weiß an und alle unter den Schwellenwert nehmen die Werte von Schwarz an, somit erkennen wir ein klarer Umriss, der uns bzw. den Rechner erleichtert das Objekt wahrzunehmen. {{ref>Abb03}}  
<figure Abb03>
{{:projektesose20:gestensteuerung1:hand04.jpg?300|}}\\
<caption>Nach Anwendung von Schwellenwertverfahren</caption>
</figure>
\\
Durch die Anwendung vom Schwellenwert entstehen einzelne Stücke von Umrissen, deswegen wird eine [[https://de.wikipedia.org/wiki/Dilatation_(Bildverarbeitung)|Dilation-Funktion]] angewendet, um die weißen Pixeln zu erweitern bzw. die einzelnen Stücken von Umrissen zu verbinden. Auf einem Grauwertbild wirkt die Dilatation mit einem strukturierenden Element ähnlich einem Maximum-Filter. Helle Strukturen werden vergrößert, dunklere verkleinert.\\
Die [[https://de.wikipedia.org/wiki/Erosion_(Bildverarbeitung)|Erosion-Funktion]] ist das Gegenteil von dilation. Auf einem Grauwertbild funktioniert die Erosion mit einem strukturierenden Element ähnlich einem Minimum-Filter. Dunkle Strukturen werden vergrößert, hellere verkleinert. {{ref>Abb04}}  
<figure Abb04>
{{:projektesose20:gestensteuerung1:hand_05.jpg?300|}}
{{:projektesose20:gestensteuerung1:hand05.jpg?300|}}\\
<caption>Nach Anwendung von dilate(links) und erode(rechts)</caption>
</figure>
\\
Im letzten Schritt werden die Konturen mit Hilfe des [[https://de.wikipedia.org/wiki/Canny-Algorithmus|"Canny edge detector"-Algorithmus]] berechnet. {{ref>Abb05}}  
<figure Abb05>
{{:projektesose20:gestensteuerung1:hand06.jpg?300|}}\\
<caption>Nach Anwendung von edgedetection</caption>
</figure>
\\
Unser Ergebnis muss noch optimiert werden, da Lichtverhältnisse und Hintergrund immer noch einen großen Einfluss hat auf die Erkennung von Konturen. Die oben dargestellten Beispiele wurden in einen dunklen Raum mit einen einzigen Lichtquelle, die direkt auf die Handfläche strahlte, aufgezeichnet.\\

===Code===
Im Processing gibt es eine "Video"-library, mit der man auf die Webcam zugreifen kann. Für das Projekt habe ich zusätzlich die OpenCV library (eine Programmbibliothek mit Algorithmen für die Bildverarbeitung und Computer Vision) benutzt, um Bildrauschen und andere Störfaktoren im Bild zu eliminieren. 
<code java>
import processing.video.*;
import gab.opencv.*;
</code>

<code Java>
Capture video;
PImage prev;
OpenCV opencv;
float threshold = 25;
</code>

Hier wählen wir uns eine Kamera aus, mit der das Video aufgenommen wird und mit //video.start();// beginnen wir mit der Aufnahme. Ein Bild(//prev//) wird aufgenommen, das später als Hintergrund fungiert.
<code Java>
void setup () {
  size(640, 480);
  String[] cameras = Capture.list();
  printArray(cameras);
  video = new Capture(this, cameras[0]);
  opencv = new OpenCV(this, width, height);
  video.start();
  prev = createImage(640, 480, RGB);         //create a blank image
}
</code>

Zusätzlich werden zwei Bilder (//curr// und //result//) erschaffen. //curr// steht für die jetzigen (current) Live-Aufnahme. Mit //.filter(GRAY)// werden die Pixeln in beide Bilder(//curr// und //prev//)zu Grayscale (Grauwerte) konvergiert. Um die veränderte Werte wiederzugeben wird //.loadPixels()// verwendet.
<code Java>
void draw() {
  PImage result =  createImage(640, 480, RGB);
  PImage curr = createImage(640, 480, RGB);
  curr.copy(video, 0, 0, video.width, video.height, 0, 0, prev.width, prev.height);  
  prev.filter(GRAY);
  curr.filter(GRAY);

  result.loadPixels();
  prev.loadPixels();
  curr.loadPixels();
</code>

Durch einen for-loop werden die Differenzen der einzelne Pixel zwischen den Hintergrund (//prev//) und die Live-Aufnahme (//curr//) berechnet. Ist der Unterschied größer ist als der festgelegte //threshold//(Schwellenwert), so werden sie in Bild //result// eingesetzt und ausgelesen.
<code Java>
  for (int i = 0; i < prev.pixels.length; i++) {
    int difference = curr.pixels[i] - prev.pixels[i];
    if (difference > 25) {
      result.pixels[i] = difference;
    }
  }
</code>

In diesem Abschnitt benutzen wir diverse Filter, die Processing zur Verfügung stellt, um zuerst Bildrauschen zu entfernen. Danach wird es in Binärbild verändert und zum Schluss durch Erosion weiterverarbeitet. Mit der //findCannyedges//-Funktion aus OpenCV werden die Kanten berechnet und gezeichnet.
<code Java>
  result.updatePixels();
  result.filter(BLUR, 3);
  result.filter(THRESHOLD, 0.3);
  result.filter(ERODE);
  image(result, 0, 0);
  opencv.loadImage(result);
  opencv.findCannyEdges(20, 75); // Kantendetektion
  PImage edges = opencv.getSnapshot();
  image(edges, 0, 0);
}
</code>

Mit einen Mausklick werden die Pixelwerte in dem Moment gespeichert und als Hintergrund (//prev//) festgelegt. 
<code Java>
//press mouse to "set the background"
void mousePressed() {
  prev.copy(video, 0, 0, video.width, video.height, 0, 0, prev.width, prev.height);     //copy the whole video into previous image(blank image we created) 
  prev.updatePixels();
}
</code>

Hier ist der Befehl, um die Bilder aus der Kamera auf dem Bildschirm wiederzugeben. 
<code Java>
//read image from Camera
void captureEvent(Capture video) {
  video.read();
}
</code>
===Fortsetzung===
Unserer Ursprünglicher Ansatz eine neuronale Netzwerk zu trainieren, um die Gesten zu erkennen war leider nicht optimal für die Aufgabe, deswegen haben wir uns für eine andere Methode entschieden, wo wir für die Erkennung von Gesten die Berechnung dessen Konvexen Hülle anwenden.\\
Eine konvexe Hülle einer Mengen von Punkten ist das kleinste konvexe Polynom, welches alle Punkte enthält.Angenommen, die Punkte der Menge sind Nägel, die aus einem Brett hervor stehen, dann kann man mit einem Gummieband um alle Nägeln spannen und der kleinstmöglicher Umfang entspricht der Umrisslinie der konvexe Hülle 
Eine der Methode um die KH zu finden ist der Graham Scan. Dieser Algorithmus findet als aller erstes einen Punkt, dass garantiert auf der konvexen Hülle liegt z.B. der Punkt mit den kleinsten y-Koordinate und größte x-Koordinate.\\
Die Punkte werden dann nach dem Winkel, den sie mit dem Anfangspunkt machen sortiert. Wenn wir nun den Punkten gegen dem Uhrzeigersinn entlang gehen, können wir bei jedem Tripel entscheiden, ob der mittlere Punkt des Tripels einen Knick nach innen oder nach außen repräsentiert. Falls ein Knick nach innen zeigt, kann der mittlere Punkt nicht Teil der komplexen Hülle sein und wird ignoriert.
\\
Wir betrachten die Kante zwischen den Linien und finden mit Kreuzprodukt heraus, ob es sich gegen die Uhrzeiger dreht, also nach außen. Dieser Prozess laufen wir durch alle Punkte. 
\\
Bereiche innerhalb des konvex Hulls, die aber nicht zur Handfläche gehören, werden convexity defects genannt. Durch diese können wir genau die Positionen der Fingerspitzen erkennen. Wir können dann den Winkel zwischen zwei convexity defects berechnen und je nach Winkelgröße bestimmen, ob ein Finger gestreckt wird oder nicht. \\
[[https://soi.ch/wiki/convex-hull/|Link zu konvexe Hülle]]

===== Ergebnis/Diskussion =====
Durch Schwierigkeiten sowohl in der Teamarbeit als auch in der Umstellung unseres Lösungsansatzes kamen wir letztendlich nicht zum eigentlichen Ziel. Ich habe die Schritte bis zur Kantendetektion erreicht und die notwendigen Vorgänge zur Weiterentwicklung des Projekts herausgearbeitet. Leider war es mir nicht möglich am Ende diese noch in Code umzusetzen. \\
Es besteht noch Verbesserungsmöglichkeiten wie z.B. die Optimierung der Bildstabilität. Lichtverhältnisse und Hintergrund spielen weiterhin eine entscheidende Rolle, welche einen großen Einfluss hat auf die Erkennung von Konturen. Da unser Projekt leider nicht fertig geworden ist, gibt es noch viel Raum für die Weiterentwicklung. 
----
[[Quellenverzeichnis]]\\
\\
Processing-Code:\\
{{:projektesose20:gestensteuerung1:gesture_code.pde.zip|}}
Projektlabor Robotik MINTgrün

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Seiten-Werkzeuge
